static void CPath_Finalize(CPath *_this) { /* assertions */ CASSERT((_this != 0)); /* finalize the path */ { /* get the point list */ CPointF *points = _this->points; /* get the type list */ CByte *types = _this->types; /* finalize, as needed */ if(points != 0) { /* reset the members */ _this->capacity = 0; _this->count = 0; _this->points = 0; _this->types = 0; _this->winding = 0; _this->newFigure = 1; _this->hasCurves = 0; /* free the point list */ CFree(points); /* free the type list */ CFree(types); } } }
static void CRegionCloner_FreeData(void *data) { /* assertions */ CASSERT((data != 0)); /* free the node members, as needed */ if(CRegionNode_IsOp(((CRegionNode *)data))) { /* get the operation node */ CRegionOp *op = ((CRegionOp *)data); /* free the left operand node, as needed */ if(op->left) { CRegionCloner_FreeData(op->left); } /* free the right operand node, as needed */ if(op->right) { CRegionCloner_FreeData(op->right); } } else if(((CRegionNode *)data)->type == CRegionType_Path) { /* get the path node */ CRegionPath *rp = ((CRegionPath *)data); /* free the point list */ CFree(rp->points); /* free the type list */ CFree(rp->types); } /* free the node */ CFree(data); }
CStatus CBitmapSurface_Create(CBitmapSurface **_this, CBitmap *image) { /* ensure we have a this pointer pointer */ CStatus_Require((_this != 0), CStatus_ArgumentNull); /* ensure we have an image pointer */ CStatus_Require((image != 0), CStatus_ArgumentNull); /* allocate the bitmap surface */ if(!(*_this = (CBitmapSurface *)CMalloc(sizeof(CBitmapSurface)))) { return CStatus_OutOfMemory; } /* initialize the bitmap surface */ if(!((*_this)->image = (CBitmap *)CImage_Reference((CImage *)image))) { CFree(*_this); *_this = 0; return CStatus_OutOfMemory; } /* initialize the base */ { /* declarations */ CStatus status; CSurface *surface; /* get this as a surface */ surface = (CSurface *)*_this; /* initialize the base */ status = CSurface_Initialize (surface, &CBitmapSurface_Class, 0, 0, image->width, image->height); /* handle base initialization failures */ if(status != CStatus_OK) { CBitmapSurface_Finalize(surface); CFree(*_this); *_this = 0; return status; } } /* return successfully */ return CStatus_OK; }
int mbbs_memalloc(MemType **buf, unsigned int *bufsz, unsigned int nobj, size_t objsz) { if (buf == (MemType **)0) return MEM_BADARG; if (bufsz == (unsigned int *)0) return MEM_BADARG; /* sufficient memory already allocated? */ if (*bufsz >= nobj) { if ((*buf != (MemType *)0) && (nobj != 0) && (objsz != 0)) MemZero(*buf, nobj * objsz); return MEM_SUCCESS; } if ((mem_maxallocsz != 0) && (mem_maxallocsz < (unsigned long)(nobj * objsz))) return MEM_OOB; /* free any existing memory */ if (*buf != (MemType *)0) CFree((MemType *)*buf); *bufsz = 0; /* allocate new memory */ if ((*buf = (MemType *)calloc((MemSizeType)nobj, (MemSizeType)objsz)) == (MemType *)0) return MEM_CALLOC; *bufsz = nobj; return MEM_SUCCESS; }
int mbbs_appendstr(char **field, char *str) /* User-callable routine. Append a string to the specified string field. Returns BS_SUCCESS, BS_BADARG or BS_MEMALLOC. */ { StrSizeType len; char *newfield; if (field == (char **) 0) return BS_BADARG; if ((str == (char *) 0) || (strlen(str) == 0)) return BS_SUCCESS; if (*field != (char *) 0) len= strlen(*field); else len= (StrSizeType) 0; len+= strlen(str)+1; if ((newfield= (char *) calloc((MemSizeType) len, sizeof(char))) == (char *) 0) return BS_MEMALLOC; if (*field != (char *) 0) (void) strcpy(newfield, *field); (void) strcat(newfield, str); if (*field != (char *) 0) CFree((MemType *) *field); *field= newfield; return BS_SUCCESS; }
/* Destroy this brush. */ CStatus CBrush_Destroy(CBrush **_this) { /* ensure we have a this pointer pointer */ CStatus_Require((_this != 0), CStatus_ArgumentNull); /* ensure we have a this pointer */ CStatus_Require(((*_this) != 0), CStatus_ArgumentNull); /* finalize the brush */ (*_this)->_class->Finalize(*_this); /* destroy the pattern, as needed */ if((*_this)->pattern.image != 0) { pixman_image_destroy((*_this)->pattern.image); (*_this)->pattern.image = 0; } /* dispose of the brush */ CFree(*_this); /* null the this pointer */ *_this = 0; /* return successfully */ return CStatus_OK; }
void GisFreeConfHandle(void *ptr) { ConfHandle *confHandle = (ConfHandle *)ptr; if (confHandle->h323EvtList) { FreeH323EvtQueue(&(confHandle->h323EvtList)); } if (confHandle->sipEvt) { SipFreeAppCallHandle(confHandle->sipEvt->data); free(confHandle->sipEvt); } GisFreeSetupQ931NodeId(confHandle); GisFreeEgressTokenNodeId(confHandle); if (confHandle->mediaRouted) nlm_freeMRvport(); // free the media routing license for this call (CFree(confCache))(ptr); }
int mbbs_freebsfmem(BSFile *bsf) { if (bsf == (BSFile *) 0) return BS_BADARG; if (bsf->bsf_srcfilenm != (char *) 0) { CFree((MemType *) bsf->bsf_srcfilenm); bsf->bsf_srcfilenm= (char *) 0; } if (bsf->bsf_log != (char *) 0) { CFree((MemType *) bsf->bsf_log); bsf->bsf_log= (char *) 0; } return BS_SUCCESS; }
/* Clone this path. */ CStatus CPath_Clone(CPath *_this, CPath **clone) { /* ensure we have a this pointer */ CStatus_Require((_this != 0), CStatus_ArgumentNull); /* ensure we have a clone pointer pointer */ CStatus_Require((clone != 0), CStatus_ArgumentNull); /* create the clone path */ CStatus_Check(CPath_Create(clone)); /* clone the members */ { /* declarations */ CPointF *tmpP; CByte *tmpT; /* get the count and capacity */ const CUInt32 count = _this->count; const CUInt32 capacity = ((count + 31) & ~31); /* allocate the clone points list */ if(!(tmpP = (CPointF *)CMalloc(capacity * sizeof(CPointF)))) { CPath_Destroy(clone); return CStatus_OutOfMemory; } /* allocate the clone types list */ if(!(tmpT = (CByte *)CMalloc(capacity * sizeof(CByte)))) { CFree(tmpP); CPath_Destroy(clone); return CStatus_OutOfMemory; } /* deep copy the points into the clone */ CMemCopy(tmpP, _this->points, (count * sizeof(CPointF))); /* deep copy the types into the clone */ CMemCopy(tmpT, _this->types, (count * sizeof(CByte))); /* set the clone members */ (*clone)->capacity = capacity; (*clone)->count = count; (*clone)->points = tmpP; (*clone)->types = tmpT; (*clone)->winding = _this->winding; (*clone)->newFigure = _this->newFigure; } /* return successfully */ return CStatus_OK; }
/* Get the points and types in this path. */ CStatus CPath_GetPathData(CPath *_this, CPointF **points, CByte **types, CUInt32 *count) { /* ensure we have a this pointer */ CStatus_Require((_this != 0), CStatus_ArgumentNull); /* ensure we have a point list pointer */ CStatus_Require((points != 0), CStatus_ArgumentNull); /* ensure we have a type list pointer */ CStatus_Require((types != 0), CStatus_ArgumentNull); /* ensure we have a count pointer */ CStatus_Require((count != 0), CStatus_ArgumentNull); /* get the path data */ { /* get the count and sizes */ const CUInt32 cnt = _this->count; const CUInt32 sizeP = (cnt * sizeof(CPointF)); const CUInt32 sizeT = (cnt * sizeof(CByte)); /* allocate the point list */ if(!(*points = (CPointF *)CMalloc(sizeP))) { *types = 0; *count = 0; return CStatus_OutOfMemory; } /* allocate the type list */ if(!(*types = (CByte *)CMalloc(sizeT))) { CFree(*points); *points = 0; *count = 0; return CStatus_OutOfMemory; } /* get the points */ CMemCopy(*points, _this->points, sizeP); /* get the types */ CMemCopy(*types, _this->types, sizeT); /* get the count */ *count = cnt; } /* return successfully */ return CStatus_OK; }
int mbbs_replacestr(char **field, char *str) /* User-callable routine. Copy a string to the specified string field. Returns BS_SUCCESS, BS_BADARG or BS_MEMALLOC. */ { StrSizeType olen, nlen; char *newfield; if (field == (char **) 0) return BS_BADARG; if ((str == (char *) 0) || (strlen(str) == 0)) { if (*field != (char *) 0) { CFree((MemType *) *field); *field= (char *) 0; } return BS_SUCCESS; } if (*field != (char *) 0) olen= strlen(*field)+1; else olen= 0; nlen= strlen(str)+1; if (nlen != olen) { if ((newfield= (char *) calloc((MemSizeType) nlen, sizeof(char))) == (char *) 0) return BS_MEMALLOC; (void) strcpy(newfield, str); if (*field != (char *) 0) CFree((MemType *) *field); *field= newfield; } else (void) strcpy(*field, str); return BS_SUCCESS; }
int Free(void * pointer) { struct alloc_head * mem_head=(struct alloc_head *)(pointer-sizeof(POINTER_LIST)); switch(mem_head->type) { case ALLOC_TEMP: return TFree(pointer); case ALLOC_STATIC: return SFree(pointer); case ALLOC_DYNAMIC: return DFree(pointer); case ALLOC_CACHE: return CFree(pointer,mem_head->flag); default: return -EINVAL; } }
/* Destroy a path. */ CStatus CPath_Destroy(CPath **_this) { /* ensure we have a this pointer pointer */ CStatus_Require((_this != 0), CStatus_ArgumentNull); /* ensure we have a this pointer */ CStatus_Require(((*_this) != 0), CStatus_ArgumentNull); /* finalize the path */ CPath_Finalize(*_this); /* free the path */ CFree(*_this); /* null the this pointer */ *_this = 0; /* return successfully */ return CStatus_OK; }
/* Flatten curves in this path into sequences of connected line segments. */ CStatus CPath_Flatten(CPath *_this, CMatrix *matrix, CFloat flatness) { /* ensure we have a this pointer */ CStatus_Require((_this != 0), CStatus_ArgumentNull); /* bail out now if there's nothing to flatten */ CStatus_Require((_this->count == 0), CStatus_OK); /* transform the path, as needed */ if(matrix != 0) { /* transform the points */ CStatus_Check (CMatrix_TransformPoints (matrix, _this->points, _this->count)); } /* bail out now if there's nothing more to do */ CStatus_Require((_this->hasCurves != 0), CStatus_OK); /* flatten the path */ { /* declarations */ CFlattener flattener; CPointF *points; CByte *types; CUInt32 count; CUInt32 capacity; CStatus status; /* initialize the flattener */ CFlattener_Initialize(&flattener); /* flatten the path */ status = CFlattener_Flatten (&flattener, _this->points, _this->types, _this->count, flatness); /* handle flattening failures */ if(status != CStatus_OK) { /* finalize the flattener */ CFlattener_Finalize(&flattener, 0, 0, 0, 0); /* return status */ return status; } /* finalize the flattener */ CFlattener_Finalize(&flattener, &points, &types, &count, &capacity); /* finalize the current path members */ CFree(_this->points); CFree(_this->types); /* initialize the members */ _this->points = points; _this->types = types; _this->count = count; _this->capacity = capacity; } /* return successfully */ return CStatus_OK; }
int mbbs_appendlog(BSFile *bsf, char **argv) /* User-callable routine. Appends the specified argument list to the file log with (i) a leading newline (if the current file log is non-empty), (ii) separating blank spaces between the strings of the argument list and (iii) a trailing semicolon. Returns BS_SUCCESS, BS_BADARCH, BS_BADARG or BS_MEMALLOC. */ { char **av; int firstarg; StrSizeType len; char *newlog; if (sizeof(int) < 4) return BS_BADARCH; if (bsf == (BSFile *) 0) return BS_BADARG; if (argv == (char **) 0) return BS_BADARG; for (av= argv, len= 0; *av != (char *) 0; av++) { if (strlen(*av) > 0) len+= strlen(*av)+1; } if (len == (StrSizeType) 0) return BS_SUCCESS; if ((bsf->bsf_log != (char *) 0) && (strlen(bsf->bsf_log) > 0)) len+= strlen(bsf->bsf_log); else len-= 1; len+= 2; if ((newlog= (char *) calloc((MemSizeType) len, sizeof(char))) == (char *) 0) return BS_MEMALLOC; if ((bsf->bsf_log != (char *) 0) && (strlen(bsf->bsf_log) > 0)) (void) strcpy(newlog, bsf->bsf_log); else (void) strcpy(newlog, ""); for (av= argv, firstarg= 1; *av != (char *) 0; av++) { if (strlen(*av) > 0) { if (firstarg) { if ((bsf->bsf_log != (char *) 0) && (strlen(bsf->bsf_log) > 0)) (void) strcat(newlog, "\n"); firstarg= 0; } else (void) strcat(newlog, " "); (void) strcat(newlog, *av); } } (void) strcat(newlog, ";"); if (bsf->bsf_log != (char *) 0) CFree((MemType *) bsf->bsf_log); bsf->bsf_log= newlog; return BS_SUCCESS; }
static CStatus CRegionCloner_Data(CRegionInterpreter *_this, CRegionNode *node, void **data) { /* assertions */ CASSERT((_this != 0)); CASSERT((node != 0)); CASSERT((data != 0)); /* set the data to the default */ *data = 0; /* clone the data node */ if(node->type == CRegionType_Path) { /* declarations */ CRegionPath *rp; /* get the count and sizes */ const CUInt32 count = ((CRegionPath *)node)->count; const CUInt32 sizeP = (count * sizeof(CPointF)); const CUInt32 sizeT = (count * sizeof(CByte)); /* create the path node */ if(!(CRegionPath_Alloc(rp))) { return CStatus_OutOfMemory; } /* initialize the path node */ rp->_base = *node; rp->count = count; rp->fillMode = ((CRegionPath *)node)->fillMode; /* allocate the point list */ if(!(rp->points = (CPointF *)CMalloc(sizeP))) { CFree(rp); return CStatus_OutOfMemory; } /* allocate the type list */ if(!(rp->types = (CByte *)CMalloc(sizeT))) { CFree(rp->points); CFree(rp); return CStatus_OutOfMemory; } /* copy the points */ CMemCopy(rp->points, ((CRegionPath *)node)->points, sizeP); /* copy the types */ CMemCopy(rp->types, ((CRegionPath *)node)->types, sizeT); /* set the clone */ *data = (void *)rp; } else if(node->type == CRegionType_Rectangle) { /* declarations */ CRegionRect *rr; /* create the rectangle node */ if(!(CRegionRect_Alloc(rr))) { return CStatus_OutOfMemory; } /* initialize the rectangle node */ rr->_base = *node; rr->rectangle = ((CRegionRect *)node)->rectangle; /* set the clone */ *data = (void *)rr; } else { /* declarations */ CRegionNode *rn; /* create the node */ if(!(CRegionNode_Alloc(rn))) { return CStatus_OutOfMemory; } /* initialize the node */ *rn = *node; /* set the clone */ *data = (void *)rn; } /* return successfully */ return CStatus_OK; }
/* Free H323RTPSet if its there */ void GisFreeCallHandle(void *ptr) { CallHandle *p = ptr; void *timerdata = NULL; SCC_EventBlock *evtPtr = NULL; if(p->max_call_duration_tid) { if(timerDeleteFromList(&localConfig.timerPrivate, p->max_call_duration_tid, &timerdata)) { if(timerdata) { free(timerdata); } } p->max_call_duration_tid = 0; } switch(p->handleType) { case SCC_eH323CallHandle: if (H323inChan(p)[2].dataTypeHandle > 0 ) { cmMeiEnter(UH323Globals()->hApp); freeNodeTree(UH323Globals()->hApp, H323inChan(p)[2].dataTypeHandle, 0); cmMeiExit(UH323Globals()->hApp); } if (H323inChan(p)[1].dataTypeHandle > 0 ) { cmMeiEnter(UH323Globals()->hApp); freeNodeTree(UH323Globals()->hApp, H323inChan(p)[1].dataTypeHandle, 0); cmMeiExit(UH323Globals()->hApp); } if (H323localSet(p)!= NULL) { (CFree(callCache))(H323localSet(p)); } if (H323remoteSet(p)!= NULL) { (CFree(callCache))(H323remoteSet(p)); } if(H323remoteTCSNodeId(p)) { cmMeiEnter(UH323Globals()->peerhApp); freeNodeTree(UH323Globals()->peerhApp, H323remoteTCSNodeId(p), 0); cmMeiExit(UH323Globals()->peerhApp); } if(H323tokenNodeId(p)>0) { cmMeiEnter(UH323Globals()->peerhApp); freeNodeTree(UH323Globals()->peerhApp, H323tokenNodeId(p), 0); cmMeiExit(UH323Globals()->peerhApp); } break; case SCC_eSipCallHandle: SipFreeSipCallHandle(SipCallHandle(p), sipCallCache->free); break; default: break; } if (p->realmInfo) { RealmInfoFree(p->realmInfo, callCache->malloc); } if(p->evtList) { SCC_EventBlock *evtPtr = NULL; while((evtPtr = listDeleteFirstItem(p->evtList))) { H323FreeEvData((H323EventData *)(evtPtr->data)); free(evtPtr); } listDestroy(p->evtList); } while ((evtPtr = listDeleteFirstItem(p->fcevtList))) { if (evtPtr->callDetails.callType == CAP_SIP) { SipFreeAppCallHandle(evtPtr->data); free(evtPtr); } else { H323FreeEvent(evtPtr); } } if(p->fcevtList) { listDestroy(p->fcevtList); } if (p->conf_id) (CFree(callCache))(p->conf_id); if (p->incoming_conf_id) (CFree(callCache))(p->incoming_conf_id); if (p->custID) (CFree(callCache))(p->custID); if (p->tg) (CFree(callCache))(p->tg); if (p->destTg) (CFree(callCache))(p->destTg); if (p->dtgInfo) (CFree(callCache))(p->dtgInfo); if (p->srccrname) (CFree(callCache))(p->srccrname); if (p->destcrname) (CFree(callCache))(p->destcrname); if (p->transitcrname) (CFree(callCache))(p->transitcrname); if (p->transRouteNumber) (CFree(callCache))(p->transRouteNumber); if(p->ogprefix) (CFree(callCache))(p->ogprefix); if (p->vpnName) { free(p->vpnName); } if (p->zone) { free(p->zone); } if (p->cpname) { free(p->cpname); } GwFreeRejectList(p->destRejectList, CFree(callCache)); p->destRejectList = NULL; SipFreeRemotecontactList(p->remotecontact_list); p->remotecontact_list = NULL; CdrArgsFree(p->prevcdr); (CFree(callCache))(p); }