backend/src/rpm/rpm-installer-signature.c

   1 /*
   2  * rpm-installer
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22 #include <pkgmgr_parser.h>
  23 #include "rpm-installer-util.h"
  24 #include "rpm-installer-signature.h"
  25
  26
  27 static int _ri_next_child_element(xmlTextReaderPtr reader, int depth)
  28 {
  29         int ret = xmlTextReaderRead(reader);
  30         int cur = xmlTextReaderDepth(reader);
  31         while (ret == 1) {
  32
  33                 switch (xmlTextReaderNodeType(reader)) {
  34                 case XML_READER_TYPE_ELEMENT:
  35                         if (cur == depth + 1)
  36                                 return 1;
  37                         break;
  38                 case XML_READER_TYPE_TEXT:
  39                         if (cur == depth + 1)
  40                                 return 0;
  41                         break;
  42                 case XML_READER_TYPE_END_ELEMENT:
  43                         if (cur == depth)
  44                                 return 0;
  45                         break;
  46                 default:
  47                         if (cur <= depth)
  48                                 return 0;
  49                         break;
  50                 }
  51                 ret = xmlTextReaderRead(reader);
  52                 cur = xmlTextReaderDepth(reader);
  53         }
  54         return ret;
  55 }
  56
  57 static void _ri_free_transform(transform_x *transform)
  58 {
  59         if (transform == NULL)
  60                 return;
  61         if (transform->algorithm) {
  62                 free((void *)transform->algorithm);
  63                 transform->algorithm = NULL;
  64         }
  65         free((void*)transform);
  66         transform = NULL;
  67 }
  68
  69 static void _ri_free_cannonicalizationmethod(cannonicalizationmethod_x *cannonicalizationmethod)
  70 {
  71         if (cannonicalizationmethod == NULL)
  72                 return;
  73         if (cannonicalizationmethod->algorithm) {
  74                 free((void *)cannonicalizationmethod->algorithm);
  75                 cannonicalizationmethod->algorithm = NULL;
  76         }
  77         free((void*)cannonicalizationmethod);
  78         cannonicalizationmethod = NULL;
  79 }
  80
  81 static void _ri_free_signaturemethod(signaturemethod_x *signaturemethod)
  82 {
  83         if (signaturemethod == NULL)
  84                 return;
  85         if (signaturemethod->algorithm) {
  86                 free((void *)signaturemethod->algorithm);
  87                 signaturemethod->algorithm = NULL;
  88         }
  89         free((void*)signaturemethod);
  90         signaturemethod = NULL;
  91 }
  92
  93 static void _ri_free_digestmethod(digestmethod_x *digestmethod)
  94 {
  95         if (digestmethod == NULL)
  96                 return;
  97         if (digestmethod->algorithm) {
  98                 free((void *)digestmethod->algorithm);
  99                 digestmethod->algorithm = NULL;
 100         }
 101         free((void*)digestmethod);
 102         digestmethod = NULL;
 103 }
 104
 105 static void _ri_free_digestvalue(digestvalue_x *digestvalue)
 106 {
 107         if (digestvalue == NULL)
 108                 return;
 109         if (digestvalue->text) {
 110                 free((void *)digestvalue->text);
 111                 digestvalue->text = NULL;
 112         }
 113         free((void*)digestvalue);
 114         digestvalue = NULL;
 115 }
 116
 117 static void _ri_free_signaturevalue(signaturevalue_x *signaturevalue)
 118 {
 119         if (signaturevalue == NULL)
 120                 return;
 121         if (signaturevalue->text) {
 122                 free((void *)signaturevalue->text);
 123                 signaturevalue->text = NULL;
 124         }
 125         free((void*)signaturevalue);
 126         signaturevalue = NULL;
 127 }
 128
 129 static void _ri_free_x509certificate(x509certificate_x *x509certificate)
 130 {
 131         if (x509certificate == NULL)
 132                 return;
 133         if (x509certificate->text) {
 134                 free((void *)x509certificate->text);
 135                 x509certificate->text = NULL;
 136         }
 137         free((void*)x509certificate);
 138         x509certificate = NULL;
 139 }
 140
 141 static void _ri_free_x509data(x509data_x *x509data)
 142 {
 143         if (x509data == NULL)
 144                 return;
 145         if (x509data->x509certificate) {
 146                 x509certificate_x *x509certificate = x509data->x509certificate;
 147                 x509certificate_x *tmp = NULL;
 148                 while(x509certificate != NULL) {
 149                         tmp = x509certificate->next;
 150                         _ri_free_x509certificate(x509certificate);
 151                         x509certificate = tmp;
 152                 }
 153         }
 154         free((void*)x509data);
 155         x509data = NULL;
 156 }
 157
 158 static void _ri_free_keyinfo(keyinfo_x *keyinfo)
 159 {
 160         if (keyinfo == NULL)
 161                 return;
 162         if (keyinfo->x509data) {
 163                 x509data_x *x509data = keyinfo->x509data;
 164                 x509data_x *tmp = NULL;
 165                 while(x509data != NULL) {
 166                         tmp = x509data->next;
 167                         _ri_free_x509data(x509data);
 168                         x509data = tmp;
 169                 }
 170         }
 171         free((void*)keyinfo);
 172         keyinfo = NULL;
 173 }
 174
 175 static void _ri_free_transforms(transforms_x *transforms)
 176 {
 177         if (transforms == NULL)
 178                 return;
 179         if (transforms->transform) {
 180                 transform_x *transform = transforms->transform;
 181                 transform_x *tmp = NULL;
 182                 while(transform != NULL) {
 183                         tmp = transform->next;
 184                         _ri_free_transform(transform);
 185                         transform = tmp;
 186                 }
 187         }
 188         free((void*)transforms);
 189         transforms = NULL;
 190 }
 191
 192 static void _ri_free_reference(reference_x *reference)
 193 {
 194         if (reference == NULL)
 195                 return;
 196         if (reference->digestmethod) {
 197                 digestmethod_x *digestmethod = reference->digestmethod;
 198                 digestmethod_x *tmp = NULL;
 199                 while(digestmethod != NULL) {
 200                         tmp = digestmethod->next;
 201                         _ri_free_digestmethod(digestmethod);
 202                         digestmethod = tmp;
 203                 }
 204         }
 205         if (reference->digestvalue) {
 206                 digestvalue_x *digestvalue = reference->digestvalue;
 207                 digestvalue_x *tmp = NULL;
 208                 while(digestvalue != NULL) {
 209                         tmp = digestvalue->next;
 210                         _ri_free_digestvalue(digestvalue);
 211                         digestvalue = tmp;
 212                 }
 213         }
 214         if (reference->transforms) {
 215                 transforms_x *transforms = reference->transforms;
 216                 transforms_x *tmp = NULL;
 217                 while(transforms != NULL) {
 218                         tmp = transforms->next;
 219                         _ri_free_transforms(transforms);
 220                         transforms = tmp;
 221                 }
 222         }
 223         if(reference->uri)
 224                 free((void*)reference->uri);
 225
 226         free((void*)reference);
 227         reference = NULL;
 228 }
 229
 230 static void _ri_free_signedinfo(signedinfo_x *signedinfo)
 231 {
 232         if (signedinfo == NULL)
 233                 return;
 234         if (signedinfo->cannonicalizationmethod) {
 235                 cannonicalizationmethod_x *cannonicalizationmethod = signedinfo->cannonicalizationmethod;
 236                 cannonicalizationmethod_x *tmp = NULL;
 237                 while(cannonicalizationmethod != NULL) {
 238                         tmp = cannonicalizationmethod->next;
 239                         _ri_free_cannonicalizationmethod(cannonicalizationmethod);
 240                         cannonicalizationmethod = tmp;
 241                 }
 242         }
 243         if (signedinfo->signaturemethod) {
 244                 signaturemethod_x *signaturemethod = signedinfo->signaturemethod;
 245                 signaturemethod_x *tmp = NULL;
 246                 while(signaturemethod != NULL) {
 247                         tmp = signaturemethod->next;
 248                         _ri_free_signaturemethod(signaturemethod);
 249                         signaturemethod = tmp;
 250                 }
 251         }
 252         if (signedinfo->reference) {
 253                 reference_x *reference = signedinfo->reference;
 254                 reference_x *tmp = NULL;
 255                 while(reference != NULL) {
 256                         tmp = reference->next;
 257                         _ri_free_reference(reference);
 258                         reference = tmp;
 259                 }
 260         }
 261         free((void*)signedinfo);
 262         signedinfo = NULL;
 263 }
 264
 265 void _ri_free_signature_xml(signature_x *sigx)
 266 {
 267         if (sigx == NULL)
 268                 return;
 269         if (sigx->id) {
 270                 free((void *)sigx->id);
 271                 sigx->id = NULL;
 272         }
 273         if (sigx->xmlns) {
 274                 free((void *)sigx->xmlns);
 275                 sigx->xmlns = NULL;
 276         }
 277         if (sigx->signedinfo) {
 278                 signedinfo_x *signedinfo = sigx->signedinfo;
 279                 signedinfo_x *tmp = NULL;
 280                 while(signedinfo != NULL) {
 281                         tmp = signedinfo->next;
 282                         _ri_free_signedinfo(signedinfo);
 283                         signedinfo = tmp;
 284                 }
 285         }
 286         if (sigx->signaturevalue) {
 287                 signaturevalue_x *signaturevalue = sigx->signaturevalue;
 288                 signaturevalue_x *tmp = NULL;
 289                 while(signaturevalue != NULL) {
 290                         tmp = signaturevalue->next;
 291                         _ri_free_signaturevalue(signaturevalue);
 292                         signaturevalue = tmp;
 293                 }
 294         }
 295         if (sigx->keyinfo) {
 296                 keyinfo_x *keyinfo = sigx->keyinfo;
 297                 keyinfo_x *tmp = NULL;
 298                 while(keyinfo != NULL) {
 299                         tmp = keyinfo->next;
 300                         _ri_free_keyinfo(keyinfo);
 301                         keyinfo = tmp;
 302                 }
 303         }
 304         /*Object will be freed when it will be parsed in future*/
 305         free((void*)sigx);
 306         sigx = NULL;
 307 }
 308
 309 static int _ri_process_digestmethod(xmlTextReaderPtr reader, digestmethod_x *digestmethod)
 310 {
 311         int ret = -1;
 312         ret = _ri_get_attribute(reader,"Algorithm",&digestmethod->algorithm);
 313         if(ret != 0){
 314                 _LOGE("@Error in getting the attribute value");
 315         }
 316         return ret;
 317 }
 318
 319 static int _ri_process_digestvalue(xmlTextReaderPtr reader, digestvalue_x *digestvalue)
 320 {
 321         xmlTextReaderRead(reader);
 322         xmlChar *tmp = NULL;
 323         tmp = xmlTextReaderValue(reader);
 324         if (tmp)
 325                 digestvalue->text = ASCII(tmp);
 326         return 0;
 327 }
 328
 329 static int _ri_process_transform(xmlTextReaderPtr reader, transform_x *transform)
 330 {
 331         int ret = -1;
 332         ret = _ri_get_attribute(reader,"Algorithm",&transform->algorithm);
 333         if(ret != 0){
 334                 _LOGE("@Error in getting the attribute value");
 335         }
 336         return ret;
 337 }
 338
 339 static int _ri_process_transforms(xmlTextReaderPtr reader, transforms_x *transforms)
 340 {
 341         const xmlChar *node = NULL;
 342         int ret = 0;
 343         int depth = 0;
 344         transform_x *tmp1 = NULL;
 345
 346         depth = xmlTextReaderDepth(reader);
 347         while ((ret = _ri_next_child_element(reader, depth))) {
 348                 node = xmlTextReaderConstName(reader);
 349                 if (!node) {
 350                         _LOGE("node is NULL\n");
 351                         return -1;
 352                 }
 353                 if (strcmp(ASCII(node), "Transform") == 0) {
 354                         transform_x *transform = calloc(1, sizeof(transform_x));
 355                         if (transform == NULL) {
 356                                 _LOGE("Calloc Failed\n");
 357                                 return -1;
 358                         }
 359                         LISTADD(transforms->transform, transform);
 360                         ret = _ri_process_transform(reader, transform);
 361                 } else {
 362                         _LOGD("Invalid tag %s", ASCII(node));
 363                         return -1;
 364                 }
 365                 if (ret < 0)
 366                         return ret;
 367         }
 368         if (transforms->transform) {
 369                 LISTHEAD(transforms->transform, tmp1);
 370                 transforms->transform = tmp1;
 371         }
 372         return ret;
 373 }
 374
 375 static int _ri_process_cannonicalizationmethod(xmlTextReaderPtr reader, cannonicalizationmethod_x *cannonicalizationmethod)
 376 {
 377         int ret = -1;
 378         ret = _ri_get_attribute(reader,"Algorithm",&cannonicalizationmethod->algorithm);
 379         if(ret != 0){
 380                 _LOGE("@Error in getting the attribute value");
 381         }
 382         return ret;
 383 }
 384
 385 static int _ri_process_signaturemethod(xmlTextReaderPtr reader, signaturemethod_x *signaturemethod)
 386 {
 387         int ret = -1;
 388         ret = _ri_get_attribute(reader,"Algorithm",&signaturemethod->algorithm);
 389         if(ret != 0){
 390                 _LOGE("@Error in getting the attribute value");
 391         }
 392         return ret;
 393 }
 394
 395 static int _ri_process_reference(xmlTextReaderPtr reader, reference_x *reference)
 396 {
 397         const xmlChar *node = NULL;
 398         int ret = 0;
 399         int depth = 0;
 400         digestmethod_x *tmp1 = NULL;
 401         digestvalue_x *tmp2 = NULL;
 402         transforms_x *tmp3 = NULL;
 403
 404         ret = _ri_get_attribute(reader,"URI",&reference->uri);
 405         if(ret != 0){
 406                 _LOGE("@Error in getting the attribute value");
 407                 return -1;
 408         }
 409
 410         depth = xmlTextReaderDepth(reader);
 411         while ((ret = _ri_next_child_element(reader, depth))) {
 412                 node = xmlTextReaderConstName(reader);
 413                 if (!node) {
 414                         _LOGE("node is NULL\n");
 415                         return -1;
 416                 }
 417                 if (strcmp(ASCII(node), "DigestMethod") == 0) {
 418                         digestmethod_x *digestmethod = calloc(1, sizeof(digestmethod_x));
 419                         if (digestmethod == NULL) {
 420                                 _LOGE("Calloc Failed\n");
 421                                 return -1;
 422                         }
 423                         LISTADD(reference->digestmethod, digestmethod);
 424                         ret = _ri_process_digestmethod(reader, digestmethod);
 425                 } else if (strcmp(ASCII(node), "DigestValue") == 0) {
 426                         digestvalue_x *digestvalue = calloc(1, sizeof(digestvalue_x));
 427                         if (digestvalue == NULL) {
 428                                 _LOGE("Calloc Failed\n");
 429                                 return -1;
 430                         }
 431                         LISTADD(reference->digestvalue, digestvalue);
 432                         ret = _ri_process_digestvalue(reader, digestvalue);
 433                 } else if (strcmp(ASCII(node), "Transforms") == 0) {
 434                         transforms_x *transforms = calloc(1, sizeof(transforms_x));
 435                         if (transforms == NULL) {
 436                                 _LOGE("Calloc Failed\n");
 437                                 return -1;
 438                         }
 439                         LISTADD(reference->transforms, transforms);
 440                         ret = _ri_process_transforms(reader, transforms);
 441                 } else {
 442                         _LOGD("Invalid tag %s", ASCII(node));
 443                         return -1;
 444                 }
 445                 if (ret < 0)
 446                         return ret;
 447         }
 448         if (reference->digestmethod) {
 449                 LISTHEAD(reference->digestmethod, tmp1);
 450                 reference->digestmethod = tmp1;
 451         }
 452         if (reference->digestvalue) {
 453                 LISTHEAD(reference->digestvalue, tmp2);
 454                 reference->digestvalue = tmp2;
 455         }
 456         if (reference->transforms) {
 457                 LISTHEAD(reference->transforms, tmp3);
 458                 reference->transforms = tmp3;
 459         }
 460         return ret;
 461 }
 462
 463 static int _ri_process_x509certificate(xmlTextReaderPtr reader, x509certificate_x *x509certificate)
 464 {
 465         xmlTextReaderRead(reader);
 466         xmlChar *tmp = NULL;
 467         tmp = xmlTextReaderValue(reader);
 468         if (tmp) {
 469                 x509certificate->text = ASCII(tmp);
 470                 _LOGD("x509certificate, len=[%d]\n%s", strlen(x509certificate->text), x509certificate->text);
 471         }
 472         return 0;
 473 }
 474
 475 static int _ri_process_x509data(xmlTextReaderPtr reader, x509data_x *x509data)
 476 {
 477         const xmlChar *node = NULL;
 478         int ret = 0;
 479         int depth = 0;
 480         x509certificate_x *tmp1 = NULL;
 481
 482         depth = xmlTextReaderDepth(reader);
 483         while ((ret = _ri_next_child_element(reader, depth))) {
 484                 node = xmlTextReaderConstName(reader);
 485                 if (!node) {
 486                         _LOGE("node is NULL\n");
 487                         return -1;
 488                 }
 489                 if (strcmp(ASCII(node), "X509Certificate") == 0) {
 490                         x509certificate_x *x509certificate = calloc(1, sizeof(x509certificate_x));
 491                         if (x509certificate == NULL) {
 492                                 _LOGE("Calloc Failed\n");
 493                                 return -1;
 494                         }
 495                         LISTADD(x509data->x509certificate, x509certificate);
 496                         ret = _ri_process_x509certificate(reader, x509certificate);
 497                 } else {
 498                         _LOGD("Invalid tag %s", ASCII(node));
 499                         return -1;
 500                 }
 501                 if (ret < 0)
 502                         return ret;
 503         }
 504         if (x509data->x509certificate) {
 505                 LISTHEAD(x509data->x509certificate, tmp1);
 506                 x509data->x509certificate = tmp1;
 507         }
 508         return ret;
 509 }
 510
 511 #if 0
 512 static int _ri_process_object(xmlTextReaderPtr reader, object_x *object)
 513 {
 514         /*To be parsed later*/
 515         return 0;
 516 }
 517 #endif
 518
 519 static int _ri_process_keyinfo(xmlTextReaderPtr reader, keyinfo_x *keyinfo)
 520 {
 521         const xmlChar *node = NULL;
 522         int ret = 0;
 523         int depth = 0;
 524         x509data_x *tmp1 = NULL;
 525
 526         depth = xmlTextReaderDepth(reader);
 527         while ((ret = _ri_next_child_element(reader, depth))) {
 528                 node = xmlTextReaderConstName(reader);
 529                 if (!node) {
 530                         _LOGE("node is NULL\n");
 531                         return -1;
 532                 }
 533                 if (strcmp(ASCII(node), "X509Data") == 0) {
 534                         x509data_x *x509data = calloc(1, sizeof(x509data_x));
 535                         if (x509data == NULL) {
 536                                 _LOGE("Calloc Failed\n");
 537                                 return -1;
 538                         }
 539                         LISTADD(keyinfo->x509data, x509data);
 540                         ret = _ri_process_x509data(reader, x509data);
 541                 } else {
 542                         _LOGD("Invalid tag %s", ASCII(node));
 543                         return -1;
 544                 }
 545                 if (ret < 0)
 546                         return ret;
 547         }
 548         if (keyinfo->x509data) {
 549                 LISTHEAD(keyinfo->x509data, tmp1);
 550                 keyinfo->x509data = tmp1;
 551         }
 552         return ret;
 553 }
 554
 555 static int _ri_process_signaturevalue(xmlTextReaderPtr reader, signaturevalue_x *signaturevalue)
 556 {
 557         xmlTextReaderRead(reader);
 558         xmlChar *tmp = NULL;
 559         tmp = xmlTextReaderValue(reader);
 560         if (tmp) {
 561                 signaturevalue->text = ASCII(tmp);
 562                 _LOGD("SignatureValue, len=[%d]\n%s", strlen(signaturevalue->text), signaturevalue->text);
 563         }
 564         return 0;
 565 }
 566
 567 static int _ri_process_signedinfo(xmlTextReaderPtr reader, signedinfo_x *signedinfo)
 568 {
 569         const xmlChar *node = NULL;
 570         int ret = 0;
 571         int depth = 0;
 572         cannonicalizationmethod_x *tmp1 = NULL;
 573         signaturemethod_x *tmp2 = NULL;
 574         reference_x *tmp3 = NULL;
 575
 576         depth = xmlTextReaderDepth(reader);
 577         while ((ret = _ri_next_child_element(reader, depth))) {
 578                 node = xmlTextReaderConstName(reader);
 579                 if (!node) {
 580                         _LOGE("node is NULL\n");
 581                         return -1;
 582                 }
 583                 if (strcmp(ASCII(node), "CanonicalizationMethod") == 0) {
 584                         cannonicalizationmethod_x *cannonicalizationmethod = calloc(1, sizeof(cannonicalizationmethod_x));
 585                         if (cannonicalizationmethod == NULL) {
 586                                 _LOGE("Calloc Failed\n");
 587                                 return -1;
 588                         }
 589                         LISTADD(signedinfo->cannonicalizationmethod, cannonicalizationmethod);
 590                         ret = _ri_process_cannonicalizationmethod(reader, cannonicalizationmethod);
 591                 } else if (strcmp(ASCII(node), "SignatureMethod") == 0) {
 592                         signaturemethod_x *signaturemethod = calloc(1, sizeof(signaturemethod_x));
 593                         if (signaturemethod == NULL) {
 594                                 _LOGE("Calloc Failed\n");
 595                                 return -1;
 596                         }
 597                         LISTADD(signedinfo->signaturemethod, signaturemethod);
 598                         ret = _ri_process_signaturemethod(reader, signaturemethod);
 599                 } else if (strcmp(ASCII(node), "Reference") == 0) {
 600                         reference_x *reference = calloc(1, sizeof(reference_x));
 601                         if (reference == NULL) {
 602                                 _LOGE("Calloc Failed\n");
 603                                 return -1;
 604                         }
 605                         LISTADD(signedinfo->reference, reference);
 606                         ret = _ri_process_reference(reader, reference);
 607                 } else {
 608                         _LOGD("Invalid tag %s", ASCII(node));
 609                         return -1;
 610                 }
 611                 if (ret < 0)
 612                         return ret;
 613         }
 614         if (signedinfo->cannonicalizationmethod) {
 615                 LISTHEAD(signedinfo->cannonicalizationmethod, tmp1);
 616                 signedinfo->cannonicalizationmethod = tmp1;
 617         }
 618         if (signedinfo->signaturemethod) {
 619                 LISTHEAD(signedinfo->signaturemethod, tmp2);
 620                 signedinfo->signaturemethod = tmp2;
 621         }
 622         if (signedinfo->reference) {
 623                 LISTHEAD(signedinfo->reference, tmp3);
 624                 signedinfo->reference = tmp3;
 625         }
 626         return ret;
 627 }
 628
 629 static int _ri_process_sign(xmlTextReaderPtr reader, signature_x *sigx)
 630 {
 631         const xmlChar *node = NULL;
 632         int ret = 0;
 633         int depth = 0;
 634         signedinfo_x *tmp1 = NULL;
 635         signaturevalue_x *tmp2 = NULL;
 636         keyinfo_x *tmp3 = NULL;
 637         object_x *tmp4 = NULL;
 638
 639         depth = xmlTextReaderDepth(reader);
 640         while ((ret = _ri_next_child_element(reader, depth))) {
 641                 node = xmlTextReaderConstName(reader);
 642                 if (!node) {
 643                         _LOGE("node is NULL\n");
 644                         return -1;
 645                 }
 646                 if (strcmp(ASCII(node), "SignedInfo") == 0) {
 647                         signedinfo_x *signedinfo = calloc(1, sizeof(signedinfo_x));
 648                         if (signedinfo == NULL) {
 649                                 _LOGE("Calloc Failed\n");
 650                                 return -1;
 651                         }
 652                         LISTADD(sigx->signedinfo, signedinfo);
 653                         ret = _ri_process_signedinfo(reader, signedinfo);
 654                 } else if (strcmp(ASCII(node), "SignatureValue") == 0) {
 655                         signaturevalue_x *signaturevalue = calloc(1, sizeof(signaturevalue_x));
 656                         if (signaturevalue == NULL) {
 657                                 _LOGE("Calloc Failed\n");
 658                                 return -1;
 659                         }
 660                         LISTADD(sigx->signaturevalue, signaturevalue);
 661                         ret = _ri_process_signaturevalue(reader, signaturevalue);
 662                 } else if (strcmp(ASCII(node), "KeyInfo") == 0) {
 663                         keyinfo_x *keyinfo = calloc(1, sizeof(keyinfo_x));
 664                         if (keyinfo == NULL) {
 665                                 _LOGE("Calloc Failed\n");
 666                                 return -1;
 667                         }
 668                         LISTADD(sigx->keyinfo, keyinfo);
 669                         ret = _ri_process_keyinfo(reader, keyinfo);
 670                 } else if (strcmp(ASCII(node), "Object") == 0) {
 671                         /*
 672                         object_x *object = calloc(1, sizeof(object_x));
 673                         if (object == NULL) {
 674                                 _LOGE("Calloc Failed\n");
 675                                 return -1;
 676                         }
 677                         LISTADD(sigx->object, object);
 678                         ret = _ri_process_object(reader, object);
 679                         */
 680                         continue;
 681                 } else {
 682                         _LOGD("Invalid tag %s", ASCII(node));
 683                         return -1;
 684                 }
 685                 if (ret < 0)
 686                         return ret;
 687         }
 688         if (sigx->signedinfo) {
 689                 LISTHEAD(sigx->signedinfo, tmp1);
 690                 sigx->signedinfo = tmp1;
 691         }
 692         if (sigx->signaturevalue) {
 693                 LISTHEAD(sigx->signaturevalue, tmp2);
 694                 sigx->signaturevalue = tmp2;
 695         }
 696         if (sigx->keyinfo) {
 697                 LISTHEAD(sigx->keyinfo, tmp3);
 698                 sigx->keyinfo = tmp3;
 699         }
 700         if (sigx->object) {
 701                 LISTHEAD(sigx->object, tmp4);
 702                 sigx->object = tmp4;
 703         }
 704         return ret;
 705 }
 706
 707 static int _ri_process_signature(xmlTextReaderPtr reader, signature_x *sigx)
 708 {
 709         const xmlChar *node = NULL;
 710         int ret = -1;
 711
 712         if ((ret = _ri_next_child_element(reader, -1))) {
 713                 node = xmlTextReaderConstName(reader);
 714                 if (!node) {
 715                         _LOGE("Node is null");
 716                         return -1;
 717                 }
 718                 if (!strcmp(ASCII(node), "Signature")) {
 719                         ret = _ri_get_attribute(reader,"Id",&sigx->id);
 720                         if(ret != 0){
 721                                 _LOGE("@Error in getting the attribute value");
 722                                 return -1;
 723                         }
 724
 725                         ret = _ri_get_attribute(reader,"xmlns",&sigx->xmlns);
 726                         if(ret != 0){
 727                                 _LOGE("@Error in getting the attribute value");
 728                                 return -1;
 729                         }
 730
 731                         ret = _ri_process_sign(reader, sigx);
 732                 } else {
 733                         _LOGE("No Signature element found\n");
 734                         return -1;
 735                 }
 736         }
 737         return ret;
 738 }
 739
 740 signature_x *_ri_process_signature_xml(const char *signature_file)
 741 {
 742         xmlTextReaderPtr reader;
 743         signature_x *sigx = NULL;
 744
 745         reader = xmlReaderForFile(signature_file, NULL, 0);
 746
 747         if (reader) {
 748                 sigx = calloc(1, sizeof(signature_x));
 749                 if (sigx) {
 750                         if (_ri_process_signature(reader, sigx) < 0) {
 751                                 /* error in parsing. Let's display some hint where we failed */
 752                                 _LOGE("Syntax error in processing signature in the above line\n");
 753                                 _ri_free_signature_xml(sigx);
 754                                 xmlFreeTextReader(reader);
 755                                 return NULL;
 756                         }
 757                 } else {
 758                         _LOGE("Calloc failed\n");
 759                 }
 760                 xmlFreeTextReader(reader);
 761         } else {
 762                 _LOGE("Unable to create xml reader\n");
 763         }
 764         return sigx;
 765 }