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