1 /*

     2 * Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  SyncML command struct implementations.

    15 *

    16 */

    17 

    18 

    19 // ------------------------------------------------------------------------------------------------

    20 // Includes

    21 // ------------------------------------------------------------------------------------------------

    22 

    23 #include "smldtd.h"

    24 #include "smlsyncmltags.h"

    25 #include "smlmetinfdtd.h"

    26 #include "smldevinfdtd.h"

    27 #include "WBXMLSyncMLParser.h"

    28 #include "WBXMLParserError.h"

    29 

    30 // ------------------------------------------------------------------------------------------------

    31 // Macros

    32 // ------------------------------------------------------------------------------------------------

    33 #define CHECK_NO_DUPLICATE(a) if( a ) { User::Leave(KErrParserErrorInvalidDocument); }

    34 

    35 // ------------------------------------------------------------------------------------------------

    36 // Helper functions

    37 // ------------------------------------------------------------------------------------------------

    38 CXMLElement* AddPCDataL( SmlPcdataListPtr_t* aList )

    39 	{

    40 	SmlPcdataListPtr_t itemL = new (ELeave) SmlPcdataList_t();

    41 	CleanupStack::PushL(itemL);

    42 	itemL->data = new (ELeave) SmlPcdata_t();

    43 	GenericListAddL(aList, itemL);

    44 	CleanupStack::Pop(); // itemL

    45 	return itemL->data;

    46 	}

    47 

    48 // ------------------------------------------------------------------------------------------------

    49 CXMLElement* AddItemL( SmlItemListPtr_t* aList )

    50 	{

    51 	SmlItemListPtr_t itemL = new (ELeave) SmlItemList_t();

    52 	CleanupStack::PushL(itemL);

    53 	itemL->item = new (ELeave) SmlItem_t();

    54 	GenericListAddL(aList, itemL);

    55 	CleanupStack::Pop(); // itemL

    56 	return itemL->item;

    57 	}

    58 

    59 // ------------------------------------------------------------------------------------------------

    60 CXMLElement* AddMapItemL( SmlMapItemListPtr_t* aList )

    61 	{

    62 	SmlMapItemListPtr_t itemL = new (ELeave) SmlMapItemList_t();

    63 	CleanupStack::PushL(itemL);

    64 	itemL->mapItem = new (ELeave) SmlMapItem_t();

    65 	GenericListAddL(aList, itemL);

    66 	CleanupStack::Pop(); // itemL

    67 	return itemL->mapItem;

    68 	}

    69 

    70 // ------------------------------------------------------------------------------------------------

    71 CXMLElement* AddSourceListL( SmlSourceListPtr_t* aList )

    72 	{

    73 	SmlSourceListPtr_t itemL = new (ELeave) SmlSourceList_t();

    74 	CleanupStack::PushL(itemL);

    75 	itemL->source = new (ELeave) SmlSource_t();

    76 	GenericListAddL(aList, itemL);

    77 	CleanupStack::Pop(); // itemL

    78 	return itemL->source;

    79 	}

    80 

    81 // ------------------------------------------------------------------------------------------------

    82 CXMLElement* AddTargetRefL( SmlTargetRefListPtr_t* aList )

    83 	{

    84 	SmlTargetRefListPtr_t itemL = new (ELeave) SmlTargetRefList_t();

    85 	CleanupStack::PushL(itemL);

    86 	itemL->targetRef = new (ELeave) SmlPcdata_t();

    87 	GenericListAddL(aList, itemL);

    88 	CleanupStack::Pop(); // itemL

    89 	return itemL->targetRef;

    90 	}

    91 

    92 // ------------------------------------------------------------------------------------------------

    93 CXMLElement* AddSourceRefL( SmlSourceRefListPtr_t* aList )

    94 	{

    95 	SmlSourceRefListPtr_t itemL = new (ELeave) SmlSourceRefList_t();

    96 	CleanupStack::PushL(itemL);

    97 	itemL->sourceRef = new (ELeave) SmlPcdata_t();

    98 	GenericListAddL(aList, itemL);

    99 	CleanupStack::Pop(); // itemL

   100 	return itemL->sourceRef;

   101 	}

   102 

   103 // ------------------------------------------------------------------------------------------------

   104 LOCAL_D TBool CreateBasicCommandL( CXMLElement*& aElement, TUint8 aTag )

   105 	{

   106 	aElement = 0;

   107 	switch( aTag )

   108 		{

   109 		case EMap:

   110 			aElement = new (ELeave) SmlMap_t();

   111 			return ETrue;

   112 

   113 		case EAlert:

   114 			aElement = new (ELeave) SmlAlert_t();

   115 			return ETrue;

   116 		

   117 		case EAtomic:

   118 			aElement = new (ELeave) SmlAtomic_t(SML_PE_ATOMIC_START);

   119 			return ETrue;

   120 

   121 		case EAdd:

   122 		case ECopy:

   123 		case EDelete:

   124 		case EReplace:

   125 		case EMove:

   126 			aElement = new (ELeave) SmlCopy_t();

   127 			return ETrue;

   128 

   129 		case EGet:

   130 		case EPut:

   131 			aElement = new (ELeave) SmlGet_t();

   132 			return ETrue;

   133 

   134 		case EExec:

   135 			aElement = new (ELeave) SmlExec_t();

   136 			return ETrue;

   137 

   138 		case EResults:

   139 			aElement = new (ELeave) SmlResults_t();

   140 			return ETrue;

   141 

   142 		case ESearch:

   143 			aElement = new (ELeave) SmlSearch_t();

   144 			return ETrue;

   145 

   146 		case ESequence:

   147 			aElement = new (ELeave) SmlSequence_t(SML_PE_SEQUENCE_START);

   148 			return ETrue;

   149 

   150 		case EStatus:

   151 			aElement = new (ELeave) SmlStatus_t();

   152 			return ETrue;

   153 

   154 		case ESync:

   155 			aElement = new (ELeave) SmlSync_t();

   156 			return ETrue;

   157 

   158 		default:

   159 			break;

   160 		}

   161 	return EFalse;

   162 	}

   163 

   164 // ------------------------------------------------------------------------------------------------

   165 // sml_pcdata_s

   166 // ------------------------------------------------------------------------------------------------

   167 EXPORT_C sml_pcdata_s::sml_pcdata_s( const SmlPcdataType_t aType, const SmlPcdataExtension_t aExt )

   168 	: contentType(aType), extension(aExt)

   169 	{

   170 	}

   171 

   172 // ------------------------------------------------------------------------------------------------

   173 EXPORT_C sml_pcdata_s::sml_pcdata_s() : contentType(SML_PCDATA_OPAQUE), extension(SML_EXT_UNDEFINED)

   174 	{

   175 	}

   176 

   177 // ------------------------------------------------------------------------------------------------

   178 EXPORT_C sml_pcdata_s::~sml_pcdata_s()

   179 	{

   180 	FreeContent();

   181 	}

   182 

   183 // ------------------------------------------------------------------------------------------------

   184 EXPORT_C void sml_pcdata_s::FreeContent()

   185 	{

   186 	if( extension == SML_EXT_METINF )

   187 		{

   188 		delete SmlMetInfMetInfPtr_t(content);

   189 		}

   190     else if( extension == SML_EXT_DEVINFPROP )

   191 		{

   192         delete SmlDevInfPropertyListPtr_t(content);            

   193 		}

   194 	else

   195 		{

   196 		delete content;

   197 		}

   198 	content = 0;

   199 	}

   200 

   201 // ------------------------------------------------------------------------------------------------

   202 EXPORT_C void sml_pcdata_s::SetDataL( const TDesC8& aData )

   203 	{

   204 	FreeContent();

   205 	length = aData.Length();

   206 	content = User::AllocL(length);

   207 	Mem::Copy(content, aData.Ptr(), length);

   208 	}

   209 

   210 // ------------------------------------------------------------------------------------------------

   211 EXPORT_C TPtrC8 sml_pcdata_s::Data() const

   212 	{

   213 	return TPtrC8((TUint8*)content, length);

   214 	}

   215 

   216 	// ------------------------------------------------------------------------------------------------

   217 EXPORT_C void sml_pcdata_s::TruncateL( TInt aConsumed )

   218 	{

   219 	HBufC8* buffer = TPtrC8((TUint8*)content + aConsumed, length - aConsumed).AllocLC();

   220 	SetDataL(*buffer);

   221 	CleanupStack::PopAndDestroy(); // buffer

   222 	}

   223 

   224 // ------------------------------------------------------------------------------------------------

   225 // sml_pcdata_list_s

   226 // ------------------------------------------------------------------------------------------------

   227 EXPORT_C sml_pcdata_list_s::sml_pcdata_list_s()

   228 	{

   229 	}

   230 

   231 // ------------------------------------------------------------------------------------------------

   232 EXPORT_C sml_pcdata_list_s::~sml_pcdata_list_s()

   233 	{

   234 	delete data;

   235 	}

   236 

   237 // ------------------------------------------------------------------------------------------------

   238 // sml_chal_s

   239 // ------------------------------------------------------------------------------------------------

   240 EXPORT_C sml_chal_s::sml_chal_s()

   241 	{

   242 	delete meta;

   243 	}

   244 

   245 // ------------------------------------------------------------------------------------------------

   246 EXPORT_C sml_chal_s::~sml_chal_s()

   247 	{

   248 	delete meta;

   249 	}

   250 

   251 // ------------------------------------------------------------------------------------------------

   252 CXMLElement* sml_chal_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   253 	{

   254 	switch( aTag )

   255 		{

   256 		case EMeta:

   257 			CHECK_NO_DUPLICATE(meta);

   258 			meta = new (ELeave) SmlPcdata_t( /*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

   259 			meta->contentType = SML_PCDATA_EXTENSION;

   260 			meta->extension = SML_EXT_METINF;

   261 			return meta;

   262 

   263 		default:

   264 			User::Leave(KWBXMLParserErrorInvalidTag);

   265 		}

   266 	return 0;

   267 	}

   268 

   269 // ------------------------------------------------------------------------------------------------

   270 // sml_cred_s

   271 // ------------------------------------------------------------------------------------------------

   272 EXPORT_C sml_cred_s::sml_cred_s()

   273 	{

   274 	}

   275 

   276 // ------------------------------------------------------------------------------------------------

   277 EXPORT_C sml_cred_s::~sml_cred_s()

   278 	{

   279 	delete data;

   280 	delete meta;

   281 	}

   282 

   283 // ------------------------------------------------------------------------------------------------

   284 CXMLElement* sml_cred_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   285 	{

   286 	switch( aTag )

   287 		{

   288 		case EData:

   289 			CHECK_NO_DUPLICATE(data);

   290 			data = new (ELeave) SmlPcdata_t();

   291 			return data;

   292 

   293 		case EMeta:

   294 			CHECK_NO_DUPLICATE(meta)

   295 			meta = new (ELeave) SmlPcdata_t(/*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

   296 			meta->contentType = SML_PCDATA_EXTENSION;

   297 			meta->extension = SML_EXT_METINF;

   298 			return meta;

   299 

   300 		default:

   301 			User::Leave(KWBXMLParserErrorInvalidTag);

   302 		}

   303 	return 0;

   304 	}

   305 

   306 // 1.2 CHANGES: new common use elements

   307 // ------------------------------------------------------------------------------------------------

   308 // sml_field_or_record_s

   309 // ------------------------------------------------------------------------------------------------

   310 EXPORT_C sml_field_or_record_s::sml_field_or_record_s()

   311 	{

   312 	}

   313 

   314 // ------------------------------------------------------------------------------------------------

   315 EXPORT_C sml_field_or_record_s::~sml_field_or_record_s()

   316 	{

   317 	delete item;

   318 	}

   319 

   320 // ------------------------------------------------------------------------------------------------

   321 CXMLElement* sml_field_or_record_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   322 	{

   323 	switch( aTag )

   324 		{

   325 		case EItem:

   326 			CHECK_NO_DUPLICATE(item);

   327 			item = new (ELeave) SmlItem_t();

   328 			return item;

   329 			

   330 		default:

   331 			User::Leave(KWBXMLParserErrorInvalidTag);

   332 		}

   333 	return 0;

   334 	}

   335 

   336 

   337 // ------------------------------------------------------------------------------------------------

   338 // sml_filter_s

   339 // ------------------------------------------------------------------------------------------------

   340 EXPORT_C sml_filter_s::sml_filter_s()

   341 	{

   342 	}

   343 

   344 // ------------------------------------------------------------------------------------------------

   345 EXPORT_C sml_filter_s::~sml_filter_s()

   346 	{

   347 	delete meta;

   348 	delete field;

   349 	delete record;

   350 	delete filterType;

   351 	}

   352 

   353 // ------------------------------------------------------------------------------------------------

   354 CXMLElement* sml_filter_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   355 	{

   356 	switch( aTag )

   357 		{

   358 		case EMeta:

   359 			CHECK_NO_DUPLICATE(meta);

   360 			meta = new (ELeave) SmlPcdata_t();

   361 			meta->contentType = SML_PCDATA_EXTENSION;

   362 			meta->extension = SML_EXT_METINF;

   363 			return meta;

   364 

   365 		case EField:

   366 			CHECK_NO_DUPLICATE(field);

   367 			field = new (ELeave) SmlField_t();

   368 			return field;

   369 

   370 		case ERecord:

   371 			CHECK_NO_DUPLICATE(record);

   372 			record = new (ELeave) SmlRecord_t();

   373 			return record;

   374 

   375 		case EFilterType:

   376 			CHECK_NO_DUPLICATE(filterType);

   377 			filterType = new (ELeave) SmlPcdata_t();

   378 			return filterType;

   379 			

   380 		default:

   381 			User::Leave(KWBXMLParserErrorInvalidTag);

   382 		}

   383 	return 0;

   384 	}

   385 // Changes end

   386 

   387 // 1.2 CHANGES: Source & Target divided to their own structs

   388 

   389 // ------------------------------------------------------------------------------------------------

   390 // sml_source_s

   391 // ------------------------------------------------------------------------------------------------

   392 EXPORT_C sml_source_s::sml_source_s()

   393 	{

   394 	}

   395 

   396 // ------------------------------------------------------------------------------------------------

   397 EXPORT_C sml_source_s::~sml_source_s()

   398 	{

   399 	delete locURI;

   400 	delete locName;

   401 	}

   402 

   403 // ------------------------------------------------------------------------------------------------

   404 CXMLElement* sml_source_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   405 	{

   406 	switch( aTag )

   407 		{

   408 		case ELocURI:

   409 			CHECK_NO_DUPLICATE(locURI);

   410 			locURI = new (ELeave) SmlPcdata_t();

   411 			return locURI;

   412 

   413 		case ELocName:

   414 			CHECK_NO_DUPLICATE(locName);

   415 			locName = new (ELeave) SmlPcdata_t();

   416 			return locName;

   417 

   418 		default:

   419 			User::Leave(KWBXMLParserErrorInvalidTag);

   420 		}

   421 	return 0;

   422 	}

   423 

   424 // ------------------------------------------------------------------------------------------------

   425 // sml_target_s

   426 // ------------------------------------------------------------------------------------------------

   427 EXPORT_C sml_target_s::sml_target_s()

   428 	{

   429 	}

   430 

   431 // ------------------------------------------------------------------------------------------------

   432 EXPORT_C sml_target_s::~sml_target_s()

   433 	{

   434 	delete locURI;

   435 	delete locName;

   436 	delete filter;

   437 	}

   438 

   439 // ------------------------------------------------------------------------------------------------

   440 CXMLElement* sml_target_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   441 	{

   442 	switch( aTag )

   443 		{

   444 		case ELocURI:

   445 			CHECK_NO_DUPLICATE(locURI);

   446 			locURI = new (ELeave) SmlPcdata_t();

   447 			return locURI;

   448 			

   449 		case ELocName:

   450 			CHECK_NO_DUPLICATE(locName);

   451 			locName = new (ELeave) SmlPcdata_t();

   452 			return locName;

   453 

   454 		case EFilter:

   455 			CHECK_NO_DUPLICATE(filter);

   456 			filter = new (ELeave) SmlFilter_t();

   457 			return filter;

   458 			

   459 		default:

   460 			User::Leave(KWBXMLParserErrorInvalidTag);

   461 		}

   462 	return 0;

   463 	}

   464 // Changes end

   465 

   466 // ------------------------------------------------------------------------------------------------

   467 // sml_source_list_s

   468 // ------------------------------------------------------------------------------------------------

   469 EXPORT_C sml_source_list_s::sml_source_list_s()

   470 	{

   471 	}

   472 

   473 // ------------------------------------------------------------------------------------------------

   474 EXPORT_C sml_source_list_s::~sml_source_list_s()

   475 	{

   476 	delete source;

   477 	}

   478 

   479 //1.2 CHANGES: Source & Target parent

   480 // ------------------------------------------------------------------------------------------------

   481 // sml_source_or_target_parent_s

   482 // ------------------------------------------------------------------------------------------------

   483 EXPORT_C sml_source_or_target_parent_s::sml_source_or_target_parent_s()

   484 	{

   485 	}

   486 

   487 // ------------------------------------------------------------------------------------------------

   488 EXPORT_C sml_source_or_target_parent_s::~sml_source_or_target_parent_s()

   489 	{

   490 	delete locURI;

   491 	}

   492 

   493 // ------------------------------------------------------------------------------------------------

   494 CXMLElement* sml_source_or_target_parent_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   495 	{

   496 	switch( aTag )

   497 		{

   498 		case ELocURI:

   499 			CHECK_NO_DUPLICATE(locURI);

   500 			locURI = new (ELeave) SmlPcdata_t();

   501 			return locURI;

   502 			

   503 		default:

   504 			User::Leave(KWBXMLParserErrorInvalidTag);

   505 		}

   506 	return 0;

   507 	}

   508 // Changes end

   509 

   510 

   511 // ------------------------------------------------------------------------------------------------

   512 // sml_sync_hdr_s

   513 // ------------------------------------------------------------------------------------------------

   514 EXPORT_C sml_sync_hdr_s::sml_sync_hdr_s()

   515 	{

   516 	}

   517 

   518 // ------------------------------------------------------------------------------------------------

   519 EXPORT_C sml_sync_hdr_s::~sml_sync_hdr_s()

   520 	{

   521 	delete version;       

   522 	delete proto;         

   523 	delete sessionID;     

   524 	delete msgID;         

   525 	delete target;

   526 	delete source;

   527 	delete respURI;

   528 	delete cred;

   529 	delete meta;

   530 	}

   531 

   532 // ------------------------------------------------------------------------------------------------

   533 CXMLElement* sml_sync_hdr_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   534 	{

   535 	switch( aTag )

   536 		{

   537 		case EVerDTD:

   538 			CHECK_NO_DUPLICATE(version);

   539 			version = new (ELeave) SmlPcdata_t();

   540 			return version;

   541 

   542 		case EVerProto:

   543 			CHECK_NO_DUPLICATE(proto);

   544 			proto = new (ELeave) SmlPcdata_t();

   545 			return proto;

   546 

   547 		case ESessionID:

   548 			CHECK_NO_DUPLICATE(sessionID);

   549 			sessionID = new (ELeave) SmlPcdata_t();

   550 			return sessionID;

   551 

   552 		case EMsgID:

   553 			CHECK_NO_DUPLICATE(msgID);

   554 			msgID = new (ELeave) SmlPcdata_t();

   555 			return msgID;

   556 

   557 		case ETarget:

   558 			CHECK_NO_DUPLICATE(target);

   559 			target = new (ELeave) SmlTarget_t();

   560 			return target;

   561 

   562 		case ESource:

   563 			CHECK_NO_DUPLICATE(source);

   564 			source = new (ELeave) SmlSource_t();

   565 			return source;

   566 

   567 		case ERespURI:

   568 			CHECK_NO_DUPLICATE(respURI);

   569 			respURI = new (ELeave) SmlPcdata_t();

   570 			return respURI;

   571 

   572 		case ECred:

   573 			CHECK_NO_DUPLICATE(cred);

   574 			cred = new (ELeave) SmlCred_t();

   575 			return cred;

   576 

   577 		case EMeta:

   578 			CHECK_NO_DUPLICATE(meta);

   579 			meta = new (ELeave) SmlPcdata_t(/*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

   580 			meta->contentType = SML_PCDATA_EXTENSION;

   581 			meta->extension = SML_EXT_METINF;

   582 			return meta;

   583 

   584 		case ENoResp:

   585 			CHECK_NO_DUPLICATE(flags & SmlNoResp_f);

   586 			flags |= SmlNoResp_f;

   587 			break;

   588 

   589 		default:

   590 			User::Leave(KWBXMLParserErrorInvalidTag);

   591 		}

   592 	return 0;

   593 	}

   594 

   595 // ------------------------------------------------------------------------------------------------

   596 CXMLElement::TAction sml_sync_hdr_s::EndElementL( TAny* aCallbacks, TUint8 aTag )

   597 	{

   598 	switch( aTag )

   599 		{

   600 		case ESyncHdr:

   601 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlStartMessageFuncL(this);

   602 			return EPopAndDestroy;

   603 		

   604 		case ENoResp:

   605 			return ENone;

   606 

   607 		default:

   608 			User::Leave(KWBXMLParserErrorInvalidTag);

   609 		}

   610 

   611 	return EPop;

   612 	}

   613 

   614 // ------------------------------------------------------------------------------------------------

   615 TBool sml_sync_hdr_s::NeedsCleanup() const

   616 	{

   617 	return ETrue;

   618 	}

   619 

   620 // ------------------------------------------------------------------------------------------------

   621 // sml_item_s

   622 // ------------------------------------------------------------------------------------------------

   623 EXPORT_C sml_item_s::sml_item_s()

   624 	{

   625 	}

   626 

   627 // ------------------------------------------------------------------------------------------------

   628 EXPORT_C sml_item_s::~sml_item_s()

   629 	{

   630 	delete target;

   631 	delete source;

   632 	delete sourceParent;

   633 	delete targetParent;

   634 	delete meta;

   635 	delete data;

   636 	}

   637 

   638 // ------------------------------------------------------------------------------------------------

   639 CXMLElement* sml_item_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   640 	{

   641 	switch( aTag )

   642 		{

   643 		case ETarget:

   644 			CHECK_NO_DUPLICATE(target);

   645 			target = new (ELeave) SmlTarget_t();

   646 			return target;

   647 

   648 		case ESource:

   649 			CHECK_NO_DUPLICATE(source);

   650 			source = new (ELeave) SmlSource_t();

   651 			return source;

   652 

   653 // 1.2 CHANGES: SourceParent and TargetParent added

   654 		case ESourceParent:

   655 			CHECK_NO_DUPLICATE(sourceParent);

   656 			sourceParent = new (ELeave) SmlSourceParent_t();

   657 			return sourceParent;

   658 

   659 		case ETargetParent:

   660 			CHECK_NO_DUPLICATE(targetParent);

   661 			targetParent = new (ELeave) SmlTargetParent_t();

   662 			return targetParent;

   663 // End Changes

   664 

   665 		case EMeta:

   666 			CHECK_NO_DUPLICATE(meta);

   667 			meta = new (ELeave) SmlPcdata_t(/*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

   668 			meta->contentType = SML_PCDATA_EXTENSION;

   669 			meta->extension = SML_EXT_METINF;

   670 			return meta;

   671 

   672 		case EData:

   673 			CHECK_NO_DUPLICATE(data);

   674 			data = new (ELeave) SmlPcdata_t();

   675 			return data;

   676 

   677 		case EMoreData:

   678 			CHECK_NO_DUPLICATE(flags & SmlMoreData_f);

   679 			flags |= SmlMoreData_f;

   680 			break;

   681 

   682 		default:

   683 			User::Leave(KWBXMLParserErrorInvalidTag);

   684 		}

   685 	return 0;

   686 	}

   687 

   688 // ------------------------------------------------------------------------------------------------

   689 CXMLElement::TAction sml_item_s::EndElementL( TAny* /*aCallbacks*/, TUint8 aTag )

   690 	{

   691 	if( aTag == EMoreData )

   692 		{

   693 		return ENone;

   694 		}

   695 	return EPop;

   696 	}

   697 

   698 // ------------------------------------------------------------------------------------------------

   699 // sml_item_list_s

   700 // ------------------------------------------------------------------------------------------------

   701 EXPORT_C sml_item_list_s::sml_item_list_s()

   702 	{

   703 	}

   704 

   705 // ------------------------------------------------------------------------------------------------

   706 EXPORT_C sml_item_list_s::~sml_item_list_s()

   707 	{

   708 	delete item;

   709 	}

   710 

   711 // ------------------------------------------------------------------------------------------------

   712 // sml_generic_s

   713 // ------------------------------------------------------------------------------------------------

   714 EXPORT_C sml_generic_s::sml_generic_s()

   715 	{

   716 	}

   717 

   718 // ------------------------------------------------------------------------------------------------

   719 EXPORT_C sml_generic_s::~sml_generic_s()

   720 	{

   721 	delete cmdID;      

   722 	delete cred;

   723 	delete meta;

   724 	GenericListDelete( itemList );    		

   725 	}

   726 

   727 // ------------------------------------------------------------------------------------------------

   728 CXMLElement* sml_generic_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   729 	{

   730 	switch( aTag )

   731 		{

   732 		case ECmdID:

   733 			CHECK_NO_DUPLICATE(cmdID);

   734 			cmdID = new (ELeave) SmlPcdata_t();

   735 			return cmdID;

   736 

   737 		case ECred:

   738 			CHECK_NO_DUPLICATE(cred);

   739 			cred = new (ELeave) SmlCred_t();

   740 			return cred;

   741 

   742 		case EMeta:

   743 			CHECK_NO_DUPLICATE(meta);

   744 			meta = new (ELeave) SmlPcdata_t(/*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

   745 			meta->contentType = SML_PCDATA_EXTENSION;

   746 			meta->extension = SML_EXT_METINF;

   747 			return meta;

   748 

   749 		case ENoResp:

   750 			CHECK_NO_DUPLICATE(flags & SmlNoResp_f);

   751 			flags |= SmlNoResp_f;

   752 			break;

   753 

   754 		case EArchive:

   755 			CHECK_NO_DUPLICATE(flags & SmlArchive_f);

   756 			flags |= SmlArchive_f;

   757 			break;

   758 		

   759 		case ESftDel:

   760 			CHECK_NO_DUPLICATE(flags & SmlSftDel_f);

   761 			flags |= SmlSftDel_f;

   762 			break;

   763 

   764 		case EItem:

   765 			return AddItemL(&itemList);

   766 

   767 		default:

   768 			User::Leave(KWBXMLParserErrorInvalidTag);

   769 		}

   770 	return 0;

   771 	}

   772 

   773 // ------------------------------------------------------------------------------------------------

   774 CXMLElement::TAction sml_generic_s::EndElementL( TAny* aCallbacks, TUint8 aTag )

   775 	{

   776 	switch( aTag )

   777 		{

   778 		case EAdd:

   779 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlAddCmdFuncL(this);

   780 			return EPopAndDestroy;

   781 

   782 		case ECopy:

   783 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlCopyCmdFuncL(this);

   784 			return EPopAndDestroy;

   785 		

   786 		case EDelete:

   787 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlDeleteCmdFuncL(this);

   788 			return EPopAndDestroy;

   789 		

   790 		case EReplace:

   791 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlReplaceCmdFuncL(this);

   792 			return EPopAndDestroy;

   793 

   794 		case EMove:

   795 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlMoveCmdFuncL(this);

   796 			return EPopAndDestroy;

   797 

   798 		case ENoResp:

   799 		case EArchive:

   800 		case ESftDel:

   801 			return ENone;

   802 

   803 		default:

   804 			User::Leave(KWBXMLParserErrorInvalidTag);

   805 		}

   806 

   807 	return EPop;

   808 	}

   809 

   810 // ------------------------------------------------------------------------------------------------

   811 TBool sml_generic_s::NeedsCleanup() const

   812 	{

   813 	return ETrue;

   814 	}

   815 

   816 // ------------------------------------------------------------------------------------------------

   817 // sml_alert_s

   818 // ------------------------------------------------------------------------------------------------

   819 EXPORT_C sml_alert_s::sml_alert_s()

   820 	{

   821 	}

   822 

   823 // ------------------------------------------------------------------------------------------------

   824 EXPORT_C sml_alert_s::~sml_alert_s()

   825 	{

   826 	delete cmdID;      

   827 	delete cred;

   828 	delete data;

   829 	// FOTA

   830 	delete correlator;

   831 	// FOTA end	

   832 	GenericListDelete( itemList );	

   833 	}

   834 

   835 // ------------------------------------------------------------------------------------------------

   836 CXMLElement* sml_alert_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   837 	{

   838 	switch( aTag )

   839 		{

   840 		case ECmdID:

   841 			CHECK_NO_DUPLICATE(cmdID);

   842 			cmdID = new (ELeave) SmlPcdata_t();

   843 			return cmdID;

   844 

   845 		case ENoResp:

   846 			CHECK_NO_DUPLICATE(flags & SmlNoResp_f);

   847 			flags |= SmlNoResp_f;

   848 			break;

   849 

   850 		case ECred:

   851 			CHECK_NO_DUPLICATE(cred);

   852 			cred = new (ELeave) SmlCred_t();

   853 			return cred;

   854 

   855 		case EData:

   856 			CHECK_NO_DUPLICATE(data);

   857 			data = new (ELeave) SmlPcdata_t();

   858 			return data;

   859 // FOTA

   860 		case ECorrelator:

   861 			CHECK_NO_DUPLICATE(correlator);

   862 			correlator = new (ELeave) SmlPcdata_t();

   863 			return correlator;

   864 // FOTA end			

   865 

   866 		case EItem:

   867 			return AddItemL(&itemList);

   868 

   869 		default:

   870 			User::Leave(KWBXMLParserErrorInvalidTag);

   871 		}

   872 	return 0;

   873 	}

   874 

   875 // ------------------------------------------------------------------------------------------------

   876 CXMLElement::TAction sml_alert_s::EndElementL( TAny* aCallbacks, TUint8 aTag )

   877 	{

   878 	switch( aTag )

   879 		{

   880 		case EAlert:

   881 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlAlertCmdFuncL(this);

   882 			return EPopAndDestroy;

   883 

   884 		case ENoResp:

   885 			return ENone;

   886 

   887 		default:

   888 			User::Leave(KWBXMLParserErrorInvalidTag);

   889 		}

   890 

   891 	return EPop;

   892 	}

   893 

   894 // ------------------------------------------------------------------------------------------------

   895 TBool sml_alert_s::NeedsCleanup() const

   896 	{

   897 	return ETrue;

   898 	}

   899 

   900 // ------------------------------------------------------------------------------------------------

   901 // sml_atomic_s

   902 // ------------------------------------------------------------------------------------------------

   903 EXPORT_C sml_atomic_s::sml_atomic_s( SmlProtoElement_t aType )

   904 	{

   905 	elementType = aType;

   906 	}

   907 

   908 // ------------------------------------------------------------------------------------------------

   909 EXPORT_C sml_atomic_s::~sml_atomic_s()

   910 	{

   911 	delete cmdID;      

   912 	delete meta;

   913 	}

   914 

   915 // ------------------------------------------------------------------------------------------------

   916 CXMLElement* sml_atomic_s::BeginElementL( TUint8 aTag, const TXMLElementParams& aParams )

   917 	{

   918 	switch( aTag )

   919 		{

   920 		case ECmdID:

   921 			CHECK_NO_DUPLICATE(cmdID);

   922 			cmdID = new (ELeave) SmlPcdata_t();

   923 			return cmdID;

   924 

   925 		case ENoResp:

   926 			CHECK_NO_DUPLICATE(flags & SmlNoResp_f);

   927 			flags |= SmlNoResp_f;

   928 			break;

   929 

   930 		case EMeta:

   931 			CHECK_NO_DUPLICATE(meta);

   932 			meta = new (ELeave) SmlPcdata_t(/*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

   933 			meta->contentType = SML_PCDATA_EXTENSION;

   934 			meta->extension = SML_EXT_METINF;

   935 			return meta;

   936 

   937 		default:

   938 			CXMLElement* e;

   939 			if( CreateBasicCommandL(e, aTag) )

   940 				{

   941 				if( this->elementType == SML_PE_ATOMIC_START )

   942 					{

   943 					this->elementType = SML_PE_ATOMIC_END;

   944 					((MWBXMLSyncMLCallbacks*)aParams.Callbacks())->smlStartAtomicFuncL(this);

   945 					}

   946 				else if( this->elementType == SML_PE_SEQUENCE_START )

   947 					{

   948 					this->elementType = SML_PE_SEQUENCE_END;

   949 					((MWBXMLSyncMLCallbacks*)aParams.Callbacks())->smlStartSequenceFuncL(this);

   950 					}

   951 				}

   952 			else

   953 				{

   954 				User::Leave(KWBXMLParserErrorInvalidTag);

   955 				}

   956 			return e;

   957 		}

   958 	return 0;

   959 	}

   960 

   961 // ------------------------------------------------------------------------------------------------

   962 CXMLElement::TAction sml_atomic_s::EndElementL( TAny* aCallbacks, TUint8 aTag )

   963 	{

   964 	switch( aTag )

   965 		{

   966 		case EAtomic:

   967 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlEndAtomicFuncL();

   968 			return EPopAndDestroy;

   969 

   970 		case ESequence:

   971 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlEndSequenceFuncL();

   972 			return EPopAndDestroy;

   973 

   974 		case ENoResp:

   975 			return ENone;

   976 

   977 		default:

   978 			User::Leave(KWBXMLParserErrorInvalidTag);

   979 		}

   980 

   981 	return EPop;

   982 	}

   983 

   984 // ------------------------------------------------------------------------------------------------

   985 TBool sml_atomic_s::NeedsCleanup() const

   986 	{

   987 	return ETrue;

   988 	}

   989 

   990 // ------------------------------------------------------------------------------------------------

   991 // sml_sync_s

   992 // ------------------------------------------------------------------------------------------------

   993 

   994 

   995 EXPORT_C sml_sync_s::sml_sync_s()

   996 	{

   997 	elementType = SML_PE_SYNC_START;

   998 	}

   999 

  1000 // ------------------------------------------------------------------------------------------------

  1001 EXPORT_C sml_sync_s::~sml_sync_s()

  1002 	{

  1003 	delete cmdID;

  1004 	delete cred;

  1005 	delete target;

  1006 	delete source;

  1007 	delete meta;

  1008 	delete noc;

  1009 	}

  1010 

  1011 // ------------------------------------------------------------------------------------------------

  1012 CXMLElement* sml_sync_s::BeginElementL( TUint8 aTag, const TXMLElementParams& aParams )

  1013 	{

  1014 	switch( aTag )

  1015 		{

  1016 		case ECmdID:

  1017 			CHECK_NO_DUPLICATE(cmdID);

  1018 			cmdID = new (ELeave) SmlPcdata_t();

  1019 			return cmdID;

  1020 

  1021 		case ENoResp:

  1022 			CHECK_NO_DUPLICATE(flags & SmlNoResp_f);

  1023 			flags |= SmlNoResp_f;

  1024 			break;

  1025 

  1026 		case ECred:

  1027 			CHECK_NO_DUPLICATE(cred);

  1028 			cred = new (ELeave) SmlCred_t();

  1029 			return cred;

  1030 

  1031 		case ETarget:

  1032 			CHECK_NO_DUPLICATE(target);

  1033 			target = new (ELeave) SmlTarget_t();

  1034 			return target;

  1035 

  1036 		case ESource:

  1037 			CHECK_NO_DUPLICATE(source);

  1038 			source = new (ELeave) SmlSource_t();

  1039 			return source;

  1040 

  1041 		case EMeta:

  1042 			CHECK_NO_DUPLICATE(meta);

  1043 			meta = new (ELeave) SmlPcdata_t(/*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

  1044 			meta->contentType = SML_PCDATA_EXTENSION;

  1045 			meta->extension = SML_EXT_METINF;

  1046 			return meta;

  1047 

  1048 		case ENumberOfChanges:

  1049 			CHECK_NO_DUPLICATE(noc);

  1050 			noc = new (ELeave) SmlPcdata_t();

  1051 			return noc;

  1052 

  1053 		default:

  1054 			CXMLElement* e;

  1055 			if( CreateBasicCommandL(e, aTag) )

  1056 				{

  1057 				if( this->elementType == SML_PE_SYNC_START )

  1058 					{

  1059 					this->elementType = SML_PE_SYNC_END;

  1060 					((MWBXMLSyncMLCallbacks*)aParams.Callbacks())->smlStartSyncFuncL(this);

  1061 					}

  1062 				}

  1063 			else

  1064 				{

  1065 				User::Leave(KWBXMLParserErrorInvalidTag);

  1066 				}

  1067 			return e;

  1068 		}

  1069 	return 0;

  1070 	}

  1071 

  1072 // ------------------------------------------------------------------------------------------------

  1073 CXMLElement::TAction sml_sync_s::EndElementL( TAny* aCallbacks, TUint8 aTag )

  1074 	{

  1075 	switch( aTag )

  1076 		{

  1077 		case ESync:

  1078 			// If Sync element did not contain any commands -> call startsync and then end sync

  1079 			if( this->elementType == SML_PE_SYNC_START )

  1080 				{

  1081 				this->elementType = SML_PE_SYNC_END;

  1082 				((MWBXMLSyncMLCallbacks*)aCallbacks)->smlStartSyncFuncL(this);

  1083 				}

  1084 			((MWBXMLSyncMLCallbacks*)aCallbacks)->smlEndSyncFuncL();

  1085 			return EPopAndDestroy;

  1086 

  1087 		case ENoResp:

  1088 			return ENone;

  1089 

  1090 		default:

  1091 			User::Leave(KWBXMLParserErrorInvalidTag);

  1092 		}

  1093 

  1094 	return EPop;

  1095 	}

  1096 

  1097 // ------------------------------------------------------------------------------------------------

  1098 TBool sml_sync_s::NeedsCleanup() const

  1099 	{

  1100 	return ETrue;

  1101 	}

  1102 

  1103 // ------------------------------------------------------------------------------------------------

  1104 // sml_exec_s

  1105 // ------------------------------------------------------------------------------------------------

  1106 EXPORT_C sml_exec_s::sml_exec_s()

  1107 	{

  1108 	}

  1109 

  1110 // ------------------------------------------------------------------------------------------------

  1111 EXPORT_C sml_exec_s::~sml_exec_s()

  1112 	{

  1113 	delete cmdID;      

  1114 	delete cred;

  1115 	delete meta;

  1116 	// FOTA

  1117 	delete correlator;

  1118 	// FOTA end

  1119 	delete item;

  1120 	}

  1121 

  1122 // ------------------------------------------------------------------------------------------------

  1123 CXMLElement* sml_exec_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

  1124 	{

  1125 	switch( aTag )

  1126 		{

  1127 		case ECmdID:

  1128 			CHECK_NO_DUPLICATE(cmdID);

  1129 			cmdID = new (ELeave) SmlPcdata_t();

  1130 			return cmdID;

  1131 

  1132 		case ENoResp:

  1133 			CHECK_NO_DUPLICATE(flags & SmlNoResp_f);

  1134 			flags |= SmlNoResp_f;