src/privilege_info.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <libintl.h>
   4 #include <dlog.h>
   5 #include <privilege_db_manager.h>
   6 #include "privilege_information.h"
   7 #ifdef LOG_TAG
   8 #undef LOG_TAG
   9 #define LOG_TAG "PRIVILEGE_INFO"
  10 #endif
  11
  12 #define TryReturn(condition, expr, returnValue, ...)  \
  13     if (!(condition)) { \
  14                 expr; \
  15         LOGE(__VA_ARGS__); \
  16         return returnValue; \
  17     } \
  18     else {;}
  19
  20 #ifndef PI_API
  21 #define PI_API __attribute__((visibility("default")))
  22 #endif
  23
  24 typedef enum
  25 {
  26     PRVINFO_ERROR_NO_MATCHING_PRIVILEGE        = TIZEN_ERROR_PRIVILEGE_INFORMATION | 0x01
  27 }privilege_info_internal_error_e;
  28
  29 int privilege_info_get_display_name_string_id(const char* api_version, const char *privilege, char **display_name_string_id)
  30 {
  31     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
  32     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
  33
  34     char* temp = NULL;
  35
  36     // Check NATIVE
  37     int ret = privilege_db_manager_get_privilege_display(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_CORE, privilege, api_version, &temp);
  38
  39     if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
  40     {
  41         if(temp == NULL)
  42         {
  43             *display_name_string_id = NULL;
  44         }
  45         else if(strcmp(temp,"") == 0)
  46         {
  47             *display_name_string_id = NULL;
  48         }
  49         else
  50         {
  51             goto err_none;
  52         }
  53     }
  54     else if(ret != PRIVILEGE_DB_NO_EXIST_RESULT)
  55     {
  56         goto err_internal_error;
  57     }
  58
  59     if(temp != NULL)
  60     {
  61         free(temp);
  62         temp = NULL;
  63     }
  64
  65     // Check WEB
  66     ret = privilege_db_manager_get_privilege_display(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_WRT, privilege, api_version, &temp);
  67
  68     if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
  69     {
  70         if(temp == NULL)
  71         {
  72             goto err_no_matching_privilege;
  73         }
  74         else if(strcmp(temp,"") == 0)
  75         {
  76             goto err_no_matching_privilege;
  77         }
  78         else
  79         {
  80             goto err_none;
  81         }
  82     }
  83     else if(ret == PRIVILEGE_DB_NO_EXIST_RESULT)
  84     {
  85         goto err_no_matching_privilege;
  86     }
  87     else
  88     {
  89         goto err_internal_error;
  90     }
  91
  92 err_none:
  93     *display_name_string_id = (char*)calloc(strlen(temp) + 1, sizeof(char));
  94     TryReturn(*display_name_string_id != NULL, free(temp), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation is failed.");
  95     memcpy(*display_name_string_id, temp, strlen(temp));
  96     LOGD("display_name_string_id = %s", *display_name_string_id);
  97     free(temp);
  98     return PRVINFO_ERROR_NONE;
  99
 100 err_no_matching_privilege:
 101     *display_name_string_id = NULL;
 102     free(temp);
 103     return PRVINFO_ERROR_NO_MATCHING_PRIVILEGE;
 104
 105 err_internal_error:
 106     free(temp);
 107     return PRVINFO_ERROR_INTERNAL_ERROR;
 108 }
 109
 110
 111 int privilege_info_get_display_name_by_string_id(const char *string_id, char **display_name)
 112 {
 113     char *temp = NULL;
 114     TryReturn(string_id != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] string_id is NULL");
 115
 116     temp = dgettext("privilege", string_id);
 117
 118     *display_name = (char*)calloc(strlen(temp) + 1, sizeof(char));
 119     TryReturn(*display_name != NULL,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 120
 121     memcpy(*display_name, temp, strlen(temp));
 122
 123     return PRVINFO_ERROR_NONE;
 124 }
 125
 126 PI_API
 127 int privilege_info_get_display_name(const char* api_version, const char* privilege, char** display_name)
 128 {
 129     int ret = 0;
 130     char* display_name_string_id = NULL;
 131
 132     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
 133     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
 134
 135     ret = privilege_info_get_display_name_string_id(api_version, privilege, &display_name_string_id);
 136
 137     if(ret == PRVINFO_ERROR_NO_MATCHING_PRIVILEGE)
 138     {
 139         char* tempPrivilege = NULL;
 140         char* token = NULL;
 141         char* temp = NULL;
 142                 char* save = NULL;
 143
 144                 tempPrivilege = strdup(privilege);
 145                 TryReturn(tempPrivilege != NULL, free(tempPrivilege), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] tempPrivilege's strdup is failed.");
 146
 147         token = strtok_r(tempPrivilege, "/", &save);
 148         while(token)
 149         {
 150             temp = token;
 151             token = strtok_r(NULL, "/", &save);
 152         }
 153         *display_name = (char*)calloc(strlen(temp) + 1, sizeof(char));
 154         TryReturn(*display_name != NULL, free(tempPrivilege), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 155         memcpy(*display_name, temp, strlen(temp));
 156                 free(tempPrivilege);
 157     }
 158     else if(ret == PRVINFO_ERROR_NONE)
 159     {
 160         ret = privilege_info_get_display_name_by_string_id(display_name_string_id, display_name);
 161         free(display_name_string_id);
 162         TryReturn(ret == PRVINFO_ERROR_NONE,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 163     }
 164     else
 165     {
 166         return PRVINFO_ERROR_INTERNAL_ERROR;
 167     }
 168     return PRVINFO_ERROR_NONE;
 169 }
 170
 171
 172 int privilege_info_get_description_string_id(const char* api_version, const char *privilege, char **description_string_id)
 173 {
 174     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
 175     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
 176
 177     char* temp = NULL;
 178
 179     // Check NATIVE
 180     int ret = privilege_db_manager_get_privilege_description(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_CORE, privilege, api_version, &temp);
 181
 182     if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
 183     {
 184         if(temp == NULL)
 185         {
 186             *description_string_id = NULL;
 187         }
 188         else if(strcmp(temp, "") == 0)
 189         {
 190             *description_string_id = NULL;
 191         }
 192         else
 193         {
 194             goto err_none;
 195         }
 196     }
 197     else if(ret != PRIVILEGE_DB_NO_EXIST_RESULT)
 198     {
 199         goto err_internal_error;
 200     }
 201
 202     if(temp != NULL)
 203     {
 204         free(temp);
 205         temp = NULL;
 206     }
 207     // Check WEB
 208     ret = privilege_db_manager_get_privilege_description(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_WRT, privilege, api_version, &temp);
 209
 210     if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
 211     {
 212         if(temp == NULL)
 213         {
 214             goto err_no_matching_privilege;
 215         }
 216         else if(strcmp(temp,"") == 0)
 217         {
 218             goto err_no_matching_privilege;
 219         }
 220         else
 221         {
 222             goto err_none;
 223         }
 224     }
 225     else if(ret == PRIVILEGE_DB_NO_EXIST_RESULT)
 226     {
 227         goto err_no_matching_privilege;
 228     }
 229     else
 230     {
 231         goto err_internal_error;
 232     }
 233
 234 err_none:
 235     *description_string_id = (char*)calloc(strlen(temp) + 1, sizeof(char));
 236     TryReturn(*description_string_id != NULL, free(temp), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation is failed.");
 237     memcpy(*description_string_id, temp, strlen(temp));
 238     LOGD("description_string_id = %s", *description_string_id);
 239     free(temp);
 240     return PRVINFO_ERROR_NONE;
 241
 242 err_no_matching_privilege:
 243     *description_string_id = NULL;
 244     free(temp);
 245     return PRVINFO_ERROR_NO_MATCHING_PRIVILEGE;
 246
 247 err_internal_error:
 248     free(temp);
 249     return PRVINFO_ERROR_INTERNAL_ERROR;
 250 }
 251
 252 int privilege_info_get_description_by_string_id(const char *string_id, char **description)
 253 {
 254     char *temp = NULL;
 255     TryReturn(string_id != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] string_id is NULL");
 256
 257     temp = dgettext("privilege", string_id);
 258
 259     *description = (char*)calloc(strlen(temp) + 1, sizeof(char));
 260     TryReturn(*description != NULL,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 261
 262     memcpy(*description, temp, strlen(temp));
 263
 264     return PRVINFO_ERROR_NONE;
 265 }
 266
 267 PI_API
 268 int privilege_info_get_description(const char* api_version, const char* privilege, char** description)
 269 {
 270     int ret = 0;
 271     char* description_string_id = NULL;
 272
 273     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
 274     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
 275
 276     ret = privilege_info_get_description_string_id(api_version, privilege, &description_string_id);
 277
 278     if(ret == PRVINFO_ERROR_NO_MATCHING_PRIVILEGE)
 279     {
 280         char* temp = NULL;
 281         temp = dgettext("privilege", "IDS_TPLATFORM_BODY_THIS_PRIVILEGE_IS_NOT_DEFINED");
 282         *description = (char*)calloc(strlen(temp) + 1, sizeof(char));
 283         TryReturn(*description != NULL,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 284
 285         memcpy(*description, temp, strlen(temp));
 286     }
 287     else if(ret == PRVINFO_ERROR_NONE)
 288     {
 289         ret = privilege_info_get_description_by_string_id(description_string_id, description);
 290         free(description_string_id);
 291         TryReturn(ret == PRVINFO_ERROR_NONE,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 292     }
 293     else
 294     {
 295         return PRVINFO_ERROR_INTERNAL_ERROR;
 296     }
 297     return PRVINFO_ERROR_NONE;
 298 }
 299
 300 int privilege_info_get_display_name_string_id_by_pkgtype(const char* package_type, const char* api_version, const char *privilege, char **display_name_string_id)
 301 {
 302     TryReturn(package_type != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] package_type is NULL");
 303     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
 304     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
 305
 306     char* temp = NULL;
 307
 308     // Check package_type
 309     int ret = 0;
 310     if(strcmp(package_type,"PRVINFO_PACKAGE_TYPE_NATIVE") == 0)
 311     {
 312         LOGD("package_type = %s", package_type);
 313     }
 314     else if(strcmp(package_type,"PRVINFO_PACKAGE_TYPE_WEB") == 0)
 315     {
 316         LOGD("package_type = %s", package_type);
 317         ret = privilege_db_manager_get_privilege_display(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_WRT, privilege, api_version, &temp);
 318         if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
 319         {
 320             if(temp == NULL)
 321             {
 322                 *display_name_string_id = NULL;
 323             }
 324             else if(strcmp(temp,"") == 0)
 325             {
 326                 *display_name_string_id = NULL;
 327             }
 328             else
 329             {
 330                 goto err_none;
 331             }
 332         }
 333         else if(ret != PRIVILEGE_DB_NO_EXIST_RESULT)
 334         {
 335             goto err_internal_error;
 336         }
 337
 338         if(temp != NULL)
 339         {
 340             free(temp);
 341             temp = NULL;
 342         }
 343     }
 344     else
 345     {
 346         LOGD("package_type = %s", package_type);
 347         free(temp);
 348         return PRVINFO_ERROR_INVALID_PARAMETER;
 349     }
 350
 351     ret = privilege_db_manager_get_privilege_display(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_CORE, privilege, api_version, &temp);
 352
 353     if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
 354     {
 355         if(temp == NULL)
 356         {
 357             goto err_no_matching_privilege;
 358         }
 359         else if(strcmp(temp, "") == 0)
 360         {
 361             goto err_no_matching_privilege;
 362         }
 363         else
 364         {
 365             goto err_none;
 366         }
 367     }
 368     else if(ret == PRIVILEGE_DB_NO_EXIST_RESULT)
 369     {
 370         goto err_no_matching_privilege;
 371     }
 372     else
 373     {
 374         goto err_internal_error;
 375     }
 376
 377 err_none:
 378     *display_name_string_id = (char*)calloc(strlen(temp) + 1, sizeof(char));
 379     TryReturn(*display_name_string_id != NULL, free(temp), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation is failed.");
 380     memcpy(*display_name_string_id, temp, strlen(temp));
 381     LOGD("display_name_string_id = %s", *display_name_string_id);
 382     free(temp);
 383     return PRVINFO_ERROR_NONE;
 384
 385 err_no_matching_privilege:
 386     *display_name_string_id = NULL;
 387     free(temp);
 388     return PRVINFO_ERROR_NO_MATCHING_PRIVILEGE;
 389
 390 err_internal_error:
 391     free(temp);
 392     return PRVINFO_ERROR_INTERNAL_ERROR;
 393 }
 394
 395 PI_API
 396 int privilege_info_get_display_name_by_pkgtype(const const char* package_type, const char* api_version, const char* privilege, char** display_name)
 397 {
 398     int ret = 0;
 399     char* display_name_string_id = NULL;
 400
 401     TryReturn(package_type != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] package_type is NULL");
 402     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
 403     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
 404
 405     ret = privilege_info_get_display_name_string_id_by_pkgtype(package_type, api_version, privilege, &display_name_string_id);
 406
 407     if(ret == PRVINFO_ERROR_NO_MATCHING_PRIVILEGE)
 408     {
 409         char* tempPrivilege = NULL;
 410         char* token = NULL;
 411         char* temp = NULL;
 412                 char* save = NULL;
 413         tempPrivilege = strdup(privilege);
 414                 TryReturn(tempPrivilege != NULL, free(tempPrivilege), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] tempPrivilege's strdup is failed.");
 415         token = strtok_r(tempPrivilege, "/", &save);
 416         while(token)
 417         {
 418             temp = token;
 419             token = strtok_r(NULL, "/", &save);
 420         }
 421         *display_name = (char*)calloc(strlen(temp) + 1, sizeof(char));
 422         TryReturn(*display_name != NULL, free(tempPrivilege), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 423         memcpy(*display_name, temp, strlen(temp));
 424                 free(tempPrivilege);
 425     }
 426     else if(ret == PRVINFO_ERROR_NONE)
 427     {
 428         ret = privilege_info_get_display_name_by_string_id(display_name_string_id, display_name);
 429         free(display_name_string_id);
 430         TryReturn(ret == PRVINFO_ERROR_NONE,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 431     }
 432     else
 433     {
 434         return PRVINFO_ERROR_INTERNAL_ERROR;
 435     }
 436     return PRVINFO_ERROR_NONE;
 437 }
 438
 439
 440 int privilege_info_get_description_string_id_by_pkgtype(const char* package_type, const char* api_version, const char *privilege, char **description_string_id)
 441 {
 442     TryReturn(package_type != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] package_type is NULL");
 443     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
 444     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
 445
 446     char* temp = NULL;
 447
 448     // Check package_type
 449     int ret = 0;
 450
 451     if(strcmp(package_type,"PRVINFO_PACKAGE_TYPE_WEB") == 0)
 452     {
 453         LOGD("package_type = %s", package_type);
 454         ret = privilege_db_manager_get_privilege_description(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_WRT, privilege, api_version, &temp);
 455         if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
 456         {
 457             if(temp == NULL)
 458             {
 459                 *description_string_id = NULL;
 460             }
 461             else if(strcmp(temp,"") == 0)
 462             {
 463                 *description_string_id = NULL;
 464             }
 465             else
 466             {
 467                 goto err_none;
 468             }
 469         }
 470         else if(ret != PRIVILEGE_DB_NO_EXIST_RESULT)
 471         {
 472             goto err_internal_error;
 473         }
 474
 475         if(temp != NULL)
 476         {
 477             free(temp);
 478             temp = NULL;
 479         }
 480     }
 481     else if(strcmp(package_type,"PRVINFO_PACKAGE_TYPE_NATIVE") == 0)
 482     {
 483         LOGD("package_type = %s", package_type);
 484     }
 485     else
 486     {
 487         LOGD("package_type = %s", package_type);
 488         free(temp);
 489         return PRVINFO_ERROR_INVALID_PARAMETER;
 490     }
 491
 492     ret = privilege_db_manager_get_privilege_description(PRIVILEGE_DB_MANAGER_PACKAGE_TYPE_CORE, privilege, api_version, &temp);
 493
 494     if(ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
 495     {
 496         if(temp == NULL)
 497         {
 498             goto err_no_matching_privilege;
 499         }
 500         else if(strcmp(temp,"") == 0)
 501         {
 502             goto err_no_matching_privilege;
 503         }
 504         else
 505         {
 506             goto err_none;
 507         }
 508     }
 509     else if(ret == PRIVILEGE_DB_NO_EXIST_RESULT)
 510     {
 511         goto err_no_matching_privilege;
 512     }
 513     else
 514     {
 515         goto err_internal_error;
 516     }
 517
 518
 519 err_none:
 520     *description_string_id = (char*)calloc(strlen(temp) + 1, sizeof(char));
 521     TryReturn(*description_string_id != NULL, free(temp), PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation is failed.");
 522     memcpy(*description_string_id, temp, strlen(temp));
 523     LOGD("description_string_id = %s", *description_string_id);
 524     free(temp);
 525     return PRVINFO_ERROR_NONE;
 526
 527 err_no_matching_privilege:
 528     *description_string_id = NULL;
 529     free(temp);
 530     return PRVINFO_ERROR_NO_MATCHING_PRIVILEGE;
 531
 532 err_internal_error:
 533     free(temp);
 534     return PRVINFO_ERROR_INTERNAL_ERROR;
 535 }
 536
 537 PI_API
 538 int privilege_info_get_description_by_pkgtype(const char* package_type, const char* api_version, const char* privilege, char** description)
 539 {
 540     int ret = 0;
 541     char* description_string_id = NULL;
 542
 543     TryReturn(package_type != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] package_type is NULL");
 544     TryReturn(api_version != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] api_version is NULL");
 545     TryReturn(privilege != NULL,, PRVINFO_ERROR_INVALID_PARAMETER, "[PRVINFO_ERROR_INVALID_PARAMETER] privilege is NULL");
 546
 547     ret = privilege_info_get_description_string_id_by_pkgtype(package_type, api_version, privilege, &description_string_id);
 548
 549     if(ret == PRVINFO_ERROR_NO_MATCHING_PRIVILEGE)
 550     {
 551         char* temp = NULL;
 552         temp = dgettext("privilege", "IDS_TPLATFORM_BODY_THIS_PRIVILEGE_IS_NOT_DEFINED");
 553         *description = (char*)calloc(strlen(temp) + 1, sizeof(char));
 554         TryReturn(*description != NULL,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 555         memcpy(*description, temp, strlen(temp));
 556         //return PRVINFO_ERROR_NO_MATCHING_PRIVILEGE;
 557     }
 558     else if(ret == PRVINFO_ERROR_NONE)
 559     {
 560         ret = privilege_info_get_description_by_string_id(description_string_id, description);
 561         free(description_string_id);
 562         TryReturn(ret == PRVINFO_ERROR_NONE,, PRVINFO_ERROR_OUT_OF_MEMORY, "[PRVINFO_ERROR_OUT_OF_MEMORY] Memory allocation failed.");
 563     }
 564     else
 565     {
 566         return PRVINFO_ERROR_INTERNAL_ERROR;
 567     }
 568     return PRVINFO_ERROR_NONE;
 569 }
 570