src/network-state.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012-2013 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 <aul.h>
  23
  24 #include "wifi.h"
  25 #include "log.h"
  26 #include "util.h"
  27 #include "netdbus.h"
  28 #include "neterror.h"
  29 #include "emulator.h"
  30 #include "wifi-state.h"
  31 #include "network-state.h"
  32
  33 #define NETCONFIG_NETWORK_STATE_PATH    "/net/netconfig/network"
  34 #define ROUTE_EXEC_PATH                 "/sbin/route"
  35
  36 #define PROP_DEFAULT            FALSE
  37 #define PROP_DEFAULT_STR   NULL
  38
  39
  40 gboolean netconfig_iface_network_state_add_route(
  41                 NetconfigNetworkState *master,
  42                 gchar *ip_addr, gchar *netmask,
  43                 gchar *interface, gboolean *result, GError **error);
  44
  45 gboolean netconfig_iface_network_state_remove_route(
  46                 NetconfigNetworkState *master,
  47                 gchar *ip_addr, gchar *netmask,
  48                 gchar *interface, gboolean *result, GError **error);
  49
  50 #include "netconfig-iface-network-state-glue.h"
  51
  52 enum {
  53         PROP_O,
  54         PROP_NETWORK_STATE_CONN,
  55         PROP_NETWORK_STATE_PATH,
  56 };
  57
  58 struct NetconfigNetworkStateClass {
  59         GObjectClass parent;
  60 };
  61
  62 struct NetconfigNetworkState {
  63         GObject parent;
  64
  65         DBusGConnection *conn;
  66         gchar *path;
  67 };
  68
  69 G_DEFINE_TYPE(NetconfigNetworkState, netconfig_network_state, G_TYPE_OBJECT);
  70
  71
  72 static void __netconfig_network_state_gobject_get_property(GObject *object,
  73                 guint prop_id, GValue *value, GParamSpec *pspec)
  74 {
  75         return;
  76 }
  77
  78 static void __netconfig_network_state_gobject_set_property(GObject *object,
  79                 guint prop_id, const GValue *value, GParamSpec *pspec)
  80 {
  81         NetconfigNetworkState *network_state = NETCONFIG_NETWORK_STATE(object);
  82
  83         switch (prop_id) {
  84         case PROP_NETWORK_STATE_CONN:
  85         {
  86                 network_state->conn = g_value_get_boxed(value);
  87                 INFO("network_state(%p) set conn(%p)", network_state, network_state->conn);
  88                 break;
  89         }
  90
  91         case PROP_NETWORK_STATE_PATH:
  92         {
  93                 if (network_state->path)
  94                         g_free(network_state->path);
  95
  96                 network_state->path = g_value_dup_string(value);
  97                 INFO("network_state(%p) path(%s)", network_state, network_state->path);
  98
  99                 break;
 100         }
 101
 102         default:
 103                 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 104         }
 105 }
 106
 107 static void netconfig_network_state_init(NetconfigNetworkState *network_state)
 108 {
 109         DBG("network_state initialize");
 110
 111         network_state->conn = NULL;
 112         network_state->path = g_strdup(PROP_DEFAULT_STR);
 113 }
 114
 115 static void netconfig_network_state_class_init(NetconfigNetworkStateClass *klass)
 116 {
 117         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 118
 119         DBG("class initialize");
 120
 121         object_class->get_property = __netconfig_network_state_gobject_get_property;
 122         object_class->set_property = __netconfig_network_state_gobject_set_property;
 123
 124         /* DBus register */
 125         dbus_g_object_type_install_info(NETCONFIG_TYPE_NETWORK_STATE,
 126                         &dbus_glib_netconfig_iface_network_state_object_info);
 127
 128         /* property */
 129         g_object_class_install_property(object_class, PROP_NETWORK_STATE_CONN,
 130                         g_param_spec_boxed("conn", "CONNECTION", "DBus connection",
 131                                         DBUS_TYPE_G_CONNECTION,
 132                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 133
 134         g_object_class_install_property(object_class, PROP_NETWORK_STATE_PATH,
 135                         g_param_spec_string("path", "Path", "Object path",
 136                                         PROP_DEFAULT_STR,
 137                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 138 }
 139
 140 struct netconfig_default_connection {
 141         char *profile;
 142         char *ifname;
 143         char *ipaddress;
 144         char *proxy;
 145         char *essid;
 146 };
 147
 148 static struct netconfig_default_connection
 149                                 netconfig_default_connection_info;
 150
 151 static void __netconfig_pop_3g_alert_syspoppup(void)
 152 {
 153         int rv = 0;
 154         bundle *b = NULL;
 155         int wifi_ug_state = 0;
 156
 157         vconf_get_int(VCONFKEY_WIFI_UG_RUN_STATE, &wifi_ug_state);
 158         if (wifi_ug_state == VCONFKEY_WIFI_UG_RUN_STATE_ON_FOREGROUND)
 159                 return;
 160
 161         b = bundle_create();
 162
 163         bundle_add(b, "_SYSPOPUP_TITLE_", "Cellular connection popup");
 164         bundle_add(b, "_SYSPOPUP_TYPE_", "notification");
 165         bundle_add(b, "_SYSPOPUP_CONTENT_", "connected");
 166
 167         DBG("Launch 3G alert network popup");
 168         rv = aul_launch_app("org.tizen.net-popup", b);
 169
 170         bundle_free(b);
 171 }
 172
 173 static gboolean __netconfig_is_connected(const char *profile)
 174 {
 175         gboolean is_connected = FALSE;
 176         DBusMessage *message = NULL;
 177         DBusMessageIter iter, array;
 178
 179         if (profile == NULL)
 180                 return FALSE;
 181
 182         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE, profile,
 183                         CONNMAN_SERVICE_INTERFACE, "GetProperties", NULL);
 184         if (message == NULL) {
 185                 ERR("Failed to get service properties");
 186                 return is_connected;
 187         }
 188
 189         if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
 190                 const char *ptr = dbus_message_get_error_name(message);
 191                 ERR("Error!!! Error message received [%s]", ptr);
 192                 goto done;
 193         }
 194
 195         dbus_message_iter_init(message, &iter);
 196         dbus_message_iter_recurse(&iter, &array);
 197
 198         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
 199                 DBusMessageIter entry, string;
 200                 const char *key = NULL;
 201
 202                 dbus_message_iter_recurse(&array, &entry);
 203                 dbus_message_iter_get_basic(&entry, &key);
 204
 205                 if (g_str_equal(key, "State") == TRUE) {
 206                         dbus_message_iter_next(&entry);
 207                         dbus_message_iter_recurse(&entry, &string);
 208
 209                         if (dbus_message_iter_get_arg_type(&string) == DBUS_TYPE_STRING) {
 210                                 dbus_message_iter_get_basic(&string, &key);
 211
 212                                 if (g_str_equal(key, "ready") == TRUE ||
 213                                                 g_str_equal(key, "online") == TRUE) {
 214                                         is_connected = TRUE;
 215
 216                                         break;
 217                                 }
 218                         }
 219                 }
 220
 221                 dbus_message_iter_next(&array);
 222         }
 223
 224 done:
 225         if (message != NULL)
 226                 dbus_message_unref(message);
 227
 228         return is_connected;
 229 }
 230
 231 static char *__netconfig_get_default_profile(void)
 232 {
 233         DBusMessage *message = NULL;
 234         GSList *service_profiles = NULL;
 235         GSList *list = NULL;
 236         DBusMessageIter iter, dict;
 237         char *default_profile = NULL;
 238
 239         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE,
 240                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
 241                         "GetServices", NULL);
 242         if (message == NULL) {
 243                 ERR("Failed to get profiles");
 244                 return NULL;
 245         }
 246
 247         dbus_message_iter_init(message, &iter);
 248         dbus_message_iter_recurse(&iter, &dict);
 249
 250         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
 251                 DBusMessageIter entry;
 252                 const char *object_path = NULL;
 253
 254                 dbus_message_iter_recurse(&dict, &entry);
 255                 dbus_message_iter_get_basic(&entry, &object_path);
 256
 257                 if (object_path)
 258                         service_profiles = g_slist_append(
 259                                                 service_profiles,
 260                                                 g_strdup(object_path));
 261
 262                 dbus_message_iter_next(&dict);
 263         }
 264
 265         for (list = service_profiles; list != NULL; list = list->next) {
 266                 char *profile_path = list->data;
 267
 268                 if (__netconfig_is_connected((const char *)profile_path) == TRUE) {
 269                         default_profile = g_strdup(profile_path);
 270                         break;
 271                 }
 272         }
 273
 274         g_slist_free(service_profiles);
 275
 276         dbus_message_unref(message);
 277
 278         return default_profile;
 279 }
 280
 281 static void __netconfig_get_default_connection_info(const char *profile)
 282 {
 283         DBusMessage *message = NULL;
 284         DBusMessageIter iter, array;
 285
 286         message = netconfig_invoke_dbus_method(CONNMAN_SERVICE, profile,
 287                         CONNMAN_SERVICE_INTERFACE, "GetProperties", NULL);
 288         if (message == NULL) {
 289                 ERR("Failed to get service properties");
 290                 return;
 291         }
 292
 293         if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
 294                 const char *ptr = dbus_message_get_error_name(message);
 295                 ERR("Error!!! Error message received [%s]", ptr);
 296                 goto done;
 297         }
 298
 299         dbus_message_iter_init(message, &iter);
 300         dbus_message_iter_recurse(&iter, &array);
 301
 302         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
 303                 DBusMessageIter entry, variant, string, iter1, iter2, iter3;
 304                 const char *key = NULL, *value = NULL;
 305
 306                 dbus_message_iter_recurse(&array, &entry);
 307                 dbus_message_iter_get_basic(&entry, &key);
 308
 309                 if (g_str_equal(key, "Name") == TRUE &&
 310                                 netconfig_is_wifi_profile(profile) == TRUE) {
 311                         dbus_message_iter_next(&entry);
 312                         dbus_message_iter_recurse(&entry, &string);
 313
 314                         if (dbus_message_iter_get_arg_type(&string) == DBUS_TYPE_STRING) {
 315                                 dbus_message_iter_get_basic(&string, &value);
 316
 317                                 netconfig_default_connection_info.essid = g_strdup(value);
 318                         }
 319                 } else if (g_str_equal(key, "Ethernet") == TRUE) {
 320                         dbus_message_iter_next(&entry);
 321                         dbus_message_iter_recurse(&entry, &variant);
 322                         dbus_message_iter_recurse(&variant, &iter1);
 323
 324                         while (dbus_message_iter_get_arg_type(&iter1)
 325                                         == DBUS_TYPE_DICT_ENTRY) {
 326                                 dbus_message_iter_recurse(&iter1, &iter2);
 327                                 dbus_message_iter_get_basic(&iter2, &key);
 328
 329                                 if (g_str_equal(key, "Interface") == TRUE) {
 330                                         dbus_message_iter_next(&iter2);
 331                                         dbus_message_iter_recurse(&iter2, &iter3);
 332                                         dbus_message_iter_get_basic(&iter3, &value);
 333
 334                                         netconfig_default_connection_info.ifname = g_strdup(value);
 335                                 }
 336
 337                                 dbus_message_iter_next(&iter1);
 338                         }
 339                 } else if (g_str_equal(key, "IPv4") == TRUE) {
 340                         dbus_message_iter_next(&entry);
 341                         dbus_message_iter_recurse(&entry, &variant);
 342                         dbus_message_iter_recurse(&variant, &iter1);
 343
 344                         while (dbus_message_iter_get_arg_type(&iter1)
 345                                         == DBUS_TYPE_DICT_ENTRY) {
 346                                 dbus_message_iter_recurse(&iter1, &iter2);
 347                                 dbus_message_iter_get_basic(&iter2, &key);
 348
 349                                 if (g_str_equal(key, "Address") == TRUE) {
 350                                         dbus_message_iter_next(&iter2);
 351                                         dbus_message_iter_recurse(&iter2, &iter3);
 352                                         dbus_message_iter_get_basic(&iter3, &value);
 353
 354                                         netconfig_default_connection_info.ipaddress = g_strdup(value);
 355                                 }
 356
 357                                 dbus_message_iter_next(&iter1);
 358                         }
 359                 } else if (g_str_equal(key, "IPv6") == TRUE) {
 360                         dbus_message_iter_next(&entry);
 361                         dbus_message_iter_recurse(&entry, &variant);
 362                         dbus_message_iter_recurse(&variant, &iter1);
 363
 364                         while (dbus_message_iter_get_arg_type(&iter1)
 365                                         == DBUS_TYPE_DICT_ENTRY) {
 366                                 dbus_message_iter_recurse(&iter1, &iter2);
 367                                 dbus_message_iter_get_basic(&iter2, &key);
 368
 369                                 if (g_str_equal(key, "Address") == TRUE) {
 370                                         dbus_message_iter_next(&iter2);
 371                                         dbus_message_iter_recurse(&iter2, &iter3);
 372                                         dbus_message_iter_get_basic(&iter3, &value);
 373
 374                                         netconfig_default_connection_info.ipaddress = g_strdup(value);
 375                                 }
 376
 377                                 dbus_message_iter_next(&iter1);
 378                         }
 379                 } else if (g_str_equal(key, "Proxy") == TRUE) {
 380                         dbus_message_iter_next(&entry);
 381                         dbus_message_iter_recurse(&entry, &variant);
 382                         dbus_message_iter_recurse(&variant, &iter1);
 383
 384                         while (dbus_message_iter_get_arg_type(&iter1)
 385                                         == DBUS_TYPE_DICT_ENTRY) {
 386                                 DBusMessageIter iter4;
 387
 388                                 dbus_message_iter_recurse(&iter1, &iter2);
 389                                 dbus_message_iter_get_basic(&iter2, &key);
 390
 391                                 if (g_str_equal(key, "Servers") == TRUE) {
 392                                         dbus_message_iter_next(&iter2);
 393                                         dbus_message_iter_recurse(&iter2, &iter3);
 394                                         if (dbus_message_iter_get_arg_type(&iter3)
 395                                                         != DBUS_TYPE_ARRAY)
 396                                                 break;
 397
 398                                         dbus_message_iter_recurse(&iter3, &iter4);
 399                                         if (dbus_message_iter_get_arg_type(&iter4)
 400                                                         != DBUS_TYPE_STRING)
 401                                                 break;
 402
 403                                         dbus_message_iter_get_basic(&iter4, &value);
 404                                         if (value != NULL && (strlen(value) > 0))
 405                                                 netconfig_default_connection_info.proxy = g_strdup(value);
 406
 407                                 } else if (g_str_equal(key, "Method") == TRUE) {
 408                                         dbus_message_iter_next(&iter2);
 409                                         dbus_message_iter_recurse(&iter2, &iter3);
 410                                         if (dbus_message_iter_get_arg_type(&iter3)
 411                                                         != DBUS_TYPE_STRING)
 412                                                 break;
 413
 414                                         dbus_message_iter_get_basic(&iter3, &value);
 415                                         if (g_strcmp0(value, "direct") == 0) {
 416                                                 g_free(netconfig_default_connection_info.proxy);
 417                                                 netconfig_default_connection_info.proxy = NULL;
 418
 419                                                 break;
 420                                         }
 421                                 }
 422
 423                                 dbus_message_iter_next(&iter1);
 424                         }
 425                 }
 426
 427                 dbus_message_iter_next(&array);
 428         }
 429
 430 done:
 431         if (message != NULL)
 432                 dbus_message_unref(message);
 433 }
 434
 435 static void __netconfig_update_default_connection_info(void)
 436 {
 437         int old_network_status = 0;
 438         const char *profile = netconfig_get_default_profile();
 439         const char *ip_addr = netconfig_get_default_ipaddress();
 440         const char *proxy_addr = netconfig_get_default_proxy();
 441
 442         if (netconfig_emulator_is_emulated() == TRUE)
 443                 return;
 444
 445         if (profile == NULL)
 446                 DBG("Reset network state configuration");
 447         else
 448                 DBG("%s: ip(%s) proxy(%s)", profile, ip_addr, proxy_addr);
 449
 450         vconf_get_int(VCONFKEY_NETWORK_STATUS, &old_network_status);
 451
 452         if (profile == NULL && old_network_status != VCONFKEY_NETWORK_OFF) {
 453                 vconf_set_int(VCONFKEY_NETWORK_STATUS, VCONFKEY_NETWORK_OFF);
 454
 455                 vconf_set_str(VCONFKEY_NETWORK_IP, "");
 456                 vconf_set_str(VCONFKEY_NETWORK_PROXY, "");
 457
 458                 vconf_set_int(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND, 0);
 459
 460                 DBG("Successfully clear IP and PROXY up");
 461         } else if (profile != NULL) {
 462                 char *old_ip = vconf_get_str(VCONFKEY_NETWORK_IP);
 463                 char *old_proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 464
 465                 if (netconfig_is_wifi_profile(profile) == TRUE) {
 466                         vconf_set_int(VCONFKEY_NETWORK_STATUS, VCONFKEY_NETWORK_WIFI);
 467                 } else if (netconfig_is_cellular_profile(profile) == TRUE) {
 468                         vconf_set_int(VCONFKEY_NETWORK_STATUS, VCONFKEY_NETWORK_CELLULAR);
 469
 470                         if (old_network_status != VCONFKEY_NETWORK_CELLULAR)
 471                                 __netconfig_pop_3g_alert_syspoppup();
 472                 } else if (netconfig_is_ethernet_profile(profile) == TRUE) {
 473                         vconf_set_int(VCONFKEY_NETWORK_STATUS, VCONFKEY_NETWORK_ETHERNET);
 474                 } else if (netconfig_is_bluetooth_profile(profile) == TRUE) {
 475                         vconf_set_int(VCONFKEY_NETWORK_STATUS, VCONFKEY_NETWORK_BLUETOOTH);
 476                 } else {
 477                         vconf_set_int(VCONFKEY_NETWORK_STATUS, VCONFKEY_NETWORK_OFF);
 478                 }
 479
 480                 if (g_strcmp0(old_ip, ip_addr) != 0) {
 481                         if (ip_addr == NULL)
 482                                 vconf_set_str(VCONFKEY_NETWORK_IP, "");
 483                         else
 484                                 vconf_set_str(VCONFKEY_NETWORK_IP, ip_addr);
 485                 }
 486
 487                 if (g_strcmp0(old_proxy, proxy_addr) != 0) {
 488                         if (proxy_addr == NULL)
 489                                 vconf_set_str(VCONFKEY_NETWORK_PROXY, "");
 490                         else
 491                                 vconf_set_str(VCONFKEY_NETWORK_PROXY, proxy_addr);
 492                 }
 493
 494                 vconf_set_int(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND, 1);
 495
 496                 DBG("Successfully update default network configuration");
 497         }
 498 }
 499
 500 const char *netconfig_get_default_profile(void)
 501 {
 502         return netconfig_default_connection_info.profile;
 503 }
 504
 505 const char *netconfig_get_default_ipaddress(void)
 506 {
 507         return netconfig_default_connection_info.ipaddress;
 508 }
 509
 510 const char *netconfig_get_default_proxy(void)
 511 {
 512         return netconfig_default_connection_info.proxy;
 513 }
 514
 515 const char *netconfig_wifi_get_connected_essid(const char *default_profile)
 516 {
 517         if (default_profile == NULL)
 518                 return NULL;
 519
 520         if (netconfig_is_wifi_profile(default_profile) != TRUE)
 521                 return NULL;
 522
 523         if (g_str_equal(default_profile, netconfig_default_connection_info.profile)
 524                         != TRUE)
 525                 return NULL;
 526
 527         return netconfig_default_connection_info.essid;
 528 }
 529
 530 void netconfig_set_default_profile(const char *profile)
 531 {
 532         char *default_profile = NULL;
 533
 534         /* It's automatically updated by signal-handler
 535          * DO NOT update manually
 536          *
 537          * It is going to update default connection information
 538          */
 539         if (netconfig_default_connection_info.profile != NULL) {
 540                 g_free(netconfig_default_connection_info.profile);
 541                 netconfig_default_connection_info.profile = NULL;
 542
 543                 g_free(netconfig_default_connection_info.ifname);
 544                 netconfig_default_connection_info.ifname = NULL;
 545
 546                 g_free(netconfig_default_connection_info.ipaddress);
 547                 netconfig_default_connection_info.ipaddress = NULL;
 548
 549                 g_free(netconfig_default_connection_info.proxy);
 550                 netconfig_default_connection_info.proxy = NULL;
 551
 552                 if (netconfig_wifi_state_get_service_state()
 553                                 != NETCONFIG_WIFI_CONNECTED) {
 554                         g_free(netconfig_default_connection_info.essid);
 555                         netconfig_default_connection_info.essid = NULL;
 556                 }
 557         }
 558
 559         if (profile == NULL) {
 560                 default_profile = __netconfig_get_default_profile();
 561                 if (default_profile == NULL) {
 562                         __netconfig_update_default_connection_info();
 563                         return;
 564                 }
 565         }
 566
 567         if (profile != NULL)
 568                 netconfig_default_connection_info.profile = g_strdup(profile);
 569         else
 570                 netconfig_default_connection_info.profile = default_profile;
 571
 572         __netconfig_get_default_connection_info(
 573                         netconfig_default_connection_info.profile);
 574
 575         __netconfig_update_default_connection_info();
 576 }
 577
 578 gboolean netconfig_iface_network_state_add_route(
 579                 NetconfigNetworkState *master,
 580                 gchar *ip_addr, gchar *netmask,
 581                 gchar *interface, gboolean *result, GError **error)
 582 {
 583         gboolean ret = FALSE;
 584         gboolean rv = FALSE;
 585         const char *path = ROUTE_EXEC_PATH;
 586         char *const args[] = {"route", "add",
 587                                 "-net", ip_addr,
 588                                 "netmask", netmask,
 589                                 "dev", interface,
 590                                 0};
 591         char *const envs[] = { NULL };
 592
 593         DBG("ip_addr(%s), netmask(%s), interface(%s)", ip_addr, netmask, interface);
 594
 595         if (ip_addr == NULL || netmask == NULL || interface == NULL) {
 596                 DBG("Invalid parameter!");
 597                 goto done;
 598         }
 599
 600         rv = netconfig_execute_file(path, args, envs);
 601         if (rv != TRUE) {
 602                 DBG("Failed to add a new route");
 603                 goto done;
 604         }
 605
 606         DBG("Successfully added a new route");
 607         ret = TRUE;
 608
 609 done:
 610         *result = ret;
 611         return ret;
 612 }
 613
 614 gboolean netconfig_iface_network_state_remove_route(
 615                 NetconfigNetworkState *master,
 616                 gchar *ip_addr, gchar *netmask,
 617                 gchar *interface, gboolean *result, GError **error)
 618 {
 619         gboolean ret = FALSE;
 620         gboolean rv = FALSE;
 621         const char *path = ROUTE_EXEC_PATH;
 622         char *const args[] = {"route", "del",
 623                                 "-net", ip_addr,
 624                                 "netmask", netmask,
 625                                 "dev", interface,
 626                                 0};
 627         char *const envs[] = { NULL };
 628
 629         DBG("ip_addr(%s), netmask(%s), interface(%s)", ip_addr, netmask, interface);
 630
 631         if (ip_addr == NULL || netmask == NULL || interface == NULL) {
 632                 DBG("Invalid parameter!");
 633                 goto done;
 634         }
 635
 636         rv = netconfig_execute_file(path, args, envs);
 637         if (rv != TRUE) {
 638                 DBG("Failed to remove a new route");
 639                 goto done;
 640         }
 641
 642         DBG("Successfully remove a new route");
 643         ret = TRUE;
 644
 645 done:
 646         *result = ret;
 647         return ret;
 648 }
 649
 650 gpointer netconfig_network_state_create_and_init(DBusGConnection *conn)
 651 {
 652         GObject *object;
 653
 654         g_return_val_if_fail(conn != NULL, NULL);
 655
 656         object = g_object_new(NETCONFIG_TYPE_NETWORK_STATE, "conn", conn, "path",
 657                         NETCONFIG_NETWORK_STATE_PATH, NULL);
 658
 659         INFO("create network_state(%p)", object);
 660
 661         dbus_g_connection_register_g_object(conn, NETCONFIG_NETWORK_STATE_PATH, object);
 662
 663         INFO("network_state(%p) register DBus path(%s)", object, NETCONFIG_NETWORK_STATE_PATH);
 664
 665         return object;
 666 }