1 /*************************************************************************/ 2 /* module: some helper functions */ 3 /* */ 4 /* file: mgrutil.c */ 5 /* target system: all */ 6 /* target OS: all */ 7 /* */ 8 /* Description: */ 9 /*************************************************************************/ 10 11 /* 12 * Copyright Notice 13 * Copyright (c) Ericsson, IBM, Lotus, Matsushita Communication 14 * Industrial Co., Ltd., Motorola, Nokia, Openwave Systems, Inc., 15 * Palm, Inc., Psion, Starfish Software, Symbian, Ltd. (2001). 16 * All Rights Reserved. 17 * Implementation of all or part of any Specification may require 18 * licenses under third party intellectual property rights, 19 * including without limitation, patent rights (such a third party 20 * may or may not be a Supporter). The Sponsors of the Specification 21 * are not responsible and shall not be held responsible in any 22 * manner for identifying or failing to identify any or all such 23 * third party intellectual property rights. 24 * 25 * THIS DOCUMENT AND THE INFORMATION CONTAINED HEREIN ARE PROVIDED 26 * ON AN "AS IS" BASIS WITHOUT WARRANTY OF ANY KIND AND ERICSSON, IBM, 27 * LOTUS, MATSUSHITA COMMUNICATION INDUSTRIAL CO. LTD, MOTOROLA, 28 * NOKIA, PALM INC., PSION, STARFISH SOFTWARE AND ALL OTHER SYNCML 29 * SPONSORS DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 30 * BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION 31 * HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF 32 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 33 * SHALL ERICSSON, IBM, LOTUS, MATSUSHITA COMMUNICATION INDUSTRIAL CO., 34 * LTD, MOTOROLA, NOKIA, PALM INC., PSION, STARFISH SOFTWARE OR ANY 35 * OTHER SYNCML SPONSOR BE LIABLE TO ANY PARTY FOR ANY LOSS OF 36 * PROFITS, LOSS OF BUSINESS, LOSS OF USE OF DATA, INTERRUPTION OF 37 * BUSINESS, OR FOR DIRECT, INDIRECT, SPECIAL OR EXEMPLARY, INCIDENTAL, 38 * PUNITIVE OR CONSEQUENTIAL DAMAGES OF ANY KIND IN CONNECTION WITH 39 * THIS DOCUMENT OR THE INFORMATION CONTAINED HEREIN, EVEN IF ADVISED 40 * OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE. 41 * 42 * The above notice and this paragraph must be included on all copies 43 * of this document that are made. 44 * 45 */ 46 47 /************************************************************************* 48 * Definitions 49 *************************************************************************/ 50 51 52 /* Include Headers */ 53 #include <sml.h> 54 #include <smldtd.h> 55 #include <smldef.h> 56 #include <smlerr.h> 57 #include <smlmetinfdtd.h> 58 #include <smldevinfdtd.h> 59 #include <smldmtnddtd.h> 60 #include "libmem.h" 61 #include "libstr.h" 62 #include "liblock.h" 63 #include "mgr.h" 64 #include "mgrutil.h" 65 66 67 /************************************************************************* 68 * Exported SyncML API functions 69 *************************************************************************/ 70 71 /** 72 * FUNCTION: smlFreeProtoElement 73 * 74 * frees all allocated memory of a smlProtoElement 75 * 76 * IN: VoidPtr_t 77 * Element to free 78 * 79 * RETURN: Ret_t 80 * Return Code 81 */ 82 SML_API Ret_t smlFreeProtoElement(VoidPtr_t pProtoElement) 83 { 84 if (! pProtoElement) 85 return(SML_ERR_OK); 86 87 switch (((SmlUnknownProtoElementPtr_t)pProtoElement)->elementType) { 88 89 case SML_PE_HEADER: 90 smlFreeSyncHdr((SmlSyncHdrPtr_t)pProtoElement); 91 break; 92 93 case SML_PE_SYNC_START: 94 smlFreeSync((SmlSyncPtr_t)pProtoElement); 95 break; 96 97 case SML_PE_ADD: 98 case SML_PE_COPY: 99 case SML_PE_REPLACE: 100 case SML_PE_DELETE: 101 case SML_PE_GENERIC: 102 smlFreeGeneric((SmlGenericCmdPtr_t)pProtoElement); 103 break; 104 105 case SML_PE_ALERT: 106 smlFreeAlert((SmlAlertPtr_t)pProtoElement); 107 break; 108 109 case SML_PE_ATOMIC_START: 110 case SML_PE_SEQUENCE_START: 111 case SML_PE_CMD_GROUP: 112 smlFreeAtomic((SmlAtomicPtr_t)pProtoElement); 113 break; 114 115 #if (defined EXEC_SEND || defined EXEC_RECEIVE) 116 case SML_PE_EXEC: 117 smlFreeExec((SmlExecPtr_t)pProtoElement); 118 break; 119 #endif 120 121 case SML_PE_PUT: 122 case SML_PE_GET: 123 case SML_PE_PUT_GET: 124 smlFreeGetPut((SmlPutPtr_t)pProtoElement); 125 break; 126 127 case SML_PE_MAP: 128 smlFreeMap((SmlMapPtr_t)pProtoElement); 129 break; 130 131 case SML_PE_RESULTS: 132 smlFreeResults((SmlResultsPtr_t)pProtoElement); 133 break; 134 135 #if (defined SEARCH_SEND || defined SEARCH_RECEIVE) 136 case SML_PE_SEARCH: 137 smlFreeSearch((SmlSearchPtr_t)pProtoElement); 138 break; 139 #endif 140 case SML_PE_STATUS: 141 smlFreeStatus((SmlStatusPtr_t)pProtoElement); 142 break; 143 144 default: 145 return(SML_ERR_A_UTI_UNKNOWN_PROTO_ELEMENT); 146 } 147 148 return(SML_ERR_OK); 149 } 150 151 152 /** 153 * FUNCTION: smlFreePcdata 154 * 155 * frees the Memory of an allocated Pcdata memory object 156 * 157 * IN: SmlPcdataPtr_t 158 * A Pointer to a PcData structure, which should be freed 159 * 160 * RETURN: --- 161 * 162 */ 163 SML_API void smlFreePcdata(SmlPcdataPtr_t pPcdata) 164 { 165 if (! pPcdata) 166 return; 167 168 if (pPcdata->contentType == SML_PCDATA_EXTENSION) { 169 switch ((int)pPcdata->extension) { 170 #ifdef __USE_METINF__ 171 case SML_EXT_METINF: 172 smlFreeMetinfMetinf(pPcdata->content); 173 smlLibFree(pPcdata); 174 break; 175 #endif 176 #ifdef __USE_DEVINF__ 177 case SML_EXT_DEVINF: 178 smlFreeDevInfDevInf(pPcdata->content); 179 smlLibFree(pPcdata); 180 break; 181 #endif 182 #ifdef __USE_DMTND__ 183 case SML_EXT_DMTND: 184 smlFreeDmTnd(pPcdata->content); 185 smlLibFree(pPcdata); 186 break; 187 #endif 188 } 189 return; 190 } 191 192 if (pPcdata->content) 193 smlLibFree(pPcdata->content); 194 195 smlLibFree(pPcdata); 196 } 197 198 199 SML_API void smlFreePcdataList(SmlPcdataListPtr_t list) { 200 if (!list) return; 201 smlFreePcdataList(list->next); 202 smlFreePcdata(list->data); 203 smlLibFree(list); 204 return; 205 } 206 207 #ifdef __USE_METINF__ 208 /** Subfunctions to smlFreePcdata, to freeup MetaInf DTD structures **/ 209 SML_API void smlFreeMetinfMetinf(SmlMetInfMetInfPtr_t data) { 210 if (!data) return; 211 smlFreePcdata(data->format); 212 smlFreePcdata(data->type); 213 smlFreePcdata(data->mark); 214 smlFreePcdata(data->size); 215 smlFreePcdata(data->version); 216 smlFreePcdata(data->nextnonce); 217 smlFreePcdata(data->maxmsgsize); 218 /* SCTSTK - 18/03/2002, S.H. 2002-04-05 : SyncML 1.1 */ 219 smlFreePcdata(data->maxobjsize); 220 smlFreeMetinfAnchor(data->anchor); 221 smlFreeMetinfMem(data->mem); 222 smlFreePcdataList(data->emi); 223 smlLibFree(data); 224 return; 225 } 226 SML_API void smlFreeMetinfAnchor(SmlMetInfAnchorPtr_t data) { 227 if (!data) return; 228 smlFreePcdata(data->last); 229 smlFreePcdata(data->next); 230 smlLibFree(data); 231 return; 232 } 233 SML_API void smlFreeMetinfMem(SmlMetInfMemPtr_t data) { 234 if (!data) return; 235 smlFreePcdata(data->shared); 236 smlFreePcdata(data->free); 237 smlFreePcdata(data->freeid); 238 smlLibFree(data); 239 return; 240 } 241 #endif 242 243 #ifdef __USE_DEVINF__ 244 /** Subfunctions to smlFreePcdata, to freeup DevInf DTD structures **/ 245 SML_API void smlFreeDevInfDevInf(SmlDevInfDevInfPtr_t data) { 246 if (!data) return; 247 smlFreePcdata(data->verdtd); 248 smlFreePcdata(data->man); 249 smlFreePcdata(data->mod); 250 smlFreePcdata(data->oem); 251 smlFreePcdata(data->fwv); 252 smlFreePcdata(data->hwv); 253 smlFreePcdata(data->swv); 254 smlFreePcdata(data->devid); 255 smlFreePcdata(data->devtyp); 256 smlFreeDevInfDatastoreList(data->datastore); 257 smlFreeDevInfExtList(data->ext); 258 smlFreeDevInfCtcapList(data->ctcap); 259 smlLibFree(data); 260 } 261 SML_API void smlFreeDevInfDatastore(SmlDevInfDatastorePtr_t data) { 262 if (!data) return; 263 smlFreePcdata(data->sourceref); 264 smlFreePcdata(data->displayname); 265 smlFreePcdata(data->maxguidsize); 266 smlFreeDevInfXmit(data->rxpref); 267 smlFreeDevInfXmit(data->txpref); 268 smlFreeDevInfXmitList(data->rx); 269 smlFreeDevInfXmitList(data->tx); 270 smlFreeDevInfDSMem(data->dsmem); 271 smlFreeDevInfSynccap(data->synccap); 272 smlLibFree(data); 273 return; 274 } 275 SML_API void smlFreeDevInfDatastoreList(SmlDevInfDatastoreListPtr_t data) { 276 if (!data) return; 277 smlFreeDevInfDatastore(data->data); 278 smlFreeDevInfDatastoreList(data->next); 279 smlLibFree(data); 280 return; 281 } 282 SML_API void smlFreeDevInfXmitList(SmlDevInfXmitListPtr_t data) { 283 if (!data) return; 284 smlFreeDevInfXmit(data->data); 285 smlFreeDevInfXmitList(data->next); 286 smlLibFree(data); 287 } 288 SML_API void smlFreeDevInfXmit(SmlDevInfXmitPtr_t data) { 289 if (!data) return; 290 smlFreePcdata(data->cttype); 291 smlFreePcdata(data->verct); 292 smlLibFree(data); 293 } 294 SML_API void smlFreeDevInfDSMem(SmlDevInfDSMemPtr_t data) { 295 if (!data) return; 296 // %%%luz:2003-04-28: this is now a flag! smlFreePcdata(data->shared); 297 smlFreePcdata(data->maxmem); 298 smlFreePcdata(data->maxid); 299 smlLibFree(data); 300 } 301 SML_API void smlFreeDevInfSynccap(SmlDevInfSyncCapPtr_t data) { 302 if (!data) return; 303 smlFreePcdataList(data->synctype); 304 smlLibFree(data); 305 } 306 SML_API void smlFreeDevInfExt(SmlDevInfExtPtr_t data) { 307 if (!data) return; 308 smlFreePcdata(data->xnam); 309 smlFreePcdataList(data->xval); 310 smlLibFree(data); 311 } 312 SML_API void smlFreeDevInfExtList(SmlDevInfExtListPtr_t data) { 313 if (!data) return; 314 smlFreeDevInfExt(data->data); 315 smlFreeDevInfExtList(data->next); 316 smlLibFree(data); 317 } 318 SML_API void smlFreeDevInfCTData(SmlDevInfCTDataPtr_t data) { 319 if (!data) return; 320 smlFreePcdata(data->name); 321 smlFreePcdata(data->dname); 322 smlFreePcdataList(data->valenum); 323 smlFreePcdata(data->datatype); 324 smlFreePcdata(data->size); 325 smlLibFree(data); 326 } 327 SML_API void smlFreeDevInfCTDataProp(SmlDevInfCTDataPropPtr_t data) { 328 if (!data) return; 329 smlFreeDevInfCTData(data->prop); 330 smlFreeDevInfCTDataList(data->param); 331 smlLibFree(data); 332 } 333 334 SML_API void smlFreeDevInfCTDataList(SmlDevInfCTDataListPtr_t data) { 335 if (!data) return; 336 smlFreeDevInfCTData(data->data); 337 smlFreeDevInfCTDataList(data->next); 338 smlLibFree(data); 339 } 340 341 SML_API void smlFreeDevInfCTDataPropList(SmlDevInfCTDataPropListPtr_t data) { 342 if (!data) return; 343 smlFreeDevInfCTDataProp(data->data); 344 smlFreeDevInfCTDataPropList(data->next); 345 smlLibFree(data); 346 } 347 348 SML_API void smlFreeDevInfCTCap(SmlDevInfCTCapPtr_t data) { 349 if (!data) return; 350 smlFreePcdata(data->cttype); 351 smlFreeDevInfCTDataPropList(data->prop); 352 smlLibFree(data); 353 } 354 355 SML_API void smlFreeDevInfCtcapList(SmlDevInfCtcapListPtr_t data) { 356 if (!data) return; 357 358 smlFreeDevInfCTCap(data->data); 359 smlFreeDevInfCtcapList(data->next); 360 smlLibFree(data); 361 } 362 #endif 363 364 #ifdef __USE_DMTND__ 365 /** Subfunctions to smlFreePcdata, to freeup DM TND DTD structures **/ 366 SML_API void smlFreeDmTndFormat(SmlDmTndFormatPtr_t data) { 367 if (!data) return; 368 smlFreePcdata(data->value); 369 smlLibFree(data); 370 } 371 372 SML_API void smlFreeDmTndType(SmlDmTndTypePtr_t data) { 373 if (!data) return; 374 smlFreePcdata(data->mime); 375 smlFreePcdata(data->ddfname); 376 smlLibFree(data); 377 } 378 379 SML_API void smlFreeDmTndDFElement(SmlDmTndDFElementPtr_t data) { 380 if (!data) return; 381 smlFreePcdata(data->value); 382 smlLibFree(data); 383 } 384 385 SML_API void smlFreeDmTndRTProps(SmlDmTndRTPropsPtr_t data) { 386 if (!data) return; 387 smlFreePcdata(data->acl); 388 smlFreeDmTndFormat(data->format); 389 smlFreePcdata(data->name); 390 smlFreePcdata(data->size); 391 smlFreePcdata(data->title); 392 smlFreePcdata(data->tstamp); 393 smlFreeDmTndType(data->type); 394 smlFreePcdata(data->verno); 395 smlLibFree(data); 396 } 397 398 SML_API void smlFreeDmTndDFProps(SmlDmTndDFPropsPtr_t data) { 399 if (!data) return; 400 smlFreeDmTndDFElement(data->accesstype); 401 smlFreePcdata(data->defaultvalue); 402 smlFreePcdata(data->description); 403 smlFreeDmTndFormat(data->dfformat); 404 smlFreeDmTndDFElement(data->occurrence); 405 smlFreeDmTndDFElement(data->scope); 406 smlFreePcdata(data->dftitle); 407 smlFreeDmTndType(data->dftype); 408 smlFreeDmTndDFElement(data->casesense); 409 smlLibFree(data); 410 } 411 412 SML_API void smlFreeDmTndNodeList(SmlDmTndNodeListPtr_t data); 413 414 SML_API void smlFreeDmTndNode(SmlDmTndNodePtr_t data) { 415 if (!data) return; 416 smlFreePcdata(data->nodename); 417 smlFreePcdata(data->path); 418 smlFreeDmTndRTProps(data->rtprops); 419 smlFreeDmTndDFProps(data->dfprops); 420 smlFreePcdata(data->value); 421 smlFreeDmTndNodeList(data->nodelist); 422 smlLibFree(data); 423 } 424 425 SML_API void smlFreeDmTndNodeList(SmlDmTndNodeListPtr_t data) { 426 if (!data) return; 427 smlFreeDmTndNode(data->node); 428 smlFreeDmTndNodeList(data->next); 429 smlLibFree(data); 430 return; 431 } 432 433 SML_API void smlFreeDmTnd(SmlDmTndPtr_t data) { 434 if (!data) return; 435 smlFreePcdata(data->verdtd); 436 smlFreePcdata(data->man); 437 smlFreePcdata(data->mod); 438 smlFreeDmTndNodeList(data->nodelist); 439 smlLibFree(data); 440 return; 441 } 442 #endif 443 444 /************************************************************************* 445 * Exported SyncML API functions (FULL-SIZE TOOLKIT ONLY) 446 *************************************************************************/ 447 448 #ifndef __SML_LITE__ /* these API calls are NOT included in the Toolkit lite version */ 449 450 /** 451 * FUNCTION: smlGetFreeBuffer 452 * 453 * Return amount of unused Workspace memory 454 * 455 * RETURN: MemSize_t 456 * Amount of unused Workspace memory 457 * 458 */ 459 SML_API MemSize_t smlGetFreeBuffer(InstanceID_t id) 460 { 461 /* Definitions */ 462 MemSize_t freeMem=0; 463 464 #ifdef NOWSM 465 InstanceInfoPtr_t pInstanceInfo = (InstanceInfoPtr_t)id; // ID is the instance info pointer 466 if (pInstanceInfo==NULL) return 0; // no buffer if no instance there 467 freeMem = 468 (pInstanceInfo->instanceBuffer+pInstanceInfo->instanceBufSiz) - // end of buffer 469 pInstanceInfo->writePointer; // current write pointer 470 #else 471 /* ask the Workspace Buffer */ 472 LOCKTOOLKIT("smlGetFreeBuffer"); 473 wsmGetFreeSize(id, &freeMem); 474 RELEASETOOLKIT("smlGetFreeBuffer"); 475 #endif 476 477 return (MemSize_t)freeMem; 478 } 479 480 481 /** 482 * FUNCTION: smlString2Pcdata 483 * 484 * copy a string into a Pcdata structure 485 * 486 * IN: String_t 487 * Input String 488 * 489 * RETURN: SmlPcdataPtr_t 490 * A Pointer to a PcData structure 491 * 492 */ 493 SML_API SmlPcdataPtr_t smlString2Pcdata(String_t str) 494 { 495 /* Definitions */ 496 SmlPcdataPtr_t pcdata; 497 498 /* Invalid Input */ 499 if (! str) 500 return NULL; 501 502 /* Allocate the PcData Structure */ 503 pcdata = (SmlPcdataPtr_t)smlLibMalloc((MemSize_t)sizeof(SmlPcdata_t)); 504 if (! pcdata) 505 return NULL; 506 smlLibMemset (pcdata, 0, (MemSize_t)sizeof(SmlPcdata_t)); 507 508 /* Set the PcData Structure */ 509 pcdata->contentType = SML_PCDATA_STRING; 510 pcdata->length = smlLibStrlen( str ); 511 pcdata->content = (VoidPtr_t)smlLibStrdup(str); 512 513 return pcdata; 514 } 515 516 517 /** 518 * FUNCTION: smlPcdata2String 519 * 520 * copy a Pcdata structure into a string 521 * 522 * IN: SmlPcdataPtr_t 523 * A Pointer to a PcData structure 524 * RETURN: String_t 525 * Input String 526 * 527 */ 528 SML_API String_t smlPcdata2String(SmlPcdataPtr_t pcdata) 529 { 530 /* Definitions */ 531 String_t str; 532 533 /* Invalid Input */ 534 if (! pcdata) 535 return NULL; 536 537 /* Allocate the String */ 538 str = (String_t)smlLibMalloc((MemSize_t)(pcdata->length+1)); 539 if (str == NULL) 540 return NULL; 541 542 /* Copy the string into the allocated data structure */ 543 smlLibMemcpy((MemPtr_t)str, (MemPtr_t)pcdata->content, pcdata->length); 544 *(str + pcdata->length) = '\0'; 545 546 return str; 547 } 548 549 550 /** 551 * FUNCTION: smlPcdataDup 552 * 553 * Duplicates a Pcdata memory object 554 * 555 * IN: SmlPcdataPtr_t 556 * A Pointer to the original PcData structure 557 * 558 * RETURN: SmlPcdataPtr_t 559 * A Pointer to the copy of the PcData structure 560 * 561 */ 562 SML_API SmlPcdataPtr_t smlPcdataDup(SmlPcdataPtr_t pcdata) 563 { 564 /* Definitions */ 565 SmlPcdataPtr_t newPcdata; 566 567 /* Invalid Input */ 568 if (! pcdata) 569 return NULL; 570 571 /* Allocate the new pcdata memory object */ 572 newPcdata = (SmlPcdataPtr_t)smlLibMalloc((MemSize_t)sizeof(SmlPcdata_t)); 573 if (! newPcdata) 574 return NULL; 575 smlLibMemset (newPcdata, 0, (MemSize_t)sizeof(SmlPcdata_t)); 576 577 /* Set the PcData Structure */ 578 newPcdata->contentType = pcdata->contentType; 579 newPcdata->length = pcdata->length; 580 newPcdata->content =(VoidPtr_t)smlLibMalloc((MemSize_t)pcdata->length+1); 581 if (newPcdata->content ==NULL) 582 { 583 smlLibFree(newPcdata->content); 584 smlLibFree(newPcdata); 585 return NULL; 586 } 587 smlLibMemset(newPcdata->content, 0, (MemSize_t)((pcdata->length)+1)); 588 smlLibMemcpy(newPcdata->content, pcdata->content, (MemSize_t)pcdata->length); 589 590 return newPcdata; 591 } 592 593 #endif 594 595 SML_API void smlFreeSyncHdr(SmlSyncHdrPtr_t pSyncHdr) 596 { 597 if (! pSyncHdr) 598 return; 599 600 smlFreePcdata(pSyncHdr->version); 601 smlFreePcdata(pSyncHdr->proto); 602 smlFreePcdata(pSyncHdr->sessionID); 603 smlFreePcdata(pSyncHdr->msgID); 604 smlFreePcdata(pSyncHdr->respURI); 605 smlFreePcdata(pSyncHdr->meta); 606 607 smlFreeSourceTargetPtr(pSyncHdr->source); 608 smlFreeSourceTargetPtr(pSyncHdr->target); 609 610 smlFreeCredPtr(pSyncHdr->cred); 611 612 smlLibFree(pSyncHdr); 613 } 614 615 616 SML_API void smlFreeSync(SmlSyncPtr_t pSync) 617 { 618 if (! pSync) 619 return; 620 621 smlFreePcdata(pSync->cmdID); 622 smlFreePcdata(pSync->meta); 623 624 smlFreeSourceTargetPtr(pSync->source); 625 smlFreeSourceTargetPtr(pSync->target); 626 627 smlFreeCredPtr(pSync->cred); 628 629 smlLibFree(pSync); 630 } 631 632 633 SML_API void smlFreeGeneric(SmlGenericCmdPtr_t pGenericCmd) 634 { 635 if (! pGenericCmd) 636 return; 637 638 smlFreePcdata(pGenericCmd->cmdID); 639 smlFreePcdata(pGenericCmd->meta); 640 641 smlFreeCredPtr(pGenericCmd->cred); 642 643 smlFreeItemList(pGenericCmd->itemList); 644 645 smlLibFree(pGenericCmd); 646 } 647 648 649 SML_API void smlFreeAlert(SmlAlertPtr_t pAlert) 650 { 651 if (! pAlert) 652 return; 653 654 smlFreePcdata(pAlert->cmdID); 655 smlFreePcdata(pAlert->data); 656 657 smlFreeCredPtr(pAlert->cred); 658 659 smlFreeItemList(pAlert->itemList); 660 smlFreePcdata(pAlert->correlator); 661 662 smlLibFree(pAlert); 663 } 664 665 666 SML_API void smlFreeAtomic(SmlAtomicPtr_t pAtomic) 667 { 668 if (! pAtomic) 669 return; 670 671 smlFreePcdata(pAtomic->cmdID); 672 smlFreePcdata(pAtomic->meta); 673 674 smlLibFree(pAtomic); 675 } 676 677 #if (defined EXEC_SEND || defined EXEC_RECEIVE) 678 679 SML_API void smlFreeExec(SmlExecPtr_t pExec) 680 { 681 if (! pExec) 682 return; 683 684 smlFreePcdata(pExec->cmdID); 685 686 smlFreeCredPtr(pExec->cred); 687 688 smlFreeItemPtr(pExec->item); 689 690 smlFreePcdata(pExec->correlator); 691 692 smlLibFree(pExec); 693 } 694 695 #endif 696 697 SML_API void smlFreeGetPut(SmlPutPtr_t pGetPut) 698 { 699 if (! pGetPut) 700 return; 701 702 smlFreePcdata(pGetPut->cmdID); 703 smlFreePcdata(pGetPut->meta); 704 smlFreePcdata(pGetPut->lang); 705 706 smlFreeCredPtr(pGetPut->cred); 707 708 smlFreeItemList(pGetPut->itemList); 709 710 smlLibFree(pGetPut); 711 } 712 713 714 SML_API void smlFreeMap(SmlMapPtr_t pMap) 715 { 716 if (! pMap) 717 return; 718 719 smlFreePcdata(pMap->cmdID); 720 smlFreePcdata(pMap->meta); 721 722 smlFreeCredPtr(pMap->cred); 723 724 smlFreeSourceTargetPtr(pMap->source); 725 smlFreeSourceTargetPtr(pMap->target); 726 727 smlFreeMapItemList(pMap->mapItemList); 728 729 smlLibFree(pMap); 730 } 731 732 733 SML_API void smlFreeResults(SmlResultsPtr_t pResults) 734 { 735 if (! pResults) 736 return; 737 738 smlFreePcdata(pResults->cmdID); 739 smlFreePcdata(pResults->msgRef); 740 smlFreePcdata(pResults->cmdRef); 741 smlFreePcdata(pResults->meta); 742 smlFreePcdata(pResults->targetRef); 743 smlFreePcdata(pResults->sourceRef); 744 745 smlFreeItemList(pResults->itemList); 746 747 smlLibFree(pResults); 748 } 749 750 #if (defined SEARCH_SEND || defined SEARCH_RECEIVE) 751 752 SML_API void smlFreeSearch(SmlSearchPtr_t pSearch) 753 { 754 if (! pSearch) 755 return; 756 757 smlFreePcdata(pSearch->cmdID); 758 smlFreePcdata(pSearch->lang); 759 smlFreePcdata(pSearch->meta); 760 smlFreePcdata(pSearch->data); 761 762 smlFreeCredPtr(pSearch->cred); 763 764 smlFreeSourceTargetPtr(pSearch->target); 765 766 smlFreeSourceList(pSearch->sourceList); 767 768 smlLibFree(pSearch); 769 } 770 771 #endif 772 773 SML_API void smlFreeStatus(SmlStatusPtr_t pStatus) 774 { 775 if (! pStatus) 776 return; 777 778 smlFreePcdata(pStatus->cmdID); 779 smlFreePcdata(pStatus->msgRef); 780 smlFreePcdata(pStatus->cmdRef); 781 smlFreePcdata(pStatus->cmd); 782 smlFreePcdata(pStatus->data); 783 784 smlFreeCredPtr(pStatus->cred); 785 smlFreeChalPtr(pStatus->chal); 786 787 smlFreeTargetRefList(pStatus->targetRefList); 788 smlFreeSourceRefList(pStatus->sourceRefList); 789 790 smlFreeItemList(pStatus->itemList); 791 792 smlLibFree(pStatus); 793 } 794 795 796 SML_API void smlFreeCredPtr(SmlCredPtr_t pCred) 797 { 798 if (! pCred) 799 return; 800 801 smlFreePcdata(pCred->meta); 802 smlFreePcdata(pCred->data); 803 804 smlLibFree(pCred); 805 } 806 807 808 SML_API void smlFreeChalPtr(SmlChalPtr_t pChal) 809 { 810 if (! pChal) 811 return; 812 813 smlFreePcdata(pChal->meta); 814 815 smlLibFree(pChal); 816 } 817 818 819 SML_API void smlFreeSourceTargetPtr(SmlSourcePtr_t pSourceTarget) 820 { 821 if (! pSourceTarget) 822 return; 823 824 smlFreePcdata(pSourceTarget->locURI); 825 smlFreePcdata(pSourceTarget->locName); 826 827 smlLibFree(pSourceTarget); 828 } 829 830 831 SML_API void smlFreeSourceList(SmlSourceListPtr_t pSourceList) 832 { 833 SmlSourceListPtr_t pTmp; 834 835 while (pSourceList) { 836 pTmp = pSourceList->next; 837 smlFreeSourceTargetPtr(pSourceList->source); 838 smlLibFree(pSourceList); 839 pSourceList = pTmp; 840 } 841 } 842 843 844 SML_API void smlFreeSourceRefList(SmlSourceRefListPtr_t pSourceRefList) 845 { 846 SmlSourceRefListPtr_t pTmp; 847 848 while (pSourceRefList) { 849 pTmp = pSourceRefList->next; 850 smlFreePcdata(pSourceRefList->sourceRef); 851 smlLibFree(pSourceRefList); 852 pSourceRefList = pTmp; 853 } 854 } 855 856 857 SML_API void smlFreeTargetRefList(SmlTargetRefListPtr_t pTargetRefList) 858 { 859 SmlTargetRefListPtr_t pTmp; 860 861 while (pTargetRefList) { 862 pTmp = pTargetRefList->next; 863 smlFreePcdata(pTargetRefList->targetRef); 864 smlLibFree(pTargetRefList); 865 pTargetRefList = pTmp; 866 } 867 } 868 869 870 SML_API void smlFreeItemPtr(SmlItemPtr_t pItem) 871 { 872 if (! pItem) 873 return; 874 875 smlFreePcdata(pItem->meta); 876 smlFreePcdata(pItem->data); 877 878 smlFreeSourceTargetPtr(pItem->source); 879 smlFreeSourceTargetPtr(pItem->target); 880 881 smlLibFree(pItem); 882 } 883 884 885 SML_API void smlFreeItemList(SmlItemListPtr_t pItemList) 886 { 887 SmlItemListPtr_t pTmp; 888 889 while (pItemList) { 890 pTmp = pItemList->next; 891 smlFreeItemPtr(pItemList->item); 892 smlLibFree(pItemList); 893 pItemList = pTmp; 894 } 895 } 896 897 898 SML_API void smlFreeMapItemPtr(SmlMapItemPtr_t pMapItem) 899 { 900 if (! pMapItem) 901 return; 902 903 smlFreeSourceTargetPtr(pMapItem->source); 904 smlFreeSourceTargetPtr(pMapItem->target); 905 906 smlLibFree(pMapItem); 907 } 908 909 910 SML_API void smlFreeMapItemList(SmlMapItemListPtr_t pMapItemList) 911 { 912 SmlMapItemListPtr_t pTmp; 913 914 while (pMapItemList) { 915 pTmp = pMapItemList->next; 916 smlFreeMapItemPtr(pMapItemList->mapItem); 917 smlLibFree(pMapItemList); 918 pMapItemList = pTmp; 919 } 920 } 921 922 #ifdef __USE_ALLOCFUNCS__ 923 /* Helperfunctions, that allocate and preset SyncML C structs */ 924 SML_API SmlPcdataPtr_t smlAllocPcdata() { 925 SmlPcdataPtr_t p = (SmlPcdataPtr_t)smlLibMalloc(sizeof(SmlPcdata_t)); 926 if (p == NULL) return NULL; 927 smlLibMemset(p, 0, sizeof(SmlPcdata_t)); 928 return p; 929 } 930 931 SML_API SmlPcdataListPtr_t smlAllocPcdataList() { 932 SmlPcdataListPtr_t p = (SmlPcdataListPtr_t)smlLibMalloc(sizeof(SmlPcdataList_t)); 933 if (p == NULL) return NULL; 934 smlLibMemset(p, 0, sizeof(SmlPcdataList_t)); 935 p->data = smlAllocPcdata(); 936 if (p->data == NULL) { 937 smlFreePcdataList(p); 938 return NULL; 939 } 940 return p; 941 } 942 943 SML_API SmlChalPtr_t smlAllocChal() { 944 SmlChalPtr_t p = (SmlChalPtr_t)smlLibMalloc(sizeof(SmlChal_t)); 945 if (p == NULL) return NULL; 946 smlLibMemset(p, 0, sizeof(SmlChal_t)); 947 p->meta = smlAllocPcdata(); 948 if (p->meta == NULL) { 949 smlFreeChalPtr(p); 950 return NULL; 951 } 952 return p; 953 } 954 955 SML_API SmlCredPtr_t smlAllocCred() { 956 SmlCredPtr_t p = (SmlCredPtr_t)smlLibMalloc(sizeof(SmlCred_t)); 957 if (p == NULL) return NULL; 958 smlLibMemset(p, 0, sizeof(SmlCred_t)); 959 p->data = smlAllocPcdata(); 960 if (p->data == NULL) { 961 smlFreeCredPtr(p); 962 return NULL; 963 } 964 return p; 965 } 966 967 SML_API SmlSourcePtr_t smlAllocSource() { 968 SmlSourcePtr_t p = (SmlSourcePtr_t)smlLibMalloc(sizeof(SmlSource_t)); 969 if (p == NULL) return NULL; 970 smlLibMemset(p, 0, sizeof(SmlSource_t)); 971 p->locURI = smlAllocPcdata(); 972 if (p->locURI == NULL) { 973 smlFreeSourceTargetPtr(p); 974 return NULL; 975 } 976 return p; 977 } 978 979 SML_API SmlTargetPtr_t smlAllocTarget() { 980 return smlAllocSource(); 981 } 982 983 SML_API SmlSourceListPtr_t smlAllocSourceList() { 984 SmlSourceListPtr_t p = (SmlSourceListPtr_t)smlLibMalloc(sizeof(SmlSourceList_t)); 985 if (p == NULL) return NULL; 986 smlLibMemset(p, 0, sizeof(SmlSourceList_t)); 987 p->source = smlAllocSource(); 988 if (p->source == NULL) { 989 smlFreeSourceList(p); 990 return NULL; 991 } 992 return p; 993 } 994 995 996 SML_API SmlSyncHdrPtr_t smlAllocSyncHdr() { 997 SmlSyncHdrPtr_t p = (SmlSyncHdrPtr_t)smlLibMalloc(sizeof(SmlSyncHdr_t)); 998 if (p == NULL) return NULL; 999 smlLibMemset(p, 0, sizeof(SmlSyncHdr_t)); 1000 p->elementType = SML_PE_HEADER; 1001 p->version = smlAllocPcdata(); 1002 if (p->version == NULL) { 1003 smlFreeSyncHdr(p); 1004 return NULL; 1005 } 1006 p->proto = smlAllocPcdata(); 1007 if (p->proto == NULL) { 1008 smlFreeSyncHdr(p); 1009 return NULL; 1010 } 1011 p->sessionID = smlAllocPcdata(); 1012 if (p->sessionID == NULL) { 1013 smlFreeSyncHdr(p); 1014 return NULL; 1015 } 1016 p->msgID = smlAllocPcdata(); 1017 if (p->msgID == NULL) { 1018 smlFreeSyncHdr(p); 1019 return NULL; 1020 } 1021 p->target = smlAllocTarget(); 1022 if (p->target == NULL) { 1023 smlFreeSyncHdr(p); 1024 return NULL; 1025 } 1026 p->source = smlAllocSource(); 1027 if (p->source == NULL) { 1028 smlFreeSyncHdr(p); 1029 return NULL; 1030 } 1031 return p; 1032 } 1033 1034 SML_API SmlItemPtr_t smlAllocItem() { 1035 SmlItemPtr_t p = (SmlItemPtr_t)smlLibMalloc(sizeof(SmlItem_t)); 1036 if (p == NULL) return NULL; 1037 smlLibMemset(p, 0, sizeof(SmlItem_t)); 1038 return p; 1039 } 1040 1041 SML_API SmlItemListPtr_t smlAllocItemList() { 1042 SmlItemListPtr_t p = (SmlItemListPtr_t)smlLibMalloc(sizeof(SmlItemList_t)); 1043 if (p == NULL) return NULL; 1044 smlLibMemset(p, 0, sizeof(SmlItemList_t)); 1045 p->item = smlAllocItem(); 1046 if (p->item == NULL) { 1047 smlFreeItemList(p); 1048 return NULL; 1049 } 1050 return p; 1051 } 1052 1053 SML_API SmlGenericCmdPtr_t smlAllocGeneric() { 1054 SmlGenericCmdPtr_t p = (SmlGenericCmdPtr_t)smlLibMalloc(sizeof(SmlGenericCmd_t)); 1055 if (p == NULL) return NULL; 1056 smlLibMemset(p, 0, sizeof(SmlGenericCmd_t)); 1057 p->elementType = SML_PE_GENERIC; 1058 p->cmdID = smlAllocPcdata(); 1059 if (p->cmdID == NULL) { 1060 smlFreeGeneric(p); 1061 return NULL; 1062 } 1063 p->itemList = smlAllocItemList(); 1064 if (p->itemList == NULL) { 1065 smlFreeGeneric(p); 1066 return NULL; 1067 } 1068 return p; 1069 } 1070 1071 SML_API SmlAddPtr_t smlAllocAdd() { 1072 SmlAddPtr_t p = smlAllocGeneric(); 1073 if (p == NULL) return p; 1074 p->elementType = SML_PE_ADD; 1075 return p; 1076 } 1077 1078 SML_API SmlCopyPtr_t smlAllocCopy() { 1079 SmlCopyPtr_t p = smlAllocGeneric(); 1080 if (p == NULL) return p; 1081 p->elementType = SML_PE_COPY; 1082 return p; 1083 } 1084 1085 SML_API SmlReplacePtr_t smlAllocReplace() { 1086 SmlReplacePtr_t p = smlAllocGeneric(); 1087 if (p == NULL) return p; 1088 p->elementType = SML_PE_REPLACE; 1089 return p; 1090 } 1091 1092 SML_API SmlDeletePtr_t smlAllocDelete() { 1093 SmlDeletePtr_t p = smlAllocGeneric(); 1094 if (p == NULL) return p; 1095 p->elementType = SML_PE_DELETE; 1096 return p; 1097 } 1098 1099 SML_API SmlAlertPtr_t smlAllocAlert() { 1100 SmlAlertPtr_t p = (SmlAlertPtr_t)smlLibMalloc(sizeof(SmlAlert_t)); 1101 if (p == NULL) return NULL; 1102 smlLibMemset(p, 0, sizeof(SmlAlert_t)); 1103 p->elementType = SML_PE_ALERT; 1104 p->cmdID = smlAllocPcdata(); 1105 if (p->cmdID == NULL) { 1106 smlFreeAlert(p); 1107 return NULL; 1108 } 1109 p->itemList = smlAllocItemList(); 1110 if (p->itemList == NULL) { 1111 smlFreeAlert(p); 1112 return NULL; 1113 } 1114 return p; 1115 } 1116 1117 SML_API SmlAtomicPtr_t smlAllocAtomic() { 1118 SmlAtomicPtr_t p = (SmlAtomicPtr_t)smlLibMalloc(sizeof(SmlAtomic_t)); 1119 if (p == NULL) return NULL; 1120 smlLibMemset(p, 0, sizeof(SmlAtomic_t)); 1121 p->elementType = SML_PE_ATOMIC_START; 1122 p->cmdID = smlAllocPcdata(); 1123 if (p->cmdID == NULL) { 1124 smlFreeAtomic(p); 1125 return NULL; 1126 } 1127 return p; 1128 } 1129 1130 SML_API SmlSequencePtr_t smlAllocSequence() { 1131 SmlSequencePtr_t p = smlAllocAtomic(); 1132 if (p == NULL) return NULL; 1133 p->elementType = SML_PE_SEQUENCE_START; 1134 return p; 1135 } 1136 1137 SML_API SmlSyncPtr_t smlAllocSync() { 1138 SmlSyncPtr_t p = (SmlSyncPtr_t)smlLibMalloc(sizeof(SmlSync_t)); 1139 if (p == NULL) return NULL; 1140 smlLibMemset(p, 0, sizeof(SmlSync_t)); 1141 p->elementType = SML_PE_SYNC_START; 1142 p->cmdID = smlAllocPcdata(); 1143 if (p->cmdID == NULL) { 1144 smlFreeSync(p); 1145 return NULL; 1146 } 1147 return p; 1148 } 1149 1150 #if defined(EXEC_SEND) || defined(EXEC_RECEIVE) 1151 SML_API SmlExecPtr_t smlAllocExec() { 1152 SmlExecPtr_t p = (SmlExecPtr_t)smlLibMalloc(sizeof(SmlExec_t)); 1153 if (p == NULL) return NULL; 1154 smlLibMemset(p, 0, sizeof(SmlExec_t)); 1155 p->elementType = SML_PE_EXEC; 1156 p->cmdID = smlAllocPcdata(); 1157 if (p->cmdID == NULL) { 1158 smlFreeExec(p); 1159 return NULL; 1160 } 1161 p->item = smlAllocItem(); 1162 if (p->item == NULL) { 1163 smlFreeExec(p); 1164 return NULL; 1165 } 1166 return p; 1167 } 1168 #endif 1169 1170 SML_API SmlGetPtr_t smlAllocGet() { 1171 SmlGetPtr_t p = (SmlGetPtr_t)smlLibMalloc(sizeof(SmlGet_t)); 1172 if (p == NULL) return NULL; 1173 smlLibMemset(p, 0, sizeof(SmlGet_t)); 1174 p->elementType = SML_PE_GET; 1175 p->cmdID = smlAllocPcdata(); 1176 if (p->cmdID == NULL) { 1177 smlFreeGetPut(p); 1178 return NULL; 1179 } 1180 p->itemList = smlAllocItemList(); 1181 if (p->itemList == NULL) { 1182 smlFreeGetPut(p); 1183 return NULL; 1184 } 1185 return p; 1186 } 1187 1188 SML_API SmlPutPtr_t smlAllocPut() { 1189 SmlPutPtr_t p = smlAllocGet(); 1190 if (p == NULL) return NULL; 1191 p->elementType = SML_PE_PUT; 1192 return p; 1193 } 1194 1195 SML_API SmlMapItemPtr_t smlAllocMapItem() { 1196 SmlMapItemPtr_t p = (SmlMapItemPtr_t)smlLibMalloc(sizeof(SmlMapItem_t)); 1197 if (p == 0) return NULL; 1198 smlLibMemset(p, 0, sizeof(SmlMapItem_t)); 1199 p->target = smlAllocTarget(); 1200 if (p->target == NULL) { 1201 smlFreeMapItemPtr(p); 1202 return NULL; 1203 } 1204 p->source = smlAllocSource(); 1205 if (p->source == NULL) { 1206 smlFreeMapItemPtr(p); 1207 return NULL; 1208 } 1209 return p; 1210 } 1211 1212 SML_API SmlMapItemListPtr_t smlAllocMapItemList() { 1213 SmlMapItemListPtr_t p = (SmlMapItemListPtr_t)smlLibMalloc(sizeof(SmlMapItemList_t)); 1214 if (p == 0) return NULL; 1215 smlLibMemset(p, 0, sizeof(SmlMapItemList_t)); 1216 p->mapItem = smlAllocMapItem(); 1217 if (p->mapItem == NULL) { 1218 smlFreeMapItemList(p); 1219 return NULL; 1220 } 1221 return p; 1222 } 1223 1224 SML_API SmlMapPtr_t smlAllocMap() { 1225 SmlMapPtr_t p = (SmlMapPtr_t)smlLibMalloc(sizeof(SmlMap_t)); 1226 if (p == 0) return NULL; 1227 smlLibMemset(p, 0, sizeof(SmlMap_t)); 1228 p->elementType = SML_PE_MAP; 1229 p->cmdID = smlAllocPcdata(); 1230 if (p->cmdID == NULL) { 1231 smlFreeMap(p); 1232 return NULL; 1233 } 1234 p->target = smlAllocTarget(); 1235 if (p->target == NULL) { 1236 smlFreeMap(p); 1237 return NULL; 1238 } 1239 p->source = smlAllocSource(); 1240 if (p->source == NULL) { 1241 smlFreeMap(p); 1242 return NULL; 1243 } 1244 p->mapItemList = smlAllocMapItemList(); 1245 if (p->mapItemList == NULL) { 1246 smlFreeMap(p); 1247 return NULL; 1248 } 1249 return p; 1250 } 1251 1252 SML_API SmlResultsPtr_t smlAllocResults() { 1253 SmlResultsPtr_t p = (SmlResultsPtr_t)smlLibMalloc(sizeof(SmlResults_t)); 1254 if (p == 0) return NULL; 1255 smlLibMemset(p, 0, sizeof(SmlResults_t)); 1256 p->elementType = SML_PE_RESULTS; 1257 p->cmdID = smlAllocPcdata(); 1258 if (p->cmdID == NULL) { 1259 smlFreeResults(p); 1260 return NULL; 1261 } 1262 p->cmdRef = smlAllocPcdata(); 1263 if (p->cmdRef == NULL) { 1264 smlFreeResults(p); 1265 return NULL; 1266 } 1267 p->itemList = smlAllocItemList(); 1268 if (p->itemList == NULL) { 1269 smlFreeResults(p); 1270 return NULL; 1271 } 1272 return p; 1273 } 1274 1275 #if (defined SEARCH_SEND || defined SEARCH_RECEIVE) 1276 1277 SML_API SmlSearchPtr_t smlAllocSearch() { 1278 SmlSearchPtr_t p = (SmlSearchPtr_t)smlLibMalloc(sizeof(SmlSearch_t)); 1279 if (p == 0) return NULL; 1280 smlLibMemset(p, 0, sizeof(SmlSearch_t)); 1281 p->elementType = SML_PE_SEARCH; 1282 p->cmdID = smlAllocPcdata(); 1283 if (p->cmdID == NULL) { 1284 smlFreeSearch(p); 1285 return NULL; 1286 } 1287 p->meta = smlAllocPcdata(); 1288 if (p->meta == NULL) { 1289 smlFreeSearch(p); 1290 return NULL; 1291 } 1292 p->data = smlAllocPcdata(); 1293 if (p->data == NULL) { 1294 smlFreeSearch(p); 1295 return NULL; 1296 } 1297 p->sourceList = smlAllocSourceList(); 1298 if (p->sourceList == NULL) { 1299 smlFreeSearch(p); 1300 return NULL; 1301 } 1302 return p; 1303 } 1304 #endif 1305 1306 SML_API SmlTargetRefListPtr_t smlAllocTargetRefList() { 1307 SmlTargetRefListPtr_t p = (SmlTargetRefListPtr_t)smlLibMalloc(sizeof(SmlTargetRefList_t)); 1308 if (p == 0) return NULL; 1309 smlLibMemset(p, 0, sizeof(SmlTargetRefList_t)); 1310 p->targetRef = smlAllocPcdata(); 1311 if (p->targetRef == NULL) { 1312 smlFreeTargetRefList(p); 1313 return NULL; 1314 } 1315 return p; 1316 } 1317 1318 SML_API SmlSourceRefListPtr_t smlAllocSourceRefList() { 1319 SmlSourceRefListPtr_t p = (SmlSourceRefListPtr_t)smlLibMalloc(sizeof(SmlSourceRefList_t)); 1320 if (p == 0) return NULL; 1321 smlLibMemset(p, 0, sizeof(SmlSourceRefList_t)); 1322 p->sourceRef = smlAllocPcdata(); 1323 if (p->sourceRef == NULL) { 1324 smlFreeSourceRefList(p); 1325 return NULL; 1326 } 1327 return p; 1328 } 1329 1330 SML_API SmlStatusPtr_t smlAllocStatus() { 1331 SmlStatusPtr_t p = (SmlStatusPtr_t)smlLibMalloc(sizeof(SmlStatus_t)); 1332 if (p == 0) return NULL; 1333 smlLibMemset(p, 0, sizeof(SmlStatus_t)); 1334 p->elementType = SML_PE_STATUS; 1335 p->cmdID = smlAllocPcdata(); 1336 if (p->cmdID == NULL) { 1337 smlFreeStatus(p); 1338 return NULL; 1339 } 1340 p->msgRef = smlAllocPcdata(); 1341 if (p->msgRef == NULL) { 1342 smlFreeStatus(p); 1343 return NULL; 1344 } 1345 p->cmdRef = smlAllocPcdata(); 1346 if (p->cmdRef == NULL) { 1347 smlFreeStatus(p); 1348 return NULL; 1349 } 1350 p->cmd = smlAllocPcdata(); 1351 if (p->cmd == NULL) { 1352 smlFreeStatus(p); 1353 return NULL; 1354 } 1355 p->data = smlAllocPcdata(); 1356 if (p->data == NULL) { 1357 smlFreeStatus(p); 1358 return NULL; 1359 } 1360 return p; 1361 } 1362 1363 SML_API SmlUnknownProtoElementPtr_t smlAllocUnknownProtoElement() { 1364 SmlUnknownProtoElementPtr_t p = (SmlUnknownProtoElementPtr_t)smlLibMalloc(sizeof(SmlUnknownProtoElement_t)); 1365 if (p == 0) return NULL; 1366 smlLibMemset(p, 0, sizeof(SmlUnknownProtoElement_t)); 1367 p->elementType = SML_PE_UNDEF; 1368 return p; 1369 } 1370 1371 #ifdef __USE_METINF__ 1372 SML_API SmlMetInfMetInfPtr_t smlAllocMetInfMetInf() { 1373 SmlMetInfMetInfPtr_t p = (SmlMetInfMetInfPtr_t)smlLibMalloc(sizeof(SmlMetInfMetInf_t)); 1374 if (p == NULL) return NULL; 1375 smlLibMemset(p, 0, sizeof(SmlMetInfMetInf_t)); 1376 return p; 1377 } 1378 1379 SML_API SmlMetInfAnchorPtr_t smlAllocMetInfAnchor() { 1380 SmlMetInfAnchorPtr_t p = (SmlMetInfAnchorPtr_t)smlLibMalloc(sizeof(SmlMetInfAnchor_t)); 1381 if (p == NULL) return NULL; 1382 smlLibMemset(p, 0, sizeof(SmlMetInfAnchor_t)); 1383 p->next = smlAllocPcdata(); 1384 if (p->next == NULL) { 1385 smlFreeMetinfAnchor(p); 1386 return NULL; 1387 } 1388 return p; 1389 } 1390 1391 SML_API SmlMetInfMemPtr_t smlAllocMetInfMem() { 1392 SmlMetInfMemPtr_t p = (SmlMetInfMemPtr_t)smlLibMalloc(sizeof(SmlMetInfMem_t)); 1393 if (p == NULL) return NULL; 1394 smlLibMemset(p, 0, sizeof(SmlMetInfMem_t)); 1395 p->free = smlAllocPcdata(); 1396 if (p->free == NULL) { 1397 smlFreeMetinfMem(p); 1398 return NULL; 1399 } 1400 p->freeid = smlAllocPcdata(); 1401 if (p->freeid == NULL) { 1402 smlFreeMetinfMem(p); 1403 return NULL; 1404 } 1405 return p; 1406 } 1407 #endif 1408 1409 #ifdef __USE_DEVINF__ 1410 SML_API SmlDevInfExtPtr_t smlAllocDevInfExt() { 1411 SmlDevInfExtPtr_t p = (SmlDevInfExtPtr_t)smlLibMalloc(sizeof(SmlDevInfExt_t)); 1412 if (p == NULL) return NULL; 1413 smlLibMemset(p, 0, sizeof(SmlDevInfExt_t)); 1414 p->xnam = smlAllocPcdata(); 1415 if (p->xnam == NULL) { 1416 smlFreeDevInfExt(p); 1417 return NULL; 1418 } 1419 return p; 1420 } 1421 1422 SML_API SmlDevInfExtListPtr_t smlAllocDevInfExtList() { 1423 SmlDevInfExtListPtr_t p = (SmlDevInfExtListPtr_t)smlLibMalloc(sizeof(SmlDevInfExtList_t)); 1424 if (p == NULL) return NULL; 1425 smlLibMemset(p, 0, sizeof(SmlDevInfExtList_t)); 1426 p->data = smlAllocDevInfExt(); 1427 if (p->data == NULL) { 1428 smlFreeDevInfExtList(p); 1429 return NULL; 1430 } 1431 return p; 1432 } 1433 1434 SML_API SmlDevInfSyncCapPtr_t smlAllocDevInfSyncCap() { 1435 SmlDevInfSyncCapPtr_t p = (SmlDevInfSyncCapPtr_t)smlLibMalloc(sizeof(SmlDevInfSyncCap_t)); 1436 if (p == NULL) return NULL; 1437 smlLibMemset(p, 0, sizeof(SmlDevInfSyncCap_t)); 1438 p->synctype = smlAllocPcdataList(); 1439 if (p->synctype == NULL) { 1440 smlFreeDevInfSynccap(p); 1441 return NULL; 1442 } 1443 return p; 1444 } 1445 1446 SML_API SmlDevInfCTDataPtr_t smlAllocDevInfCTData() { 1447 SmlDevInfCTDataPtr_t p = (SmlDevInfCTDataPtr_t)smlLibMalloc(sizeof(SmlDevInfCTData_t)); 1448 if (p == NULL) return NULL; 1449 smlLibMemset(p, 0, sizeof(SmlDevInfCTData_t)); 1450 p->name = smlAllocPcdata(); 1451 if (p->name == NULL) { 1452 smlFreeDevInfCTData(p); 1453 return NULL; 1454 } 1455 return p; 1456 } 1457 1458 SML_API SmlDevInfCTDataListPtr_t smlAllocDevInfCTDataList() { 1459 SmlDevInfCTDataListPtr_t p = (SmlDevInfCTDataListPtr_t)smlLibMalloc(sizeof(SmlDevInfCTDataList_t)); 1460 if (p == NULL) return NULL; 1461 smlLibMemset(p, 0, sizeof(SmlDevInfCTDataList_t)); 1462 p->data = smlAllocDevInfCTData(); 1463 if (p->data == NULL) { 1464 smlFreeDevInfCTDataList(p); 1465 return NULL; 1466 } 1467 return p; 1468 } 1469 1470 SML_API SmlDevInfCTDataPropPtr_t smlAllocDevInfCTDataProp() { 1471 SmlDevInfCTDataPropPtr_t p = (SmlDevInfCTDataPropPtr_t)smlLibMalloc(sizeof(SmlDevInfCTDataProp_t)); 1472 if (p == NULL) return NULL; 1473 smlLibMemset(p, 0, sizeof(SmlDevInfCTDataProp_t)); 1474 p->prop = smlAllocDevInfCTData(); 1475 if (p->prop == NULL) { 1476 smlFreeDevInfCTDataProp(p); 1477 return NULL; 1478 } 1479 return p; 1480 } 1481 1482 SML_API SmlDevInfCTDataPropListPtr_t smlAllocDevInfCTDataPropList() { 1483 SmlDevInfCTDataPropListPtr_t p = (SmlDevInfCTDataPropListPtr_t)smlLibMalloc(sizeof(SmlDevInfCTDataPropList_t)); 1484 if (p == NULL) return NULL; 1485 smlLibMemset(p, 0, sizeof(SmlDevInfCTDataPropList_t)); 1486 p->data = smlAllocDevInfCTDataProp(); 1487 if (p->data == NULL) { 1488 smlFreeDevInfCTDataPropList(p); 1489 return NULL; 1490 } 1491 return p; 1492 } 1493 1494 SML_API SmlDevInfCTCapPtr_t smlAllocDevInfCTCap() { 1495 SmlDevInfCTCapPtr_t p = (SmlDevInfCTCapPtr_t)smlLibMalloc(sizeof(SmlDevInfCTCap_t)); 1496 if (p == NULL) return NULL; 1497 smlLibMemset(p, 0, sizeof(SmlDevInfCTCap_t)); 1498 p->cttype = smlAllocPcdata(); 1499 if (p->cttype == NULL) { 1500 smlFreeDevInfCTCap(p); 1501 return NULL; 1502 } 1503 p->prop = smlAllocDevInfCTDataPropList(); 1504 if (p->prop == NULL) { 1505 smlFreeDevInfCTCap(p); 1506 return NULL; 1507 } 1508 return p; 1509 } 1510 1511 SML_API SmlDevInfCtcapListPtr_t smlAllocDevInfCtcapList() { 1512 SmlDevInfCtcapListPtr_t p = (SmlDevInfCtcapListPtr_t)smlLibMalloc(sizeof(SmlDevInfCtcapList_t)); 1513 if (p == NULL) return NULL; 1514 smlLibMemset(p, 0, sizeof(SmlDevInfCtcapList_t)); 1515 p->data = smlAllocDevInfCTCap(); 1516 if (p->data == NULL) { 1517 smlFreeDevInfCtcapList(p); 1518 return NULL; 1519 } 1520 return p; 1521 } 1522 1523 SML_API SmlDevInfDSMemPtr_t smlAllocDevInfDSMem() { 1524 SmlDevInfDSMemPtr_t p = (SmlDevInfDSMemPtr_t)smlLibMalloc(sizeof(SmlDevInfDSMem_t)); 1525 if (p == NULL) return NULL; 1526 smlLibMemset(p, 0, sizeof(SmlDevInfDSMem_t)); 1527 return p; 1528 } 1529 1530 SML_API SmlDevInfXmitPtr_t smlAllocDevInfXmit() { 1531 SmlDevInfXmitPtr_t p = (SmlDevInfXmitPtr_t)smlLibMalloc(sizeof(SmlDevInfXmit_t)); 1532 if (p == NULL) return NULL; 1533 smlLibMemset(p, 0, sizeof(SmlDevInfXmit_t)); 1534 p->cttype = smlAllocPcdata(); 1535 if (p->cttype == NULL) { 1536 smlFreeDevInfXmit(p); 1537 return NULL; 1538 } 1539 p->verct = smlAllocPcdata(); 1540 if (p->verct == NULL) { 1541 smlFreeDevInfXmit(p); 1542 return NULL; 1543 } 1544 return p; 1545 } 1546 1547 SML_API SmlDevInfXmitListPtr_t smlAllocDevInfXmitList() { 1548 SmlDevInfXmitListPtr_t p = (SmlDevInfXmitListPtr_t)smlLibMalloc(sizeof(SmlDevInfXmitList_t)); 1549 if (p == NULL) return NULL; 1550 smlLibMemset(p, 0, sizeof(SmlDevInfXmitList_t)); 1551 p->data = smlAllocDevInfXmit(); 1552 if (p->data == NULL) { 1553 smlFreeDevInfXmitList(p); 1554 return NULL; 1555 } 1556 return p; 1557 } 1558 1559 SML_API SmlDevInfDatastorePtr_t smlAllocDevInfDatastore() { 1560 SmlDevInfDatastorePtr_t p = (SmlDevInfDatastorePtr_t)smlLibMalloc(sizeof(SmlDevInfDatastore_t)); 1561 if (p == NULL) return NULL; 1562 smlLibMemset(p, 0, sizeof(SmlDevInfDatastore_t)); 1563 p->sourceref = smlAllocPcdata(); 1564 if (p->sourceref == NULL) { 1565 smlFreeDevInfDatastore(p); 1566 return NULL; 1567 } 1568 p->rxpref = smlAllocDevInfXmit(); 1569 if (p->rxpref == NULL) { 1570 smlFreeDevInfDatastore(p); 1571 return NULL; 1572 } 1573 p->txpref = smlAllocDevInfXmit(); 1574 if (p->txpref == NULL) { 1575 smlFreeDevInfDatastore(p); 1576 return NULL; 1577 } 1578 p->synccap = smlAllocDevInfSyncCap(); 1579 if (p->synccap == NULL) { 1580 smlFreeDevInfDatastore(p); 1581 return NULL; 1582 } 1583 return p; 1584 } 1585 1586 SML_API SmlDevInfDatastoreListPtr_t smlAllocDevInfDatastoreList() { 1587 SmlDevInfDatastoreListPtr_t p = (SmlDevInfDatastoreListPtr_t)smlLibMalloc(sizeof(SmlDevInfDatastoreList_t)); 1588 if (p == NULL) return NULL; 1589 smlLibMemset(p, 0, sizeof(SmlDevInfDatastoreList_t)); 1590 p->data = smlAllocDevInfDatastore(); 1591 if (p->data == NULL) { 1592 smlFreeDevInfDatastoreList(p); 1593 return NULL; 1594 } 1595 return p; 1596 } 1597 1598 SML_API SmlDevInfDevInfPtr_t smlAllocDevInfDevInf() { 1599 SmlDevInfDevInfPtr_t p = (SmlDevInfDevInfPtr_t)smlLibMalloc(sizeof(SmlDevInfDevInf_t)); 1600 if (p == NULL) return NULL; 1601 smlLibMemset(p, 0, sizeof(SmlDevInfDevInf_t)); 1602 p->verdtd = smlAllocPcdata(); 1603 if (p->verdtd == NULL) { 1604 smlFreeDevInfDevInf(p); 1605 return NULL; 1606 } 1607 p->devid = smlAllocPcdata(); 1608 if (p->devid == NULL) { 1609 smlFreeDevInfDevInf(p); 1610 return NULL; 1611 } 1612 p->devtyp = smlAllocPcdata(); 1613 if (p->devtyp == NULL) { 1614 smlFreeDevInfDevInf(p); 1615 return NULL; 1616 } 1617 1618 p->datastore = smlAllocDevInfDatastoreList(); 1619 /* Fixed error checking. 3/07/03 Emily Bernotas */ 1620 if (p->datastore == NULL) { 1621 smlFreeDevInfDevInf(p); 1622 return NULL; 1623 } 1624 /* When developing the DS Stack, testing showed that the RTK was depending on these 1625 * two optional DevInf element to have valid data when encoding the SyncML document. 1626 * Although the phone does use the CTCAP element, it does NOT use the Ext element and 1627 * not having valid data in the Ext was causing a PANIC. 1628 * The design decision was made to fix the RTK here to follow the original philosophy 1629 * not allocating memory of optional elements. For example, memory for other optional 1630 * elements like Man, FwV, etc is not allocated here. It is now the responsibility of 1631 * the DS Stack to allocate memory for CTCAP. 04/02/03 Emily Bernotas 1632 */ 1633 /* 1634 p->ctcap = smlAllocDevInfCtcapList(); 1635 if (p->ctcap == NULL) { 1636 smlFreeDevInfDevInf(p); 1637 return NULL; 1638 } 1639 p->ext = smlAllocDevInfExtList(); 1640 if (p->ext == NULL) { 1641 smlFreeDevInfDevInf(p); 1642 return NULL; 1643 } 1644 */ 1645 return p; 1646 } 1647 1648 #endif // DevInf 1649 1650 #ifdef __USE_DMTND__ 1651 SML_API SmlDmTndPtr_t smlAllocDmTnd() { 1652 SmlDmTndPtr_t p = (SmlDmTndPtr_t)smlLibMalloc(sizeof(SmlDmTnd_t)); 1653 if (p == NULL) return NULL; 1654 smlLibMemset(p, 0, sizeof(SmlDmTnd_t)); 1655 return p; 1656 } 1657 1658 SML_API SmlDmTndNodeListPtr_t smlAllocDmTndNodeList() { 1659 SmlDmTndNodeListPtr_t p = (SmlDmTndNodeListPtr_t)smlLibMalloc(sizeof(SmlDmTndNodeList_t)); 1660 if (p == NULL) return NULL; 1661 smlLibMemset(p, 0, sizeof(SmlDmTndNodeList_t)); 1662 return p; 1663 } 1664 1665 SML_API SmlDmTndNodePtr_t smlAllocDmTndNode() { 1666 SmlDmTndNodePtr_t p = (SmlDmTndNodePtr_t)smlLibMalloc(sizeof(SmlDmTndNode_t)); 1667 if (p == NULL) return NULL; 1668 smlLibMemset(p, 0, sizeof(SmlDmTndNode_t)); 1669 return p; 1670 } 1671 1672 SML_API SmlDmTndRTPropsPtr_t smlAllocDmTndRTProps() { 1673 SmlDmTndRTPropsPtr_t p = (SmlDmTndRTPropsPtr_t)smlLibMalloc(sizeof(SmlDmTndRTProps_t)); 1674 if (p == NULL) return NULL; 1675 smlLibMemset(p, 0, sizeof(SmlDmTndRTProps_t)); 1676 return p; 1677 } 1678 1679 SML_API SmlDmTndFormatPtr_t smlAllocDmTndFormat() { 1680 SmlDmTndFormatPtr_t p = (SmlDmTndFormatPtr_t)smlLibMalloc(sizeof(SmlDmTndFormatPtr_t)); 1681 if (p == NULL) return NULL; 1682 smlLibMemset(p, 0, sizeof(SmlDmTndFormat_t)); 1683 return p; 1684 } 1685 1686 SML_API SmlDmTndTypePtr_t smlAllocDmTndType() { 1687 SmlDmTndTypePtr_t p = (SmlDmTndTypePtr_t)smlLibMalloc(sizeof(SmlDmTndRTProps_t)); 1688 if (p == NULL) return NULL; 1689 smlLibMemset(p, 0, sizeof(SmlDmTndType_t)); 1690 return p; 1691 } 1692 #endif // AllocDmTnd 1693 1694 #endif // AllocFuncs 1695
