src/agent/serviceadapter/protocolbinder/syncml_protocol_binder.c

   1 /*
   2  * oma-dm-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /*lib*/
  19 #include <glib.h>
  20 #include <assert.h>
  21
  22 /*sync-agent*/
  23 #include <sync_agent.h>
  24
  25 /*dm-agent*/
  26 #include "common/dm_common.h"
  27 #include "common/util/util.h"
  28 #include "serviceadapter/protocolbinder/syncml_def.h"
  29 #include "serviceadapter/protocolbinder/syncml_protocol_binder.h"
  30 #include "serviceadapter/sa_command_internal.h"
  31 #include "serviceadapter/sa_command.h"
  32 #include "serviceadapter/sa_elements_internal.h"
  33 #include "serviceadapter/sa_elements.h"
  34 #include "serviceadapter/sa_define.h"
  35
  36 #ifndef OMADM_AGENT_LOG
  37 #undef LOG_TAG
  38 #define LOG_TAG "OMA_DM_BINDER"
  39 #endif
  40
  41 #define SYNC_AGENT_INIT_ESTIMATE_DOC_SIZE       10      /* TODO : remove */
  42
  43 static ProtocolVersion __get_oma_dm_protocol_version(char *verdtd);
  44 static Location *__get_location(WBXMLTreeNode * node);
  45 static Cred *__get_cred(WBXMLTreeNode * node);
  46 static Chal *__get_chal(WBXMLTreeNode * node);
  47
  48 static sync_agent_pb_error_e __append_location_to_wbxml_node(Location * pLocation, sync_agent_pb_protocol_binder_info_s * pBinder, WBXMLTreeNode * parent_node);
  49 static sync_agent_pb_error_e __append_cred_to_wbxml_node(Cred * pCred, sync_agent_pb_protocol_binder_info_s * pBinder, WBXMLTreeNode * parent_node);
  50 static sync_agent_pb_error_e __append_chal_to_wbxml_node(Chal * pChal, sync_agent_pb_protocol_binder_info_s * pBinder, WBXMLTreeNode * parent_node);
  51
  52 static sync_agent_pb_error_e _syncml_binder_syncml_start_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  53 static sync_agent_pb_error_e _syncml_binder_header_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  54 static sync_agent_pb_error_e _syncml_binder_final_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  55 static sync_agent_pb_error_e _syncml_binder_body_start_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  56 static sync_agent_pb_error_e _syncml_binder_status_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  57 static sync_agent_pb_error_e _syncml_binder_alert_command_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  58 static sync_agent_pb_error_e _syncml_binder_results_command_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  59 static sync_agent_pb_error_e _syncml_binder_replace_command_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node);
  60
  61 static sync_agent_pb_error_e _syncml_binder_header_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  62 static sync_agent_pb_error_e _syncml_binder_results_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  63 static sync_agent_pb_error_e _syncml_binder_get_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  64 static sync_agent_pb_error_e _syncml_binder_alert_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  65 static sync_agent_pb_error_e _syncml_binder_add_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  66 static sync_agent_pb_error_e _syncml_binder_replace_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  67 static sync_agent_pb_error_e _syncml_binder_delete_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  68 static sync_agent_pb_error_e _syncml_binder_atomic_end_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  69 static sync_agent_pb_error_e _syncml_binder_atomic_start_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  70 static sync_agent_pb_error_e _syncml_binder_sequence_end_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  71 static sync_agent_pb_error_e _syncml_binder_sequence_start_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  72 static sync_agent_pb_error_e _syncml_binder_exec_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  73 static sync_agent_pb_error_e _syncml_binder_final_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  74 static sync_agent_pb_error_e _syncml_binder_status_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  75 static sync_agent_pb_error_e _syncml_binder_copy_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent);
  76
  77 const sync_agent_pb_function_info_s oma_dm_binder_function_info[] = {
  78         {PE_SYNCML_START, "SyncML", _syncml_binder_syncml_start_converter_function, NULL, false},
  79         {PE_SYNCML_END, "/SyncML", NULL, NULL, false},
  80         {PE_HEADER, "SyncHdr", _syncml_binder_header_converter_function, _syncml_binder_header_reverse_converter_function, true},
  81         {PE_BODY_START, "SyncBody", _syncml_binder_body_start_converter_function, NULL, false},
  82         {PE_BODY_END, "/SyncBody", NULL, NULL, false},
  83         {PE_FINAL, "Final", _syncml_binder_final_converter_function, _syncml_binder_final_reverse_converter_function, true},
  84         {PE_ALERT, "Alert", _syncml_binder_alert_command_converter_function, _syncml_binder_alert_command_reverse_converter_function, true},
  85         {PE_STATUS, "Status", _syncml_binder_status_converter_function, _syncml_binder_status_reverse_converter_function, true},
  86         {PE_RESULTS_START, "Results", _syncml_binder_results_command_converter_function, _syncml_binder_results_command_reverse_converter_function, false},
  87         {PE_RESULTS_END, "/Results", NULL, NULL, false},
  88         {PE_GET, "Get", NULL, _syncml_binder_get_command_reverse_converter_function, true},
  89         {PE_ADD, "Add", NULL, _syncml_binder_add_command_reverse_converter_function, true},
  90         {PE_REPLACE, "Replace", _syncml_binder_replace_command_converter_function, _syncml_binder_replace_command_reverse_converter_function, true},
  91         {PE_DELETE, "Delete", NULL, _syncml_binder_delete_command_reverse_converter_function, true},
  92         {PE_EXEC, "Exec", NULL, _syncml_binder_exec_command_reverse_converter_function, true},
  93         {PE_SEQUENCE_START, "Sequence", NULL, _syncml_binder_sequence_start_command_reverse_converter_function, false},
  94         {PE_SEQUENCE_END, "/Sequence", NULL, _syncml_binder_sequence_end_command_reverse_converter_function, false},
  95         {PE_ATOMIC_START, "Atomic", NULL, _syncml_binder_atomic_start_command_reverse_converter_function, false},
  96         {PE_ATOMIC_END, "/Atomic", NULL, _syncml_binder_atomic_end_command_reverse_converter_function, false},
  97         {PE_COPY, "Copy", NULL, _syncml_binder_copy_command_reverse_converter_function, true}
  98 };
  99
 100 static sync_agent_pb_error_e __append_location_to_wbxml_node(Location * pLocation, sync_agent_pb_protocol_binder_info_s * pBinder, WBXMLTreeNode * parent_node)
 101 {
 102         _INNER_FUNC_ENTER;
 103         _DEBUG_VERBOSE("start");
 104
 105         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 106
 107         if (pLocation->locURI != NULL) {
 108                 WBXMLTreeNode *LocURI = sync_agent_add_child_text_node(pBinder, parent_node, ELEMENT_LOCURI, pLocation->locURI, strlen(pLocation->locURI));
 109                 if (LocURI == NULL) {
 110                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 111                         goto error;
 112                 }
 113         } else {
 114                 /* error case */
 115         }
 116
 117         if (pLocation->locName != NULL) {
 118                 WBXMLTreeNode *locName = sync_agent_add_child_text_node(pBinder, parent_node, ELEMENT_LOCNAME, pLocation->locName, strlen(pLocation->locName));
 119                 if (locName == NULL) {
 120                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 121                         goto error;
 122                 }
 123         }
 124
 125         _INNER_FUNC_EXIT;
 126         return err;
 127  error:
 128         _DEBUG_VERBOSE("error : %d", err);
 129         _INNER_FUNC_EXIT;
 130         return err;
 131
 132 }
 133
 134 static sync_agent_pb_error_e __append_cred_to_wbxml_node(Cred * pCred, sync_agent_pb_protocol_binder_info_s * pBinder, WBXMLTreeNode * parent_node)
 135 {
 136         _INNER_FUNC_ENTER;
 137         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 138
 139         retvm_if((pCred) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pCred is NULL!!");
 140         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 141
 142         /* check validity */
 143         WBXMLTreeNode *cred_node = sync_agent_add_child_node(pBinder, parent_node, ELEMENT_CRED);
 144         if (cred_node == NULL) {
 145                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 146                 goto error;
 147         }
 148
 149         WBXMLTreeNode *meta_node = sync_agent_add_child_node(pBinder, cred_node, ELEMENT_META);
 150         if (meta_node == NULL) {
 151                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 152                 goto error;
 153         }
 154
 155         WBXMLTreeNode *type_node = NULL;
 156
 157         switch (pCred->type) {
 158         case AUTH_TYPE_BASIC:
 159
 160                 if (pCred->format == FORMAT_TYPE_BASE64) {
 161                         WBXMLTreeNode *format_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, ELEMENT_FORMAT_BASE64, strlen(ELEMENT_FORMAT_BASE64));
 162                         if (format_node == NULL) {
 163                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 164                                 goto error;
 165                         }
 166                 }
 167
 168                 type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, ELEMENT_AUTH_BASIC, strlen(ELEMENT_AUTH_BASIC));
 169                 if (type_node == NULL) {
 170                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 171                         goto error;
 172                 }
 173
 174                 if (pCred->data != NULL) {
 175                         WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, cred_node, ELEMENT_DATA, pCred->data, strlen(pCred->data));
 176                         if (type_node == NULL) {
 177                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 178                                 goto error;
 179                         }
 180                 }
 181                 break;
 182         case AUTH_TYPE_MD5:
 183                 {
 184                         if (pCred->format == FORMAT_TYPE_BASE64) {
 185                                 WBXMLTreeNode *format_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, ELEMENT_FORMAT_BASE64, strlen(ELEMENT_FORMAT_BASE64));
 186                                 if (format_node == NULL) {
 187                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 188                                         goto error;
 189                                 }
 190                         }
 191
 192                         type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, ELEMENT_AUTH_MD5, strlen(ELEMENT_AUTH_MD5));
 193                         if (type_node == NULL) {
 194                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 195                                 goto error;
 196                         }
 197
 198                         if (pCred->data != NULL) {
 199                                 WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, cred_node, ELEMENT_DATA, pCred->data, strlen(pCred->data));
 200                                 if (type_node == NULL) {
 201                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 202                                         goto error;
 203                                 }
 204                         }
 205                 }
 206                 break;
 207         case AUTH_TYPE_HMAC:
 208                 {
 209                         /*do not use cred element */
 210                 }
 211                 break;
 212         default:
 213                 break;
 214         }
 215
 216         _INNER_FUNC_EXIT;
 217         return err;
 218
 219  error:
 220         _DEBUG_VERBOSE("error : %d", err);
 221         _INNER_FUNC_EXIT;
 222         return err;
 223 }
 224
 225 static sync_agent_pb_error_e __append_chal_to_wbxml_node(Chal * pChal, sync_agent_pb_protocol_binder_info_s * pBinder, WBXMLTreeNode * parent_node)
 226 {
 227         _INNER_FUNC_ENTER;
 228
 229         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 230
 231         retvm_if((pChal) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pChal is NULL!!");
 232         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 233
 234         /* check validity */
 235         WBXMLTreeNode *chal_node = sync_agent_add_child_node(pBinder, parent_node, ELEMENT_CHAL);
 236         if (chal_node == NULL) {
 237                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 238                 goto error;
 239         }
 240         WBXMLTreeNode *meta_node = sync_agent_add_child_node(pBinder, chal_node, ELEMENT_META);
 241         if (meta_node == NULL) {
 242                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 243                 goto error;
 244         }
 245
 246         WBXMLTreeNode *type_node = NULL;
 247
 248         switch (pChal->type) {
 249         case AUTH_TYPE_BASIC:
 250
 251                 if (pChal->format == FORMAT_TYPE_BASE64) {
 252                         WBXMLTreeNode *format_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, ELEMENT_FORMAT_BASE64, strlen(ELEMENT_FORMAT_BASE64));
 253                         if (format_node == NULL) {
 254                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 255                                 goto error;
 256                         }
 257                 }
 258
 259                 type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, ELEMENT_AUTH_BASIC, strlen(ELEMENT_AUTH_BASIC));
 260                 if (type_node == NULL) {
 261                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 262                         goto error;
 263                 }
 264
 265                 break;
 266         case AUTH_TYPE_MD5:
 267                 {
 268                         if (pChal->format == FORMAT_TYPE_BASE64) {
 269                                 WBXMLTreeNode *format_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, ELEMENT_FORMAT_BASE64, strlen(ELEMENT_FORMAT_BASE64));
 270                                 if (format_node == NULL) {
 271                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 272                                         goto error;
 273                                 }
 274                         }
 275
 276                         type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, ELEMENT_AUTH_MD5, strlen(ELEMENT_AUTH_MD5));
 277                         if (type_node == NULL) {
 278                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 279                                 goto error;
 280                         }
 281
 282                         WBXMLTreeNode *nextnonce_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_NEXTNONCE, pChal->nonce_plain, strlen(pChal->nonce_plain));
 283                         if (nextnonce_node == NULL) {
 284                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 285                                 goto error;
 286                         }
 287                 }
 288                 break;
 289         case AUTH_TYPE_HMAC:
 290                 {
 291                         if (pChal->format == FORMAT_TYPE_BASE64) {
 292                                 WBXMLTreeNode *format_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, ELEMENT_FORMAT_BASE64, strlen(ELEMENT_FORMAT_BASE64));
 293                                 if (format_node == NULL) {
 294                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 295                                         goto error;
 296                                 }
 297                         }
 298
 299                         type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, ELEMENT_AUTH_HMAC, strlen(ELEMENT_AUTH_HMAC));
 300                         if (type_node == NULL) {
 301                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 302                                 goto error;
 303                         }
 304
 305                         WBXMLTreeNode *nextnonce_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_NEXTNONCE, pChal->nonce_plain, strlen(pChal->nonce_plain));
 306                         if (nextnonce_node == NULL) {
 307                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 308                                 goto error;
 309                         }
 310                 }
 311                 break;
 312         default:
 313                 break;
 314         }
 315
 316         _INNER_FUNC_EXIT;
 317         return err;
 318
 319  error:
 320         _DEBUG_VERBOSE("error : %d", err);
 321         _INNER_FUNC_EXIT;
 322         return err;
 323 }
 324
 325 static sync_agent_pb_error_e _syncml_binder_syncml_start_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
 326 {
 327         _INNER_FUNC_ENTER;
 328
 329         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 330
 331         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 332         WBXMLTreeNode *syncml_node = sync_agent_create_node(pBinder, ELEMENT_SYNCML);
 333         if (syncml_node == NULL) {
 334                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 335                 goto error;
 336         }
 337
 338         *ppWbxml_dom_node = syncml_node;
 339
 340         _INNER_FUNC_EXIT;
 341         return err;
 342
 343  error:
 344         sync_agent_destroy_wbxml_node(syncml_node);
 345         _DEBUG_TRACE("error :%d", err);
 346         _INNER_FUNC_EXIT;
 347         return err;
 348 }
 349
 350 static sync_agent_pb_error_e _syncml_binder_header_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
 351 {
 352         _INNER_FUNC_ENTER;
 353
 354         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 355
 356         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 357         SyncHdr *pSyncHdr = (SyncHdr *) pContent;
 358
 359         /* add SyncHdr, VerDTD, VerProto node */
 360         WBXMLTreeNode *synchdr_node = NULL;
 361         synchdr_node = sync_agent_create_node(pBinder, ELEMENT_SYNCHDR);
 362         if (synchdr_node == NULL) {
 363                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 364                 goto error;
 365         }
 366
 367         char *verDTD = ELEMENT_VERDTD;
 368         char *verProto = ELEMENT_VERPROTO;
 369
 370         char *verDTD_data = NULL;
 371         char *verProto_data = NULL;
 372         if (pSyncHdr->version == VERSION_10) {
 373                 verDTD_data = ELEMENT_VERDTD_10;
 374                 verProto_data = ELEMENT_VERPROTO_10;
 375         } else if (pSyncHdr->version == VERSION_11) {
 376                 verDTD_data = ELEMENT_VERDTD_11;
 377                 verProto_data = ELEMENT_VERPROTO_11;
 378         } else if (pSyncHdr->version == VERSION_12) {
 379                 verDTD_data = ELEMENT_VERDTD_12;
 380                 verProto_data = ELEMENT_VERPROTO_12;
 381         }
 382
 383         if (verDTD_data == NULL || verProto_data == NULL) {
 384                 err = SYNC_AGENT_PB_RETURN_NOT_DEFINED;
 385                 goto error;
 386         }
 387
 388         WBXMLTreeNode *verdtd_node = sync_agent_add_child_text_node(pBinder, synchdr_node, verDTD, verDTD_data, strlen(verDTD_data));
 389         if (verdtd_node == NULL) {
 390                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 391                 goto error;
 392         }
 393
 394         WBXMLTreeNode *verProto_node = sync_agent_add_child_text_node(pBinder, synchdr_node, verProto, verProto_data, strlen(verProto_data));
 395         if (verProto_node == NULL) {
 396                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 397                 goto error;
 398         }
 399
 400         /* session ID */
 401         WBXMLTreeNode *sessionID_node = NULL;
 402         if (pSyncHdr->sessionID != NULL) {
 403                 sessionID_node = sync_agent_add_child_text_node(pBinder, synchdr_node, ELEMENT_SESSIONID, pSyncHdr->sessionID, strlen(pSyncHdr->sessionID));
 404         } else {
 405                 sessionID_node = sync_agent_add_child_node(pBinder, synchdr_node, ELEMENT_SESSIONID);
 406         }
 407
 408         if (sessionID_node == NULL) {
 409                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 410                 goto error;
 411         }
 412
 413         /* msgID */
 414         char *msgID_data = g_strdup_printf("%u", pSyncHdr->messageID);
 415         if (msgID_data == NULL) {
 416                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 417                 goto error;
 418         }
 419         WBXMLTreeNode *msgID_node = sync_agent_add_child_text_node(pBinder, synchdr_node, ELEMENT_MSGID, msgID_data, strlen(msgID_data));
 420         str_free(&msgID_data);
 421         if (msgID_node == NULL) {
 422                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 423                 goto error;
 424         }
 425
 426         WBXMLTreeNode *target_node = sync_agent_add_child_node(pBinder, synchdr_node, ELEMENT_TARGET);
 427         if (target_node == NULL) {
 428                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 429                 goto error;
 430         }
 431
 432         err = __append_location_to_wbxml_node(pSyncHdr->target, pBinder, target_node);
 433         if (err != SYNC_AGENT_PB_RETURN_OK)
 434                 goto error;
 435
 436         WBXMLTreeNode *source_node = sync_agent_add_child_node(pBinder, synchdr_node, ELEMENT_SOURCE);
 437         if (source_node == NULL) {
 438                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 439                 goto error;
 440         }
 441
 442         err = __append_location_to_wbxml_node(pSyncHdr->source, pBinder, source_node);
 443         if (err != SYNC_AGENT_PB_RETURN_OK)
 444                 goto error;
 445
 446         if (pSyncHdr->responseURI) {
 447                 WBXMLTreeNode *respuri_node = sync_agent_add_child_text_node(pBinder, synchdr_node, ELEMENT_RESPURI, pSyncHdr->responseURI, strlen(pSyncHdr->responseURI));
 448                 if (respuri_node == NULL) {
 449                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 450                         goto error;
 451                 }
 452         }
 453
 454         if (pSyncHdr->cred != NULL) {
 455                 err = __append_cred_to_wbxml_node(pSyncHdr->cred, pBinder, synchdr_node);
 456                 if (err != SYNC_AGENT_PB_RETURN_OK)
 457                         goto error;
 458         }
 459
 460         char *meta = ELEMENT_META;
 461         if (pSyncHdr->maxmsgsize != 0 || pSyncHdr->maxobjsize != 0) {
 462                 WBXMLTreeNode *meta_node = sync_agent_add_child_node(pBinder, synchdr_node, meta);
 463                 if (meta_node == NULL) {
 464                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 465                         goto error;
 466                 }
 467
 468                 unsigned int maxmsgsize = pSyncHdr->maxmsgsize;
 469                 unsigned int maxobjsize = pSyncHdr->maxobjsize;
 470
 471                 if (maxmsgsize != 0) {
 472                         char *str_maxmsgsize = g_strdup_printf("%u", maxmsgsize);
 473                         if (str_maxmsgsize == NULL) {
 474                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 475                                 goto error;
 476                         }
 477
 478                         WBXMLTreeNode *maxmsgsize_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_MAXMSGSIZE, str_maxmsgsize, strlen(str_maxmsgsize));
 479                         str_free(&str_maxmsgsize);
 480                         if (maxmsgsize_node == NULL) {
 481                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 482                                 goto error;
 483                         }
 484                 }
 485
 486                 if (maxobjsize != 0) {
 487                         char *str_maxobjsize = g_strdup_printf("%u", maxobjsize);
 488                         if (str_maxobjsize == NULL) {
 489                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 490                                 goto error;
 491                         }
 492
 493                         WBXMLTreeNode *maxmsgsize_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_MAXOBJSIZE, str_maxobjsize, strlen(str_maxobjsize));
 494                         str_free(&str_maxobjsize);
 495                         if (maxmsgsize_node == NULL) {
 496                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 497                                 goto error;
 498                         }
 499                 }
 500         }
 501
 502         *ppWbxml_dom_node = synchdr_node;
 503
 504         _INNER_FUNC_EXIT;
 505         return err;
 506
 507  error:
 508         sync_agent_destroy_wbxml_node(synchdr_node);
 509         _DEBUG_TRACE("error :%d", err);
 510         _INNER_FUNC_EXIT;
 511         return err;
 512 }
 513
 514 static sync_agent_pb_error_e _syncml_binder_final_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
 515 {
 516
 517         _INNER_FUNC_ENTER;
 518
 519         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 520
 521         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 522
 523         WBXMLTreeNode *final_node = sync_agent_create_node(pBinder, ELEMENT_FINAL);
 524         if (final_node == NULL) {
 525                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 526                 goto error;
 527         }
 528
 529         *ppWbxml_dom_node = final_node;
 530
 531         _INNER_FUNC_EXIT;
 532         return err;
 533
 534  error:
 535         sync_agent_destroy_wbxml_node(final_node);
 536         _DEBUG_TRACE("error :%d", err);
 537         _INNER_FUNC_EXIT;
 538         return err;
 539 }
 540
 541 static sync_agent_pb_error_e _syncml_binder_body_start_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
 542 {
 543         _INNER_FUNC_ENTER;
 544
 545         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 546
 547         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 548
 549         WBXMLTreeNode *syncbody_node = sync_agent_create_node(pBinder, ELEMENT_SYNCBODY);
 550         if (syncbody_node == NULL) {
 551                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 552                 goto error;
 553         }
 554
 555         *ppWbxml_dom_node = syncbody_node;
 556
 557         _INNER_FUNC_EXIT;
 558         return err;
 559
 560  error:
 561         sync_agent_destroy_wbxml_node(syncbody_node);
 562         _DEBUG_TRACE("error :%d", err);
 563         _INNER_FUNC_EXIT;
 564         return err;
 565 }
 566
 567 static sync_agent_pb_error_e _syncml_binder_status_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
 568 {
 569         _INNER_FUNC_ENTER;
 570
 571         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 572
 573         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 574
 575         Status *pStatus = (Status *) pContent;
 576         assert(pStatus != NULL);
 577
 578         CommandType type = pStatus->type;
 579
 580         WBXMLTreeNode *status_node = NULL;
 581         status_node = sync_agent_create_node(pBinder, ELEMENT_STATUS);
 582         if (status_node == NULL) {
 583                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 584                 goto error;
 585         }
 586
 587         unsigned int cmdID = pStatus->cmdID;
 588         char *str_cmdID = g_strdup_printf("%u", cmdID);
 589         if (str_cmdID == NULL) {
 590                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 591                 goto error;
 592         }
 593
 594         WBXMLTreeNode *cmdid_node = sync_agent_add_child_text_node(pBinder, status_node, ELEMENT_CMDID, str_cmdID, strlen(str_cmdID));
 595         str_free(&str_cmdID);
 596         if (cmdid_node == NULL) {
 597                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 598                 goto error;
 599         }
 600
 601         unsigned int msgRef = pStatus->msgRef;
 602         char *str_msgRef = g_strdup_printf("%u", msgRef);
 603         if (str_msgRef == NULL) {
 604                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 605                 goto error;
 606         }
 607
 608         WBXMLTreeNode *msgref_node = sync_agent_add_child_text_node(pBinder, status_node, ELEMENT_MSGREF, str_msgRef, strlen(str_msgRef));
 609         str_free(&str_msgRef);
 610         if (msgref_node == NULL) {
 611                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 612                 goto error;
 613         }
 614
 615         unsigned int cmdRef = pStatus->cmdRef;
 616         char *str_cmdRef = g_strdup_printf("%u", cmdRef);
 617         if (str_cmdRef == NULL) {
 618                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 619                 goto error;
 620         }
 621
 622         WBXMLTreeNode *cmdref_node = sync_agent_add_child_text_node(pBinder, status_node, ELEMENT_CMDREF, str_cmdRef, strlen(str_cmdRef));
 623         str_free(&str_cmdRef);
 624         if (cmdref_node == NULL) {
 625                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 626                 goto error;
 627         }
 628
 629         char *str_command = NULL;
 630         switch (type) {
 631         case COMMAND_TYPE_ALERT:
 632                 {
 633                         str_command = ELEMENT_ALERT;
 634                 }
 635                 break;
 636         case COMMAND_TYPE_HEADER:
 637                 {
 638                         str_command = ELEMENT_SYNCHDR;
 639                 }
 640                 break;
 641         case COMMAND_TYPE_ADD:
 642                 {
 643                         str_command = ELEMENT_ADD;
 644                 }
 645                 break;
 646         case COMMAND_TYPE_REPLACE:
 647                 {
 648                         str_command = ELEMENT_REPLACE;
 649                 }
 650                 break;
 651         case COMMAND_TYPE_DELETE:
 652                 {
 653                         str_command = ELEMENT_DELETE;
 654                 }
 655                 break;
 656         case COMMAND_TYPE_GET:
 657                 {
 658                         str_command = ELEMENT_GET;
 659                 }
 660                 break;
 661         case COMMAND_TYPE_RESULTS:
 662                 {
 663                         str_command = ELEMENT_RESULTS;
 664                 }
 665                 break;
 666         case COMMAND_TYPE_EXEC:
 667                 {
 668                         str_command = ELEMENT_EXEC;
 669                 }
 670                 break;
 671         case COMMAND_TYPE_SEQUENCE:
 672                 {
 673                         str_command = ELEMENT_SEQUENCE;
 674                 }
 675                 break;
 676         case COMMAND_TYPE_ATOMIC:
 677                 {
 678                         str_command = ELEMENT_ATOMIC;
 679                 }
 680                 break;
 681         default:
 682                 break;
 683         }
 684
 685         if (str_command == NULL) {
 686                 err = SYNC_AGENT_PB_RETURN_NOT_DEFINED;
 687                 goto error;
 688         }
 689
 690         WBXMLTreeNode *command_node = sync_agent_add_child_text_node(pBinder, status_node, ELEMENT_CMD, str_command, strlen(str_command));
 691         if (command_node == NULL) {
 692                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 693                 goto error;
 694         }
 695
 696         if (pStatus->targetRef != NULL) {
 697                 WBXMLTreeNode *targetref_node = sync_agent_add_child_text_node(pBinder, status_node, ELEMENT_TARGETREF, pStatus->targetRef->locURI, strlen(pStatus->targetRef->locURI));
 698                 if (targetref_node == NULL) {
 699                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 700                         goto error;
 701                 }
 702         }
 703
 704         if (pStatus->sourceRef != NULL) {
 705                 WBXMLTreeNode *sourceref_node = sync_agent_add_child_text_node(pBinder, status_node, ELEMENT_SOURCEREF, pStatus->sourceRef->locURI, strlen(pStatus->sourceRef->locURI));
 706                 if (sourceref_node == NULL) {
 707                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 708                         goto error;
 709                 }
 710         }
 711
 712         if (pStatus->cred != NULL) {
 713                 /*err = append_cred_to_wbxml_node(pStatus->cred, pBinder, status_node);
 714                  *      if(err != SYNC_AGENT_PB_RETURN_OK)
 715                  goto error;
 716                  */
 717         }
 718
 719         if (pStatus->chal != NULL) {
 720                 err = __append_chal_to_wbxml_node(pStatus->chal, pBinder, status_node);
 721                 if (err != SYNC_AGENT_PB_RETURN_OK)
 722                         goto error;
 723
 724         }
 725
 726         WBXMLTreeNode *data_node = sync_agent_add_child_text_node(pBinder, status_node, ELEMENT_DATA, pStatus->data, strlen(pStatus->data));
 727         if (data_node == NULL) {
 728                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 729                 goto error;
 730         }
 731
 732         if (type == COMMAND_TYPE_ALERT) {
 733                 GList *Iter = NULL;
 734                 Item *item = NULL;
 735                 if (pStatus->items != NULL) {
 736                         for (Iter = pStatus->items; Iter != NULL; Iter = g_list_next(Iter)) {
 737                                 item = (Iter->data);
 738                                 if (item != NULL) {
 739                                         WBXMLTreeNode *item_node = sync_agent_add_child_node(pBinder, status_node, ELEMENT_ITEM);
 740                                         if (item_node == NULL) {
 741                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 742                                                 goto error;
 743                                         }
 744                                         char *data = NULL;
 745                                         data = item->private.data;
 746                                         if (data != NULL) {
 747                                                 WBXMLTreeNode *item_data_node = sync_agent_add_child_text_node(pBinder, item_node, ELEMENT_DATA, data, strlen(data));
 748                                                 if (item_data_node == NULL) {
 749                                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 750                                                         goto error;
 751                                                 }
 752                                         }
 753                                 }
 754                         }
 755                 }
 756         }
 757
 758         *ppWbxml_dom_node = status_node;
 759
 760         _INNER_FUNC_EXIT;
 761         return err;
 762
 763  error:
 764         sync_agent_destroy_wbxml_node(status_node);
 765
 766         _DEBUG_TRACE("error :%d", err);
 767         _INNER_FUNC_EXIT;
 768         return err;
 769 }
 770
 771 static sync_agent_pb_error_e _syncml_binder_alert_command_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
 772 {
 773
 774         _INNER_FUNC_ENTER;
 775
 776         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 777
 778         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 779
 780         Command *pCommand = (Command *) pContent;
 781         CommandAlertPrivate *pAlert = (CommandAlertPrivate *) (&(pCommand->private));
 782         WBXMLTreeNode *alert_node = NULL;
 783
 784         if (pAlert == NULL) {
 785                 err = SYNC_AGENT_PB_RETURN_NOT_DEFINED;
 786                 _DEBUG_TRACE("pAlert is not defined");
 787                 goto error;
 788         }
 789
 790         if (pAlert->type == ALERT_UNKNOWN) {
 791                 /* error case */
 792                 err = SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR;
 793                 _DEBUG_TRACE("type is unknown");
 794                 goto error;
 795         }
 796
 797         alert_node = sync_agent_create_node(pBinder, ELEMENT_ALERT);
 798         if (alert_node == NULL) {
 799                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 800                 goto error;
 801         }
 802
 803         char *str_cmdID = g_strdup_printf("%u", pCommand->cmdID);
 804         if (str_cmdID == NULL) {
 805                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 806                 goto error;
 807         }
 808
 809         WBXMLTreeNode *cmdid_node = sync_agent_add_child_text_node(pBinder, alert_node, ELEMENT_CMDID, str_cmdID, strlen(str_cmdID));
 810         str_free(&str_cmdID);
 811         if (cmdid_node == NULL) {
 812                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 813                 goto error;
 814         }
 815
 816 /*      if(pCommand->cred){
 817                 err = __append_cred_to_wbxml_node(pCommand->cred, pBinder, alert_node);
 818                 if(err != SYNC_AGENT_PB_RETURN_OK)
 819                         goto error;
 820         }*/
 821
 822         char *str_alert_type = g_strdup_printf("%d", pAlert->type);
 823         if (str_alert_type == NULL) {
 824                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 825                 goto error;
 826         }
 827
 828         WBXMLTreeNode *data_node = sync_agent_add_child_text_node(pBinder, alert_node, ELEMENT_DATA, str_alert_type, strlen(str_alert_type));
 829         str_free(&str_alert_type);
 830         if (data_node == NULL) {
 831                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 832                 goto error;
 833         }
 834
 835         if (pAlert->Correlator != NULL) {
 836                 char *pCorrelator = g_strdup(pAlert->Correlator);
 837                 if (pCorrelator == NULL) {
 838                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 839                         goto error;
 840                 }
 841                 WBXMLTreeNode *correlator_node = sync_agent_add_child_text_node(pBinder, alert_node, ELEMENT_CORRELATOR, pCorrelator, strlen(pCorrelator));
 842                 str_free(&pCorrelator);
 843                 if (correlator_node == NULL) {
 844                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 845                         goto error;
 846                 }
 847         }
 848
 849         GList *Iter = NULL;
 850         Item *item = NULL;
 851         for (Iter = pAlert->items; Iter != NULL; Iter = g_list_next(Iter)) {
 852                 item = (Iter->data);
 853                 WBXMLTreeNode *item_node = sync_agent_add_child_node(pBinder, alert_node, ELEMENT_ITEM);
 854                 if (item_node == NULL) {
 855                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 856                         goto error;
 857                 }
 858
 859                 if (item->source != NULL) {
 860                         WBXMLTreeNode *source_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_SOURCE);
 861                         if (source_node == NULL) {
 862                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 863                                 goto error;
 864                         }
 865                         err = __append_location_to_wbxml_node(item->source, pBinder, source_node);
 866                         if (err != SYNC_AGENT_PB_RETURN_OK)
 867                                 goto error;
 868                 }
 869                 if (item->target != NULL) {
 870                         WBXMLTreeNode *target_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_TARGET);
 871                         if (target_node == NULL) {
 872                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 873                                 goto error;
 874                         }
 875                         err = __append_location_to_wbxml_node(item->target, pBinder, target_node);
 876                         if (err != SYNC_AGENT_PB_RETURN_OK)
 877                                 goto error;
 878                 }
 879
 880                 if (item->format != NULL || item->contenttype != NULL) {
 881                         WBXMLTreeNode *meta_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_META);
 882                         if (meta_node == NULL) {
 883                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 884                                 goto error;
 885                         }
 886                         if (item->format != NULL) {
 887                                 WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, item->format, strlen(item->format));
 888                                 if (type_node == NULL) {
 889                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 890                                         goto error;
 891                                 }
 892                         }
 893                         if (item->contenttype != NULL) {
 894                                 WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, item->contenttype, strlen(item->contenttype));
 895                                 if (type_node == NULL) {
 896                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 897                                         goto error;
 898                                 }
 899                                 if (item->moreData != 0) {
 900                                         if (item->size > 0) {
 901                                                 char *str_size = g_strdup_printf("%u", item->size);
 902                                                 if (str_size == NULL) {
 903                                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 904                                                         goto error;
 905                                                 }
 906
 907                                                 WBXMLTreeNode *size_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_SIZE, str_size, strlen(str_size));
 908                                                 str_free(&str_size);
 909                                                 if (size_node == NULL) {
 910                                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 911                                                         goto error;
 912                                                 }
 913
 914                                         }
 915                                 }
 916                         }
 917                 }
 918
 919                 if (item->dataType == ITEM_DATA) {
 920                         if (item->private.data != NULL) {
 921                                 WBXMLTreeNode *data_node = sync_agent_add_child_text_node(pBinder, item_node, ELEMENT_DATA, item->private.data, strlen(item->private.data));
 922                                 //WBXMLTreeNode* data_node = sync_agent_add_child_cdata_node(pBinder, item_node, ELEMENT_DATA, item->private.data, strlen(item->private.data));
 923                                 if (data_node == NULL) {
 924                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 925                                         goto error;
 926                                 }
 927                         }
 928                 }
 929
 930                 if (item->moreData != 0) {
 931                         WBXMLTreeNode *data_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_MOREDATA);
 932                         if (data_node == NULL) {
 933                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 934                                 goto error;
 935                         }
 936                 }
 937         }
 938
 939         *ppWbxml_dom_node = alert_node;
 940
 941         _INNER_FUNC_EXIT;
 942         return err;
 943
 944  error:
 945         sync_agent_destroy_wbxml_node(alert_node);
 946         _DEBUG_TRACE("error :%d", err);
 947         _INNER_FUNC_EXIT;
 948         return err;
 949 }
 950
 951 static sync_agent_pb_error_e _syncml_binder_results_command_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
 952 {
 953
 954         _INNER_FUNC_ENTER;
 955
 956         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
 957
 958         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
 959
 960         Command *pCommand = (Command *) pContent;
 961         CommandResultsPrivate *pResults = (CommandResultsPrivate *) (&(pCommand->private));
 962         WBXMLTreeNode *results_node = NULL;
 963         if (pResults == NULL) {
 964                 err = SYNC_AGENT_PB_RETURN_NOT_DEFINED;
 965                 _DEBUG_TRACE("pResults is not defined");
 966                 goto error;
 967         }
 968
 969         results_node = sync_agent_create_node(pBinder, ELEMENT_RESULTS);
 970         if (results_node == NULL) {
 971                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 972                 goto error;
 973         }
 974
 975         char *str_cmdID = g_strdup_printf("%u", pCommand->cmdID);
 976         if (str_cmdID == NULL) {
 977                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 978                 goto error;
 979         }
 980         WBXMLTreeNode *cmdid_node = sync_agent_add_child_text_node(pBinder, results_node, ELEMENT_CMDID, str_cmdID, strlen(str_cmdID));
 981         str_free(&str_cmdID);
 982         if (cmdid_node == NULL) {
 983                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 984                 goto error;
 985         }
 986
 987         if (pResults->msgRef != 0) {
 988                 char *str_msgRef = g_strdup_printf("%u", pResults->msgRef);
 989                 if (str_msgRef == NULL) {
 990                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 991                         goto error;
 992                 }
 993                 WBXMLTreeNode *msgref_node = sync_agent_add_child_text_node(pBinder, results_node, ELEMENT_MSGREF, str_msgRef, strlen(str_msgRef));
 994                 str_free(&str_msgRef);
 995                 if (msgref_node == NULL) {
 996                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
 997                         goto error;
 998                 }
 999         }
1000
1001         char *str_cmdRef = g_strdup_printf("%u", pResults->cmdRef);
1002         if (str_cmdRef == NULL) {
1003                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1004                 goto error;
1005         }
1006         WBXMLTreeNode *msgref_node = sync_agent_add_child_text_node(pBinder, results_node, ELEMENT_CMDREF, str_cmdRef, strlen(str_cmdRef));
1007         str_free(&str_cmdRef);
1008         if (msgref_node == NULL) {
1009                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1010                 goto error;
1011         }
1012
1013         /*     if(content_type){
1014            WBXMLTreeNode * meta_node = sync_agent_add_child_node(pBinder, results_node, ELEMENT_META);
1015            sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, content_type, strlen(content_type));
1016            } */
1017
1018         if (pResults->targetRef != NULL) {
1019                 WBXMLTreeNode *targetref_node = sync_agent_add_child_text_node(pBinder, results_node, ELEMENT_TARGETREF, pResults->targetRef->locURI, strlen(pResults->targetRef->locURI));
1020                 if (targetref_node == NULL) {
1021                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1022                         goto error;
1023                 }
1024         }
1025
1026         GList *Iter = NULL;
1027         Item *item = NULL;
1028         for (Iter = pResults->items; Iter != NULL; Iter = g_list_next(Iter)) {
1029                 item = (Iter->data);
1030                 WBXMLTreeNode *item_node = sync_agent_add_child_node(pBinder, results_node, ELEMENT_ITEM);
1031                 if (item_node == NULL) {
1032                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1033                         goto error;
1034                 }
1035                 if (item->source != NULL) {
1036                         WBXMLTreeNode *source_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_SOURCE);
1037                         if (source_node == NULL) {
1038                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1039                                 goto error;
1040                         }
1041                         err = __append_location_to_wbxml_node(item->source, pBinder, source_node);
1042                         if (err != SYNC_AGENT_PB_RETURN_OK)
1043                                 goto error;
1044                 }
1045                 if (item->target != NULL) {
1046                         WBXMLTreeNode *target_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_TARGET);
1047                         if (target_node == NULL) {
1048                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1049                                 goto error;
1050                         }
1051                         err = __append_location_to_wbxml_node(item->target, pBinder, target_node);
1052                         if (err != SYNC_AGENT_PB_RETURN_OK)
1053                                 goto error;
1054                 }
1055
1056                 if (item->format != NULL || item->contenttype != NULL) {
1057                         WBXMLTreeNode *meta_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_META);
1058                         if (meta_node == NULL) {
1059                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1060                                 goto error;
1061                         }
1062                         if (item->format != NULL) {
1063                                 WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, item->format, strlen(item->format));
1064                                 if (type_node == NULL) {
1065                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1066                                         goto error;
1067                                 }
1068                         }
1069                         if (item->contenttype != NULL) {
1070                                 WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, item->contenttype, strlen(item->contenttype));
1071                                 if (type_node == NULL) {
1072                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1073                                         goto error;
1074                                 }
1075                                 if (item->moreData != 0) {
1076                                         if (item->size > 0) {
1077                                                 char *str_size = g_strdup_printf("%u", item->size);
1078                                                 WBXMLTreeNode *size_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_SIZE, str_size, strlen(str_size));
1079                                                 str_free(&str_size);
1080                                                 if (size_node == NULL) {
1081                                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1082                                                         goto error;
1083                                                 }
1084                                         }
1085                                 }
1086                         }
1087                 }
1088                 if (item->dataType == ITEM_DATA) {
1089                         if (item->private.data != NULL) {
1090                                 WBXMLTreeNode *data_node = sync_agent_add_child_text_node(pBinder, item_node, ELEMENT_DATA, item->private.data, strlen(item->private.data));
1091                                 //WBXMLTreeNode* data_node = sync_agent_add_child_cdata_node(pBinder, item_node, ELEMENT_DATA, item->private.data, strlen(item->private.data));
1092                                 if (data_node == NULL) {
1093                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1094                                         goto error;
1095                                 }
1096                         }
1097                 }
1098
1099                 if (item->moreData != 0) {
1100                         WBXMLTreeNode *data_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_MOREDATA);
1101                         if (data_node == NULL) {
1102                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1103                                 goto error;
1104                         }
1105                 }
1106         }
1107
1108         *ppWbxml_dom_node = results_node;
1109
1110         _INNER_FUNC_EXIT;
1111         return err;
1112
1113  error:
1114         sync_agent_destroy_wbxml_node(results_node);
1115         _DEBUG_TRACE("error :%d", err);
1116         _INNER_FUNC_EXIT;
1117         return err;
1118 }
1119
1120 static sync_agent_pb_error_e _syncml_binder_replace_command_converter_function(sync_agent_pb_protocol_binder_info_s * pBinder, Content_Ptr pContent, WBXMLTreeNode ** ppWbxml_dom_node)
1121 {
1122         _INNER_FUNC_ENTER;
1123
1124         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pBinder is NULL!!");
1125
1126         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1127
1128         Command *pCommand = (Command *) pContent;
1129         CommandChangePrivate *pChange = (CommandChangePrivate *) (&(pCommand->private));
1130
1131         if (pChange == NULL) {
1132                 err = SYNC_AGENT_PB_RETURN_NOT_DEFINED;
1133                 _DEBUG_TRACE("pChange is not defined");
1134                 _INNER_FUNC_EXIT;
1135                 return err;
1136         }
1137
1138         WBXMLTreeNode *replace_node = NULL;
1139         replace_node = sync_agent_create_node(pBinder, ELEMENT_REPLACE);
1140         if (replace_node == NULL) {
1141                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1142                 goto error;
1143         }
1144
1145         char *str_cmdID = g_strdup_printf("%u", pCommand->cmdID);
1146         if (str_cmdID == NULL) {
1147                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1148                 goto error;
1149         }
1150         WBXMLTreeNode *cmdid_node = sync_agent_add_child_text_node(pBinder, replace_node, ELEMENT_CMDID, str_cmdID, strlen(str_cmdID));
1151         str_free(&str_cmdID);
1152         if (cmdid_node == NULL) {
1153                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1154                 goto error;
1155         }
1156
1157         GList *Iter = NULL;
1158         Item *item = NULL;
1159         for (Iter = pChange->items; Iter != NULL; Iter = g_list_next(Iter)) {
1160                 item = (Iter->data);
1161                 WBXMLTreeNode *item_node = sync_agent_add_child_node(pBinder, replace_node, ELEMENT_ITEM);
1162                 if (item_node == NULL) {
1163                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1164                         goto error;
1165                 }
1166                 if (item->source != NULL) {
1167                         WBXMLTreeNode *source_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_SOURCE);
1168                         if (source_node == NULL) {
1169                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1170                                 goto error;
1171                         }
1172                         err = __append_location_to_wbxml_node(item->source, pBinder, source_node);
1173                         if (err != SYNC_AGENT_PB_RETURN_OK)
1174                                 goto error;
1175                 }
1176                 if (item->target != NULL) {
1177                         WBXMLTreeNode *target_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_TARGET);
1178                         if (target_node == NULL) {
1179                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1180                                 goto error;
1181                         }
1182                         err = __append_location_to_wbxml_node(item->target, pBinder, target_node);
1183                         if (err != SYNC_AGENT_PB_RETURN_OK)
1184                                 goto error;
1185                 }
1186                 if (item->format != NULL || item->contenttype != NULL) {
1187                         WBXMLTreeNode *meta_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_META);
1188                         if (meta_node == NULL) {
1189                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1190                                 goto error;
1191                         }
1192                         if (item->format != NULL) {
1193                                 WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_FORMAT, item->format, strlen(item->format));
1194                                 if (type_node == NULL) {
1195                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1196                                         goto error;
1197                                 }
1198                         }
1199                         if (item->contenttype != NULL) {
1200                                 WBXMLTreeNode *type_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_TYPE, item->contenttype, strlen(item->contenttype));
1201                                 if (type_node == NULL) {
1202                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1203                                         goto error;
1204                                 }
1205                                 if (item->moreData != 0) {
1206                                         if (item->size > 0) {
1207                                                 char *str_size = g_strdup_printf("%u", item->size);
1208                                                 WBXMLTreeNode *size_node = sync_agent_add_child_text_node(pBinder, meta_node, ELEMENT_SIZE, str_size, strlen(str_size));
1209                                                 str_free(&str_size);
1210                                                 if (size_node == NULL) {
1211                                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1212                                                         goto error;
1213                                                 }
1214                                         }
1215                                 }
1216                         }
1217                 }
1218                 if (item->dataType == ITEM_DATA) {
1219                         if (item->private.data != NULL) {
1220                                 //WBXMLTreeNode* data_node = sync_agent_add_child_cdata_node(pBinder, item_node, ELEMENT_DATA, item->private.data, strlen(item->private.data));
1221                                 WBXMLTreeNode *data_node = sync_agent_add_child_text_node(pBinder, item_node, ELEMENT_DATA, item->private.data, strlen(item->private.data));
1222                                 if (data_node == NULL) {
1223                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1224                                         goto error;
1225                                 }
1226                         }
1227                 }
1228
1229                 if (item->moreData != 0) {
1230                         WBXMLTreeNode *data_node = sync_agent_add_child_node(pBinder, item_node, ELEMENT_MOREDATA);
1231                         if (data_node == NULL) {
1232                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1233                                 goto error;
1234                         }
1235                 }
1236         }
1237
1238         *ppWbxml_dom_node = replace_node;
1239
1240         _INNER_FUNC_EXIT;
1241         return err;
1242
1243  error:
1244         sync_agent_destroy_wbxml_node(replace_node);
1245         _DEBUG_TRACE("error :%d", err);
1246         _INNER_FUNC_EXIT;
1247         return err;
1248 }
1249
1250 static ProtocolVersion __get_oma_dm_protocol_version(char *verdtd)
1251 {
1252         _INNER_FUNC_ENTER;
1253
1254         retvm_if((verdtd) == NULL, VERSION_12, "verdtd is NULL!!");
1255
1256         ProtocolVersion protocol_version = VERSION_UNKNOWN;
1257         if (strcmp(verdtd, ELEMENT_VERDTD_12) == 0) {
1258                 protocol_version = VERSION_12;
1259         } else if (strcmp(verdtd, ELEMENT_VERDTD_11) == 0) {
1260                 protocol_version = VERSION_11;
1261         } else if (strcmp(verdtd, ELEMENT_VERDTD_10) == 0) {
1262                 protocol_version = VERSION_10;
1263         }
1264
1265         _INNER_FUNC_EXIT;
1266         return protocol_version;
1267 }
1268
1269 static Location *__get_location(WBXMLTreeNode * node)
1270 {
1271
1272         _INNER_FUNC_ENTER;
1273
1274         retvm_if((node) == NULL, NULL, "node is NULL!!");
1275         DM_ERROR ret = DM_OK;
1276         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1277         Location *pLocation = NULL;
1278
1279         WBXMLTreeNode *child = NULL;
1280         const char *child_name = NULL;
1281
1282         char *locURI = NULL;
1283         char *locName = NULL;
1284         /* get first child : required LocURI */
1285         child = node->children;
1286
1287         child_name = (const char *)wbxml_tag_get_xml_name(child->name);
1288         if (strcmp(child_name, ELEMENT_LOCURI) == 0) {
1289                 err = sync_agent_get_text_from_node(child, &locURI);
1290                 if (err != SYNC_AGENT_PB_RETURN_OK) {
1291                         goto return_part;
1292                 }
1293         } else {
1294                 /* error */
1295                 goto return_part;
1296         }
1297
1298         /* get second child : optional LocName */
1299         child = child->next;
1300         if (child != NULL) {
1301                 child_name = (const char *)wbxml_tag_get_xml_name(child->name);
1302                 if (strcmp(child_name, ELEMENT_LOCNAME) == 0) {
1303                         err = sync_agent_get_text_from_node(child, &locName);
1304                         if (err != SYNC_AGENT_PB_RETURN_OK)
1305                                 goto return_part;
1306                 } else {
1307                         /* error */
1308                         goto return_part;
1309                 }
1310         }
1311
1312         ret = create_location(locURI, locName, &pLocation);
1313         if (ret != DM_OK) {
1314                 goto return_part;
1315         }
1316
1317         _INNER_FUNC_EXIT;
1318         return pLocation;
1319
1320  return_part:
1321         _DEBUG_VERBOSE("error : %d", ret);
1322         if (pLocation != NULL) {
1323                 free_location(pLocation);
1324                 pLocation = NULL;
1325         }
1326
1327         _INNER_FUNC_EXIT;
1328         return NULL;
1329 }
1330
1331 static Cred *__get_cred(WBXMLTreeNode * node)
1332 {
1333         _INNER_FUNC_ENTER;
1334
1335         retvm_if((node) == NULL, NULL, "node is NULL!!");
1336
1337         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1338         Cred *cred = NULL;
1339
1340         char *data = NULL;
1341         char *type = NULL;
1342         char *format = NULL;
1343
1344         WBXMLTreeNode *child = NULL;
1345         const char *child_xml_name = NULL;
1346         for (child = node->children; child != NULL; child = child->next) {
1347                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
1348
1349                 if (strcmp(child_xml_name, ELEMENT_META) == 0) {
1350                         WBXMLTreeNode *grand_child = child->children;
1351                         const char *grand_child_xml_name = NULL;
1352                         grand_child_xml_name = (const char *)wbxml_tag_get_xml_name(grand_child->name);
1353
1354                         if (strcmp(grand_child_xml_name, ELEMENT_TYPE) == 0) {
1355                                 err = sync_agent_get_text_from_node(grand_child, &type);
1356                                 if (err != SYNC_AGENT_PB_RETURN_OK) {
1357                                         goto return_part;
1358                                 }
1359                                 _DEBUG_VERBOSE("Type = [%s]", type);
1360                         } else if (strcmp(grand_child_xml_name, ELEMENT_FORMAT) == 0) {
1361                                 err = sync_agent_get_text_from_node(grand_child, &format);
1362                                 if (err != SYNC_AGENT_PB_RETURN_OK) {
1363                                         goto return_part;
1364                                 }
1365                                 _DEBUG_VERBOSE("Type = [%s]", format);
1366                         }
1367                 } else if (strcmp(child_xml_name, ELEMENT_DATA) == 0) {
1368                         err = sync_agent_get_text_from_node(child, &data);
1369                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1370                                 goto return_part;
1371                         }
1372                         _DEBUG_VERBOSE("Data = [%s]", data);
1373                 }
1374         }
1375
1376         cred = create_credwithdata(converttoauthtype(type), data);
1377         if (cred == NULL) {
1378                 return NULL;
1379         }
1380
1381         /*all auth type base 64 */
1382         set_credformattype(cred, FORMAT_TYPE_BASE64);
1383         _DEBUG_VERBOSE("base 64 format");
1384
1385         _INNER_FUNC_EXIT;
1386         return cred;
1387
1388  return_part:
1389         _DEBUG_VERBOSE("error");
1390         free_cred(cred);
1391
1392         _INNER_FUNC_EXIT;
1393         return NULL;
1394 }
1395
1396 static Chal *__get_chal(WBXMLTreeNode * node)
1397 {
1398         _INNER_FUNC_ENTER;
1399
1400         retvm_if((node) == NULL, NULL, "node is NULL!!");
1401
1402         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1403
1404         Chal *chal = (Chal *) calloc(1, sizeof(Chal));
1405         if (chal == NULL) {
1406                 _DEBUG_VERBOSE("alloc fail");
1407                 _INNER_FUNC_EXIT;
1408                 return NULL;
1409         }
1410         WBXMLTreeNode *chal_child = node->children;
1411
1412         WBXMLTreeNode *meta_child = NULL;
1413         const char *meta_child_xml_name = NULL;
1414         for (meta_child = chal_child->children; meta_child != NULL; meta_child = meta_child->next) {
1415                 meta_child_xml_name = (const char *)wbxml_tag_get_xml_name(meta_child->name);
1416
1417                 if (strcmp(meta_child_xml_name, ELEMENT_TYPE) == 0) {
1418                         char *type = NULL;
1419                         err = sync_agent_get_text_from_node(meta_child, &type);
1420                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1421                                 goto return_part;
1422                         }
1423                         _DEBUG_VERBOSE("Type = [%s]", type);
1424
1425                         chal->type = converttoauthtype(type);
1426                 } else if (strcmp(meta_child_xml_name, ELEMENT_FORMAT) == 0) {
1427                         char *format = NULL;
1428                         err = sync_agent_get_text_from_node(meta_child, &format);
1429                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1430                                 goto return_part;
1431                         }
1432                         _DEBUG_VERBOSE("Format = [%s]", format);
1433
1434                         chal->format = converttoformattype(format);
1435                 } else if (strcmp(meta_child_xml_name, "NextNonce") == 0) {
1436                         char *nextnonce = NULL;
1437                         unsigned int nonce_len = 0;
1438                         err = sync_agent_get_binary_from_node(meta_child, &nextnonce, &nonce_len);
1439                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1440                                 goto return_part;
1441                         }
1442                         _DEBUG_VERBOSE("NextNonce =[%s] ", nextnonce);
1443                         if (chal->format == FORMAT_TYPE_BASE64 && chal->type == AUTH_TYPE_BASIC) {
1444                                 chal->nonce_b64 = strdup(nextnonce);
1445                         } else if (chal->format == FORMAT_TYPE_BASE64 && (chal->type == AUTH_TYPE_MD5 || chal->type == AUTH_TYPE_HMAC)) {
1446                                 chal->nonce_plain = (char *)calloc(1, nonce_len + 1);
1447                                 if (chal->nonce_plain == NULL) {
1448                                         err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1449                                         goto return_part;
1450                                 }
1451                                 memcpy(chal->nonce_plain, nextnonce, nonce_len);
1452                                 chal->nonce_plain[nonce_len] = '\0';
1453                         }
1454                         chal->nonce_length = nonce_len;
1455                 }
1456         }
1457
1458         _INNER_FUNC_EXIT;
1459         return chal;
1460
1461  return_part:
1462         _DEBUG_VERBOSE("error ");
1463         free_chal(chal);
1464         _INNER_FUNC_EXIT;
1465         return NULL;
1466 }
1467
1468 static sync_agent_pb_error_e _syncml_binder_header_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
1469 {
1470         _INNER_FUNC_ENTER;
1471
1472         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
1473
1474         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1475
1476         /* get data from dom tree */
1477         SyncHdr *pSyncHdr = (SyncHdr *) calloc(1, sizeof(SyncHdr));
1478         if (pSyncHdr == NULL) {
1479                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1480                 _DEBUG_TRACE("pSyncHdr is null");
1481                 goto return_part;
1482         }
1483
1484         WBXMLTreeNode *child = NULL;
1485         const char *child_xml_name = NULL;
1486         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
1487                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
1488
1489                 if (strcmp(child_xml_name, ELEMENT_VERDTD) == 0) {
1490                         char *verdtd = NULL;
1491                         err = sync_agent_get_text_from_node(child, &verdtd);
1492                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1493                                 goto return_part;
1494                         }
1495                         _DEBUG_TRACE("VerDTD = [%s]", verdtd);
1496
1497                         pSyncHdr->version = __get_oma_dm_protocol_version(verdtd);
1498                 } else if (strcmp(child_xml_name, ELEMENT_SESSIONID) == 0) {
1499                         char *sessionID = NULL;
1500                         err = sync_agent_get_text_from_node(child, &sessionID);
1501                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1502                                 goto return_part;
1503                         }
1504                         _DEBUG_TRACE("SessionID = [%s]", sessionID);
1505
1506                         if (sessionID != NULL) {
1507                                 pSyncHdr->sessionID = strdup(sessionID);
1508                         } else {
1509                                 pSyncHdr->sessionID = NULL;
1510                         }
1511                 } else if (strcmp(child_xml_name, ELEMENT_MSGID) == 0) {
1512                         char *msgID = NULL;
1513                         err = sync_agent_get_text_from_node(child, &msgID);
1514                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1515                                 goto return_part;
1516                         }
1517                         _DEBUG_TRACE("MsgID = [%s]", msgID);
1518                         if (msgID != NULL)
1519                                 pSyncHdr->messageID = atoi(msgID);
1520                 } else if (strcmp(child_xml_name, ELEMENT_TARGET) == 0) {
1521                         Location *pTargetLocation = __get_location(child);
1522                         if (pTargetLocation == NULL) {
1523                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1524                                 goto return_part;
1525                         }
1526                         if (pTargetLocation != NULL)
1527                                 pSyncHdr->target = pTargetLocation;
1528                 } else if (strcmp(child_xml_name, ELEMENT_SOURCE) == 0) {
1529                         Location *pSourceLocation = __get_location(child);
1530                         if (pSourceLocation == NULL) {
1531                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1532                                 goto return_part;
1533                         }
1534                         if (pSourceLocation != NULL)
1535                                 pSyncHdr->source = pSourceLocation;
1536                 } else if (strcmp(child_xml_name, ELEMENT_RESPURI) == 0) {
1537                         char *resp_uri = NULL;
1538                         err = sync_agent_get_text_from_node(child, &resp_uri);
1539                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1540                                 goto return_part;
1541                         }
1542                         if (resp_uri != NULL) {
1543                                 _DEBUG_TRACE("resp_uri =[%s] ", resp_uri);
1544                                 pSyncHdr->responseURI = strdup(resp_uri);
1545                         }
1546                 } else if (strcmp(child_xml_name, ELEMENT_CRED) == 0) {
1547                         Cred *pCred = NULL;
1548                         pCred = __get_cred(child);
1549                         if (pCred == NULL) {
1550                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1551                                 goto return_part;
1552                         }
1553                         _DEBUG_TRACE("Cred\n");
1554                         pSyncHdr->cred = pCred;
1555                 } else if (strcmp(child_xml_name, ELEMENT_META) == 0) {
1556
1557                 }
1558         }
1559
1560  return_part:
1561         if (err == SYNC_AGENT_PB_RETURN_OK) {
1562                 _DEBUG_TRACE("end");
1563                 *pContent = pSyncHdr;
1564         } else {
1565                 _DEBUG_TRACE("error");
1566                 free_synchdr(pSyncHdr);
1567         }
1568
1569         _INNER_FUNC_EXIT;
1570         return err;
1571 }
1572
1573 static sync_agent_pb_error_e _syncml_binder_results_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
1574 {
1575         _INNER_FUNC_ENTER;
1576
1577         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
1578         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
1579
1580         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1581
1582         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
1583
1584         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
1585         Item *item = NULL;
1586
1587         /* get data from dom tree */
1588         Command *pResults = (Command *) calloc(1, sizeof(Command));
1589         if (pResults == NULL) {
1590                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1591                 _DEBUG_TRACE("pResults is null");
1592                 goto return_part;
1593         }
1594
1595         pResults->type = COMMAND_TYPE_RESULTS;
1596         pResults->msgID = pSyncHdr->messageID;
1597         pResults->refCount = 1;
1598
1599         WBXMLTreeNode *child = NULL;
1600         const char *child_xml_name = NULL;
1601         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
1602                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
1603
1604                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
1605                         char *cmd_id = NULL;
1606                         err = sync_agent_get_text_from_node(child, &cmd_id);
1607                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1608                                 goto return_part;
1609                         }
1610                         if (cmd_id != NULL) {
1611                                 _DEBUG_TRACE("CmdID = [%s]", cmd_id);
1612                                 pResults->cmdID = atoi(cmd_id);
1613                         }
1614                 } else if (strcmp(child_xml_name, ELEMENT_MSGREF) == 0) {
1615                         char *msg_ref = NULL;
1616                         err = sync_agent_get_text_from_node(child, &msg_ref);
1617                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1618                                 goto return_part;
1619                         }
1620                         if (msg_ref != NULL) {
1621                                 _DEBUG_TRACE("MsgRef = [%s]", msg_ref);
1622                                 pResults->private.results.msgRef = atoi(msg_ref);
1623                         }
1624                 } else if (strcmp(child_xml_name, ELEMENT_CMDREF) == 0) {
1625                         char *cmd_ref = NULL;
1626                         err = sync_agent_get_text_from_node(child, &cmd_ref);
1627                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1628                                 goto return_part;
1629                         }
1630                         if (cmd_ref != NULL) {
1631                                 _DEBUG_TRACE("MsgRef = [%s]", cmd_ref);
1632                                 pResults->private.results.cmdRef = atoi(cmd_ref);
1633                         }
1634                 } else if (strcmp(child_xml_name, ELEMENT_META) == 0) {
1635
1636                         WBXMLTreeNode *grandchild = NULL;
1637                         const char *grandchild_xml_name = NULL;
1638
1639                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
1640                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
1641
1642                                 if (strcmp(grandchild_xml_name, ELEMENT_TYPE) == 0) {
1643                                         char *contentType = NULL;
1644                                         err = sync_agent_get_text_from_node(grandchild, &contentType);
1645                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1646                                                 goto return_part;
1647                                         }
1648                                         if (contentType != NULL) {
1649                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
1650                                                 pResults->private.results.type = strdup(contentType);
1651                                         }
1652                                 }
1653                         }
1654                 } else if (strcmp(child_xml_name, ELEMENT_TARGETREF) == 0) {
1655                         //TODO targetRef
1656                 } else if (strcmp(child_xml_name, ELEMENT_SOURCEREF) == 0) {
1657                         //TODO sourceRef
1658                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
1659                         /*create item in results command */
1660                         if (item == NULL)
1661                                 item = create_Item();
1662                         if (item == NULL) {
1663                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1664                                 goto return_part;
1665                         }
1666
1667                         WBXMLTreeNode *grandchild = NULL;
1668                         const char *grandchild_xml_name = NULL;
1669                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
1670                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
1671
1672                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
1673                                         Location *pSourceLocation = __get_location(grandchild);
1674                                         if (pSourceLocation == NULL) {
1675                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1676                                                 goto return_part;
1677                                         }
1678                                         if (pSourceLocation != NULL)
1679                                                 item->source = pSourceLocation;
1680                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
1681                                         Location *pTargetLocation = __get_location(grandchild);
1682                                         if (pTargetLocation == NULL) {
1683                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1684                                                 goto return_part;
1685                                         }
1686                                         if (pTargetLocation != NULL)
1687                                                 item->target = pTargetLocation;
1688                                 } else if (strcmp(grandchild_xml_name, ELEMENT_META) == 0) {
1689                                         WBXMLTreeNode *grandgrandchild = NULL;
1690                                         const char *grandgrandchild_xml_name = NULL;
1691
1692                                         for (grandgrandchild = grandchild->children; grandgrandchild != NULL; grandgrandchild = grandgrandchild->next) {
1693                                                 grandgrandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandgrandchild->name);
1694
1695                                                 if (strcmp(grandgrandchild_xml_name, ELEMENT_TYPE) == 0) {
1696                                                         char *contentType = NULL;
1697                                                         err = sync_agent_get_text_from_node(grandgrandchild, &contentType);
1698                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1699                                                                 goto return_part;
1700                                                         }
1701                                                         if (contentType != NULL) {
1702                                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
1703                                                                 item->contenttype = strdup(contentType);
1704                                                         }
1705                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_SIZE) == 0) {
1706                                                         char *size = NULL;
1707                                                         err = sync_agent_get_text_from_node(grandgrandchild, &size);
1708                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1709                                                                 goto return_part;
1710                                                         }
1711                                                         if (size != NULL) {
1712                                                                 _DEBUG_TRACE("Size = [%s]", size);
1713                                                                 item->size = atoi(size);
1714                                                         }
1715                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_FORMAT) == 0) {
1716                                                         char *format = NULL;
1717                                                         err = sync_agent_get_text_from_node(grandgrandchild, &format);
1718                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1719                                                                 goto return_part;
1720                                                         }
1721                                                         if (format != NULL) {
1722                                                                 _DEBUG_TRACE("Content Type = [%s]", format);
1723                                                                 item->format = strdup(format);
1724                                                         }
1725                                                 }
1726                                         }
1727                                 } else if (strcmp(grandchild_xml_name, ELEMENT_DATA) == 0) {
1728                                         char *data = NULL;
1729                                         err = sync_agent_get_text_from_cdata_node(grandchild, &data);
1730                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1731                                                 goto return_part;
1732                                         }
1733                                         if (data != NULL) {
1734                                                 _DEBUG_TRACE("Data =[%s] ", data);
1735                                                 item->private.data = g_strdup(data);
1736                                                 item->dataType = ITEM_DATA;
1737                                         }
1738                                 } else if (strcmp(grandchild_xml_name, ELEMENT_MOREDATA) == 0) {
1739                                         _DEBUG_TRACE(ELEMENT_MOREDATA);
1740                                         item->moreData = 1;
1741                                 }
1742                         }
1743                         pResults->private.results.items = g_list_append(pResults->private.results.items, item);
1744                         item = NULL;
1745                 }
1746         }
1747  return_part:
1748         if (err == SYNC_AGENT_PB_RETURN_OK) {
1749                 _DEBUG_TRACE("end");
1750                 *pContent = pResults;
1751         } else {
1752                 _DEBUG_TRACE("error");
1753                 free_command(pResults);
1754                 free_Item(item);
1755         }
1756
1757         _INNER_FUNC_EXIT;
1758         return err;
1759 }
1760
1761 static sync_agent_pb_error_e _syncml_binder_get_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
1762 {
1763         _INNER_FUNC_ENTER;
1764
1765         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
1766         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
1767
1768         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1769
1770         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
1771         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
1772         Item *item = NULL;
1773
1774         /* get data from dom tree */
1775         Command *pGet = (Command *) calloc(1, sizeof(Command));
1776         if (pGet == NULL) {
1777                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1778                 _DEBUG_TRACE("pGet is null");
1779                 goto return_part;
1780         }
1781
1782         pGet->type = COMMAND_TYPE_GET;
1783         pGet->msgID = pSyncHdr->messageID;
1784         pGet->refCount = 1;
1785
1786         WBXMLTreeNode *child = NULL;
1787         const char *child_xml_name = NULL;
1788         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
1789                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
1790
1791                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
1792                         char *cmd_id = NULL;
1793                         err = sync_agent_get_text_from_node(child, &cmd_id);
1794                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1795                                 goto return_part;
1796                         }
1797                         if (cmd_id != NULL) {
1798                                 _DEBUG_TRACE("CmdID = [%s]", cmd_id);
1799                                 pGet->cmdID = atoi(cmd_id);
1800                         }
1801                 } else if (strcmp(child_xml_name, ELEMENT_META) == 0) {
1802
1803                         WBXMLTreeNode *grandchild = NULL;
1804                         const char *grandchild_xml_name = NULL;
1805
1806                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
1807                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
1808
1809                                 if (strcmp(grandchild_xml_name, ELEMENT_TYPE) == 0) {
1810                                         char *contentType = NULL;
1811                                         err = sync_agent_get_text_from_node(grandchild, &contentType);
1812                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1813                                                 goto return_part;
1814                                         }
1815                                         if (contentType != NULL) {
1816                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
1817                                                 pGet->private.access.type = strdup(contentType);
1818                                         }
1819                                 }
1820                         }
1821                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
1822
1823                         if (item == NULL)
1824                                 item = create_Item();
1825                         if (item == NULL) {
1826                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1827                                 goto return_part;
1828                         }
1829
1830                         WBXMLTreeNode *grandchild = NULL;
1831                         const char *grandchild_xml_name = NULL;
1832                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
1833                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
1834
1835                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
1836                                         Location *pSourceLocation = __get_location(grandchild);
1837                                         if (pSourceLocation == NULL) {
1838                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1839                                                 goto return_part;
1840                                         }
1841                                         if (pSourceLocation != NULL)
1842                                                 item->source = pSourceLocation;
1843                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
1844                                         Location *pTargetLocation = __get_location(grandchild);
1845                                         if (pTargetLocation == NULL) {
1846                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1847                                                 goto return_part;
1848                                         }
1849                                         if (pTargetLocation != NULL)
1850                                                 item->target = pTargetLocation;
1851                                 } else if (strcmp(grandchild_xml_name, ELEMENT_META) == 0) {
1852                                         WBXMLTreeNode *grandgrandchild = NULL;
1853                                         const char *grandgrandchild_xml_name = NULL;
1854
1855                                         for (grandgrandchild = grandchild->children; grandgrandchild != NULL; grandgrandchild = grandgrandchild->next) {
1856                                                 grandgrandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandgrandchild->name);
1857
1858                                                 if (strcmp(grandgrandchild_xml_name, ELEMENT_TYPE) == 0) {
1859                                                         char *contentType = NULL;
1860                                                         err = sync_agent_get_text_from_node(grandgrandchild, &contentType);
1861                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1862                                                                 goto return_part;
1863                                                         }
1864                                                         if (contentType != NULL) {
1865                                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
1866                                                                 item->contenttype = strdup(contentType);
1867                                                         }
1868                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_SIZE) == 0) {
1869                                                         char *size = NULL;
1870                                                         err = sync_agent_get_text_from_node(grandgrandchild, &size);
1871                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1872                                                                 goto return_part;
1873                                                         }
1874                                                         if (size != NULL) {
1875                                                                 _DEBUG_TRACE("Size = [%s]", size);
1876                                                                 item->size = atoi(size);
1877                                                         }
1878                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_FORMAT) == 0) {
1879                                                         char *format = NULL;
1880                                                         err = sync_agent_get_text_from_node(grandgrandchild, &format);
1881                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1882                                                                 goto return_part;
1883                                                         }
1884                                                         if (format != NULL) {
1885                                                                 _DEBUG_TRACE("Content Type =[%s] ", format);
1886                                                                 item->format = strdup(format);
1887                                                         }
1888                                                 }
1889                                         }
1890                                 } else if (strcmp(grandchild_xml_name, ELEMENT_DATA) == 0) {
1891                                         char *data = NULL;
1892                                         err = sync_agent_get_text_from_cdata_node(grandchild, &data);
1893                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1894                                                 goto return_part;
1895                                         }
1896                                         if (data != NULL) {
1897                                                 _DEBUG_TRACE("Data = [%s]", data);
1898                                                 item->private.data = strdup(data);
1899                                                 item->dataType = ITEM_DATA;
1900                                         }
1901                                 } else if (strcmp(grandchild_xml_name, ELEMENT_MOREDATA) == 0) {
1902                                         _DEBUG_TRACE(ELEMENT_MOREDATA);
1903                                         item->moreData = 1;
1904                                 }
1905                         }
1906
1907                         pGet->private.access.items = g_list_append(pGet->private.access.items, item);
1908                         item = NULL;
1909                 }
1910         }
1911
1912  return_part:
1913         if (err == SYNC_AGENT_PB_RETURN_OK) {
1914                 _DEBUG_TRACE("end");
1915                 *pContent = pGet;
1916         } else {
1917                 _DEBUG_TRACE("error");
1918                 free_command(pGet);
1919                 free_Item(item);
1920         }
1921
1922         _INNER_FUNC_EXIT;
1923         return err;
1924 }
1925
1926 static sync_agent_pb_error_e _syncml_binder_alert_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
1927 {
1928         _INNER_FUNC_ENTER;
1929
1930         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
1931         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
1932
1933         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
1934
1935         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
1936         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
1937         Item *item = NULL;
1938
1939         /* get data from dom tree */
1940         Command *pAlert = (Command *) calloc(1, sizeof(Command));
1941         if (pAlert == NULL) {
1942                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1943                 _DEBUG_TRACE("pAlert is null");
1944                 goto return_part;
1945         }
1946
1947         pAlert->type = COMMAND_TYPE_ALERT;
1948         pAlert->msgID = pSyncHdr->messageID;
1949         pAlert->refCount = 1;
1950
1951         WBXMLTreeNode *child = NULL;
1952         const char *child_xml_name = NULL;
1953         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
1954                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
1955
1956                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
1957                         char *cmd_id = NULL;
1958                         err = sync_agent_get_text_from_node(child, &cmd_id);
1959                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1960                                 goto return_part;
1961                         }
1962                         if (cmd_id != NULL) {
1963                                 _DEBUG_TRACE("CmdID = [%s]", cmd_id);
1964                                 pAlert->cmdID = atoi(cmd_id);
1965                         }
1966                 } else if (strcmp(child_xml_name, ELEMENT_DATA) == 0) {
1967                         char *data = NULL;
1968                         err = sync_agent_get_text_from_node(child, &data);
1969                         if (err != SYNC_AGENT_PB_RETURN_OK) {
1970                                 goto return_part;
1971                         }
1972                         if (data != NULL) {
1973                                 _DEBUG_TRACE("Data = [%s]", data);
1974                                 pAlert->private.alert.type = atoi(data);
1975                         }
1976                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
1977                         _DEBUG_TRACE("alert item");
1978                         if (item == NULL) {
1979                                 item = create_Item();
1980                         }
1981                         if (item == NULL) {
1982                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1983                                 goto return_part;
1984                         }
1985
1986                         WBXMLTreeNode *grandchild = NULL;
1987                         const char *grandchild_xml_name = NULL;
1988                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
1989                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
1990
1991                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
1992                                         Location *pSourceLocation = __get_location(grandchild);
1993                                         if (pSourceLocation == NULL) {
1994                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
1995                                                 goto return_part;
1996                                         }
1997                                         if (pSourceLocation != NULL)
1998                                                 pAlert->source = pSourceLocation;
1999                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
2000                                         Location *pTargetLocation = __get_location(grandchild);
2001                                         if (pTargetLocation == NULL) {
2002                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2003                                                 goto return_part;
2004                                         }
2005                                         if (pTargetLocation != NULL)
2006                                                 item->target = pTargetLocation;
2007                                 } else if (strcmp(grandchild_xml_name, ELEMENT_META) == 0) {
2008                                         WBXMLTreeNode *grandgrandchild = NULL;
2009                                         const char *grandgrandchild_xml_name = NULL;
2010
2011                                         for (grandgrandchild = grandchild->children; grandgrandchild != NULL; grandgrandchild = grandgrandchild->next) {
2012                                                 grandgrandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandgrandchild->name);
2013
2014                                                 if (strcmp(grandgrandchild_xml_name, ELEMENT_MAXOBJSIZE) == 0) {
2015                                                         char *maxObjSize = NULL;
2016                                                         err = sync_agent_get_text_from_node(grandgrandchild, &maxObjSize);
2017                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2018                                                                 goto return_part;
2019                                                         }
2020                                                         if (maxObjSize != NULL) {
2021                                                                 _DEBUG_TRACE("MaxObjSize = [%s]", maxObjSize);
2022                                                                 pAlert->private.alert.maxObjSize = atoi(maxObjSize);
2023                                                         }
2024                                                 }
2025                                         }
2026                                 } else if (strcmp(grandchild_xml_name, ELEMENT_DATA) == 0) {
2027                                         char *data = NULL;
2028                                         /*err = sync_agent_get_text_from_cdata_node(grandchild, &data); */
2029                                         err = sync_agent_get_text_from_node(grandchild, &data);
2030                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2031                                                 goto return_part;
2032                                         }
2033                                         if (data != NULL) {
2034                                                 _DEBUG_TRACE("item Data =[%s] ", data);
2035                                                 item->private.data = g_strdup(data);
2036                                                 item->dataType = ITEM_DATA;
2037                                         }
2038                                 }
2039                         }
2040                         pAlert->private.alert.items = g_list_append(pAlert->private.alert.items, item);
2041                         item = NULL;
2042                 }
2043         }
2044
2045  return_part:
2046         if (err == SYNC_AGENT_PB_RETURN_OK) {
2047                 _DEBUG_TRACE("end");
2048                 *pContent = pAlert;
2049         } else {
2050                 _DEBUG_TRACE("error");
2051                 free_command(pAlert);
2052                 free_Item(item);
2053         }
2054
2055         _INNER_FUNC_EXIT;
2056         return err;
2057 }
2058
2059 static sync_agent_pb_error_e _syncml_binder_add_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2060 {
2061         _INNER_FUNC_ENTER;
2062
2063         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
2064         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
2065
2066         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2067
2068         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
2069         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
2070         Item *item = NULL;
2071
2072         /* get data from dom tree */
2073         Command *pAdd = (Command *) calloc(1, sizeof(Command));
2074         if (pAdd == NULL) {
2075                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2076                 _DEBUG_TRACE("pAdd is null");
2077                 goto return_part;
2078         }
2079
2080         pAdd->type = COMMAND_TYPE_ADD;;
2081         pAdd->msgID = pSyncHdr->messageID;
2082         pAdd->private.change.type = CHANGE_ADD;
2083         pAdd->refCount = 1;
2084
2085         WBXMLTreeNode *child = NULL;
2086         const char *child_xml_name = NULL;
2087         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
2088                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
2089
2090                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
2091                         char *cmd_id = NULL;
2092                         err = sync_agent_get_text_from_node(child, &cmd_id);
2093                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2094                                 goto return_part;
2095                         }
2096                         if (cmd_id != NULL) {
2097                                 _DEBUG_TRACE("CmdID =[%s] ", cmd_id);
2098                                 pAdd->cmdID = atoi(cmd_id);
2099                         }
2100                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
2101
2102                         if (item == NULL)
2103                                 item = create_Item();
2104                         if (item == NULL) {
2105                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2106                                 goto return_part;
2107                         }
2108
2109                         WBXMLTreeNode *grandchild = NULL;
2110                         const char *grandchild_xml_name = NULL;
2111                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
2112                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
2113
2114                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
2115                                         Location *pSourceLocation = __get_location(grandchild);
2116                                         if (pSourceLocation == NULL) {
2117                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2118                                                 goto return_part;
2119                                         }
2120                                         if (pSourceLocation != NULL)
2121                                                 item->source = pSourceLocation;
2122                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
2123                                         Location *pTargetLocation = __get_location(grandchild);
2124                                         if (pTargetLocation == NULL) {
2125                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2126                                                 goto return_part;
2127                                         }
2128                                         if (pTargetLocation != NULL)
2129                                                 item->target = pTargetLocation;
2130                                 } else if (strcmp(grandchild_xml_name, ELEMENT_META) == 0) {
2131                                         WBXMLTreeNode *grandgrandchild = NULL;
2132                                         const char *grandgrandchild_xml_name = NULL;
2133
2134                                         for (grandgrandchild = grandchild->children; grandgrandchild != NULL; grandgrandchild = grandgrandchild->next) {
2135                                                 grandgrandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandgrandchild->name);
2136
2137                                                 if (strcmp(grandgrandchild_xml_name, ELEMENT_TYPE) == 0) {
2138                                                         char *contentType = NULL;
2139                                                         err = sync_agent_get_text_from_node(grandgrandchild, &contentType);
2140                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2141                                                                 goto return_part;
2142                                                         }
2143                                                         if (contentType != NULL) {
2144                                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
2145                                                                 item->contenttype = strdup(contentType);
2146                                                         }
2147                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_SIZE) == 0) {
2148                                                         char *size = NULL;
2149                                                         err = sync_agent_get_text_from_node(grandgrandchild, &size);
2150                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2151                                                                 goto return_part;
2152                                                         }
2153                                                         if (size != NULL) {
2154                                                                 _DEBUG_TRACE("Size =[%s] ", size);
2155                                                                 item->size = atoi(size);
2156                                                         }
2157                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_FORMAT) == 0) {
2158                                                         char *format = NULL;
2159                                                         err = sync_agent_get_text_from_node(grandgrandchild, &format);
2160                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2161                                                                 goto return_part;
2162                                                         }
2163                                                         if (format != NULL) {
2164                                                                 _DEBUG_TRACE("format =[%s] ", format);
2165                                                                 item->format = strdup(format);
2166                                                         }
2167                                                 }
2168                                         }
2169                                 } else if (strcmp(grandchild_xml_name, ELEMENT_DATA) == 0) {
2170                                         char *data = NULL;
2171                                         err = sync_agent_get_text_from_cdata_node(grandchild, &data);
2172                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2173                                                 goto return_part;
2174                                         }
2175                                         if (data != NULL) {
2176                                                 _DEBUG_TRACE("Data =[%s] ", data);
2177                                                 item->private.data = g_strdup(data);
2178                                                 item->dataType = ITEM_DATA;
2179                                         }
2180                                 } else if (strcmp(grandchild_xml_name, ELEMENT_MOREDATA) == 0) {
2181                                         _DEBUG_TRACE(ELEMENT_MOREDATA);
2182                                         item->moreData = 1;
2183                                 }
2184                         }
2185                         pAdd->private.change.items = g_list_append(pAdd->private.change.items, item);
2186                         item = NULL;
2187                 }
2188         }
2189
2190  return_part:
2191         if (err == SYNC_AGENT_PB_RETURN_OK) {
2192                 _DEBUG_TRACE("end");
2193                 *pContent = pAdd;
2194         } else {
2195                 _DEBUG_TRACE("error");
2196                 free_command(pAdd);
2197                 free_Item(item);
2198         }
2199
2200         _INNER_FUNC_EXIT;
2201         return err;
2202 }
2203
2204 static sync_agent_pb_error_e _syncml_binder_replace_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2205 {
2206         _INNER_FUNC_ENTER;
2207
2208         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
2209         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
2210
2211         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2212
2213         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
2214         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
2215         Item *item = NULL;
2216
2217         /* get data from dom tree */
2218         Command *pReplace = (Command *) calloc(1, sizeof(Command));
2219         if (pReplace == NULL) {
2220                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2221                 _DEBUG_TRACE("pReplace is null");
2222                 goto return_part;
2223         }
2224
2225         pReplace->type = COMMAND_TYPE_REPLACE;;
2226         pReplace->msgID = pSyncHdr->messageID;
2227         pReplace->private.change.type = CHANGE_REPLACE;
2228         pReplace->refCount = 1;
2229
2230         WBXMLTreeNode *child = NULL;
2231         const char *child_xml_name = NULL;
2232         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
2233                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
2234
2235                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
2236                         char *cmd_id = NULL;
2237                         err = sync_agent_get_text_from_node(child, &cmd_id);
2238                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2239                                 goto return_part;
2240                         }
2241                         if (cmd_id) {
2242                                 _DEBUG_TRACE("CmdID =[%s] ", cmd_id);
2243                                 pReplace->cmdID = atoi(cmd_id);
2244                         }
2245                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
2246
2247                         if (item == NULL)
2248                                 item = create_Item();
2249                         if (item == NULL) {
2250                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2251                                 goto return_part;
2252                         }
2253
2254                         WBXMLTreeNode *grandchild = NULL;
2255                         const char *grandchild_xml_name = NULL;
2256                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
2257                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
2258
2259                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
2260                                         Location *pSourceLocation = __get_location(grandchild);
2261                                         if (pSourceLocation == NULL) {
2262                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2263                                                 goto return_part;
2264                                         }
2265                                         if (pSourceLocation != NULL)
2266                                                 item->source = pSourceLocation;
2267                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
2268                                         Location *pTargetLocation = __get_location(grandchild);
2269                                         if (pTargetLocation == NULL) {
2270                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2271                                                 goto return_part;
2272                                         }
2273                                         if (pTargetLocation != NULL)
2274                                                 item->target = pTargetLocation;
2275                                 } else if (strcmp(grandchild_xml_name, ELEMENT_META) == 0) {
2276                                         WBXMLTreeNode *grandgrandchild = NULL;
2277                                         const char *grandgrandchild_xml_name = NULL;
2278
2279                                         for (grandgrandchild = grandchild->children; grandgrandchild != NULL; grandgrandchild = grandgrandchild->next) {
2280                                                 grandgrandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandgrandchild->name);
2281                                                 if (strcmp(grandgrandchild_xml_name, ELEMENT_TYPE) == 0) {
2282
2283                                                         char *contentType = NULL;
2284                                                         err = sync_agent_get_text_from_node(grandgrandchild, &contentType);
2285                                                         _DEBUG_TRACE("%d\n", err);
2286
2287                                                         /*      if (err != SYNC_AGENT_PB_RETURN_OK || err != SYNC_AGENT_PB_RETURN_UTIL_NO_TEXT_VALUE) {
2288                                                            goto return_part;
2289                                                            } */
2290                                                         if (contentType != NULL) {
2291                                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
2292                                                                 item->contenttype = strdup(contentType);
2293                                                         }
2294                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_SIZE) == 0) {
2295
2296                                                         char *size = NULL;
2297                                                         err = sync_agent_get_text_from_node(grandgrandchild, &size);
2298                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2299                                                                 goto return_part;
2300                                                         }
2301                                                         if (size != NULL) {
2302                                                                 _DEBUG_TRACE("Size =[%s] ", size);
2303                                                                 item->size = atoi(size);
2304                                                         }
2305                                                 } else if (strcmp(grandgrandchild_xml_name, ELEMENT_FORMAT) == 0) {
2306                                                         char *format = NULL;
2307                                                         err = sync_agent_get_text_from_node(grandgrandchild, &format);
2308                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2309                                                                 goto return_part;
2310                                                         }
2311                                                         if (format != NULL) {
2312                                                                 _DEBUG_TRACE("Content Type = [%s]", format);
2313                                                                 item->format = strdup(format);
2314                                                         }
2315                                                 }
2316                                         }
2317
2318                                 } else if (strcmp(grandchild_xml_name, ELEMENT_DATA) == 0) {
2319                                         char *data = NULL;
2320                                         err = sync_agent_get_text_from_cdata_node(grandchild, &data);
2321                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2322                                                 goto return_part;
2323                                         }
2324                                         if (data != NULL) {
2325                                                 _DEBUG_TRACE("Data = [%s]", data);
2326                                                 item->private.data = g_strdup(data);
2327                                                 item->dataType = ITEM_DATA;
2328                                         }
2329                                 }
2330                         }
2331                         pReplace->private.change.items = g_list_append(pReplace->private.change.items, item);
2332                         item = NULL;
2333                 }
2334         }
2335
2336  return_part:
2337         if (err == SYNC_AGENT_PB_RETURN_OK) {
2338                 _DEBUG_TRACE("end");
2339                 *pContent = pReplace;
2340         } else {
2341                 _DEBUG_TRACE("error");
2342                 free_command(pReplace);
2343                 free_Item(item);
2344         }
2345
2346         _INNER_FUNC_EXIT;
2347         return err;
2348 }
2349
2350 static sync_agent_pb_error_e _syncml_binder_delete_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2351 {
2352         _INNER_FUNC_ENTER;
2353
2354         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
2355         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
2356
2357         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2358
2359         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
2360         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
2361         Item *item = NULL;
2362
2363         /* get data from dom tree */
2364         Command *pDelete = (Command *) calloc(1, sizeof(Command));
2365         if (pDelete == NULL) {
2366                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2367                 _DEBUG_TRACE("pDelete is null");
2368                 goto return_part;
2369         }
2370
2371         pDelete->type = COMMAND_TYPE_DELETE;
2372         pDelete->msgID = pSyncHdr->messageID;
2373         pDelete->private.change.type = CHANGE_DELETE;
2374         pDelete->refCount = 1;
2375
2376         WBXMLTreeNode *child = NULL;
2377         const char *child_xml_name = NULL;
2378         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
2379                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
2380
2381                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
2382                         char *cmd_id = NULL;
2383                         err = sync_agent_get_text_from_node(child, &cmd_id);
2384                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2385                                 goto return_part;
2386                         }
2387                         if (cmd_id != NULL) {
2388                                 _DEBUG_TRACE("CmdID = [%s]", cmd_id);
2389                                 pDelete->cmdID = atoi(cmd_id);
2390                         }
2391                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
2392                         /* create Item */
2393                         if (item == NULL)
2394                                 item = create_Item();
2395                         if (item == NULL) {
2396                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2397                                 goto return_part;
2398                         }
2399
2400                         WBXMLTreeNode *grandchild = NULL;
2401                         const char *grandchild_xml_name = NULL;
2402                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
2403                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
2404
2405                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
2406                                         Location *pSourceLocation = __get_location(grandchild);
2407                                         if (pSourceLocation == NULL) {
2408                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2409                                                 goto return_part;
2410                                         }
2411                                         if (pSourceLocation != NULL)
2412                                                 item->source = pSourceLocation;
2413                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
2414                                         Location *pTargetLocation = __get_location(grandchild);
2415                                         if (pTargetLocation == NULL) {
2416                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2417                                                 goto return_part;
2418                                         }
2419                                         if (pTargetLocation != NULL)
2420                                                 item->target = pTargetLocation;
2421                                 } else if (strcmp(grandchild_xml_name, ELEMENT_META) == 0) {
2422                                         WBXMLTreeNode *grandgrandchild = NULL;
2423                                         const char *grandgrandchild_xml_name = NULL;
2424
2425                                         for (grandgrandchild = grandchild->children; grandgrandchild != NULL; grandgrandchild = grandgrandchild->next) {
2426                                                 grandgrandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandgrandchild->name);
2427
2428                                                 if (strcmp(grandgrandchild_xml_name, ELEMENT_TYPE) == 0) {
2429                                                         char *contentType = NULL;
2430                                                         err = sync_agent_get_text_from_node(grandgrandchild, &contentType);
2431                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2432                                                                 goto return_part;
2433                                                         }
2434                                                         if (contentType != NULL) {
2435                                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
2436                                                                 item->contenttype = strdup(contentType);
2437                                                         }
2438                                                 }
2439                                         }
2440                                 } else if (strcmp(grandchild_xml_name, ELEMENT_DATA) == 0) {
2441
2442                                 }
2443                         }
2444                         pDelete->private.change.items = g_list_append(pDelete->private.change.items, item);
2445                         item = NULL;
2446                 }
2447         }
2448
2449  return_part:
2450         if (err == SYNC_AGENT_PB_RETURN_OK) {
2451                 _DEBUG_TRACE("end");
2452                 *pContent = pDelete;
2453         } else {
2454                 _DEBUG_TRACE("error");
2455                 free_command(pDelete);
2456                 free_Item(item);
2457         }
2458
2459         _INNER_FUNC_EXIT;
2460         return err;
2461 }
2462
2463 static sync_agent_pb_error_e _syncml_binder_exec_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2464 {
2465         _INNER_FUNC_ENTER;
2466
2467         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
2468         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
2469
2470         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2471
2472         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
2473         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
2474
2475         /* get data from dom tree */
2476         Command *pExec = (Command *) calloc(1, sizeof(Command));
2477         if (pExec == NULL) {
2478                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2479                 _DEBUG_TRACE("pExec is null");
2480                 goto return_part;
2481         }
2482
2483         pExec->type = COMMAND_TYPE_EXEC;
2484         pExec->msgID = pSyncHdr->messageID;
2485         pExec->refCount = 1;
2486
2487         WBXMLTreeNode *child = NULL;
2488         const char *child_xml_name = NULL;
2489         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
2490                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
2491
2492                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
2493                         char *cmd_id = NULL;
2494                         err = sync_agent_get_text_from_node(child, &cmd_id);
2495                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2496                                 goto return_part;
2497                         }
2498                         if (cmd_id != NULL) {
2499                                 _DEBUG_TRACE("CmdID =[%s] ", cmd_id);
2500                                 pExec->cmdID = atoi(cmd_id);
2501                         }
2502                 } else if (strcmp(child_xml_name, ELEMENT_CORRELATOR) == 0) {
2503                         char *pCorrelator = NULL;
2504                         err = sync_agent_get_text_from_node(child, &pCorrelator);
2505                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2506                                 goto return_part;
2507                         }
2508                         if (pCorrelator != NULL) {
2509                                 _DEBUG_TRACE("pCorrelator = [%s]", pCorrelator);
2510                                 pExec->private.exec.correlator = strdup(pCorrelator);
2511                         }
2512                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
2513                         /* create Item */
2514                         pExec->private.exec.item = create_Item();
2515                         if (pExec->private.exec.item == NULL) {
2516                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2517                                 goto return_part;
2518                         }
2519                         WBXMLTreeNode *grandchild = NULL;
2520                         const char *grandchild_xml_name = NULL;
2521                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
2522                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
2523
2524                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
2525                                         Location *pSourceLocation = __get_location(grandchild);
2526                                         if (pSourceLocation == NULL) {
2527                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2528                                                 goto return_part;
2529                                         }
2530                                         if (pSourceLocation != NULL)
2531                                                 pExec->private.exec.item->source = pSourceLocation;
2532                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
2533                                         Location *pTargetLocation = __get_location(grandchild);
2534                                         if (pTargetLocation == NULL) {
2535                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2536                                                 goto return_part;
2537                                         }
2538                                         if (pTargetLocation != NULL)
2539                                                 pExec->private.exec.item->target = pTargetLocation;
2540                                 }
2541                         }
2542                 }
2543         }
2544
2545  return_part:
2546         if (err == SYNC_AGENT_PB_RETURN_OK) {
2547                 _DEBUG_TRACE("end");
2548                 *pContent = pExec;
2549         } else {
2550                 _DEBUG_TRACE("error");
2551                 free_command(pExec);
2552         }
2553
2554         _INNER_FUNC_EXIT;
2555         return err;
2556 }
2557
2558 static sync_agent_pb_error_e _syncml_binder_sequence_start_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2559 {
2560
2561         _INNER_FUNC_ENTER;
2562
2563         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
2564
2565         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2566
2567         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
2568         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
2569
2570         /* get data from dom tree */
2571         Command *pSequence = (Command *) calloc(1, sizeof(Command));
2572
2573         if (pSequence == NULL) {
2574                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2575                 _DEBUG_TRACE("pSequence is null");
2576                 goto return_part;
2577         }
2578
2579         pSequence->type = COMMAND_TYPE_SEQUENCE;
2580         pSequence->msgID = pSyncHdr->messageID;
2581         pSequence->refCount = 1;
2582
2583  return_part:
2584         if (err == SYNC_AGENT_PB_RETURN_OK) {
2585                 _DEBUG_TRACE("end");
2586                 *pContent = pSequence;
2587         } else {
2588                 _DEBUG_TRACE("error");
2589                 free_command(pSequence);
2590         }
2591
2592         _INNER_FUNC_EXIT;
2593         return err;
2594
2595 }
2596
2597 static sync_agent_pb_error_e _syncml_binder_sequence_end_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2598 {
2599
2600         _INNER_FUNC_ENTER;
2601
2602         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2603
2604         if (err == SYNC_AGENT_PB_RETURN_OK) {
2605                 _DEBUG_TRACE("end");
2606         } else {
2607                 _DEBUG_TRACE("error");
2608         }
2609
2610         _INNER_FUNC_EXIT;
2611         return err;
2612
2613 }
2614
2615 static sync_agent_pb_error_e _syncml_binder_atomic_start_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2616 {
2617
2618         _INNER_FUNC_ENTER;
2619
2620         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
2621
2622         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2623
2624         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
2625         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
2626         Command *pAtomic = (Command *) calloc(1, sizeof(Command));
2627
2628         if (pAtomic == NULL) {
2629                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2630                 _DEBUG_TRACE("pExec is null");
2631                 goto return_part;
2632         }
2633
2634         pAtomic->type = COMMAND_TYPE_ATOMIC;
2635         pAtomic->msgID = pSyncHdr->messageID;
2636         pAtomic->refCount = 1;
2637
2638  return_part:
2639         if (err == SYNC_AGENT_PB_RETURN_OK) {
2640                 _DEBUG_TRACE("end");
2641                 *pContent = pAtomic;
2642         } else {
2643                 _DEBUG_TRACE("error");
2644                 free_command(pAtomic);
2645         }
2646
2647         _INNER_FUNC_EXIT;
2648         return err;
2649 }
2650
2651 static sync_agent_pb_error_e _syncml_binder_atomic_end_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2652 {
2653
2654         _INNER_FUNC_ENTER;
2655
2656         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2657
2658         if (err == SYNC_AGENT_PB_RETURN_OK) {
2659                 _DEBUG_TRACE("end");
2660         } else {
2661                 _DEBUG_TRACE("error");
2662         }
2663
2664         _INNER_FUNC_EXIT;
2665         return err;
2666 }
2667
2668 static sync_agent_pb_error_e _syncml_binder_final_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2669 {
2670         _INNER_FUNC_ENTER;
2671
2672         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2673
2674         int *pFinal = (int *)1;
2675         *pContent = pFinal;
2676
2677         _INNER_FUNC_EXIT;
2678         return err;
2679 }
2680
2681 static sync_agent_pb_error_e _syncml_binder_status_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2682 {
2683         _INNER_FUNC_ENTER;
2684
2685         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
2686
2687         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2688
2689         /* get data from dom tree */
2690         Status *pStatus = (Status *) calloc(1, sizeof(Status));
2691         if (pStatus == NULL) {
2692                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2693                 _DEBUG_TRACE("pStatus is null");
2694                 goto return_part;
2695         }
2696
2697         WBXMLTreeNode *child = NULL;
2698         const char *child_xml_name = NULL;
2699         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
2700                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
2701
2702                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
2703                         char *cmd_id = NULL;
2704                         err = sync_agent_get_text_from_node(child, &cmd_id);
2705                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2706                                 goto return_part;
2707                         }
2708                         if (cmd_id != NULL) {
2709                                 _DEBUG_TRACE("CmdID =[%s] ", cmd_id);
2710                                 pStatus->cmdID = atoi(cmd_id);
2711                         }
2712                 } else if (strcmp(child_xml_name, ELEMENT_MSGREF) == 0) {
2713                         char *msgref = NULL;
2714                         err = sync_agent_get_text_from_node(child, &msgref);
2715                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2716                                 goto return_part;
2717                         }
2718                         if (msgref != NULL) {
2719                                 _DEBUG_TRACE("MsgRef = [%s]", msgref);
2720                                 pStatus->msgRef = atoi(msgref);
2721                         }
2722                 } else if (strcmp(child_xml_name, ELEMENT_CMDREF) == 0) {
2723                         char *cmdref = NULL;
2724                         err = sync_agent_get_text_from_node(child, &cmdref);
2725                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2726                                 goto return_part;
2727                         }
2728                         if (cmdref != NULL) {
2729                                 _DEBUG_TRACE("CmdRef = [%s]", cmdref);
2730                                 pStatus->cmdRef = atoi(cmdref);
2731                         }
2732                 } else if (strcmp(child_xml_name, ELEMENT_CMD) == 0) {
2733                         char *cmd = NULL;
2734                         err = sync_agent_get_text_from_node(child, &cmd);
2735                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2736                                 goto return_part;
2737                         }
2738                         if (cmd != NULL) {
2739                                 _DEBUG_TRACE("Cmd =[%s] ", cmd);
2740                                 pStatus->type = converttocommandtype(cmd);
2741                         }
2742                 } else if (strcmp(child_xml_name, ELEMENT_TARGETREF) == 0) {
2743                         char *targetref = NULL;
2744                         Location *pLocation = NULL;
2745                         err = sync_agent_get_text_from_node(child, &targetref);
2746                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2747                                 goto return_part;
2748                         }
2749                         if (targetref != NULL) {
2750                                 DM_ERROR ret = DM_OK;
2751                                 _DEBUG_TRACE("TargetRef = [%s]", targetref);
2752                                 ret = create_location(targetref, NULL, &pLocation);
2753                                 if(ret != DM_OK) {
2754                                         _DEBUG_VERBOSE("create_location failed");
2755                                         goto return_part;
2756                                 }
2757                                 pStatus->targetRef = pLocation;
2758                         }
2759                 } else if (strcmp(child_xml_name, ELEMENT_SOURCEREF) == 0) {
2760                         char *sourceref = NULL;
2761                         Location *pLocation = NULL;
2762                         err = sync_agent_get_text_from_node(child, &sourceref);
2763                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2764                                 goto return_part;
2765                         }
2766                         if (sourceref != NULL) {
2767                                 DM_ERROR ret = DM_OK;
2768                                 _DEBUG_TRACE("SourceRef = [%s]", sourceref);
2769                                 ret = create_location(sourceref, NULL, &pLocation);
2770                                 if(ret != DM_OK) {
2771                                         _DEBUG_VERBOSE("create_location failed");
2772                                         goto return_part;
2773                                 }
2774                                 pStatus->sourceRef = pLocation;
2775                         }
2776                 } else if (strcmp(child_xml_name, ELEMENT_CRED) == 0) {
2777                         _DEBUG_TRACE(ELEMENT_CRED);
2778                         pStatus->cred = __get_cred(child);
2779                 } else if (strcmp(child_xml_name, ELEMENT_CHAL) == 0) {
2780                         _DEBUG_TRACE("Chal\n");
2781                         pStatus->chal = __get_chal(child);
2782                 } else if (strcmp(child_xml_name, ELEMENT_DATA) == 0) {
2783                         char *data = NULL;
2784                         err = sync_agent_get_text_from_node(child, &data);
2785                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2786                                 goto return_part;
2787                         }
2788                         if (data != NULL) {
2789                                 _DEBUG_TRACE("Data = [%s]\n", data);
2790                                 pStatus->data = strdup(data);
2791                         }
2792                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
2793                         /* TODO : item */
2794                 }
2795         }
2796
2797  return_part:
2798         if (err == SYNC_AGENT_PB_RETURN_OK) {
2799                 _DEBUG_TRACE("end");
2800                 *pContent = pStatus;
2801         } else {
2802                 _DEBUG_TRACE("error");
2803                 free_status(pStatus);
2804         }
2805         _INNER_FUNC_EXIT;
2806         return err;
2807 }
2808
2809 static sync_agent_pb_error_e _syncml_binder_copy_command_reverse_converter_function(sync_agent_pb_protocol_binder_reverse_info_s * pReverse_binder, WBXMLTreeNode * wbxml_dom_node, Content_Ptr * pContent)
2810 {
2811         _INNER_FUNC_ENTER;
2812
2813         retvm_if((pReverse_binder) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "pReverse_binder is NULL!!");
2814         retvm_if((wbxml_dom_node) == NULL, SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY, "wbxml_dom_node is NULL!!");
2815
2816         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2817
2818         void *user_data = sync_agent_get_user_data_from_reverse_protocol_binder(pReverse_binder);
2819         SyncHdr *pSyncHdr = (SyncHdr *) user_data;
2820         Item *item = NULL;
2821         /* get data from dom tree */
2822         Command *pCopy = (Command *) calloc(1, sizeof(Command));
2823         if (pCopy == NULL) {
2824                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2825                 _DEBUG_TRACE("pCopy is null");
2826                 goto return_part;
2827         }
2828
2829         pCopy->type = COMMAND_TYPE_COPY;
2830         pCopy->msgID = pSyncHdr->messageID;
2831         pCopy->private.change.type = CHANGE_COPY;
2832         pCopy->refCount = 1;
2833
2834         WBXMLTreeNode *child = NULL;
2835         const char *child_xml_name = NULL;
2836         for (child = wbxml_dom_node->children; child != NULL; child = child->next) {
2837                 child_xml_name = (const char *)wbxml_tag_get_xml_name(child->name);
2838
2839                 if (strcmp(child_xml_name, ELEMENT_CMDID) == 0) {
2840                         char *cmd_id = NULL;
2841                         err = sync_agent_get_text_from_node(child, &cmd_id);
2842                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2843                                 goto return_part;
2844                         }
2845                         if (cmd_id != NULL) {
2846                                 _DEBUG_TRACE("CmdID = [%s]", cmd_id);
2847                                 pCopy->cmdID = atoi(cmd_id);
2848                         }
2849                 } else if (strcmp(child_xml_name, ELEMENT_ITEM) == 0) {
2850                         /* create Item */
2851
2852                         if (item == NULL)
2853                                 item = create_Item();
2854                         if (item == NULL) {
2855                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2856                                 goto return_part;
2857                         }
2858
2859                         WBXMLTreeNode *grandchild = NULL;
2860                         const char *grandchild_xml_name = NULL;
2861                         for (grandchild = child->children; grandchild != NULL; grandchild = grandchild->next) {
2862                                 grandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandchild->name);
2863
2864                                 if (strcmp(grandchild_xml_name, ELEMENT_SOURCE) == 0) {
2865                                         Location *pSourceLocation = __get_location(grandchild);
2866                                         if (pSourceLocation == NULL) {
2867                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2868                                                 goto return_part;
2869                                         }
2870                                         if (pSourceLocation != NULL)
2871                                                 item->source = pSourceLocation;
2872                                 } else if (strcmp(grandchild_xml_name, ELEMENT_TARGET) == 0) {
2873                                         Location *pTargetLocation = __get_location(grandchild);
2874                                         if (pTargetLocation == NULL) {
2875                                                 err = SYNC_AGENT_PB_RETURN_OUT_OF_MEMORY;
2876                                                 goto return_part;
2877                                         }
2878                                         if (pTargetLocation != NULL)
2879                                                 item->target = pTargetLocation;
2880                                 } else if (strcmp(grandchild_xml_name, ELEMENT_META) == 0) {
2881                                         WBXMLTreeNode *grandgrandchild = NULL;
2882                                         const char *grandgrandchild_xml_name = NULL;
2883
2884                                         for (grandgrandchild = grandchild->children; grandgrandchild != NULL; grandgrandchild = grandgrandchild->next) {
2885                                                 grandgrandchild_xml_name = (const char *)wbxml_tag_get_xml_name(grandgrandchild->name);
2886
2887                                                 if (strcmp(grandgrandchild_xml_name, ELEMENT_TYPE) == 0) {
2888                                                         char *contentType = NULL;
2889                                                         err = sync_agent_get_text_from_node(grandgrandchild, &contentType);
2890                                                         if (err != SYNC_AGENT_PB_RETURN_OK) {
2891                                                                 goto return_part;
2892                                                         }
2893                                                         if (contentType != NULL) {
2894                                                                 _DEBUG_TRACE("Content Type = [%s]", contentType);
2895                                                                 item->contenttype = strdup(contentType);
2896                                                         }
2897                                                 }
2898                                         }
2899                                 } else if (strcmp(grandchild_xml_name, ELEMENT_DATA) == 0) {
2900
2901                                 }
2902                         }
2903                         pCopy->private.change.items = g_list_append(pCopy->private.change.items, item);
2904                         item = NULL;
2905                 }
2906         }
2907
2908  return_part:
2909         if (err == SYNC_AGENT_PB_RETURN_OK) {
2910                 _DEBUG_TRACE("end");
2911                 *pContent = pCopy;
2912         } else {
2913                 _DEBUG_TRACE("error");
2914                 free_command(pCopy);
2915                 free_Item(item);
2916         }
2917
2918         _INNER_FUNC_EXIT;
2919         return err;
2920 }
2921
2922 sync_agent_pb_error_e init_syncml_binder_function_set(sync_agent_pb_protocol_binder_function_set_s ** pBinder_function_set)
2923 {
2924         _EXTERN_FUNC_ENTER;
2925
2926         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2927
2928         err = sync_agent_init_binder_function_set(sizeof(oma_dm_binder_function_info) / sizeof(sync_agent_pb_function_info_s), (sync_agent_pb_function_info_s *) oma_dm_binder_function_info, pBinder_function_set);
2929
2930         _EXTERN_FUNC_EXIT;
2931         return err;
2932 }
2933
2934 void free_syncml_binder_function_set(sync_agent_pb_protocol_binder_function_set_s * pBinder_function_set)
2935 {
2936         _EXTERN_FUNC_ENTER;
2937
2938         retm_if((pBinder_function_set) == NULL, "pBinder_function_set is NULL!!");
2939
2940         sync_agent_free_binder_function_set(pBinder_function_set);
2941
2942         _EXTERN_FUNC_EXIT;
2943 }
2944
2945 sync_agent_pb_protocol_binder_info_s *syncml_binder_init(sync_agent_pb_protocol_binder_info_s * pBinder, sync_agent_pb_encoding_e enc, bool use_strtbl, bool use_flow_mode, sync_agent_pb_protocol_binder_function_set_s * pBinder_function_set)
2946 {
2947         _EXTERN_FUNC_ENTER;
2948
2949         sync_agent_pb_protocol_binder_info_s *pOutBinder = NULL;
2950
2951         pOutBinder = sync_agent_init_protocol_binder(pBinder, SYNC_AGENT_PB_PROTOCOL_SYNCML_SYNCML12, NULL, enc, 1, use_strtbl, false, use_flow_mode, false, NULL, NULL, pBinder_function_set);
2952
2953         if (pOutBinder == NULL) {
2954                 goto return_part;
2955         }
2956         //protocol_binder_set_estimate_doc_size(pOutBinder, SYNC_AGENT_INIT_ESTIMATE_DOC_SIZE);
2957
2958  return_part:
2959         _EXTERN_FUNC_EXIT;
2960         return pOutBinder;
2961 }
2962
2963 sync_agent_pb_error_e syncml_binder_append(sync_agent_pb_protocol_binder_info_s * pBinder, OMA_DM_Protocol_Element protocol_element, Content_Ptr pContent)
2964 {
2965         _EXTERN_FUNC_ENTER;
2966
2967         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR, "pBinder is NULL!!");
2968
2969         _DEBUG_TRACE(" protocol_element = %d, pContent = %p\n", protocol_element, pContent);
2970         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2971
2972         err = sync_agent_append_element(pBinder, protocol_element, pContent);
2973
2974         _EXTERN_FUNC_EXIT;
2975         return err;
2976 }
2977
2978 void syncml_binder_terminate(sync_agent_pb_protocol_binder_info_s * pBinder)
2979 {
2980         _EXTERN_FUNC_ENTER;
2981
2982         retm_if((pBinder) == NULL, "pBinder is NULL!!");
2983
2984         sync_agent_destroy_protocol_binder(pBinder);
2985
2986         _EXTERN_FUNC_EXIT;
2987 }
2988
2989 sync_agent_pb_error_e syncml_binder_get_stream(sync_agent_pb_protocol_binder_info_s * pBinder, char **byte_stream, unsigned int *byte_stream_size)
2990 {
2991         _EXTERN_FUNC_ENTER;
2992
2993         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR, "pBinder is NULL!!");
2994
2995         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
2996
2997         err = sync_agent_get_stream_from_protocol_binder(pBinder, byte_stream, byte_stream_size);
2998         if (err != SYNC_AGENT_PB_RETURN_OK) {
2999                 goto return_part;
3000         }
3001
3002  return_part:
3003         _EXTERN_FUNC_EXIT;
3004         return err;
3005 }
3006
3007 sync_agent_pb_error_e syncml_binder_get_stream_size(sync_agent_pb_protocol_binder_info_s * pBinder, unsigned int *byte_stream_size)
3008 {
3009         _EXTERN_FUNC_ENTER;
3010
3011         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR, "pBinder is NULL!!");
3012
3013         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
3014
3015         err = sync_agent_get_stream_size_from_protocol_binder(pBinder, byte_stream_size);
3016
3017         _EXTERN_FUNC_EXIT;
3018         return err;
3019 }
3020
3021 sync_agent_pb_error_e syncml_binder_get_encoding(sync_agent_pb_protocol_binder_info_s * pBinder, sync_agent_pb_encoding_e * enc)
3022 {
3023         _EXTERN_FUNC_ENTER;
3024
3025         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR, "pBinder is NULL!!");
3026
3027         sync_agent_pb_error_e err = SYNC_AGENT_PB_RETURN_OK;
3028
3029         err = sync_agent_get_encoding_from_protocol_binder(pBinder, enc);
3030
3031         _EXTERN_FUNC_EXIT;
3032         return err;
3033 }
3034
3035 sync_agent_pb_error_e reverse_syncml_binder_init(char *byte_stream,
3036                                                  unsigned int byte_stream_len, sync_agent_pb_decoding_e dec, sync_agent_pb_protocol_binder_function_set_s * pBinder_function_set, void *user_data, sync_agent_pb_protocol_binder_reverse_info_s ** ppBinder)
3037 {
3038         _EXTERN_FUNC_ENTER;
3039
3040         retvm_if((byte_stream) == NULL, SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR, "byte_stream is NULL!!");
3041         retvm_if((pBinder_function_set) == NULL, SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR, "pBinder_function_set is NULL!!");
3042
3043         sync_agent_pb_protocol_e protocol = SYNC_AGENT_PB_PROTOCOL_UNKNOWN;
3044         sync_agent_pb_error_e err = sync_agent_init_reverse_protocol_binder(byte_stream, byte_stream_len, dec,
3045                                                                             &protocol, pBinder_function_set, user_data, ppBinder);
3046
3047         _EXTERN_FUNC_EXIT;
3048         return err;
3049 }
3050
3051 sync_agent_pb_error_e reverse_syncml_binder_next(sync_agent_pb_protocol_binder_reverse_info_s * pBinder, OMA_DM_Protocol_Element * protocol_element, char **protocol_element_name, Content_Ptr * pContent)
3052 {
3053         _EXTERN_FUNC_ENTER;
3054
3055         retvm_if((pBinder) == NULL, SYNC_AGENT_PB_RETURN_UNKNOWN_ERROR, "pBinder is NULL!!");
3056
3057         sync_agent_pb_error_e err = sync_agent_next_element(pBinder, protocol_element, protocol_element_name, pContent);
3058
3059         _EXTERN_FUNC_EXIT;
3060
3061         return err;
3062 }