src/utils/setting.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include "setting.h"
  21 #include "util.h"
  22 #include "log.h"
  23
  24 typedef struct {
  25         const char *key;
  26         union {
  27                 GSList *string_list;
  28                 int size;
  29                 int *size_list;
  30         } data;
  31 } netconfig_setting_data_s;
  32
  33 typedef enum {
  34         SETTING_TYPE_LAST_POWER = 0,
  35         SETTING_TYPE_WIFI_OFF_BY_AIRPLANE,
  36         SETTING_TYPE_WIFI_OFF_BY_RESTRICTED,
  37         SETTING_TYPE_WIFI_OFF_BY_EMERGENCY,
  38
  39         // Extension data for socket buffer size. This might be used on Robot profile only.
  40         SETTING_TYPE_READ_BUFFER_SIZE_DEFAULT,
  41         SETTING_TYPE_READ_BUFFER_SIZE_MAX,
  42         SETTING_TYPE_WRITE_BUFFER_SIZE_DEFAULT,
  43         SETTING_TYPE_WRITE_BUFFER_SIZE_MAX,
  44         SETTING_TYPE_IPV4_UDP_BUFFER_SIZE,
  45 } netconfig_setting_type_e;
  46
  47 netconfig_setting_data_s netconfig_setting_data[] = {
  48         { "LastPoweredInterfaces", {NULL} },
  49         { "WifiOffByAirplaneInterfaces", {NULL} },
  50         { "WifiOffByRestrictedInterfaces", {NULL} },
  51         { "WifiOffByEmergencyInterfaces", {NULL} },
  52
  53         // Extension data.
  54         { "ReadBufferSizeDefault", {0} },
  55         { "ReadBufferSizeMax", {0} },
  56         { "WriteBufferSizeDefault", {0} },
  57         { "WriteBufferSizeMax", {0} },
  58         { "IPv4UdpBufferSize", {NULL} },
  59 };
  60
  61 void netconfig_setting_init(void)
  62 {
  63         netconfig_setting_load();
  64
  65         INFO("setting is initialized");
  66
  67         return;
  68 }
  69
  70 void netconfig_setting_deinit(void)
  71 {
  72         int i, size;
  73
  74         netconfig_setting_save();
  75
  76         size = SETTING_TYPE_WIFI_OFF_BY_EMERGENCY;
  77         for (i = 0; i <= size; i++)
  78                 g_slist_free_full(netconfig_setting_data[i].data.string_list, g_free);
  79
  80         g_free(netconfig_setting_data[SETTING_TYPE_IPV4_UDP_BUFFER_SIZE].data.size_list);
  81
  82         INFO("setting is deinitialized");
  83
  84         return;
  85 }
  86
  87 static void __setting_set_string_list(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
  88 {
  89         GString *string_str = NULL;
  90         char **string_list = NULL;
  91         GSList *list = NULL;
  92         guint length;
  93
  94         string_str = g_string_new(NULL);
  95         if (string_str) {
  96                 list = netconfig_setting_data[type].data.string_list;
  97                 for (; list; list = list->next) {
  98                         if (string_str->len > 0)
  99                                 g_string_append_printf(string_str, " %s", (char *)list->data);
 100                         else
 101                                 g_string_append(string_str, list->data);
 102                 }
 103
 104                 if (string_str->len > 0) {
 105                         string_list = g_strsplit_set(string_str->str, " ", 0);
 106                         length = g_strv_length(string_list);
 107                         g_key_file_set_string_list(keyfile, group,
 108                                 netconfig_setting_data[type].key,
 109                                 (const gchar **)string_list, length);
 110                 } else {
 111                         g_key_file_remove_key(keyfile, group,
 112                                 netconfig_setting_data[type].key, NULL);
 113                 }
 114
 115                 g_strfreev(string_list);
 116                 g_string_free(string_str, TRUE);
 117         }
 118 }
 119
 120 static void __setting_get_string_list(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
 121 {
 122         char **string_list = NULL;
 123         gsize length;
 124         int i;
 125
 126         INFO("Key [%s]", netconfig_setting_data[type].key);
 127
 128         string_list = g_key_file_get_string_list(keyfile, group,
 129                                         netconfig_setting_data[type].key, &length, NULL);
 130         if (!string_list) {
 131                 ERR("%d key cannot be found from %s.", type, group);
 132                 return;
 133         }
 134
 135         if (length != 0) {
 136                 for (i = 0; string_list[i]; i++) {
 137                         netconfig_setting_data[type].data.string_list = g_slist_append(
 138                                 netconfig_setting_data[type].data.string_list,
 139                                 g_strdup(string_list[i]));
 140
 141                         INFO("%s", string_list[i]);
 142                 }
 143         }
 144
 145         g_strfreev(string_list);
 146 }
 147
 148 static void __setting_get_integer(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
 149 {
 150         int value;
 151         GError *error = NULL;
 152
 153         INFO("Key [%s]", netconfig_setting_data[type].key);
 154         value = g_key_file_get_integer(keyfile, group, netconfig_setting_data[type].key, &error);
 155         if (error) {
 156                 ERR("Failed to get integer value from keyfile. %s", error->message);
 157                 return;
 158         }
 159
 160         netconfig_setting_data[type].data.size = value;
 161 }
 162
 163 static void __setting_get_integer_list(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
 164 {
 165         int *value_list = NULL;
 166         gsize length;
 167         GError *error = NULL;
 168
 169         INFO("Key [%s]", netconfig_setting_data[type].key);
 170         value_list = g_key_file_get_integer_list(keyfile, group,
 171                         netconfig_setting_data[type].key, &length, &error);
 172         if (error || length != 3) {
 173                 ERR("Failed to get integer value from keyfile. %s",
 174                                 error ? error->message : "length isn't 3.");
 175                 return;
 176         }
 177
 178         netconfig_setting_data[type].data.size_list = value_list;
 179 }
 180
 181 int netconfig_setting_save(void)
 182 {
 183         GKeyFile *keyfile = NULL;
 184
 185         INFO("Save setting [%s]", NETCONFIG_SETTINGS_PATH);
 186
 187         keyfile = netconfig_keyfile_load(NETCONFIG_SETTINGS_PATH);
 188         if (keyfile == NULL) {
 189                 ERR("Fail to get settings keyfile");
 190                 return -EIO;
 191         }
 192
 193         __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME, SETTING_TYPE_LAST_POWER);
 194         __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 195                         SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
 196         __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 197                         SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
 198         __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 199                         SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
 200
 201         netconfig_keyfile_save(keyfile, NETCONFIG_SETTINGS_PATH);
 202
 203         g_key_file_free(keyfile);
 204         return 0;
 205 }
 206
 207 int netconfig_setting_load(void)
 208 {
 209         GKeyFile *keyfile = NULL;
 210
 211         INFO("Load setting [%s]", NETCONFIG_SETTINGS_PATH);
 212
 213         keyfile = netconfig_keyfile_load(NETCONFIG_SETTINGS_PATH);
 214         if (keyfile == NULL) {
 215                 ERR("Fail to get settings keyfile");
 216                 return -EIO;
 217         }
 218
 219         __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME, SETTING_TYPE_LAST_POWER);
 220         __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 221                         SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
 222         __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 223                         SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
 224         __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 225                         SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
 226
 227         __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
 228                         SETTING_TYPE_READ_BUFFER_SIZE_DEFAULT);
 229         __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
 230                         SETTING_TYPE_READ_BUFFER_SIZE_MAX);
 231         __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
 232                         SETTING_TYPE_WRITE_BUFFER_SIZE_DEFAULT);
 233         __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
 234                         SETTING_TYPE_WRITE_BUFFER_SIZE_MAX);
 235
 236         __setting_get_integer_list(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
 237                         SETTING_TYPE_IPV4_UDP_BUFFER_SIZE);
 238
 239         return 0;
 240 }
 241
 242 void netconfig_setting_update_interface_for_last_powered(const char *interface_name,
 243                 bool mode)
 244 {
 245         GSList *list = netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list;
 246         bool find = FALSE;
 247
 248         for ( ; list; list = list->next) {
 249                 const char *ifname = list->data;
 250                 if (g_strcmp0(ifname, interface_name) == 0) {
 251                         if (mode == FALSE)
 252                                 netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list = g_slist_remove(
 253                                         netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list, ifname);
 254
 255                         find = TRUE;
 256                         break;
 257                 }
 258         }
 259
 260         if (mode == TRUE && find == FALSE)
 261                 netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list = g_slist_append(
 262                         netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list, g_strdup(interface_name));
 263
 264         netconfig_setting_save();
 265 }
 266
 267 GSList *netconfig_setting_get_interfaces_for_last_powered(void)
 268 {
 269         return netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list;
 270 }
 271
 272 void netconfig_setting_update_interface_off_for_airplane(const char *interface_name,
 273                 bool mode)
 274 {
 275         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list;
 276         bool find = FALSE;
 277
 278         for ( ; list; list = list->next) {
 279                 const char *ifname = list->data;
 280                 if (g_strcmp0(ifname, interface_name) == 0) {
 281                         if (mode == FALSE)
 282                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list = g_slist_remove(
 283                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list, ifname);
 284
 285                         find = TRUE;
 286                         break;
 287                 }
 288         }
 289
 290         if (mode == TRUE && find == FALSE)
 291                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list = g_slist_append(
 292                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list, g_strdup(interface_name));
 293
 294         netconfig_setting_save();
 295 }
 296
 297 GSList *netconfig_setting_get_interfaces_off_by_airplane(void)
 298 {
 299         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list;
 300 }
 301
 302 void netconfig_setting_update_interface_off_for_restricted(const char *interface_name,
 303                 bool mode)
 304 {
 305         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list;
 306         bool find = FALSE;
 307
 308         for ( ; list; list = list->next) {
 309                 const char *ifname = list->data;
 310                 if (g_strcmp0(ifname, interface_name) == 0) {
 311                         if (mode == FALSE)
 312                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list = g_slist_remove(
 313                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list, ifname);
 314
 315                         find = TRUE;
 316                         break;
 317                 }
 318         }
 319
 320         if (mode == TRUE && find == FALSE)
 321                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list = g_slist_append(
 322                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list, g_strdup(interface_name));
 323
 324         netconfig_setting_save();
 325 }
 326
 327 GSList *netconfig_setting_get_interfaces_off_by_restricted(void)
 328 {
 329         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list;
 330 }
 331
 332 void netconfig_setting_update_interface_off_for_emergency(const char *interface_name,
 333                 bool mode)
 334 {
 335         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list;
 336         bool find = FALSE;
 337
 338         for ( ; list; list = list->next) {
 339                 const char *ifname = list->data;
 340                 if (g_strcmp0(ifname, interface_name) == 0) {
 341                         if (mode == FALSE)
 342                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list
 343                                         = g_slist_remove(
 344                                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list,
 345                                                 ifname);
 346
 347                         find = TRUE;
 348                         break;
 349                 }
 350         }
 351
 352         if (mode == TRUE && find == FALSE)
 353                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list
 354                         = g_slist_append(
 355                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list,
 356                                 g_strdup(interface_name));
 357
 358         netconfig_setting_save();
 359 }
 360
 361 GSList *netconfig_setting_get_interfaces_off_by_emergency(void)
 362 {
 363         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list;
 364 }
 365
 366 int netconfig_setting_get_read_buffer_size_default(void)
 367 {
 368         return netconfig_setting_data[SETTING_TYPE_READ_BUFFER_SIZE_DEFAULT].data.size;
 369 }
 370
 371 int netconfig_setting_get_read_buffer_size_max(void)
 372 {
 373         return netconfig_setting_data[SETTING_TYPE_READ_BUFFER_SIZE_MAX].data.size;
 374 }
 375
 376 int netconfig_setting_get_write_buffer_size_default(void)
 377 {
 378         return netconfig_setting_data[SETTING_TYPE_WRITE_BUFFER_SIZE_DEFAULT].data.size;
 379 }
 380
 381 int netconfig_setting_get_write_buffer_size_max(void)
 382 {
 383         return netconfig_setting_data[SETTING_TYPE_WRITE_BUFFER_SIZE_MAX].data.size;
 384 }
 385
 386 int *netconfig_setting_get_ipv4_udp_buffer_size(void)
 387 {
 388         return netconfig_setting_data[SETTING_TYPE_IPV4_UDP_BUFFER_SIZE].data.size_list;
 389 }