src/utils/network-accessibility.c

   1 /*
   2  *  Internet-accessibility check
   3  *
   4  * Copyright 2012  Samsung Electronics Co., Ltd
   5  *
   6  * Licensed under the Flora License, Version 1.1 (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.tizenopensource.org/license
  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 <net/if.h>
  21 #include <unistd.h>
  22 #include <stdlib.h>
  23 #include <sys/ioctl.h>
  24 #include <sys/socket.h>
  25 #include <sys/inotify.h>
  26 #include <netinet/in.h>
  27 #include <arpa/inet.h>
  28 #include <netinet/if_ether.h>
  29 #include <net/if_arp.h>
  30 #include <netinet/ip.h>
  31 #include <netinet/tcp.h>
  32 #include <netinet/udp.h>
  33 #include <net/route.h>
  34 #include <glib.h>
  35 #include <gio/gio.h>
  36 #include <stdio.h>
  37 #include <errno.h>
  38 #include <string.h>
  39
  40 #include "log.h"
  41 #include "util.h"
  42 #include "wifi-agent.h"
  43 #include "netsupplicant.h"
  44 #include "network-state.h"
  45 #include "network-accessibility.h"
  46
  47 #define BUF_SIZE 2048
  48 #define NETCONFIG_INTERNET_CHECK_TIMEOUT        3
  49
  50 enum netconfig_internet_check_state {
  51         INTERNET_CHECK_STATE_NONE                       = 0,
  52         INTERNET_CHECK_STATE_DNS_CHECK          = 1,
  53         INTERNET_CHECK_STATE_PACKET_CHECK       = 2
  54 };
  55
  56 struct internet_params {
  57         int fd;
  58         char *addr;
  59         int port;
  60         guint transport_watch;
  61         guint send_watch;
  62         gboolean header_done;
  63         gboolean request_started;
  64 };
  65
  66 static const char* url_list[] = {
  67          "www.google.com",
  68          "www.msn.com",
  69          "www.yahoo.com",
  70          "m.google.com",
  71          "www.amazon.com",
  72          "www.youtube.com"
  73 };
  74
  75 #define URL_LIST_NUM            6
  76
  77 static guint timer_id = 0;
  78 static const char *proxy_addr = NULL;
  79 static gboolean perform_recheck = TRUE;
  80 struct internet_params *net_params = NULL;
  81 static gboolean is_internet_available = FALSE;
  82 static int url_index = 0;
  83 static char * redirect_url1 = NULL;
  84 static char * redirect_url2 = NULL;
  85 static enum netconfig_internet_check_state check_state = INTERNET_CHECK_STATE_NONE;
  86
  87 static GCancellable *cancellable;
  88
  89 static void __netconfig_connect_sockets(void);
  90 static void __internet_check_state(enum netconfig_internet_check_state state);
  91
  92 gboolean netconfig_get_internet_status()
  93 {
  94         return is_internet_available;
  95 }
  96
  97 static void __netconfig_update_internet_status(unsigned char *reply)
  98 {
  99         /* If the HTTP response is either 302 or 200 with redirection,
 100          * then no Internet is available */
 101         char *temp = NULL;
 102         is_internet_available = FALSE;
 103         char *saveptr = NULL;
 104
 105         if (NULL != reply) {
 106                 if ((NULL != g_strrstr((char*)reply, "HTTP/1.1 200")) &&
 107                                 (NULL != g_strrstr((char*)reply, "auth action"))) {
 108                         DBG("200 OK but redirection found so:: Internet is un-available");
 109                 } else if (NULL != g_strrstr((char*)reply, "HTTP/1.1 302")) {
 110                         DBG("302:: Internet is un-available");
 111                 } else if ((temp = g_strrstr((char*)reply, "Location:")) != NULL) {
 112                         char * location = strtok_r(temp, "\r", &saveptr);
 113                         if (location != NULL) {
 114                                 DBG("%s", location);
 115                                 if (redirect_url1 == NULL)
 116                                         redirect_url1 = g_strdup(location + strlen("Location: "));
 117                                 else if (redirect_url2 == NULL)
 118                                         redirect_url2 = g_strdup(location + strlen("Location: "));
 119
 120                                 if (redirect_url1 != NULL && redirect_url2 != NULL) {
 121                                         DBG("[%s] [%s]", redirect_url1, redirect_url2);
 122                                         if (g_strcmp0(redirect_url1, redirect_url2) == 0) {
 123                                                 DBG("Internet is un-available(Redirection to Error page)");
 124                                                 is_internet_available = FALSE;
 125                                         } else
 126                                                 is_internet_available = TRUE;
 127
 128                                         g_free(redirect_url1);
 129                                         g_free(redirect_url2);
 130                                         redirect_url1 = NULL;
 131                                         redirect_url2 = NULL;
 132                                 }
 133                         }
 134                 } else {
 135                         is_internet_available = TRUE;
 136                         DBG("Internet is available");
 137                 }
 138         }
 139
 140         if (is_internet_available == TRUE)
 141                 netconfig_send_notification_to_net_popup(NETCONFIG_DEL_PORTAL_NOTI, NULL);
 142 }
 143
 144 static gboolean __netconfig_data_activity_timeout(gpointer data)
 145 {
 146         DBG("Timer timed-out");
 147         enum netconfig_internet_check_state prev_state = (enum netconfig_internet_check_state)GPOINTER_TO_INT(data);
 148         INFO("Prev_state: state=%d (1:dns check / 2:packet check)", prev_state);
 149
 150         if (net_params == NULL)
 151                 return FALSE;
 152
 153         if (TRUE == perform_recheck && prev_state != INTERNET_CHECK_STATE_NONE) {
 154                 perform_recheck = FALSE;
 155                 if (prev_state == INTERNET_CHECK_STATE_DNS_CHECK) {
 156                         net_params->request_started = FALSE;
 157                         netconfig_check_internet_accessibility();
 158                 } else /* (state == NETCONFIG_DATA_ACTIVITY_STATE_PACKET_CHECK) */
 159                         __netconfig_connect_sockets();
 160         } else {
 161                 perform_recheck = TRUE;
 162                 __internet_check_state(INTERNET_CHECK_STATE_NONE);
 163         }
 164
 165         return FALSE;
 166 }
 167
 168 static void __netconfig_internet_check_timer_stop(void)
 169 {
 170         if (timer_id != 0)
 171                 netconfig_stop_timer(&timer_id);
 172 }
 173
 174 static void __netconfig_internet_check_timer_start(enum netconfig_internet_check_state state)
 175 {
 176         static guint timeout = 0;
 177         if (timer_id != 0) {
 178                 DBG("netconfig_data_activity_timer is already running, so stop it");
 179                 __netconfig_internet_check_timer_stop();
 180         }
 181
 182         if (state == INTERNET_CHECK_STATE_NONE)
 183                 return;
 184         else if (state == INTERNET_CHECK_STATE_DNS_CHECK)
 185                 timeout = NETCONFIG_INTERNET_CHECK_TIMEOUT;
 186         else if (state == INTERNET_CHECK_STATE_PACKET_CHECK)
 187                 timeout = NETCONFIG_INTERNET_CHECK_TIMEOUT;
 188
 189         netconfig_start_timer_seconds(timeout,
 190                         __netconfig_data_activity_timeout,
 191                         GINT_TO_POINTER(state),
 192                         &timer_id);
 193 }
 194
 195 static void __internet_check_state(enum netconfig_internet_check_state state)
 196 {
 197         enum netconfig_internet_check_state prev_state = check_state;
 198
 199         if (prev_state == state)
 200                 return;
 201
 202         ERR("state change (%d) -> (%d)", prev_state, state);
 203         check_state = state;
 204
 205         switch (state) {
 206         case INTERNET_CHECK_STATE_DNS_CHECK:
 207                 __netconfig_internet_check_timer_start(state);
 208                 break;
 209         case INTERNET_CHECK_STATE_PACKET_CHECK:
 210                 if (prev_state == INTERNET_CHECK_STATE_DNS_CHECK)
 211                         __netconfig_internet_check_timer_stop();
 212
 213                 __netconfig_internet_check_timer_start(state);
 214                 break;
 215         case INTERNET_CHECK_STATE_NONE:
 216                 switch (prev_state) {
 217                 case INTERNET_CHECK_STATE_DNS_CHECK:
 218                 case INTERNET_CHECK_STATE_PACKET_CHECK:
 219                         __netconfig_internet_check_timer_stop();
 220                         netconfig_stop_internet_check();
 221                         break;
 222                 default:
 223                         break;
 224                 }
 225                 break;
 226         }
 227 }
 228
 229 static gboolean __received_data_event(GIOChannel *channel,
 230                 GIOCondition condition, gpointer data)
 231 {
 232         int n, fd;
 233         unsigned char buf[BUF_SIZE] = { 0, };
 234
 235         if (net_params == NULL)
 236                 return FALSE;
 237
 238         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP))
 239                 goto cleanup;
 240
 241         fd = g_io_channel_unix_get_fd(channel);
 242         if (fd < 0)
 243                 goto cleanup;
 244
 245         n = read(fd, buf, BUF_SIZE - 1);
 246         DBG("Received %d bytes[%s]", n, buf);
 247         buf[BUF_SIZE - 1] = '\0';
 248
 249         if (n < 0) {
 250                 ERR("read failed. %s", strerror(errno));
 251
 252                 goto cleanup;
 253         } else if (n == 0) {
 254                 INFO("connection closed");
 255
 256                 goto cleanup;
 257         }
 258
 259         /* We got data from server successfully */
 260         __netconfig_update_internet_status(buf);
 261         __internet_check_state(INTERNET_CHECK_STATE_NONE);
 262
 263         return TRUE;
 264
 265 cleanup:
 266         /* Fail to get data from server */
 267         __internet_check_state(INTERNET_CHECK_STATE_NONE);
 268
 269         return FALSE;
 270 }
 271
 272 static gboolean __send_data_event(GIOChannel *channel,
 273                 GIOCondition condition, gpointer data)
 274 {
 275         int n, fd;
 276         const char *request_data =
 277                         "GET /index.html HTTP/1.1\r\nHost: connman.net\r\n\r\n";
 278
 279         if (net_params == NULL)
 280                 return FALSE;
 281
 282         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP))
 283                 goto cleanup;
 284
 285         fd = g_io_channel_unix_get_fd(channel);
 286         if (fd < 0)
 287                 goto cleanup;
 288
 289         /* We don't need to send anymore. Just return here.*/
 290         /* Socket will be closed received part*/
 291         if (net_params->header_done == TRUE)
 292                 return FALSE;
 293
 294         n = send(fd, request_data, strlen(request_data), MSG_NOSIGNAL);
 295         DBG("Sent %d bytes", n);
 296
 297         if (n < 0) {
 298                 ERR("send failed. %s", strerror(errno));
 299
 300                 goto cleanup;
 301         } else if (n == 0) {
 302                 INFO("connection closed");
 303
 304                 goto cleanup;
 305         }
 306
 307         net_params->header_done = TRUE;
 308         return TRUE;
 309
 310 cleanup:
 311         __internet_check_state(INTERNET_CHECK_STATE_NONE);
 312
 313         return FALSE;
 314 }
 315
 316 static void __netconfig_connect_sockets(void)
 317 {
 318         GIOFlags flags;
 319         struct sockaddr_in addr;
 320         GIOChannel *channel = NULL;
 321         int sock;
 322
 323         if (net_params == NULL || net_params->addr == NULL)
 324                 return;
 325
 326         sock = socket(PF_INET, SOCK_STREAM, 0);
 327         if (sock < 0)
 328                 goto cleanup;
 329
 330         if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE,
 331                         WIFI_IFNAME, strlen(WIFI_IFNAME) + 1) < 0) {
 332                 ERR("Bind to device error");
 333                 close(sock);
 334                 goto cleanup;
 335         }
 336
 337         memset(&addr, 0, sizeof(struct sockaddr_in));
 338         addr.sin_family = AF_INET;
 339         addr.sin_addr.s_addr = inet_addr(net_params->addr);
 340         addr.sin_port = htons(net_params->port);
 341
 342         /* Register Watch */
 343         channel = g_io_channel_unix_new(sock);
 344
 345         flags = g_io_channel_get_flags(channel);
 346         g_io_channel_set_flags(channel, flags | G_IO_FLAG_NONBLOCK, NULL);
 347         g_io_channel_set_encoding(channel, NULL, NULL);
 348         g_io_channel_set_buffered(channel, FALSE);
 349
 350         if (connect(sock, (struct sockaddr *)&addr,
 351                         sizeof(struct sockaddr_in)) < 0) {
 352                 if (errno != EINPROGRESS) {
 353                         INFO("connect fail");
 354                         close(sock);
 355                         goto cleanup;
 356                 }
 357         }
 358
 359         DBG("Connect successful");
 360
 361         net_params->fd = sock;
 362         net_params->transport_watch = g_io_add_watch(channel,
 363                         (GIOCondition) (G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR),
 364                         (GIOFunc) __received_data_event, NULL);
 365         net_params->send_watch = g_io_add_watch(channel,
 366                         (GIOCondition) (G_IO_OUT | G_IO_HUP | G_IO_NVAL | G_IO_ERR),
 367                         (GIOFunc) __send_data_event, NULL);
 368
 369         __internet_check_state(INTERNET_CHECK_STATE_PACKET_CHECK);
 370         return;
 371
 372 cleanup:
 373         __internet_check_state(INTERNET_CHECK_STATE_NONE);
 374 }
 375
 376 static void __netconfig_obtain_host_ip_addr_cb(GObject *src,
 377                 GAsyncResult *res,
 378                 gpointer user_data)
 379 {
 380         GList *list, *cur;
 381         GInetAddress *addr;
 382         gchar *str_addr;
 383         GError *error = NULL;
 384
 385         if (net_params == NULL)
 386                 return;
 387
 388         if (check_state == INTERNET_CHECK_STATE_NONE)
 389                 return;
 390
 391         list = g_resolver_lookup_by_name_finish((GResolver *)src, res, &error);
 392         if (error != NULL) {
 393                 if (error->code == G_IO_ERROR_CANCELLED)
 394                         ERR("G_IO_ERROR_CANCELLED is called[%s]", error->message);
 395                 g_error_free(error);
 396         }
 397
 398         if (!list) {
 399                 INFO("no data");
 400                 goto cleanup;
 401         }
 402
 403         for (cur = list; cur; cur = cur->next) {
 404                 addr = cur->data;
 405                 str_addr = g_inet_address_to_string(addr);
 406                 if (!str_addr)
 407                         continue;
 408
 409                 if (net_params != NULL) {
 410                         g_free(net_params->addr);
 411                         net_params->addr = str_addr;
 412                 }
 413
 414                 g_object_unref(cur->data);
 415                 break;
 416         }
 417
 418         g_list_free(list);
 419
 420         if (net_params->addr == NULL)
 421                 goto cleanup;
 422
 423         net_params->port = 80;
 424         __netconfig_connect_sockets();
 425
 426         return;
 427
 428 cleanup:
 429         __internet_check_state(INTERNET_CHECK_STATE_NONE);
 430 }
 431
 432 gboolean __netconfig_obtain_host_ip_addr(void)
 433 {
 434         char *host, *addr, *port;
 435         char *saveptr = NULL;
 436
 437         if (net_params == NULL)
 438                 return FALSE;
 439
 440         if (net_params->request_started == TRUE)
 441                 return FALSE;
 442         else
 443                 net_params->request_started = TRUE;
 444
 445         if (net_params->addr != NULL)
 446                 return TRUE;
 447
 448         proxy_addr = netconfig_get_default_proxy();
 449         DBG("Proxy(%s)", proxy_addr);
 450
 451         if (++url_index >= URL_LIST_NUM)
 452                 url_index = 0;
 453
 454         DBG("addr (%s)", url_list[url_index]);
 455
 456         /* FIXME: domain proxy should be resolved */
 457         if (proxy_addr == NULL) {
 458                 GResolver *r = NULL;
 459                 r = g_resolver_get_default();
 460
 461                 g_resolver_lookup_by_name_async(r,
 462                                 url_list[url_index],
 463                                 cancellable,
 464                                 __netconfig_obtain_host_ip_addr_cb,
 465                                 NULL);
 466                 __internet_check_state(INTERNET_CHECK_STATE_DNS_CHECK);
 467
 468                 g_object_unref(r);
 469                 return FALSE;
 470         } else {
 471                 host = g_strdup(proxy_addr);
 472                 if (host == NULL)
 473                         goto cleanup;
 474
 475                 addr = strtok_r(host, ":", &saveptr);
 476                 if (addr == NULL)
 477                         goto cleanup;
 478
 479                 port = strrchr(proxy_addr, ':');
 480                 if (port == NULL)
 481                         goto cleanup;
 482                 else {
 483                         char *end;
 484                         int tmp = strtol(port + 1, &end, 10);
 485
 486                         if (*end == '\0') {
 487                                 *port = '\0';
 488                                 net_params->port = tmp;
 489                         }
 490                 }
 491                 g_free(net_params->addr);
 492                 net_params->addr = g_strdup(addr);
 493
 494                 g_free(host);
 495         }
 496         return TRUE;
 497
 498 cleanup:
 499         g_free(host);
 500         netconfig_stop_internet_check();
 501
 502         return FALSE;
 503 }
 504
 505 void netconfig_check_internet_accessibility(void)
 506 {
 507         ERR("::Entry");
 508
 509         if (net_params == NULL) {
 510                 net_params = g_try_malloc0(sizeof(struct internet_params));
 511                 if (net_params == NULL)
 512                         return;
 513                 net_params->fd = -1;
 514         }
 515
 516         if ((check_state != INTERNET_CHECK_STATE_NONE) || (net_params->request_started == TRUE)) {
 517                 DBG("Older query in progress");
 518                 return;
 519         }
 520
 521         is_internet_available = FALSE;
 522
 523         /* If the host IP is resolved, directly go for connecting to sockets*/
 524         if (__netconfig_obtain_host_ip_addr() == TRUE)
 525                 __netconfig_connect_sockets();
 526 }
 527
 528 void netconfig_stop_internet_check(void)
 529 {
 530         if (net_params == NULL)
 531                 return;
 532
 533         net_params->header_done = FALSE;
 534         net_params->request_started = FALSE;
 535
 536         if (g_cancellable_is_cancelled(cancellable) == FALSE) {
 537                 g_cancellable_cancel(cancellable);
 538                 ERR("g_cancellable_cancel is called and return stop_internet_check");
 539                 return;
 540         }
 541
 542         if (net_params->transport_watch > 0) {
 543                 g_source_remove(net_params->transport_watch);
 544                 net_params->transport_watch = 0;
 545         }
 546
 547         if (net_params->send_watch > 0) {
 548                 g_source_remove(net_params->send_watch);
 549                 net_params->send_watch = 0;
 550         }
 551
 552         if (net_params->fd > 0) {
 553                 close(net_params->fd);
 554                 net_params->fd = -1;
 555         }
 556
 557         if (net_params->addr != NULL) {
 558                 g_free(net_params->addr);
 559                 net_params->addr = NULL;
 560         }
 561
 562         g_free(net_params);
 563         net_params = NULL;
 564
 565         if (redirect_url1) {
 566                 g_free(redirect_url1);
 567                 redirect_url1 = NULL;
 568         }
 569
 570         if (redirect_url2) {
 571                 g_free(redirect_url2);
 572                 redirect_url2 = NULL;
 573         }
 574 }
 575
 576 void netconfig_internet_accessibility_init(void)
 577 {
 578         cancellable = g_cancellable_new();
 579 }
 580
 581 void netconfig_internet_accessibility_deinit(void)
 582 {
 583         g_object_unref(cancellable);
 584 }