/* ************************************************************************ */ BlockHeap * BlockHeapCreate(size_t elemsize, int elemsperblock) { BlockHeap *bh; assert(elemsize > 0 && elemsperblock > 0); /* Catch idiotic requests up front */ if ((elemsize <= 0) || (elemsperblock <= 0)) { outofmemory(); /* die.. out of memory */ } /* Allocate our new BlockHeap */ bh = (BlockHeap *) calloc(1, sizeof(BlockHeap)); if (bh == NULL) { outofmemory(); /* die.. out of memory */ } #ifdef MEMDEBUG elemsize += sizeof(MemoryEntry); #endif if((elemsize % sizeof(void *)) != 0) { /* Pad to even pointer boundary */ elemsize += sizeof(void *); elemsize &= ~(sizeof(void *) - 1); } bh->elemSize = elemsize; bh->elemsPerBlock = elemsperblock; bh->blocksAllocated = 0; bh->freeElems = 0; bh->base = NULL; /* Be sure our malloc was successful */ if (newblock(bh)) { if(bh != NULL) free(bh); outofmemory(); /* die.. out of memory */ } if (bh == NULL) { outofmemory(); /* die.. out of memory */ } return(bh); }
void *MyRealloc_impl(MemTracer *mt, void *obj, size_t mlen) { MemTag *tag; if (!mt->initialized) { mt->next = mtrace_list; mtrace_list = mt; mt->initialized = 1; } if (obj) { tag = (MemTag *)obj - 1; tag->tracer->objects--; tag->tracer->allocated -= tag->length; obj = tag; /* subtle */ } tag = realloc(obj, mlen + sizeof(MemTag)); if (!tag) outofmemory(); tag->tracer = mt; tag->length = mlen; mt->objects++; mt->allocated += mlen; return tag + 1; }
/* returns 0 on error */ static int run_let_string(struct VarSet *varset, const char *rd, struct Variable *v) { char *str, *strt; int len,n; rd = getstring(varset, rd, &len, &strt); str = malloc(len+1); if(str == NULL) outofmemory(); strncpy(str, strt, len); str[len] = '\0'; rd = skipwhite_s(rd); while(*rd == '+'){ rd = skipwhite_s(rd+1); rd = getstring(varset, rd, &n, &strt); str = realloc(str, len += n); strncat(str, strt, n); rd = skipwhite_s(rd); } if(v->val_s != NULL) free(v->val_s); v->val_s = str; return 1; }
void *doMemAlloc(int size) { void *ptr = NULL; ptr = malloc(size); if (!ptr) { outofmemory(); } return(ptr); }
/* * MyMalloc - allocate memory, call outofmemory on failure */ void * MyMalloc(size_t size) { void *ret = calloc(1, size); if(ret == NULL) outofmemory(); return ret; }
void * _BlockHeapAlloc(BlockHeap * bh) { Block *walker; dlink_node *new_node; assert(bh != NULL); if (bh == NULL) { return(NULL); } if (bh->freeElems == 0) { /* Allocate new block and assign */ /* newblock returns 1 if unsuccessful, 0 if not */ if (newblock(bh)) { /* That didn't work..try to garbage collect */ BlockHeapGarbageCollect(bh); if(bh->freeElems == 0) { outofmemory(); /* Well that didn't work either...bail */ } } } for (walker = bh->base; walker != NULL; walker = walker->next) { if (walker->freeElems > 0) { bh->freeElems--; walker->freeElems--; new_node = walker->free_list.head; dlinkDelete(new_node, &walker->free_list); dlinkAdd(new_node->data, new_node, &walker->used_list); assert(new_node->data != NULL); if(new_node->data == NULL) outofmemory(); return (new_node->data); } } assert(0 == 1); return(NULL); /* If you get here, something bad happened ! */ }
void initBlockHeap(void) { zero_fd = open("/dev/zero", O_RDWR); if (zero_fd < 0) { outofmemory(); } }
/* * MyRealloc - reallocate memory, call outofmemory on failure */ void* MyRealloc(void* x, size_t y) { char *ret = realloc(x, y); if (!ret) outofmemory(); return ret; }
/* * MyMalloc - allocate memory, call outofmemory on failure */ void* MyMalloc(size_t x) { void* ret = malloc(x); if (!ret) outofmemory(); return ret; }
void initBlockHeap(void) { zero_fd = open("/dev/zero", O_RDWR); if (zero_fd < 0) outofmemory(); fd_open(zero_fd, FD_FILE, "Anonymous mmap()"); }
/* * MyRealloc - reallocate memory, call outofmemory on failure */ void * MyRealloc(void *x, size_t y) { void *ret = realloc(x, y); if(ret == NULL) outofmemory(); return ret; }
/** Does the actual reading of the MOTD. To be called only by read_motd() or read_motd_asynch_downloaded(). */ void do_read_motd(const char *filename, aMotdFile *themotd) { FILE *fd; struct tm *tm_tmp; time_t modtime; char line[512]; char *tmp; aMotdLine *last, *temp; free_motd(themotd); if(!filename) return; fd = fopen(filename, "r"); if (!fd) return; /* record file modification time */ modtime = unreal_getfilemodtime(filename); tm_tmp = localtime(&modtime); memcpy(&themotd->last_modified, tm_tmp, sizeof(struct tm)); last = NULL; while (fgets(line, sizeof(line), fd)) { if ((tmp = strchr(line, '\n'))) *tmp = '\0'; if ((tmp = strchr(line, '\r'))) *tmp = '\0'; if (strlen(line) > MOTD_LINE_LEN) line[MOTD_LINE_LEN] = '\0'; temp = MyMalloc(sizeof(aMotdLine)); if (!temp) outofmemory(); AllocCpy(temp->line, line); if(last) last->next = temp; else /* handle the special case of the first line */ themotd->lines = temp; last = temp; } /* the file could be zero bytes long? */ if(last) last->next = NULL; fclose(fd); return; }
void *MyRealloc(void *x, size_t y) { void *ret = realloc(x, y); if (!ret) { outofmemory(); } return ret; }
/* ** Create a new aClient structure and set it to initial state. ** ** from == NULL, create local client (a client connected ** to a socket). ** ** from, create remote client (behind a socket ** associated with the client defined by ** 'from'). ('from' is a local client!!). */ aClient *make_client(aClient *from) { Reg aClient *cptr = NULL; Reg unsigned size = CLIENT_REMOTE_SIZE; /* * Check freelists first to see if we can grab a client without * having to call malloc. */ if (!from) size = CLIENT_LOCAL_SIZE; if (!(cptr = (aClient *)MyMalloc(size))) outofmemory(); bzero((char *)cptr, (int)size); #ifdef DEBUGMODE if (size == CLIENT_LOCAL_SIZE) cloc.inuse++; else crem.inuse++; #endif /* Note: structure is zero (calloc) */ cptr->from = from ? from : cptr; /* 'from' of local client is self! */ cptr->next = NULL; /* For machines with NON-ZERO NULL pointers >;) */ cptr->prev = NULL; cptr->hnext = NULL; cptr->user = NULL; cptr->serv = NULL; cptr->name = cptr->namebuf; cptr->status = STAT_UNKNOWN; cptr->fd = -1; (void)strcpy(cptr->username, "unknown"); cptr->info = DefInfo; if (size == CLIENT_LOCAL_SIZE) { cptr->since = cptr->lasttime = cptr->firsttime = timeofday; cptr->confs = NULL; cptr->sockhost[0] = '\0'; cptr->buffer[0] = '\0'; cptr->authfd = -1; cptr->auth = cptr->username; cptr->exitc = EXITC_UNDEF; cptr->receiveB = cptr->sendB = cptr->receiveM = cptr->sendM = 0; #ifdef ZIP_LINKS cptr->zip = NULL; #endif #ifdef XLINE cptr->user2 = NULL; cptr->user3 = NULL; #endif } return (cptr); }
/* ************************************************************************ */ BlockHeap * BlockHeapCreate (size_t elemsize, int elemsperblock) { BlockHeap *bh; /* Catch idiotic requests up front */ if ((elemsize <= 0) || (elemsperblock <= 0)) { outofmemory(); /* die.. out of memory */ } /* Allocate our new BlockHeap */ bh = (BlockHeap *) MyMalloc( sizeof (BlockHeap)); if (bh == NULL) { outofmemory(); /* die.. out of memory */ } elemsize = elemsize + (elemsize & (sizeof(void *) - 1)); bh->elemSize = elemsize; bh->elemsPerBlock = elemsperblock; bh->blocksAllocated = 0; bh->freeElems = 0; bh->numlongs = (bh->elemsPerBlock / (sizeof(long) * 8)) + 1; if ( (bh->elemsPerBlock % (sizeof(long) * 8)) == 0) bh->numlongs--; bh->base = NULL; /* Be sure our malloc was successful */ if (newblock(bh)) { free(bh); outofmemory(); /* die.. out of memory */ } /* DEBUG */ if(bh == NULL) { outofmemory(); /* die.. out of memory */ } return bh; }
/*! \brief Returns a pointer to a struct within our BlockHeap that's free for * the taking. * \param bh Pointer to the Blockheap * \return Address pointer to allocated data space, or NULL if unsuccessful */ void * BlockHeapAlloc(BlockHeap *bh) { Block *walker = NULL; dlink_node *new_node = NULL; assert(bh != NULL); if (bh->freeElems == 0) { /* Allocate new block and assign */ /* newblock returns 1 if unsuccessful, 0 if not */ if (newblock(bh)) { /* That didn't work..try to garbage collect */ BlockHeapGarbageCollect(bh); if (newblock(bh)) outofmemory(); /* Well that didn't work either...bail */ } } for (walker = bh->base; walker != NULL; walker = walker->next) { if (walker->freeElems > 0) { --bh->freeElems; --walker->freeElems; new_node = walker->free_list.head; dlinkDelete(new_node, &walker->free_list); assert(new_node->data != NULL); memset(new_node->data, 0, bh->elemSize); return new_node->data; } } assert(0 == 1); outofmemory(); return NULL; }
Link *make_link() { Link *lp; lp = MyMalloc(sizeof(Link)); if( lp == (Link *)NULL) outofmemory(); lp->next = (Link *)NULL; /* just to be paranoid... */ return lp; }
void * xstrdup(const char *s) { void *ret = malloc(strlen(s) + 1); if (ret == NULL) outofmemory(); strcpy(ret, s); return ret; }
void * xstrndup(const char *s, size_t len) { void *ret = malloc(len + 1); if (ret == NULL) outofmemory(); strlcpy(ret, s, len + 1); return ret; }
char* getstring(void) { char *buf; int maxlen = 50, len = 0; buf = malloc(maxlen); if(buf == NULL) outofmemory(); while(look != '\r' && look != '\n'){ if(len == maxlen){ buf = realloc(buf, maxlen += 50); if(buf == NULL) outofmemory(); } buf[len++] = look; getlook(); } return buf; }
/*! \brief Creates a new blockheap * * Creates a new blockheap from which smaller blocks can be allocated. * Intended to be used instead of multiple calls to malloc() when * performance is an issue. * * \param name Name of the blockheap * \param elemsize Size of the basic element to be stored * \param elemsperblock Number of elements to be stored in a single block of * memory. When the blockheap runs out of free memory, * it will allocate elemsize * elemsperblock more. * \return Pointer to new BlockHeap, or NULL if unsuccessful */ BlockHeap * BlockHeapCreate(const char *const name, size_t elemsize, int elemsperblock) { BlockHeap *bh = NULL; assert(elemsize > 0 && elemsperblock > 0); /* Catch idiotic requests up front */ if ((elemsize <= 0) || (elemsperblock <= 0)) outofmemory(); /* die.. out of memory */ /* Allocate our new BlockHeap */ if ((bh = calloc(1, sizeof(BlockHeap))) == NULL) outofmemory(); /* die.. out of memory */ if ((elemsize % sizeof(void *)) != 0) { /* Pad to even pointer boundary */ elemsize += sizeof(void *); elemsize &= ~(sizeof(void *) - 1); } bh->name = name; bh->elemSize = elemsize; bh->elemsPerBlock = elemsperblock; /* Be sure our malloc was successful */ if (newblock(bh)) { if (bh != NULL) free(bh); outofmemory(); /* die.. out of memory */ } bh->next = heap_list; heap_list = bh; return bh; }
/*! \brief Opens /dev/zero and saves the file handle for * future allocations. */ void initBlockHeap(void) { #ifdef HAVE_MMAP #ifndef MAP_ANON int zero_fd = open("/dev/zero", O_RDWR); if (zero_fd < 0) outofmemory(); fd_open(&dpfd, zero_fd, 0, "Anonymous mmap()"); #endif eventAdd("heap_garbage_collection", &heap_garbage_collection, NULL, 119); #endif }
/** Read motd-like file, used for rules/motd/botmotd/opermotd/etc. * Multiplexes to either directly reading the MOTD or downloading it asynchronously. * @param filename Filename of file to read or URL. NULL is accepted and causes the *motd to be free()d. * @param motd Reference to motd pointer (used for freeing if needed and for asynchronous remote MOTD support) */ void read_motd(const char *filename, aMotdFile *themotd) { #ifdef USE_LIBCURL time_t modtime; aMotdDownload *motd_download; #endif /* TODO: if themotd points to a tld's motd, could a rehash disrupt this pointer?*/ #ifdef USE_LIBCURL if(themotd->motd_download) { themotd->motd_download->themotd = NULL; /* * It is not our job to free() motd_download, the * read_motd_asynch_downloaded() function will do that * when it sees that ->themod == NULL. */ themotd->motd_download = NULL; } /* if filename is NULL, do_read_motd will catch it */ if(filename && url_is_valid(filename)) { /* prepare our payload for read_motd_asynch_downloaded() */ motd_download = MyMallocEx(sizeof(aMotdDownload)); if(!motd_download) outofmemory(); motd_download->themotd = themotd; themotd->motd_download = motd_download; #ifdef REMOTEINC_SPECIALCACHE modtime = unreal_getfilemodtime(unreal_mkcache(filename)); #else modtime = 0; #endif download_file_async(filename, modtime, (vFP)read_motd_asynch_downloaded, motd_download); return; } #endif /* USE_LIBCURL */ do_read_motd(filename, themotd); return; }
PUBLIC void syminit() { unsigned i; for (i = sizeof(int) <= 2 ? 0xE000 : (unsigned) 0x38000; i != 0; i -= 512) if ((tableptr = malloc(i)) != NUL_PTR) break; if (tableptr == NUL_PTR) outofmemory(); tableend = tableptr + i; for (i = 0; i < HASHTABSIZE; i++) hashtab[i] = NUL_PTR; mainavail = tableend - tableptr; usedtop = 0; }
/* ************************************************************************ */ int _BlockHeapFree(BlockHeap * bh, void *ptr) { Block *block; struct MemBlock *memblock; assert(bh != NULL); assert(ptr != NULL); if (bh == NULL) { ilog(L_NOTICE, "balloc.c:BlockHeapFree() bh == NULL"); return(1); } if (ptr == NULL) { ilog(L_NOTICE, "balloc.BlockHeapFree() ptr == NULL"); return(1); } memblock = (void *)((size_t)ptr - sizeof(MemBlock)); assert(memblock->block != NULL); if(memblock->block == NULL) { outofmemory(); } /* Is this block really on the used list? */ assert(dlinkFind(&memblock->block->used_list, memblock) == NULL); block = memblock->block; bh->freeElems++; block->freeElems++; mem_frob(ptr, bh->elemSize); dlinkDelete(&memblock->self, &block->used_list); dlinkAdd(ptr, &memblock->self, &block->free_list); return(0); }
/* ** 'make_user' add's an User information block to a client ** if it was not previously allocated. */ anUser* make_user(aClient *cptr) { anUser *user; user = cptr->user; if (!user) { user = MyMalloc(sizeof(anUser)); if( user == (anUser *)NULL) outofmemory(); user->away = NULL; user->server = (char *)NULL; /* scache server name */ user->refcnt = 1; user->joined = 0; user->channel = NULL; user->invited = NULL; user->silence = NULL; user->vlink = NULL; cptr->user = user; } return user; }
void *MyMalloc_impl(MemTracer *mt, size_t mlen) { MemTag *tag; if (!mt->initialized) { mt->next = mtrace_list; mtrace_list = mt; mt->initialized = 1; } tag = malloc(mlen + sizeof(MemTag)); if (!tag) outofmemory(); tag->tracer = mt; tag->length = mlen; mt->objects++; mt->allocated += mlen; return tag + 1; }
/*! \brief Returns an element to the free pool, does not free() * \param bh Pointer to BlockHeap containing element * \param ptr Pointer to element to be "freed" * \return 0 if successful, 1 if element not contained within BlockHeap */ int BlockHeapFree(BlockHeap *bh, void *ptr) { Block *block = NULL; struct MemBlock *memblock = NULL; assert(bh != NULL); assert(ptr != NULL); memblock = (void *)((size_t)ptr - sizeof(MemBlock)); assert(memblock->block != NULL); if (memblock->block == NULL) outofmemory(); block = memblock->block; ++bh->freeElems; ++block->freeElems; mem_frob(ptr, bh->elemSize); dlinkAdd(ptr, &memblock->self, &block->free_list); return 0; }