src/process_parser.c

   1 /*
   2  * process_parser.c
   3  *
   4  *  Created on: Sep 16, 2010
   5  *      Author: lamikr
   6  */
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <dirent.h>
  11 #include <uci.h>
  12
  13 #include "common.h"
  14 #include "process_parser.h"
  15
  16 t_process_arg_list *parse_command_line_args(char *cmd_line_param) {
  17         char                    *line_pointer;
  18         char                    *start;
  19         int                     len;
  20         t_process_arg_list      *ret_val;
  21
  22         ret_val = NULL;
  23         if (cmd_line_param != NULL) {
  24                 ret_val         = calloc(1, sizeof(t_process_arg_list));
  25                 line_pointer    = cmd_line_param;
  26                 while(*line_pointer != '\0') {
  27                         while((*line_pointer == ' ') ||
  28                               (*line_pointer == '\t')) {
  29                                 line_pointer++;
  30                         }
  31                         if (*line_pointer != '\0') {
  32                                 if (ret_val->arg_arr == NULL) {
  33                                         ret_val->arg_arr        = calloc(1, sizeof(char *));
  34                                 }
  35                                 else {
  36                                         char    **arg_arr;
  37
  38                                         arg_arr = ret_val->arg_arr;
  39                                         arg_arr = realloc(arg_arr, (ret_val->count + 1) * sizeof(char *));
  40                                         ret_val->arg_arr        = arg_arr;
  41                                 }
  42                                 start           = line_pointer;
  43                                 len             = 1;
  44                                 while((*++line_pointer != '\0') &&
  45                                       (*line_pointer != ' ') &&
  46                                       (*line_pointer != '\t')) {
  47                                         len++;
  48                                 }
  49                                 ret_val->arg_arr[ret_val->count]        = strndup(start, len);
  50                                 printf("ret_val[%d] = %s\n", ret_val->count, ret_val->arg_arr[ret_val->count]);
  51                                 ret_val->count                          = ret_val->count + 1;
  52                         }
  53                         else {
  54                                 break;
  55                         }
  56                 }
  57                 // terminate list with null
  58                 ret_val->arg_arr                        = realloc(ret_val->arg_arr, (ret_val->count + 1) * sizeof(char *));
  59                 ret_val->arg_arr[ret_val->count]        = NULL;
  60                 ret_val->count                          = ret_val->count + 1;
  61         }
  62         return ret_val;
  63 }
  64
  65 t_process_info *parse_process_info(struct uci_option *option_param) {
  66         t_process_info  *ret_val;
  67
  68         ret_val = NULL;
  69         if (option_param->type == UCI_TYPE_STRING) {
  70                 ret_val                 = calloc(1, sizeof(t_process_info));
  71                 ret_val->arg_list       = parse_command_line_args(option_param->v.string);
  72         }
  73         return ret_val;
  74 }
  75
  76 int add_process_config(t_process_info_list *list_param, struct uci_option *option_param) {
  77         int             ret_val;
  78         t_process_info  *new_item;
  79
  80         ret_val         = -1;
  81         new_item        = parse_process_info(option_param);
  82         if (new_item != NULL) {
  83                 if (list_param->last_item != NULL) {
  84                         list_param->last_item->next     = new_item;
  85                         list_param->last_item           = new_item;
  86                 }
  87                 else {
  88                         list_param->first_item  = new_item;
  89                         list_param->last_item   = new_item;
  90                 }
  91                 list_param->count       = list_param->count + 1;
  92                 ret_val                 = 0;
  93         }
  94         return ret_val;
  95 }
  96
  97 t_process_info_list *get_process_config_list() {
  98         char                    **config_list;
  99         char                    **config_file;
 100         int                     err_flg;
 101         struct uci_context      *ctx;
 102         struct uci_package      *pkg;
 103         struct uci_section      *section;
 104         struct uci_option       *option;
 105         t_process_info_list     *ret_val;
 106
 107         ret_val = calloc(1, sizeof(t_process_info_list));
 108         ctx     = uci_alloc_context();
 109         if (ctx != NULL) {
 110                 uci_set_confdir(ctx, CONST_SERVICE_DIRECTORY_LOCATION);
 111                 config_list     = NULL;
 112                 err_flg         = uci_list_configs(ctx, &config_list);
 113                 if ((err_flg == UCI_OK) &&
 114                     (config_list != NULL)) {
 115                         for (config_file = config_list; *config_file != NULL; config_file++) {
 116                                 err_flg = uci_load(ctx, *config_file, &pkg);
 117                                 if (err_flg == UCI_OK) {
 118                                         section = uci_lookup_section(ctx, pkg, "service");
 119                                         if (section != NULL) {
 120                                                 option  = uci_lookup_option(ctx, section, "ExecStart");
 121                                                 switch (option->type) {
 122                                                         case UCI_TYPE_STRING:
 123                                                                 printf("config file: %s name: %s, value: %s\n", *config_file, option->e.name, option->v.string);
 124                                                                 add_process_config(ret_val, option);
 125                                                                 break;
 126                                                         default:
 127                                                                 break;
 128                                                 }
 129                                         }
 130                                         //int num_sections = _uci_show_package(*config_file, result);
 131                                         //printf("Queried package: %s -> %d\n", *config_file, num_sections);
 132                                 }
 133                                 uci_unload(ctx, pkg);
 134                         }
 135                         // free config_files
 136 /*
 137                         for (config_file = config_list; *config_file != NULL; config_file++) {
 138                                 free(config_file);
 139                         }
 140 */
 141                         free(config_list);
 142                 }
 143                 else {
 144                         printf("Failed to read service configurations from directory: %s\n", CONST_SERVICE_DIRECTORY_LOCATION);
 145                 }
 146                 uci_free_context(ctx);
 147         }
 148         else {
 149                 printf("Failed to read service configurations from directory: %s\n Memory allocation error.", CONST_SERVICE_DIRECTORY_LOCATION);
 150         }
 151         return ret_val;
 152 }
 153
 154 void release_process_config_arg_list(t_process_arg_list *arg_list_param) {
 155         int     ii;
 156
 157         for (ii = 0; ii < arg_list_param->count; ii++) {
 158                 if (arg_list_param->arg_arr[ii] != NULL) {
 159                         free(arg_list_param->arg_arr[ii]);
 160                         arg_list_param->arg_arr[ii]     = NULL;
 161                 }
 162         }
 163         free(arg_list_param->arg_arr);
 164         arg_list_param->count   = 0;
 165         free(arg_list_param);
 166 }
 167
 168 void release_process_config_list(t_process_info_list *list_param) {
 169         t_process_info          *item;
 170         t_process_info          *next;
 171
 172         if (list_param != NULL) {
 173                 item    = list_param->first_item;
 174                 while (item != NULL) {
 175                         next            = item->next;
 176                         item->next      = NULL;
 177                         release_process_config_arg_list(item->arg_list);
 178                         item->arg_list  = NULL;
 179                         free(item);
 180                         item            = next;
 181                 }
 182                 list_param->first_item  = NULL;
 183                 list_param->last_item   = NULL;
 184                 free(list_param);
 185         }
 186 }