Loading api-features from a file.

[Issue#]       SSDWSSP-183
[Bug/Feature]  Loading permission from a file.
[Cause]        N/A
[Solution]     Added option to api_feature_loader.
[Verification] Build, install, use api_feature_loader --file=file_path
               run sqlite3 /opt/dbspace/.rules-db.db3 'select * from permission_view;'
               and confirm permission is loaded

Change-Id: I662ee3ee116b66f4730251be37ff85206c4276e8

diff --git a/api_feature_loader/api_feature_loader.c b/api_feature_loader/api_feature_loader.c
index 7d88044..cd76b0d 100644 (file)
--- a/api_feature_loader/api_feature_loader.c
+++ b/api_feature_loader/api_feature_loader.c
@@ -27,32 +27,30 @@
 */
 
 #define _GNU_SOURCE
-#include <stdio.h>              // For file manipulation
-#include <stdlib.h>             // For malloc and free
 #include <dirent.h>             // For iterating directories
+#include <getopt.h>             // For getopt
 #include <obstack.h>            // For obstack implementation
 #include <privilege-control.h>  // For app_type
+#include <stdio.h>              // For file manipulation
+#include <stdlib.h>             // For malloc and free
 #include <sys/smack.h>          // For SMACK_LABEL_LEN
-#include <getopt.h>             // For getopt
+#include <unistd.h>             // For basename
 
 
 #define API_FEATURE_LOADER_VERSION "1.0"
+#define ACC_LEN 6
+#define API_FEATURES_DIR "/usr/share/privilege-control/"
+#define API_FEATURE_LOADER_LOG(format, ...) if(i_verbose_flag__) printf(format, ##__VA_ARGS__)
 
+// Obstack configuration
 #define obstack_chunk_alloc malloc
 #define obstack_chunk_free  free
-
 #define vector_init(V)              obstack_init(&(V))
 #define vector_push_back_ptr(V, I)  obstack_ptr_grow(&(V), (I))
 #define vector_finish(V)            obstack_finish(&(V))
 #define vector_free(V)              obstack_free(&(V), NULL)
-
-#define ACC_LEN 6
-
-#define API_FEATURES_DIR "/usr/share/privilege-control/"
-
-#define API_FEATURE_LOADER_LOG(format, ...) if(i_verbose_flag__) printf(format, ##__VA_ARGS__)
-
 typedef struct obstack vector_t;
+
 static int i_verbose_flag__ = 0;
 static const size_t ui_smack_ext_len__ = 6; // = strlen(".smack");
 
@@ -169,8 +167,30 @@ finish:
        }
 }
 
+
+char *get_permission_name(const char *s_file_name, const char *s_prefix)
+{
+       int i_prefix_len = strlen(s_prefix);
+
+       // Allocate memory
+       int i_perm_name_len = strlen(s_file_name);
+       char *s_permission_name = (char *) malloc(i_perm_name_len);
+       if(!s_permission_name) {
+               API_FEATURE_LOADER_LOG("Error during allocating memory.\n");
+               return NULL;
+       }
+
+       strncpy(s_permission_name,
+               &(s_file_name[i_prefix_len]),
+               i_perm_name_len - i_prefix_len - ui_smack_ext_len__);
+
+       s_permission_name[i_perm_name_len - i_prefix_len - ui_smack_ext_len__ ] = '\0';
+
+       return s_permission_name;
+}
+
 void load_permission_family(int (*filter)(const struct dirent *),
-                           int i_prefix_len,
+                           const char const *s_prefix,
                            const app_type_t app_type,
                            const char const *s_dir)
 {
@@ -178,22 +198,13 @@ void load_permission_family(int (*filter)(const struct dirent *),
        struct dirent **file_list = NULL;
        char *s_path              = NULL;
        char *s_permission_name   = NULL;
-       int i_perm_name_len;
+
 
        num_files = scandir(s_dir, &file_list, filter, alphasort);
        for(i = 0; i < num_files; ++i) {
                if(asprintf(&s_path, "%s%s", s_dir, file_list[i]->d_name) <= 0) continue;
 
-               i_perm_name_len = strlen(file_list[i]->d_name);
-               s_permission_name = (char *) malloc(i_perm_name_len);
-               if(!s_permission_name) {
-                       API_FEATURE_LOADER_LOG("Error during allocating memory.\n");
-                       return;
-               }
-               strncpy(s_permission_name,
-                       &(file_list[i]->d_name[i_prefix_len]),
-                       i_perm_name_len - i_prefix_len - ui_smack_ext_len__);
-               s_permission_name[i_perm_name_len - i_prefix_len - ui_smack_ext_len__ ] = '\0';
+               s_permission_name = get_permission_name(file_list[i]->d_name, s_prefix);
                load_rules_from_file(s_path, s_permission_name, app_type);
 
                free(file_list[i]);
@@ -235,34 +246,75 @@ void load_from_dir(const char  *const s_dir)
        if(perm_modification_start()) return;
 
        // Load rules specific to permission's types:
-       load_pemission_type_rules(wrt_filter, "WRT", APP_TYPE_WGT, s_dir);
-       load_pemission_type_rules(wrt_partner_filter, "WRT_partner", APP_TYPE_WGT_PARTNER, s_dir);
+       load_pemission_type_rules(wrt_filter,         "WRT",          APP_TYPE_WGT,         s_dir);
+       load_pemission_type_rules(wrt_partner_filter, "WRT_partner",  APP_TYPE_WGT_PARTNER, s_dir);
        load_pemission_type_rules(wrt_platform_filter, "WRT_platform", APP_TYPE_WGT_PLATFORM, s_dir);
-       load_pemission_type_rules(osp_filter, "OSP", APP_TYPE_OSP, s_dir);
+       load_pemission_type_rules(osp_filter,         "OSP",          APP_TYPE_OSP,         s_dir);
        load_pemission_type_rules(osp_partner_filter, "OSP_partner" , APP_TYPE_OSP_PARTNER, s_dir);
        load_pemission_type_rules(osp_platform_filter, "OSP_platform", APP_TYPE_OSP_PLATFORM, s_dir);
-       load_pemission_type_rules(efl_filter, "EFL", APP_TYPE_EFL, s_dir);
+       load_pemission_type_rules(efl_filter,         "EFL",          APP_TYPE_EFL,         s_dir);
 
        // Load rules for each permission type:
-       load_permission_family(wrt_family_filter, strlen("WRT_"), APP_TYPE_WGT, s_dir);
-       load_permission_family(osp_family_filter, strlen("OSP_"), APP_TYPE_OSP, s_dir);
-       load_permission_family(efl_family_filter, strlen("EFL_"), APP_TYPE_EFL, s_dir);
+       load_permission_family(wrt_family_filter, "WRT_", APP_TYPE_WGT, s_dir);
+       load_permission_family(osp_family_filter, "OSP_", APP_TYPE_OSP, s_dir);
+       load_permission_family(efl_family_filter, "EFL_", APP_TYPE_EFL, s_dir);
 
        perm_modification_finish();
        API_FEATURE_LOADER_LOG("Done.\n");
+}
+
+void load_from_file(const char  *const s_file_path)
+{
+       API_FEATURE_LOADER_LOG("Loading rules from file...\n");
+       if(perm_modification_start()) return;
+
+       char *s_permission_name = NULL;
+       char *s_file_name;
+       struct dirent file;
+
+       if(!has_smack_ext(s_file_path)) {
+               API_FEATURE_LOADER_LOG("File doesn't have smack extension.");
+               return;
+       }
+
+       s_file_name = basename(s_file_path);
+       strcpy(file.d_name, s_file_name);
+
+       // Load as the right type of permission
+       if(wrt_family_filter(&file)) {
+               s_permission_name = get_permission_name(s_file_name, "WRT_");
+               load_rules_from_file(s_file_path, s_permission_name, APP_TYPE_WGT);
+
+       } else if(osp_family_filter(&file)) {
+               s_permission_name = get_permission_name(s_file_name, "OSP_");
+               load_rules_from_file(s_file_path, s_permission_name, APP_TYPE_OSP);
+
+       } else if(efl_family_filter(&file)) {
+               s_permission_name = get_permission_name(s_file_name, "EFL_");
+               load_rules_from_file(s_file_path, s_permission_name, APP_TYPE_EFL);
+
+       } else {
+               API_FEATURE_LOADER_LOG("Unknown api-feature type.");
+       }
+
+       free(s_permission_name);
 
+       perm_modification_finish();
+       API_FEATURE_LOADER_LOG("Done.\n");
 }
 
+
+
 int main(int argc, char *argv[])
 {
        int c;
        int i_option_index = 0;
 
        bool b_load_from_file = false;
-       const char *s_file;
+       const char *s_file_name = NULL;
 
        bool b_load_from_dir = false;
-       const char *s_dir;
+       const char *s_dir_name = NULL;
 
        static struct option long_options[] = {
                {"verbose", no_argument,       &i_verbose_flag__,  1},
@@ -274,7 +326,7 @@ int main(int argc, char *argv[])
        };
 
        while((c = getopt_long(argc, argv,
-                              "f:d:hav",
+                              "f:d:hv",
                               long_options,
                               &i_option_index)) != -1) {
                switch(c) {
@@ -287,12 +339,12 @@ int main(int argc, char *argv[])
                        return 0;
                case 'f':
                        b_load_from_file = true;
-                       s_file = optarg;
+                       s_file_name = optarg;
                        break;
 
                case 'd':
-                       b_load_from_dir = false;
-                       s_dir = optarg;
+                       b_load_from_dir = true;
+                       s_dir_name = optarg;
                        break;
 
                case 'h':
@@ -324,18 +376,11 @@ int main(int argc, char *argv[])
                return 0;
        }
 
-
-       if(b_load_from_dir) load_from_dir(s_dir);
-
-       if(b_load_from_file) {
-               // TODO: Call the function that loads the permission from a file.
-       }
-
-       // By default we load from API_FEATURES_DIR
-       load_from_dir(API_FEATURES_DIR);
+       // Run task
+       if(b_load_from_dir) load_from_dir(s_dir_name);
+       if(b_load_from_file) load_from_file(s_file_name);
+       if(!b_load_from_dir &&
+           !b_load_from_file) load_from_dir(API_FEATURES_DIR);
 
        return 0;
-
 }
-
-