agent/download-agent-debug.c

   1 /*
   2  * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20 #include "download-agent-debug.h"
  21 #include "download-agent-utils.h"
  22
  23 #define STRING_IT(x) #x
  24 #define TURN_ON_LOG(channel) (DALogBitMap |= (0x1<<(channel)))
  25
  26 int DALogBitMap;
  27
  28 char *__get_log_env(void);
  29 char **__parsing_log_env(char *in_log_env);
  30 char *__copying_str(char *source, int length);
  31 char *__get_channel_name_from_enum(da_log_channel channel_enum);
  32
  33 da_result_t init_log_mgr(void) {
  34         da_result_t ret = DA_RESULT_OK;
  35         static da_bool_t did_log_mgr_init = DA_FALSE;
  36         char *log_env = DA_NULL;
  37         char **parsed_log_env = DA_NULL;
  38         char **cur_parsed_log_env = DA_NULL;
  39         int i = 0;
  40
  41         if (did_log_mgr_init)
  42                 return ret;
  43
  44         did_log_mgr_init = DA_TRUE;
  45
  46         log_env = __get_log_env();
  47         if (!log_env) {
  48                 /* If no environment values are found, do behave like all logs are turned on except for Soup log */
  49                 DALogBitMap = ~(0x1 << Soup);
  50                 return ret;
  51         }
  52
  53         TURN_ON_LOG(Default);
  54
  55         parsed_log_env = __parsing_log_env(log_env);
  56         if (parsed_log_env) {
  57                 char *channel_keyward = DA_NULL;
  58                 for (cur_parsed_log_env = parsed_log_env; *cur_parsed_log_env; cur_parsed_log_env++) {
  59                         if (!*cur_parsed_log_env)
  60                                 break;
  61                         for (i = 0; i < DA_LOG_CHANNEL_MAX; i++) {
  62                                 channel_keyward = __get_channel_name_from_enum(i);
  63                                 if (channel_keyward && !strcmp(*cur_parsed_log_env,
  64                                                 channel_keyward)) {
  65                                         TURN_ON_LOG(i);
  66                                         break;
  67                                 }
  68                         }
  69                         free(*cur_parsed_log_env);
  70                 }
  71                 free(parsed_log_env);
  72         }
  73
  74         if (log_env)
  75                 free(log_env);
  76
  77         return ret;
  78 }
  79
  80 char *__get_log_env(void) {
  81         char *log_env = DA_NULL;
  82
  83         /* environment value has higher priority than configure file */
  84         log_env = getenv(DA_DEBUG_ENV_KEY);
  85         if (log_env && strlen(log_env))
  86                 return strdup(log_env);
  87
  88         if (read_data_from_file(DA_DEBUG_CONFIG_FILE_PATH, &log_env))
  89                 return log_env;
  90
  91         return DA_NULL;
  92 }
  93
  94 char **__parsing_log_env(char *in_log_env) {
  95         char **out_parsed_result = DA_NULL;
  96
  97         char **temp_result_array = DA_NULL;
  98         char **cur_temp_result_array = DA_NULL;
  99         int how_many_item = 0;
 100         int how_many_delimeter = 0;
 101
 102         char delimiter = ',';
 103
 104         char *org_str = in_log_env;
 105         char *cur_char = org_str;
 106         char *start = org_str;
 107         char *end = org_str;
 108         int target_len = 0;
 109
 110         if (!org_str)
 111                 return DA_NULL;
 112
 113         /* counting delimiter to know how many items should be memory allocated.
 114          *  This causes two round of loop (counting delimiter and real operation).
 115          *  But I think it is tolerable, because input parameter is from console.
 116          *  And it is also a reason why we should not use fixed length array.
 117          *  Users are hard to input very long environment, but it is possible. */
 118         for (cur_char = org_str; *cur_char; cur_char++) {
 119                 if (*cur_char == delimiter)
 120                         how_many_delimeter++;
 121         }
 122         how_many_item = how_many_delimeter + 1;
 123         temp_result_array = (char**) calloc(1, how_many_item + 1);
 124         if (!(temp_result_array))
 125                 goto ERR;
 126
 127         cur_temp_result_array = temp_result_array;
 128         cur_char = org_str;
 129         while (1) {
 130                 if (*cur_char == delimiter) {
 131                         end = cur_char;
 132                         target_len = (int) (end - start);
 133                         *cur_temp_result_array++ = __copying_str(start,
 134                                         target_len);
 135                         start = ++cur_char;
 136                         continue;
 137                 } else if (!(*cur_char)) {
 138                         end = cur_char;
 139                         target_len = (int) (end - start);
 140                         *cur_temp_result_array++ = __copying_str(start,
 141                                         target_len);
 142                         *cur_temp_result_array = DA_NULL;
 143                         break;
 144                 } else {
 145                         cur_char++;
 146                 }
 147         }
 148         out_parsed_result = temp_result_array;
 149 ERR:
 150         return out_parsed_result;
 151 }
 152
 153 char *__copying_str(char *source, int length) {
 154         char *copied_str = DA_NULL;
 155         char *cur_pos = DA_NULL;
 156         char white_space = ' ';
 157         char end_of_line = 10; /* ASCII for LF */
 158         int i = 0;
 159
 160         if (!source || !(length > 0))
 161                 return DA_NULL;
 162
 163         copied_str = (char*) calloc(1, length + 1);
 164         if (copied_str) {
 165                 cur_pos = copied_str;
 166                 for (i = 0; i < length; i++) {
 167                         if ((source[i] != white_space) && (source[i]
 168                                         != end_of_line))
 169                                 *cur_pos++ = source[i];
 170                 }
 171         }
 172
 173         return copied_str;
 174 }
 175
 176 char *__get_channel_name_from_enum(da_log_channel channel_enum) {
 177         switch (channel_enum) {
 178         case Soup:
 179                 return STRING_IT(Soup);
 180         case HTTPManager:
 181                 return STRING_IT(HTTPManager);
 182         case FileManager:
 183                 return STRING_IT(FileManager);
 184         case DRMManager:
 185                 return STRING_IT(DRMManager);
 186         case DownloadManager:
 187                 return STRING_IT(DownloadManager);
 188         case ClientNoti:
 189                 return STRING_IT(ClientNoti);
 190         case HTTPMessageHandler:
 191                 return STRING_IT(HTTPMessageHandler);
 192         case Encoding:
 193                 return STRING_IT(Encoding);
 194         case QueueManager:
 195                 return STRING_IT(QueueManager);
 196         case Parsing:
 197                 return STRING_IT(Parsing);
 198         case Thread:
 199                 return STRING_IT(Thread);
 200         case Default:
 201                 return STRING_IT(Default);
 202         default:
 203                 return DA_NULL;
 204         }
 205 }