HPCC-23158 Fix more issues picked up by sanitize option

Signed-off-by: Gavin Halliday <gavin.halliday@lexisnexis.com>

common/deftype/deftype.cpp

@@ -1136,7 +1136,7 @@ IValue *CEnumeratedTypeInfo::castFrom(size32_t len, const char * text)
     if (len<baselen)
     {
         char *pad = (char *)temp.allocate(baselen);
-        memcpy(pad, text, len);
+        memcpy_iflen(pad, text, len);
         memset(pad+len, ' ', baselen-len);
         text = pad;
     }

common/deftype/defvalue.cpp

@@ -236,7 +236,7 @@ VarStringValue::VarStringValue(unsigned len, const char *v, ITypeInfo *_type) :
     else
     {
         char * temp = (char *)checked_malloc(typeLen+1, DEFVALUE_MALLOC_FAILED);
-        memcpy(temp, v, len);
+        memcpy_iflen(temp, v, len);
         temp[len] = 0;
         val.set(temp, typeLen);
         free(temp);
@@ -264,7 +264,7 @@ void VarStringValue::toMem(void *target)
             copyLen = typeLen - 1;
     
         memcpy(target, val.get(), copyLen);
-        memset((char *)target+copyLen, 0, (typeLen-copyLen));
+        memset_iflen((char *)target+copyLen, 0, (typeLen-copyLen));
     }
     else {
         memcpy(target, val.get(), copyLen + 1);

common/fileview2/fvtransform.cpp

@@ -252,7 +252,7 @@ void ViewFieldECLTransformer::transform(unsigned & lenTarget, char * & target, u
     unsigned size = rtlUtf8Size(len, data);
     lenTarget = len;
     target = (char *)rtlMalloc(size);
-    memcpy(target, data, size);
+    memcpy_iflen(target, data, size);
 }
 
 void ViewFieldECLTransformer::transform(unsigned & lenTarget, char * & target, unsigned lenSource, const char * source)

common/remote/hooks/git/gitfile.cpp

@@ -102,7 +102,7 @@ public:
             return 0;
         if (pos+len > buf.length())
             len = buf.length()-pos;
-        memcpy(data, buf.toByteArray()+pos, len);
+        memcpy_iflen(data, buf.toByteArray()+pos, len);
         return len;
     }
     virtual offset_t size()

common/thorhelper/thorcommon.ipp

@@ -614,7 +614,7 @@ public:
     virtual void put(size32_t len, const void * ptr)
     {
         assertex(pos+len <= maxSize);
-        memcpy(buffer+pos, ptr, len);
+        memcpy_iflen(buffer+pos, ptr, len);
         pos += len;
     }
     virtual size32_t beginNested(size32_t count)

common/thorhelper/thorsort.cpp

@@ -94,7 +94,7 @@ void tbbqsortstable(void ** rows, size_t n, const ICompare & compare, void ** te
     {
 #ifdef _USE_TBB
         void * * * rowsAsIndex = (void * * *)rows;
-        memcpy(temp, rows, n * sizeof(void*));
+        memcpy_iflen(temp, rows, n * sizeof(void*));
 
         for(unsigned i=0; i<n; ++i)
             rowsAsIndex[i] = temp+i;

common/thorhelper/thorxmlread.cpp

@@ -214,7 +214,7 @@ void XmlDatasetColumnProvider::getUtf8X(size32_t & len, char * & target, const c
     const char * value = row->queryProp(path);
     size32_t size = value ? (size32_t)strlen(value) : 0;
     target = (char *)malloc(size);
-    memcpy(target, value, size);
+    memcpy_iflen(target, value, size);
     len = rtlUtf8Length(size, target);
 }
 
@@ -453,7 +453,7 @@ void XmlSetColumnProvider::getStringX(size32_t & len, char * & target, const cha
     const char * value = row->queryProp(NULL);
     len = value ? (size32_t)strlen(value) : 0;
     target = (char *)malloc(len);
-    memcpy(target, value, len);
+    memcpy_iflen(target, value, len);
     //MORE: utf8->ascii?
 }
 
@@ -480,7 +480,7 @@ void XmlSetColumnProvider::getUtf8X(size32_t & len, char * & target, const char
     const char * value = row->queryProp(NULL);
     size32_t size = value ? (size32_t)strlen(value) : 0;
     target = (char *)malloc(size);
-    memcpy(target, value, size);
+    memcpy_iflen(target, value, size);
     len = rtlUtf8Length(size, value);
 }
 

roxie/roxiemem/roxierowbuff.cpp

@@ -186,7 +186,7 @@ bool DynamicRoxieOutputRowArray::ensure(rowidx_t requiredRows)
     {
         RoxieOutputRowArrayLock block(*this);
         oldRows = rows;
-        memcpy(newRows, oldRows+firstRow, (numRows - firstRow) * sizeof(void*));
+        memcpy_iflen(newRows, oldRows+firstRow, (numRows - firstRow) * sizeof(void*));
         numRows -= firstRow;
         commitRows -= firstRow;
         firstRow = 0;

rtl/eclrtl/rtlds.cpp

@@ -89,7 +89,7 @@ void RtlDatasetBuilder::getData(size32_t & len, void * & data)
     flushDataset();
     len = totalSize;
     data = malloc(totalSize);
-    memcpy(data, buffer, totalSize);
+    memcpy_iflen(data, buffer, totalSize);
 }
 
 
@@ -1032,7 +1032,7 @@ public:
     virtual void put(size32_t len, const void * ptr)
     {
         byte * data = builder.ensureCapacity(offset + len, "");
-        memcpy(data+offset, ptr, len);
+        memcpy_iflen(data+offset, ptr, len);
         offset += len;
     }
 
@@ -1738,7 +1738,7 @@ void rtlSetToSetX(bool & outIsAll, size32_t & outLen, void * & outData, bool inI
     outIsAll = inIsAll;
     outLen = inLen;
     outData = malloc(inLen);
-    memcpy(outData, inData, inLen);
+    memcpy_iflen(outData, inData, inLen);
 }
 
 
@@ -1754,8 +1754,8 @@ void rtlAppendSetX(bool & outIsAll, size32_t & outLen, void * & outData, bool le
     {
         outLen = leftLen+rightLen;
         outData = malloc(outLen);
-        memcpy(outData, leftData, leftLen);
-        memcpy((byte*)outData+leftLen, rightData, rightLen);
+        memcpy_iflen(outData, leftData, leftLen);
+        memcpy_iflen((byte*)outData+leftLen, rightData, rightLen);
     }
 }
 

rtl/eclrtl/rtlfield.cpp

@@ -1189,7 +1189,7 @@ size32_t RtlStringTypeInfo::buildString(ARowBuilder &builder, size32_t offset, c
         if (isEbcdic())
             rtlStrToEStr(size, (char *) dest+sizeof(size32_t), size, (char *)value);
         else
-            memcpy(dest+sizeof(size32_t), value, size);
+            memcpy_iflen(dest+sizeof(size32_t), value, size);
         offset += size+sizeof(size32_t);
     }
     else
@@ -1493,7 +1493,7 @@ size32_t RtlDataTypeInfo::buildString(ARowBuilder &builder, size32_t offset, con
         builder.ensureCapacity(offset+size+sizeof(size32_t), queryName(field));
         byte *dest = builder.getSelf()+offset;
         rtlWriteInt4(dest, size);
-        memcpy(dest+sizeof(size32_t), value, size);
+        memcpy_iflen(dest+sizeof(size32_t), value, size);
         offset += size+sizeof(size32_t);
     }
     else
@@ -1717,7 +1717,7 @@ size32_t RtlVarStringTypeInfo::buildString(ARowBuilder &builder, size32_t offset
         if (isEbcdic())
             rtlStrToEStr(size, (char *) dest, size, (char *)value);
         else
-            memcpy(dest, value, size);
+            memcpy_iflen(dest, value, size);
         dest[size] = '\0';
         offset += size+1;
     }
@@ -2374,7 +2374,7 @@ size32_t RtlUnicodeTypeInfo::build(ARowBuilder &builder, size32_t offset, const
         builder.ensureCapacity(offset+sizeInBytes+sizeof(size32_t), queryName(field));
         byte *dest = builder.getSelf()+offset;
         rtlWriteInt4(dest, sizeInChars);  // NOTE - in chars!
-        memcpy(dest+sizeof(size32_t), value, sizeInBytes);
+        memcpy_iflen(dest+sizeof(size32_t), value, sizeInBytes);
         offset += sizeInBytes+sizeof(size32_t);
     }
     else
@@ -2679,7 +2679,7 @@ size32_t RtlVarUnicodeTypeInfo::build(ARowBuilder &builder, size32_t offset, con
         size32_t sizeInBytes = (sizeInChars+1) * sizeof(UChar);
         builder.ensureCapacity(offset+sizeInBytes, queryName(field));
         UChar *dest = (UChar *) (builder.getSelf()+offset);
-        memcpy(dest, value, sizeInBytes - sizeof(UChar));
+        memcpy_iflen(dest, value, sizeInBytes - sizeof(UChar));
         dest[sizeInChars] = 0;
         offset += sizeInBytes;
     }
@@ -2705,7 +2705,7 @@ size32_t RtlVarUnicodeTypeInfo::buildUtf8(ARowBuilder &builder, size32_t offset,
         size32_t sizeInBytes = (usize+1) * sizeof(UChar);
         builder.ensureCapacity(offset+sizeInBytes, queryName(field));
         UChar *dest = (UChar *) (builder.getSelf()+offset);
-        memcpy(dest, uvalue.getustr(), sizeInBytes - sizeof(UChar));
+        memcpy_iflen(dest, uvalue.getustr(), sizeInBytes - sizeof(UChar));
         dest[usize] = 0;
         offset += sizeInBytes;
     }
@@ -2894,7 +2894,7 @@ size32_t RtlUtf8TypeInfo::buildUtf8(ARowBuilder &builder, size32_t offset, const
     builder.ensureCapacity(offset+sizeInBytes+sizeof(size32_t), queryName(field));
     byte *dest = builder.getSelf()+offset;
     rtlWriteSize32t(dest, sizeInChars);  // NOTE - in chars!
-    memcpy(dest+sizeof(size32_t), value, sizeInBytes);
+    memcpy_iflen(dest+sizeof(size32_t), value, sizeInBytes);
     return offset + sizeInBytes+sizeof(size32_t);
 }
 
@@ -2910,7 +2910,7 @@ size32_t RtlUtf8TypeInfo::buildString(ARowBuilder &builder, size32_t offset, con
     builder.ensureCapacity(offset+sizeInBytes+sizeof(size32_t), queryName(field));
     byte *dest = builder.getSelf()+offset;
     rtlWriteSize32t(dest, sizeInChars);  // NOTE - in chars!
-    memcpy((dest+sizeof(size32_t)), temp.getstr(), sizeInBytes);
+    memcpy_iflen((dest+sizeof(size32_t)), temp.getstr(), sizeInBytes);
     return offset + sizeInBytes+sizeof(size32_t);
 }
 
@@ -3035,7 +3035,7 @@ void RtlUtf8TypeInfo::setBound(void * buffer, const byte * value, size32_t subLe
         //Generally cannot work for variable length fields - since always possible to create a larger value
         //Default does not work for real types, or variable length signed integers
         assertex(fill == 0);
-        memset(dst, fill, minSize);
+        memset_iflen(dst, fill, minSize);
     }
 }
 

system/include/platform.h

@@ -541,9 +541,9 @@ typedef unsigned __int64 timestamp_type;
 #endif
 
 //Versions of memcpy etc which are safe to use with null parameters if the size is 0
-inline void memcpy_iflen(void * dest, const void * src, size_t n)   { if (likely(n)) memcpy(dest, src, n); }
-inline void memmove_iflen(void * dest, const void * src, size_t n)  { if (likely(n)) memmove(dest, src, n); }
-inline void memset_iflen(void * dest, int c, size_t n)              { if (likely(n)) memset(dest, c, n); }
-inline int memcmp_iflen(const void * l, const void * r, size_t n)   { return likely(n) ? memcmp(l, r, n) : 0; }
+inline void * memcpy_iflen(void * dest, const void * src, size_t n)   { return (likely(n)) ? memcpy(dest, src, n) : dest; }
+inline void * memmove_iflen(void * dest, const void * src, size_t n)  { return (likely(n)) ? memmove(dest, src, n) : dest; }
+inline void * memset_iflen(void * dest, int c, size_t n)              { return (likely(n)) ? memset(dest, c, n) : dest; }
+inline int memcmp_iflen(const void * l, const void * r, size_t n)     { return likely(n) ? memcmp(l, r, n) : 0; }
 
 #endif

system/jlib/jbuff.cpp

@@ -412,7 +412,7 @@ void *MemoryBuffer::detach()
         ret = buffer;
     }
     else {
-        ret = memcpy(checked_malloc(curLen,-3), buffer, curLen);
+        ret = memcpy_iflen(checked_malloc(curLen,-3), buffer, curLen);
     }
     init();
     return ret;
@@ -605,42 +605,54 @@ MemoryBuffer & MemoryBuffer::appendPacked(unsigned __int64 value)
 MemoryBuffer & MemoryBuffer::append(const MemoryBuffer & value)
 {
     size32_t SourceLen = value.length();
-    unsigned newLen = checkMemoryBufferOverflow(curLen, SourceLen);
-    _realloc(newLen);
-    memcpy(buffer + curLen, value.toByteArray(), SourceLen);
-    curLen += SourceLen;
+    if (likely(SourceLen))
+    {
+        unsigned newLen = checkMemoryBufferOverflow(curLen, SourceLen);
+        _realloc(newLen);
+        memcpy(buffer + curLen, value.toByteArray(), SourceLen);
+        curLen += SourceLen;
+    }
     return *this;
 }
 
 MemoryBuffer & MemoryBuffer::appendBytes(unsigned char value, unsigned count)
 {
-    unsigned newLen = checkMemoryBufferOverflow(curLen, count);
-    _realloc(newLen);
-    memset(buffer+curLen, value, count);
-    curLen+=count;
+    if (likely(count))
+    {
+        unsigned newLen = checkMemoryBufferOverflow(curLen, count);
+        _realloc(newLen);
+        memset(buffer+curLen, value, count);
+        curLen+=count;
+    }
     return *this;
 }
 
 MemoryBuffer & MemoryBuffer::appendEndian(size32_t len, const void * value)
 {
-    unsigned newLen = checkMemoryBufferOverflow(curLen, len);
-    _realloc(newLen);
-    
-    if (swapEndian)
-        _cpyrevn(buffer + curLen, value, len);
-    else
-        memcpy(buffer + curLen, value, len);
-    
-    curLen += len;
+    if (likely(len))
+    {
+        unsigned newLen = checkMemoryBufferOverflow(curLen, len);
+        _realloc(newLen);
+
+        if (swapEndian)
+            _cpyrevn(buffer + curLen, value, len);
+        else
+            memcpy(buffer + curLen, value, len);
+
+        curLen += len;
+    }
     return *this;
 }
 
 MemoryBuffer & MemoryBuffer::appendSwap(size32_t len, const void * value)
 {
-    unsigned newLen = checkMemoryBufferOverflow(curLen, len);
-    _realloc(newLen);
-    _cpyrevn(buffer + curLen, value, len);
-    curLen += len;
+    if (likely(len))
+    {
+        unsigned newLen = checkMemoryBufferOverflow(curLen, len);
+        _realloc(newLen);
+        _cpyrevn(buffer + curLen, value, len);
+        curLen += len;
+    }
     return *this;
 }
 
@@ -721,9 +733,12 @@ MemoryBuffer & MemoryBuffer::read(const char * &value)
 
 MemoryBuffer & MemoryBuffer::read(size32_t len, void * value)
 {
-    CHECKREADPOS(len);
-    memcpy(value, buffer + readPos, len);
-    readPos += len;
+    if (likely(len))
+    {
+        CHECKREADPOS(len);
+        memcpy(value, buffer + readPos, len);
+        readPos += len;
+    }
     return *this;
 }
 
@@ -827,7 +842,7 @@ MemoryBuffer & MemoryBuffer::skip(unsigned len)
 void MemoryBuffer::writeDirect(size32_t pos,size32_t len,const void *buf)
 {
     assertex(pos+len<=curLen); // does not extend
-    memcpy(buffer+pos,buf,len);
+    memcpy_iflen(buffer+pos,buf,len);
 }
 
 void MemoryBuffer::writeEndianDirect(size32_t pos,size32_t len,const void *buf)
@@ -836,7 +851,7 @@ void MemoryBuffer::writeEndianDirect(size32_t pos,size32_t len,const void *buf)
     if (swapEndian)
         _cpyrevn(buffer+pos,buf,len);
     else
-        memcpy(buffer+pos,buf,len);
+        memcpy_iflen(buffer+pos,buf,len);
 }
 
 
@@ -846,7 +861,7 @@ MemoryBuffer & MemoryBuffer::readEndian(size32_t len, void * value)
     if (swapEndian)
         _cpyrevn(value, buffer + readPos, len);
     else
-        memcpy(value, buffer + readPos, len);
+        memcpy_iflen(value, buffer + readPos, len);
     
     readPos += len;
     return *this;
@@ -911,7 +926,7 @@ MemoryBuffer & MemoryBuffer::reset(size32_t pos)
 #if 0
 void MemoryBuffer::getBytes(int srcBegin, int srcEnd, char * target)
 {
-    memcpy(target, buffer + srcBegin, srcEnd - srcBegin);
+    memcpy_iflen(target, buffer + srcBegin, srcEnd - srcBegin);
 }
 
 MemoryBuffer & MemoryBuffer::remove(unsigned start, unsigned len)

system/jlib/jstring.cpp

@@ -158,7 +158,7 @@ void StringBuffer::_realloc(size_t newLen)
             throw MakeStringException(MSGAUD_operator, -1, "StringBuffer::_realloc: Failed to realloc = %zu, oldMax = %zu", newMax, maxLen);
         }
         if (useInternal())
-            memcpy(newStr, internalBuffer, curLen);
+            memcpy_iflen(newStr, internalBuffer, curLen);
         buffer = newStr;
         maxLen = newMax;
     }
@@ -172,7 +172,7 @@ char * StringBuffer::detach()
     if (buffer == internalBuffer)
     {
         result = (char *)malloc(curLen+1);
-        memcpy(result, buffer, curLen);
+        memcpy_iflen(result, buffer, curLen);
     }
     else
     {
@@ -205,26 +205,32 @@ StringBuffer & StringBuffer::append(unsigned char value)
 
 StringBuffer & StringBuffer::append(const char * value)
 {
-    if (value)
+    if (likely(value))
     {
         size_t SourceLen = strlen(value);
         
-        ensureCapacity(SourceLen);
-        memcpy(buffer + curLen, value, SourceLen);
-        curLen += SourceLen;
+        if (likely(SourceLen))
+        {
+            ensureCapacity(SourceLen);
+            memcpy(buffer + curLen, value, SourceLen);
+            curLen += SourceLen;
+        }
     }
     return *this;
 }
 
 StringBuffer & StringBuffer::append(size_t len, const char * value)
 {
-    if (len)
+    if (likely(len))
     {
         unsigned truncLen = (unsigned)len;
         assertex(truncLen == len); // MORE: StringBuffer should use size_t throughout
-        ensureCapacity(truncLen);
-        memcpy(buffer + curLen, value, truncLen);
-        curLen += truncLen;
+        if (likely(truncLen))
+        {
+            ensureCapacity(truncLen);
+            memcpy(buffer + curLen, value, truncLen);
+            curLen += truncLen;
+        }
     }
     return *this;
 }
@@ -236,9 +242,12 @@ StringBuffer & StringBuffer::append(const unsigned char * value)
 
 StringBuffer & StringBuffer::append(const char * value, size_t offset, size_t len)
 {
-    ensureCapacity(len);
-    memcpy(buffer + curLen, value+offset, len);
-    curLen += len;
+    if (likely(len))
+    {
+        ensureCapacity(len);
+        memcpy(buffer + curLen, value+offset, len);
+        curLen += len;
+    }
     return *this;
 }
 
@@ -529,7 +538,7 @@ char * StringBuffer::reserveTruncate(size_t size)
             char * newStr = (char *)malloc(newMax);
             if (!newStr)
                 throw MakeStringException(-1, "StringBuffer::_realloc: Failed to realloc newMax = %zu, oldMax = %zu", newMax, maxLen);
-            memcpy(newStr, buffer, curLen);
+            memcpy_iflen(newStr, buffer, curLen);
             buffer = newStr;
             maxLen = newMax;
         }
@@ -650,8 +659,11 @@ StringBuffer & StringBuffer::insert(size_t offset, const char * value)
     if (!value) return *this;
     
     size_t len = strlen(value);
-    _insert(offset, len);
-    memcpy(buffer + offset, value, len);
+    if (likely(len))
+    {
+        _insert(offset, len);
+        memcpy(buffer + offset, value, len);
+    }
     return *this;
 }
 
@@ -1058,7 +1070,7 @@ String::String(const char * value)
 String::String(const char * value, int offset, int _count)
 {
   text = (char *)malloc(_count+1);
-  memcpy(text, value+offset, _count);
+  memcpy_iflen(text, value+offset, _count);
   text[_count]=0;
 }
 
@@ -1131,12 +1143,12 @@ bool String::equalsIgnoreCase(const String & value) const
 
 void String::getBytes(int srcBegin, int srcEnd, void * dest, int dstBegin) const
 {
-  memcpy((char *)dest+dstBegin, text+srcBegin, srcEnd-srcBegin);
+    memcpy_iflen((char *)dest+dstBegin, text+srcBegin, srcEnd-srcBegin);
 }
 
 void String::getChars(int srcBegin, int srcEnd, void * dest, int dstBegin) const
 {
-  memcpy((char *)dest+dstBegin, text+srcBegin, srcEnd-srcBegin);
+    memcpy_iflen((char *)dest+dstBegin, text+srcBegin, srcEnd-srcBegin);
 }
 
 int String::hashCode() const
@@ -1371,7 +1383,7 @@ void StringAttr::set(const char * _text, size_t _len)
 {
     char * oldtext = text;
     text = (char *)malloc(_len+1);
-    memcpy(text, _text, _len);
+    memcpy_iflen(text, _text, _len);
     text[_len] = 0;
     free(oldtext);
 }

thorlcr/activities/fetch/thfetchslave.cpp

@@ -138,7 +138,7 @@ public:
 
         assertex(offsetMapSz == sizeof(FPosTableEntry) * offsetCount);
         offsetTable = new FPosTableEntry[offsetCount];
-        memcpy(offsetTable, offsetMap, offsetMapSz);
+        memcpy_iflen(offsetTable, offsetMap, offsetMapSz);
         unsigned c;
         for (c=0; c<offsetCount; c++)
         {

thorlcr/activities/msort/thsortu.cpp

@@ -829,7 +829,7 @@ public:
                                 nr++;
                             rightgroup.removeRows(0,nr);
                             rightgroupmatched = (bool *)rightgroupmatchedbuf.clear().reserve(rightgroup.ordinality());
-                            memset(rightgroupmatched,rightmatched?1:0,rightgroup.ordinality());
+                            memset_iflen(rightgroupmatched,rightmatched?1:0,rightgroup.ordinality());
                         }
                         else
                             rightgroup.kill();
@@ -891,7 +891,7 @@ public:
                                 nextR();
                             }
                             rightgroupmatched = (bool *)rightgroupmatchedbuf.clear().reserve(rightgroup.ordinality());
-                            memset(rightgroupmatched,rightmatched?1:0,rightgroup.ordinality());
+                            memset_iflen(rightgroupmatched,rightmatched?1:0,rightgroup.ordinality());
                             if (!hitatmost&&rightgroup.ordinality())
                                 state = JSmatch;
                             else if (cmp<0)
@@ -1527,7 +1527,7 @@ public:
         bool *rmatched = NULL;
         if (rightouter) {
             rmatched = (bool *)rmatchedbuf.clear().reserve(rgroup.ordinality());
-            memset(rmatched,0,rgroup.ordinality());
+            memset_iflen(rmatched,0,rgroup.ordinality());
         }
         ForEachItemIn(leftidx,work.lgroup)
         {