gweb/gweb.c

   1 /*
   2  *
   3  *  Web service library with GLib integration
   4  *
   5  *  Copyright (C) 2009-2013  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <stdarg.h>
  32 #include <string.h>
  33 #include <sys/socket.h>
  34 #include <sys/sendfile.h>
  35 #include <sys/stat.h>
  36 #include <arpa/inet.h>
  37 #include <netdb.h>
  38 #include <net/if.h>
  39 #include <netinet/tcp.h>
  40 #include <ifaddrs.h>
  41
  42 #include "giognutls.h"
  43 #include "gresolv.h"
  44 #include "gweb.h"
  45
  46 #define DEFAULT_BUFFER_SIZE  2048
  47
  48 #define SESSION_FLAG_USE_TLS    (1 << 0)
  49
  50 enum chunk_state {
  51         CHUNK_SIZE,
  52         CHUNK_R_BODY,
  53         CHUNK_N_BODY,
  54         CHUNK_DATA,
  55 };
  56
  57 struct _GWebResult {
  58         guint16 status;
  59         const guint8 *buffer;
  60         gsize length;
  61         bool use_chunk;
  62         gchar *last_key;
  63         GHashTable *headers;
  64 };
  65
  66 struct web_session {
  67         GWeb *web;
  68
  69         char *address;
  70         char *host;
  71         uint16_t port;
  72         unsigned long flags;
  73         struct addrinfo *addr;
  74
  75         char *content_type;
  76
  77         GIOChannel *transport_channel;
  78         guint transport_watch;
  79         guint send_watch;
  80
  81         guint resolv_action;
  82         guint address_action;
  83         char *request;
  84
  85         guint8 *receive_buffer;
  86         gsize receive_space;
  87         GString *send_buffer;
  88         GString *current_header;
  89         bool header_done;
  90         bool body_done;
  91         bool more_data;
  92         bool request_started;
  93
  94         enum chunk_state chunck_state;
  95         gsize chunk_size;
  96         gsize chunk_left;
  97         gsize total_len;
  98
  99         GWebResult result;
 100
 101         GWebResultFunc result_func;
 102         GWebRouteFunc route_func;
 103         GWebInputFunc input_func;
 104         int fd;
 105         gsize length;
 106         gsize offset;
 107         gpointer user_data;
 108 };
 109
 110 struct _GWeb {
 111         int ref_count;
 112
 113         guint next_query_id;
 114
 115         int family;
 116
 117         int index;
 118         GList *session_list;
 119
 120         GResolv *resolv;
 121         char *proxy;
 122         char *accept_option;
 123         char *user_agent;
 124         char *user_agent_profile;
 125         char *http_version;
 126         bool close_connection;
 127
 128         GWebDebugFunc debug_func;
 129         gpointer debug_data;
 130 };
 131
 132 #define debug(web, format, arg...)                              \
 133         _debug(web, __FILE__, __func__, format, ## arg)
 134
 135 static void _debug(GWeb *web, const char *file, const char *caller,
 136                                                 const char *format, ...)
 137 {
 138         char str[256];
 139         va_list ap;
 140         int len;
 141
 142         if (!web->debug_func)
 143                 return;
 144
 145         va_start(ap, format);
 146
 147         if ((len = snprintf(str, sizeof(str), "%s:%s() web %p ",
 148                                                 file, caller, web)) > 0) {
 149                 if (vsnprintf(str + len, sizeof(str) - len, format, ap) > 0)
 150                         web->debug_func(str, web->debug_data);
 151         }
 152
 153         va_end(ap);
 154 }
 155
 156 static void free_session(struct web_session *session)
 157 {
 158         GWeb *web;
 159
 160         if (!session)
 161                 return;
 162
 163         g_free(session->request);
 164
 165         web = session->web;
 166
 167         if (session->address_action > 0)
 168                 g_source_remove(session->address_action);
 169
 170         if (session->resolv_action > 0)
 171                 g_resolv_cancel_lookup(web->resolv, session->resolv_action);
 172
 173         if (session->transport_watch > 0)
 174                 g_source_remove(session->transport_watch);
 175
 176         if (session->send_watch > 0)
 177                 g_source_remove(session->send_watch);
 178
 179         if (session->transport_channel)
 180                 g_io_channel_unref(session->transport_channel);
 181
 182         g_free(session->result.last_key);
 183
 184         if (session->result.headers)
 185                 g_hash_table_destroy(session->result.headers);
 186
 187         if (session->send_buffer)
 188                 g_string_free(session->send_buffer, TRUE);
 189
 190         if (session->current_header)
 191                 g_string_free(session->current_header, TRUE);
 192
 193         g_free(session->receive_buffer);
 194
 195         g_free(session->content_type);
 196
 197         g_free(session->host);
 198         g_free(session->address);
 199         if (session->addr)
 200                 freeaddrinfo(session->addr);
 201
 202         g_free(session);
 203 }
 204
 205 static void flush_sessions(GWeb *web)
 206 {
 207         GList *list;
 208
 209         for (list = g_list_first(web->session_list);
 210                                         list; list = g_list_next(list))
 211                 free_session(list->data);
 212
 213         g_list_free(web->session_list);
 214         web->session_list = NULL;
 215 }
 216
 217 GWeb *g_web_new(int index)
 218 {
 219         GWeb *web;
 220
 221         if (index < 0)
 222                 return NULL;
 223
 224         web = g_try_new0(GWeb, 1);
 225         if (!web)
 226                 return NULL;
 227
 228         web->ref_count = 1;
 229
 230         web->next_query_id = 1;
 231
 232         web->family = AF_UNSPEC;
 233
 234         web->index = index;
 235         web->session_list = NULL;
 236
 237         web->resolv = g_resolv_new(index);
 238         if (!web->resolv) {
 239                 g_free(web);
 240                 return NULL;
 241         }
 242
 243         web->accept_option = g_strdup("*/*");
 244         web->user_agent = g_strdup_printf("GWeb/%s", VERSION);
 245         web->close_connection = false;
 246
 247         return web;
 248 }
 249
 250 GWeb *g_web_ref(GWeb *web)
 251 {
 252         if (!web)
 253                 return NULL;
 254
 255         __sync_fetch_and_add(&web->ref_count, 1);
 256
 257         return web;
 258 }
 259
 260 void g_web_unref(GWeb *web)
 261 {
 262         if (!web)
 263                 return;
 264
 265         if (__sync_fetch_and_sub(&web->ref_count, 1) != 1)
 266                 return;
 267
 268         flush_sessions(web);
 269
 270         g_resolv_unref(web->resolv);
 271
 272         g_free(web->proxy);
 273
 274         g_free(web->accept_option);
 275         g_free(web->user_agent);
 276         g_free(web->user_agent_profile);
 277         g_free(web->http_version);
 278
 279         g_free(web);
 280 }
 281
 282 bool g_web_supports_tls(void)
 283 {
 284         return g_io_channel_supports_tls();
 285 }
 286
 287 void g_web_set_debug(GWeb *web, GWebDebugFunc func, gpointer user_data)
 288 {
 289         if (!web)
 290                 return;
 291
 292         web->debug_func = func;
 293         web->debug_data = user_data;
 294
 295         g_resolv_set_debug(web->resolv, func, user_data);
 296 }
 297
 298 bool g_web_set_proxy(GWeb *web, const char *proxy)
 299 {
 300         if (!web)
 301                 return false;
 302
 303         g_free(web->proxy);
 304
 305         if (!proxy) {
 306                 web->proxy = NULL;
 307                 debug(web, "clearing proxy");
 308         } else {
 309                 web->proxy = g_strdup(proxy);
 310                 debug(web, "setting proxy %s", web->proxy);
 311         }
 312
 313         return true;
 314 }
 315
 316 bool g_web_set_address_family(GWeb *web, int family)
 317 {
 318         if (!web)
 319                 return false;
 320
 321         if (family != AF_UNSPEC && family != AF_INET && family != AF_INET6)
 322                 return false;
 323
 324         web->family = family;
 325
 326         g_resolv_set_address_family(web->resolv, family);
 327
 328         return true;
 329 }
 330
 331 bool g_web_add_nameserver(GWeb *web, const char *address)
 332 {
 333         if (!web)
 334                 return false;
 335
 336         g_resolv_add_nameserver(web->resolv, address, 53, 0);
 337
 338         return true;
 339 }
 340
 341 static bool set_accept_option(GWeb *web, const char *format, va_list args)
 342 {
 343         g_free(web->accept_option);
 344
 345         if (!format) {
 346                 web->accept_option = NULL;
 347                 debug(web, "clearing accept option");
 348         } else {
 349                 web->accept_option = g_strdup_vprintf(format, args);
 350                 debug(web, "setting accept %s", web->accept_option);
 351         }
 352
 353         return true;
 354 }
 355
 356 bool g_web_set_accept(GWeb *web, const char *format, ...)
 357 {
 358         va_list args;
 359         bool result;
 360
 361         if (!web)
 362                 return false;
 363
 364         va_start(args, format);
 365         result = set_accept_option(web, format, args);
 366         va_end(args);
 367
 368         return result;
 369 }
 370
 371 static bool set_user_agent(GWeb *web, const char *format, va_list args)
 372 {
 373         g_free(web->user_agent);
 374
 375         if (!format) {
 376                 web->user_agent = NULL;
 377                 debug(web, "clearing user agent");
 378         } else {
 379                 web->user_agent = g_strdup_vprintf(format, args);
 380                 debug(web, "setting user agent %s", web->user_agent);
 381         }
 382
 383         return true;
 384 }
 385
 386 bool g_web_set_user_agent(GWeb *web, const char *format, ...)
 387 {
 388         va_list args;
 389         bool result;
 390
 391         if (!web)
 392                 return false;
 393
 394         va_start(args, format);
 395         result = set_user_agent(web, format, args);
 396         va_end(args);
 397
 398         return result;
 399 }
 400
 401 bool g_web_set_ua_profile(GWeb *web, const char *profile)
 402 {
 403         if (!web)
 404                 return false;
 405
 406         g_free(web->user_agent_profile);
 407
 408         web->user_agent_profile = g_strdup(profile);
 409         debug(web, "setting user agent profile %s", web->user_agent);
 410
 411         return true;
 412 }
 413
 414 bool g_web_set_http_version(GWeb *web, const char *version)
 415 {
 416         if (!web)
 417                 return false;
 418
 419         g_free(web->http_version);
 420
 421         if (!version) {
 422                 web->http_version = NULL;
 423                 debug(web, "clearing HTTP version");
 424         } else {
 425                 web->http_version = g_strdup(version);
 426                 debug(web, "setting HTTP version %s", web->http_version);
 427         }
 428
 429         return true;
 430 }
 431
 432 void g_web_set_close_connection(GWeb *web, bool enabled)
 433 {
 434         if (!web)
 435                 return;
 436
 437         web->close_connection = enabled;
 438 }
 439
 440 bool g_web_get_close_connection(GWeb *web)
 441 {
 442         if (!web)
 443                 return false;
 444
 445         return web->close_connection;
 446 }
 447
 448 static inline void call_result_func(struct web_session *session, guint16 status)
 449 {
 450
 451         if (!session->result_func)
 452                 return;
 453
 454         if (status != 0)
 455                 session->result.status = status;
 456
 457         session->result_func(&session->result, session->user_data);
 458
 459 }
 460
 461 static inline void call_route_func(struct web_session *session)
 462 {
 463         if (session->route_func)
 464                 session->route_func(session->address, session->addr->ai_family,
 465                                 session->web->index, session->user_data);
 466 }
 467
 468 static bool process_send_buffer(struct web_session *session)
 469 {
 470         GString *buf;
 471         gsize count, bytes_written;
 472         GIOStatus status;
 473
 474         if (!session)
 475                 return false;
 476
 477         buf = session->send_buffer;
 478         count = buf->len;
 479
 480         if (count == 0) {
 481                 if (session->request_started &&
 482                                         !session->more_data &&
 483                                         session->fd == -1)
 484                         session->body_done = true;
 485
 486                 return false;
 487         }
 488
 489         status = g_io_channel_write_chars(session->transport_channel,
 490                                         buf->str, count, &bytes_written, NULL);
 491
 492         debug(session->web, "status %u bytes to write %zu bytes written %zu",
 493                                         status, count, bytes_written);
 494
 495         if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN)
 496                 return false;
 497
 498         g_string_erase(buf, 0, bytes_written);
 499
 500         return true;
 501 }
 502
 503 static bool process_send_file(struct web_session *session)
 504 {
 505         int sk;
 506         off_t offset;
 507         ssize_t bytes_sent;
 508
 509         if (session->fd == -1)
 510                 return false;
 511
 512         if (!session->request_started || session->more_data)
 513                 return false;
 514
 515         sk = g_io_channel_unix_get_fd(session->transport_channel);
 516         if (sk < 0)
 517                 return false;
 518
 519         offset = session->offset;
 520
 521         bytes_sent = sendfile(sk, session->fd, &offset, session->length);
 522
 523         debug(session->web, "errno: %d, bytes to send %zu / bytes sent %zu",
 524                         errno, session->length, bytes_sent);
 525
 526         if (bytes_sent < 0 && errno != EAGAIN)
 527                 return false;
 528
 529         session->offset = offset;
 530         session->length -= bytes_sent;
 531
 532         if (session->length == 0) {
 533                 session->body_done = true;
 534                 return false;
 535         }
 536
 537         return true;
 538 }
 539
 540 static void process_next_chunk(struct web_session *session)
 541 {
 542         GString *buf = session->send_buffer;
 543         const guint8 *body;
 544         gsize length;
 545
 546         if (!session->input_func) {
 547                 session->more_data = false;
 548                 return;
 549         }
 550
 551         session->more_data = session->input_func(&body, &length,
 552                                                 session->user_data);
 553
 554         if (length > 0) {
 555                 g_string_append_printf(buf, "%zx\r\n", length);
 556                 g_string_append_len(buf, (char *) body, length);
 557                 g_string_append(buf, "\r\n");
 558         }
 559
 560         if (!session->more_data)
 561                 g_string_append(buf, "0\r\n\r\n");
 562 }
 563
 564 static void start_request(struct web_session *session)
 565 {
 566         GString *buf = session->send_buffer;
 567         const char *version;
 568         const guint8 *body;
 569         gsize length;
 570
 571         debug(session->web, "request %s from %s",
 572                                         session->request, session->host);
 573
 574         g_string_truncate(buf, 0);
 575
 576         if (!session->web->http_version)
 577                 version = "1.1";
 578         else
 579                 version = session->web->http_version;
 580
 581         if (!session->content_type)
 582                 g_string_append_printf(buf, "GET %s HTTP/%s\r\n",
 583                                                 session->request, version);
 584         else
 585                 g_string_append_printf(buf, "POST %s HTTP/%s\r\n",
 586                                                 session->request, version);
 587
 588         g_string_append_printf(buf, "Host: %s\r\n", session->host);
 589
 590         if (session->web->user_agent)
 591                 g_string_append_printf(buf, "User-Agent: %s\r\n",
 592                                                 session->web->user_agent);
 593
 594         if (session->web->user_agent_profile) {
 595                 g_string_append_printf(buf, "x-wap-profile: %s\r\n",
 596                                        session->web->user_agent_profile);
 597         }
 598
 599         if (session->web->accept_option)
 600                 g_string_append_printf(buf, "Accept: %s\r\n",
 601                                                 session->web->accept_option);
 602
 603         if (session->content_type) {
 604                 g_string_append_printf(buf, "Content-Type: %s\r\n",
 605                                                         session->content_type);
 606                 if (!session->input_func) {
 607                         session->more_data = false;
 608                         length = session->length;
 609                 } else
 610                         session->more_data = session->input_func(&body, &length,
 611                                                         session->user_data);
 612                 if (!session->more_data)
 613                         g_string_append_printf(buf, "Content-Length: %zu\r\n",
 614                                                                         length);
 615                 else
 616                         g_string_append(buf, "Transfer-Encoding: chunked\r\n");
 617         }
 618
 619         if (session->web->close_connection)
 620                 g_string_append(buf, "Connection: close\r\n");
 621
 622         g_string_append(buf, "\r\n");
 623
 624         if (session->content_type && length > 0) {
 625                 if (session->more_data) {
 626                         g_string_append_printf(buf, "%zx\r\n", length);
 627                         g_string_append_len(buf, (char *) body, length);
 628                         g_string_append(buf, "\r\n");
 629                 } else if (session->fd == -1)
 630                         g_string_append_len(buf, (char *) body, length);
 631         }
 632 }
 633
 634 static gboolean send_data(GIOChannel *channel, GIOCondition cond,
 635                                                 gpointer user_data)
 636 {
 637         struct web_session *session = user_data;
 638
 639         if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 640                 session->send_watch = 0;
 641                 return FALSE;
 642         }
 643
 644         if (process_send_buffer(session))
 645                 return TRUE;
 646
 647         if (process_send_file(session))
 648                 return TRUE;
 649
 650         if (!session->request_started) {
 651                 session->request_started = true;
 652                 start_request(session);
 653         } else if (session->more_data)
 654                 process_next_chunk(session);
 655
 656         process_send_buffer(session);
 657
 658         if (session->body_done) {
 659                 session->send_watch = 0;
 660                 return FALSE;
 661         }
 662
 663         return TRUE;
 664 }
 665
 666 static int decode_chunked(struct web_session *session,
 667                                         const guint8 *buf, gsize len)
 668 {
 669         const guint8 *ptr = buf;
 670         gsize counter;
 671
 672         while (len > 0) {
 673                 guint8 *pos;
 674                 gsize count;
 675                 char *str;
 676
 677                 switch (session->chunck_state) {
 678                 case CHUNK_SIZE:
 679                         pos = memchr(ptr, '\n', len);
 680                         if (!pos) {
 681                                 g_string_append_len(session->current_header,
 682                                                 (gchar *) ptr, len);
 683                                 return 0;
 684                         }
 685
 686                         count = pos - ptr;
 687                         if (count < 1 || ptr[count - 1] != '\r')
 688                                 return -EILSEQ;
 689
 690                         g_string_append_len(session->current_header,
 691                                                 (gchar *) ptr, count);
 692
 693                         len -= count + 1;
 694                         ptr = pos + 1;
 695
 696                         str = session->current_header->str;
 697
 698                         counter = strtoul(str, NULL, 16);
 699                         if ((counter == 0 && errno == EINVAL) ||
 700                                                 counter == ULONG_MAX)
 701                                 return -EILSEQ;
 702
 703                         session->chunk_size = counter;
 704                         session->chunk_left = counter;
 705
 706                         session->chunck_state = CHUNK_DATA;
 707                         break;
 708                 case CHUNK_R_BODY:
 709                         if (*ptr != '\r')
 710                                 return -EILSEQ;
 711                         ptr++;
 712                         len--;
 713                         session->chunck_state = CHUNK_N_BODY;
 714                         break;
 715                 case CHUNK_N_BODY:
 716                         if (*ptr != '\n')
 717                                 return -EILSEQ;
 718                         ptr++;
 719                         len--;
 720                         session->chunck_state = CHUNK_SIZE;
 721                         break;
 722                 case CHUNK_DATA:
 723                         if (session->chunk_size == 0) {
 724                                 debug(session->web, "Download Done in chunk");
 725                                 g_string_truncate(session->current_header, 0);
 726                                 return 0;
 727                         }
 728
 729                         if (session->chunk_left <= len) {
 730                                 session->result.buffer = ptr;
 731                                 session->result.length = session->chunk_left;
 732                                 call_result_func(session, 0);
 733
 734                                 len -= session->chunk_left;
 735                                 ptr += session->chunk_left;
 736
 737                                 session->total_len += session->chunk_left;
 738                                 session->chunk_left = 0;
 739
 740                                 g_string_truncate(session->current_header, 0);
 741                                 session->chunck_state = CHUNK_R_BODY;
 742                                 break;
 743                         }
 744                         /* more data */
 745                         session->result.buffer = ptr;
 746                         session->result.length = len;
 747                         call_result_func(session, 0);
 748
 749                         session->chunk_left -= len;
 750                         session->total_len += len;
 751
 752                         len -= len;
 753                         ptr += len;
 754                         break;
 755                 }
 756         }
 757
 758         return 0;
 759 }
 760
 761 static int handle_body(struct web_session *session,
 762                                 const guint8 *buf, gsize len)
 763 {
 764         int err;
 765
 766         debug(session->web, "[body] length %zu", len);
 767
 768         if (!session->result.use_chunk) {
 769                 if (len > 0) {
 770                         session->result.buffer = buf;
 771                         session->result.length = len;
 772                         call_result_func(session, 0);
 773                 }
 774                 return 0;
 775         }
 776
 777         err = decode_chunked(session, buf, len);
 778         if (err < 0) {
 779                 debug(session->web, "Error in chunk decode %d", err);
 780
 781                 session->result.buffer = NULL;
 782                 session->result.length = 0;
 783                 call_result_func(session, 400);
 784         }
 785
 786         return err;
 787 }
 788
 789 static void handle_multi_line(struct web_session *session)
 790 {
 791         gsize count;
 792         char *str;
 793         gchar *value;
 794
 795         str = session->current_header->str;
 796
 797         if (str[0] != ' ' && str[0] != '\t')
 798                 return;
 799
 800         while (str[0] == ' ' || str[0] == '\t')
 801                 str++;
 802
 803         count = str - session->current_header->str;
 804         if (count > 0) {
 805                 g_string_erase(session->current_header, 0, count);
 806                 g_string_insert_c(session->current_header, 0, ' ');
 807         }
 808
 809 #if defined TIZEN_EXT
 810         if (session->result.last_key == NULL)
 811                 return;
 812 #endif
 813         value = g_hash_table_lookup(session->result.headers,
 814                                         session->result.last_key);
 815         if (value) {
 816                 g_string_insert(session->current_header, 0, value);
 817
 818                 str = session->current_header->str;
 819
 820                 g_hash_table_replace(session->result.headers,
 821                                         g_strdup(session->result.last_key),
 822                                         g_strdup(str));
 823         }
 824 }
 825
 826 static void add_header_field(struct web_session *session)
 827 {
 828         gsize count;
 829         guint8 *pos;
 830         char *str;
 831         gchar *value;
 832         gchar *key;
 833
 834         str = session->current_header->str;
 835
 836         pos = memchr(str, ':', session->current_header->len);
 837         if (pos) {
 838                 *pos = '\0';
 839                 pos++;
 840
 841                 key = g_strdup(str);
 842
 843                 /* remove preceding white spaces */
 844                 while (*pos == ' ')
 845                         pos++;
 846
 847                 count = (char *) pos - str;
 848
 849                 g_string_erase(session->current_header, 0, count);
 850
 851                 value = g_hash_table_lookup(session->result.headers, key);
 852                 if (value) {
 853                         g_string_insert_c(session->current_header, 0, ' ');
 854                         g_string_insert_c(session->current_header, 0, ';');
 855
 856                         g_string_insert(session->current_header, 0, value);
 857                 }
 858
 859                 str = session->current_header->str;
 860                 g_hash_table_replace(session->result.headers, key,
 861                                                         g_strdup(str));
 862
 863                 g_free(session->result.last_key);
 864                 session->result.last_key = g_strdup(key);
 865         }
 866 }
 867
 868 static gboolean received_data(GIOChannel *channel, GIOCondition cond,
 869                                                         gpointer user_data)
 870 {
 871         struct web_session *session = user_data;
 872         guint8 *ptr = session->receive_buffer;
 873         gsize bytes_read;
 874         GIOStatus status;
 875
 876         if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 877                 session->transport_watch = 0;
 878                 session->result.buffer = NULL;
 879                 session->result.length = 0;
 880                 call_result_func(session, 400);
 881                 return FALSE;
 882         }
 883
 884         status = g_io_channel_read_chars(channel,
 885                                 (gchar *) session->receive_buffer,
 886                                 session->receive_space - 1, &bytes_read, NULL);
 887
 888         debug(session->web, "bytes read %zu", bytes_read);
 889
 890         if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN) {
 891                 session->transport_watch = 0;
 892                 session->result.buffer = NULL;
 893                 session->result.length = 0;
 894                 call_result_func(session, 0);
 895                 return FALSE;
 896         }
 897
 898         session->receive_buffer[bytes_read] = '\0';
 899
 900         if (session->header_done) {
 901                 if (handle_body(session, session->receive_buffer,
 902                                                         bytes_read) < 0) {
 903                         session->transport_watch = 0;
 904                         return FALSE;
 905                 }
 906                 return TRUE;
 907         }
 908
 909         while (bytes_read > 0) {
 910                 guint8 *pos;
 911                 gsize count;
 912                 char *str;
 913
 914                 pos = memchr(ptr, '\n', bytes_read);
 915                 if (!pos) {
 916                         g_string_append_len(session->current_header,
 917                                                 (gchar *) ptr, bytes_read);
 918                         return TRUE;
 919                 }
 920
 921                 *pos = '\0';
 922                 count = strlen((char *) ptr);
 923                 if (count > 0 && ptr[count - 1] == '\r') {
 924                         ptr[--count] = '\0';
 925                         bytes_read--;
 926                 }
 927
 928                 g_string_append_len(session->current_header,
 929                                                 (gchar *) ptr, count);
 930
 931                 bytes_read -= count + 1;
 932                 if (bytes_read > 0)
 933                         ptr = pos + 1;
 934                 else
 935                         ptr = NULL;
 936
 937                 if (session->current_header->len == 0) {
 938                         char *val;
 939
 940                         session->header_done = true;
 941
 942                         val = g_hash_table_lookup(session->result.headers,
 943                                                         "Transfer-Encoding");
 944                         if (val) {
 945                                 val = g_strrstr(val, "chunked");
 946                                 if (val) {
 947                                         session->result.use_chunk = true;
 948
 949                                         session->chunck_state = CHUNK_SIZE;
 950                                         session->chunk_left = 0;
 951                                         session->total_len = 0;
 952                                 }
 953                         }
 954
 955                         if (handle_body(session, ptr, bytes_read) < 0) {
 956                                 session->transport_watch = 0;
 957                                 return FALSE;
 958                         }
 959                         break;
 960                 }
 961
 962                 str = session->current_header->str;
 963
 964                 if (session->result.status == 0) {
 965                         unsigned int code;
 966
 967                         if (sscanf(str, "HTTP/%*s %u %*s", &code) == 1)
 968                                 session->result.status = code;
 969                 }
 970
 971                 debug(session->web, "[header] %s", str);
 972
 973                 /* handle multi-line header */
 974                 if (str[0] == ' ' || str[0] == '\t')
 975                         handle_multi_line(session);
 976                 else
 977                         add_header_field(session);
 978
 979                 g_string_truncate(session->current_header, 0);
 980         }
 981
 982         return TRUE;
 983 }
 984
 985 static int bind_to_address(int sk, const char *interface, int family)
 986 {
 987         struct ifaddrs *ifaddr_list, *ifaddr;
 988         int size, err = -1;
 989
 990         if (getifaddrs(&ifaddr_list) < 0)
 991                 return err;
 992
 993         for (ifaddr = ifaddr_list; ifaddr; ifaddr = ifaddr->ifa_next) {
 994                 if (g_strcmp0(ifaddr->ifa_name, interface) != 0)
 995                         continue;
 996
 997                 if (!ifaddr->ifa_addr ||
 998                                 ifaddr->ifa_addr->sa_family != family)
 999                         continue;
1000
1001                 switch (family) {
1002                 case AF_INET:
1003                         size = sizeof(struct sockaddr_in);
1004                         break;
1005                 case AF_INET6:
1006                         size = sizeof(struct sockaddr_in6);
1007                         break;
1008                 default:
1009                         continue;
1010                 }
1011
1012                 err = bind(sk, (struct sockaddr *) ifaddr->ifa_addr, size);
1013                 break;
1014         }
1015
1016         freeifaddrs(ifaddr_list);
1017         return err;
1018 }
1019
1020 static inline int bind_socket(int sk, int index, int family)
1021 {
1022         char interface[IF_NAMESIZE];
1023         int err;
1024
1025         if (!if_indextoname(index, interface))
1026                 return -1;
1027
1028         err = setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
1029                                         interface, IF_NAMESIZE);
1030         if (err < 0)
1031                 err = bind_to_address(sk, interface, family);
1032
1033         return err;
1034 }
1035
1036 static int connect_session_transport(struct web_session *session)
1037 {
1038         GIOFlags flags;
1039         int sk;
1040
1041         sk = socket(session->addr->ai_family, SOCK_STREAM | SOCK_CLOEXEC,
1042                         IPPROTO_TCP);
1043         if (sk < 0)
1044                 return -EIO;
1045
1046         if (session->web->index > 0) {
1047                 if (bind_socket(sk, session->web->index,
1048                                         session->addr->ai_family) < 0) {
1049                         debug(session->web, "bind() %s", strerror(errno));
1050                         close(sk);
1051                         return -EIO;
1052                 }
1053         }
1054
1055         if (session->flags & SESSION_FLAG_USE_TLS) {
1056                 debug(session->web, "using TLS encryption");
1057                 session->transport_channel = g_io_channel_gnutls_new(sk);
1058         } else {
1059                 debug(session->web, "no encryption");
1060                 session->transport_channel = g_io_channel_unix_new(sk);
1061         }
1062
1063         if (!session->transport_channel) {
1064                 debug(session->web, "channel missing");
1065                 close(sk);
1066                 return -ENOMEM;
1067         }
1068
1069         flags = g_io_channel_get_flags(session->transport_channel);
1070         g_io_channel_set_flags(session->transport_channel,
1071                                         flags | G_IO_FLAG_NONBLOCK, NULL);
1072
1073         g_io_channel_set_encoding(session->transport_channel, NULL, NULL);
1074         g_io_channel_set_buffered(session->transport_channel, FALSE);
1075
1076         g_io_channel_set_close_on_unref(session->transport_channel, TRUE);
1077
1078         if (connect(sk, session->addr->ai_addr,
1079                         session->addr->ai_addrlen) < 0) {
1080                 if (errno != EINPROGRESS) {
1081                         debug(session->web, "connect() %s", strerror(errno));
1082                         close(sk);
1083                         return -EIO;
1084                 }
1085         }
1086
1087         session->transport_watch = g_io_add_watch(session->transport_channel,
1088                                 G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
1089                                                 received_data, session);
1090
1091         session->send_watch = g_io_add_watch(session->transport_channel,
1092                                 G_IO_OUT | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
1093                                                 send_data, session);
1094
1095         return 0;
1096 }
1097
1098 static int create_transport(struct web_session *session)
1099 {
1100         int err;
1101
1102         err = connect_session_transport(session);
1103         if (err < 0)
1104                 return err;
1105
1106         debug(session->web, "creating session %s:%u",
1107                                         session->address, session->port);
1108
1109         return 0;
1110 }
1111
1112 static int parse_url(struct web_session *session,
1113                                 const char *url, const char *proxy)
1114 {
1115         char *scheme, *host, *port, *path;
1116
1117         scheme = g_strdup(url);
1118         if (!scheme)
1119                 return -EINVAL;
1120
1121         host = strstr(scheme, "://");
1122         if (host) {
1123                 *host = '\0';
1124                 host += 3;
1125
1126                 if (strcasecmp(scheme, "https") == 0) {
1127                         session->port = 443;
1128                         session->flags |= SESSION_FLAG_USE_TLS;
1129                 } else if (strcasecmp(scheme, "http") == 0) {
1130                         session->port = 80;
1131                 } else {
1132                         g_free(scheme);
1133                         return -EINVAL;
1134                 }
1135         } else {
1136                 host = scheme;
1137                 session->port = 80;
1138         }
1139
1140         path = strchr(host, '/');
1141         if (path)
1142                 *(path++) = '\0';
1143
1144         if (!proxy)
1145                 session->request = g_strdup_printf("/%s", path ? path : "");
1146         else
1147                 session->request = g_strdup(url);
1148
1149         port = strrchr(host, ':');
1150         if (port) {
1151                 char *end;
1152                 int tmp = strtol(port + 1, &end, 10);
1153
1154                 if (*end == '\0') {
1155                         *port = '\0';
1156                         session->port = tmp;
1157                 }
1158
1159                 if (!proxy)
1160                         session->host = g_strdup(host);
1161                 else
1162                         session->host = g_strdup_printf("%s:%u", host, tmp);
1163         } else
1164                 session->host = g_strdup(host);
1165
1166         g_free(scheme);
1167
1168         if (!proxy)
1169                 return 0;
1170
1171         scheme = g_strdup(proxy);
1172         if (!scheme)
1173                 return -EINVAL;
1174
1175         host = strstr(proxy, "://");
1176         if (host) {
1177                 *host = '\0';
1178                 host += 3;
1179
1180                 if (strcasecmp(scheme, "http") != 0) {
1181                         g_free(scheme);
1182                         return -EINVAL;
1183                 }
1184         } else
1185                 host = scheme;
1186
1187         path = strchr(host, '/');
1188         if (path)
1189                 *(path++) = '\0';
1190
1191         port = strrchr(host, ':');
1192         if (port) {
1193                 char *end;
1194                 int tmp = strtol(port + 1, &end, 10);
1195
1196                 if (*end == '\0') {
1197                         *port = '\0';
1198                         session->port = tmp;
1199                 }
1200         }
1201
1202         session->address = g_strdup(host);
1203
1204         g_free(scheme);
1205
1206         return 0;
1207 }
1208
1209 static void handle_resolved_address(struct web_session *session)
1210 {
1211         struct addrinfo hints;
1212         char *port;
1213         int ret;
1214
1215         debug(session->web, "address %s", session->address);
1216
1217         memset(&hints, 0, sizeof(struct addrinfo));
1218         hints.ai_flags = AI_NUMERICHOST;
1219         hints.ai_family = session->web->family;
1220
1221         if (session->addr) {
1222                 freeaddrinfo(session->addr);
1223                 session->addr = NULL;
1224         }
1225
1226         port = g_strdup_printf("%u", session->port);
1227         ret = getaddrinfo(session->address, port, &hints, &session->addr);
1228         g_free(port);
1229         if (ret != 0 || !session->addr) {
1230                 call_result_func(session, 400);
1231                 return;
1232         }
1233
1234         call_route_func(session);
1235
1236         if (create_transport(session) < 0) {
1237                 call_result_func(session, 409);
1238                 return;
1239         }
1240 }
1241
1242 static gboolean already_resolved(gpointer data)
1243 {
1244         struct web_session *session = data;
1245
1246         session->address_action = 0;
1247         handle_resolved_address(session);
1248
1249         return FALSE;
1250 }
1251
1252 static void resolv_result(GResolvResultStatus status,
1253                                         char **results, gpointer user_data)
1254 {
1255         struct web_session *session = user_data;
1256
1257         if (!results || !results[0]) {
1258                 call_result_func(session, 404);
1259                 return;
1260         }
1261
1262         g_free(session->address);
1263         session->address = g_strdup(results[0]);
1264
1265         handle_resolved_address(session);
1266 }
1267
1268 static bool is_ip_address(const char *host)
1269 {
1270         struct addrinfo hints;
1271         struct addrinfo *addr;
1272         int result;
1273
1274         memset(&hints, 0, sizeof(struct addrinfo));
1275         hints.ai_flags = AI_NUMERICHOST;
1276         addr = NULL;
1277
1278         result = getaddrinfo(host, NULL, &hints, &addr);
1279         freeaddrinfo(addr);
1280
1281         return result == 0;
1282 }
1283
1284 static guint do_request(GWeb *web, const char *url,
1285                                 const char *type, GWebInputFunc input,
1286                                 int fd, gsize length, GWebResultFunc func,
1287                                 GWebRouteFunc route, gpointer user_data)
1288 {
1289         struct web_session *session;
1290         const gchar *host;
1291
1292         if (!web || !url)
1293                 return 0;
1294
1295         debug(web, "request %s", url);
1296
1297         session = g_try_new0(struct web_session, 1);
1298         if (!session)
1299                 return 0;
1300
1301         if (parse_url(session, url, web->proxy) < 0) {
1302                 free_session(session);
1303                 return 0;
1304         }
1305
1306         debug(web, "proxy host %s", session->address);
1307         debug(web, "port %u", session->port);
1308         debug(web, "host %s", session->host);
1309         debug(web, "flags %lu", session->flags);
1310         debug(web, "request %s", session->request);
1311
1312         if (type) {
1313                 session->content_type = g_strdup(type);
1314
1315                 debug(web, "content-type %s", session->content_type);
1316         }
1317
1318         session->web = web;
1319
1320         session->result_func = func;
1321         session->route_func = route;
1322         session->input_func = input;
1323         session->fd = fd;
1324         session->length = length;
1325         session->offset = 0;
1326         session->user_data = user_data;
1327
1328         session->receive_buffer = g_try_malloc(DEFAULT_BUFFER_SIZE);
1329         if (!session->receive_buffer) {
1330                 free_session(session);
1331                 return 0;
1332         }
1333
1334         session->result.headers = g_hash_table_new_full(g_str_hash, g_str_equal,
1335                                                         g_free, g_free);
1336         if (!session->result.headers) {
1337                 free_session(session);
1338                 return 0;
1339         }
1340
1341         session->receive_space = DEFAULT_BUFFER_SIZE;
1342         session->send_buffer = g_string_sized_new(0);
1343         session->current_header = g_string_sized_new(0);
1344         session->header_done = false;
1345         session->body_done = false;
1346
1347         host = session->address ? session->address : session->host;
1348         if (is_ip_address(host)) {
1349                 if (session->address != host) {
1350                         g_free(session->address);
1351                         session->address = g_strdup(host);
1352                 }
1353                 session->address_action = g_timeout_add(0, already_resolved,
1354                                                         session);
1355         } else {
1356                 session->resolv_action = g_resolv_lookup_hostname(web->resolv,
1357                                         host, resolv_result, session);
1358                 if (session->resolv_action == 0) {
1359                         free_session(session);
1360                         return 0;
1361                 }
1362         }
1363
1364         web->session_list = g_list_append(web->session_list, session);
1365
1366         return web->next_query_id++;
1367 }
1368
1369 guint g_web_request_get(GWeb *web, const char *url, GWebResultFunc func,
1370                 GWebRouteFunc route, gpointer user_data)
1371 {
1372         return do_request(web, url, NULL, NULL, -1, 0, func, route, user_data);
1373 }
1374
1375 guint g_web_request_post(GWeb *web, const char *url,
1376                                 const char *type, GWebInputFunc input,
1377                                 GWebResultFunc func, gpointer user_data)
1378 {
1379         return do_request(web, url, type, input, -1, 0, func, NULL, user_data);
1380 }
1381
1382 guint g_web_request_post_file(GWeb *web, const char *url,
1383                                 const char *type, const char *file,
1384                                 GWebResultFunc func, gpointer user_data)
1385 {
1386         struct stat st;
1387         int fd;
1388         guint ret;
1389
1390         if (stat(file, &st) < 0)
1391                 return 0;
1392
1393         fd = open(file, O_RDONLY);
1394         if (fd < 0)
1395                 return 0;
1396
1397         ret = do_request(web, url, type, NULL, fd, st.st_size, func, NULL,
1398                         user_data);
1399         if (ret == 0)
1400                 close(fd);
1401
1402         return ret;
1403 }
1404
1405 bool g_web_cancel_request(GWeb *web, guint id)
1406 {
1407         if (!web)
1408                 return false;
1409
1410         return true;
1411 }
1412
1413 guint16 g_web_result_get_status(GWebResult *result)
1414 {
1415         if (!result)
1416                 return 0;
1417
1418         return result->status;
1419 }
1420
1421 bool g_web_result_get_chunk(GWebResult *result,
1422                                 const guint8 **chunk, gsize *length)
1423 {
1424         if (!result)
1425                 return false;
1426
1427         if (!chunk)
1428                 return false;
1429
1430         *chunk = result->buffer;
1431
1432         if (length)
1433                 *length = result->length;
1434
1435         return true;
1436 }
1437
1438 bool g_web_result_get_header(GWebResult *result,
1439                                 const char *header, const char **value)
1440 {
1441         if (!result)
1442                 return false;
1443
1444         if (!value)
1445                 return false;
1446
1447         *value = g_hash_table_lookup(result->headers, header);
1448
1449         if (!*value)
1450                 return false;
1451
1452         return true;
1453 }
1454
1455 struct _GWebParser {
1456         gint ref_count;
1457         char *begin_token;
1458         char *end_token;
1459         const char *token_str;
1460         size_t token_len;
1461         size_t token_pos;
1462         bool intoken;
1463         GString *content;
1464         GWebParserFunc func;
1465         gpointer user_data;
1466 };
1467
1468 GWebParser *g_web_parser_new(const char *begin, const char *end,
1469                                 GWebParserFunc func, gpointer user_data)
1470 {
1471         GWebParser *parser;
1472
1473         parser = g_try_new0(GWebParser, 1);
1474         if (!parser)
1475                 return NULL;
1476
1477         parser->ref_count = 1;
1478
1479         parser->begin_token = g_strdup(begin);
1480         parser->end_token = g_strdup(end);
1481
1482         if (!parser->begin_token) {
1483                 g_free(parser);
1484                 return NULL;
1485         }
1486
1487         parser->func = func;
1488         parser->user_data = user_data;
1489
1490         parser->token_str = parser->begin_token;
1491         parser->token_len = strlen(parser->token_str);
1492         parser->token_pos = 0;
1493
1494         parser->intoken = false;
1495         parser->content = g_string_sized_new(0);
1496
1497         return parser;
1498 }
1499
1500 GWebParser *g_web_parser_ref(GWebParser *parser)
1501 {
1502         if (!parser)
1503                 return NULL;
1504
1505         __sync_fetch_and_add(&parser->ref_count, 1);
1506
1507         return parser;
1508 }
1509
1510 void g_web_parser_unref(GWebParser *parser)
1511 {
1512         if (!parser)
1513                 return;
1514
1515         if (__sync_fetch_and_sub(&parser->ref_count, 1) != 1)
1516                 return;
1517
1518         g_string_free(parser->content, TRUE);
1519
1520         g_free(parser->begin_token);
1521         g_free(parser->end_token);
1522         g_free(parser);
1523 }
1524
1525 void g_web_parser_feed_data(GWebParser *parser,
1526                                 const guint8 *data, gsize length)
1527 {
1528         const guint8 *ptr = data;
1529
1530         if (!parser)
1531                 return;
1532
1533         while (length > 0) {
1534                 guint8 chr = parser->token_str[parser->token_pos];
1535
1536                 if (parser->token_pos == 0) {
1537                         guint8 *pos;
1538
1539                         pos = memchr(ptr, chr, length);
1540                         if (!pos) {
1541                                 if (parser->intoken)
1542                                         g_string_append_len(parser->content,
1543                                                         (gchar *) ptr, length);
1544                                 break;
1545                         }
1546
1547                         if (parser->intoken)
1548                                 g_string_append_len(parser->content,
1549                                                 (gchar *) ptr, (pos - ptr) + 1);
1550
1551                         length -= (pos - ptr) + 1;
1552                         ptr = pos + 1;
1553
1554                         parser->token_pos++;
1555                         continue;
1556                 }
1557
1558                 if (parser->intoken)
1559                         g_string_append_c(parser->content, ptr[0]);
1560
1561                 if (ptr[0] != chr) {
1562                         length--;
1563                         ptr++;
1564
1565                         parser->token_pos = 0;
1566                         continue;
1567                 }
1568
1569                 length--;
1570                 ptr++;
1571
1572                 parser->token_pos++;
1573
1574                 if (parser->token_pos == parser->token_len) {
1575                         if (!parser->intoken) {
1576                                 g_string_append(parser->content,
1577                                                         parser->token_str);
1578
1579                                 parser->intoken = true;
1580                                 parser->token_str = parser->end_token;
1581                                 parser->token_len = strlen(parser->end_token);
1582                                 parser->token_pos = 0;
1583                         } else {
1584                                 char *str;
1585                                 str = g_string_free(parser->content, FALSE);
1586                                 parser->content = g_string_sized_new(0);
1587                                 if (parser->func)
1588                                         parser->func(str, parser->user_data);
1589                                 g_free(str);
1590
1591                                 parser->intoken = false;
1592                                 parser->token_str = parser->begin_token;
1593                                 parser->token_len = strlen(parser->begin_token);
1594                                 parser->token_pos = 0;
1595                         }
1596                 }
1597         }
1598 }
1599
1600 void g_web_parser_end_data(GWebParser *parser)
1601 {
1602         if (!parser)
1603                 return;
1604 }