test/tc-common.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdarg.h>
   5 #include <stdbool.h>
   6 #include <glib.h>
   7 #include <tc-common.h>
   8 #include <iniparser.h>
   9
  10 /*** Color section ***/
  11 void __color_to_red()
  12 {
  13         printf("%c[%d;%dm", 0x1B, BRIGHTNESS, RED);
  14 }
  15 void __color_to_green()
  16 {
  17         printf("%c[%d;%dm", 0x1B, BRIGHTNESS, GREEN);
  18 }
  19 void __color_to_yellow()
  20 {
  21         printf("%c[%d;%dm", 0x1B, BRIGHTNESS, YELLOW);
  22 }
  23 void __color_to_blue()
  24 {
  25         printf("%c[%d;%dm", 0x1B, BRIGHTNESS, BLUE);
  26 }
  27 void __color_to_origin()
  28 {
  29         printf("%c[%dm", 0x1B, 0);
  30 }
  31 void __color_to_bold_red()
  32 {
  33         printf("%c[%dm%c[%dm", 0x1B, 1, 0x1B, RED);
  34 }
  35 void __color_to_bold_yellow()
  36 {
  37         printf("%c[%dm%c[%dm", 0x1B, 1, 0x1B, YELLOW);
  38 }
  39
  40 /* error enum to string */
  41 char* __get_result_string(char type, int ret)
  42 {
  43         switch (type) {
  44         case 'm':
  45                 if (ret == PRVMGR_ERR_NONE)
  46                         return "PRVMGR_ERR_NONE";
  47                 else if (ret == PRVMGR_ERR_INVALID_PRIVILEGE)
  48                         return "PRVMGR_ERR_INVALID_PRIVILEGE";
  49                 else if (ret == PRVMGR_ERR_INVALID_PARAMETER)
  50                         return "PRVMGR_ERR_INVALID_PARAMETER";
  51                 else if (ret == PRVMGR_ERR_INTERNAL_ERROR)
  52                         return "PRVMGR_ERR_INTERNAL_ERROR";
  53                 else if (ret == PRVMGR_ERR_USING_BANNED_PRIVILEGE)
  54                         return "PRVMGR_ERR_USING_BANNED_PRIVILEGE";
  55                 break;
  56         case 'd':
  57                 if (ret == PRIVILEGE_DB_MANAGER_ERR_NONE)
  58                         return "PRIVILEGE_DB_MANAGER_ERR_NONE";
  59                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT)
  60                         return "PRIVILEGE_DB_MANAGER_ERR_NO_EXIST_RESULT";
  61                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_CONNECTION_FAIL)
  62                         return "PRIVILEGE_DB_MANAGER_ERR_CONNECTION_FAIL";
  63                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY)
  64                         return "PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY";
  65                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY)
  66                         return "PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY";
  67                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_INVALID_TYPE)
  68                         return "PRIVILEGE_DB_MANAGER_ERR_INVALID_TYPE";
  69                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_DB_BUSY_FAIL)
  70                         return "PRIVILEGE_DB_MANAGER_ERR_DB_BUSY_FAIL";
  71                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_DB_CONSTRAINT_FAIL)
  72                         return "PRIVILEGE_DB_MANAGER_ERR_DB_CONSTRAINT_FAIL";
  73                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_DB_FULL_FAIL)
  74                         return "PRIVILEGE_DB_MANAGER_ERR_DB_FULL_FAIL";
  75                 else if (ret == PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL)
  76                         return "PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL";
  77                 break;
  78         default:
  79                 break;
  80         }
  81
  82         return "FAIL";
  83 }
  84
  85 char* __get_privilege_type_string(privilege_manager_privilege_type_e type)
  86 {
  87         switch (type) {
  88         case PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL:
  89                 return "PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL";
  90         case PRIVILEGE_MANAGER_PRIVILEGE_TYPE_PRIVACY:
  91                 return "PRIVILEGE_MANAGER_PRIVILEGE_TYPE_PRIVACY";
  92         case PRIVILEGE_MANAGER_PRIVILEGE_TYPE_BLACKLIST:
  93                 return "PRIVILEGE_MANAGER_PRIVILEGE_TYPE_PRIVACY";
  94         default:
  95                 return "None of privilege_manager_privilege_type_e";
  96         }
  97 }
  98
  99 /* shows error_message returned by privilege_manager_verify_privilege() */
 100 void __print_error_message(char *error_message)
 101 {
 102         char *token = NULL;
 103         char *temp = strdup(error_message);
 104         char *save = NULL;
 105
 106         char err_type[256] = { 0, };
 107
 108         if (strstr(error_message, "DEPRECATED") != NULL)
 109                 strncat(err_type, "PRVMGR_ERR_DEPRECATED_PRIVILEGE ", strlen("PRVMGR_ERR_DEPRECATED_PRIVILEGE "));
 110
 111         if (strstr(error_message, "NO_EXIST") != NULL)
 112                 strncat(err_type, "PRVMGR_ERR_NO_EXIST_PRIVILEGE ", strlen("PRVMGR_ERR_NO_EXIST_PRIVILEGE "));
 113
 114         if (strstr(error_message, "MISMATCHED") != NULL)
 115                 strncat(err_type, "PRVMGR_ERR_MISMACHED_PRIVILEGE_LEVEL ", strlen("PRVMGR_ERR_MISMACHED_PRIVILEGE_LEVEL "));
 116
 117         if (strstr(error_message, "INVALID_PARAMETER") != NULL)
 118                 strncat(err_type, "PRVMGR_ERR_INVALID_PARAMETER ", strlen("PRVMGR_ERR_INVALID_PARAMETER "));
 119
 120         if (strstr(error_message, "BANNED") != NULL)
 121                 strncat(err_type, "PRVMGR_ERR_USING_BANNED_PRIVILEGE ", strlen("PRVMGR_ERR_USING_BANNED_PRIVILEGE "));
 122
 123         if (strlen(err_type) == 0) {
 124                 fail_cnt++;
 125                 strncat(err_type, "test failed - unknown error type", strlen("test failed - unknown error type "));
 126                 __color_to_red();
 127         } else {
 128                 __color_to_blue();
 129         }
 130         printf("\nError Message : %s\n", err_type);
 131         __color_to_origin();
 132
 133         token = strtok_r(temp, "|", &save);
 134         while (token) {
 135                 printf("%s\n", token);
 136                 token = strtok_r(NULL, "|", &save);
 137         }
 138         printf("\n");
 139         free(temp);
 140 }
 141
 142 void __tcinfo(tcinfo_type_e type, ...)
 143 {
 144         va_list ap;
 145         va_start(ap, type);
 146         switch (type) {
 147         case goal: /* shows test goal */
 148                 __color_to_yellow();
 149                 printf("TEST >> %s\n\n", va_arg(ap, char*));
 150                 __color_to_origin();
 151                 break;
 152         case cert_level: /* set certificate level */
 153                 visibility_string = va_arg(ap, char*);
 154                 if (strncmp(visibility_string, "public", strlen(visibility_string)) == 0)
 155                         visibility = PRVMGR_PACKAGE_VISIBILITY_PUBLIC;
 156                 else if (strncmp(visibility_string, "partner", strlen(visibility_string)) == 0)
 157                         visibility = PRVMGR_PACKAGE_VISIBILITY_PARTNER;
 158                 else if (strncmp(visibility_string, "platform", strlen(visibility_string)) == 0)
 159                         visibility = PRVMGR_PACKAGE_VISIBILITY_PLATFORM;
 160                 else
 161                         printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!WRONG CERT LEVEL!!!!!!!!!!!!!!!!!!!!!");
 162                 printf("\n- SIGNATURE LEVEL : %s\n", visibility_string);
 163                 break;
 164         case version_type: /* set api_version and pkg_type */
 165                 __print_dline();
 166                 __color_to_bold_yellow();
 167                 api_version = va_arg(ap, char*);
 168                 char* pkg_type_string = va_arg(ap, char*);
 169                 if (strncmp("core", pkg_type_string, strlen("core")) == 0)
 170                         pkg_type = PRVMGR_PACKAGE_TYPE_CORE;
 171                 else if (strncmp("wrt", pkg_type_string, strlen("wrt")) == 0)
 172                         pkg_type = PRVMGR_PACKAGE_TYPE_WRT;
 173                 else
 174                         printf("!!!!!!!!!!!!!!!!!!!!!!WRONG PACKAGE TYPE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 175                 printf("- API VERSION : %s\n", api_version);
 176                 printf("- PACKAGE TYPE : %s\n", pkg_type_string);
 177                 __color_to_origin();
 178                 __print_dline();
 179                 __print_nline();
 180                 break;
 181         case expect: /* set expected_result */
 182                 expected_result = va_arg(ap, int);
 183                 break;
 184         case results: /* shows expected result and achieved result */
 185                 printf("\n- EXPECTED RESULT : %s\n", va_arg(ap, char*));
 186                 printf("- ACHIEVED RESULT : %s\n\n", va_arg(ap, char*));
 187                 break;
 188         case function: /* shows function to test */
 189                 __color_to_yellow();
 190                 __print_dline();
 191                 printf("# TEST FUNCTION : %s()\n", va_arg(ap, char*));
 192                 __print_dline();
 193                 __color_to_origin();
 194                 break;
 195         default:
 196                 printf("no matching enum for input\n");
 197         }
 198         va_end(ap);
 199 }
 200
 201 void __privinfo(char *name, char *level, char *comment)
 202 {
 203         if (level != NULL)
 204                 printf("|%s| ", level);
 205         printf("%s", name);
 206         privilege_list = g_list_append(privilege_list, name);
 207         if (comment != NULL)
 208                 printf("   -- %s", comment);
 209         printf("\n");
 210 }
 211
 212 void __print_line()
 213 {
 214         printf("-------------------------------------------------------------------\n");
 215 }
 216
 217 void __print_dline()
 218 {
 219         printf("===================================================================\n");
 220 }
 221
 222 void __print_nline()
 223 {
 224         printf("\n");
 225 }
 226
 227 void __print_privilege_list(GList * privilege_list)
 228 {
 229         GList *l;
 230         printf("Print mapped privilege list: \n");
 231         for (l = privilege_list; l != NULL; l = l->next) {
 232                 char *privilege_name = (char *)l->data;
 233                 printf("%s\n", privilege_name);
 234         }
 235 }
 236
 237 void __print_glist(GList* glist)
 238 {
 239         GList *l;
 240         for (l = glist; l != NULL; l = l->next) {
 241                 char *text = (char *)l->data;
 242                 printf("%s\n", text);
 243         }
 244 }
 245
 246 bool __check_result(int result)
 247 {
 248         if (expected_result == result)
 249                 return true;
 250         else
 251                 return false;
 252 }
 253
 254 bool __count_result(int result)
 255 {
 256         bool success = __check_result(result);
 257         if (success)
 258                 success_cnt++;
 259         else
 260                 fail_cnt++;
 261         return success;
 262 }
 263
 264 void __print_result(char type, int result)
 265 {
 266         __tcinfo(results, __get_result_string(type, expected_result), __get_result_string(type, result));
 267         if (__count_result(result)) {
 268                 __color_to_green();
 269                 printf(">> test success\n");
 270         } else {
 271                 __color_to_bold_red();
 272                 printf(">> test fail\n");
 273         }
 274         __color_to_origin();
 275 }
 276
 277 #define INI_PATH "/etc/privilege-checker.ini"
 278 #define INI_KEYWORD_PROFILE "General:Profile"
 279 tizen_profile_t _get_tizen_profile()
 280 {
 281         static tizen_profile_t profile = TIZEN_PROFILE_UNKNOWN;
 282         if (__builtin_expect(profile != TIZEN_PROFILE_UNKNOWN, 1))
 283                 return profile;
 284
 285         char *val = NULL;
 286         dictionary *dic = iniparser_load(INI_PATH);
 287
 288         if (dic == NULL) {
 289                 /* if there is no .ini file, let's assume it's common */
 290                 profile = TIZEN_PROFILE_COMMON;
 291                 return profile;
 292         }
 293
 294         val = iniparser_getstring(dic, INI_KEYWORD_PROFILE, NULL);
 295
 296         if (val != NULL) {
 297                 switch (*val) {
 298                 case 'm':
 299                 case 'M':
 300                         profile = TIZEN_PROFILE_MOBILE;
 301                         break;
 302                 case 'w':
 303                 case 'W':
 304                         profile = TIZEN_PROFILE_WEARABLE;
 305                         break;
 306                 case 't':
 307                 case 'T':
 308                         profile = TIZEN_PROFILE_TV;
 309                         break;
 310                 case 'i':
 311                 case 'I':
 312                         profile = TIZEN_PROFILE_IVI;
 313                         break;
 314                 default: // common or unknown ==> ALL ARE COMMON.
 315                         profile = TIZEN_PROFILE_COMMON;
 316                 }
 317                 iniparser_freedict(dic);
 318         } else {
 319                 profile = TIZEN_PROFILE_COMMON;
 320         }
 321
 322         return profile;
 323 }