src/framework/device-manager/mo_parser_properties.c

   1 /*
   2  * sync-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 #include <string.h>
  19
  20 #include "utility/sync_util.h"
  21
  22 #include "device-manager/mo_parser_properties.h"
  23
  24 #ifndef SYNC_AGENT_LOG
  25 #undef LOG_TAG
  26 #define LOG_TAG "AF_MO"
  27 #endif
  28
  29 void dm_parse_property_access_type(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
  30 {
  31         _EXTERN_FUNC_ENTER;
  32
  33         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
  34
  35 //      framework->accessType = 0x00;
  36         framework->accessType = SYNC_AGENT_DM_MO_ACCESSTYPE_NO_SET;
  37
  38         int node_type;
  39         const char *name = NULL;
  40
  41         do {
  42                 xmlTextReaderRead(*reader);
  43
  44                 node_type = xmlTextReaderNodeType(*reader);
  45                 name = (const char *)xmlTextReaderConstName(*reader);
  46
  47                 if (node_type == XML_ELEMENT_NODE) {
  48                         if (!strcmp(name, "Add")) {
  49                                 framework->accessType = framework->accessType | SYNC_AGENT_DM_MO_ACCESSTYPE_ADD;
  50                         } else if (!strcmp(name, "Copy")) {
  51                                 framework->accessType = framework->accessType | SYNC_AGENT_DM_MO_ACCESSTYPE_COPY;
  52                         } else if (!strcmp(name, "Delete")) {
  53                                 framework->accessType = framework->accessType | SYNC_AGENT_DM_MO_ACCESSTYPE_DELETE;
  54                         } else if (!strcmp(name, "Exec")) {
  55                                 framework->accessType = framework->accessType | SYNC_AGENT_DM_MO_ACCESSTYPE_EXEC;
  56                         } else if (!strcmp(name, "Get")) {
  57                                 framework->accessType = framework->accessType | SYNC_AGENT_DM_MO_ACCESSTYPE_GET;
  58                         } else if (!strcmp(name, "Replace")) {
  59                                 framework->accessType = framework->accessType | SYNC_AGENT_DM_MO_ACCESSTYPE_REPLACE;
  60                         }
  61                 }
  62
  63         } while (!(node_type == XML_ELEMENT_DECL && !strcmp(name, "AccessType")));
  64
  65         _EXTERN_FUNC_EXIT;
  66 }
  67
  68 void dm_parse_property_default_value(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
  69 {
  70         _EXTERN_FUNC_ENTER;
  71
  72         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
  73
  74         int node_type;
  75         const char *name = NULL;
  76         const char *value = NULL;
  77
  78         do {
  79                 xmlTextReaderRead(*reader);
  80
  81                 node_type = xmlTextReaderNodeType(*reader);
  82                 name = (const char *)xmlTextReaderConstName(*reader);
  83                 value = (const char *)xmlTextReaderConstValue(*reader);
  84
  85                 if (node_type == XML_TEXT_NODE) {
  86                         if (value == NULL) {
  87                                 value = "";
  88                         }
  89                         framework->defaultValue = strdup(value);
  90                 }
  91         } while (!(node_type == XML_ELEMENT_DECL && !strcmp(name, "DefaultValue")) && (node_type != XML_DTD_NODE));
  92
  93         _EXTERN_FUNC_EXIT;
  94 }
  95
  96 void dm_parse_property_description(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
  97 {
  98         _EXTERN_FUNC_ENTER;
  99
 100         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
 101
 102         int node_type;
 103         const char *name = NULL;
 104         const char *value = NULL;
 105
 106         do {
 107                 xmlTextReaderRead(*reader);
 108
 109                 node_type = xmlTextReaderNodeType(*reader);
 110                 name = (const char *)xmlTextReaderConstName(*reader);
 111                 value = (const char *)xmlTextReaderConstValue(*reader);
 112
 113                 if (node_type == XML_TEXT_NODE) {
 114                         if (value == NULL) {
 115                                 value = "";
 116                         }
 117
 118                         framework->description = strdup(value);
 119
 120                         break;
 121                 }
 122         } while (!(node_type == XML_ELEMENT_DECL && !strcmp(name, "Description")) && (node_type != XML_DTD_NODE));
 123
 124         _EXTERN_FUNC_EXIT;
 125 }
 126
 127 void dm_parse_property_dffFormat(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
 128 {
 129         _EXTERN_FUNC_ENTER;
 130
 131         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
 132
 133         while (1) {
 134                 xmlTextReaderRead(*reader);
 135
 136                 int node_type = xmlTextReaderNodeType(*reader);
 137
 138                 if (node_type == XML_ELEMENT_NODE) {
 139                         const char *name = (const char *)xmlTextReaderConstName(*reader);
 140                         if (!strcmp(name, "b64")) {
 141                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_B64;
 142                         } else if (!strcmp(name, "bin")) {
 143                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_BIN;
 144                         } else if (!strcmp(name, "bool")) {
 145                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_BOOL;
 146                         } else if (!strcmp(name, "chr")) {
 147                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_CHR;
 148                         } else if (!strcmp(name, "int")) {
 149                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_INT;
 150                         } else if (!strcmp(name, "node")) {
 151                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_NODE;
 152                         } else if (!strcmp(name, "null")) {
 153                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_NULL;
 154                         } else if (!strcmp(name, "xml")) {
 155                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_XML;
 156                         } else if (!strcmp(name, "date")) {
 157                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_DATE;
 158                         } else if (!strcmp(name, "time")) {
 159                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_TIME;
 160                         } else if (!strcmp(name, "float")) {
 161                                 framework->dffFormat = SYNC_AGENT_DM_MO_FORMAT_FLOAT;
 162                         }
 163
 164                         break;
 165                 }
 166         }
 167
 168         _EXTERN_FUNC_EXIT;
 169 }
 170
 171 void dm_parse_property_occurrence(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
 172 {
 173         _EXTERN_FUNC_ENTER;
 174
 175         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
 176
 177         int node_type;
 178         const char *name = NULL;
 179         int flag = 0;
 180
 181         do {
 182                 xmlTextReaderRead(*reader);
 183
 184                 node_type = xmlTextReaderNodeType(*reader);
 185                 name = (const char *)xmlTextReaderConstName(*reader);
 186
 187                 if (node_type == XML_ELEMENT_NODE) {
 188                         if (!strcmp(name, "One")) {
 189                                 framework->occurrence = SYNC_AGENT_DM_MO_OCCURRENCE_ONE;
 190                         } else if (!strcmp(name, "ZeroOrOne")) {
 191                                 framework->occurrence = SYNC_AGENT_DM_MO_OCCURRENCE_ZEROORONE;
 192                         } else if (!strcmp(name, "ZeroOrMore")) {
 193                                 framework->occurrence = SYNC_AGENT_DM_MO_OCCURRENCE_ZEROORMORE;
 194                         } else if (!strcmp(name, "OneOrMore")) {
 195                                 framework->occurrence = SYNC_AGENT_DM_MO_OCCURRENCE_ONEORMORE;
 196                         } else if (!strcmp(name, "ZeroOrN")) {
 197                                 framework->occurrence = SYNC_AGENT_DM_MO_OCCURRENCE_ZEROORN;
 198                         } else if (!strcmp(name, "OneOrN")) {
 199                                 framework->occurrence = SYNC_AGENT_DM_MO_OCCURRENCE_ONEORN;
 200                         }
 201
 202                         flag = 1;
 203                 } else if (node_type == XML_TEXT_NODE && flag == 1) {
 204                         const char *occurrence_num = (const char *)xmlTextReaderConstValue(*reader);
 205                         if (occurrence_num != NULL) {
 206                                 framework->occurrence_num = atoi(occurrence_num);
 207                         }
 208                         break;
 209                 }
 210
 211         } while (!(node_type == XML_ELEMENT_DECL && !strcmp(name, "Occurrence")));
 212
 213         _EXTERN_FUNC_EXIT;
 214 }
 215
 216 void dm_parse_property_scope(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
 217 {
 218         _EXTERN_FUNC_ENTER;
 219
 220         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
 221
 222         while (1) {
 223                 xmlTextReaderRead(*reader);
 224
 225                 int node_type = xmlTextReaderNodeType(*reader);
 226
 227                 if (node_type == XML_ELEMENT_NODE) {
 228                         const char *name = (const char *)xmlTextReaderConstName(*reader);
 229                         if (!strcmp(name, "Permanent")) {
 230                                 framework->scope = SYNC_AGENT_DM_MO_SCOPE_PERMANENT;
 231                         } else if (!strcmp(name, "Dynamic")) {
 232                                 framework->scope = SYNC_AGENT_DM_MO_SCOPE_DYNAMIC;
 233                         }
 234
 235                         break;
 236                 }
 237         }
 238
 239         _EXTERN_FUNC_EXIT;
 240 }
 241
 242 void dm_parse_property_df_title(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
 243 {
 244         _EXTERN_FUNC_ENTER;
 245
 246         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
 247
 248         int node_type;
 249         const char *name = NULL;
 250         const char *value = NULL;
 251
 252         do {
 253                 xmlTextReaderRead(*reader);
 254
 255                 node_type = xmlTextReaderNodeType(*reader);
 256                 name = (const char *)xmlTextReaderConstName(*reader);
 257                 value = (const char *)xmlTextReaderConstValue(*reader);
 258                 /*
 259                    const char *baseURL = (const char *)xmlTextReaderConstBaseUri(*reader);
 260                    const char *localName = (const char *)xmlTextReaderConstLocalName(*reader);
 261                    const char *namespace = (const char *)xmlTextReaderConstNamespaceUri(*reader);
 262                    const char *prefix = (const char *)xmlTextReaderConstPrefix(*reader);
 263                    const char *xmlLang = (const char *)xmlTextReaderConstXmlLang(*reader);
 264                  */
 265                 if (node_type == XML_TEXT_NODE) {
 266                         if (value == NULL) {
 267                                 value = "";
 268                         }
 269
 270                         framework->dfTitle = strdup(value);
 271
 272                         break;
 273                 } else {
 274
 275                 }
 276         } while (!(node_type == XML_ELEMENT_DECL && !strcmp(name, "DFTitle")) && (node_type != XML_DTD_NODE));
 277
 278         _EXTERN_FUNC_EXIT;
 279 }
 280
 281 void dm_parse_property_df_type(xmlTextReaderPtr * reader, sync_agent_dm_mo_framework_property_s * framework)
 282 {
 283         _EXTERN_FUNC_ENTER;
 284
 285         retm_if(framework == NULL, "sync_agent_dm_mo_framework_property_s is NULL !!");
 286
 287         int node_type;
 288         const char *name = NULL;
 289         int start_depth = xmlTextReaderDepth(*reader);
 290         int flag = 0;
 291         do {
 292                 xmlTextReaderRead(*reader);
 293                 node_type = xmlTextReaderNodeType(*reader);
 294                 name = (const char *)xmlTextReaderConstName(*reader);
 295                 int current_depth = xmlTextReaderDepth(*reader);
 296                 /* _DEBUG_INFO("node_type : %d, name : %s, isEmpty : %d", node_type, name, isEmpty);        */
 297
 298                 if (node_type == XML_ELEMENT_NODE) {
 299                         if (!strcmp(name, "MIME")) {
 300                                 framework->dfType = SYNC_AGENT_DM_MO_DF_TYPE_MIME;
 301                         } else if (!strcmp(name, "DDFName")) {
 302                                 framework->dfType = SYNC_AGENT_DM_MO_DF_TYPE_DDFNAME;
 303                         }
 304                         flag = 1;
 305                 } else if (node_type == XML_TEXT_NODE && flag == 1) {
 306                         const char *dfType_Value = (const char *)xmlTextReaderConstValue(*reader);
 307                         if (dfType_Value == NULL) {
 308                                 dfType_Value = "";
 309                         }
 310                         framework->dfType_Value = strdup(dfType_Value);
 311                         break;
 312                 } else if (node_type == XML_DTD_NODE) {
 313                         if (start_depth == current_depth) {
 314                                 break;
 315                         }
 316                 }
 317         } while (!(node_type == XML_ELEMENT_DECL && !strcmp(name, "DFType")));
 318
 319         _EXTERN_FUNC_EXIT;
 320 }