kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-10-22 12:52:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

core: Don't allow free to mean ast_free (and malloc, etc..).

Browse Source 
This gets rid of most old libc free/malloc/realloc and replaces them
with ast_free and friends. When compiling with MALLOC_DEBUG you'll
notice it when you're mistakenly using one of the libc variants. For
the legacy cases you can define WRAP_LIBC_MALLOC before including
asterisk.h.

Even better would be if the errors were also enabled when compiling
without MALLOC_DEBUG, but that's a slightly more invasive header
file change.

Those compiling addons/format_mp3 will need to rerun
./contrib/scripts/get_mp3_source.sh.

ASTERISK-24348 #related
Review: https://reviewboard.asterisk.org/r/4015/


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@423978 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Walter Doekes
2014-09-26 14:41:38 +00:00
parent b8c1130ed1
commit 37179a2b1f
44 changed files with 375 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
addons/ooh323c/src/context.c
View File

@@ -15,6 +15,7 @@
*****************************************************************************/
#include "asterisk.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "ooasn1.h"
#include <stdlib.h>
@@ -157,11 +158,11 @@ int setPERBuffer (OOCTXT* pctxt,
OOCTXT* newContext ()
{
/* OOCTXT* pctxt = (OOCTXT*) ASN1CRTMALLOC0 (sizeof(OOCTXT)); */
OOCTXT* pctxt = (OOCTXT*) malloc (sizeof(OOCTXT));
OOCTXT* pctxt = ast_malloc(sizeof(OOCTXT));
if (pctxt) {
if (initContext(pctxt) != ASN_OK) {
/* ASN1CRTFREE0 (pctxt); */
free(pctxt);
ast_free(pctxt);
pctxt = 0;
}
pctxt->flags |= ASN1DYNCTXT;

5
addons/ooh323c/src/errmgmt.c
View File

@@ -18,6 +18,7 @@
#include "asterisk.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include <stdlib.h>
#include "ooasn1.h"
@@ -89,7 +90,7 @@ int errAddStrParm (ASN1ErrInfo* pErrInfo, const char* errprm_p)
#if defined(_NO_THREADS) || !defined(_NO_MALLOC)
if (pErrInfo->parmcnt < ASN_K_MAXERRP) {
/* char* tmpstr = (char*) ASN1CRTMALLOC0 (strlen(errprm_p)+1); */
char* tmpstr = (char*) malloc (strlen(errprm_p)+1);
char* tmpstr = ast_malloc(strlen(errprm_p) + 1);
strcpy (tmpstr, errprm_p);
pErrInfo->parms[pErrInfo->parmcnt] = tmpstr;
pErrInfo->parmcnt++;
@@ -118,7 +119,7 @@ void errFreeParms (ASN1ErrInfo* pErrInfo)
for (i = 0; i < pErrInfo->parmcnt; i++)
/* ASN1CRTFREE0 ((char*)pErrInfo->parms[i]); */
free ((char*)pErrInfo->parms[i]);
ast_free((char*)pErrInfo->parms[i]);
#endif
pErrInfo->parmcnt = 0;

34
addons/ooh323c/src/memheap.c
View File

@@ -15,6 +15,7 @@
*****************************************************************************/
#include "asterisk.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include <stdlib.h>
#include "memheap.h"
@@ -176,13 +177,13 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
/* allocate raw block */
data = malloc (nbytes);
data = ast_malloc(nbytes);
if (data == NULL) {
return NULL;
}
pMemLink = memHeapAddBlock (ppMemLink, data, RTMEMMALLOC | RTMEMRAW);
if (pMemLink == 0) {
free (data);
ast_free(data);
return NULL;
}
/* save size of the RAW memory block behind the pMemLink */
@@ -333,7 +334,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
((((ASN1UINT)dataUnits) * 8u) + sizeof (OSMemBlk));
}
pmem = (ASN1OCTET*) malloc (allocSize + sizeof (OSMemLink));
pmem = (ASN1OCTET*) ast_malloc(allocSize + sizeof (OSMemLink));
if (0 != pmem) {
OSMemElemDescr* pElem;
@@ -357,7 +358,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
if (memHeapAddBlock (ppMemLink, pMemBlk, RTMEMSTD | RTMEMLINK) == 0)
{
free (pmem);
ast_free(pmem);
ast_mutex_unlock(&pMemHeap->pLock);
return NULL;
}
@@ -437,12 +438,12 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
if ((pMemLink->blockType & RTMEMLINK) &&
(pMemLink->blockType & RTMEMMALLOC))
{
free (pMemLink);
ast_free(pMemLink);
}
else {
if (pMemLink->blockType & RTMEMMALLOC)
free (pMemLink->pMemBlk);
free (pMemLink);
ast_free(pMemLink->pMemBlk);
ast_free(pMemLink);
}
ast_mutex_unlock(&pMemHeap->pLock);
return;
@@ -553,11 +554,11 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
FILLFREEMEM (pMemBlk->plink, sizeof (*pMemBlk->plink));
FILLFREEMEM (pMemBlk->data, (pMemBlk->nunits * 8u));
free (pMemBlk->plink);
ast_free(pMemBlk->plink);
if (!(blockType & RTMEMLINK)) {
FILLFREEMEM (pMemBlk, sizeof (*pMemBlk));
free (pMemBlk);
ast_free(pMemBlk);
}
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x was freed\n",
pMemBlk);
@@ -748,7 +749,7 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
pMemLink->pMemBlk == mem_p)
{
if (pMemLink->blockType & RTMEMMALLOC) {
void *newMemBlk = realloc (pMemLink->pMemBlk, nbytes_);
void *newMemBlk = ast_realloc(pMemLink->pMemBlk, nbytes_);
if (newMemBlk == 0)
return 0;
pMemLink->pMemBlk = newMemBlk;
@@ -1038,8 +1039,8 @@ void memHeapFreeAll (void** ppvMemHeap)
if (((pMemLink2->blockType & RTMEMSTD) ||
(pMemLink2->blockType & RTMEMMALLOC)) &&
!(pMemLink2->blockType & RTMEMLINK))
free (pMemLink2->pMemBlk);
free (pMemLink2);
ast_free(pMemLink2->pMemBlk);
ast_free(pMemLink2);
}
}
ast_mutex_unlock(&pMemHeap->pLock);
@@ -1075,12 +1076,12 @@ void memHeapRelease (void** ppvMemHeap)
pMemLink2 = pMemLink;
pMemLink = pMemLink2->pnext;
free (pMemLink2);
ast_free(pMemLink2);
}
if ((*ppMemHeap)->flags & RT_MH_FREEHEAPDESC) {
ast_mutex_destroy(&pMemHeap->pLock);
free (*ppMemHeap);
ast_free(*ppMemHeap);
}
*ppMemHeap = 0;
}
@@ -1215,8 +1216,7 @@ static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
if (blockType & RTMEMLINK)
pMemLink = (OSMemLink*) (((ASN1OCTET*)pMemBlk) - sizeof (OSMemLink));
else {
pMemLink = (OSMemLink*) malloc (
sizeof(OSMemLink) + sizeof (int));
pMemLink = ast_malloc(sizeof(OSMemLink) + sizeof(int));
if (pMemLink == 0) return 0;
/* An extra integer is necessary to save a size of a RAW memory block
to perform rtMemRealloc through malloc/memcpy/free */
@@ -1339,7 +1339,7 @@ int memHeapCreate (void** ppvMemHeap)
OSMemHeap* pMemHeap;
if (ppvMemHeap == 0) return ASN_E_INVPARAM;
pMemHeap = (OSMemHeap*) malloc (sizeof (OSMemHeap));
pMemHeap = ast_malloc(sizeof (OSMemHeap));
if (pMemHeap == NULL) return ASN_E_NOMEM;
memset (pMemHeap, 0, sizeof (OSMemHeap));
pMemHeap->defBlkSize = g_defBlkSize;

5
addons/ooh323c/src/ooCalls.c
View File

@@ -16,6 +16,7 @@
#include "asterisk.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "ootrace.h"
#include "ootypes.h"
@@ -366,13 +367,13 @@ int ooCleanCall(OOH323CallData *call)
if ((call->rtpMask->inuse) == 0) {
regfree(&call->rtpMask->regex);
ast_mutex_destroy(&call->rtpMask->lock);
free(call->rtpMask);
ast_free(call->rtpMask);
}
}
if ((pctxt = call->msgctxt) != NULL) {
freeContext(pctxt);
free(pctxt);
ast_free(pctxt);
call->msgctxt = NULL;
}
/* May !!!! Fix it !! */

18
addons/ooh323c/src/ooCmdChannel.c
View File

@@ -57,13 +57,13 @@ int ooCreateCallCmdConnection(OOH323CallData* call)
OOTRACEINFO2("INFO: create cmd connect for call: %lx\n", call);
call->CmdChanLock = calloc(1, sizeof(ast_mutex_t));
call->CmdChanLock = ast_calloc(1, sizeof(ast_mutex_t));
ast_mutex_init(call->CmdChanLock);
if ((ret = socketpair(PF_LOCAL, SOCK_STREAM, 0, thePipe)) == -1) {
ast_mutex_destroy(call->CmdChanLock);
free(call->CmdChanLock);
ast_free(call->CmdChanLock);
call->CmdChanLock = NULL;
return OO_FAILED;
}
@@ -94,7 +94,7 @@ int ooCloseCallCmdConnection(OOH323CallData* call)
call->CmdChan = 0;
ast_mutex_unlock(call->CmdChanLock);
ast_mutex_destroy(call->CmdChanLock);
free(call->CmdChanLock);
ast_free(call->CmdChanLock);
call->CmdChanLock = NULL;
return OO_OK;
@@ -267,9 +267,9 @@ int ooReadAndProcessStackCommand()
default: OOTRACEERR1("ERROR:Unknown command\n");
}
}
if(cmd.param1) free(cmd.param1);
if(cmd.param2) free(cmd.param2);
if(cmd.param3) free(cmd.param3);
ast_free(cmd.param1);
ast_free(cmd.param2);
ast_free(cmd.param3);
}
@@ -302,7 +302,7 @@ int ooReadAndProcessCallStackCommand(OOH323CallData* call)
bPoint += sizeof(OOStackCommand);
if (cmd.plen1 > 0) {
cmd.param1 = malloc(cmd.plen1 + 1);
cmd.param1 = ast_malloc(cmd.plen1 + 1);
if (!cmd.param1)
return OO_FAILED;
memset(cmd.param1, 0, cmd.plen1 + 1);
@@ -311,7 +311,7 @@ int ooReadAndProcessCallStackCommand(OOH323CallData* call)
}
if (cmd.plen2 > 0) {
cmd.param2 = malloc(cmd.plen2 + 1);
cmd.param2 = ast_malloc(cmd.plen2 + 1);
if (!cmd.param2)
return OO_FAILED;
memset(cmd.param2, 0, cmd.plen2 + 1);
@@ -320,7 +320,7 @@ int ooReadAndProcessCallStackCommand(OOH323CallData* call)
}
if (cmd.plen3 > 0) {
cmd.param3 = malloc(cmd.plen3 + 1);
cmd.param3 = ast_malloc(cmd.plen3 + 1);
if (!cmd.param3)
return OO_FAILED;
memset(cmd.param3, 0, cmd.plen3 + 1);

148
addons/ooh323c/src/ooStackCmds.c
View File

@@ -79,7 +79,7 @@ OOStkCmdStat ooMakeCall
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_MAKECALL;
cmd.param1 = (void*) malloc(strlen(dest)+1);
cmd.param1 = ast_malloc(strlen(dest)+1);
if(!cmd.param1)
{
return OO_STKCMD_MEMERR;
@@ -87,10 +87,10 @@ OOStkCmdStat ooMakeCall
strcpy((char*)cmd.param1, dest);
cmd.param2 = (void*) malloc(strlen(callToken)+1);
cmd.param2 = ast_malloc(strlen(callToken)+1);
if(!cmd.param2)
{
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_MEMERR;
}
@@ -101,11 +101,11 @@ OOStkCmdStat ooMakeCall
cmd.param3 = 0;
}
else {
cmd.param3 = (void*) malloc(sizeof(ooCallOptions));
cmd.param3 = ast_malloc(sizeof(ooCallOptions));
if(!cmd.param3)
{
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_MEMERR;
}
memcpy((void*)cmd.param3, opts, sizeof(ooCallOptions));
@@ -113,9 +113,9 @@ OOStkCmdStat ooMakeCall
if(ooWriteStackCommand(&cmd) != OO_OK)
{
free(cmd.param1);
free(cmd.param2);
if(cmd.param3) free(cmd.param3);
ast_free(cmd.param1);
ast_free(cmd.param2);
if(cmd.param3) ast_free(cmd.param3);
return OO_STKCMD_WRITEERR;
}
@@ -149,7 +149,7 @@ OOStkCmdStat ooRunCall
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_MAKECALL;
cmd.param1 = (void*) malloc(strlen(dest)+1);
cmd.param1 = ast_malloc(strlen(dest)+1);
if(!cmd.param1)
{
return OO_STKCMD_MEMERR;
@@ -158,10 +158,10 @@ OOStkCmdStat ooRunCall
cmd.plen1 = strlen(dest);
cmd.param2 = (void*) malloc(strlen(callToken)+1);
cmd.param2 = ast_malloc(strlen(callToken)+1);
if(!cmd.param2)
{
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_MEMERR;
}
@@ -173,11 +173,11 @@ OOStkCmdStat ooRunCall
cmd.param3 = 0;
}
else {
cmd.param3 = (void*) malloc(sizeof(ooCallOptions));
cmd.param3 = ast_malloc(sizeof(ooCallOptions));
if(!cmd.param3)
{
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_MEMERR;
}
memcpy((void*)cmd.param3, opts, sizeof(ooCallOptions));
@@ -186,16 +186,16 @@ OOStkCmdStat ooRunCall
if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
{
free(cmd.param1);
free(cmd.param2);
if(cmd.param3) free(cmd.param3);
ast_free(cmd.param1);
ast_free(cmd.param2);
if(cmd.param3) ast_free(cmd.param3);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
free(cmd.param2);
if(cmd.param3) free(cmd.param3);
ast_free(cmd.param1);
ast_free(cmd.param2);
if(cmd.param3) ast_free(cmd.param3);
return OO_STKCMD_SUCCESS;
}
@@ -223,7 +223,7 @@ OOStkCmdStat ooManualRingback(const char *callToken)
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_MANUALRINGBACK;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param1 = ast_malloc(strlen(callToken)+1);
if(!cmd.param1)
{
return OO_STKCMD_MEMERR;
@@ -233,11 +233,11 @@ OOStkCmdStat ooManualRingback(const char *callToken)
if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
{
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_SUCCESS;
}
@@ -267,7 +267,7 @@ OOStkCmdStat ooManualProgress(const char *callToken)
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_MANUALPROGRESS;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param1 = ast_malloc(strlen(callToken)+1);
if(!cmd.param1)
{
return OO_STKCMD_MEMERR;
@@ -277,11 +277,11 @@ OOStkCmdStat ooManualProgress(const char *callToken)
if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
{
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_SUCCESS;
}
@@ -309,7 +309,7 @@ OOStkCmdStat ooAnswerCall(const char *callToken)
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_ANSCALL;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param1 = ast_malloc(strlen(callToken)+1);
if(!cmd.param1)
{
return OO_STKCMD_MEMERR;
@@ -319,11 +319,11 @@ OOStkCmdStat ooAnswerCall(const char *callToken)
if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
{
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
ast_free(cmd.param1);
return OO_STKCMD_SUCCESS;
}
@@ -350,12 +350,12 @@ OOStkCmdStat ooForwardCall(const char* callToken, char *dest)
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_FWDCALL;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param2 = (void*) malloc(strlen(dest)+1);
cmd.param1 = ast_malloc(strlen(callToken)+1);
cmd.param2 = ast_malloc(strlen(dest)+1);
if(!cmd.param1 || !cmd.param2)
{
if(cmd.param1) free(cmd.param1); /* Release memory */
if(cmd.param2) free(cmd.param2);
if(cmd.param1) ast_free(cmd.param1); /* Release memory */
if(cmd.param2) ast_free(cmd.param2);
return OO_STKCMD_MEMERR;
}
strcpy((char*)cmd.param1, callToken);
@@ -365,12 +365,12 @@ OOStkCmdStat ooForwardCall(const char* callToken, char *dest)
if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
{
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_SUCCESS;
}
@@ -399,14 +399,14 @@ OOStkCmdStat ooHangCall(const char* callToken, OOCallClearReason reason, int q93
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_HANGCALL;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param2 = (void*) malloc(sizeof(OOCallClearReason));
cmd.param3 = (void*) malloc(sizeof(int));
cmd.param1 = ast_malloc(strlen(callToken)+1);
cmd.param2 = ast_malloc(sizeof(OOCallClearReason));
cmd.param3 = ast_malloc(sizeof(int));
if(!cmd.param1 || !cmd.param2 || !cmd.param3)
{
if(cmd.param1) free(cmd.param1); /* Release memory */
if(cmd.param2) free(cmd.param2);
if(cmd.param3) free(cmd.param3);
if(cmd.param1) ast_free(cmd.param1); /* Release memory */
if(cmd.param2) ast_free(cmd.param2);
if(cmd.param3) ast_free(cmd.param3);
return OO_STKCMD_MEMERR;
}
strcpy((char*)cmd.param1, callToken);
@@ -418,14 +418,14 @@ OOStkCmdStat ooHangCall(const char* callToken, OOCallClearReason reason, int q93
if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
{
free(cmd.param1);
free(cmd.param2);
free(cmd.param3);
ast_free(cmd.param1);
ast_free(cmd.param2);
ast_free(cmd.param3);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
free(cmd.param2);
free(cmd.param3);
ast_free(cmd.param1);
ast_free(cmd.param2);
ast_free(cmd.param3);
return OO_STKCMD_SUCCESS;
}
@@ -473,12 +473,12 @@ OOStkCmdStat ooSendDTMFDigit(const char *callToken, const char* dtmf)
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_SENDDIGIT;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param2 = (void*) malloc(strlen(dtmf)+1);
cmd.param1 = ast_malloc(strlen(callToken)+1);
cmd.param2 = ast_malloc(strlen(dtmf)+1);
if(!cmd.param1 || !cmd.param2)
{
if(cmd.param1) free(cmd.param1); /* Release memory */
if(cmd.param2) free(cmd.param2);
if(cmd.param1) ast_free(cmd.param1); /* Release memory */
if(cmd.param2) ast_free(cmd.param2);
return OO_STKCMD_MEMERR;
}
strcpy((char*)cmd.param1, callToken);
@@ -488,12 +488,12 @@ OOStkCmdStat ooSendDTMFDigit(const char *callToken, const char* dtmf)
if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
{
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_SUCCESS;
}
@@ -521,12 +521,12 @@ OOStkCmdStat ooSetANI(const char *callToken, const char* ani)
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_SETANI;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param2 = (void*) malloc(strlen(ani)+1);
cmd.param1 = ast_malloc(strlen(callToken)+1);
cmd.param2 = ast_malloc(strlen(ani)+1);
if(!cmd.param1 || !cmd.param2)
{
if(cmd.param1) free(cmd.param1); /* Release memory */
if(cmd.param2) free(cmd.param2);
if(cmd.param1) ast_free(cmd.param1); /* Release memory */
if(cmd.param2) ast_free(cmd.param2);
return OO_STKCMD_MEMERR;
}
strcpy((char*)cmd.param1, callToken);
@@ -536,12 +536,12 @@ OOStkCmdStat ooSetANI(const char *callToken, const char* ani)
if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
{
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_SUCCESS;
}
@@ -631,12 +631,12 @@ OOStkCmdStat ooRequestChangeMode(const char *callToken, int isT38Mode)
memset(&cmd, 0, sizeof(OOStackCommand));
cmd.type = OO_CMD_REQMODE;
cmd.param1 = (void*) malloc(strlen(callToken)+1);
cmd.param2 = (void*) malloc(sizeof(int));
cmd.param1 = ast_malloc(strlen(callToken)+1);
cmd.param2 = ast_malloc(sizeof(int));
if(!cmd.param1 || !cmd.param2)
{
if(cmd.param1) free(cmd.param1); /* Release memory */
if(cmd.param2) free(cmd.param2);
ast_free(cmd.param1); /* Release memory */
ast_free(cmd.param2);
return OO_STKCMD_MEMERR;
}
strcpy((char*)cmd.param1, callToken);
@@ -646,12 +646,12 @@ OOStkCmdStat ooRequestChangeMode(const char *callToken, int isT38Mode)
if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
{
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_WRITEERR;
}
free(cmd.param1);
free(cmd.param2);
ast_free(cmd.param1);
ast_free(cmd.param2);
return OO_STKCMD_SUCCESS;
}

2
addons/ooh323c/src/oochannels.c
View File

@@ -961,7 +961,7 @@ int ooMonitorCallChannels(OOH323CallData *call)
ast_cond_destroy(&call->gkWait);
pctxt = call->pctxt;
freeContext(pctxt);
free(pctxt);
ast_free(pctxt);
return OO_OK;
}

9
addons/ooh323c/src/printHandler.c
View File

@@ -19,6 +19,7 @@
*/
#include "asterisk.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include <stdlib.h>
/* #ifdef HAVE_MALLOC_H
@@ -126,10 +127,10 @@ void printBitStrValue (ASN1UINT numbits, const ASN1OCTET* data)
indent ();
OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
#else
char* s = (char*)malloc(numbits + 8);
char* s = ast_malloc(numbits + 8);
indent ();
OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8));
free(s);
ast_free(s);
#endif
}
@@ -141,10 +142,10 @@ void printOctStrValue (ASN1UINT numocts, const ASN1OCTET* data)
indent ();
OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
#else
char* s = (char*)malloc(bufsiz);
char* s = ast_malloc(bufsiz);
indent ();
OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz));
free(s);
ast_free(s);
#endif
}