1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /*-------------------------------------------------------------------------------------------------- 18 19 Header Name: xltdmtnd.c 20 21 General Description: XLT DM TND related functions 22 23 --------------------------------------------------------------------------------------------------*/ 24 25 #include "define.h" 26 27 #ifdef __USE_DMTND__ 28 #include "smldmtnddtd.h" 29 30 #include "xlttags.h" 31 #include "xltdmtnd.h" 32 #include "xlttagtbl.h" 33 #include "xltenc.h" 34 #include "xltencwbxml.h" 35 36 #include <define.h> 37 #include <libstr.h> 38 #include <smlerr.h> 39 #include <libmem.h> 40 #include <libutil.h> 41 /* extern */ 42 extern SML_API void smlFreeDmTndFormat(SmlDmTndFormatPtr_t data); 43 extern SML_API void smlFreeDmTndType(SmlDmTndTypePtr_t data); 44 extern SML_API void smlFreeDmTndDFElement(SmlDmTndDFElementPtr_t data); 45 extern SML_API void smlFreeDmTndRTProps(SmlDmTndRTPropsPtr_t data); 46 extern SML_API void smlFreeDmTndDFProps(SmlDmTndDFPropsPtr_t data); 47 extern SML_API void smlFreeDmTndNode(SmlDmTndNodePtr_t data); 48 extern SML_API void smlFreeDmTndNodeList(SmlDmTndNodeListPtr_t data); 49 extern SML_API void smlFreeDmTnd(SmlDmTndPtr_t data); 50 51 Ret_t buildDmTndNodeCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem); 52 53 /* decoder callbacks */ 54 Ret_t buildDmTndFormatCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 55 { 56 XltDecScannerPtr_t pScanner; 57 SmlDmTndFormatPtr_t pDmTndFormat; 58 Ret_t rc; 59 60 pScanner = pDecoder->scanner; 61 62 if (*ppElem != NULL) 63 return SML_ERR_XLT_INVAL_SYNCML_DOC; 64 65 if ((pDmTndFormat = (SmlDmTndFormatPtr_t)smlLibMalloc(sizeof(SmlDmTndFormat_t))) == NULL) 66 return SML_ERR_NOT_ENOUGH_SPACE; 67 smlLibMemset(pDmTndFormat, 0, sizeof(SmlDmTndFormat_t)); 68 69 if (IS_EMPTY(pScanner->curtok)) { 70 *ppElem = pDmTndFormat; 71 return SML_ERR_OK; 72 } 73 74 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 75 smlFreeDmTndFormat(pDmTndFormat); 76 return rc; 77 } 78 79 while (pScanner->curtok->type != TOK_TAG_END) { 80 VoidPtr_t pContent = smlLibMalloc(6); 81 if ( pContent == NULL ) 82 { 83 smlFreeDmTndFormat(pDmTndFormat); 84 return SML_ERR_NOT_ENOUGH_SPACE; 85 } 86 smlLibMemset(pContent, 0, 6); 87 88 switch (pScanner->curtok->tagid) { 89 case TN_DMTND_b64: 90 smlLibStrcpy(pContent, "b64"); 91 break; 92 case TN_DMTND_bin: 93 smlLibStrcpy(pContent, "bin"); 94 break; 95 case TN_DMTND_bool: 96 smlLibStrcpy(pContent, "bool"); 97 break; 98 case TN_DMTND_chr: 99 smlLibStrcpy(pContent, "chr"); 100 break; 101 case TN_DMTND_int: 102 smlLibStrcpy(pContent, "int"); 103 break; 104 case TN_DMTND_node: 105 smlLibStrcpy(pContent, "node"); 106 break; 107 case TN_DMTND_null: 108 smlLibStrcpy(pContent, "null"); 109 break; 110 case TN_DMTND_xml: 111 smlLibStrcpy(pContent, "xml"); 112 break; 113 case TN_DMTND_date: 114 smlLibStrcpy(pContent, "date"); 115 break; 116 case TN_DMTND_time: 117 smlLibStrcpy(pContent, "time"); 118 break; 119 case TN_DMTND_float: 120 smlLibStrcpy(pContent, "float"); 121 break; 122 default: 123 KCDBG(">>>>> Unkown token: %d <<<<<\n", pScanner->curtok->tagid); 124 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 125 } 126 127 if (rc != SML_ERR_OK) { 128 smlLibFree(pContent); 129 smlFreeDmTndFormat(pDmTndFormat); 130 return rc; 131 } 132 133 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndFormat->value); 134 if (rc != SML_ERR_OK) { 135 smlLibFree(pContent); 136 smlFreeDmTndFormat(pDmTndFormat); 137 return rc; 138 } 139 pDmTndFormat->value->content = pContent; 140 pDmTndFormat->value->length = smlLibStrlen(pContent); 141 142 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 143 smlLibFree(pContent); 144 smlFreeDmTndFormat(pDmTndFormat); 145 return rc; 146 } 147 if (pScanner->curtok->type != TOK_TAG_END) { 148 smlLibFree(pContent); 149 smlFreeDmTndFormat(pDmTndFormat); 150 return SML_ERR_XLT_INVAL_SYNCML_DOC; 151 } 152 } 153 154 *ppElem = pDmTndFormat; 155 156 return SML_ERR_OK; 157 } 158 159 /* decoder callbacks */ 160 Ret_t buildDmTndTypeCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 161 { 162 XltDecScannerPtr_t pScanner; 163 SmlDmTndTypePtr_t pDmTndType; 164 Ret_t rc; 165 166 pScanner = pDecoder->scanner; 167 168 if (*ppElem != NULL) 169 return SML_ERR_XLT_INVAL_SYNCML_DOC; 170 171 if ((pDmTndType = (SmlDmTndTypePtr_t)smlLibMalloc(sizeof(SmlDmTndType_t))) == NULL) 172 return SML_ERR_NOT_ENOUGH_SPACE; 173 smlLibMemset(pDmTndType, 0, sizeof(SmlDmTndType_t)); 174 175 if (IS_EMPTY(pScanner->curtok)) { 176 *ppElem = pDmTndType; 177 return SML_ERR_OK; 178 } 179 180 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 181 smlFreeDmTndType(pDmTndType); 182 return rc; 183 } 184 185 while (pScanner->curtok->type != TOK_TAG_END) { 186 switch (pScanner->curtok->tagid) { 187 case TN_DMTND_MIME: 188 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndType->mime); 189 break; 190 case TN_DMTND_DDFName: 191 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndType->ddfname); 192 break; 193 default: 194 KCDBG(">>>>> Unkown token: %d <<<<<\n", pScanner->curtok->tagid); 195 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 196 } 197 if (rc != SML_ERR_OK) { 198 smlFreeDmTndType(pDmTndType); 199 return rc; 200 } 201 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 202 smlFreeDmTndType(pDmTndType); 203 return rc; 204 } 205 if (pScanner->curtok->type != TOK_TAG_END) { 206 smlFreeDmTndType(pDmTndType); 207 return SML_ERR_XLT_INVAL_SYNCML_DOC; 208 } 209 } 210 211 *ppElem = pDmTndType; 212 213 return SML_ERR_OK; 214 } 215 216 /* decoder callbacks */ 217 Ret_t buildDmTndDFElementCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 218 { 219 XltDecScannerPtr_t pScanner; 220 SmlDmTndDFElementPtr_t pDmTndDFElement; 221 Ret_t rc; 222 223 pScanner = pDecoder->scanner; 224 225 if (*ppElem != NULL) 226 return SML_ERR_XLT_INVAL_SYNCML_DOC; 227 228 if ((pDmTndDFElement = (SmlDmTndDFElementPtr_t)smlLibMalloc(sizeof(SmlDmTndDFElement_t))) == NULL) 229 return SML_ERR_NOT_ENOUGH_SPACE; 230 smlLibMemset(pDmTndDFElement, 0, sizeof(SmlDmTndDFElement_t)); 231 232 if (IS_EMPTY(pScanner->curtok)) { 233 *ppElem = pDmTndDFElement; 234 return SML_ERR_OK; 235 } 236 237 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 238 smlFreeDmTndDFElement(pDmTndDFElement); 239 return rc; 240 } 241 242 while (pScanner->curtok->type != TOK_TAG_END) { 243 VoidPtr_t pContent = smlLibMalloc(10); 244 if ( pContent == NULL ) 245 { 246 smlFreeDmTndDFElement(pDmTndDFElement); 247 return SML_ERR_NOT_ENOUGH_SPACE; 248 } 249 smlLibMemset(pContent, 0, 10); 250 251 switch (pScanner->curtok->tagid) { 252 /* AccessType Elements */ 253 case TN_DMTND_Add: 254 smlLibStrcpy(pContent, "Add"); 255 break; 256 case TN_DMTND_Copy: 257 smlLibStrcpy(pContent, "Copy"); 258 break; 259 case TN_DMTND_Delete: 260 smlLibStrcpy(pContent, "Delete"); 261 break; 262 case TN_DMTND_Exec: 263 smlLibStrcpy(pContent, "Exec"); 264 break; 265 case TN_DMTND_Get: 266 smlLibStrcpy(pContent, "Get"); 267 break; 268 case TN_DMTND_Replace: 269 smlLibStrcpy(pContent, "Replace"); 270 break; 271 /* Occurrence Elements */ 272 case TN_DMTND_One: 273 smlLibStrcpy(pContent, "One"); 274 break; 275 case TN_DMTND_ZeroOrOne: 276 smlLibStrcpy(pContent, "ZeroOrOne"); 277 break; 278 case TN_DMTND_ZeroOrMore: 279 smlLibStrcpy(pContent, "ZeroOrMore"); 280 break; 281 case TN_DMTND_OneOrMore: 282 smlLibStrcpy(pContent, "OneOrMore"); 283 break; 284 case TN_DMTND_ZeroOrN: 285 smlLibStrcpy(pContent, "ZeroOrN"); 286 break; 287 case TN_DMTND_OneOrN: 288 smlLibStrcpy(pContent, "OneOrN"); 289 break; 290 /* Scope Elements */ 291 case TN_DMTND_Permanent: 292 smlLibStrcpy(pContent, "Permanent"); 293 break; 294 case TN_DMTND_Dynamic: 295 smlLibStrcpy(pContent, "Dynamic"); 296 break; 297 /* CaseSense Elements */ 298 case TN_DMTND_CS: 299 smlLibStrcpy(pContent, "CS"); 300 break; 301 case TN_DMTND_CIS: 302 smlLibStrcpy(pContent, "CIS"); 303 break; 304 default: 305 KCDBG(">>>>> buildDmTndDFElementCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); 306 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 307 } 308 if (rc != SML_ERR_OK) { 309 smlFreeDmTndDFElement(pDmTndDFElement); 310 return rc; 311 } 312 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 313 smlFreeDmTndDFElement(pDmTndDFElement); 314 return rc; 315 } 316 if (pScanner->curtok->type != TOK_TAG_END) { 317 smlFreeDmTndDFElement(pDmTndDFElement); 318 return SML_ERR_XLT_INVAL_SYNCML_DOC; 319 } 320 } 321 322 *ppElem = pDmTndDFElement; 323 324 return SML_ERR_OK; 325 } 326 327 /* decoder callbacks */ 328 Ret_t buildDmTndRTPropsCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 329 { 330 XltDecScannerPtr_t pScanner; 331 SmlDmTndRTPropsPtr_t pDmTndRTProps; 332 Ret_t rc; 333 334 pScanner = pDecoder->scanner; 335 336 if (*ppElem != NULL) 337 return SML_ERR_XLT_INVAL_SYNCML_DOC; 338 339 if ((pDmTndRTProps = (SmlDmTndRTPropsPtr_t)smlLibMalloc(sizeof(SmlDmTndRTProps_t))) == NULL) 340 return SML_ERR_NOT_ENOUGH_SPACE; 341 smlLibMemset(pDmTndRTProps, 0, sizeof(SmlDmTndRTProps_t)); 342 343 if (IS_EMPTY(pScanner->curtok)) { 344 *ppElem = pDmTndRTProps; 345 return SML_ERR_OK; 346 } 347 348 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 349 smlFreeDmTndRTProps(pDmTndRTProps); 350 return rc; 351 } 352 353 while (pScanner->curtok->type != TOK_TAG_END) { 354 switch (pScanner->curtok->tagid) { 355 case TN_DMTND_ACL: 356 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->acl); 357 break; 358 case TN_DMTND_Format: 359 rc = buildDmTndFormatCmd(pDecoder, (VoidPtr_t)&pDmTndRTProps->format); 360 break; 361 case TN_DMTND_Name: 362 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->name); 363 break; 364 case TN_DMTND_Size: 365 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->size); 366 break; 367 case TN_DMTND_Title: 368 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->title); 369 break; 370 case TN_DMTND_TStamp: 371 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->tstamp); 372 break; 373 case TN_DMTND_Type: 374 rc = buildDmTndTypeCmd(pDecoder, (VoidPtr_t)&pDmTndRTProps->type); 375 break; 376 case TN_DMTND_VerNo: 377 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->verno); 378 break; 379 default: 380 KCDBG(">>>>> buildDmTndRTPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); 381 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 382 } 383 if (rc != SML_ERR_OK) { 384 smlFreeDmTndRTProps(pDmTndRTProps); 385 return rc; 386 } 387 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 388 smlFreeDmTndRTProps(pDmTndRTProps); 389 return rc; 390 } 391 } 392 393 *ppElem = pDmTndRTProps; 394 395 return SML_ERR_OK; 396 } 397 398 /* decoder callbacks */ 399 Ret_t buildDmTndDFPropsCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 400 { 401 XltDecScannerPtr_t pScanner; 402 SmlDmTndDFPropsPtr_t pDmTndDFProps; 403 Ret_t rc = SML_ERR_OK; 404 405 pScanner = pDecoder->scanner; 406 407 if (*ppElem != NULL) 408 return SML_ERR_XLT_INVAL_SYNCML_DOC; 409 410 if ((pDmTndDFProps = (SmlDmTndDFPropsPtr_t)smlLibMalloc(sizeof(SmlDmTndDFProps_t))) == NULL) 411 return SML_ERR_NOT_ENOUGH_SPACE; 412 smlLibMemset(pDmTndDFProps, 0, sizeof(SmlDmTndDFProps_t)); 413 414 if (IS_EMPTY(pScanner->curtok)) { 415 *ppElem = pDmTndDFProps; 416 return SML_ERR_OK; 417 } 418 419 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 420 smlFreeDmTndDFProps(pDmTndDFProps); 421 return rc; 422 } 423 424 while (pScanner->curtok->type != TOK_TAG_END) { 425 switch (pScanner->curtok->tagid) { 426 case TN_DMTND_AccessType: 427 rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->accesstype); 428 break; 429 case TN_DMTND_DefaultValue: 430 rc = buildDmTndFormatCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->defaultvalue); 431 break; 432 case TN_DMTND_Description: 433 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndDFProps->description); 434 break; 435 case TN_DMTND_DFFormat: 436 rc = buildDmTndFormatCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->dfformat); 437 break; 438 case TN_DMTND_Occurrence: 439 rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->occurrence); 440 break; 441 case TN_DMTND_Scope: 442 rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->scope); 443 break; 444 case TN_DMTND_DFTitle: 445 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndDFProps->dftitle); 446 break; 447 case TN_DMTND_DFType: 448 rc = buildDmTndTypeCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->dftype); 449 break; 450 case TN_DMTND_CaseSense: 451 rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->casesense); 452 break; 453 default: 454 KCDBG(">>>>> buildDmTndDFPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); 455 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 456 } 457 if (rc != SML_ERR_OK) { 458 smlFreeDmTndDFProps(pDmTndDFProps); 459 return rc; 460 } 461 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 462 smlFreeDmTndDFProps(pDmTndDFProps); 463 return rc; 464 } 465 } 466 467 *ppElem = pDmTndDFProps; 468 469 return SML_ERR_OK; 470 } 471 472 Ret_t buildDmTndNodeList(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 473 { 474 SmlDmTndNodeListPtr_t pElem = NULL, pPrev = NULL; 475 476 pElem = (SmlDmTndNodeListPtr_t) *ppElem; 477 /* advance to the end of the list, and create ther an empty list element */ 478 while (pElem != NULL) { 479 pPrev = pElem; 480 pElem = pPrev->next; 481 } 482 if ((pElem = (SmlDmTndNodeListPtr_t)smlLibMalloc(sizeof(SmlDmTndNodeListPtr_t))) == NULL) 483 return SML_ERR_NOT_ENOUGH_SPACE; 484 smlLibMemset(pElem, 0, sizeof(SmlDmTndNodeListPtr_t)); 485 pElem->next = NULL; 486 if (pPrev != NULL) /* we already had some entries in the list */ 487 pPrev->next = pElem; 488 else /* nope we created a new list */ 489 *ppElem = pElem; 490 pElem->node = NULL; 491 /* at this point pElem should point to an valid list element */ 492 return buildDmTndNodeCmd(pDecoder, (VoidPtr_t)&pElem->node); 493 } 494 495 /* decoder callbacks */ 496 Ret_t buildDmTndNodeCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 497 { 498 XltDecScannerPtr_t pScanner; 499 SmlDmTndNodePtr_t pDmTndNode; 500 Ret_t rc; 501 502 pScanner = pDecoder->scanner; 503 504 if (*ppElem != NULL) 505 return SML_ERR_XLT_INVAL_SYNCML_DOC; 506 507 if ((pDmTndNode = (SmlDmTndNodePtr_t)smlLibMalloc(sizeof(SmlDmTndNode_t))) == NULL) 508 return SML_ERR_NOT_ENOUGH_SPACE; 509 smlLibMemset(pDmTndNode, 0, sizeof(SmlDmTndNode_t)); 510 511 if (IS_EMPTY(pScanner->curtok)) { 512 *ppElem = pDmTndNode; 513 return SML_ERR_OK; 514 } 515 516 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 517 smlFreeDmTndNode(pDmTndNode); 518 return rc; 519 } 520 521 while (pScanner->curtok->type != TOK_TAG_END) { 522 switch (pScanner->curtok->tagid) { 523 case TN_DMTND_NodeName: 524 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndNode->nodename); 525 break; 526 case TN_DMTND_Path: 527 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndNode->path); 528 break; 529 case TN_DMTND_RTProperties: 530 rc = buildDmTndRTPropsCmd(pDecoder, (VoidPtr_t)&pDmTndNode->rtprops); 531 break; 532 case TN_DMTND_DFProperties: 533 rc = buildDmTndDFPropsCmd(pDecoder, (VoidPtr_t)&pDmTndNode->dfprops); 534 break; 535 case TN_DMTND_Value: 536 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndNode->value); 537 break; 538 case TN_DMTND_Node: 539 rc = buildDmTndNodeList(pDecoder, (VoidPtr_t)&pDmTndNode->nodelist); 540 break; 541 default: 542 KCDBG(">>>>> buildDmTndDFPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); 543 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 544 } 545 if (rc != SML_ERR_OK) { 546 if ( NULL != pDmTndNode->nodename && NULL != pDmTndNode->nodename->content ) 547 { 548 KCDBG(">>>>> buildDmTndDFPropsCmd: Node %s corrupted <<<<<\n", (char *)pDmTndNode->nodename->content); 549 } 550 smlFreeDmTndNode(pDmTndNode); 551 return rc; 552 } 553 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 554 smlFreeDmTndNode(pDmTndNode); 555 return rc; 556 } 557 } 558 559 *ppElem = pDmTndNode; 560 561 return SML_ERR_OK; 562 } 563 564 /* decoder callbacks */ 565 Ret_t buildDmTndCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) 566 { 567 XltDecScannerPtr_t pScanner; 568 SmlDmTndPtr_t pDmTnd; 569 Ret_t rc; 570 571 pScanner = pDecoder->scanner; 572 573 if (*ppElem != NULL) 574 return SML_ERR_XLT_INVAL_SYNCML_DOC; 575 576 if ((pDmTnd = (SmlDmTndPtr_t)smlLibMalloc(sizeof(SmlDmTnd_t))) == NULL) 577 return SML_ERR_NOT_ENOUGH_SPACE; 578 smlLibMemset(pDmTnd, 0, sizeof(SmlDmTnd_t)); 579 580 if (IS_EMPTY(pScanner->curtok)) { 581 *ppElem = pDmTnd; 582 return SML_ERR_OK; 583 } 584 585 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 586 smlFreeDmTnd(pDmTnd); 587 return rc; 588 } 589 590 while (pScanner->curtok->type != TOK_TAG_END) { 591 switch (pScanner->curtok->tagid) { 592 case TN_DMTND_MgmtTree: 593 break; 594 case TN_DMTND_VerDTD: 595 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTnd->verdtd); 596 break; 597 case TN_DMTND_Man: 598 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTnd->man); 599 break; 600 case TN_DMTND_Mod: 601 rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTnd->mod); 602 break; 603 case TN_DMTND_Node: 604 rc = buildDmTndNodeList(pDecoder, (VoidPtr_t)&pDmTnd->nodelist); 605 break; 606 default: 607 KCDBG(">>>>> buildDmTndDFPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); 608 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 609 } 610 if (rc != SML_ERR_OK) { 611 smlFreeDmTnd(pDmTnd); 612 return rc; 613 } 614 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 615 smlFreeDmTnd(pDmTnd); 616 return rc; 617 } 618 } 619 620 *ppElem = pDmTnd; 621 622 return SML_ERR_OK; 623 } 624 625 /* see xltenc.c:XltEncBlock for description of parameters */ 626 Ret_t dmtndEncBlock(XltTagID_t tagId, XltRO_t reqOptFlag, const VoidPtr_t pContent, SmlEncoding_t enc, BufferMgmtPtr_t pBufMgr, SmlPcdataExtension_t attFlag) 627 { 628 if ((reqOptFlag == REQUIRED) && (pContent == NULL)) 629 { 630 KCDBG(">>>>> TNDS required tag: %d missed ! <<<<<\n", tagId); 631 return SML_ERR_XLT_MISSING_CONT; 632 } 633 //Check if pContent of a optional field is missing -> if yes we are done 634 else if (pContent == NULL) 635 return SML_ERR_OK; 636 637 Ret_t _err; 638 SmlDmTndNodeListPtr_t nodeList = NULL; 639 640 //Generate the commands -> see DTD 641 switch (tagId) 642 { 643 case TN_DMTND_MgmtTree: 644 if ((_err = xltGenerateTag(TN_DMTND_MgmtTree, TT_BEG, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 645 if ((_err = dmtndEncBlock(TN_DMTND_VerDTD, REQUIRED, ((SmlDmTndPtr_t) pContent)->verdtd, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 646 if ((_err = dmtndEncBlock(TN_DMTND_Man, OPTIONAL, ((SmlDmTndPtr_t) pContent)->man, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 647 if ((_err = dmtndEncBlock(TN_DMTND_Mod, OPTIONAL, ((SmlDmTndPtr_t) pContent)->mod, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 648 nodeList = ((SmlDmTndPtr_t)pContent)->nodelist; 649 while (nodeList != NULL) 650 { 651 if ((_err = dmtndEncBlock(TN_DMTND_Node, OPTIONAL, nodeList->node, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 652 nodeList = nodeList->next; 653 }; 654 if ((_err = xltGenerateTag(TN_DMTND_MgmtTree, TT_END, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 655 break; 656 case TN_DMTND_Node: 657 if ((_err = xltGenerateTag(TN_DMTND_Node, TT_BEG, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 658 if ((_err = dmtndEncBlock(TN_DMTND_NodeName, REQUIRED, ((SmlDmTndNodePtr_t) pContent)->nodename, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 659 if ((_err = dmtndEncBlock(TN_DMTND_Path, OPTIONAL, ((SmlDmTndNodePtr_t) pContent)->path, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 660 if ((_err = dmtndEncBlock(TN_DMTND_RTProperties, OPTIONAL, ((SmlDmTndNodePtr_t) pContent)->rtprops, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 661 if ((_err = dmtndEncBlock(TN_DMTND_Value, OPTIONAL, ((SmlDmTndNodePtr_t) pContent)->value, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 662 nodeList = ((SmlDmTndNodePtr_t)pContent)->nodelist; 663 while (nodeList != NULL) 664 { 665 if ((_err = dmtndEncBlock(TN_DMTND_Node, OPTIONAL, nodeList->node, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 666 nodeList = nodeList->next; 667 }; 668 if ((_err = xltGenerateTag(TN_DMTND_Node, TT_END, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 669 break; 670 case TN_DMTND_RTProperties: 671 if ((_err = xltGenerateTag(TN_DMTND_RTProperties, TT_BEG, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 672 if ((_err = dmtndEncBlock(TN_DMTND_ACL, OPTIONAL, ((SmlDmTndRTPropsPtr_t) pContent)->acl, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 673 if ((_err = dmtndEncBlock(TN_DMTND_Format, OPTIONAL, ((SmlDmTndRTPropsPtr_t) pContent)->format, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 674 if ((_err = dmtndEncBlock(TN_DMTND_Name, OPTIONAL, ((SmlDmTndRTPropsPtr_t) pContent)->name, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 675 if ((_err = dmtndEncBlock(TN_DMTND_Size, OPTIONAL, ((SmlDmTndRTPropsPtr_t) pContent)->size, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 676 if ((_err = dmtndEncBlock(TN_DMTND_Title, OPTIONAL, ((SmlDmTndRTPropsPtr_t) pContent)->title, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 677 if ((_err = dmtndEncBlock(TN_DMTND_TStamp, OPTIONAL, ((SmlDmTndRTPropsPtr_t) pContent)->tstamp, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 678 if ((_err = dmtndEncBlock(TN_DMTND_Type, REQUIRED, ((SmlDmTndRTPropsPtr_t) pContent)->type, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 679 if ((_err = dmtndEncBlock(TN_DMTND_VerNo, OPTIONAL, ((SmlDmTndRTPropsPtr_t) pContent)->verno, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 680 if ((_err = xltGenerateTag(TN_DMTND_RTProperties, TT_END, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 681 break; 682 case TN_DMTND_Format: 683 if ( NULL == pContent || NULL == ((SmlDmTndFormatPtr_t) pContent)->value || NULL == ((SmlDmTndFormatPtr_t) pContent)->value->content ) 684 break; 685 if ((_err = xltGenerateTag(TN_DMTND_Format, TT_BEG, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 686 if ( !strcmp("b64", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 687 { 688 if ((_err = xltGenerateTag(TN_DMTND_b64, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 689 } 690 else if ( !strcmp("bin", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 691 { 692 if ((_err = xltGenerateTag(TN_DMTND_bin, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 693 } 694 else if ( !strcmp("bool", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 695 { 696 if ((_err = xltGenerateTag(TN_DMTND_bool, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 697 } 698 else if ( !strcmp("chr", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 699 { 700 if ((_err = xltGenerateTag(TN_DMTND_chr, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 701 } 702 else if ( !strcmp("int", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 703 { 704 if ((_err = xltGenerateTag(TN_DMTND_int, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 705 } 706 else if ( !strcmp("node", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 707 { 708 if ((_err = xltGenerateTag(TN_DMTND_node, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 709 } 710 else if ( !strcmp("null", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 711 { 712 if ((_err = xltGenerateTag(TN_DMTND_null, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 713 } 714 else if ( !strcmp("xml", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 715 { 716 if ((_err = xltGenerateTag(TN_DMTND_xml, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 717 } 718 else if ( !strcmp("date", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 719 { 720 if ((_err = xltGenerateTag(TN_DMTND_date, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 721 } 722 else if ( !strcmp("time", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 723 { 724 if ((_err = xltGenerateTag(TN_DMTND_time, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 725 } 726 else if ( !strcmp("float", (char *)(((SmlDmTndFormatPtr_t) pContent)->value->content)) ) 727 { 728 if ((_err = xltGenerateTag(TN_DMTND_float, TT_ALL, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 729 } 730 else 731 { 732 KCDBG(">>>>> Unkown format: %s <<<<<\n", (char *)(((SmlDmTndFormatPtr_t)pContent)->value->content)); 733 return SML_ERR_XLT_INVAL_SYNCML_DOC; 734 } 735 if ((_err = xltGenerateTag(TN_DMTND_Format, TT_END, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 736 break; 737 case TN_DMTND_Type: 738 if ((_err = xltGenerateTag(TN_DMTND_Type, TT_BEG, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 739 if ( ((SmlDmTndTypePtr_t) pContent)->mime ) 740 { 741 if ((_err = dmtndEncBlock(TN_DMTND_MIME, OPTIONAL, ((SmlDmTndTypePtr_t) pContent)->mime, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 742 } 743 else if ( ((SmlDmTndTypePtr_t) pContent)->ddfname ) 744 { 745 if ((_err = dmtndEncBlock(TN_DMTND_DDFName, OPTIONAL, ((SmlDmTndTypePtr_t) pContent)->ddfname, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 746 } 747 if ((_err = xltGenerateTag(TN_DMTND_Type, TT_END, enc, pBufMgr, SML_EXT_DMTND)) != SML_ERR_OK) return _err; 748 break; 749 default: // all leaf nodes (PCDATA#) 750 return xltEncPcdata(tagId, reqOptFlag, pContent, enc, pBufMgr, attFlag); 751 } /* eof switch tagid */ 752 return SML_ERR_OK; 753 } 754 755 #endif /* __USE_DMTND__ */ 756
