自学教程：C++ CHKmalloc函数代码示例

static inline rsRetValaddEntry(struct sockaddr_storage *addr, dnscache_entry_t **pEtry){    int r;    struct sockaddr_storage *keybuf;    dnscache_entry_t *etry = NULL;    DEFiRet;    CHKmalloc(etry = MALLOC(sizeof(dnscache_entry_t)));    CHKiRet(resolveAddr(addr, etry));    memcpy(&etry->addr, addr, SALEN((struct sockaddr*) addr));    etry->nUsed = 0;    *pEtry = etry;    CHKmalloc(keybuf = malloc(sizeof(struct sockaddr_storage)));    memcpy(keybuf, addr, sizeof(struct sockaddr_storage));    pthread_rwlock_unlock(&dnsCache.rwlock); /* release read lock */    pthread_rwlock_wrlock(&dnsCache.rwlock); /* and re-aquire for writing */    r = hashtable_insert(dnsCache.ht, keybuf, *pEtry);    if(r == 0) {        DBGPRINTF("dnscache: inserting element failed/n");    }    pthread_rwlock_unlock(&dnsCache.rwlock);    pthread_rwlock_rdlock(&dnsCache.rwlock); /* we need this again */finalize_it:    if(iRet != RS_RET_OK && etry != NULL) {        /* Note: sub-fields cannot be populated in this case */        free(etry);    }    RETiRet;}

addEntry(struct sockaddr_storage *const addr, dnscache_entry_t **const pEtry){	int r;	dnscache_entry_t *etry = NULL;	DEFiRet;	/* entry still does not exist, so add it */	struct sockaddr_storage *const keybuf =  malloc(sizeof(struct sockaddr_storage));	CHKmalloc(keybuf);	CHKmalloc(etry = malloc(sizeof(dnscache_entry_t)));	resolveAddr(addr, etry);	assert(etry != NULL);	memcpy(&etry->addr, addr, SALEN((struct sockaddr*) addr));	etry->nUsed = 0;	if(dnscacheEnableTTL) {		etry->validUntil = time(NULL) + dnscacheDefaultTTL;	}	memcpy(keybuf, addr, sizeof(struct sockaddr_storage));	r = hashtable_insert(dnsCache.ht, keybuf, etry);	if(r == 0) {		DBGPRINTF("dnscache: inserting element failed/n");	}	*pEtry = etry;finalize_it:	if(iRet != RS_RET_OK) {		free(keybuf);	}	RETiRet;}

/* add a counter to an object * ctrName is duplicated, caller must free it if requried * NOTE: The counter is READ-ONLY and MUST NOT be modified (most * importantly, it must not be initialized, so the caller must * ensure the counter is properly initialized before AddCounter() * is called. */static rsRetValaddCounter(statsobj_t *pThis, uchar *ctrName, statsCtrType_t ctrType, int8_t flags, void *pCtr){	ctr_t *ctr;	DEFiRet;	CHKmalloc(ctr = malloc(sizeof(ctr_t)));	ctr->next = NULL;	ctr->prev = NULL;	CHKmalloc(ctr->name = ustrdup(ctrName));	ctr->flags = flags;	ctr->ctrType = ctrType;	switch(ctrType) {	case ctrType_IntCtr:		ctr->val.pIntCtr = (intctr_t*) pCtr;		break;	case ctrType_Int:		ctr->val.pInt = (int*) pCtr;		break;	}	addCtrToList(pThis, ctr);finalize_it:	RETiRet;}

/* create a new lookup table object AND include it in our list of * lookup tables. */rsRetVallookupNew(lookup_ref_t **ppThis){	lookup_ref_t *pThis = NULL;	lookup_t *t = NULL;	DEFiRet;	CHKmalloc(pThis = calloc(1, sizeof(lookup_ref_t)));	CHKmalloc(t = calloc(1, sizeof(lookup_t)));	pthread_rwlock_init(&pThis->rwlock, NULL);	pthread_mutex_init(&pThis->reloader_mut, NULL);	pthread_cond_init(&pThis->run_reloader, NULL);	pthread_attr_init(&pThis->reloader_thd_attr);	pThis->do_reload = pThis->do_stop = 0;	pThis->reload_on_hup = 1; /*DO reload on HUP (default)*/	pthread_create(&pThis->reloader, &pThis->reloader_thd_attr, lookupTableReloader, pThis);	pThis->next = NULL;	if(loadConf->lu_tabs.root == NULL) {		loadConf->lu_tabs.root = pThis;	} else {		loadConf->lu_tabs.last->next = pThis;	}	loadConf->lu_tabs.last = pThis;	pThis->self = t;	*ppThis = pThis;finalize_it:	if(iRet != RS_RET_OK) {		free(t);		free(pThis);	}	RETiRet;}

/* this reloads a lookup table. This is done while the engine is running, * as such the function must ensure proper locking and proper order of * operations (so that nothing can interfere). If the table cannot be loaded, * the old table is continued to be used. */static rsRetVallookupReload(lookup_t *pThis){	uint32_t i;	lookup_t newlu; /* dummy to be able to use support functions without 	                   affecting current settings. */	DEFiRet;		DBGPRINTF("reload requested for lookup table '%s'/n", pThis->name);	memset(&newlu, 0, sizeof(newlu));	CHKmalloc(newlu.name = ustrdup(pThis->name));	CHKmalloc(newlu.filename = ustrdup(pThis->filename));	CHKiRet(lookupReadFile(&newlu));	/* all went well, copy over data members */	pthread_rwlock_wrlock(&pThis->rwlock);	for(i = 0 ; i < pThis->nmemb ; ++i) {		free(pThis->d.strtab[i].key), /* we don't care about exec order of frees */		free(pThis->d.strtab[i].val);	}	free(pThis->d.strtab);	pThis->d.strtab = newlu.d.strtab; /* hand table AND ALL STRINGS over! */	pthread_rwlock_unlock(&pThis->rwlock);	errmsg.LogError(0, RS_RET_OK, "lookup table '%s' reloaded from file '%s'",			pThis->name, pThis->filename);finalize_it:	free(newlu.name);	free(newlu.filename);	RETiRet;}

/* ConstructionFinalizer */static rsRetValtcpsrvConstructFinalize(tcpsrv_t *pThis){	DEFiRet;	ISOBJ_TYPE_assert(pThis, tcpsrv);	/* prepare network stream subsystem */	CHKiRet(netstrms.Construct(&pThis->pNS));	if(pThis->pszDrvrName != NULL)		CHKiRet(netstrms.SetDrvrName(pThis->pNS, pThis->pszDrvrName));	CHKiRet(netstrms.SetDrvrMode(pThis->pNS, pThis->iDrvrMode));	if(pThis->pszDrvrAuthMode != NULL)		CHKiRet(netstrms.SetDrvrAuthMode(pThis->pNS, pThis->pszDrvrAuthMode));	if(pThis->pPermPeers != NULL)		CHKiRet(netstrms.SetDrvrPermPeers(pThis->pNS, pThis->pPermPeers));	CHKiRet(netstrms.ConstructFinalize(pThis->pNS));	/* set up listeners */	CHKmalloc(pThis->ppLstn = calloc(pThis->iLstnMax, sizeof(netstrm_t*)));	CHKmalloc(pThis->ppLstnPort = calloc(pThis->iLstnMax, sizeof(tcpLstnPortList_t*)));	iRet = pThis->OpenLstnSocks(pThis);finalize_it:	if(iRet != RS_RET_OK) {		if(pThis->pNS != NULL)			netstrms.Destruct(&pThis->pNS);		errmsg.LogError(0, iRet, "tcpsrv could not create listener (inputname: '%s')",				(pThis->pszInputName == NULL) ? (uchar*)"*UNSET*" : pThis->pszInputName);	}	RETiRet;}

/* get the name of the local host. A pointer to a character pointer is passed * in, which on exit points to the local hostname. This buffer is dynamically * allocated and must be free()ed by the caller. If the functions returns an * error, the pointer is NULL. This function is based on GNU/Hurd's localhostname * function. * rgerhards, 20080-04-10 */static rsRetValgetLocalHostname(uchar **ppName){	DEFiRet;	uchar *buf = NULL;	size_t buf_len = 0;	assert(ppName != NULL);	do {		if(buf == NULL) {			buf_len = 128;        /* Initial guess */			CHKmalloc(buf = MALLOC(buf_len));		} else {			uchar *p;			buf_len += buf_len;			CHKmalloc(p = realloc (buf, buf_len));			buf = p;		}	} while((gethostname((char*)buf, buf_len) == 0 && !memchr (buf, '/0', buf_len)) || errno == ENAMETOOLONG);	*ppName = buf;	buf = NULL;finalize_it:	if(iRet != RS_RET_OK) {		if(buf != NULL)			free(buf);	}	RETiRet;}

/* get the name of the local host. A pointer to a character pointer is passed * in, which on exit points to the local hostname. This buffer is dynamically * allocated and must be free()ed by the caller. If the functions returns an * error, the pointer is NULL. * This function always tries to return a FQDN, even so be quering DNS. So it * is safe to assume for the caller that when the function does not return * a FQDN, it simply is not available. The domain part of that string is * normalized to lower case. The hostname is kept in mixed case for historic * reasons. */static rsRetValgetLocalHostname(uchar **ppName){	DEFiRet;	char hnbuf[8192];	uchar *fqdn = NULL;	if(gethostname(hnbuf, sizeof(hnbuf)) != 0) {		strcpy(hnbuf, "localhost");	} else {		hnbuf[sizeof(hnbuf)-1] = '/0'; /* be on the safe side... */	}	char *dot = strstr(hnbuf, ".");	if(dot == NULL) {		/* we need to (try) to find the real name via resolver */		struct hostent *hent = gethostbyname((char*)hnbuf);		if(hent) {			int i = 0;			if(hent->h_aliases) {				const size_t hnlen = strlen(hnbuf);				for(i = 0; hent->h_aliases[i]; i++) {					if(!strncmp(hent->h_aliases[i], hnbuf, hnlen)					   && hent->h_aliases[i][hnlen] == '.') {						break; /* match! */					}				}			}			if(hent->h_aliases && hent->h_aliases[i]) {				CHKmalloc(fqdn = (uchar*)strdup(hent->h_aliases[i]));			} else {				CHKmalloc(fqdn = (uchar*)strdup(hent->h_name));			}			dot = strstr((char*)fqdn, ".");		}	}	if(fqdn == NULL) {		/* already was FQDN or we could not obtain a better one */		CHKmalloc(fqdn = (uchar*) strdup(hnbuf));	}	if(dot != NULL)		for(char *p = dot+1 ; *p ; ++p)			*p = tolower(*p);	*ppName = fqdn;finalize_it:	RETiRet;}

/* add new listener port to listener port list * rgerhards, 2009-05-21 */static inline rsRetValaddNewLstnPort(tcpsrv_t *pThis, uchar *pszPort, int bSuppOctetFram, uchar *pszAddr){	tcpLstnPortList_t *pEntry;	uchar statname[64];	DEFiRet;	ISOBJ_TYPE_assert(pThis, tcpsrv);	/* create entry */	CHKmalloc(pEntry = MALLOC(sizeof(tcpLstnPortList_t)));	CHKmalloc(pEntry->pszPort = ustrdup(pszPort));        pEntry->pszAddr = NULL; // Initalize address to null        /* only if a bind adress is defined copy it in struct */        if (pszAddr != NULL) CHKmalloc(pEntry->pszAddr = ustrdup(pszAddr));	strcpy((char*)pEntry->dfltTZ, (char*)pThis->dfltTZ);	pEntry->bSPFramingFix = pThis->bSPFramingFix;	pEntry->pSrv = pThis;	pEntry->pRuleset = pThis->pRuleset;	pEntry->bSuppOctetFram = bSuppOctetFram;	/* we need to create a property */ 	CHKiRet(prop.Construct(&pEntry->pInputName));	CHKiRet(prop.SetString(pEntry->pInputName, pThis->pszInputName, ustrlen(pThis->pszInputName)));	CHKiRet(prop.ConstructFinalize(pEntry->pInputName));	/* and add to list */	pEntry->pNext = pThis->pLstnPorts;	pThis->pLstnPorts = pEntry;	/* support statistics gathering */	CHKiRet(statsobj.Construct(&(pEntry->stats)));	snprintf((char*)statname, sizeof(statname), "%s(%s)", pThis->pszInputName, pszPort);	statname[sizeof(statname)-1] = '/0'; /* just to be on the save side... */	CHKiRet(statsobj.SetName(pEntry->stats, statname));	CHKiRet(statsobj.SetOrigin(pEntry->stats, pThis->pszOrigin));	CHKiRet(ratelimitNew(&pEntry->ratelimiter, "tcperver", NULL));	ratelimitSetLinuxLike(pEntry->ratelimiter, pThis->ratelimitInterval, pThis->ratelimitBurst);	ratelimitSetThreadSafe(pEntry->ratelimiter);	STATSCOUNTER_INIT(pEntry->ctrSubmit, pEntry->mutCtrSubmit);	CHKiRet(statsobj.AddCounter(pEntry->stats, UCHAR_CONSTANT("submitted"),		ctrType_IntCtr, CTR_FLAG_RESETTABLE, &(pEntry->ctrSubmit)));	CHKiRet(statsobj.ConstructFinalize(pEntry->stats));finalize_it:	RETiRet;}

/* extract a groupname and return its gid. * rgerhards, 2007-07-17 */static rsRetVal doGetGID(uchar **pp, rsRetVal (*pSetHdlr)(void*, uid_t), void *pVal){	struct group *pgBuf = NULL;	struct group gBuf;	DEFiRet;	uchar szName[256];	int bufSize = 2048;	char * stringBuf = NULL;	assert(pp != NULL);	assert(*pp != NULL);	if(getSubString(pp, (char*) szName, sizeof(szName) / sizeof(uchar), ' ')  != 0) {		errmsg.LogError(0, RS_RET_NOT_FOUND, "could not extract group name");		ABORT_FINALIZE(RS_RET_NOT_FOUND);	}	CHKmalloc(stringBuf = malloc(bufSize));	while(pgBuf == NULL) {		errno = 0;		getgrnam_r((char*)szName, &gBuf, stringBuf, bufSize, &pgBuf);		if((pgBuf == NULL) && (errno == ERANGE)) {			/* Increase bufsize and try again.*/			bufSize *= 2;			CHKmalloc(stringBuf = realloc(stringBuf, bufSize));		}	}	if(pgBuf == NULL) {		errmsg.LogError(0, RS_RET_NOT_FOUND, "ID for group '%s' could not be found or error", (char*)szName);		iRet = RS_RET_NOT_FOUND;	} else {		if(pSetHdlr == NULL) {			/* we should set value directly to var */			*((gid_t*)pVal) = pgBuf->gr_gid;		} else {			/* we set value via a set function */			CHKiRet(pSetHdlr(pVal, pgBuf->gr_gid));		}		dbgprintf("gid %d obtained for group '%s'/n", (int) pgBuf->gr_gid, szName);	}	skipWhiteSpace(pp); /* skip over any whitespace */finalize_it:	free(stringBuf);	RETiRet;}

/* create a new lookup table object AND include it in our list of * lookup tables. */static rsRetVallookupNew(lookup_ref_t **ppThis){	lookup_ref_t *pThis = NULL;	lookup_t *t = NULL;	int initialized = 0;	DEFiRet;	CHKmalloc(pThis = calloc(1, sizeof(lookup_ref_t)));	CHKmalloc(t = calloc(1, sizeof(lookup_t)));	CHKiConcCtrl(pthread_rwlock_init(&pThis->rwlock, NULL));	initialized++; /*1*/	CHKiConcCtrl(pthread_mutex_init(&pThis->reloader_mut, NULL));	initialized++; /*2*/	CHKiConcCtrl(pthread_cond_init(&pThis->run_reloader, NULL));	initialized++; /*3*/	CHKiConcCtrl(pthread_attr_init(&pThis->reloader_thd_attr));	initialized++; /*4*/	pThis->do_reload = pThis->do_stop = 0;	pThis->reload_on_hup = 1; /*DO reload on HUP (default)*/	CHKiConcCtrl(pthread_create(&pThis->reloader, &pThis->reloader_thd_attr, lookupTableReloader, pThis));	initialized++; /*5*/	pThis->next = NULL;	if(loadConf->lu_tabs.root == NULL) {		loadConf->lu_tabs.root = pThis;	} else {		loadConf->lu_tabs.last->next = pThis;	}	loadConf->lu_tabs.last = pThis;	pThis->self = t;	*ppThis = pThis;finalize_it:	if(iRet != RS_RET_OK) {		errmsg.LogError(errno, iRet, "a lookup table could not be initialized: failed at init-step %d "		"(please enable debug logs for details)", initialized);		if (initialized > 4) lookupStopReloader(pThis);		if (initialized > 3) pthread_attr_destroy(&pThis->reloader_thd_attr);		if (initialized > 2) pthread_cond_destroy(&pThis->run_reloader);		if (initialized > 1) pthread_mutex_destroy(&pThis->reloader_mut);		if (initialized > 0) pthread_rwlock_destroy(&pThis->rwlock);		free(t);		free(pThis);	}	RETiRet;}

/* add new entry to list. We assume that the fd is not already present and DO NOT check this! * Returns newly created entry in pEvtLst. * Note that we currently need to use level-triggered mode, because the upper layers do not work * in parallel. As such, in edge-triggered mode we may not get notified, because new data comes * in after we have read everything that was present. To use ET mode, we need to change the upper * peers so that they immediately start a new wait before processing the data read. That obviously * requires more elaborate redesign and we postpone this until the current more simplictic mode has * been proven OK in practice. * rgerhards, 2009-11-18 */static inline rsRetValaddEvent(nsdpoll_ptcp_t *pThis, int id, void *pUsr, int mode, nsd_ptcp_t *pSock, nsdpoll_epollevt_lst_t **pEvtLst) {	nsdpoll_epollevt_lst_t *pNew;	DEFiRet;	CHKmalloc(pNew = (nsdpoll_epollevt_lst_t*) calloc(1, sizeof(nsdpoll_epollevt_lst_t)));	pNew->id = id;	pNew->pUsr = pUsr;	pNew->pSock = pSock;	pNew->event.events = 0; /* TODO: at some time we should be able to use EPOLLET */	//pNew->event.events = EPOLLET;	if(mode & NSDPOLL_IN)		pNew->event.events |= EPOLLIN;	if(mode & NSDPOLL_OUT)		pNew->event.events |= EPOLLOUT;	pNew->event.data.ptr = pNew;	pthread_mutex_lock(&pThis->mutEvtLst);	pNew->pNext = pThis->pRoot;	pThis->pRoot = pNew;	pthread_mutex_unlock(&pThis->mutEvtLst);	*pEvtLst = pNew;finalize_it:	RETiRet;}

/* Add a parser to the list. We use a VERY simple and ineffcient algorithm, * but it is employed only for a few milliseconds during config processing. So * I prefer to keep it very simple and with simple data structures. Unfortunately, * we need to preserve the order, but I don't like to add a tail pointer as that * would require a container object. So I do the extra work to skip to the tail * when adding elements... * rgerhards, 2009-11-03 */static rsRetValAddParserToList(parserList_t **ppListRoot, parser_t *pParser){	parserList_t *pThis;	parserList_t *pTail;	DEFiRet;	CHKmalloc(pThis = MALLOC(sizeof(parserList_t)));	pThis->pParser = pParser;	pThis->pNext = NULL;	if(*ppListRoot == NULL) {		pThis->pNext = *ppListRoot;		*ppListRoot = pThis;	} else {		/* find tail first */		for(pTail = *ppListRoot ; pTail->pNext != NULL ; pTail = pTail->pNext)			/* just search, do nothing else */;		/* add at tail */		pTail->pNext = pThis;	}DBGPRINTF("DDDDD: added parser '%s' to list %p/n", pParser->pName, ppListRoot);finalize_it:	RETiRet;}

/* add a function to the function registry. * The handed-over cstr_t* object must no longer be used by the caller. * A duplicate function name is an error. * rgerhards, 2009-04-06 */static rsRetValrsfrAddFunction(uchar *szName, prsf_t rsf){	rsf_entry_t *pEntry;	size_t lenName;	DEFiRet;	assert(szName != NULL);	assert(rsf != NULL);	/* first check if we have a duplicate name, with the current approach this means	 * we need to go through the whole list.	 */	lenName = strlen((char*)szName);	for(pEntry = funcRegRoot ; pEntry != NULL ; pEntry = pEntry->pNext)		if(!rsCStrSzStrCmp(pEntry->pName, szName, lenName))			ABORT_FINALIZE(RS_RET_DUP_FUNC_NAME);	/* unique name, so add to head of list */	CHKmalloc(pEntry = calloc(1, sizeof(rsf_entry_t)));	CHKiRet(rsCStrConstructFromszStr(&pEntry->pName, szName));	CHKiRet(cstrFinalize(pEntry->pName));	pEntry->rsf = rsf;	pEntry->pNext = funcRegRoot;	funcRegRoot = pEntry;finalize_it:	if(iRet != RS_RET_OK && iRet != RS_RET_DUP_FUNC_NAME)		free(pEntry);	RETiRet;}

/* Add a strgen to the list. We use a VERY simple and ineffcient algorithm, * but it is employed only for a few milliseconds during config processing. So * I prefer to keep it very simple and with simple data structures. Unfortunately, * we need to preserve the order, but I don't like to add a tail pointer as that * would require a container object. So I do the extra work to skip to the tail * when adding elements... */static rsRetValAddStrgenToList(strgenList_t **ppListRoot, strgen_t *pStrgen){	strgenList_t *pThis;	strgenList_t *pTail;	DEFiRet;	CHKmalloc(pThis = MALLOC(sizeof(strgenList_t)));	pThis->pStrgen = pStrgen;	pThis->pNext = NULL;	if(*ppListRoot == NULL) {		pThis->pNext = *ppListRoot;		*ppListRoot = pThis;	} else {		/* find tail first */		for(pTail = *ppListRoot ; pTail->pNext != NULL ; pTail = pTail->pNext)			/* just search, do nothing else */;		/* add at tail */		pTail->pNext = pThis;	}finalize_it:	RETiRet;}

/* Construction finalizer * rgerhards, 2008-01-17 */rsRetValwtiConstructFinalize(wti_t *pThis){	DEFiRet;	int iDeqBatchSize;	ISOBJ_TYPE_assert(pThis, wti);	DBGPRINTF("%s: finalizing construction of worker instance data (for %d actions)/n",		  wtiGetDbgHdr(pThis), iActionNbr);	/* initialize our thread instance descriptor (no concurrency here) */	pThis->bIsRunning = WRKTHRD_STOPPED;	/* must use calloc as we need zero-init */	CHKmalloc(pThis->actWrkrInfo = calloc(iActionNbr, sizeof(actWrkrInfo_t)));	if(pThis->pWtp == NULL) {		dbgprintf("wtiConstructFinalize: pWtp not set, this may be intentional/n");		FINALIZE;	}	/* we now alloc the array for user pointers. We obtain the max from the queue itself. */	CHKiRet(pThis->pWtp->pfGetDeqBatchSize(pThis->pWtp->pUsr, &iDeqBatchSize));	CHKiRet(batchInit(&pThis->batch, iDeqBatchSize));finalize_it:	RETiRet;}

/* note: this function is only called once in action.c */rsRetValwtiNewIParam(wti_t *const pWti, action_t *const pAction, actWrkrIParams_t **piparams){	actWrkrInfo_t *const wrkrInfo = &(pWti->actWrkrInfo[pAction->iActionNbr]);	actWrkrIParams_t *iparams;	int newMax;	DEFiRet;	if(wrkrInfo->p.tx.currIParam == wrkrInfo->p.tx.maxIParams) {		/* we need to extend */		newMax = (wrkrInfo->p.tx.maxIParams == 0) ? CONF_IPARAMS_BUFSIZE							  : 2 * wrkrInfo->p.tx.maxIParams;		CHKmalloc(iparams = realloc(wrkrInfo->p.tx.iparams,					    sizeof(actWrkrIParams_t) * pAction->iNumTpls * newMax));		memset(iparams + (wrkrInfo->p.tx.currIParam * pAction->iNumTpls), 0,		       sizeof(actWrkrIParams_t) * pAction->iNumTpls * (newMax - wrkrInfo->p.tx.maxIParams));		wrkrInfo->p.tx.iparams = iparams;		wrkrInfo->p.tx.maxIParams = newMax;	}	*piparams = wrkrInfo->p.tx.iparams + wrkrInfo->p.tx.currIParam * pAction->iNumTpls;	++wrkrInfo->p.tx.currIParam;finalize_it:	RETiRet;}

/* create a new lookup table object AND include it in our list of * lookup tables. */rsRetVallookupNew(lookup_t **ppThis){	lookup_t *pThis = NULL;	DEFiRet;	CHKmalloc(pThis = malloc(sizeof(lookup_t)));	pthread_rwlock_init(&pThis->rwlock, NULL);	pThis->name = NULL;	if(loadConf->lu_tabs.root == NULL) {		loadConf->lu_tabs.root = pThis;		pThis->next = NULL;	} else {		pThis->next = loadConf->lu_tabs.last;	}	loadConf->lu_tabs.last = pThis;	*ppThis = pThis;finalize_it:	if(iRet != RS_RET_OK) {		free(pThis);	}	RETiRet;}

/* extend the string buffer if its size is insufficient. * Param iMinNeeded is the minumum free space needed. If it is larger * than the default alloc increment, space for at least this amount is * allocated. In practice, a bit more is allocated because we envision that * some more characters may be added after these. * rgerhards, 2008-01-07 * changed to utilized realloc() -- rgerhards, 2009-06-16 */rsRetValrsCStrExtendBuf(cstr_t *pThis, size_t iMinNeeded){	uchar *pNewBuf;	size_t iNewSize;	DEFiRet;	/* first compute the new size needed */	if(iMinNeeded > RS_STRINGBUF_ALLOC_INCREMENT) {		/* we allocate "n" ALLOC_INCREMENTs. Usually, that should		 * leave some room after the absolutely needed one. It also		 * reduces memory fragmentation. Note that all of this are		 * integer operations (very important to understand what is		 * going on)! Parenthesis are for better readibility.		 */		iNewSize = (iMinNeeded / RS_STRINGBUF_ALLOC_INCREMENT + 1) * RS_STRINGBUF_ALLOC_INCREMENT;	} else {		iNewSize = pThis->iBufSize + RS_STRINGBUF_ALLOC_INCREMENT;	}	iNewSize += pThis->iBufSize; /* add current size */	/* DEV debugging only: dbgprintf("extending string buffer, old %d, new %d/n", pThis->iBufSize, iNewSize); */	CHKmalloc(pNewBuf = (uchar*) realloc(pThis->pBuf, iNewSize * sizeof(uchar)));	pThis->iBufSize = iNewSize;	pThis->pBuf = pNewBuf;finalize_it:	RETiRet;}

/* Converts the CStr object to a classical zero-terminated C string, * returns that string and destroys the CStr object. The returned string * MUST be freed by the caller. The function might return NULL if * no memory can be allocated. * * This is the NEW replacement for rsCStrConvSzStrAndDestruct which does * no longer utilize a special buffer but soley works on pBuf (and also * assumes that cstrFinalize had been called). * * Parameters are as follows: * pointer to the object, pointer to string-pointer to receive string and * bRetNULL: 0 - must not return NULL on empty string, return "" in that * case, 1 - return NULL instead of an empty string. * PLEASE NOTE: the caller must free the memory returned in ppSz in any case * (except, of course, if it is NULL). */rsRetVal cstrConvSzStrAndDestruct(cstr_t *pThis, uchar **ppSz, int bRetNULL){	DEFiRet;	uchar* pRetBuf;	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);	assert(ppSz != NULL);	assert(bRetNULL == 0 || bRetNULL == 1);	if(pThis->pBuf == NULL) {		if(bRetNULL == 0) {			CHKmalloc(pRetBuf = MALLOC(sizeof(uchar)));			*pRetBuf = '/0';		} else {			pRetBuf = NULL;		}	} else		pRetBuf = pThis->pBuf;		*ppSz = pRetBuf;finalize_it:	/* We got it, now free the object ourselfs. Please note	 * that we can NOT use the rsCStrDestruct function as it would	 * also free the sz String buffer, which we pass on to the user.	 */	RSFREEOBJ(pThis);	RETiRet;}

/* load our low-level driver. This must be done before any * driver-specific functions (allmost all...) can be carried * out. Note that the driver's .ifIsLoaded is correctly * initialized by calloc() and we depend on that. * WARNING: this code is mostly identical to similar code in  * nssel.c - TODO: abstract it and move it to some common place. * rgerhards, 2008-04-18 */static rsRetValloadDrvr(netstrms_t *pThis){	DEFiRet;	uchar *pBaseDrvrName;	uchar szDrvrName[48]; /* 48 shall be large enough */	pBaseDrvrName = pThis->pBaseDrvrName;	if(pBaseDrvrName == NULL) /* if no drvr name is set, use system default */		pBaseDrvrName = glbl.GetDfltNetstrmDrvr();	if(snprintf((char*)szDrvrName, sizeof(szDrvrName), "lmnsd_%s", pBaseDrvrName) == sizeof(szDrvrName))		ABORT_FINALIZE(RS_RET_DRVRNAME_TOO_LONG);	CHKmalloc(pThis->pDrvrName = (uchar*) strdup((char*)szDrvrName));	pThis->Drvr.ifVersion = nsdCURR_IF_VERSION;	/* The pDrvrName+2 below is a hack to obtain the object name. It 	 * safes us to have yet another variable with the name without "lm" in	 * front of it. If we change the module load interface, we may re-think	 * about this hack, but for the time being it is efficient and clean	 * enough. -- rgerhards, 2008-04-18	 */	CHKiRet(obj.UseObj(__FILE__, szDrvrName+2, szDrvrName, (void*) &pThis->Drvr));finalize_it:	if(iRet != RS_RET_OK) {		if(pThis->pDrvrName != NULL)			free(pThis->pDrvrName);			pThis->pDrvrName = NULL;	}	RETiRet;}

static rsRetValsetReportingNamespace(statsobj_t *pThis, uchar *ns){	DEFiRet;	CHKmalloc(pThis->reporting_ns = ustrdup(ns));finalize_it:	RETiRet;}

/* set name. Note that we make our own copy of the memory, caller is * responsible to free up name it passes in (if required). */static rsRetValsetName(statsobj_t *pThis, uchar *name){	DEFiRet;	CHKmalloc(pThis->name = ustrdup(name));finalize_it:	RETiRet;}

/* set origin (module name, etc). * Note that we make our own copy of the memory, caller is * responsible to free up name it passes in (if required). */static rsRetValsetOrigin(statsobj_t *pThis, uchar *origin){	DEFiRet;	CHKmalloc(pThis->origin = ustrdup(origin));finalize_it:	RETiRet;}

static rsRetVal  /* assumes exclusive access to bucket */dynstats_rebuildSurvivorTable(dynstats_bucket_t *b) {	htable *survivor_table = NULL;	htable *new_table = NULL;	size_t htab_sz;	DEFiRet;		htab_sz = (size_t) (DYNSTATS_HASHTABLE_SIZE_OVERPROVISIONING * b->maxCardinality + 1);	if (b->table == NULL) {		CHKmalloc(survivor_table = create_hashtable(htab_sz, hash_from_string, key_equals_string,			no_op_free));	}	CHKmalloc(new_table = create_hashtable(htab_sz, hash_from_string, key_equals_string, no_op_free));	statsobj.UnlinkAllCounters(b->stats);	if (b->survivor_table != NULL) {		dynstats_destroyCountersIn(b, b->survivor_table, b->survivor_ctrs);	}	b->survivor_table = (b->table == NULL) ? survivor_table : b->table;	b->survivor_ctrs = b->ctrs;	b->table = new_table;	b->ctrs = NULL;finalize_it:	if (iRet != RS_RET_OK) {		LogError(errno, RS_RET_INTERNAL_ERROR, "error trying to evict "			"TTL-expired metrics of dyn-stats bucket named: %s", b->name);		if (new_table == NULL) {			LogError(errno, RS_RET_INTERNAL_ERROR, "error trying to "				"initialize hash-table for dyn-stats bucket named: %s", b->name);		} else {			assert(0); /* "can" not happen -- triggers Coverity CID 184307:			hashtable_destroy(new_table, 0);			We keep this as guard should code above change in the future */		}		if (b->table == NULL) {			if (survivor_table == NULL) {				LogError(errno, RS_RET_INTERNAL_ERROR, "error trying to initialize "				"ttl-survivor hash-table for dyn-stats bucket named: %s", b->name);			} else {				hashtable_destroy(survivor_table, 0);			}		}	}	RETiRet;}

// in case existing buffer too smallstatic rsRetVal _grow_buffer(protocolState_t *pState){	DEFiRet;	pState->buffer_size *= 2;	free(pState->encode_buffer);	pState->encode_buffer = (char *)malloc(pState->buffer_size);	CHKmalloc(pState->encode_buffer);finalize_it:	RETiRet;}

static rsRetValaddContextForReporting(json_object *to, const uchar* field_name, const uchar* value) {	json_object *v;	DEFiRet;	CHKmalloc(v = json_object_new_string((const char*) value));	json_object_object_add(to, (const char*) field_name, v);finalize_it:	RETiRet;}

addEntry(struct sockaddr_storage *const addr, dnscache_entry_t **const pEtry){	int r;	struct sockaddr_storage *keybuf = NULL;	dnscache_entry_t *etry = NULL;	DEFiRet;	pthread_rwlock_wrlock(&dnsCache.rwlock);	/* first check, if the entry was added in the mean time */	etry = findEntry(addr);	if(etry != NULL) {		FINALIZE;	}	/* entry still does not exist, so add it */	CHKmalloc(etry = malloc(sizeof(dnscache_entry_t)));	CHKmalloc(keybuf = malloc(sizeof(struct sockaddr_storage)));	CHKiRet(resolveAddr(addr, etry));	memcpy(&etry->addr, addr, SALEN((struct sockaddr*) addr));	etry->nUsed = 0;	memcpy(keybuf, addr, sizeof(struct sockaddr_storage));	r = hashtable_insert(dnsCache.ht, keybuf, etry);	keybuf = NULL;	if(r == 0) {		DBGPRINTF("dnscache: inserting element failed/n");	}finalize_it:	pthread_rwlock_unlock(&dnsCache.rwlock);	if(iRet == RS_RET_OK) {		*pEtry = etry;	} else {		free(keybuf);		free(etry); /* Note: sub-fields cannot be populated in this case */	}	RETiRet;}

/* Called by strmsrv on acceptance of a new session. This allocates our * own session data. * rgerhards, 2009-06-02 */static rsRetValOnSessConstructFinalize(void *pUsr){    diis_sess_t *pData;    DEFiRet;    assert(pUsr != NULL);    CHKmalloc(pData = calloc(1, sizeof(diis_sess_t)));    pData->state = DIIS_IN_HDR;    *((diis_sess_t**) pUsr) = pData;finalize_it:    RETiRet;}

rsRetVallookupBuildTable(lookup_t *pThis, struct json_object *jroot){	//struct json_object *jversion, *jnomatch, *jtype, *jtab;	struct json_object *jtab;	struct json_object *jrow, *jindex, *jvalue;	uint32_t i;	uint32_t maxStrSize;	DEFiRet;#if 0 // enable when we continue to work on this module	jversion = json_object_object_get(jroot, "version");	jnomatch = json_object_object_get(jroot, "nomatch");	jtype = json_object_object_get(jroot, "type");#endif	jtab = json_object_object_get(jroot, "table");	pThis->nmemb = json_object_array_length(jtab);	CHKmalloc(pThis->d.strtab = malloc(pThis->nmemb * sizeof(lookup_string_tab_etry_t)));	maxStrSize = 0;	for(i = 0 ; i < pThis->nmemb ; ++i) {		jrow = json_object_array_get_idx(jtab, i);		jindex = json_object_object_get(jrow, "index");		jvalue = json_object_object_get(jrow, "value");		CHKmalloc(pThis->d.strtab[i].key = (uchar*) strdup(json_object_get_string(jindex)));		CHKmalloc(pThis->d.strtab[i].val = (uchar*) strdup(json_object_get_string(jvalue)));		maxStrSize += ustrlen(pThis->d.strtab[i].val);	}	qsort(pThis->d.strtab, pThis->nmemb, sizeof(lookup_string_tab_etry_t), qs_arrcmp_strtab);dbgprintf("DDDD: table loaded (max size %u):/n", maxStrSize);for(i = 0 ; i < pThis->nmemb ; ++i)  dbgprintf("key: '%s', val: '%s'/n", pThis->d.strtab[i].key, pThis->d.strtab[i].val);finalize_it:	RETiRet;}