src/network-state.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2000 - 2012 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 <vconf.h>
  21 #include <vconf-keys.h>
  22 #include <fcntl.h>
  23 #include <unistd.h>
  24 #include <stdlib.h>
  25 #include <net/if.h>
  26 #include <arpa/inet.h>
  27 #include <netinet/in.h>
  28 #include <sys/ioctl.h>
  29
  30 #include "log.h"
  31 #include "util.h"
  32 #include "netdbus.h"
  33 #include "neterror.h"
  34 #include "emulator.h"
  35 #include "wifi-state.h"
  36 #include "wifi-power.h"
  37 #include "network-state.h"
  38 #include "network-dpm.h"
  39 #include "network-monitor.h"
  40 #include "netsupplicant.h"
  41 #include "clatd-handler.h"
  42 #if defined TIZEN_DEBUG_ENABLE
  43 #include "network-dump.h"
  44 #endif
  45
  46 #include "generated-code.h"
  47 /* Define TCP buffer sizes for various networks */
  48 /* ReadMin, ReadInitial, ReadMax */ /* WriteMin, WriteInitial, WriteMax */
  49 #define NET_TCP_BUFFERSIZE_DEFAULT_READ         "4096 87380 704512"
  50 #define NET_TCP_BUFFERSIZE_DEFAULT_WRITE        "4096 16384 110208"
  51 #define NET_TCP_BUFFERSIZE_WIFI_READ            "524288 1048576 2560000"
  52 #define NET_TCP_BUFFERSIZE_WIFI_WRITE           "524288 1048576 2560000"
  53 #define NET_TCP_BUFFERSIZE_LTE_READ             "524288 1048576 2560000"
  54 #define NET_TCP_BUFFERSIZE_LTE_WRITE            "524288 1048576 2560000"
  55 #define NET_TCP_BUFFERSIZE_UMTS_READ            "4094 87380 704512"
  56 #define NET_TCP_BUFFERSIZE_UMTS_WRITE           "4096 16384 110208"
  57 #define NET_TCP_BUFFERSIZE_HSPA_READ            "4092 87380 704512"
  58 #define NET_TCP_BUFFERSIZE_HSPA_WRITE           "4096 16384 262144"
  59 #define NET_TCP_BUFFERSIZE_HSDPA_READ           "4092 87380 704512"
  60 #define NET_TCP_BUFFERSIZE_HSDPA_WRITE          "4096 16384 262144"
  61 #define NET_TCP_BUFFERSIZE_HSUPA_READ           "4092 87380 704512"
  62 #define NET_TCP_BUFFERSIZE_HSUPA_WRITE          "4096 16384 262144"
  63 #define NET_TCP_BUFFERSIZE_HSPAP_READ           "4092 87380 1220608"
  64 #define NET_TCP_BUFFERSIZE_HSPAP_WRITE          "4096 16384 1220608"
  65 #define NET_TCP_BUFFERSIZE_EDGE_READ            "4093 26280 35040"
  66 #define NET_TCP_BUFFERSIZE_EDGE_WRITE           "4096 16384 35040"
  67 #define NET_TCP_BUFFERSIZE_GPRS_READ            "4096 30000 30000"
  68 #define NET_TCP_BUFFERSIZE_GPRS_WRITE           "4096 8760 11680"
  69
  70 #define NET_TCP_BUFFERSIZE_WIFI_RMEM_MAX        "1048576"
  71 #define NET_TCP_BUFFERSIZE_WIFI_WMEM_MAX        "2097152"
  72 #define NET_TCP_BUFFERSIZE_LTE_RMEM_MAX         "5242880"
  73
  74 #define NET_TCP_BUFFERSIZE_WIFID_WMEM_MAX       "2097152"
  75
  76 #define NET_PROC_SYS_NET_IPV4_TCP_RMEM          "/proc/sys/net/ipv4/tcp_rmem"
  77 #define NET_PROC_SYS_NET_IPv4_TCP_WMEM          "/proc/sys/net/ipv4/tcp_wmem"
  78 #define NET_PROC_SYS_NET_CORE_RMEM_MAX          "/proc/sys/net/core/rmem_max"
  79 #define NET_PROC_SYS_NET_CORE_WMEM_MAX          "/proc/sys/net/core/wmem_max"
  80
  81 #define ROUTE_EXEC_PATH                                         "/sbin/route"
  82
  83 #define TELEPHONY_SERVICE                       "com.tcore.ps"
  84 #define TELEPHONY_MASTER_INTERFACE              TELEPHONY_SERVICE ".master"
  85 #define TELEPHONY_MODEM_INTERFACE               TELEPHONY_SERVICE ".modem"
  86 #define TELEPHONY_PROFILE_INTERFACE             TELEPHONY_SERVICE ".context"
  87 #define TELEPHONY_MASTER_PATH                   "/"
  88 #define NET_PROFILE_NAME_LEN_MAX 512
  89
  90 typedef struct {
  91         char                    profile_name[NET_PROFILE_NAME_LEN_MAX];
  92 } net_profile_name_t;
  93
  94 static Network *netconfigstate = NULL;
  95 #if defined TIZEN_DEBUG_ENABLE
  96 static Tcpdump *tcpdump_object = NULL;
  97 #endif
  98 static Battery *battery_object = NULL;
  99
 100 struct netconfig_default_connection {
 101         char *profile;
 102         char *ifname;
 103         char *mac_address;
 104         char *ipaddress;
 105         char *ipaddress6;
 106         char *proxy;
 107         char *essid;
 108         unsigned int freq;
 109         gboolean is_metered;
 110 };
 111
 112 static struct netconfig_default_connection
 113                                 netconfig_default_connection_info = { NULL, };
 114
 115 gboolean netconfig_iface_network_state_ethernet_cable_state(gint32 *state);
 116
 117 static gboolean __netconfig_is_connected(GVariantIter *array)
 118 {
 119         gboolean is_connected = FALSE;
 120         GVariant *variant = NULL;
 121         gchar *key = NULL;
 122         const gchar *value = NULL;
 123
 124         while (g_variant_iter_loop(array, "{sv}", &key, &variant)) {
 125                 if (g_strcmp0(key, "State") != 0)
 126                         continue;
 127
 128                 if (g_variant_is_of_type(variant, G_VARIANT_TYPE_STRING)) {
 129                         value = g_variant_get_string(variant, NULL);
 130                         if (g_strcmp0(value, "ready") == 0 || g_strcmp0(value, "online") == 0)
 131                                 is_connected = TRUE;
 132                 }
 133
 134                 g_free(key);
 135                 g_variant_unref(variant);
 136                 break;
 137         }
 138
 139         return is_connected;
 140 }
 141
 142 static char *__netconfig_get_default_profile(void)
 143 {
 144         GVariant *message = NULL;
 145         GVariantIter *iter;
 146         GVariantIter *next;
 147         gchar *default_profile = NULL;
 148         gchar *object_path;
 149
 150         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
 151                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
 152                         "GetServices", NULL);
 153         if (message == NULL) {
 154                 ERR("Failed to get profiles");
 155                 return NULL;
 156         }
 157
 158         g_variant_get(message, "(a(oa{sv}))", &iter);
 159         while (g_variant_iter_loop(iter, "(oa{sv})", &object_path, &next)) {
 160                 if (object_path == NULL)
 161                         continue;
 162
 163                 if (netconfig_is_cellular_profile(object_path) && !netconfig_is_cellular_internet_profile(object_path))
 164                         continue;
 165
 166                 if (__netconfig_is_connected(next) == TRUE) {
 167                         default_profile = g_strdup(object_path);
 168                         g_free(object_path);
 169                         g_variant_iter_free(next);
 170                         break;
 171                 }
 172         }
 173         g_variant_iter_free(iter);
 174         g_variant_unref(message);
 175
 176         return default_profile;
 177 }
 178
 179 static int __netconfig_telephony_get_modem_object_path(GSList **modem_path_list)
 180 {
 181         GVariant *result;
 182         GVariantIter *iter_modem = NULL;
 183         GVariantIter *modem_properties = NULL;
 184         const char *modem_path;
 185
 186         result = netconfig_invoke_dbus_method(TELEPHONY_SERVICE, TELEPHONY_MASTER_PATH,
 187                         TELEPHONY_MASTER_INTERFACE, "GetModems", NULL);
 188         if (result == NULL) {
 189                 ERR("Failed to get modem path list");
 190                 return -1;
 191         }
 192
 193         g_variant_get(result, "(a{sa{ss}})", &iter_modem);
 194         while (g_variant_iter_loop(iter_modem, "{sa{ss}}", &modem_path, &modem_properties)) {
 195                 *modem_path_list = g_slist_append(*modem_path_list, g_strdup(modem_path));
 196                 DBG("modem object path: %s",    modem_path);
 197         }
 198
 199         g_variant_iter_free(iter_modem);
 200         g_variant_unref(result);
 201
 202         return 0;
 203 }
 204
 205 static int __netconfig_telephony_get_profile_list(net_profile_name_t **profile_list,
 206                 int *profile_count)
 207 {
 208         int ret = 0;
 209         int count = 0, i = 0;
 210         const char *str = NULL;
 211         GVariant *result;
 212         GVariantIter *iter = NULL;
 213         GSList *profiles = NULL, *list = NULL;
 214         net_profile_name_t *plist = NULL;
 215
 216         GSList *modem_path_list = NULL;
 217         const char *path = NULL;
 218
 219         ret = __netconfig_telephony_get_modem_object_path(&modem_path_list);
 220         if (ret < 0) {
 221                 ERR("Failed to get modems path list");
 222
 223                 g_slist_free_full(modem_path_list, g_free);
 224                 return ret;
 225         }
 226
 227         for (list = modem_path_list; list != NULL; list = list->next) {
 228                 path = (const char *)list->data;
 229
 230                 DBG("path: %s", path);
 231                 result = netconfig_invoke_dbus_method(TELEPHONY_SERVICE, path,
 232                                 TELEPHONY_MODEM_INTERFACE, "GetProfileList", NULL);
 233                 if (result == NULL) {
 234                         DBG("Failed to get profiles: %s", path);
 235                         continue;
 236                 }
 237
 238                 g_variant_get(result, "(as)", &iter);
 239                 while (g_variant_iter_loop(iter, "s", &str))
 240                         profiles = g_slist_append(profiles, g_strdup(str));
 241
 242                 g_variant_iter_free(iter);
 243                 g_variant_unref(result);
 244         }
 245
 246         g_slist_free_full(modem_path_list, g_free);
 247
 248         count = g_slist_length(profiles);
 249         if (count > 0) {
 250                 plist = (net_profile_name_t*)malloc(sizeof(net_profile_name_t) * count);
 251         } else {
 252                 *profile_count = 0;
 253                 goto out;
 254         }
 255
 256         if (plist == NULL) {
 257                 ERR("Failed to allocate memory");
 258                 *profile_count = 0;
 259                 ret = -1;
 260                 goto out;
 261         }
 262
 263         for (list = profiles, i = 0; list != NULL; list = list->next, i++)
 264                 g_strlcpy(plist[i].profile_name,
 265                                 (const char *)list->data, NET_PROFILE_NAME_LEN_MAX);
 266
 267         *profile_list = plist;
 268         *profile_count = count;
 269
 270 out:
 271         g_slist_free_full(profiles, g_free);
 272
 273         return ret;
 274 }
 275
 276 static int __netconfig_telephony_search_pdp_profile(const char* profile_name, net_profile_name_t* pdp_name)
 277 {
 278         int ret;
 279         net_profile_name_t* profile_list = NULL;
 280         char* prof_name = NULL;
 281         char* tel_prof_name = NULL;
 282         char* found_ptr = NULL;
 283         int profile_count = 0;
 284         int i;
 285
 286         /* Get pdp profile list from telephony service */
 287         ret = __netconfig_telephony_get_profile_list(&profile_list, &profile_count);
 288         if (ret < 0) {
 289                 ERR("Failed to get profile list from telephony service");
 290                 g_free(profile_list);
 291                 return ret;
 292         }
 293
 294         if (profile_list == NULL || profile_count <= 0) {
 295                 ERR("There is no PDP profiles");
 296                 g_free(profile_list);
 297                 return -1;
 298         }
 299
 300         /* Find matching profile */
 301         prof_name = strrchr(profile_name, '/') + 1;
 302         for (i = 0; i < profile_count; i++) {
 303                 tel_prof_name = strrchr(profile_list[i].profile_name, '/') + 1;
 304                 found_ptr = strstr(prof_name, tel_prof_name);
 305
 306                 if (found_ptr != NULL && g_strcmp0(found_ptr, tel_prof_name) == 0) {
 307                         g_strlcpy(pdp_name->profile_name,
 308                                         profile_list[i].profile_name, NET_PROFILE_NAME_LEN_MAX);
 309
 310                         DBG("PDP profile name found in cellular profile: %s", pdp_name->profile_name);
 311                         break;
 312                 }
 313         }
 314
 315         if (i >= profile_count) {
 316                 ERR("There is no matching PDP profiles");
 317                 g_free(profile_list);
 318                 return -1;
 319         }
 320
 321         g_free(profile_list);
 322
 323         return ret;
 324 }
 325
 326 static gboolean __netconfig_telephony_get_metered_info(net_profile_name_t* pdp_name)
 327 {
 328         GVariant *result;
 329         GVariantIter *iter;
 330         const gchar *key = NULL;
 331         const gchar *value = NULL;
 332         gboolean ret = FALSE;
 333
 334         if (pdp_name == NULL) {
 335                 ERR("Invalid parameter!");
 336                 return ret;
 337         }
 338
 339         result = netconfig_invoke_dbus_method(TELEPHONY_SERVICE, pdp_name->profile_name,
 340                         TELEPHONY_PROFILE_INTERFACE, "GetProfile", NULL);
 341         if (result == NULL) {
 342                 ERR("_net_invoke_dbus_method failed");
 343                 return ret;
 344         }
 345
 346         g_variant_get(result, "(a{ss})", &iter);
 347         while (g_variant_iter_next(iter, "{ss}", &key, &value)) {
 348                 if (g_strcmp0(key, "is_metered") == 0) {
 349                         if (value == NULL)
 350                                 continue;
 351
 352                         if (g_strcmp0(value, "TRUE") == 0)
 353                                 ret = TRUE;
 354                 }
 355         }
 356
 357         g_variant_iter_free(iter);
 358         g_variant_unref(result);
 359
 360         DBG("is_metered = %s", ret ? "TRUE" : "FALSE");
 361
 362         return ret;
 363 }
 364
 365 static void __netconfig_get_default_connection_info(const char *profile)
 366 {
 367         GVariant *message = NULL, *variant = NULL, *variant2 = NULL;
 368         GVariantIter *iter = NULL, *iter1 = NULL,  *service = NULL;
 369         GVariant *next = NULL;
 370         gchar *obj_path;
 371         gchar *key = NULL;
 372         gchar *key1 = NULL;
 373         gchar *key2 = NULL;
 374         gboolean found_profile = 0;
 375
 376         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
 377                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
 378                         "GetServices", NULL);
 379         if (message == NULL) {
 380                 ERR("Failed to get services informations");
 381                 goto done;
 382         }
 383
 384         g_variant_get(message, "(a(oa{sv}))", &service);
 385         if (service == NULL) {
 386                 ERR("Failed to get services iter");
 387                 goto done;
 388         }
 389
 390         while (g_variant_iter_loop(service, "(oa{sv})", &obj_path, &iter)) {
 391                 if (g_strcmp0(obj_path, profile) == 0) {
 392                         g_free(obj_path);
 393                         found_profile = 1;
 394                         break;
 395                 }
 396         }
 397
 398         if (iter == NULL || found_profile == 0) {
 399                 ERR("Profile %s doesn't exist", profile);
 400                 goto done;
 401         }
 402
 403         while (g_variant_iter_loop(iter, "{sv}", &key, &next)) {
 404                 const gchar *value = NULL;
 405                 guint16 freq = 0;
 406                 if (g_strcmp0(key, "Name") == 0 &&
 407                                 netconfig_is_wifi_profile(profile) == TRUE) {
 408                         if (g_variant_is_of_type(next, G_VARIANT_TYPE_STRING)) {
 409                                 value = g_variant_get_string(next, NULL);
 410
 411                                 netconfig_default_connection_info.essid = g_strdup(value);
 412                         }
 413                 } else if (g_strcmp0(key, "Ethernet") == 0) {
 414                         g_variant_get(next, "a{sv}", &iter1);
 415                         if (iter1 == NULL)
 416                                 continue;
 417                         while (g_variant_iter_loop(iter1, "{sv}", &key1, &variant)) {
 418                                 if (g_strcmp0(key1, "Interface") == 0) {
 419                                         value = g_variant_get_string(variant, NULL);
 420                                         netconfig_default_connection_info.ifname = g_strdup(value);
 421                                 } else if (g_strcmp0(key1, "Address") == 0) {
 422                                         value = g_variant_get_string(variant, NULL);
 423                                         netconfig_default_connection_info.mac_address = g_strdup(value);
 424                                 }
 425                         }
 426                         g_variant_iter_free(iter1);
 427                 } else if (g_strcmp0(key, "IPv4") == 0) {
 428                         g_variant_get(next, "a{sv}", &iter1);
 429                         if (iter1 == NULL)
 430                                 continue;
 431                         while (g_variant_iter_loop(iter1, "{sv}", &key1, &variant)) {
 432                                 if (g_strcmp0(key1, "Address") == 0) {
 433                                         value = g_variant_get_string(variant, NULL);
 434                                         netconfig_default_connection_info.ipaddress = g_strdup(value);
 435                                 }
 436                         }
 437                         g_variant_iter_free(iter1);
 438                 } else if (g_strcmp0(key, "IPv6") == 0) {
 439                         g_variant_get(next, "a{sv}", &iter1);
 440                         if (iter1 == NULL)
 441                                 continue;
 442                         while (g_variant_iter_loop(iter1, "{sv}", &key1, &variant)) {
 443                                 if (g_strcmp0(key1, "Address") == 0) {
 444                                         value = g_variant_get_string(variant, NULL);
 445                                         netconfig_default_connection_info.ipaddress6 = g_strdup(value);
 446                                 }
 447                         }
 448                         g_variant_iter_free(iter1);
 449
 450                 } else if (g_strcmp0(key, "Proxy") == 0) {
 451                         g_variant_get(next, "a{sv}", &iter1);
 452                         if (iter1 == NULL)
 453                                 continue;
 454                         while (g_variant_iter_loop(iter1, "{sv}", &key2, &variant2)) {
 455                                 GVariantIter *iter_sub = NULL;
 456
 457                                 if (g_strcmp0(key2, "Servers") == 0) {
 458                                         if (!g_variant_is_of_type(variant2, G_VARIANT_TYPE_STRING_ARRAY)) {
 459                                                 g_free(key2);
 460                                                 g_variant_unref(variant2);
 461                                                 break;
 462                                         }
 463
 464                                         g_variant_get(variant2, "as", &iter_sub);
 465                                         g_variant_iter_loop(iter_sub, "s", &value);
 466                                         g_variant_iter_free(iter_sub);
 467                                         if (value != NULL && (strlen(value) > 0))
 468                                                 netconfig_default_connection_info.proxy = g_strdup(value);
 469                                 } else if (g_strcmp0(key2, "Method") == 0) {
 470                                         if (g_variant_is_of_type(variant2, G_VARIANT_TYPE_STRING)) {
 471                                                 g_free(key2);
 472                                                 g_variant_unref(variant2);
 473                                                 break;
 474                                         }
 475
 476                                         value = g_variant_get_string(variant2, NULL);
 477                                         if (g_strcmp0(value, "direct") == 0) {
 478                                                 g_free(netconfig_default_connection_info.proxy);
 479                                                 netconfig_default_connection_info.proxy = NULL;
 480
 481                                                 g_free(key2);
 482                                                 g_variant_unref(variant2);
 483                                                 break;
 484                                         }
 485                                 }
 486                         }
 487                         g_variant_iter_free(iter1);
 488                 } else if (g_strcmp0(key, "Frequency") == 0) {
 489                         if (g_variant_is_of_type(next, G_VARIANT_TYPE_UINT16)) {
 490                                 freq = g_variant_get_uint16(next);
 491                                 netconfig_default_connection_info.freq = freq;
 492                         }
 493                 }
 494         }
 495
 496         if (netconfig_is_cellular_profile(profile) == TRUE) {
 497                 net_profile_name_t pdp_name;
 498                 int ret;
 499
 500                 ret = __netconfig_telephony_search_pdp_profile(profile, &pdp_name);
 501                 if (ret >= 0 && strlen(pdp_name.profile_name) > 0)
 502                         if (__netconfig_telephony_get_metered_info(&pdp_name))
 503                                 netconfig_default_connection_info.is_metered = TRUE;
 504         }
 505
 506 done:
 507         if (message)
 508                 g_variant_unref(message);
 509
 510         if (iter)
 511                 g_variant_iter_free(iter);
 512
 513         if (service)
 514                 g_variant_iter_free(service);
 515
 516         return;
 517 }
 518
 519 static char *__netconfig_get_preferred_ipv6_address(char *profile)
 520 {
 521         GVariant *message = NULL, *variant = NULL, *next = NULL;
 522         GVariantIter *iter = NULL, *sub_iter = NULL, *service = NULL;
 523         gchar *obj_path;
 524         gchar *key = NULL;
 525         gchar *sub_key = NULL;
 526         gchar *preferred_address6 = NULL;
 527         gboolean found_profile = 0;
 528
 529         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
 530                                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
 531                                         "GetServices", NULL);
 532         if (message == NULL) {
 533                 ERR("Failed to get service informations");
 534                 goto done;
 535         }
 536
 537         g_variant_get(message, "(a(oa{sv}))", &service);
 538         if (service == NULL) {
 539                 ERR("Failed to get services iter");
 540                 goto done;
 541         }
 542
 543         while (g_variant_iter_loop(service, "(oa{sv})", &obj_path, &iter)) {
 544                 if (g_strcmp0(obj_path, profile) == 0) {
 545                         g_free(obj_path);
 546                         found_profile = 1;
 547                         break;
 548                 }
 549         }
 550
 551         if (iter == NULL || found_profile == 0) {
 552                 ERR("Profile %s doesn't exist", profile);
 553                         goto done;
 554         }
 555
 556         while (g_variant_iter_loop(iter, "{sv}", &key, &next)) {
 557                 const gchar *value = NULL;
 558                 if (g_strcmp0(key, "IPv6") == 0) {
 559                         g_variant_get(next, "a{sv}", &sub_iter);
 560                         if (sub_iter == NULL)
 561                                 continue;
 562                         while (g_variant_iter_loop(sub_iter, "{sv}", &sub_key, &variant)) {
 563                                 if (g_strcmp0(sub_key, "Address") == 0) {
 564                                         value = g_variant_get_string(variant, NULL);
 565                                         if (!preferred_address6)
 566                                                 preferred_address6 = g_strdup(value);
 567                                 }
 568                         }
 569                         g_variant_iter_free(sub_iter);
 570                 }
 571         }
 572
 573 done:
 574         if (message)
 575                 g_variant_unref(message);
 576
 577         if (iter)
 578                 g_variant_iter_free(iter);
 579
 580         if (service)
 581                 g_variant_iter_free(service);
 582
 583         return preferred_address6;
 584 }
 585
 586 static void __netconfig_adjust_tcp_buffer_size(void)
 587 {
 588         int fdr = 0, fdw = 0;
 589         int fdrmax = 0, fdwmax = 0;
 590         const char *rbuf_size = NULL;
 591         const char *wbuf_size = NULL;
 592         const char *rmax_size = NULL;
 593         const char *wmax_size = NULL;
 594         const char *profile = netconfig_get_default_profile();
 595
 596         if (profile == NULL) {
 597                 DBG("There is no default connection");
 598
 599                 rbuf_size = NET_TCP_BUFFERSIZE_DEFAULT_READ;
 600                 wbuf_size = NET_TCP_BUFFERSIZE_DEFAULT_WRITE;
 601         } else if (netconfig_is_wifi_profile(profile) == TRUE) {
 602                 DBG("Default connection: Wi-Fi");
 603
 604                 rbuf_size = NET_TCP_BUFFERSIZE_WIFI_READ;
 605                 wbuf_size = NET_TCP_BUFFERSIZE_WIFI_WRITE;
 606                 rmax_size = NET_TCP_BUFFERSIZE_WIFI_RMEM_MAX;
 607                 wmax_size = NET_TCP_BUFFERSIZE_WIFI_WMEM_MAX;
 608         } else if (netconfig_is_cellular_profile(profile) == TRUE) {
 609                 int telephony_svctype = 0, telephony_pstype = 0;
 610
 611                 netconfig_get_telephony_network_type(&telephony_svctype, &telephony_pstype);
 612                 DBG("Default cellular %d, %d", telephony_svctype, telephony_pstype);
 613
 614                 switch (telephony_pstype) {
 615                 case VCONFKEY_TELEPHONY_PSTYPE_HSPA:
 616                         rbuf_size = NET_TCP_BUFFERSIZE_HSPA_READ;
 617                         wbuf_size = NET_TCP_BUFFERSIZE_HSPA_WRITE;
 618                         break;
 619                 case VCONFKEY_TELEPHONY_PSTYPE_HSUPA:
 620                         rbuf_size = NET_TCP_BUFFERSIZE_HSUPA_READ;
 621                         wbuf_size = NET_TCP_BUFFERSIZE_HSDPA_WRITE;
 622                         break;
 623                 case VCONFKEY_TELEPHONY_PSTYPE_HSDPA:
 624                         rbuf_size = NET_TCP_BUFFERSIZE_HSDPA_READ;
 625                         wbuf_size = NET_TCP_BUFFERSIZE_HSDPA_WRITE;
 626                         break;
 627 #if !defined TIZEN_WEARABLE
 628                 case VCONFKEY_TELEPHONY_PSTYPE_HSPAP:
 629                         rbuf_size = NET_TCP_BUFFERSIZE_HSPAP_READ;
 630                         wbuf_size = NET_TCP_BUFFERSIZE_HSPAP_WRITE;
 631                         break;
 632 #endif
 633                 default:
 634                         switch (telephony_svctype) {
 635                         case VCONFKEY_TELEPHONY_SVCTYPE_LTE:
 636                                 rbuf_size = NET_TCP_BUFFERSIZE_LTE_READ;
 637                                 wbuf_size = NET_TCP_BUFFERSIZE_LTE_WRITE;
 638                                 rmax_size = NET_TCP_BUFFERSIZE_LTE_RMEM_MAX;
 639                                 break;
 640                         case VCONFKEY_TELEPHONY_SVCTYPE_3G:
 641                                 rbuf_size = NET_TCP_BUFFERSIZE_UMTS_READ;
 642                                 wbuf_size = NET_TCP_BUFFERSIZE_UMTS_WRITE;
 643                                 break;
 644                         case VCONFKEY_TELEPHONY_SVCTYPE_2_5G_EDGE:
 645                                 rbuf_size = NET_TCP_BUFFERSIZE_EDGE_READ;
 646                                 wbuf_size = NET_TCP_BUFFERSIZE_EDGE_WRITE;
 647                                 break;
 648                         case VCONFKEY_TELEPHONY_SVCTYPE_2_5G:
 649                                 rbuf_size = NET_TCP_BUFFERSIZE_GPRS_READ;
 650                                 wbuf_size = NET_TCP_BUFFERSIZE_GPRS_WRITE;
 651                                 break;
 652                         default:
 653                                 /* TODO: Check LTE support */
 654                                 rbuf_size = NET_TCP_BUFFERSIZE_DEFAULT_READ;
 655                                 wbuf_size = NET_TCP_BUFFERSIZE_DEFAULT_WRITE;
 656                                 break;
 657                         }
 658                         break;
 659                 }
 660         } else {
 661                 DBG("Default TCP buffer configured");
 662
 663                 rbuf_size = NET_TCP_BUFFERSIZE_DEFAULT_READ;
 664                 wbuf_size = NET_TCP_BUFFERSIZE_DEFAULT_WRITE;
 665         }
 666
 667         if (rbuf_size != NULL) {
 668                 fdr = open(NET_PROC_SYS_NET_IPV4_TCP_RMEM, O_RDWR | O_CLOEXEC);
 669
 670                 if (fdr < 0 || write(fdr, rbuf_size, strlen(rbuf_size)) < 0)
 671                         ERR("Failed to set TCP read buffer size");
 672
 673                 if (fdr >= 0)
 674                         close(fdr);
 675         }
 676
 677         if (wbuf_size != NULL) {
 678                 fdw = open(NET_PROC_SYS_NET_IPv4_TCP_WMEM, O_RDWR | O_CLOEXEC);
 679
 680                 if (fdw < 0 || write(fdw, wbuf_size, strlen(wbuf_size)) < 0)
 681                         ERR("Failed to set TCP write buffer size");
 682
 683                 if (fdw >= 0)
 684                         close(fdw);
 685         }
 686
 687         /* As default */
 688         if (rmax_size == NULL)
 689                 rmax_size = NET_TCP_BUFFERSIZE_WIFI_RMEM_MAX;
 690         if (wmax_size == NULL)
 691                 wmax_size = NET_TCP_BUFFERSIZE_WIFI_WMEM_MAX;
 692
 693         if (rmax_size != NULL) {
 694                 fdrmax = open(NET_PROC_SYS_NET_CORE_RMEM_MAX, O_RDWR | O_CLOEXEC);
 695
 696                 if (fdrmax < 0 || write(fdrmax, rmax_size, strlen(rmax_size)) < 0)
 697                         ERR("Failed to set TCP rmem_max size");
 698
 699                 if (fdrmax >= 0)
 700                         close(fdrmax);
 701         }
 702
 703         if (wmax_size != NULL) {
 704                 fdwmax = open(NET_PROC_SYS_NET_CORE_WMEM_MAX, O_RDWR | O_CLOEXEC);
 705
 706                 if (fdwmax < 0 || write(fdwmax, wmax_size, strlen(wmax_size)) < 0)
 707                         ERR("Failed to set TCP wmem_max size");
 708
 709                 if (fdwmax >= 0)
 710                         close(fdwmax);
 711         }
 712 }
 713
 714 static void __netconfig_update_default_connection_info(void)
 715 {
 716         int old_network_status = 0;
 717         const char *profile = netconfig_get_default_profile();
 718         const char *ip_addr = netconfig_get_default_ipaddress();
 719         const char *ip_addr6 = netconfig_get_default_ipaddress6();
 720         const char *proxy_addr = netconfig_get_default_proxy();
 721         unsigned int freq = netconfig_get_default_frequency();
 722         GVariantBuilder *builder;
 723         GVariant *params;
 724
 725         if (emulator_is_emulated() == TRUE) {
 726                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 727
 728                 if (ip_addr != NULL) {
 729                         netconfig_set_vconf_str(VCONFKEY_NETWORK_IP, ip_addr);
 730                         g_variant_builder_add(builder, "{sv}", "IPv4Address",
 731                                                                   g_variant_new_string(ip_addr));
 732                 } else {
 733                         netconfig_set_vconf_str(VCONFKEY_NETWORK_IP, "");
 734                         g_variant_builder_add(builder, "{sv}", "IPv4Address",
 735                                                                   g_variant_new_string(""));
 736                 }
 737
 738                 if (ip_addr6 != NULL) {
 739                         netconfig_set_vconf_str(VCONFKEY_NETWORK_IP6, ip_addr6);
 740                         g_variant_builder_add(builder, "{sv}", "IPv6Address",
 741                                                                   g_variant_new_string(ip_addr6));
 742                 } else {
 743                         netconfig_set_vconf_str(VCONFKEY_NETWORK_IP6, "");
 744                         g_variant_builder_add(builder, "{sv}", "IPv6Address",
 745                                                                   g_variant_new_string(""));
 746                 }
 747
 748                 params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 749                 g_variant_builder_unref(builder);
 750
 751                 netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
 752                                                    NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
 753                                                    params);
 754
 755                 return;
 756         }
 757
 758         if (profile == NULL)
 759                 DBG("Reset network state configuration");
 760         else
 761                 DBG("profile[%s] ipv4(%s) ipv6(%s) proxy(%s)", profile, ip_addr,
 762                         ip_addr6, proxy_addr);
 763
 764         netconfig_vconf_get_int(VCONFKEY_NETWORK_STATUS, &old_network_status);
 765
 766         if (profile == NULL && old_network_status != VCONFKEY_NETWORK_OFF) {
 767                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 768
 769                 netconfig_set_vconf_int(VCONFKEY_NETWORK_STATUS, VCONFKEY_NETWORK_OFF);
 770                 g_variant_builder_add(builder, "{sv}", "NetworkStatus",
 771                                                           g_variant_new_int32(VCONFKEY_NETWORK_OFF));
 772
 773                 netconfig_set_vconf_str(VCONFKEY_NETWORK_IP, "");
 774                 g_variant_builder_add(builder, "{sv}", "IPv4Address",
 775                                                           g_variant_new_string(""));
 776
 777                 netconfig_set_vconf_str(VCONFKEY_NETWORK_IP6, "");
 778                 g_variant_builder_add(builder, "{sv}", "IPv6Address",
 779                                                           g_variant_new_string(""));
 780
 781                 netconfig_set_vconf_str(VCONFKEY_NETWORK_PROXY, "");
 782                 g_variant_builder_add(builder, "{sv}", "ProxyAddress",
 783                                                           g_variant_new_string(""));
 784
 785                 params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 786
 787                 netconfig_set_vconf_int(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND, 0);
 788                 netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
 789                                                    NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
 790                                                    params);
 791                 netconfig_set_vconf_int("memory/private/wifi/frequency", 0);
 792
 793                 g_variant_builder_unref(builder);
 794
 795                 DBG("Successfully clear IP and PROXY up");
 796
 797                 /* Try to disable CLATD if it was enabled */
 798                 DBG("Disable clatd");
 799                 netconfig_clatd_disable();
 800         } else if (profile != NULL) {
 801                 char *old_ip = vconf_get_str(VCONFKEY_NETWORK_IP);
 802                 char *old_ip6 = vconf_get_str(VCONFKEY_NETWORK_IP6);
 803                 char *old_proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 804
 805                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 806
 807                 if (netconfig_is_wifi_profile(profile) == TRUE) {
 808                         netconfig_set_vconf_int(VCONFKEY_NETWORK_STATUS,
 809                                                                         VCONFKEY_NETWORK_WIFI);
 810                         g_variant_builder_add(builder, "{sv}", "NetworkStatus",
 811                                                           g_variant_new_int32(VCONFKEY_NETWORK_WIFI));
 812                         netconfig_set_vconf_int("memory/private/wifi/frequency", freq);
 813
 814                         netconfig_set_system_event(SYS_EVT_NETWORK_STATUS,
 815                                 EKEY_NETWORK_STATUS, EVAL_NETWORK_WIFI);
 816                 } else if (netconfig_is_cellular_profile(profile)) {
 817
 818                         if (!netconfig_is_cellular_internet_profile(profile)) {
 819                                 DBG("connection is not a internet profile - stop to update the cellular state");
 820                                 if (old_ip)
 821                                         free(old_ip);
 822                                 if (old_ip6)
 823                                         free(old_ip6);
 824                                 if (old_proxy)
 825                                         free(old_proxy);
 826                                 return;
 827                         }
 828
 829                         netconfig_set_vconf_int(VCONFKEY_NETWORK_STATUS,
 830                                                                         VCONFKEY_NETWORK_CELLULAR);
 831                         g_variant_builder_add(builder, "{sv}", "NetworkStatus",
 832                                                           g_variant_new_int32(VCONFKEY_NETWORK_CELLULAR));
 833
 834                         netconfig_set_system_event(SYS_EVT_NETWORK_STATUS,
 835                                 EKEY_NETWORK_STATUS, EVAL_NETWORK_CELLULAR);
 836                         /* Enable clatd if IPv6 is set and no IPv4 address */
 837                         if (!ip_addr && ip_addr6) {
 838                                 DBG("Enable clatd");
 839                                 netconfig_clatd_enable();
 840                         }
 841                 } else if (netconfig_is_ethernet_profile(profile) == TRUE) {
 842                         netconfig_set_vconf_int(VCONFKEY_NETWORK_STATUS,
 843                                                                         VCONFKEY_NETWORK_ETHERNET);
 844                         g_variant_builder_add(builder, "{sv}", "NetworkStatus",
 845                                                           g_variant_new_int32(VCONFKEY_NETWORK_ETHERNET));
 846                         netconfig_set_system_event(SYS_EVT_NETWORK_STATUS,
 847                                 EKEY_NETWORK_STATUS, EVAL_NETWORK_ETHERNET);
 848                 } else if (netconfig_is_bluetooth_profile(profile) == TRUE) {
 849                         netconfig_set_vconf_int(VCONFKEY_NETWORK_STATUS,
 850                                                                         VCONFKEY_NETWORK_BLUETOOTH);
 851                         g_variant_builder_add(builder, "{sv}", "NetworkStatus",
 852                                                           g_variant_new_int32(VCONFKEY_NETWORK_BLUETOOTH));
 853                         netconfig_set_system_event(SYS_EVT_NETWORK_STATUS,
 854                                 EKEY_NETWORK_STATUS, EVAL_NETWORK_BT);
 855                 } else{
 856                         netconfig_set_vconf_int(VCONFKEY_NETWORK_STATUS,
 857                                                                         VCONFKEY_NETWORK_OFF);
 858                         g_variant_builder_add(builder, "{sv}", "NetworkStatus",
 859                                                           g_variant_new_int32(VCONFKEY_NETWORK_OFF));
 860                         netconfig_set_system_event(SYS_EVT_NETWORK_STATUS,
 861                                 EKEY_NETWORK_STATUS, EVAL_NETWORK_DISCONNECTED);
 862                 }
 863
 864                 if (g_strcmp0(old_ip, ip_addr) != 0 || old_ip == NULL) {
 865                         if (ip_addr != NULL) {
 866                                 netconfig_set_vconf_str(VCONFKEY_NETWORK_IP, ip_addr);
 867                                 g_variant_builder_add(builder, "{sv}", "IPv4Address",
 868                                                                   g_variant_new_string(ip_addr));
 869                         } else if (old_ip != NULL && strlen(old_ip) > 0) {
 870                                 netconfig_set_vconf_str(VCONFKEY_NETWORK_IP, "");
 871                                 g_variant_builder_add(builder, "{sv}", "IPv4Address",
 872                                                                   g_variant_new_string(""));
 873                         }
 874                 }
 875                 if (old_ip)
 876                         free(old_ip);
 877
 878                 if (g_strcmp0(old_ip6, ip_addr6) != 0 || old_ip6 == NULL) {
 879                         if (ip_addr6 != NULL) {
 880                                 netconfig_set_vconf_str(VCONFKEY_NETWORK_IP6, ip_addr6);
 881                                 g_variant_builder_add(builder, "{sv}", "IPv6Address",
 882                                                                   g_variant_new_string(ip_addr6));
 883                         } else if (old_ip6 != NULL && strlen(old_ip6) > 0) {
 884                                 netconfig_set_vconf_str(VCONFKEY_NETWORK_IP6, "");
 885                                 g_variant_builder_add(builder, "{sv}", "IPv6Address",
 886                                                                   g_variant_new_string(""));
 887                         }
 888                 }
 889                 if (old_ip6)
 890                         free(old_ip6);
 891
 892                 if (g_strcmp0(old_proxy, proxy_addr) != 0) {
 893                         if (proxy_addr == NULL) {
 894                                 netconfig_set_vconf_str(VCONFKEY_NETWORK_PROXY, "");
 895                                 g_variant_builder_add(builder, "{sv}", "ProxyAddress",
 896                                                                   g_variant_new_string(""));
 897                         } else {
 898                                 netconfig_set_vconf_str(VCONFKEY_NETWORK_PROXY, proxy_addr);
 899                                 g_variant_builder_add(builder, "{sv}", "ProxyAddress",
 900                                                                   g_variant_new_string(proxy_addr));
 901                         }
 902                 }
 903                 if (old_proxy)
 904                         free(old_proxy);
 905
 906                 params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 907
 908                 netconfig_set_vconf_int(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND, 1);
 909                 netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
 910                                                    NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
 911                                                    params);
 912
 913                 g_variant_builder_unref(builder);
 914
 915                 DBG("Successfully update default network configuration");
 916         }
 917
 918         __netconfig_adjust_tcp_buffer_size();
 919 }
 920
 921 static gboolean __netconfig_is_tech_state_connected(void)
 922 {
 923         gboolean ret = FALSE;
 924         GVariant *message = NULL, *variant;
 925         GVariantIter *iter, *next;
 926         gchar *path;
 927         gchar *key;
 928
 929         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
 930                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
 931                         "GetTechnologies", NULL);
 932
 933         if (message == NULL) {
 934                 DBG("Fail to get technology state");
 935                 return FALSE;
 936         }
 937
 938         g_variant_get(message, "(a(oa{sv}))", &iter);
 939         while (g_variant_iter_loop(iter, "(oa{sv})", &path, &next)) {
 940                 if (path == NULL)
 941                         continue;
 942
 943                 while (g_variant_iter_loop(next, "{sv}", &key, &variant)) {
 944                         gboolean data;
 945                         if (g_strcmp0(key, "Connected") == 0) {
 946                                 data = g_variant_get_boolean(variant);
 947                                 DBG("%s [%s: %s]", path, key, data ? "True" : "False");
 948                                 if (TRUE == data) {
 949                                         ret = TRUE;
 950                                         g_free(path);
 951                                         g_free(key);
 952                                         g_variant_unref(variant);
 953                                         g_variant_iter_free(next);
 954                                         goto done;
 955                                 }
 956                         }
 957                 }
 958         }
 959
 960 done:
 961         g_variant_iter_free(iter);
 962         g_variant_unref(message);
 963
 964         return ret;
 965 }
 966
 967 static void __netconfig_update_if_service_connected(void)
 968 {
 969         GVariant *message = NULL, *var;
 970         GVariantIter *iter, *next;
 971         gchar *path;
 972         gchar *key;
 973
 974         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
 975                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
 976                         "GetServices", NULL);
 977
 978         if (message == NULL) {
 979                 ERR("Failed to get services");
 980                 return;
 981         }
 982
 983         g_variant_get(message, "(a(oa{sv}))", &iter);
 984         while (g_variant_iter_loop(iter, "(oa{sv})", &path, &next)) {
 985                 if (path == NULL)
 986                         continue;
 987
 988                 if (g_str_has_prefix(path,
 989                                                 CONNMAN_WIFI_SERVICE_PROFILE_PREFIX) == TRUE) {
 990                         if (g_strrstr(path + strlen(CONNMAN_WIFI_SERVICE_PROFILE_PREFIX),
 991                                                         "hidden") != NULL) {
 992                                 /* skip hidden profiles */
 993                                 continue;
 994                         }
 995                         /* Process this */
 996                 } else if (g_str_has_prefix(path,
 997                                                 CONNMAN_CELLULAR_SERVICE_PROFILE_PREFIX) == TRUE) {
 998                         /* Process this */
 999                 } else if (g_str_has_prefix(path,
1000                                                 CONNMAN_ETHERNET_SERVICE_PROFILE_PREFIX) == TRUE) {
1001                         /* Process this */
1002                 } else {
1003                         continue;
1004                 }
1005
1006                 while (g_variant_iter_loop(next, "{sv}", &key, &var)) {
1007                         if (g_strcmp0(key, "State") == 0) {
1008                                 const gchar *sdata = NULL;
1009                                 sdata = g_variant_get_string(var, NULL);
1010                                 DBG("%s [%s: %s]", path, key, sdata);
1011
1012                                 if (g_strcmp0(sdata, "online") == 0 || g_strcmp0(sdata, "ready") == 0) {
1013
1014                                         /* Found a connected WiFi / 3G service.
1015                                          * Lets update the default profile info.
1016                                          */
1017                                         netconfig_update_default_profile((const gchar*)path);
1018                                         g_free(key);
1019                                         g_free(path);
1020                                         g_variant_unref(var);
1021                                         g_variant_iter_free(next);
1022                                         goto done;
1023                                 }
1024                         }
1025                 }
1026         }
1027 done:
1028         g_variant_iter_free(iter);
1029         g_variant_unref(message);
1030
1031         return;
1032 }
1033
1034 static void __netconfig_network_notify_result(const char *sig_name, const char *key)
1035 {
1036         GVariantBuilder *builder;
1037         GVariant *params;
1038
1039         INFO("[Signal] %s %s", sig_name, key);
1040
1041         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1042         g_variant_builder_add(builder, "{sv}", "key", g_variant_new_string(key));
1043
1044         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
1045         g_variant_builder_unref(builder);
1046
1047         netconfig_dbus_emit_signal(NULL,
1048                                 NETCONFIG_NETWORK_PATH,
1049                                 NETCONFIG_NETWORK_INTERFACE,
1050                                 sig_name,
1051                                 params);
1052
1053         return;
1054 }
1055
1056 const char *netconfig_get_default_profile(void)
1057 {
1058         return netconfig_default_connection_info.profile;
1059 }
1060
1061 const char *netconfig_get_default_ifname(void)
1062 {
1063         return netconfig_default_connection_info.ifname;
1064 }
1065
1066 const char *netconfig_get_default_ipaddress(void)
1067 {
1068         return netconfig_default_connection_info.ipaddress;
1069 }
1070
1071 const char *netconfig_get_default_ipaddress6(void)
1072 {
1073         return netconfig_default_connection_info.ipaddress6;
1074 }
1075
1076 const char *netconfig_get_default_proxy(void)
1077 {
1078         return netconfig_default_connection_info.proxy;
1079 }
1080
1081 unsigned int netconfig_get_default_frequency(void)
1082 {
1083         return netconfig_default_connection_info.freq;
1084 }
1085
1086 const char *netconfig_get_default_mac_address(void)
1087 {
1088         return netconfig_default_connection_info.mac_address;
1089 }
1090
1091 const char *netconfig_wifi_get_connected_essid(const char *default_profile)
1092 {
1093         if (default_profile == NULL)
1094                 return NULL;
1095
1096         if (netconfig_is_wifi_profile(default_profile) != TRUE)
1097                 return NULL;
1098
1099         if (g_strcmp0(default_profile, netconfig_default_connection_info.profile) != 0)
1100                 return NULL;
1101
1102         return netconfig_default_connection_info.essid;
1103 }
1104
1105 gboolean netconfig_get_default_is_metered(void)
1106 {
1107         return netconfig_default_connection_info.is_metered;
1108 }
1109
1110 static int __netconfig_reset_ipv4_socket(void)
1111 {
1112         int ret;
1113         int fd;
1114         struct ifreq ifr;
1115         struct sockaddr_in sai;
1116         const char *ipaddr = netconfig_get_default_ipaddress();
1117         DBG("ipaddr-[%s]", ipaddr);
1118
1119         if (!ipaddr)
1120                 return -1;
1121
1122         fd = socket(AF_INET, SOCK_DGRAM, 0);
1123         if (fd < 0)
1124                 return -1;
1125
1126         memset(&sai, 0, sizeof(struct sockaddr_in));
1127         sai.sin_family = AF_INET;
1128         sai.sin_port = 0;
1129         if (!inet_aton(ipaddr, &sai.sin_addr)) {
1130                 DBG("fail to inet_aton()");
1131                 close(fd);
1132                 return -1;
1133         }
1134
1135         memset(&ifr, 0, sizeof(struct ifreq));
1136         memcpy(&ifr.ifr_addr, &sai, sizeof(sai));
1137         g_strlcpy((char *)ifr.ifr_name, WIFI_IFNAME, IFNAMSIZ);
1138
1139 #ifndef SIOCKILLADDR
1140 #define SIOCKILLADDR    0x8939
1141 #endif
1142
1143         ret = ioctl(fd, SIOCKILLADDR, &ifr);
1144         if (ret < 0) {
1145                 DBG("fail to ioctl[SIOCKILLADDR]");
1146                 close(fd);
1147                 return -1;
1148         }
1149
1150         close(fd);
1151         return 0;
1152 }
1153
1154 void netconfig_update_default_profile(const char *profile)
1155 {
1156         static char *old_profile = NULL;
1157
1158         /* It's automatically updated by signal-handler
1159          * DO NOT update manually
1160          *
1161          * It is going to update default connection information
1162          */
1163
1164         if (netconfig_default_connection_info.profile != NULL) {
1165
1166                 if (netconfig_is_wifi_profile(netconfig_default_connection_info.profile))
1167                         __netconfig_reset_ipv4_socket();
1168
1169                 g_free(old_profile);
1170                 old_profile = strdup(netconfig_default_connection_info.profile);
1171
1172                 g_free(netconfig_default_connection_info.profile);
1173                 netconfig_default_connection_info.profile = NULL;
1174
1175                 g_free(netconfig_default_connection_info.ifname);
1176                 netconfig_default_connection_info.ifname = NULL;
1177
1178                 g_free(netconfig_default_connection_info.ipaddress);
1179                 netconfig_default_connection_info.ipaddress = NULL;
1180
1181                 g_free(netconfig_default_connection_info.ipaddress6);
1182                 netconfig_default_connection_info.ipaddress6 = NULL;
1183
1184                 g_free(netconfig_default_connection_info.proxy);
1185                 netconfig_default_connection_info.proxy = NULL;
1186
1187                 g_free(netconfig_default_connection_info.mac_address);
1188                 netconfig_default_connection_info.mac_address = NULL;
1189
1190                 netconfig_default_connection_info.freq = 0;
1191                 netconfig_default_connection_info.is_metered = FALSE;
1192
1193                 g_free(netconfig_default_connection_info.essid);
1194                 netconfig_default_connection_info.essid = NULL;
1195         }
1196
1197         /* default profile is NULL and new connected profile is NULL */
1198         if (!profile) {
1199                 char *tmp_profile = __netconfig_get_default_profile();
1200
1201                 if (tmp_profile && netconfig_is_cellular_profile(tmp_profile) &&
1202                         !netconfig_is_cellular_internet_profile(tmp_profile)) {
1203                         DBG("not a default cellular profile");
1204                         g_free(tmp_profile);
1205                         tmp_profile = NULL;
1206                 }
1207
1208                 if (!tmp_profile) {
1209                         __netconfig_update_default_connection_info();
1210                         return;
1211                 }
1212
1213                 netconfig_default_connection_info.profile = g_strdup(tmp_profile);
1214                 __netconfig_get_default_connection_info(tmp_profile);
1215                 __netconfig_update_default_connection_info();
1216                 g_free(tmp_profile);
1217                 return;
1218         }
1219
1220         netconfig_default_connection_info.profile = g_strdup(profile);
1221         __netconfig_get_default_connection_info(profile);
1222         __netconfig_update_default_connection_info();
1223 }
1224
1225 void netconfig_update_default(void)
1226 {
1227         if (__netconfig_is_tech_state_connected() == TRUE)
1228                 __netconfig_update_if_service_connected();
1229         else
1230                 __netconfig_adjust_tcp_buffer_size();
1231 }
1232
1233 char *netconfig_get_ifname(const char *profile)
1234 {
1235         GVariant *message = NULL, *variant;
1236         GVariantIter *iter, *next, *service;
1237         gchar *obj_path;
1238         gchar *key;
1239         gchar *key1;
1240         const gchar *value = NULL;
1241         gchar *ifname = NULL;
1242         gboolean found_profile = 0;
1243
1244         if (profile == NULL)
1245                 return NULL;
1246
1247         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
1248                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
1249                         "GetServices", NULL);
1250         if (message == NULL) {
1251                 ERR("Failed to get services informations");
1252                 return NULL;
1253         }
1254
1255         g_variant_get(message, "(a(oa{sv}))", &service);
1256         while (g_variant_iter_loop(service, "(oa{sv})", &obj_path, &iter)) {
1257                 if (g_strcmp0(obj_path, profile) == 0) {
1258                         g_free(obj_path);
1259                         found_profile = 1;
1260                         break;
1261                 }
1262         }
1263
1264         if (found_profile == 0) {
1265                 ERR("Profile %s doesn't exist", profile);
1266                 g_variant_iter_free(service);
1267                 g_variant_unref(message);
1268                 return NULL;
1269         }
1270
1271         while (g_variant_iter_loop(iter, "{sv}", &key, &next)) {
1272                 if (g_strcmp0(key, "Ethernet") == 0) {
1273                         while (g_variant_iter_loop(next, "{sv}", &key1, &variant)) {
1274                                 if (g_strcmp0(key1, "Interface") == 0) {
1275                                         value = g_variant_get_string(variant, NULL);
1276                                         if (!ifname)
1277                                                 ifname = g_strdup(value);
1278                                         g_free(key1);
1279                                         g_variant_unref(variant);
1280                                         break;
1281                                 }
1282                         }
1283                 }
1284         }
1285
1286         g_variant_unref(message);
1287
1288         g_variant_iter_free(service);
1289         g_variant_iter_free(iter);
1290
1291         return ifname;
1292 }
1293
1294 /* Check Ethernet Cable Plug-in /Plug-out Status */
1295 void netconfig_network_notify_ethernet_cable_state(const char *key)
1296 {
1297         __netconfig_network_notify_result("EthernetCableState", key);
1298 }
1299
1300 static gboolean handle_add_route(
1301                 Network *object,
1302                 GDBusMethodInvocation *context,
1303                 gchar *ip_addr,
1304                 gchar *netmask,
1305                 gchar *interface,  gchar *gateway, gint address_family)
1306 {
1307         const gchar *path = ROUTE_EXEC_PATH;
1308         gchar gw_str[64] = {0,};
1309         if (gateway != NULL && strlen(gateway) > 1)
1310                 g_snprintf(gw_str, 64, "gw %s", gateway);
1311         gchar *const args[] = { "/sbin/route", "add", "-net", ip_addr, gw_str,
1312                 "netmask", netmask, "dev", interface, NULL };
1313         gchar *const envs[] = { NULL };
1314         const gchar* buf = NULL;
1315         gchar* ch = NULL;
1316         int prefix_len = 0;
1317         int pos = 0;
1318
1319         DBG("ip_addr(%s), netmask(%s), interface(%s), gateway(%s)", ip_addr, netmask, interface, gateway);
1320
1321         switch (address_family) {
1322         case AF_INET:
1323                 if (ip_addr == NULL || netmask == NULL || interface == NULL) {
1324                         ERR("Invalid parameter");
1325                         netconfig_error_invalid_parameter(context);
1326                         return TRUE;
1327                 }
1328
1329                 if (netconfig_execute_file(path, args, envs) < 0) {
1330                         DBG("Failed to add a new route");
1331                         netconfig_error_permission_denied(context);
1332                         return TRUE;
1333                 }
1334
1335                 break;
1336         case AF_INET6:
1337                 if (ip_addr == NULL || interface == NULL || gateway == NULL) {
1338                         ERR("Invalid parameter");
1339                         netconfig_error_invalid_parameter(context);
1340                         return TRUE;
1341                 }
1342
1343                 buf = ip_addr;
1344                 ch = strchr(buf, '/');
1345                 pos = ch - buf + 1;
1346                 if (ch) {
1347                         prefix_len = atoi(ch + 1);
1348                         ip_addr[pos-1] = '\0';
1349                 } else {
1350                         prefix_len = 128;
1351                 }
1352
1353                 if (netconfig_add_route_ipv6(ip_addr, interface, gateway, prefix_len) < 0) {
1354                         DBG("Failed to add a new route");
1355                         netconfig_error_permission_denied(context);
1356                         return TRUE;
1357                 }
1358                 break;
1359         default:
1360                 DBG("Unknown Address Family");
1361                 netconfig_error_invalid_parameter(context);
1362                 return TRUE;
1363         }
1364
1365         DBG("Successfully added a new route");
1366         network_complete_add_route(object, context, TRUE);
1367         return TRUE;
1368 }
1369
1370 static gboolean handle_remove_route(
1371                 Network *object,
1372                 GDBusMethodInvocation *context,
1373                 gchar *ip_addr,
1374                 gchar *netmask,
1375                 gchar *interface, gchar *gateway, gint address_family)
1376 {
1377         const char *path = ROUTE_EXEC_PATH;
1378         gchar gw_str[64] = {0,};
1379         if (gateway != NULL && strlen(gateway) > 1)
1380                 g_snprintf(gw_str, 64, "gw %s", gateway);
1381         gchar *const args[] = { "/sbin/route", "del", "-net", ip_addr, gw_str,
1382                 "netmask", netmask, "dev", interface, NULL };
1383         char *const envs[] = { NULL };
1384         const char* buf = NULL;
1385         char* ch = NULL;
1386         int prefix_len = 0;
1387         int pos = 0;
1388
1389         DBG("ip_addr(%s), netmask(%s), interface(%s), gateway(%s)", ip_addr, netmask, interface, gateway);
1390
1391         switch (address_family) {
1392         case AF_INET:
1393                 if (ip_addr == NULL || netmask == NULL || interface == NULL) {
1394                         DBG("Invalid parameter!");
1395                         netconfig_error_invalid_parameter(context);
1396                         return TRUE;
1397                 }
1398                 if (netconfig_execute_file(path, args, envs) < 0) {
1399                         DBG("Failed to remove the route");
1400                         netconfig_error_permission_denied(context);
1401                         return TRUE;
1402                 }
1403                 break;
1404         case AF_INET6:
1405                 if (ip_addr == NULL || interface == NULL || gateway == NULL) {
1406                         DBG("Invalid parameter!");
1407                         netconfig_error_invalid_parameter(context);
1408                         return TRUE;
1409                 }
1410
1411                 buf = ip_addr;
1412                 ch = strchr(buf, '/');
1413                 pos = ch - buf + 1;
1414                 if (ch) {
1415                         prefix_len = atoi(ch + 1);
1416                         ip_addr[pos-1] = '\0';
1417                 } else {
1418                         prefix_len = 128;
1419                 }
1420
1421                 if (netconfig_del_route_ipv6(ip_addr, interface, gateway, prefix_len) < 0) {
1422                         DBG("Failed to remove the route");
1423                         netconfig_error_permission_denied(context);
1424                         return TRUE;
1425                 }
1426                 break;
1427         default:
1428                 DBG("Unknown Address Family");
1429                 netconfig_error_invalid_parameter(context);
1430                 return TRUE;
1431         }
1432
1433         DBG("Successfully removed the route");
1434         network_complete_remove_route(object, context, TRUE);
1435         return TRUE;
1436 }
1437
1438 static gboolean handle_check_get_privilege(Network *object,
1439                 GDBusMethodInvocation *context)
1440 {
1441         network_complete_check_get_privilege(object, context);
1442         return TRUE;
1443 }
1444
1445
1446 static gboolean handle_check_profile_privilege(Network *object,
1447                 GDBusMethodInvocation *context)
1448 {
1449         network_complete_check_profile_privilege(object, context);
1450         return TRUE;
1451 }
1452
1453 static gboolean handle_check_internet_privilege(Network *object,
1454                 GDBusMethodInvocation *context)
1455 {
1456         network_complete_check_internet_privilege(object, context);
1457         return TRUE;
1458 }
1459
1460 gboolean handle_ethernet_cable_state(Network *object,
1461         GDBusMethodInvocation *context)
1462 {
1463         int ret = 0;
1464         int state = 0;
1465
1466         ret = netconfig_get_ethernet_cable_state(&state);
1467         if (ret != 0) {
1468                 DBG("Failed to get ethernet cable state");
1469                 netconfig_error_fail_ethernet_cable_state(context);
1470                 return TRUE;
1471         }
1472
1473         DBG("Successfully get ethernet cable state[%d]", state);
1474         network_complete_ethernet_cable_state(object, context, state);
1475         return TRUE;
1476 }
1477
1478 gboolean handle_get_metered_info(Network *object,
1479         GDBusMethodInvocation *context)
1480 {
1481         gboolean state = 0;
1482
1483         state = netconfig_get_default_is_metered();
1484
1485         DBG("Default metered state [%s]", state ? "TRUE" : "FALSE");
1486         network_complete_get_metered_info(object, context, state);
1487         return TRUE;
1488 }
1489
1490 gboolean handle_preferred_ipv6_address(Network *object,
1491         GDBusMethodInvocation *context, gchar *profile)
1492 {
1493         char *address = NULL;
1494
1495         address = __netconfig_get_preferred_ipv6_address(profile);
1496         if (address == NULL) {
1497                 DBG("Failed to get preferred IPv6 address");
1498                 netconfig_error_fail_preferred_ipv6_address(context);
1499                 return TRUE;
1500         }
1501
1502         DBG("Successfully get preferred IPv6 address[%s]", address);
1503         network_complete_preferred_ipv6_address(object, context, address);
1504         return TRUE;
1505 }
1506
1507 gboolean handle_get_battery_dn_list(Battery *object,
1508         GDBusMethodInvocation *context)
1509 {
1510         GVariantBuilder *builder = NULL;
1511         GVariant *ret_params = NULL;
1512         gchar *params_str = NULL;
1513
1514         builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
1515
1516         netconfig_battery_get_dn_list(builder);
1517
1518         ret_params = g_variant_builder_end(builder);
1519         if (ret_params) {
1520                 params_str = g_variant_print(ret_params, TRUE);
1521                 DBG("DN list [%s]", params_str);
1522         }
1523
1524         battery_complete_get_battery_dn_list(object, context, ret_params);
1525         g_variant_builder_unref(builder);
1526         return TRUE;
1527 }
1528
1529 gboolean handle_get_battery_wifi_list(Battery *object,
1530         GDBusMethodInvocation *context)
1531 {
1532         GVariantBuilder *builder = NULL;
1533         GVariant *ret_params = NULL;
1534         gchar *params_str = NULL;
1535
1536         builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
1537
1538         netconfig_battery_get_wifi_list(builder);
1539
1540         ret_params = g_variant_builder_end(builder);
1541         if (ret_params) {
1542                 params_str = g_variant_print(ret_params, TRUE);
1543                 DBG("Wi-Fi list [%s]", params_str);
1544         }
1545
1546         battery_complete_get_battery_wifi_list(object, context, ret_params);
1547         g_variant_builder_unref(builder);
1548         return TRUE;
1549 }
1550
1551 void state_object_create_and_init(void)
1552 {
1553         DBG("Creating network state object");
1554         GDBusInterfaceSkeleton *interface_network = NULL;
1555 #if defined TIZEN_DEBUG_ENABLE
1556         GDBusInterfaceSkeleton *interface_tcpdump = NULL;
1557 #endif
1558         GDBusInterfaceSkeleton *interface_battery = NULL;
1559         GDBusConnection *connection = NULL;
1560         GDBusObjectManagerServer *server = netdbus_get_state_manager();
1561         if (server == NULL)
1562                 return;
1563
1564         connection = netdbus_get_connection();
1565         g_dbus_object_manager_server_set_connection(server, connection);
1566
1567         /*Interface netconfig.network*/
1568         netconfigstate = network_skeleton_new();
1569
1570         interface_network = G_DBUS_INTERFACE_SKELETON(netconfigstate);
1571         g_signal_connect(netconfigstate, "handle-add-route",
1572                                 G_CALLBACK(handle_add_route), NULL);
1573         g_signal_connect(netconfigstate, "handle-check-get-privilege",
1574                                 G_CALLBACK(handle_check_get_privilege), NULL);
1575         g_signal_connect(netconfigstate, "handle-check-profile-privilege",
1576                                 G_CALLBACK(handle_check_profile_privilege), NULL);
1577         g_signal_connect(netconfigstate, "handle-check-internet-privilege",
1578                                 G_CALLBACK(handle_check_internet_privilege), NULL);
1579         g_signal_connect(netconfigstate, "handle-ethernet-cable-state",
1580                                 G_CALLBACK(handle_ethernet_cable_state), NULL);
1581         g_signal_connect(netconfigstate, "handle-preferred-ipv6-address",
1582                                 G_CALLBACK(handle_preferred_ipv6_address), NULL);
1583         g_signal_connect(netconfigstate, "handle-remove-route",
1584                                 G_CALLBACK(handle_remove_route), NULL);
1585         g_signal_connect(netconfigstate, "handle-launch-mdns",
1586                                 G_CALLBACK(handle_launch_mdns), NULL);
1587         g_signal_connect(netconfigstate, "handle-device-policy-set-wifi",
1588                                 G_CALLBACK(handle_device_policy_set_wifi), NULL);
1589         g_signal_connect(netconfigstate, "handle-device-policy-get-wifi",
1590                                 G_CALLBACK(handle_device_policy_get_wifi), NULL);
1591         g_signal_connect(netconfigstate, "handle-device-policy-set-wifi-profile",
1592                                 G_CALLBACK(handle_device_policy_set_wifi_profile), NULL);
1593         g_signal_connect(netconfigstate, "handle-device-policy-get-wifi-profile",
1594                                 G_CALLBACK(handle_device_policy_get_wifi_profile), NULL);
1595         g_signal_connect(netconfigstate, "handle-get-metered-info",
1596                                 G_CALLBACK(handle_get_metered_info), NULL);
1597
1598         if (!g_dbus_interface_skeleton_export(interface_network, connection,
1599                         NETCONFIG_NETWORK_STATE_PATH, NULL)) {
1600                 ERR("Export with path failed");
1601         }
1602
1603 #if defined TIZEN_DEBUG_ENABLE
1604         /*Interface netconfig.tcpdump*/
1605         tcpdump_object = tcpdump_skeleton_new();
1606
1607         interface_tcpdump = G_DBUS_INTERFACE_SKELETON(tcpdump_object);
1608         g_signal_connect(tcpdump_object, "handle-start-tcpdump",
1609                                 G_CALLBACK(handle_start_tcpdump), NULL);
1610         g_signal_connect(tcpdump_object, "handle-stop-tcpdump",
1611                                 G_CALLBACK(handle_stop_tcpdump), NULL);
1612         g_signal_connect(tcpdump_object, "handle-get-tcpdump-state",
1613                                 G_CALLBACK(handle_get_tcpdump_state), NULL);
1614
1615         if (!g_dbus_interface_skeleton_export(interface_tcpdump, connection,
1616                         NETCONFIG_NETWORK_STATE_PATH, NULL)) {
1617                 ERR("Export with path failed");
1618         }
1619 #endif
1620
1621         battery_object = battery_skeleton_new();
1622
1623         interface_battery = G_DBUS_INTERFACE_SKELETON(battery_object);
1624         g_signal_connect(battery_object, "handle-get-battery-dn-list",
1625                                 G_CALLBACK(handle_get_battery_dn_list), NULL);
1626         g_signal_connect(battery_object, "handle-get-battery-wifi-list",
1627                                 G_CALLBACK(handle_get_battery_wifi_list), NULL);
1628
1629         if (!g_dbus_interface_skeleton_export(interface_battery, connection,
1630                         NETCONFIG_NETWORK_STATE_PATH, NULL)) {
1631                 ERR("Export with path failed");
1632         }
1633 }
1634
1635 void state_object_deinit(void)
1636 {
1637         g_object_unref(netconfigstate);
1638 #if defined TIZEN_DEBUG_ENABLE
1639         g_object_unref(tcpdump_object);
1640 #endif
1641 }
1642
1643 static gboolean __netconfig_check_ipv6_address(const char *address)
1644 {
1645         unsigned char buf[sizeof(struct in6_addr)];
1646         int err;
1647
1648         if (!address)
1649                 return FALSE;
1650
1651         err = inet_pton(AF_INET6, address, buf);
1652         if (err > 0)
1653                 return TRUE;
1654
1655         return FALSE;
1656 }
1657
1658 char *netconfig_get_connected_cellular_internet_ipv6only_profile(struct clatd_ctrl_hint *hint)
1659 {
1660         GVariant *message = NULL;
1661         GVariantIter *iter = NULL;
1662         GVariantIter *next = NULL;
1663         gchar *cellular_internet_profile = NULL;
1664         gchar *object_path = NULL;
1665
1666         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
1667                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
1668                         "GetServices", NULL);
1669         if (message == NULL) {
1670                 ERR("Failed to get profiles");
1671                 return NULL;
1672         }
1673
1674         g_variant_get(message, "(a(oa{sv}))", &iter);
1675         while (g_variant_iter_loop(iter, "(oa{sv})", &object_path, &next)) {
1676                 if (object_path == NULL)
1677                         continue;
1678
1679                 if (netconfig_is_cellular_profile(object_path) == FALSE)
1680                         continue;
1681
1682                 if (netconfig_is_cellular_internet_profile(object_path) == FALSE)
1683                         continue;
1684
1685                 if (__netconfig_is_connected(next) == TRUE) {
1686                         DBG("found connected profiles");
1687                         gchar *key = NULL;
1688                         gboolean has_v4 = FALSE, has_v6 = FALSE;
1689
1690                         GVariant *variant = NULL;
1691                         while (g_variant_iter_loop(next, "{sv}", &key, &variant)) {
1692                                 if (g_strcmp0(key, "IPv4") == 0) {
1693                                         GVariantIter *ipv4_iter = NULL;
1694                                         GVariant *ipv4_variant = NULL;
1695                                         gchar *ipv4_key = NULL;
1696                                         const gchar *ipv4_value = NULL;
1697                                         g_variant_get(variant, "a{sv}", &ipv4_iter);
1698                                         while (g_variant_iter_loop(ipv4_iter, "{sv}",
1699                                                 &ipv4_key, &ipv4_variant)) {
1700                                                 if (g_strcmp0(ipv4_key, "Address") == 0) {
1701                                                         ipv4_value = g_variant_get_string(ipv4_variant, NULL);
1702                                                         DBG("ipv4: %s", ipv4_value);
1703                                                         has_v4 = TRUE;
1704                                                 }
1705                                         }
1706                                         g_variant_iter_free (ipv4_iter);
1707                                 } else if (g_strcmp0(key, "IPv6") == 0) {
1708                                         GVariantIter *ipv6_iter = NULL;
1709                                         GVariant *ipv6_variant = NULL;
1710                                         gchar *ipv6_key = NULL;
1711                                         const gchar *ipv6_value = NULL;
1712                                         g_variant_get(variant, "a{sv}", &ipv6_iter);
1713                                         while (g_variant_iter_loop(ipv6_iter, "{sv}",
1714                                                 &ipv6_key, &ipv6_variant)) {
1715                                                 if (g_strcmp0(ipv6_key, "Address") == 0) {
1716                                                         ipv6_value = g_variant_get_string(ipv6_variant, NULL);
1717                                                         DBG("ipv6: %s", ipv6_value);
1718                                                         has_v6 = TRUE;
1719                                                 }
1720                                         }
1721                                         g_variant_iter_free (ipv6_iter);
1722                                 } else if (hint && g_strcmp0(key, "Nameservers") == 0) {
1723                                         int idx = 0;
1724                                         GVariantIter *ns_iter = NULL;
1725                                         gchar *nameserver = NULL;
1726                                         g_variant_get(variant, "as", &ns_iter);
1727                                         while(g_variant_iter_loop(ns_iter, "s", &nameserver)) {
1728                                                 INFO("nameserver[%d]: %s", idx, nameserver);
1729                                                 if (idx >= MAX_DNS) {
1730                                                         INFO("index exceeded %d -- skip", idx);
1731                                                         continue;
1732                                                 }
1733                                                 if (__netconfig_check_ipv6_address(nameserver) == TRUE) {
1734                                                         hint->nameserver[idx] = g_strdup(nameserver);
1735                                                         idx++;
1736                                                 } else {
1737                                                         INFO("malformed address %s -- skip", nameserver);
1738                                                 }
1739                                         }
1740                                 }
1741                         }
1742
1743                         if (!has_v4 && has_v6) {
1744                                 DBG("found 'ipv6-only/connected/internet cellular profile'");
1745                                 cellular_internet_profile = g_strdup(object_path);
1746                                 g_free(object_path);
1747                                 g_variant_iter_free(next);
1748                                 break;
1749                         }
1750                 }
1751         }
1752         g_variant_iter_free(iter);
1753         g_variant_unref(message);
1754
1755         return cellular_internet_profile;
1756 }