1 /*************************************************************************/ 2 /* module: MetaInf DTD related functions for the en-/decoder */ 3 /* file: xltmetinf.c */ 4 /* target system: all */ 5 /* target OS: all */ 6 /*************************************************************************/ 7 8 /* 9 * Copyright Notice 10 * Copyright (c) Ericsson, IBM, Lotus, Matsushita Communication 11 * Industrial Co., Ltd., Motorola, Nokia, Openwave Systems, Inc., 12 * Palm, Inc., Psion, Starfish Software, Symbian, Ltd. (2001). 13 * All Rights Reserved. 14 * Implementation of all or part of any Specification may require 15 * licenses under third party intellectual property rights, 16 * including without limitation, patent rights (such a third party 17 * may or may not be a Supporter). The Sponsors of the Specification 18 * are not responsible and shall not be held responsible in any 19 * manner for identifying or failing to identify any or all such 20 * third party intellectual property rights. 21 * 22 * THIS DOCUMENT AND THE INFORMATION CONTAINED HEREIN ARE PROVIDED 23 * ON AN "AS IS" BASIS WITHOUT WARRANTY OF ANY KIND AND ERICSSON, IBM, 24 * LOTUS, MATSUSHITA COMMUNICATION INDUSTRIAL CO. LTD, MOTOROLA, 25 * NOKIA, PALM INC., PSION, STARFISH SOFTWARE AND ALL OTHER SYNCML 26 * SPONSORS DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 27 * BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION 28 * HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF 29 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 30 * SHALL ERICSSON, IBM, LOTUS, MATSUSHITA COMMUNICATION INDUSTRIAL CO., 31 * LTD, MOTOROLA, NOKIA, PALM INC., PSION, STARFISH SOFTWARE OR ANY 32 * OTHER SYNCML SPONSOR BE LIABLE TO ANY PARTY FOR ANY LOSS OF 33 * PROFITS, LOSS OF BUSINESS, LOSS OF USE OF DATA, INTERRUPTION OF 34 * BUSINESS, OR FOR DIRECT, INDIRECT, SPECIAL OR EXEMPLARY, INCIDENTAL, 35 * PUNITIVE OR CONSEQUENTIAL DAMAGES OF ANY KIND IN CONNECTION WITH 36 * THIS DOCUMENT OR THE INFORMATION CONTAINED HEREIN, EVEN IF ADVISED 37 * OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE. 38 * 39 * The above notice and this paragraph must be included on all copies 40 * of this document that are made. 41 * 42 */ 43 44 #include "define.h" 45 #ifdef __USE_METINF__ 46 47 #include "smlmetinfdtd.h" 48 #include "xlttags.h" 49 #include "xltmetinf.h" 50 #include "xlttagtbl.h" 51 #include "xltenc.h" 52 #include "xltencwbxml.h" 53 54 #include <define.h> 55 #include <libstr.h> 56 #include <smlerr.h> 57 #include <smldtd.h> 58 #include <libmem.h> 59 #include <libutil.h> 60 /* extern */ 61 extern SML_API void smlFreeMetinfAnchor(SmlMetInfAnchorPtr_t data); 62 extern SML_API void smlFreeMetinfMem(SmlMetInfMemPtr_t data); 63 extern SML_API void smlFreeMetinfMetinf(SmlMetInfMetInfPtr_t data); 64 65 66 /* decoder callbacks */ 67 Ret_t buildMetInfAnchorCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { 68 XltDecScannerPtr_t pScanner; 69 SmlMetInfAnchorPtr_t pAnchor; 70 Ret_t rc; 71 72 pScanner = pDecoder->scanner; 73 74 if (*ppElem != NULL) 75 return SML_ERR_XLT_INVAL_SYNCML_DOC; 76 77 if ((pAnchor = (SmlMetInfAnchorPtr_t)smlLibMalloc(sizeof(SmlMetInfAnchor_t))) == NULL) 78 return SML_ERR_NOT_ENOUGH_SPACE; 79 smlLibMemset(pAnchor, 0, sizeof(SmlMetInfAnchor_t)); 80 81 if (IS_EMPTY(pScanner->curtok)) { 82 *ppElem = pAnchor; 83 return SML_ERR_OK; 84 } 85 86 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 87 smlFreeMetinfAnchor(pAnchor); 88 //smlLibFree(pAnchor); 89 return rc; 90 } 91 92 while (pScanner->curtok->type != TOK_TAG_END) { 93 switch (pScanner->curtok->tagid) { 94 /* PCDATA elements */ 95 case TN_METINF_LAST: 96 rc = buildPCData(pDecoder, (VoidPtr_t)&pAnchor->last); 97 break; 98 case TN_METINF_NEXT: 99 rc = buildPCData(pDecoder, (VoidPtr_t)&pAnchor->next); 100 break; 101 default: 102 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 103 } 104 if (rc != SML_ERR_OK) { 105 smlFreeMetinfAnchor(pAnchor); 106 //smlLibFree(pAnchor); 107 return rc; 108 } 109 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 110 smlFreeMetinfAnchor(pAnchor); 111 //smlLibFree(pAnchor); 112 return rc; 113 } 114 } 115 *ppElem = pAnchor; 116 117 return SML_ERR_OK; 118 } 119 120 Ret_t buildMetInfMemCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { 121 XltDecScannerPtr_t pScanner; 122 SmlMetInfMemPtr_t pMem; 123 Ret_t rc; 124 125 pScanner = pDecoder->scanner; 126 127 if (*ppElem != NULL) 128 return SML_ERR_XLT_INVAL_SYNCML_DOC; 129 130 if ((pMem = (SmlMetInfMemPtr_t)smlLibMalloc(sizeof(SmlMetInfMem_t))) == NULL) 131 return SML_ERR_NOT_ENOUGH_SPACE; 132 smlLibMemset(pMem, 0, sizeof(SmlMetInfMem_t)); 133 134 if (IS_EMPTY(pScanner->curtok)) { 135 *ppElem = pMem; 136 return SML_ERR_OK; 137 } 138 139 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 140 smlFreeMetinfMem(pMem); 141 //smlLibFree(pMem); 142 return rc; 143 } 144 145 while (pScanner->curtok->type != TOK_TAG_END) { 146 switch (pScanner->curtok->tagid) { 147 /* PCDATA elements */ 148 case TN_METINF_SHAREDMEM: 149 rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->shared); 150 break; 151 case TN_METINF_FREEMEM: 152 rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->free); 153 break; 154 case TN_METINF_FREEID: 155 rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->freeid); 156 break; 157 default: 158 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 159 } 160 if (rc != SML_ERR_OK) { 161 smlFreeMetinfMem(pMem); 162 //smlLibFree(pMem); 163 return rc; 164 } 165 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 166 smlFreeMetinfMem(pMem); 167 //smlLibFree(pMem); 168 return rc; 169 } 170 } 171 *ppElem = pMem; 172 173 return SML_ERR_OK; 174 } 175 176 Ret_t buildMetInfMetInfCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { 177 XltDecScannerPtr_t pScanner; 178 SmlMetInfMetInfPtr_t pMeta; 179 Ret_t rc; 180 int foundWrapper = 0; 181 182 pScanner = pDecoder->scanner; 183 184 if (*ppElem != NULL) 185 return SML_ERR_XLT_INVAL_SYNCML_DOC; 186 187 if ((pMeta = (SmlMetInfMetInfPtr_t)smlLibMalloc(sizeof(SmlMetInfMetInf_t))) == NULL) 188 return SML_ERR_NOT_ENOUGH_SPACE; 189 smlLibMemset(pMeta, 0, sizeof(SmlMetInfMetInf_t)); 190 191 if (IS_EMPTY(pScanner->curtok)) { 192 *ppElem = pMeta; 193 return SML_ERR_OK; 194 } 195 196 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 197 smlFreeMetinfMetinf(pMeta); 198 //smlLibFree(pMeta); 199 return rc; 200 } 201 202 while (pScanner->curtok->type != TOK_TAG_END) { 203 switch (pScanner->curtok->tagid) { 204 case TN_METINF_METINF: /* ignore - it's just the wrapper tag */ 205 foundWrapper = 1; 206 break; 207 case TN_METINF_FORMAT: 208 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->format); 209 break; 210 case TN_METINF_TYPE: 211 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->type); 212 #ifdef __USE_DMTND__ 213 if ( NULL != pMeta->type && NULL != pMeta->type->content ) 214 { 215 if ( !smlLibStrcmp(pMeta->type->content, META_TYPE_TNDS_XML ) ) 216 { 217 pDecoder->tndsEncoding = SML_XML; 218 } 219 else if ( !smlLibStrcmp(pMeta->type->content, META_TYPE_TNDS_XML ) ) 220 { 221 pDecoder->tndsEncoding = SML_WBXML; 222 } 223 if ( pDecoder->smlEncoding != pDecoder->tndsEncoding ) 224 { 225 KCDBG("Mismatching SML and TNDS encoding schema!"); 226 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 227 } 228 } 229 #endif 230 break; 231 case TN_METINF_MARK: 232 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->mark); 233 break; 234 case TN_METINF_SIZE: 235 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->size); 236 break; 237 case TN_METINF_VERSION: 238 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->version); 239 break; 240 case TN_METINF_NEXTNONCE: 241 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->nextnonce); 242 break; 243 case TN_METINF_ANCHOR: 244 rc = buildMetInfAnchorCmd(pDecoder, (VoidPtr_t)&pMeta->anchor); 245 break; 246 case TN_METINF_MAXMSGSIZE: 247 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->maxmsgsize); 248 break; 249 /* SCTSTK - 18/03/2002 S.H. 2002-04-05: SyncML 1.1 */ 250 case TN_METINF_MAXOBJSIZE: 251 rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->maxobjsize); 252 break; 253 case TN_METINF_MEM: 254 rc = buildMetInfMemCmd(pDecoder, (VoidPtr_t)&pMeta->mem); 255 break; 256 case TN_METINF_EMI: 257 rc = buildPCDataList(pDecoder, (VoidPtr_t)&pMeta->emi); 258 break; 259 default: 260 rc = SML_ERR_XLT_INVAL_SYNCML_DOC; 261 } 262 if (rc != SML_ERR_OK) { 263 smlFreeMetinfMetinf(pMeta); 264 //smlLibFree(pMeta); 265 return rc; 266 } 267 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 268 smlFreeMetinfMetinf(pMeta); 269 //smlLibFree(pMeta); 270 return rc; 271 } 272 } 273 274 if (foundWrapper) { 275 /* Optional Metinf root tag was used in this message. 276 * The actual token is the closing root tag. 277 * It is required that the scanner points to the first tag _after_ 278 * <MetInf>...</MetInf>, so we just skip to the next token and continue. 279 */ 280 if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { 281 smlFreeMetinfMetinf(pMeta); 282 //smlLibFree(pMeta); 283 return rc; 284 } 285 } 286 *ppElem = pMeta; 287 288 return SML_ERR_OK; 289 } 290 291 292 293 /* see xltenc.c:XltEncBlock for description of parameters */ 294 Ret_t metinfEncBlock(XltTagID_t tagId, XltRO_t reqOptFlag, const VoidPtr_t pContent, SmlEncoding_t enc, BufferMgmtPtr_t pBufMgr, SmlPcdataExtension_t attFlag) { 295 //Return variable 296 Ret_t _err; 297 SmlPcdataListPtr_t pList = NULL; 298 //Check if pContent of a required field is missing 299 if ((reqOptFlag == REQUIRED) && (pContent == NULL)) 300 return SML_ERR_XLT_MISSING_CONT; 301 //Check if pContent of a optional field is missing -> if yes we are done 302 else if (pContent == NULL) 303 return SML_ERR_OK; 304 305 //Generate the commands -> see DTD 306 switch (tagId) { 307 case TN_METINF_ANCHOR: 308 if ((_err = xltGenerateTag(TN_METINF_ANCHOR, TT_BEG, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 309 if ((_err = metinfEncBlock(TN_METINF_LAST, OPTIONAL, ((SmlMetInfAnchorPtr_t) pContent)->last, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 310 if ((_err = metinfEncBlock(TN_METINF_NEXT, REQUIRED, ((SmlMetInfAnchorPtr_t) pContent)->next, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 311 if ((_err = xltGenerateTag(TN_METINF_ANCHOR, TT_END, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 312 break; 313 case TN_METINF_MEM: 314 if ((_err = xltGenerateTag(TN_METINF_MEM, TT_BEG, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 315 if ((_err = metinfEncBlock(TN_METINF_SHAREDMEM, OPTIONAL, ((SmlMetInfMemPtr_t) pContent)->shared, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 316 if ((_err = metinfEncBlock(TN_METINF_FREEMEM, REQUIRED, ((SmlMetInfMemPtr_t) pContent)->free, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 317 if ((_err = metinfEncBlock(TN_METINF_FREEID, REQUIRED, ((SmlMetInfMemPtr_t) pContent)->freeid, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 318 if ((_err = xltGenerateTag(TN_METINF_MEM, TT_END, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 319 break; 320 case TN_METINF_SHAREDMEM: 321 //set the flag in the (WB)XML document if the flag is in the pContent 322 if ((*((Flag_t *) pContent)) & (SmlMetInfSharedMem_f)) 323 if ((_err = xltGenerateTag(tagId, TT_ALL, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 324 break; 325 case TN_METINF_METINF: 326 //if ((_err = xltGenerateTag(TN_METINF_METINF, TT_BEG, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 327 if ((_err = metinfEncBlock(TN_METINF_FORMAT, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->format, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 328 if ((_err = metinfEncBlock(TN_METINF_TYPE, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->type, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 329 if ((_err = metinfEncBlock(TN_METINF_MARK, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->mark, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 330 if ((_err = metinfEncBlock(TN_METINF_SIZE, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->size, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 331 if ((_err = metinfEncBlock(TN_METINF_ANCHOR, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->anchor, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 332 if ((_err = metinfEncBlock(TN_METINF_VERSION, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->version, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 333 if ((_err = metinfEncBlock(TN_METINF_NEXTNONCE, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->nextnonce, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 334 if ((_err = metinfEncBlock(TN_METINF_MAXMSGSIZE,OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->maxmsgsize, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 335 // %%% luz 2003-04-24: added maxobjsize generation (was missing = bug in original RTK 4.1) 336 if ((_err = metinfEncBlock(TN_METINF_MAXOBJSIZE,OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->maxobjsize, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 337 pList = ((SmlMetInfMetInfPtr_t)pContent)->emi; 338 while (pList != NULL) { 339 if ((_err = xltEncBlock(TN_METINF_EMI, OPTIONAL, pList->data, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 340 pList = pList->next; 341 }; 342 343 if ((_err = metinfEncBlock(TN_METINF_MEM, OPTIONAL, ((SmlMetInfMetInfPtr_t) pContent)->mem, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 344 //if ((_err = xltGenerateTag(TN_METINF_METINF, TT_END, enc, pBufMgr, SML_EXT_METINF)) != SML_ERR_OK) return _err; 345 break; 346 default: { // all leaf nodes (PCDATA#) 347 return xltEncPcdata(tagId, reqOptFlag, pContent, enc, pBufMgr, attFlag); 348 } /* eof default statement from switch tagid */ 349 } /* eof switch tagid */ 350 return SML_ERR_OK; 351 } 352 353 #endif /* __USE_METINF__ */ 354 355
