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_strfreev(string_list);
  96                 g_string_free(string_str, TRUE);
  97         }
  98 }
  99
 100 static void __setting_get_string_list(GKeyFile *keyfile, netconfig_setting_type_e type)
 101 {
 102         char **string_list = NULL;
 103         gsize length;
 104         int i;
 105
 106         INFO("Key [%s]", netconfig_setting_data[type].key);
 107
 108         string_list = g_key_file_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
 109                                         netconfig_setting_data[type].key, &length, NULL);
 110         if (string_list && length != 0) {
 111                 for (i = 0; string_list[i]; i++) {
 112                         netconfig_setting_data[type].string_list = g_slist_append(
 113                                 netconfig_setting_data[type].string_list,
 114                                 g_strdup(string_list[i]));
 115
 116                         INFO("%s", string_list[i]);
 117                 }
 118         }
 119
 120         g_strfreev(string_list);
 121 }
 122
 123 int netconfig_setting_save(void)
 124 {
 125         GKeyFile *keyfile = NULL;
 126
 127         INFO("Save setting [%s]", NETCONFIG_SETTINGS_PATH);
 128
 129         keyfile = netconfig_keyfile_load(NETCONFIG_SETTINGS_PATH);
 130         if (keyfile == NULL) {
 131                 ERR("Fail to get settings keyfile");
 132                 return -EIO;
 133         }
 134
 135         __setting_set_string_list(keyfile, SETTING_TYPE_LAST_POWER);
 136         __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
 137         __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
 138         __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
 139
 140         netconfig_keyfile_save(keyfile, NETCONFIG_SETTINGS_PATH);
 141
 142         g_key_file_free(keyfile);
 143         return 0;
 144 }
 145
 146 int netconfig_setting_load(void)
 147 {
 148         GKeyFile *keyfile = NULL;
 149
 150         INFO("Load setting [%s]", NETCONFIG_SETTINGS_PATH);
 151
 152         keyfile = netconfig_keyfile_load(NETCONFIG_SETTINGS_PATH);
 153         if (keyfile == NULL) {
 154                 ERR("Fail to get settings keyfile");
 155                 return -EIO;
 156         }
 157
 158         __setting_get_string_list(keyfile, SETTING_TYPE_LAST_POWER);
 159         __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
 160         __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
 161         __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
 162
 163         return 0;
 164 }
 165
 166 void netconfig_setting_update_interface_for_last_powered(const char *interface_name,
 167                 bool mode)
 168 {
 169         GSList *list = netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list;
 170         bool find = FALSE;
 171
 172         for ( ; list; list = list->next) {
 173                 const char *ifname = list->data;
 174                 if (g_strcmp0(ifname, interface_name) == 0) {
 175                         if (mode == FALSE)
 176                                 netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list = g_slist_remove(
 177                                         netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list, ifname);
 178
 179                         find = TRUE;
 180                         break;
 181                 }
 182         }
 183
 184         if (mode == TRUE && find == FALSE)
 185                 netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list = g_slist_append(
 186                         netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list, g_strdup(interface_name));
 187
 188         netconfig_setting_save();
 189 }
 190
 191 GSList *netconfig_setting_get_interfaces_for_last_powered(void)
 192 {
 193         return netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list;
 194 }
 195
 196 void netconfig_setting_update_interface_off_for_airplane(const char *interface_name,
 197                 bool mode)
 198 {
 199         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list;
 200         bool find = FALSE;
 201
 202         for ( ; list; list = list->next) {
 203                 const char *ifname = list->data;
 204                 if (g_strcmp0(ifname, interface_name) == 0) {
 205                         if (mode == FALSE)
 206                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list = g_slist_remove(
 207                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list, ifname);
 208
 209                         find = TRUE;
 210                         break;
 211                 }
 212         }
 213
 214         if (mode == TRUE && find == FALSE)
 215                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list = g_slist_append(
 216                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list, g_strdup(interface_name));
 217
 218         netconfig_setting_save();
 219 }
 220
 221 GSList *netconfig_setting_get_interfaces_off_by_airplane(void)
 222 {
 223         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list;
 224 }
 225
 226 void netconfig_setting_update_interface_off_for_restricted(const char *interface_name,
 227                 bool mode)
 228 {
 229         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list;
 230         bool find = FALSE;
 231
 232         for ( ; list; list = list->next) {
 233                 const char *ifname = list->data;
 234                 if (g_strcmp0(ifname, interface_name) == 0) {
 235                         if (mode == FALSE)
 236                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list = g_slist_remove(
 237                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list, ifname);
 238
 239                         find = TRUE;
 240                         break;
 241                 }
 242         }
 243
 244         if (mode == TRUE && find == FALSE)
 245                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list = g_slist_append(
 246                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list, g_strdup(interface_name));
 247
 248         netconfig_setting_save();
 249 }
 250
 251 GSList *netconfig_setting_get_interfaces_off_by_restricted(void)
 252 {
 253         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list;
 254 }
 255
 256 void netconfig_setting_update_interface_off_for_emergency(const char *interface_name,
 257                 bool mode)
 258 {
 259         GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list;
 260         bool find = FALSE;
 261
 262         for ( ; list; list = list->next) {
 263                 const char *ifname = list->data;
 264                 if (g_strcmp0(ifname, interface_name) == 0) {
 265                         if (mode == FALSE)
 266                                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list = g_slist_remove(
 267                                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list, ifname);
 268
 269                         find = TRUE;
 270                         break;
 271                 }
 272         }
 273
 274         if (mode == TRUE && find == FALSE)
 275                 netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list = g_slist_append(
 276                         netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list, g_strdup(interface_name));
 277
 278         netconfig_setting_save();
 279 }
 280
 281 GSList *netconfig_setting_get_interfaces_off_by_emergency(void)
 282 {
 283         return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list;
 284 }