src/utils/util.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 <app.h>
  21 #include <errno.h>
  22 #include <vconf.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <net/if.h>
  28 #include <net/route.h>
  29 #include <arpa/inet.h>
  30 #include <sys/wait.h>
  31 #include <sys/stat.h>
  32 #include <sys/ioctl.h>
  33 #include <vconf-keys.h>
  34 #include <syspopup_caller.h>
  35 #include <bundle.h>
  36 #include <bundle_internal.h>
  37 #include <eventsystem.h>
  38 #include <tzplatform_config.h>
  39
  40 #include "log.h"
  41 #include "util.h"
  42 #include "neterror.h"
  43 #include "wifi-state.h"
  44
  45 #define MAC_INFO_FILEPATH               tzplatform_mkpath(TZ_SYS_ETC, "/.mac.info")
  46 #define MAC_ADDRESS_MAX_LEN             18
  47
  48 static gboolean netconfig_device_picker_test = FALSE;
  49 static int mdnsd_ref_count = 0;
  50
  51 GKeyFile *netconfig_keyfile_load(const char *pathname)
  52 {
  53         GKeyFile *keyfile = NULL;
  54         GError *error = NULL;
  55
  56         keyfile = g_key_file_new();
  57         if (g_key_file_load_from_file(keyfile, pathname, 0, &error) != TRUE) {
  58                 DBG("Unable to open %s, error %s", pathname, error->message);
  59                 g_error_free(error);
  60
  61                 g_key_file_free(keyfile);
  62                 keyfile = NULL;
  63         }
  64
  65         DBG("loaded keyfile %s", pathname);
  66         return keyfile;
  67 }
  68
  69 void netconfig_keyfile_save(GKeyFile *keyfile, const char *pathname)
  70 {
  71         gsize size = 0;
  72         GError *error = NULL;
  73         gchar *keydata = NULL;
  74         gchar *needle = NULL, *directory = NULL;
  75
  76         directory = g_strdup(pathname);
  77         needle = g_strrstr(directory, "/");
  78
  79         if (needle != NULL)
  80                 *needle = '\0';
  81
  82         if (directory == NULL || (*directory) == '\0') {
  83                 g_free(directory);
  84                 ERR("directory is NULL");
  85                 return;
  86         }
  87
  88         if (g_file_test(directory, G_FILE_TEST_IS_DIR) != TRUE) {
  89                 if (g_mkdir_with_parents(directory,
  90                                 S_IRUSR | S_IWUSR | S_IXUSR) != 0) {
  91                         g_free(directory);
  92                         ERR("failed to make directory");
  93                         return;
  94                 }
  95         }
  96         g_free(directory);
  97
  98         keydata = g_key_file_to_data(keyfile, &size, &error);
  99         if (g_file_set_contents(pathname, keydata, size, &error) != TRUE) {
 100                 ERR("Unable to save %s, error %s", pathname, error->message);
 101                 g_error_free(error);
 102         }
 103
 104         chmod(pathname, S_IRUSR | S_IWUSR);
 105         DBG("Successfully saved keyfile %s", pathname);
 106
 107         g_free(keydata);
 108 }
 109
 110 void netconfig_start_timer_seconds(guint secs,
 111                 gboolean(*callback) (gpointer), void *user_data, guint *timer_id)
 112 {
 113         guint t_id = 0;
 114
 115         if (callback == NULL) {
 116                 ERR("callback function is NULL");
 117                 return;
 118         }
 119
 120         if ((timer_id != NULL && *timer_id != 0)) {
 121                 ERR("timer already is registered");
 122                 return;
 123         }
 124
 125         t_id = g_timeout_add_seconds(secs, callback, user_data);
 126
 127         if (t_id == 0) {
 128                 ERR("Can't add timer");
 129                 return;
 130         }
 131
 132         if (timer_id != NULL)
 133                 *timer_id = t_id;
 134 }
 135
 136 void netconfig_start_timer(guint msecs,
 137                 gboolean(*callback) (gpointer), void *user_data, guint *timer_id)
 138 {
 139         guint t_id = 0;
 140
 141         INFO("Register timer with callback pointer (%p)", callback);
 142
 143         if (callback == NULL) {
 144                 ERR("callback function is NULL");
 145                 return;
 146         }
 147
 148         if ((timer_id != NULL && *timer_id != 0)) {
 149                 ERR("timer already is registered");
 150                 return;
 151         }
 152
 153         t_id = g_timeout_add(msecs, callback, user_data);
 154
 155         if (t_id == 0) {
 156                 ERR("Can't add timer");
 157                 return;
 158         }
 159
 160         if (timer_id != NULL)
 161                 *timer_id = t_id;
 162 }
 163
 164 void netconfig_stop_timer(guint *timer_id)
 165 {
 166         if (timer_id == NULL) {
 167                 ERR("timer is NULL");
 168                 return;
 169         }
 170
 171         if (*timer_id != 0) {
 172                 g_source_remove(*timer_id);
 173                 *timer_id = 0;
 174         }
 175 }
 176
 177 static gboolean __netconfig_test_device_picker()
 178 {
 179         char *favorite_wifi_service = NULL;
 180
 181         favorite_wifi_service = wifi_get_favorite_service();
 182         if (favorite_wifi_service != NULL) {
 183                 ERR("favorite_wifi_service is existed[%s] : Donot launch device picker", favorite_wifi_service);
 184                 g_free(favorite_wifi_service);
 185                 return FALSE;
 186         }
 187
 188         return TRUE;
 189 }
 190
 191 static void __netconfig_pop_device_picker(void)
 192 {
 193 #if defined TIZEN_WEARABLE
 194         int ret = 0;
 195         app_control_h   control = NULL;
 196
 197         ret = app_control_create(&control);
 198         if (APP_CONTROL_ERROR_NONE != ret) {
 199                 DBG("failed to create app control");
 200                 return ;
 201         }
 202
 203         app_control_add_extra_data(control, "viewtype", "scanlist");
 204
 205         app_control_set_app_id(control, "org.tizen.wifi");
 206         ret = app_control_send_launch_request(control, NULL, NULL);
 207         if (APP_CONTROL_ERROR_NONE == ret)
 208                 DBG("Launch request sent successfully");
 209
 210         app_control_destroy(control);
 211 #else
 212         bundle *b = NULL;
 213         int wifi_ug_state = 0;
 214
 215         netconfig_vconf_get_int(VCONFKEY_WIFI_UG_RUN_STATE, &wifi_ug_state);
 216         if (wifi_ug_state == VCONFKEY_WIFI_UG_RUN_STATE_ON_FOREGROUND)
 217                 return;
 218
 219         b = bundle_create();
 220
 221         DBG("Launch Wi-Fi device picker");
 222         syspopup_launch("wifi-qs", b);
 223
 224         bundle_free(b);
 225 #endif
 226 }
 227
 228 static gboolean __netconfig_wifi_try_device_picker(gpointer data)
 229 {
 230         if (__netconfig_test_device_picker() == TRUE)
 231                 __netconfig_pop_device_picker();
 232
 233         return FALSE;
 234 }
 235
 236 static guint __netconfig_wifi_device_picker_timer_id(gboolean is_set_method, guint timer_id)
 237 {
 238         static guint netconfig_wifi_device_picker_service_timer = 0;
 239
 240         if (is_set_method != TRUE)
 241                 return netconfig_wifi_device_picker_service_timer;
 242
 243         if (netconfig_wifi_device_picker_service_timer != timer_id)
 244                 netconfig_wifi_device_picker_service_timer = timer_id;
 245
 246         return netconfig_wifi_device_picker_service_timer;
 247 }
 248
 249 static void __netconfig_wifi_device_picker_set_timer_id(guint timer_id)
 250 {
 251         __netconfig_wifi_device_picker_timer_id(TRUE, timer_id);
 252 }
 253
 254 static guint __netconfig_wifi_device_picker_get_timer_id(void)
 255 {
 256         return __netconfig_wifi_device_picker_timer_id(FALSE, -1);
 257 }
 258
 259 void netconfig_wifi_enable_device_picker_test(void)
 260 {
 261         netconfig_device_picker_test = TRUE;
 262 }
 263
 264 void netconfig_wifi_device_picker_service_start(void)
 265 {
 266         const int NETCONFIG_WIFI_DEVICE_PICKER_INTERVAL = 700;
 267         guint timer_id = 0;
 268
 269         if (netconfig_device_picker_test == TRUE)
 270                 netconfig_device_picker_test = FALSE;
 271         else
 272                 return;
 273
 274         int wifi_ug_state;
 275
 276         netconfig_vconf_get_int(VCONFKEY_WIFI_UG_RUN_STATE, &wifi_ug_state);
 277         if (wifi_ug_state == VCONFKEY_WIFI_UG_RUN_STATE_ON_FOREGROUND)
 278                 return;
 279
 280         DBG("Register device picker timer with %d milliseconds", NETCONFIG_WIFI_DEVICE_PICKER_INTERVAL);
 281         netconfig_start_timer(NETCONFIG_WIFI_DEVICE_PICKER_INTERVAL, __netconfig_wifi_try_device_picker, NULL, &timer_id);
 282
 283         __netconfig_wifi_device_picker_set_timer_id(timer_id);
 284 }
 285
 286 void netconfig_wifi_device_picker_service_stop(void)
 287 {
 288         guint timer_id = 0;
 289
 290         timer_id = __netconfig_wifi_device_picker_get_timer_id();
 291         if (timer_id == 0)
 292                 return;
 293
 294         DBG("Clear device picker timer with timer_id %d", timer_id);
 295
 296         netconfig_stop_timer(&timer_id);
 297
 298         __netconfig_wifi_device_picker_set_timer_id(timer_id);
 299 }
 300
 301 gboolean netconfig_is_wifi_direct_on(void)
 302 {
 303 #if defined TIZEN_P2P_ENABLE
 304         int wifi_direct_state = 0;
 305
 306         netconfig_vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &wifi_direct_state);
 307
 308         DBG("Wi-Fi direct mode %d", wifi_direct_state);
 309         return (wifi_direct_state != 0) ? TRUE : FALSE;
 310 #else
 311         return FALSE;
 312 #endif
 313 }
 314
 315 gboolean netconfig_is_wifi_tethering_on(void)
 316 {
 317 #if defined TIZEN_TETHERING_ENABLE
 318         int wifi_tethering_state = 0;
 319
 320         netconfig_vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &wifi_tethering_state);
 321         DBG("Wi-Ti tethering mode %d", wifi_tethering_state);
 322         if (wifi_tethering_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI)
 323                 return TRUE;
 324 #endif
 325         return FALSE;
 326 }
 327
 328 gboolean netconfig_interface_up(const char *ifname)
 329 {
 330         int fd;
 331         struct ifreq ifr;
 332
 333         fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 334         if (fd < 0)
 335                 return FALSE;
 336
 337         memset(&ifr, 0, sizeof(ifr));
 338         g_strlcpy((char *)ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 339
 340         if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
 341                 close(fd);
 342                 return FALSE;
 343         }
 344
 345         ifr.ifr_flags |= (IFF_UP | IFF_DYNAMIC);
 346         if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0) {
 347                 close(fd);
 348                 return FALSE;
 349         }
 350
 351         close(fd);
 352
 353         DBG("Successfully activated wireless interface");
 354         return TRUE;
 355 }
 356
 357 gboolean netconfig_interface_down(const char *ifname)
 358 {
 359         int fd;
 360         struct ifreq ifr;
 361
 362         fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 363         if (fd < 0)
 364                 return FALSE;
 365
 366         memset(&ifr, 0, sizeof(ifr));
 367         g_strlcpy((char *)ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 368
 369         if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
 370                 close(fd);
 371                 return FALSE;
 372         }
 373
 374         ifr.ifr_flags = (ifr.ifr_flags & ~IFF_UP) | IFF_DYNAMIC;
 375         if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0) {
 376                 close(fd);
 377                 return FALSE;
 378         }
 379
 380         close(fd);
 381
 382         DBG("Successfully de-activated wireless interface");
 383         return TRUE;
 384 }
 385
 386 int netconfig_execute_file(const char *file_path,
 387                 char *const args[], char *const envs[])
 388 {
 389         pid_t pid = 0;
 390         int status = 0;
 391         int rv = 0;
 392         errno = 0;
 393         register unsigned int index = 0;
 394         char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
 395
 396         while (args[index] != NULL) {
 397                 DBG("%s", args[index]);
 398                 index++;
 399         }
 400
 401         if (!(pid = fork())) {
 402                 DBG("pid(%d), ppid (%d)", getpid(), getppid());
 403                 DBG("Inside child, exec (%s) command", file_path);
 404
 405                 errno = 0;
 406                 if (execve(file_path, args, envs) == -1) {
 407                         strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 408                         DBG("Fail to execute command (%s)", error_buf);
 409                         exit(1);
 410                 }
 411         } else if (pid > 0) {
 412                 if (waitpid(pid, &status, 0) == -1)
 413                         DBG("wait pid (%u) status (%d)", pid, status);
 414
 415                 if (WIFEXITED(status)) {
 416                         rv = WEXITSTATUS(status);
 417                         DBG("exited, status=%d", rv);
 418                 } else if (WIFSIGNALED(status)) {
 419                         DBG("killed by signal %d", WTERMSIG(status));
 420                 } else if (WIFSTOPPED(status)) {
 421                         DBG("stopped by signal %d", WSTOPSIG(status));
 422                 } else if (WIFCONTINUED(status)) {
 423                         DBG("continued");
 424                 }
 425
 426                 return rv;
 427         }
 428
 429         strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 430         DBG("failed to fork(%s)", error_buf);
 431         return -EIO;
 432 }
 433
 434 static void on_clat_handler()
 435 {
 436         pid_t clat_pid = 0;
 437         int state = 0;
 438
 439         clat_pid = waitpid(-1, &state, WNOHANG);
 440
 441         DBG("clat(%d) state(%d)", clat_pid, WEXITSTATUS(state));
 442 }
 443
 444 int netconfig_execute_clatd(const char *file_path, char *const args[])
 445 {
 446         pid_t pid = 0;
 447         int rv = 0;
 448         errno = 0;
 449         register unsigned int index = 0;
 450         char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
 451
 452         struct sigaction act;
 453         int state = 0;
 454
 455         act.sa_handler = on_clat_handler;
 456         sigemptyset(&act.sa_mask);
 457         act.sa_flags = 0;
 458
 459         state = sigaction(SIGCHLD, &act, 0);
 460         if (state != 0) {
 461                 DBG("sigaction() : %d");
 462                 return -1;
 463         }
 464
 465         while (args[index] != NULL) {
 466                 DBG("%s", args[index]);
 467                 index++;
 468         }
 469
 470         if (!(pid = fork())) {
 471                 DBG("pid(%d), ppid (%d)", getpid(), getppid());
 472                 DBG("Inside child, exec (%s) command", file_path);
 473
 474                 errno = 0;
 475                 if (execvp(file_path, args) == -1) {
 476                         strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 477                         ERR("Fail to execute command (%s)", error_buf);
 478                         return -1;
 479                 }
 480         } else if (pid > 0) {
 481                 ERR("Success to launch clatd");
 482                 return rv;
 483         }
 484
 485         strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 486         DBG("failed to fork(%s)", error_buf);
 487         return -EIO;
 488 }
 489
 490 int __netconfig_get_interface_index(const char *interface_name)
 491 {
 492         struct ifreq ifr;
 493         int sock = 0;
 494         int result = 0;
 495         char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
 496
 497         if (interface_name == NULL) {
 498                 DBG("Inteface name is NULL");
 499                 return -1;
 500         }
 501
 502         errno = 0;
 503         sock = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 504         if (sock < 0) {
 505                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 506                 DBG("Failed to create socket : %s", error_buf);
 507                 return -1;
 508         }
 509
 510         memset(&ifr, 0, sizeof(ifr));
 511         strncpy(ifr.ifr_name, interface_name, sizeof(ifr.ifr_name) - 1);
 512         result = ioctl(sock, SIOCGIFINDEX, &ifr);
 513         close(sock);
 514
 515         if (result < 0) {
 516                 DBG("Failed to get ifr index: %s", error_buf);
 517                 return -1;
 518         }
 519
 520         return ifr.ifr_ifindex;
 521 }
 522
 523 int netconfig_add_route_ipv4(gchar *ip_addr, gchar *subnet, gchar *interface, gint address_family)
 524 {
 525         struct ifreq ifr;
 526         struct rtentry rt;
 527         struct sockaddr_in addr_in;
 528         int sock;
 529         char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
 530
 531         memset(&ifr, 0, sizeof(ifr));
 532
 533         ifr.ifr_ifindex = __netconfig_get_interface_index(interface);
 534
 535         if (ifr.ifr_ifindex < 0)
 536                 return -1;
 537
 538         strncpy(ifr.ifr_name, interface, IFNAMSIZ-1);
 539
 540         memset(&rt, 0, sizeof(rt));
 541
 542         rt.rt_flags = RTF_UP | RTF_HOST;
 543         memset(&addr_in, 0, sizeof(struct sockaddr_in));
 544         addr_in.sin_family = address_family;
 545         addr_in.sin_addr.s_addr = inet_addr(ip_addr);
 546         memcpy(&rt.rt_dst, &addr_in, sizeof(rt.rt_dst));
 547
 548         memset(&addr_in, 0, sizeof(struct sockaddr_in));
 549         addr_in.sin_family = address_family;
 550         addr_in.sin_addr.s_addr = INADDR_ANY;
 551         memcpy(&rt.rt_gateway, &addr_in, sizeof(rt.rt_gateway));
 552
 553         memset(&addr_in, 0, sizeof(struct sockaddr_in));
 554         addr_in.sin_family = AF_INET;
 555         addr_in.sin_addr.s_addr = inet_addr(subnet);
 556         memcpy(&rt.rt_genmask, &addr_in, sizeof(rt.rt_genmask));
 557
 558         rt.rt_dev = ifr.ifr_name;
 559
 560         errno = 0;
 561         sock = socket(PF_INET, SOCK_DGRAM, 0);
 562
 563         if (sock < 0) {
 564                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 565                 DBG("Failed to create socket : %s", error_buf);
 566                 return -1;
 567         }
 568
 569         if (ioctl(sock, SIOCADDRT, &rt) < 0) {
 570                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 571                 DBG("Failed to set route address : %s", error_buf);
 572                 close(sock);
 573                 return -1;
 574         }
 575
 576         close(sock);
 577
 578         return 1;
 579 }
 580
 581 int netconfig_del_route_ipv4(gchar *ip_addr, gchar *subnet, gchar *interface, gint address_family)
 582 {
 583         struct ifreq ifr;
 584         struct rtentry rt;
 585         struct sockaddr_in addr_in;
 586         int sock;
 587         char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
 588
 589         memset(&ifr, 0, sizeof(ifr));
 590         ifr.ifr_ifindex = __netconfig_get_interface_index(interface);
 591
 592         if (ifr.ifr_ifindex < 0)
 593                 return -1;
 594
 595         strncpy(ifr.ifr_name, interface, IFNAMSIZ-1);
 596
 597         memset(&rt, 0, sizeof(rt));
 598
 599         rt.rt_flags = RTF_UP;
 600         memset(&addr_in, 0, sizeof(struct sockaddr_in));
 601         addr_in.sin_family = address_family;
 602         addr_in.sin_addr.s_addr = inet_addr(ip_addr);
 603         memcpy(&rt.rt_dst, &addr_in, sizeof(rt.rt_dst));
 604
 605         memset(&addr_in, 0, sizeof(struct sockaddr_in));
 606         addr_in.sin_family = address_family;
 607         addr_in.sin_addr.s_addr = inet_addr(subnet);
 608         memcpy(&rt.rt_genmask, &addr_in, sizeof(rt.rt_genmask));
 609         rt.rt_dev = ifr.ifr_name;
 610
 611         errno = 0;
 612         sock = socket(PF_INET, SOCK_DGRAM, 0);
 613
 614         if (sock < 0) {
 615                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 616                 DBG("Failed to create socket : %s", error_buf);
 617                 return -1;
 618         }
 619
 620         if (ioctl(sock, SIOCDELRT, &rt) < 0) {
 621                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 622                 DBG("Failed to set route address : %s", error_buf);
 623                 close(sock);
 624                 return -1;
 625         }
 626
 627         close(sock);
 628
 629         return 1;
 630 }
 631
 632 int netconfig_add_route_ipv6(gchar *ip_addr, gchar *interface, gchar *gateway, unsigned char prefix_len)
 633 {
 634         struct in6_rtmsg rt;
 635         int fd = 0;
 636         int err = 0;
 637         char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
 638
 639         memset(&rt, 0, sizeof(rt));
 640
 641         rt.rtmsg_dst_len = prefix_len;
 642
 643         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 644
 645         errno = 0;
 646         if (inet_pton(AF_INET6, ip_addr, &rt.rtmsg_dst) < 0) {
 647                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 648                 DBG("inet_pton failed : %s", error_buf);
 649                 return -1;
 650         }
 651
 652         if (gateway != NULL) {
 653                 rt.rtmsg_flags |= RTF_GATEWAY;
 654                 if (inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway) < 0) {
 655                         strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 656                         DBG("inet_pton failed : %s", error_buf);
 657                         return -1;
 658                 }
 659         }
 660
 661         rt.rtmsg_metric = 1;
 662
 663         fd = socket(AF_INET6, SOCK_DGRAM, 0);
 664         if (fd < 0) {
 665                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 666                 DBG("Failed to create socket : %s", error_buf);
 667                 return -1;
 668         }
 669
 670         rt.rtmsg_ifindex = 0;
 671
 672         if (interface) {
 673                 struct ifreq ifr;
 674                 memset(&ifr, 0, sizeof(ifr));
 675                 strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name)-1);
 676                 ioctl(fd, SIOCGIFINDEX, &ifr);
 677                 rt.rtmsg_ifindex = ifr.ifr_ifindex;
 678         }
 679
 680         if ((err = ioctl(fd, SIOCADDRT, &rt)) < 0) {
 681                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
 682                 DBG("Failed to add route: %s", error_buf);
 683                 close(fd);
 684                 return -1;
 685         }
 686
 687         close(fd);
 688
 689         return 1;
 690 }
 691
 692 int netconfig_del_route_ipv6(gchar *ip_addr, gchar *interface, gchar *gateway, unsigned char prefix_len)
 693 {
 694         struct in6_rtmsg rt;
 695         int fd = 0;
 696         int err = 0;
 697
 698         memset(&rt, 0, sizeof(rt));
 699
 700         rt.rtmsg_dst_len = prefix_len;
 701
 702         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 703
 704         if (inet_pton(AF_INET6, ip_addr, &rt.rtmsg_dst) < 0) {
 705                 err = -errno;
 706                 return err;
 707         }
 708
 709         if (gateway != NULL) {
 710                 rt.rtmsg_flags |= RTF_GATEWAY;
 711                 if (inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway) < 0) {
 712                         err = -errno;
 713                         return err;
 714                 }
 715         }
 716
 717         rt.rtmsg_metric = 1;
 718
 719         fd = socket(AF_INET6, SOCK_DGRAM, 0);
 720         if (fd < 0)
 721                 return -1;
 722
 723         rt.rtmsg_ifindex = 0;
 724
 725         if (interface) {
 726                 struct ifreq ifr;
 727                 memset(&ifr, 0, sizeof(ifr));
 728                 strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name)-1);
 729                 ioctl(fd, SIOCGIFINDEX, &ifr);
 730                 rt.rtmsg_ifindex = ifr.ifr_ifindex;
 731         }
 732
 733         if ((err = ioctl(fd, SIOCDELRT, &rt)) < 0) {
 734                 DBG("Failed to del route: %d\n", err);
 735                 close(fd);
 736                 return -1;
 737         }
 738
 739         close(fd);
 740
 741         return 1;
 742 }
 743
 744 gboolean handle_launch_direct(Wifi *wifi, GDBusMethodInvocation *context)
 745 {
 746 #if defined TIZEN_P2P_ENABLE
 747         int ret = 0;
 748         DBG("Launch Wi-Fi direct daemon");
 749
 750         const char *path = "/usr/bin/wifi-direct-server.sh";
 751         char *const args[] = { "wifi-direct-server.sh", "start", NULL };
 752         char *const envs[] = { NULL };
 753
 754         ret = netconfig_execute_file(path, args, envs);
 755         if (ret < 0) {
 756                 ERR("Failed to launch Wi-Fi direct daemon");
 757                 netconfig_error_wifi_direct_failed(context);
 758                 return FALSE;
 759         }
 760
 761         wifi_complete_launch_direct(wifi, context);
 762         return TRUE;
 763 #else
 764         wifi_complete_launch_direct(wifi, context);
 765         return FALSE;
 766 #endif
 767 }
 768
 769 int execute_mdnsd_script(char* op) {
 770         const char *path = "/usr/bin/mdnsresponder-server.sh";
 771         char *const args[] = { "mdnsresponder-server.sh", op, NULL };
 772         char *const envs[] = { NULL };
 773
 774         return netconfig_execute_file(path, args, envs);
 775 }
 776
 777 gboolean handle_launch_mdns(Network *object, GDBusMethodInvocation *context)
 778 {
 779         DBG("Launch mdnsresponder daemon");
 780
 781         if (execute_mdnsd_script("start") < 0) {
 782                 ERR("Failed to launch mdnsresponder daemon");
 783                 netconfig_error_invalid_parameter(context);
 784                 return FALSE;
 785         }
 786
 787         mdnsd_ref_count++;
 788         DBG("Ref mdnsresponder daemon. ref count: %d", mdnsd_ref_count);
 789
 790         network_complete_launch_mdns(object, context);
 791         return TRUE;
 792 }
 793
 794 gboolean handle_unref_mdns(Network *object, GDBusMethodInvocation *context)
 795 {
 796         DBG("Unef mdnsresponder daemon");
 797
 798         if (mdnsd_ref_count <= 0) {
 799                 ERR("Invalid access");
 800                 netconfig_error_invalid_parameter(context);
 801                 return FALSE;
 802         }
 803
 804         mdnsd_ref_count--;
 805
 806         DBG("Unref mdnsresponder daemon. ref count: %d", mdnsd_ref_count);
 807         if (mdnsd_ref_count == 0) {
 808                 if (execute_mdnsd_script("stop") < 0) {
 809                         ERR("Failed to stop mdnsresponder daemon");
 810                         netconfig_error_invalid_parameter(context);
 811                         return FALSE;
 812                 }
 813         }
 814
 815         network_complete_unref_mdns(object, context);
 816         return TRUE;
 817 }
 818
 819 gboolean netconfig_send_notification_to_net_popup(const char * noti, const char * ssid)
 820 {
 821         int ret = 0;
 822         bundle *b;
 823         static gboolean is_found_noti_exists = FALSE;
 824         static gboolean is_portal_noti_exists = FALSE;
 825
 826         if (noti == NULL) {
 827                 ERR("Invalid notification");
 828                 return FALSE;
 829         }
 830
 831         if (g_strcmp0(noti, NETCONFIG_DEL_FOUND_AP_NOTI) == 0) {
 832                 if (is_found_noti_exists == FALSE)
 833                         return TRUE;
 834
 835                 is_found_noti_exists = FALSE;
 836         } else if (g_strcmp0(noti, NETCONFIG_ADD_FOUND_AP_NOTI) == 0) {
 837                 if (is_found_noti_exists == TRUE)
 838                         return TRUE;
 839
 840                 is_found_noti_exists = TRUE;
 841         } else if (g_strcmp0(noti, NETCONFIG_ADD_PORTAL_NOTI) == 0) {
 842                 if (is_portal_noti_exists == TRUE)
 843                         return TRUE;
 844
 845                 is_portal_noti_exists = TRUE;
 846         } else if (g_strcmp0(noti, NETCONFIG_DEL_PORTAL_NOTI) == 0) {
 847                 if (is_portal_noti_exists == FALSE)
 848                         return TRUE;
 849
 850                 is_portal_noti_exists = FALSE;
 851         }
 852
 853         b = bundle_create();
 854         bundle_add(b, "_SYSPOPUP_TYPE_", noti);
 855
 856         if (ssid != NULL) {
 857                 DBG("ssid (%s)", ssid);
 858                 bundle_add(b, "_AP_NAME_", ssid);
 859         }
 860
 861         ret = syspopup_launch("net-popup", b);
 862
 863         bundle_free(b);
 864
 865         if (ret < 0) {
 866                 ERR("Unable to launch noti-popup. Err = %d", ret);
 867                 return FALSE;
 868         }
 869
 870         DBG("Successfully sent notification (%s)", noti);
 871         return TRUE;
 872 }
 873
 874 int netconfig_send_message_to_net_popup(const char *title,
 875                 const char *content, const char *type, const char *ssid)
 876 {
 877         int ret = 0;
 878         bundle *b = bundle_create();
 879
 880         bundle_add(b, "_SYSPOPUP_TITLE_", title);
 881         bundle_add(b, "_SYSPOPUP_CONTENT_", content);
 882         bundle_add(b, "_SYSPOPUP_TYPE_", type);
 883         bundle_add(b, "_AP_NAME_", ssid);
 884
 885         ret = syspopup_launch("net-popup", b);
 886
 887         bundle_free(b);
 888
 889         return ret;
 890 }
 891
 892 int netconfig_send_restriction_to_net_popup(const char *title,
 893                 const char *type, const char *restriction)
 894 {
 895         int ret = 0;
 896         bundle *b = bundle_create();
 897
 898         bundle_add(b, "_SYSPOPUP_TITLE_", title);
 899         bundle_add(b, "_SYSPOPUP_CONTENT_", "security restriction");
 900         bundle_add(b, "_SYSPOPUP_TYPE_", type);
 901         bundle_add(b, "_RESTRICTED_TYPE_", restriction);
 902
 903         ret = syspopup_launch("net-popup", b);
 904
 905         bundle_free(b);
 906
 907         return ret;
 908 }
 909
 910 void netconfig_set_system_event(const char * sys_evt, const char * evt_key, const char * evt_val)
 911 {
 912         bundle *b = NULL;
 913
 914         DBG("System event set [%s : %s : %s]", sys_evt, evt_key, evt_val);
 915
 916         b = bundle_create();
 917         bundle_add_str(b, evt_key, evt_val);
 918         eventsystem_send_system_event(sys_evt, b);
 919         bundle_free(b);
 920 }
 921
 922 void netconfig_set_vconf_int(const char * key, int value)
 923 {
 924         int ret = 0;
 925
 926         DBG("[%s: %d]", key, value);
 927
 928         ret = vconf_set_int(key, value);
 929         if (ret != VCONF_OK)
 930                 ERR("Failed to set");
 931 }
 932
 933 void netconfig_set_vconf_str(const char * key, const char * value)
 934 {
 935         int ret = 0;
 936
 937         DBG("[%s: %s]", key, value);
 938
 939         ret = vconf_set_str(key, value);
 940         if (ret != VCONF_OK)
 941                 ERR("Failed to set");
 942 }
 943
 944 int netconfig_vconf_get_int(const char * key, int *value)
 945 {
 946         int ret = 0;
 947
 948         ret = vconf_get_int(key, value);
 949         if (ret != VCONF_OK) {
 950                 ERR("Failed to get vconfkey [%s] value", key);
 951                 return -1;
 952         }
 953
 954         return 0;
 955 }
 956
 957 int netconfig_vconf_get_bool(const char * key, int *value)
 958 {
 959         int ret = 0;
 960
 961         ret = vconf_get_bool(key, value);
 962         if (ret != VCONF_OK) {
 963                 ERR("Failed to get vconfkey [%s] value", key);
 964                 return -1;
 965         }
 966
 967         return 0;
 968 }
 969
 970 char* netconfig_get_env(const char *key)
 971 {
 972         FILE *fp;
 973         char buf[256], *entry = NULL, *value = NULL, *last;
 974         int len = 0;
 975
 976         if (!key)
 977                 return NULL;
 978
 979         fp = fopen(NETCONFIG_TIZEN_SYSTEM_ENV, "r");
 980         if (!fp)
 981                 return NULL;
 982
 983         while (fgets(buf, sizeof(buf), fp)) {
 984                 entry = buf;
 985                 entry = strtok_r(entry, "=", &last);
 986                 if (entry) {
 987                         if (strstr(entry, key)) {
 988                                 entry = strtok_r(NULL, "\n", &last);
 989                                 if (entry) {
 990                                         len = strlen(entry);
 991                                         value = (char*)malloc(len+1);
 992                                         g_strlcpy(value, entry, len+1);
 993                                 } else {
 994                                         value = (char*)malloc(sizeof(char));
 995                                         g_strlcpy(value, "\n", sizeof(char));
 996                                 }
 997                                 break;
 998                         }
 999                 }
1000         }
1001
1002         fclose(fp);
1003         return value;
1004 }
1005
1006 void netconfig_set_mac_address_from_file(void)
1007 {
1008         FILE *file = NULL;
1009         char mac_str[MAC_ADDRESS_MAX_LEN];
1010         gchar *mac_lower_str = NULL;
1011         int mac_len = 0;
1012
1013         file = fopen(MAC_INFO_FILEPATH, "r");
1014         if (file == NULL) {
1015                 ERR("Fail to open %s", MAC_INFO_FILEPATH);
1016                 return;
1017         }
1018         if (fgets(mac_str, sizeof(mac_str), file) == NULL) {
1019                 ERR("Fail to read mac address");
1020                 fclose(file);
1021                 return;
1022         }
1023
1024         mac_len = strlen(mac_str);
1025         if (mac_len < 17) {
1026                 ERR("mac.info is empty");
1027                 fclose(file);
1028                 return;
1029         }
1030
1031         mac_lower_str = g_ascii_strup(mac_str, (gssize)mac_len);
1032         netconfig_set_vconf_str(VCONFKEY_WIFI_BSSID_ADDRESS, mac_lower_str);
1033
1034         g_free(mac_lower_str);
1035         fclose(file);
1036 }