Adjust socket buffer size for robot profile

Change-Id: I35857cac9d8a6ae9f06308749c2e303027f044c6

diff --git a/include/setting.h b/include/setting.h
index 120370b4efdd87e958a120db1eebca7c05d98048..c5081ffb23fe72d7bc5cdb5ebe499c3dc5713d16 100755 (executable)
--- a/include/setting.h
+++ b/include/setting.h
@@ -29,6 +29,7 @@ extern "C" {
 
 #define NETCONFIG_SETTINGS_PATH         "/var/lib/net-config/settings"
 #define SETTINGS_WIFI_GROUP_NAME        "Wifi"
+#define SETTINGS_EXTENSION_GROUP_NAME  "Extension"
 
 void netconfig_setting_init(void);
 void netconfig_setting_deinit(void);
@@ -52,6 +53,12 @@ void netconfig_setting_update_interface_off_for_emergency(const char *interface_
                bool mode);
 GSList *netconfig_setting_get_interfaces_off_by_emergency(void);
 
+int netconfig_setting_get_read_buffer_size_default(void);
+int netconfig_setting_get_read_buffer_size_max(void);
+int netconfig_setting_get_write_buffer_size_default(void);
+int netconfig_setting_get_write_buffer_size_max(void);
+int *netconfig_setting_get_ipv4_udp_buffer_size(void);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/packaging/net-config.spec b/packaging/net-config.spec
index f35fa4f1eee85d61379e1bf0ad5207c1f7a6df0a..6de9d9ff2966638dce2838ea95f836cae777f43f 100755 (executable)
--- a/packaging/net-config.spec
+++ b/packaging/net-config.spec
@@ -32,6 +32,7 @@ Provides:       %{name}-profile_common = %{version}-%{release}
 Provides:       %{name}-profile_mobile = %{version}-%{release}
 Provides:       %{name}-profile_wearable = %{version}-%{release}
 Provides:       %{name}-profile_ivi = %{version}-%{release}
+Provides:       %{name}-profile_robot = %{version}-%{release}
 
 %description
 TIZEN Network Configuration service
@@ -48,6 +49,12 @@ Requires:       %{name} = %{version}-%{release}
 %description profile_wearable
 TIZEN Network Configuration service extension for Tizen wearable profile.
 
+%package profile_robot
+Summary:        net-config extension for robot profile
+Requires:       %{name} = %{version}-%{release}
+%description profile_robot
+TIZEN Network Configuration service extension for Tizen robot profile.
+
 %package plugin-headed
 Summary:        net-config extension for headed profile
 BuildRequires: pkgconfig(bundle)
@@ -134,6 +141,7 @@ make %{?_smp_mflags}
 #Settings file
 mkdir -p %{buildroot}/%{_localstatedir}/lib/net-config
 cp resources/var/lib/net-config/settings %{buildroot}/%{_localstatedir}/lib/net-config/settings
+cp resources/var/lib/net-config/settings-robot %{buildroot}/%{_localstatedir}/lib/net-config/settings-robot
 
 #Systemd service file
 mkdir -p %{buildroot}%{_unitdir}
@@ -231,6 +239,14 @@ mv net-config.wearable net-config
 %attr(500,network_fw,network_fw) %{_bindir}/net-config.wearable
 %attr(644,network_fw,network_fw) /usr/system/RestoreDir/softreset/network_softreset.sh
 
+#### robot profile ####
+%post profile_robot
+mv /var/lib/net-config/settings-robot /var/lib/net-config/settings
+
+%files profile_robot
+%manifest net-config.manifest
+%attr(644,root,root) /var/lib/net-config/settings-robot
+
 #### plugin ####
 %files plugin-headed
 %manifest net-config.manifest
@@ -251,4 +267,3 @@ mv net-config.wearable net-config
 %files haltests
 %manifest net-config.manifest
 %{_bindir}/hal/*haltests
-

diff --git a/resources/var/lib/net-config/settings-robot b/resources/var/lib/net-config/settings-robot
new file mode 100644 (file)
index 0000000..c62fc62
--- /dev/null
+++ b/resources/var/lib/net-config/settings-robot
@@ -0,0 +1,12 @@
+[Wifi]
+LastPoweredInterfaces=
+WifiOffByAirplaneInterfaces=
+WifiOffByRestrictedInterfaces=
+WifiOffByEmergencyInterfaces=
+
+[Extension]
+ReadBufferSizeDefault=30000000
+ReadBufferSizeMax=30000000
+WriteBufferSizeDefault=425984
+WriteBufferSizeMax=425984
+IPv4UdpBufferSize=181599;242134;363198

diff --git a/src/network-state.c b/src/network-state.c
index eed90e3cc9f718624afeaa0df199715f1a28fed3..f807231fa5bac0d40b996989e2764b33d336c25c 100755 (executable)
--- a/src/network-state.c
+++ b/src/network-state.c
@@ -21,6 +21,7 @@
 #include <vconf-keys.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <net/if.h>
 #include <arpa/inet.h>
@@ -29,6 +30,7 @@
 
 #include "log.h"
 #include "util.h"
+#include "setting.h"
 #include "netdbus.h"
 #include "neterror.h"
 #include "emulator.h"
@@ -73,10 +75,13 @@
 
 #define NET_TCP_BUFFERSIZE_WIFID_WMEM_MAX      "2097152"
 
-#define NET_PROC_SYS_NET_IPV4_TCP_RMEM         "/proc/sys/net/ipv4/tcp_rmem"
-#define NET_PROC_SYS_NET_IPv4_TCP_WMEM         "/proc/sys/net/ipv4/tcp_wmem"
-#define NET_PROC_SYS_NET_CORE_RMEM_MAX         "/proc/sys/net/core/rmem_max"
-#define NET_PROC_SYS_NET_CORE_WMEM_MAX         "/proc/sys/net/core/wmem_max"
+#define NET_PROC_SYS_NET_IPV4_TCP_RMEM                 "/proc/sys/net/ipv4/tcp_rmem"
+#define NET_PROC_SYS_NET_IPv4_TCP_WMEM                 "/proc/sys/net/ipv4/tcp_wmem"
+#define NET_PROC_SYS_NET_IPV4_UDP_MEM                  "/proc/sys/net/ipv4/udp_mem"
+#define NET_PROC_SYS_NET_CORE_RMEM_DEFAULT             "/proc/sys/net/core/rmem_default"
+#define NET_PROC_SYS_NET_CORE_RMEM_MAX                 "/proc/sys/net/core/rmem_max"
+#define NET_PROC_SYS_NET_CORE_WMEM_DEFAULT             "/proc/sys/net/core/wmem_default"
+#define NET_PROC_SYS_NET_CORE_WMEM_MAX                 "/proc/sys/net/core/wmem_max"
 
 #define ROUTE_EXEC_PATH                                                "/sbin/route"
 
@@ -748,6 +753,61 @@ static void __netconfig_adjust_tcp_buffer_size(void)
        }
 }
 
+static void __netconfig_write_socket_buffer_size(const char *path, int size)
+{
+       int fd = 0;
+       char buf[11] = {0, };
+
+       snprintf(buf, sizeof(buf) - 1, "%d", size);
+       fd = open(path, O_RDWR | O_CLOEXEC);
+       if (fd < 0) {
+               ERR("Failed to open %s", path);
+               return;
+       }
+
+       if (write(fd, buf, strlen(buf)) < 0)
+               ERR("Failed to set %s", path);
+       close(fd);
+}
+
+static void __netconfig_write_socket_buffer_size_list(const char *path, int *size)
+{
+       int fd = 0;
+       char buf[33] = {0, };
+
+       snprintf(buf, sizeof(buf) - 1, "%d %d %d", size[0], size[1], size[2]);
+       fd = open(path, O_RDWR | O_CLOEXEC);
+       if (fd < 0) {
+               ERR("Failed to open %s", path);
+               return;
+       }
+
+       if (write(fd, buf, strlen(buf)) < 0)
+               ERR("Failed to set %s", path);
+       close(fd);
+}
+
+static void __netconfig_adjust_udp_buffer_size(void)
+{
+       int rmem_default = netconfig_setting_get_read_buffer_size_default();
+       int rmem_max = netconfig_setting_get_read_buffer_size_max();
+       int wmem_default = netconfig_setting_get_write_buffer_size_default();
+       int wmem_max = netconfig_setting_get_write_buffer_size_max();
+       int *udp_mem = netconfig_setting_get_ipv4_udp_buffer_size();
+
+       if (rmem_default == 0 || rmem_max == 0 ||
+                       wmem_default == 0 || wmem_max == 0 || udp_mem == NULL) {
+               ERR("Failed to get udp buffer size information. Do nothing.");
+               return;
+       }
+
+       __netconfig_write_socket_buffer_size(NET_PROC_SYS_NET_CORE_RMEM_DEFAULT, rmem_default);
+       __netconfig_write_socket_buffer_size(NET_PROC_SYS_NET_CORE_RMEM_MAX, rmem_max);
+       __netconfig_write_socket_buffer_size(NET_PROC_SYS_NET_CORE_WMEM_DEFAULT, wmem_default);
+       __netconfig_write_socket_buffer_size(NET_PROC_SYS_NET_CORE_WMEM_MAX, wmem_max);
+       __netconfig_write_socket_buffer_size_list(NET_PROC_SYS_NET_IPV4_UDP_MEM, udp_mem);
+}
+
 static void __netconfig_update_default_connection_info(void)
 {
        int old_network_status = 0;
@@ -948,6 +1008,7 @@ static void __netconfig_update_default_connection_info(void)
        }
 
        __netconfig_adjust_tcp_buffer_size();
+       __netconfig_adjust_udp_buffer_size();
 }
 
 static gboolean __netconfig_is_tech_state_connected(void)
@@ -1122,10 +1183,12 @@ void netconfig_update_default_profile(void)
 
 void netconfig_update_default(void)
 {
-       if (__netconfig_is_tech_state_connected() == TRUE)
+       if (__netconfig_is_tech_state_connected() == TRUE) {
                netconfig_update_default_profile();
-       else
+       } else {
                __netconfig_adjust_tcp_buffer_size();
+               __netconfig_adjust_udp_buffer_size();
+       }
 }
 
 const char *netconfig_get_ifname(const char *profile)

diff --git a/src/utils/setting.c b/src/utils/setting.c
index 84123792322ca50a819019a68574601e05042ff7..e106fc227abb160550e550847ed1f359362ec763 100755 (executable)
--- a/src/utils/setting.c
+++ b/src/utils/setting.c
@@ -21,23 +21,41 @@
 #include "util.h"
 #include "log.h"
 
+typedef struct {
+       const char *key;
+       union {
+               GSList *string_list;
+               int size;
+               int *size_list;
+       } data;
+} netconfig_setting_data_s;
+
 typedef enum {
-       SETTING_TYPE_LAST_POWER,
+       SETTING_TYPE_LAST_POWER = 0,
        SETTING_TYPE_WIFI_OFF_BY_AIRPLANE,
        SETTING_TYPE_WIFI_OFF_BY_RESTRICTED,
        SETTING_TYPE_WIFI_OFF_BY_EMERGENCY,
-} netconfig_setting_type_e;
 
-typedef struct {
-       const char *key;
-       GSList *string_list;
-} netconfig_setting_data_s;
+       // Extension data for socket buffer size. This might be used on Robot profile only.
+       SETTING_TYPE_READ_BUFFER_SIZE_DEFAULT,
+       SETTING_TYPE_READ_BUFFER_SIZE_MAX,
+       SETTING_TYPE_WRITE_BUFFER_SIZE_DEFAULT,
+       SETTING_TYPE_WRITE_BUFFER_SIZE_MAX,
+       SETTING_TYPE_IPV4_UDP_BUFFER_SIZE,
+} netconfig_setting_type_e;
 
 netconfig_setting_data_s netconfig_setting_data[] = {
-       { "LastPoweredInterfaces", NULL },
-       { "WifiOffByAirplaneInterfaces", NULL },
-       { "WifiOffByRestrictedInterfaces", NULL },
-       { "WifiOffByEmergencyInterfaces", NULL },
+       { "LastPoweredInterfaces", {NULL} },
+       { "WifiOffByAirplaneInterfaces", {NULL} },
+       { "WifiOffByRestrictedInterfaces", {NULL} },
+       { "WifiOffByEmergencyInterfaces", {NULL} },
+
+       // Extension data.
+       { "ReadBufferSizeDefault", {0} },
+       { "ReadBufferSizeMax", {0} },
+       { "WriteBufferSizeDefault", {0} },
+       { "WriteBufferSizeMax", {0} },
+       { "IPv4UdpBufferSize", {NULL} },
 };
 
 void netconfig_setting_init(void)
@@ -55,16 +73,18 @@ void netconfig_setting_deinit(void)
 
        netconfig_setting_save();
 
-       size = ARRAY_SIZE(netconfig_setting_data);
-       for (i = 0; i < size; i++)
-               g_slist_free_full(netconfig_setting_data[i].string_list, g_free);
+       size = SETTING_TYPE_WIFI_OFF_BY_EMERGENCY;
+       for (i = 0; i <= size; i++)
+               g_slist_free_full(netconfig_setting_data[i].data.string_list, g_free);
+
+       g_free(netconfig_setting_data[SETTING_TYPE_IPV4_UDP_BUFFER_SIZE].data.size_list);
 
        INFO("setting is deinitialized");
 
        return;
 }
 
-static void __setting_set_string_list(GKeyFile *keyfile, netconfig_setting_type_e type)
+static void __setting_set_string_list(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
 {
        GString *string_str = NULL;
        char **string_list = NULL;
@@ -73,7 +93,7 @@ static void __setting_set_string_list(GKeyFile *keyfile, netconfig_setting_type_
 
        string_str = g_string_new(NULL);
        if (string_str) {
-               list = netconfig_setting_data[type].string_list;
+               list = netconfig_setting_data[type].data.string_list;
                for (; list; list = list->next) {
                        if (string_str->len > 0)
                                g_string_append_printf(string_str, " %s", (char *)list->data);
@@ -84,11 +104,11 @@ static void __setting_set_string_list(GKeyFile *keyfile, netconfig_setting_type_
                if (string_str->len > 0) {
                        string_list = g_strsplit_set(string_str->str, " ", 0);
                        length = g_strv_length(string_list);
-                       g_key_file_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       g_key_file_set_string_list(keyfile, group,
                                netconfig_setting_data[type].key,
                                (const gchar **)string_list, length);
                } else {
-                       g_key_file_remove_key(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       g_key_file_remove_key(keyfile, group,
                                netconfig_setting_data[type].key, NULL);
                }
 
@@ -97,7 +117,7 @@ static void __setting_set_string_list(GKeyFile *keyfile, netconfig_setting_type_
        }
 }
 
-static void __setting_get_string_list(GKeyFile *keyfile, netconfig_setting_type_e type)
+static void __setting_get_string_list(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
 {
        char **string_list = NULL;
        gsize length;
@@ -105,12 +125,17 @@ static void __setting_get_string_list(GKeyFile *keyfile, netconfig_setting_type_
 
        INFO("Key [%s]", netconfig_setting_data[type].key);
 
-       string_list = g_key_file_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+       string_list = g_key_file_get_string_list(keyfile, group,
                                        netconfig_setting_data[type].key, &length, NULL);
-       if (string_list && length != 0) {
+       if (!string_list) {
+               ERR("%d key cannot be found from %s.", type, group);
+               return;
+       }
+
+       if (length != 0) {
                for (i = 0; string_list[i]; i++) {
-                       netconfig_setting_data[type].string_list = g_slist_append(
-                               netconfig_setting_data[type].string_list,
+                       netconfig_setting_data[type].data.string_list = g_slist_append(
+                               netconfig_setting_data[type].data.string_list,
                                g_strdup(string_list[i]));
 
                        INFO("%s", string_list[i]);
@@ -120,6 +145,39 @@ static void __setting_get_string_list(GKeyFile *keyfile, netconfig_setting_type_
        g_strfreev(string_list);
 }
 
+static void __setting_get_integer(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
+{
+       int value;
+       GError *error = NULL;
+
+       INFO("Key [%s]", netconfig_setting_data[type].key);
+       value = g_key_file_get_integer(keyfile, group, netconfig_setting_data[type].key, &error);
+       if (error) {
+               ERR("Failed to get integer value from keyfile. %s", error->message);
+               return;
+       }
+
+       netconfig_setting_data[type].data.size = value;
+}
+
+static void __setting_get_integer_list(GKeyFile *keyfile, const char *group, netconfig_setting_type_e type)
+{
+       int *value_list = NULL;
+       gsize length;
+       GError *error = NULL;
+
+       INFO("Key [%s]", netconfig_setting_data[type].key);
+       value_list = g_key_file_get_integer_list(keyfile, group,
+                       netconfig_setting_data[type].key, &length, &error);
+       if (error || length != 3) {
+               ERR("Failed to get integer value from keyfile. %s",
+                               error ? error->message : "length isn't 3.");
+               return;
+       }
+
+       netconfig_setting_data[type].data.size_list = value_list;
+}
+
 int netconfig_setting_save(void)
 {
        GKeyFile *keyfile = NULL;
@@ -132,10 +190,13 @@ int netconfig_setting_save(void)
                return -EIO;
        }
 
-       __setting_set_string_list(keyfile, SETTING_TYPE_LAST_POWER);
-       __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
-       __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
-       __setting_set_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
+       __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME, SETTING_TYPE_LAST_POWER);
+       __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
+       __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
+       __setting_set_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
 
        netconfig_keyfile_save(keyfile, NETCONFIG_SETTINGS_PATH);
 
@@ -155,10 +216,25 @@ int netconfig_setting_load(void)
                return -EIO;
        }
 
-       __setting_get_string_list(keyfile, SETTING_TYPE_LAST_POWER);
-       __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
-       __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
-       __setting_get_string_list(keyfile, SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
+       __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME, SETTING_TYPE_LAST_POWER);
+       __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       SETTING_TYPE_WIFI_OFF_BY_AIRPLANE);
+       __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       SETTING_TYPE_WIFI_OFF_BY_RESTRICTED);
+       __setting_get_string_list(keyfile, SETTINGS_WIFI_GROUP_NAME,
+                       SETTING_TYPE_WIFI_OFF_BY_EMERGENCY);
+
+       __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
+                       SETTING_TYPE_READ_BUFFER_SIZE_DEFAULT);
+       __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
+                       SETTING_TYPE_READ_BUFFER_SIZE_MAX);
+       __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
+                       SETTING_TYPE_WRITE_BUFFER_SIZE_DEFAULT);
+       __setting_get_integer(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
+                       SETTING_TYPE_WRITE_BUFFER_SIZE_MAX);
+
+       __setting_get_integer_list(keyfile, SETTINGS_EXTENSION_GROUP_NAME,
+                       SETTING_TYPE_IPV4_UDP_BUFFER_SIZE);
 
        return 0;
 }
@@ -166,15 +242,15 @@ int netconfig_setting_load(void)
 void netconfig_setting_update_interface_for_last_powered(const char *interface_name,
                bool mode)
 {
-       GSList *list = netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list;
+       GSList *list = netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list;
        bool find = FALSE;
 
        for ( ; list; list = list->next) {
                const char *ifname = list->data;
                if (g_strcmp0(ifname, interface_name) == 0) {
                        if (mode == FALSE)
-                               netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list = g_slist_remove(
-                                       netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list, ifname);
+                               netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list = g_slist_remove(
+                                       netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list, ifname);
 
                        find = TRUE;
                        break;
@@ -182,29 +258,29 @@ void netconfig_setting_update_interface_for_last_powered(const char *interface_n
        }
 
        if (mode == TRUE && find == FALSE)
-               netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list = g_slist_append(
-                       netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list, g_strdup(interface_name));
+               netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list = g_slist_append(
+                       netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list, g_strdup(interface_name));
 
        netconfig_setting_save();
 }
 
 GSList *netconfig_setting_get_interfaces_for_last_powered(void)
 {
-       return netconfig_setting_data[SETTING_TYPE_LAST_POWER].string_list;
+       return netconfig_setting_data[SETTING_TYPE_LAST_POWER].data.string_list;
 }
 
 void netconfig_setting_update_interface_off_for_airplane(const char *interface_name,
                bool mode)
 {
-       GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list;
+       GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list;
        bool find = FALSE;
 
        for ( ; list; list = list->next) {
                const char *ifname = list->data;
                if (g_strcmp0(ifname, interface_name) == 0) {
                        if (mode == FALSE)
-                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list = g_slist_remove(
-                                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list, ifname);
+                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list = g_slist_remove(
+                                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list, ifname);
 
                        find = TRUE;
                        break;
@@ -212,29 +288,29 @@ void netconfig_setting_update_interface_off_for_airplane(const char *interface_n
        }
 
        if (mode == TRUE && find == FALSE)
-               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list = g_slist_append(
-                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list, g_strdup(interface_name));
+               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list = g_slist_append(
+                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list, g_strdup(interface_name));
 
        netconfig_setting_save();
 }
 
 GSList *netconfig_setting_get_interfaces_off_by_airplane(void)
 {
-       return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].string_list;
+       return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_AIRPLANE].data.string_list;
 }
 
 void netconfig_setting_update_interface_off_for_restricted(const char *interface_name,
                bool mode)
 {
-       GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list;
+       GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list;
        bool find = FALSE;
 
        for ( ; list; list = list->next) {
                const char *ifname = list->data;
                if (g_strcmp0(ifname, interface_name) == 0) {
                        if (mode == FALSE)
-                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list = g_slist_remove(
-                                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list, ifname);
+                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list = g_slist_remove(
+                                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list, ifname);
 
                        find = TRUE;
                        break;
@@ -242,29 +318,31 @@ void netconfig_setting_update_interface_off_for_restricted(const char *interface
        }
 
        if (mode == TRUE && find == FALSE)
-               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list = g_slist_append(
-                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list, g_strdup(interface_name));
+               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list = g_slist_append(
+                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list, g_strdup(interface_name));
 
        netconfig_setting_save();
 }
 
 GSList *netconfig_setting_get_interfaces_off_by_restricted(void)
 {
-       return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].string_list;
+       return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_RESTRICTED].data.string_list;
 }
 
 void netconfig_setting_update_interface_off_for_emergency(const char *interface_name,
                bool mode)
 {
-       GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list;
+       GSList *list = netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list;
        bool find = FALSE;
 
        for ( ; list; list = list->next) {
                const char *ifname = list->data;
                if (g_strcmp0(ifname, interface_name) == 0) {
                        if (mode == FALSE)
-                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list = g_slist_remove(
-                                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list, ifname);
+                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list
+                                       = g_slist_remove(
+                                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list,
+                                               ifname);
 
                        find = TRUE;
                        break;
@@ -272,13 +350,40 @@ void netconfig_setting_update_interface_off_for_emergency(const char *interface_
        }
 
        if (mode == TRUE && find == FALSE)
-               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list = g_slist_append(
-                       netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list, g_strdup(interface_name));
+               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list
+                       = g_slist_append(
+                               netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list,
+                               g_strdup(interface_name));
 
        netconfig_setting_save();
 }
 
 GSList *netconfig_setting_get_interfaces_off_by_emergency(void)
 {
-       return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].string_list;
+       return netconfig_setting_data[SETTING_TYPE_WIFI_OFF_BY_EMERGENCY].data.string_list;
+}
+
+int netconfig_setting_get_read_buffer_size_default(void)
+{
+       return netconfig_setting_data[SETTING_TYPE_READ_BUFFER_SIZE_DEFAULT].data.size;
+}
+
+int netconfig_setting_get_read_buffer_size_max(void)
+{
+       return netconfig_setting_data[SETTING_TYPE_READ_BUFFER_SIZE_MAX].data.size;
+}
+
+int netconfig_setting_get_write_buffer_size_default(void)
+{
+       return netconfig_setting_data[SETTING_TYPE_WRITE_BUFFER_SIZE_DEFAULT].data.size;
+}
+
+int netconfig_setting_get_write_buffer_size_max(void)
+{
+       return netconfig_setting_data[SETTING_TYPE_WRITE_BUFFER_SIZE_MAX].data.size;
+}
+
+int *netconfig_setting_get_ipv4_udp_buffer_size(void)
+{
+       return netconfig_setting_data[SETTING_TYPE_IPV4_UDP_BUFFER_SIZE].data.size_list;
 }