backend/src/coretpk/xml-parser/coretpk-parser-hybrid.c

   1 /*
   2  * coretpk-installer
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, junsuk.oh <junsuk77.oh@samsung.com>,
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #define _GNU_SOURCE
  23
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27 #include <pkgmgr-info.h>
  28 #include <pkgmgr_parser.h>
  29 #include <privilege-control.h>
  30
  31 #include "coretpk-installer-internal.h"
  32 #include "rpm-installer-util.h"
  33 #include "rpm-installer.h"
  34
  35 #define LOG_PRINT_LINE_MAX 20
  36 #define LOG_BUFFER_COUNT_MAX 4096
  37
  38 static int __coretpk_parser_hybrid_to_file(const char *web_xml, const char *core_xml);
  39 static int __coretpk_parser_hybrid_merge_privilege(char* merged_buf, char* core_buf, int* filesize);
  40 static int __coretpk_parser_hybrid_merge_ui_application(char* merged_buf, char* core_buf, int* filesize);
  41 static int __coretpk_parser_hybrid_merge_service_application(char* merged_buf, char* core_buf, int* filesize);
  42 static int __coretpk_parser_hybrid_merge_widget_tag(char* merged_buf, char* core_buf, int* filesize);
  43 static int __coretpk_parser_hybrid_merge_tag(char* merged_buf, char* core_buf, int* filesize, const char* start_tag, const char* end_tag);
  44
  45 static int __coretpk_parser_hybrid_get_part(const char* start_point, const char* start_tag, const char* end_tag, char** buf, int* length, char** next);
  46 static int __coretpk_parser_hybrid_merge_to(const char* merged_buf, int* filesize, const char* tag, const char* buf, int length);
  47 static int __coretpk_parser_hybrid_dump_log_data(char *data, int length);
  48
  49 static int _coretpk_installer_hybrid_convert_manifest(char *manifest, const char* pkgid, int apiVisibility);
  50
  51 int __coretpk_parser_hybrid_to_file(const char *web_xml, const char *core_xml)
  52 {
  53         int ret = RPM_INSTALLER_ERR_WRONG_PARAM;
  54         int res = 0;
  55         FILE* web_xml_file = NULL;
  56         FILE* core_xml_file = NULL;
  57         struct stat web_fileinfo;
  58         struct stat core_fileinfo;
  59         int web_xml_filesize = 0;
  60         int core_xml_filesize = 0;
  61         int merged_size = 0;
  62         char* merged_buf = NULL;
  63         char* core_buf = NULL;
  64         int read_bytes = 0;
  65         char* manifest_tag = NULL;
  66         int filesize = 0;
  67         FILE* result_xml_file = NULL;
  68         int result_write_bytes = 0;
  69
  70         res = stat(web_xml, &web_fileinfo);
  71         tryvm_if(res < 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fstat() failed, web_xml=[%s]\n", web_xml);
  72
  73         res = stat(core_xml, &core_fileinfo);
  74         tryvm_if(res < 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fstat() failed, core_xml=[%s]\n", core_xml);
  75
  76         web_xml_filesize = web_fileinfo.st_size;
  77         core_xml_filesize = core_fileinfo.st_size;
  78         merged_size = web_xml_filesize + core_xml_filesize;
  79
  80         web_xml_file = fopen(web_xml, "r");
  81         tryvm_if(web_xml_file == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fopen() failed, web_xml=[%s]\n", web_xml);
  82
  83         merged_buf = (char*)calloc(1, merged_size + 1);
  84         tryvm_if(merged_buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "merged_buf is NULL");
  85
  86         read_bytes = fread(merged_buf, 1, web_xml_filesize, web_xml_file);
  87         tryvm_if(read_bytes <= 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fread() failed, web_xml=[%s]", web_xml);
  88
  89         core_xml_file = fopen(core_xml, "r");
  90         tryvm_if(core_xml_file == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fopen() failed, core_xml=[%s]\n", core_xml);
  91
  92         core_buf = (char*)calloc(1, core_xml_filesize + 1);
  93         tryvm_if(core_buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "core_buf is NULL");
  94
  95         read_bytes = fread(core_buf, 1, core_xml_filesize, core_xml_file);
  96         tryvm_if(read_bytes <= 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fread() failed, core_xml=[%s]", core_xml);
  97         core_buf[read_bytes] = '\0';
  98
  99         manifest_tag = strcasestr(merged_buf, "</manifest>");
 100         tryvm_if(manifest_tag == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "manifest_tag is NULL");
 101
 102         filesize = web_xml_filesize;
 103
 104         __coretpk_parser_hybrid_merge_privilege(merged_buf, core_buf, &filesize);
 105         __coretpk_parser_hybrid_merge_ui_application(merged_buf, core_buf, &filesize);
 106         __coretpk_parser_hybrid_merge_service_application(merged_buf, core_buf, &filesize);
 107         __coretpk_parser_hybrid_merge_widget_tag(merged_buf, core_buf, &filesize);
 108
 109         result_xml_file = fopen(web_xml, "w");
 110         tryvm_if(result_xml_file == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fopen() failed, result_xml=[%s]", web_xml);
 111
 112         result_write_bytes = fwrite(merged_buf, 1, filesize, result_xml_file);
 113         tryvm_if(result_write_bytes != filesize, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "fwrite() failed, result_write_bytes=[%d]", result_write_bytes);
 114
 115
 116     ret = RPM_INSTALLER_SUCCESS;
 117
 118 catch:
 119
 120         if(result_xml_file != NULL){
 121                 fclose(result_xml_file);
 122                 result_xml_file = NULL;
 123         }
 124         if(core_xml_file != NULL){
 125                 fclose(core_xml_file);
 126                 core_xml_file = NULL;
 127         }
 128         if(web_xml_file != NULL){
 129                 fclose(web_xml_file);
 130                 web_xml_file = NULL;
 131         }
 132         FREE_AND_NULL(merged_buf);
 133         FREE_AND_NULL(core_buf);
 134         return ret;
 135 }
 136
 137 int __coretpk_parser_hybrid_merge_privilege(char* merged_buf, char* core_buf, int* filesize)
 138 {
 139         int ret = RPM_INSTALLER_ERR_WRONG_PARAM;
 140         char* merged_privilege_detected = NULL;
 141         char* merged_point = NULL;
 142         char* core_privilege_start = NULL;
 143         char* core_privilege_end = NULL;
 144         int privilege_len = 0;
 145         int core_buf_len = 0;
 146         char* selected_privilege_buf = NULL;
 147
 148         retvm_if(merged_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "merged_buf is NULL");
 149         retvm_if(core_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "core_buf is NULL");
 150         retvm_if(filesize <= 0, RPM_INSTALLER_ERR_WRONG_PARAM, "filesize is NULL");
 151
 152         if (strcasestr(core_buf, "</privileges>") == NULL) {
 153                 return RPM_INSTALLER_SUCCESS;
 154     }
 155
 156         merged_privilege_detected = strcasestr(merged_buf, "</privileges>");
 157         core_buf_len = strlen(core_buf);
 158
 159         selected_privilege_buf = (char*)calloc(1, core_buf_len + 1);
 160         tryvm_if(selected_privilege_buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "selected_privilege_buf is NULL");
 161
 162         if (merged_privilege_detected == NULL) {
 163                 _LOGD("no privileges are detected in web xml");
 164
 165                 core_privilege_start = strcasestr(core_buf, "<privileges>");
 166                 core_privilege_end = strcasestr(core_buf, "</privileges>");
 167
 168                 privilege_len = core_privilege_end - core_privilege_start + strlen("</privileges>");
 169                 merged_point = strcasestr(merged_buf, "<ui-application");
 170
 171                 _LOGD("inserted privileges of core xml");
 172                 __coretpk_parser_hybrid_dump_log_data(core_privilege_start, privilege_len);
 173         } else {
 174                 char* privilege_buf = NULL;
 175                 char* each_privilege_start = NULL;
 176                 char* each_privilege_end = NULL;
 177                 int each_privilege_len = 0;
 178                 char each_privilege_buf[512] = {0};
 179
 180                 _LOGD("privileges are detected in web xml");
 181
 182                 core_privilege_start = strcasestr(core_buf, "<privilege>");
 183                 core_privilege_end = strcasestr(core_buf, "</privileges>");
 184
 185                 privilege_len = core_privilege_end - core_privilege_start;
 186                 merged_point = strcasestr(merged_buf, "</privileges>");
 187
 188                 _LOGD("original privilege of core xml");
 189                 __coretpk_parser_hybrid_dump_log_data(core_privilege_start, privilege_len);
 190
 191                 privilege_buf = (char*)calloc(1, privilege_len + 1);
 192                 tryvm_if(privilege_buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "privilege_buf is NULL");
 193                 strncpy(privilege_buf, core_privilege_start, privilege_len);
 194
 195                 each_privilege_start = privilege_buf;
 196
 197                 while (each_privilege_start && (each_privilege_start < privilege_buf + privilege_len))
 198                 {
 199                         each_privilege_end = strcasestr(each_privilege_start, "</privilege>");
 200                         each_privilege_len = each_privilege_end - each_privilege_start + strlen("</privilege>");
 201                         if ((each_privilege_end > 0) && each_privilege_len > 0)
 202                         {
 203                                 memset(each_privilege_buf, 0, sizeof(each_privilege_buf));
 204                                 memcpy(each_privilege_buf, each_privilege_start, each_privilege_len);
 205                                 _LOGD("[%s]", each_privilege_buf);
 206
 207                         if (strcasestr(merged_buf, each_privilege_buf) == 0)
 208                         {
 209                                 strncat(selected_privilege_buf, each_privilege_buf, core_buf_len);
 210                         }
 211                         else
 212                         {
 213                                 _LOGD("this privilege is discarded, [%s]", each_privilege_buf);
 214                         }
 215                         }
 216                         else
 217                         {
 218                                 _LOGD("end of privileges merging");
 219                                 break;
 220                         }
 221
 222                                 each_privilege_start = strcasestr(each_privilege_end, "<privilege>");
 223                 }
 224
 225                 core_privilege_start = selected_privilege_buf;
 226                 privilege_len = strlen(core_privilege_start);
 227
 228                 _LOGD("filtered privileges of core xml");
 229                 __coretpk_parser_hybrid_dump_log_data(core_privilege_start, privilege_len);
 230                 FREE_AND_NULL(privilege_buf);
 231         }
 232
 233         if ((merged_point > 0) && (core_privilege_start > 0) && (privilege_len > 0))
 234         {
 235                 int last_part_len = 0;
 236                 char* last_part_buf = NULL;
 237
 238                 last_part_len = *filesize - (merged_point - merged_buf);
 239                 last_part_buf = (char*)calloc(1, *filesize + 1);
 240                 tryvm_if(last_part_buf == NULL, ret = RPM_INSTALLER_ERR_INTERNAL,"@calloc failed!!");
 241
 242                 if (last_part_len > 0)
 243                 {
 244                         memcpy(last_part_buf, merged_point, last_part_len);
 245
 246                         _LOGD("last part of merged xml for backup");
 247                         __coretpk_parser_hybrid_dump_log_data(last_part_buf, last_part_len);
 248
 249                         memcpy(merged_point, core_privilege_start, privilege_len);
 250
 251                         memcpy(merged_point + privilege_len, last_part_buf, last_part_len);
 252                         *filesize += privilege_len;
 253                 }
 254                 FREE_AND_NULL(last_part_buf);
 255
 256         }
 257         ret = RPM_INSTALLER_SUCCESS;
 258
 259 catch:
 260         FREE_AND_NULL(selected_privilege_buf);
 261         return ret;
 262 }
 263
 264 int __coretpk_parser_hybrid_merge_ui_application(char* merged_buf, char* core_buf, int* filesize)
 265 {
 266     retvm_if(merged_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "merged_buf is NULL");
 267     retvm_if(core_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "core_buf is NULL");
 268     retvm_if(filesize <= 0, RPM_INSTALLER_ERR_WRONG_PARAM, "filesize is NULL");
 269
 270          char *tmp_buf = core_buf;
 271          char *start_ptr = NULL;
 272          char *end_ptr = NULL;
 273
 274          while(1) {
 275                 start_ptr = strcasestr(tmp_buf, "<ui-application");
 276                 end_ptr = strcasestr(tmp_buf, "</ui-application>");
 277                 if (end_ptr == NULL) {
 278                         _LOGD("<ui-application> is not detected anymore in core xml");
 279                         return RPM_INSTALLER_SUCCESS;
 280                 }
 281
 282                 _LOGD("<ui-application is detected in core xml");
 283                 __coretpk_parser_hybrid_merge_tag(merged_buf, tmp_buf, filesize, "<ui-application", "</ui-application>");
 284
 285                 tmp_buf = start_ptr + (end_ptr - start_ptr + strlen("</ui-application>"));
 286          }
 287
 288     return RPM_INSTALLER_SUCCESS;
 289 }
 290
 291 int __coretpk_parser_hybrid_merge_service_application(char* merged_buf, char* core_buf, int* filesize)
 292 {
 293     retvm_if(merged_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "merged_buf is NULL");
 294     retvm_if(core_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "core_buf is NULL");
 295     retvm_if(filesize <= 0, RPM_INSTALLER_ERR_WRONG_PARAM, "filesize is NULL");
 296
 297     if (strcasestr(core_buf, "</service-application>") == NULL)
 298     {
 299         _LOGD("<service-application> is NOT detected in core xml");
 300         return RPM_INSTALLER_SUCCESS;
 301     }
 302
 303     _LOGD("<service-application> is detected in core xml");
 304     __coretpk_parser_hybrid_merge_tag(merged_buf, core_buf, filesize, "<service-application", "</service-application>");
 305
 306     return RPM_INSTALLER_SUCCESS;
 307 }
 308
 309 int __coretpk_parser_hybrid_merge_widget_tag(char* merged_buf, char* core_buf, int* filesize)
 310 {
 311     retvm_if(merged_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "merged_buf is NULL");
 312     retvm_if(core_buf == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "core_buf is NULL");
 313     retvm_if(filesize <= 0, RPM_INSTALLER_ERR_WRONG_PARAM, "filesize is NULL");
 314
 315          char *tmp_buf = core_buf;
 316          char *start_ptr = NULL;
 317          char *end_ptr = NULL;
 318
 319          while(1) {
 320                  start_ptr = strcasestr(tmp_buf, "<widget");
 321                  end_ptr = strcasestr(tmp_buf, "</widget>");
 322                 if (end_ptr == NULL) {
 323                         _LOGD("<widget> is not detected anymore in core xml");
 324                         return RPM_INSTALLER_SUCCESS;
 325                 }
 326
 327                 _LOGD("<widget is detected in core xml");
 328                 __coretpk_parser_hybrid_merge_tag(merged_buf, tmp_buf, filesize, "<widget", "</widget>");
 329
 330                 tmp_buf = start_ptr + (end_ptr - start_ptr + strlen("</widget>"));
 331          }
 332
 333     return RPM_INSTALLER_SUCCESS;
 334 }
 335
 336 int __coretpk_parser_hybrid_merge_tag(char* merged_buf, char* core_buf, int* filesize, const char* start_tag, const char* end_tag)
 337 {
 338     do
 339     {
 340         char* buf = NULL;
 341         int length = 0;
 342         char* next = NULL;
 343
 344         __coretpk_parser_hybrid_get_part(core_buf, start_tag, end_tag, &buf, &length, &next);
 345         if (length > 0)
 346         {
 347                 __coretpk_parser_hybrid_merge_to(merged_buf, filesize, "</manifest>", buf, length);
 348         }
 349
 350         if (buf)
 351                         free(buf);
 352
 353         core_buf = next;
 354     }
 355     while (core_buf > 0);
 356
 357     return RPM_INSTALLER_SUCCESS;
 358 }
 359
 360 int __coretpk_parser_hybrid_get_part(const char* start_point, const char* start_tag, const char* end_tag, char** buf, int* length, char** next)
 361 {
 362         int ret = RPM_INSTALLER_ERR_WRONG_PARAM;
 363         const char* start_buf_point = NULL;
 364         const char* end_buf_point = NULL;
 365         int len = 0;
 366
 367         tryvm_if(start_point == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "start_point is NULL");
 368         tryvm_if(start_tag == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "start_tag is NULL");
 369         tryvm_if(end_tag == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "end_tag is NULL");
 370         tryvm_if(buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "buf is NULL");
 371         tryvm_if(length == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "length is NULL");
 372         tryvm_if(next == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "next is NULL");
 373
 374         start_buf_point = strcasestr(start_point, start_tag);
 375         tryvm_if(start_buf_point == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "start_buf_point is NULL");
 376
 377         end_buf_point = strcasestr(start_buf_point, end_tag);
 378         tryvm_if(end_buf_point == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "end_buf_point is NULL");
 379
 380         len = end_buf_point - start_buf_point + strlen(end_tag);
 381         tryvm_if(len <= 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "len is invalid");
 382
 383         *buf = (char*)calloc(1, len + 1);
 384         tryvm_if(*buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "*buf is NULL");
 385         memcpy(*buf, start_buf_point, len);
 386
 387         _LOGD("extracted part, len=[%d]", len);
 388         __coretpk_parser_hybrid_dump_log_data(*buf, len);
 389
 390         *length = len;
 391         next = (char**)end_buf_point;
 392
 393         ret = RPM_INSTALLER_SUCCESS;
 394
 395 catch:
 396     return ret;
 397 }
 398
 399 int __coretpk_parser_hybrid_merge_to(const char* merged_buf, int* filesize, const char* tag, const char* buf, int length)
 400 {
 401         int ret = RPM_INSTALLER_ERR_WRONG_PARAM;
 402         char* merged_point = NULL;
 403         char* last_part_buf = NULL;
 404         int last_part_length = 0;
 405
 406     tryvm_if(merged_buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "merged_buf is NULL");
 407     tryvm_if(*filesize <= 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "filesize is invalid");
 408     tryvm_if(tag == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "tag is NULL");
 409     tryvm_if(buf == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "buf is NULL");
 410     tryvm_if(length <= 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "length is invalid");
 411
 412     merged_point = (char*)strcasestr(merged_buf, tag);
 413     tryvm_if(merged_point == NULL, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "tag is not found, tag=[%s]", tag);
 414
 415     last_part_length = *filesize - (merged_point - merged_buf);
 416     last_part_buf = (char*)calloc(1, *filesize + 1);
 417         tryvm_if(last_part_buf == NULL, ret = RPM_INSTALLER_ERR_INTERNAL, "@calloc failed!!");
 418
 419         if (last_part_length > 0)
 420         {
 421                 memcpy(last_part_buf, merged_point, last_part_length);
 422
 423                 _LOGD("last part of merged xml for backup");
 424                 __coretpk_parser_hybrid_dump_log_data(last_part_buf, last_part_length);
 425
 426                 memcpy(merged_point, buf, length);
 427                 memcpy(merged_point + length, last_part_buf, last_part_length);
 428                 *filesize += length;
 429         }
 430
 431     ret = RPM_INSTALLER_SUCCESS;
 432
 433 catch:
 434         FREE_AND_NULL(last_part_buf);
 435         return ret;
 436 }
 437
 438 char __coretpk_parser_hybrid_log_change_hex_to_str(int hex)
 439 {
 440         char ch = '0';
 441
 442         const static char       hexValues[]     = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 0};
 443
 444
 445         if (hex >= 0 && hex <= 0x0F)
 446         {
 447                 ch      = hexValues[hex];
 448         }
 449         else
 450         {
 451                 _LOGD("LogChangeHexToStr: Error! [Hex Val: %d]\n", hex);
 452         }
 453
 454         return ch;
 455 }
 456
 457 int __coretpk_parser_hybrid_dump_log_data(char *pData, int dataLen)
 458 {
 459         if(pData == NULL){
 460                 _LOGE("@No data to dump");
 461                 return 0;
 462         }
 463         const char      *szData = (const char*)pData;
 464         char            ch = 0;
 465         int                     i = 0, j = 0, idx = 0, idx2 = 0, high = 0, low = 0, temp = 0;
 466
 467         char            buf[LOG_PRINT_LINE_MAX + 2]                     = {0};
 468         char            buf2[(LOG_PRINT_LINE_MAX + 2) * 3]      = {0};
 469         char            buf_out[sizeof(buf) + sizeof(buf2) + 1] = {0};
 470
 471
 472         if (dataLen > LOG_BUFFER_COUNT_MAX)
 473         {
 474                 dataLen = LOG_BUFFER_COUNT_MAX;
 475         }
 476
 477         _LOGD("------------------------------------------");
 478
 479         while (i < (int)dataLen)
 480         {
 481                 ch      = szData[i];
 482
 483                 /* make ascii table */
 484                 if (ch >= 32 && ch <= 128)
 485                 {
 486                         buf[idx++]      = ch;
 487                 }
 488                 else
 489                         buf[idx++]      = '.';
 490
 491                 // make binary table
 492                 high = (ch & 0xf0)>>4;
 493                 low = ch & 0x0f;
 494
 495                 buf2[idx2++]    = __coretpk_parser_hybrid_log_change_hex_to_str(high);
 496                 buf2[idx2++]    = __coretpk_parser_hybrid_log_change_hex_to_str(low);
 497                 buf2[idx2++]    = ' ';
 498
 499                 if (idx >= LOG_PRINT_LINE_MAX)
 500                 {
 501                         memcpy(buf_out, buf2, idx2);
 502
 503                         buf_out[idx2++] = ' ';
 504                         buf_out[idx2++] = ' ';
 505
 506                         memcpy(buf_out + idx2, buf, idx);
 507                         buf_out[idx2+idx]       = '\0';
 508
 509                         idx             = 0;
 510                         idx2    = 0;
 511
 512                         _LOGD("%s\n", buf_out);
 513                 }
 514
 515                 i++;
 516         }
 517
 518         // last line
 519         if (idx > 0)
 520         {
 521                 memcpy(buf_out, buf2, idx2);
 522                 temp    = idx2;
 523
 524                 for (j = 0; j < (LOG_PRINT_LINE_MAX * 3) - temp; j++)
 525                 {
 526                         buf_out[idx2++] = ' ';
 527                 }
 528
 529                 buf_out[idx2++] = ' ';
 530                 buf_out[idx2++] = ' ';
 531
 532                 memcpy(buf_out+idx2, buf, idx);
 533                 buf_out[idx2+idx]       = '\0';
 534
 535                 _LOGD("%s\n", buf_out);
 536         }
 537
 538         _LOGD("------------------------------------------");
 539
 540         return 0;
 541 }
 542
 543 #if 0
 544 static void __coretpk_parser_hybrid_clean_db(const char *pkgid)
 545 {
 546     retm_if(pkgid == NULL, "pkgid is NULL");
 547
 548         int ret = 0;
 549         pkgmgrinfo_pkginfo_h handle = NULL;
 550
 551         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 552         if ((ret < 0) || (handle == NULL)) {
 553                 _LOGD("pkgid[%s] dont have package info", pkgid);
 554         } else {
 555                 _LOGD("pkgid[%s] have package info, need clean db for hybrid", pkgid);
 556                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 557
 558                 //request pkginfo unregister
 559                 ret = pkgmgr_parser_parse_manifest_for_uninstallation(pkgid, NULL);
 560                 if (ret < 0)
 561                         _LOGE("[%s]fail delete pkg info", pkgid);
 562         }
 563 }
 564 #endif
 565
 566 int _coretpk_installer_hybrid_convert_manifest(char *manifest, const char* pkgid, int apiVisibility)
 567 {
 568         int ret = 0;
 569
 570         ret = mkdir(TEMP_XML_DIR, DIRECTORY_PERMISSION_755);
 571         if (ret != 0 && errno != EEXIST) {
 572                 _LOGE("mkdir(%d)", errno);
 573                 return RPM_INSTALLER_ERR_INTERNAL;
 574         }
 575
 576         ret = _coretpk_parser_convert_manifest(manifest, pkgid, NULL, true, apiVisibility, NULL);
 577         if (ret != 0) {
 578                 _LOGE("_coretpk_parser_convert_manifest(%s) failed. ret=[%d]", manifest, ret);
 579                 return RPM_INSTALLER_ERR_INTERNAL;
 580         }
 581
 582         return ret;
 583 }
 584
 585 int _coretpk_installer_request_hybrid(int hybridOperation, char *pPkgPath, int apiVisibility)
 586 {
 587         retvm_if(pPkgPath == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "pPkgPath is NULL.");
 588
 589         int ret = 0;
 590         char wgt_xml[BUF_SIZE] = {'\0'};
 591         char core_xml[BUF_SIZE] = {'\0'};
 592         char converted_core_xml[BUF_SIZE] = {'\0'};
 593         char native_id[BUF_SIZE] = {0,};
 594         char *tmp_pkgid;
 595         manifest_x *mfx = NULL;
 596
 597         _LOGD("request_hybrid(%s) start.", pPkgPath);
 598
 599         snprintf(core_xml, BUF_SIZE, "%s/%s", pPkgPath, CORETPK_XML);
 600         retvm_if(access(core_xml, F_OK) != 0, RPM_INSTALLER_ERR_WRONG_PARAM, "cannot access core xml. [%s]", core_xml);
 601
 602         _LOGD("core xml = [%s]", core_xml);
 603
 604         // convert core xml
 605         tmp_pkgid = rindex(pPkgPath, '/') + 1;
 606         ret = _coretpk_installer_hybrid_convert_manifest(core_xml, tmp_pkgid, apiVisibility);
 607         if (ret != 0) {
 608                 _LOGD("_coretpk_installer_hybrid_convert_manifest(%s, %s) failed.", core_xml, tmp_pkgid);
 609                 return -1;
 610         }
 611
 612         snprintf(converted_core_xml, BUF_SIZE, "%s/%s", TEMP_XML_DIR, CORETPK_XML);
 613         _LOGD("hybrid_convert_manifest(%s) is done.", converted_core_xml);
 614
 615         // get pkgid and version from xml file
 616         mfx = pkgmgr_parser_process_manifest_xml(converted_core_xml);
 617         retvm_if(mfx == NULL, RPM_INSTALLER_ERR_WRONG_PARAM, "pkgmgr_parser_process_manifest_xml(%s) failed.", converted_core_xml);
 618
 619         _LOGD("pkgid = [%s], version = [%s]", mfx->package, mfx->version);
 620
 621 #if 0
 622         // clean pkgmgr db
 623         __coretpk_parser_hybrid_clean_db(mfx->package);
 624         _LOGD("hybrid_clean_db(%s) called.", mfx->package);
 625 #endif
 626
 627         if (strstr(pPkgPath, OPT_USR_APPS)) {
 628                 snprintf(wgt_xml, BUF_SIZE, "%s/%s.xml", OPT_SHARE_PACKAGES, mfx->package);
 629         } else {
 630                 snprintf(wgt_xml, BUF_SIZE, "%s/%s.xml", USR_SHARE_PACKAGES, mfx->package);
 631         }
 632
 633         _LOGD("wgt xml = [%s]", wgt_xml);
 634
 635         // merge xml start
 636         ret = __coretpk_parser_hybrid_to_file(wgt_xml, converted_core_xml);
 637         //tryvm_if(ret != 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "__coretpk_parser_hybrid_to_file(%s, %s) failed.", wgt_xml, converted_core_xml);
 638         _LOGD("hybrid_to_file(%s, %s) success", wgt_xml, converted_core_xml);
 639
 640         // make directory
 641         ret = _coretpk_installer_make_directory((char*)mfx->package);
 642         //tryvm_if(ret != 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "_coretpk_installer_make_directory(%s) failed.", mfx->package);
 643         _LOGD("make_directory(%s) success", mfx->package);
 644
 645         // apply smack to app dir
 646         ret = _coretpk_installer_apply_smack((char*)mfx->package, 1);
 647         //tryvm_if(ret != 0, ret = RPM_INSTALLER_ERR_WRONG_PARAM, "@Failed to apply_smack");
 648         _LOGD("apply_smack(%s, %d) success", mfx->package, ret);
 649
 650         // apply smack by privilege
 651         if (strlen((char*)mfx->package) < BUF_SIZE - strlen(".native") - 1) {
 652                 strcat(native_id, (char*)mfx->package);
 653                 strcat(native_id, ".native");
 654         } else
 655                 _LOGE("package name too long[%s]", (char *)mfx->package);
 656
 657         ret = _ri_privilege_register_package(native_id);
 658         if (ret != 0) {
 659                 _LOGE("_ri_privilege_register_package(%s) failed. ret = [%d].", native_id, ret);
 660         } else {
 661                 _LOGD("_ri_privilege_register_package(%s) success.", native_id);
 662         }
 663
 664         ret = _coretpk_installer_apply_privilege(native_id, pPkgPath, apiVisibility);
 665         if (ret != 0) {
 666                 _LOGE("_coretpk_installer_apply_privilege(%s) failed. ret = [%d].", native_id, ret);
 667         } else {
 668                 _LOGD("_coretpk_installer_apply_privilege(%s) success.", native_id);
 669         }
 670
 671         ret = perm_app_add_friend((char*)mfx->package, native_id);
 672         if (ret != 0) {
 673                 _LOGE("perm_app_add_friend(%s, %s, %d) failed", mfx->package, native_id, ret);
 674         } else {
 675                 _LOGD("perm_app_add_friend(%s) success.", native_id);
 676         }
 677
 678         pkgmgr_parser_free_manifest_xml(mfx);
 679
 680         const char *delete_argv[] = {"/bin/rm", "-rf", TEMP_XML_DIR, NULL};
 681         ret = _ri_xsystem(delete_argv);
 682         if(ret != 0){
 683                 _LOGE("delete the directory failed. [%s]",TEMP_XML_DIR);
 684                 //return RPM_INSTALLER_ERR_INTERNAL;
 685         }
 686
 687         _LOGD("request_hybrid(%s) end.", pPkgPath);
 688         return 0;
 689 }