src/agent/download-agent-debug.c

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