src/tdm_config.c

   1 /**************************************************************************
   2  *
   3  * libtdm
   4  *
   5  * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   6  *
   7  * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
   8  *          JinYoung Jeon <jy0.jeon@samsung.com>,
   9  *          Taeheon Kim <th908.kim@samsung.com>,
  10  *          YoungJun Cho <yj44.cho@samsung.com>,
  11  *          SooChan Lim <sc1.lim@samsung.com>,
  12  *          Boram Park <sc1.lim@samsung.com>
  13  *
  14  * Permission is hereby granted, free of charge, to any person obtaining a
  15  * copy of this software and associated documentation files (the
  16  * "Software"), to deal in the Software without restriction, including
  17  * without limitation the rights to use, copy, modify, merge, publish,
  18  * distribute, sub license, and/or sell copies of the Software, and to
  19  * permit persons to whom the Software is furnished to do so, subject to
  20  * the following conditions:
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  27  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  29  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  30  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  31  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  32  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33  *
  34 **************************************************************************/
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include <iniparser.h>
  41
  42 #include "tdm_log.h"
  43 #include "tdm_macro.h"
  44 #include "tdm_list.h"
  45 #include "tdm.h"
  46 #include "tdm_private.h"
  47 #include "tdm_config.h"
  48
  49 #define TDM_CONFIG_FILENAME "tdm.ini"
  50 #define TDM_CONFIG_GENERAL_SECTION "general"
  51
  52 static pthread_mutex_t g_dic_lock = PTHREAD_MUTEX_INITIALIZER;
  53 static dictionary *g_dic = NULL;
  54 static int init_dic = 0;
  55
  56 static int
  57 _tdm_config_check_file_owner(const char *filepath)
  58 {
  59         struct stat sb;
  60
  61         if (stat(filepath, &sb) < 0) {
  62                 TDM_WRN("%s: %m", filepath);
  63                 return -1;
  64         }
  65
  66         if (sb.st_uid != getuid()) {
  67                 TDM_WRN("'%s': not owned by %u", filepath, getuid());
  68                 return -1;
  69         }
  70
  71         return 0;
  72 }
  73
  74 static dictionary *
  75 _tdm_config_load_file(const char *dir, const char *filename)
  76 {
  77         char filepath[TDM_PATH_LEN];
  78         dictionary *dic;
  79
  80         snprintf(filepath, sizeof filepath, "%s/%s", dir, filename);
  81
  82         if (_tdm_config_check_file_owner(filepath) < 0)
  83                 return NULL;
  84
  85         dic = iniparser_load(filepath);
  86         TDM_RETURN_VAL_IF_FAIL(dic != NULL, NULL);
  87
  88         if (!iniparser_find_entry(dic, TDM_CONFIG_GENERAL_SECTION)) {
  89                 TDM_ERR("no '%s' section: '%s'", TDM_CONFIG_GENERAL_SECTION, filepath);
  90                 iniparser_freedict(dic);
  91                 return NULL;
  92         }
  93
  94         TDM_INFO("opened successed: '%s'", filepath);
  95
  96         return dic;
  97 }
  98
  99 static void
 100 _tdm_config_check_logs(void)
 101 {
 102         const char *path;
 103         int level;
 104
 105         pthread_mutex_unlock(&g_dic_lock);
 106
 107         level = tdm_config_get_int(TDM_CONFIG_KEY_DEBUG_LOG_LEVEL, 3);
 108         tdm_log_set_debug_level(level);
 109
 110         level = tdm_config_get_int(TDM_CONFIG_KEY_DEBUG_ASSERT_LEVEL, 0);
 111         tdm_log_set_assert_level(level);
 112
 113         /* if TDM_CONFIG_KEY_DEBUG_LOG_PATH is setted, TDM_CONFIG_KEY_DEBUG_DLOG will be ignored. */
 114         path = tdm_config_get_string(TDM_CONFIG_KEY_DEBUG_LOG_PATH, NULL);
 115         if (path) {
 116                 tdm_log_enable_dlog(0);
 117                 tdm_log_set_path(path);
 118         } else {
 119                 int dlog = tdm_config_get_int(TDM_CONFIG_KEY_DEBUG_DLOG, 1);
 120                 tdm_log_enable_dlog(dlog);
 121         }
 122
 123         pthread_mutex_lock(&g_dic_lock);
 124 }
 125
 126 static void
 127 _tdm_config_check_init(void)
 128 {
 129         if (init_dic)
 130                 return;
 131
 132         init_dic = 1;
 133
 134         g_dic = _tdm_config_load_file(TDM_DATA_PATH, TDM_CONFIG_FILENAME);
 135
 136         _tdm_config_check_logs();
 137
 138         TDM_INFO("tdm config init %s (%p)", (g_dic) ? "successed" : "failed", g_dic);
 139 }
 140
 141 INTERN void
 142 tdm_config_deinit(void)
 143 {
 144         pthread_mutex_lock(&g_dic_lock);
 145
 146         if (!g_dic) {
 147                 pthread_mutex_unlock(&g_dic_lock);
 148                 return;
 149         }
 150
 151         iniparser_freedict(g_dic);
 152         g_dic = NULL;
 153         init_dic = 0;
 154
 155         TDM_INFO("tdm config deinit done");
 156
 157         pthread_mutex_unlock(&g_dic_lock);
 158 }
 159
 160 static const char*
 161 _tdm_config_get_string_internal(dictionary *dic, const char *key, const char *default_value)
 162 {
 163         char *temp = NULL;
 164         const char *result;
 165
 166         if (default_value) {
 167                 temp = strdup(default_value);
 168                 if (!temp) {
 169                         TDM_ERR("strdup failed: %m");
 170                         return default_value;
 171                 }
 172         }
 173
 174         result = (const char *)iniparser_getstring(dic, key, temp);
 175         if (!result || strlen(result) == 0) {
 176                 free(temp);
 177                 return default_value;
 178         }
 179
 180         free(temp);
 181
 182         return result;
 183 }
 184
 185 EXTERN int
 186 tdm_config_get_int(const char *key, int default_value)
 187 {
 188         const char *result;
 189         int value;
 190
 191         TDM_RETURN_VAL_IF_FAIL(key != NULL, default_value);
 192
 193         pthread_mutex_lock(&g_dic_lock);
 194
 195         _tdm_config_check_init();
 196         if (!g_dic) {
 197                 TDM_INFO("%s = %d: default", key, default_value);
 198                 pthread_mutex_unlock(&g_dic_lock);
 199                 return default_value;
 200         }
 201
 202         result = _tdm_config_get_string_internal(g_dic, key, NULL);
 203         pthread_mutex_unlock(&g_dic_lock);
 204
 205         if (!result) {
 206                 TDM_INFO("%s = %d: no key", key, default_value);
 207                 return default_value;
 208         }
 209
 210         value = (int)strtol(result, NULL, 0);
 211
 212         TDM_INFO("%s = %d", key, value);
 213
 214         return value;
 215 }
 216
 217 EXTERN const char*
 218 tdm_config_get_string(const char *key, const char *default_value)
 219 {
 220         const char *result;
 221
 222         TDM_RETURN_VAL_IF_FAIL(key != NULL, default_value);
 223
 224         pthread_mutex_lock(&g_dic_lock);
 225
 226         _tdm_config_check_init();
 227         if (!g_dic) {
 228                 TDM_INFO("%s = %s: default", key, default_value);
 229                 pthread_mutex_unlock(&g_dic_lock);
 230                 return default_value;
 231         }
 232
 233         result = _tdm_config_get_string_internal(g_dic, key, default_value);
 234         pthread_mutex_unlock(&g_dic_lock);
 235
 236         TDM_INFO("%s = %s", key, result);
 237
 238         return result;
 239 }
 240
 241 EXTERN tdm_error
 242 tdm_config_set_int(const char *key, int value)
 243 {
 244         char temp[TDM_NAME_LEN];
 245         int ret;
 246
 247         TDM_RETURN_VAL_IF_FAIL(key != NULL, TDM_ERROR_INVALID_PARAMETER);
 248
 249         snprintf(temp, sizeof temp, "%d", value);
 250
 251         pthread_mutex_lock(&g_dic_lock);
 252
 253         _tdm_config_check_init();
 254         if (!g_dic) {
 255                 TDM_INFO("%s = %d set failed", key, value);
 256                 pthread_mutex_unlock(&g_dic_lock);
 257                 return TDM_ERROR_BAD_REQUEST;
 258         }
 259
 260         ret = iniparser_set(g_dic, key, (const char*)temp);
 261
 262         pthread_mutex_unlock(&g_dic_lock);
 263
 264         TDM_RETURN_VAL_IF_FAIL(ret == 0, TDM_ERROR_OPERATION_FAILED);
 265
 266         TDM_INFO("%s = %d set done", key, value);
 267
 268         return TDM_ERROR_NONE;
 269 }
 270
 271 EXTERN tdm_error
 272 tdm_config_set_string(const char *key, const char *value)
 273 {
 274         int ret;
 275
 276         TDM_RETURN_VAL_IF_FAIL(key != NULL, TDM_ERROR_INVALID_PARAMETER);
 277
 278         pthread_mutex_lock(&g_dic_lock);
 279
 280         _tdm_config_check_init();
 281         if (!g_dic) {
 282                 TDM_INFO("%s = %s set failed", key, value);
 283                 pthread_mutex_unlock(&g_dic_lock);
 284                 return TDM_ERROR_BAD_REQUEST;
 285         }
 286
 287         ret = iniparser_set(g_dic, key, value);
 288
 289         pthread_mutex_unlock(&g_dic_lock);
 290
 291         TDM_RETURN_VAL_IF_FAIL(ret == 0, TDM_ERROR_OPERATION_FAILED);
 292
 293         TDM_INFO("%s = %s set done", key, value);
 294
 295         return TDM_ERROR_NONE;
 296 }