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 enum {
  25         SETTING_TYPE_LAST_POWER,
  26         SETTING_TYPE_WIFI_OFF_BY_AIRPLANE,
  27         SETTING_TYPE_WIFI_OFF_BY_RESTRICTED,
  28         SETTING_TYPE_WIFI_OFF_BY_EMERGENCY,
  29 } netconfig_setting_type_e;
  30
  31 typedef struct {
  32         const char *key;
  33         GSList *string_list;
  34 } netconfig_setting_data_s;
  35
  36 netconfig_setting_data_s netconfig_setting_data[] = {
  37         { "LastPoweredInterfaces", NULL },
  38         { "WifiOffByAirplaneInterfaces", NULL },
  39         { "WifiOffByRestrictedInterfaces", NULL },
  40         { "WifiOffByEmergencyInterfaces", NULL },
  41 };
  42
  43 void netconfig_setting_init(void)
  44 {
  45         netconfig_setting_load();
  46
  47         INFO("setting is initialized");
  48
  49         return;
  50 }
  51
  52 void netconfig_setting_deinit(void)
  53 {
  54         int i, size;
  55
  56         netconfig_setting_save();
  57
  58         size = ARRAY_SIZE(netconfig_setting_data);
  59         for (i = 0; i < size; i++)
  60                 g_slist_free_full(netconfig_setting_data[i].string_list, g_free);
  61
  62         INFO("setting is deinitialized");
  63
  64         return;
  65 }
  66
  67 static void __setting_set_string_list(GKeyFile *keyfile, netconfig_setting_type_e type)
  68 {
  69         GString *string_str = NULL;
  70         char **string_list = NULL;
  71         GSList *list = NULL;
  72         guint length;
  73
  74         string_str = g_string_new(NULL);
  75         if (string_str) {
  76                 list = netconfig_setting_data[type].string_list;
  77                 for (; list; list = list->next) {
  78                         if (string_str->len > 0)
  79                                 g_string_append_printf(string_str, " %s", (char *)list->data);
  80                         else
  81                                 g_string_append(string_str, list->data);
  82                 }
  83
  84                 if (string_str->len > 0) {
  85                         string_list = g_strsplit_set(string_str->str, " ", 0);
  86                         length = g_strv_length(string_list);
  87                         g_key_file_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
  88                                 netconfig_setting_data[type].key,
  89                                 (const gchar **)string_list, length);
  90                 } else {
  91                         g_key_file_remove_key(keyfile, SETTINGS_WIFI_GROUP_NAME,
  92                                 netconfig_setting_data[type].key, NULL);
  93                 }
  94
  95                 g_string_free(string_str, TRUE);
  96         }
  97 }
  98
  99 static void __setting_get_string_list(GKeyFile *keyfile, netconfig_setting_type_e type)
 100 {
 101         char **string_list = NULL;
 102         gsize length;
 103         int i;
 104
 105         INFO("Key [%s]", netconfig_setting_data[type].key);
 106
 107         string_list = g_key_file_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 108                                         netconfig_setting_data[type].key, &length, NULL);
 109         if (string_list && length != 0) {
 110                 for (i = 0; string_list[i]; i++) {
 111                         netconfig_setting_data[type].string_list = g_slist_append(
 112                                 netconfig_setting_data[type].string_list,
 113                                 g_strdup(string_list[i]));
 114
 115                         INFO("%s", string_list[i]);
 116                 }
 117         }
 118
 119         g_strfreev(string_list);
 120 }
 121
 122 int netconfig_setting_save(void)
 123 {
 124         GKeyFile *keyfile = NULL;
 125
 126         INFO("Save setting [%s]", NETCONFIG_SETTINGS_PATH);
 127
 128         keyfile = netconfig_keyfile_load(NETCONFIG_SETTINGS_PATH);
 129         if (keyfile == NULL) {
 130                 ERR("Fail to get settings keyfile");
 131                 return -EIO;
 132         }
 133
 134         __setting_set_string_list(keyfile, SETTING_TYPE_LAST_POWER);
 135         __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
 136         __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
 137         __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
 138
 139         netconfig_keyfile_save(keyfile, NETCONFIG_SETTINGS_PATH);
 140
 141         g_key_file_free(keyfile);
 142         return 0;
 143 }
 144
 145 int netconfig_setting_load(void)
 146 {
 147         GKeyFile *keyfile = NULL;
 148
 149         INFO("Load setting [%s]", NETCONFIG_SETTINGS_PATH);
 150
 151         keyfile = netconfig_keyfile_load(NETCONFIG_SETTINGS_PATH);
 152         if (keyfile == NULL) {
 153                 ERR("Fail to get settings keyfile");
 154                 return -EIO;
 155         }
 156
 157         __setting_get_string_list(keyfile, SETTING_TYPE_LAST_POWER);
 158         __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
 159         __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
 160         __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
 161
 162         return 0;
 163 }
 164
 165 void netconfig_setting_update_interface_for_last_powered(const char *interface_name,
 166                 bool mode)
 167 {
 168         GSList *list = netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list;
 169         bool find = FALSE;
 170
 171         for ( ; list; list = list->next) {
 172                 const char *ifname = list->data;
 173                 if (g_strcmp0(ifname, interface_name) == 0) {
 174                         if (mode == FALSE)
 175                                 netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list = g_slist_remove(
 176                                         netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list, ifname);
 177
 178                         find = TRUE;
 179                         break;
 180                 }
 181         }
 182
 183         if (mode == TRUE && find == FALSE)
 184                 netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list = g_slist_append(
 185                         netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list, g_strdup(interface_name));
 186
 187         netconfig_setting_save();
 188 }
 189
 190 GSList *netconfig_setting_get_interfaces_for_last_powered(void)
 191 {
 192         return netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list;
 193 }
 194
 195 void netconfig_setting_update_interface_off_for_airplane(const char *interface_name,
 196                 bool mode)
 197 {
 198         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list;
 199         bool find = FALSE;
 200
 201         for ( ; list; list = list->next) {
 202                 const char *ifname = list->data;
 203                 if (g_strcmp0(ifname, interface_name) == 0) {
 204                         if (mode == FALSE)
 205                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list = g_slist_remove(
 206                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list, ifname);
 207
 208                         find = TRUE;
 209                         break;
 210                 }
 211         }
 212
 213         if (mode == TRUE && find == FALSE)
 214                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list = g_slist_append(
 215                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list, g_strdup(interface_name));
 216
 217         netconfig_setting_save();
 218 }
 219
 220 GSList *netconfig_setting_get_interfaces_off_by_airplane(void)
 221 {
 222         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list;
 223 }
 224
 225 void netconfig_setting_update_interface_off_for_restricted(const char *interface_name,
 226                 bool mode)
 227 {
 228         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list;
 229         bool find = FALSE;
 230
 231         for ( ; list; list = list->next) {
 232                 const char *ifname = list->data;
 233                 if (g_strcmp0(ifname, interface_name) == 0) {
 234                         if (mode == FALSE)
 235                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list = g_slist_remove(
 236                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list, ifname);
 237
 238                         find = TRUE;
 239                         break;
 240                 }
 241         }
 242
 243         if (mode == TRUE && find == FALSE)
 244                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list = g_slist_append(
 245                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list, g_strdup(interface_name));
 246
 247         netconfig_setting_save();
 248 }
 249
 250 GSList *netconfig_setting_get_interfaces_off_by_restricted(void)
 251 {
 252         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list;
 253 }
 254
 255 void netconfig_setting_update_interface_off_for_emergency(const char *interface_name,
 256                 bool mode)
 257 {
 258         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list;
 259         bool find = FALSE;
 260
 261         for ( ; list; list = list->next) {
 262                 const char *ifname = list->data;
 263                 if (g_strcmp0(ifname, interface_name) == 0) {
 264                         if (mode == FALSE)
 265                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list = g_slist_remove(
 266                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list, ifname);
 267
 268                         find = TRUE;
 269                         break;
 270                 }
 271         }
 272
 273         if (mode == TRUE && find == FALSE)
 274                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list = g_slist_append(
 275                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list, g_strdup(interface_name));
 276
 277         netconfig_setting_save();
 278 }
 279
 280 GSList *netconfig_setting_get_interfaces_off_by_emergency(void)
 281 {
 282         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list;
 283 }