src/common/socket.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2015 Hiroyuki Yamamoto and the Claws Mail team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #if (defined (_XOPEN_SOURCE) && !defined (_BSD_SOURCE))
  26 #define _BSD_SOURCE
  27 #endif
  28
  29 #include <glib.h>
  30 #include <glib/gi18n.h>
  31
  32 #include <sys/time.h>
  33 #include <sys/types.h>
  34 #ifdef G_OS_WIN32
  35 #  include <winsock2.h>
  36 #  ifndef EINPROGRESS
  37 #    define EINPROGRESS WSAEINPROGRESS
  38 #  endif
  39 #  include "w32lib.h"
  40 #else
  41 #  if HAVE_SYS_WAIT_H
  42 #    include <sys/wait.h>
  43 #  endif
  44 #  include <sys/socket.h>
  45 #  include <sys/stat.h>
  46 #  include <sys/un.h>
  47 #  include <netinet/in.h>
  48 #  include <arpa/inet.h>
  49 #  include <resolv.h>
  50 #  include <netdb.h>
  51 #endif /* G_OS_WIN32 */
  52 #include <unistd.h>
  53 #include <stdio.h>
  54 #include <string.h>
  55 #include <stdarg.h>
  56 #include <fcntl.h>
  57 #include <errno.h>
  58 #include <signal.h>
  59 #include <setjmp.h>
  60 #if HAVE_SYS_SELECT_H
  61 #  include <sys/select.h>
  62 #endif
  63
  64 #include "socket.h"
  65 #include "utils.h"
  66 #include "log.h"
  67 #ifdef USE_GNUTLS
  68 #  include "ssl.h"
  69 #endif
  70
  71 #if USE_GIO
  72 #error USE_GIO is currently not supported
  73 #endif
  74
  75 #if G_IO_WIN32
  76 #define BUFFSIZE        8191
  77 #else
  78 #define BUFFSIZE        8192
  79 #endif
  80
  81
  82 typedef gint (*SockAddrFunc)    (GList          *addr_list,
  83                                  gpointer        data);
  84
  85 typedef struct _SockConnectData SockConnectData;
  86 typedef struct _SockLookupData  SockLookupData;
  87 typedef struct _SockAddrData    SockAddrData;
  88 typedef struct _SockSource      SockSource;
  89
  90 struct _SockConnectData {
  91         gint id;
  92         gchar *hostname;
  93         gushort port;
  94         GList *addr_list;
  95         GList *cur_addr;
  96         SockLookupData *lookup_data;
  97         GIOChannel *channel;
  98         guint io_tag;
  99         SockConnectFunc func;
 100         gpointer data;
 101         gchar *canonical_name;
 102 };
 103
 104 struct _SockLookupData {
 105         gchar *hostname;
 106         pid_t child_pid;
 107         GIOChannel *channel;
 108         guint io_tag;
 109         SockAddrFunc func;
 110         gpointer data;
 111         gushort port;
 112         gint pipe_fds[2];
 113         gchar *canonical_name;
 114 };
 115
 116 struct _SockAddrData {
 117         gint family;
 118         gint socktype;
 119         gint protocol;
 120         gint addr_len;
 121         struct sockaddr *addr;
 122 };
 123
 124 struct _SockSource {
 125         GSource parent;
 126         SockInfo *sock;
 127 };
 128
 129 static guint io_timeout = 60;
 130
 131 static GList *sock_connect_data_list = NULL;
 132
 133 static gboolean ssl_sock_prepare        (GSource        *source,
 134                                          gint           *timeout);
 135 static gboolean ssl_sock_check          (GSource        *source);
 136 static gboolean ssl_sock_dispatch       (GSource        *source,
 137                                          GSourceFunc     callback,
 138                                          gpointer        user_data);
 139
 140 #ifdef USE_GNUTLS
 141 GSourceFuncs ssl_watch_funcs = {
 142         ssl_sock_prepare,
 143         ssl_sock_check,
 144         ssl_sock_dispatch,
 145         NULL
 146 };
 147 #endif
 148
 149 static gint sock_connect_with_timeout   (gint                    sock,
 150                                          const struct sockaddr  *serv_addr,
 151                                          gint                    addrlen,
 152                                          guint                   timeout_secs);
 153
 154 static gint sock_connect_by_getaddrinfo (const gchar    *hostname,
 155                                          gushort         port);
 156
 157 static SockInfo *sockinfo_from_fd(const gchar *hostname,
 158                                   gushort port,
 159                                   gint sock);
 160 static void sock_address_list_free              (GList          *addr_list);
 161
 162 static gboolean sock_connect_async_cb           (GIOChannel     *source,
 163                                                  GIOCondition    condition,
 164                                                  gpointer        data);
 165 static gint sock_connect_async_get_address_info_cb
 166                                                 (GList          *addr_list,
 167                                                  gpointer        data);
 168
 169 static gint sock_connect_address_list_async     (SockConnectData *conn_data);
 170
 171 static gboolean sock_get_address_info_async_cb  (GIOChannel     *source,
 172                                                  GIOCondition    condition,
 173                                                  gpointer        data);
 174 static SockLookupData *sock_get_address_info_async
 175                                                 (const gchar    *hostname,
 176                                                  gushort         port,
 177                                                  SockAddrFunc    func,
 178                                                  gpointer        data);
 179 static gint sock_get_address_info_async_cancel  (SockLookupData *lookup_data);
 180
 181
 182 gint sock_init(void)
 183 {
 184 #ifdef G_OS_WIN32
 185         WSADATA wsadata;
 186         gint result;
 187
 188         result = WSAStartup(MAKEWORD(2, 2), &wsadata);
 189         if (result != NO_ERROR) {
 190                 g_warning("WSAStartup() failed\n");
 191                 return -1;
 192         }
 193 #endif
 194         return 0;
 195 }
 196
 197 gint sock_cleanup(void)
 198 {
 199 #ifdef G_OS_WIN32
 200         WSACleanup();
 201 #endif
 202         return 0;
 203 }
 204
 205 gint sock_set_io_timeout(guint sec)
 206 {
 207         io_timeout = sec;
 208         return 0;
 209 }
 210
 211 void refresh_resolvers(void)
 212 {
 213 #ifdef G_OS_UNIX
 214         static time_t resolv_conf_changed = (time_t)NULL;
 215         GStatBuf s;
 216
 217         /* This makes the glibc re-read resolv.conf, if it changed
 218          * since our startup. Maybe that should be #ifdef'ed, I don't
 219          * know if it'd work on BSDs.
 220          * Why doesn't the glibc do it by itself?
 221          */
 222         if (g_stat("/etc/resolv.conf", &s) == 0) {
 223                 if (s.st_mtime > resolv_conf_changed) {
 224                         resolv_conf_changed = s.st_mtime;
 225                         res_init();
 226                 }
 227         } /* else
 228                 we'll have bigger problems. */
 229 #endif /*G_OS_UNIX*/
 230 }
 231
 232 #ifdef G_OS_WIN32
 233 #define SOCKET_IS_VALID(s)      ((s) != INVALID_SOCKET)
 234 #else
 235 #define SOCKET_IS_VALID(s)      (s != -1)
 236 #endif
 237
 238 /* Due to the fact that socket under Windows are not represented by
 239    standard file descriptors, we sometimes need to check whether a
 240    given file descriptor is actually a socket.  This is done by
 241    testing for an error.  Returns true under W32 if FD is a socket. */
 242 static int fd_is_w32_socket(gint fd)
 243 {
 244 #ifdef G_OS_WIN32
 245         gint optval;
 246         gint retval = sizeof(optval);
 247
 248         return !getsockopt(fd, SOL_SOCKET, SO_TYPE, (char*)&optval, &retval);
 249 #else
 250         return 0;
 251 #endif
 252 }
 253
 254 gint fd_connect_inet(gushort port)
 255 {
 256         gint sock;
 257         struct sockaddr_in addr;
 258
 259         sock = socket(AF_INET, SOCK_STREAM, 0);
 260         if (!SOCKET_IS_VALID(sock)) {
 261 #ifdef G_OS_WIN32
 262                 debug_print("fd_connect_inet(): socket() failed: %d\n",
 263                           WSAGetLastError());
 264 #else
 265                 perror("fd_connect_inet(): socket");
 266 #endif
 267                 return -1;
 268         }
 269
 270         memset(&addr, 0, sizeof(addr));
 271         addr.sin_family = AF_INET;
 272         addr.sin_port = htons(port);
 273         addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 274
 275         if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 276                 fd_close(sock);
 277                 return -1;
 278         }
 279
 280         return sock;
 281 }
 282 gint fd_open_inet(gushort port)
 283 {
 284         gint sock;
 285         struct sockaddr_in addr;
 286         gint val;
 287
 288         sock = socket(AF_INET, SOCK_STREAM, 0);
 289         if (!SOCKET_IS_VALID(sock)) {
 290 #ifdef G_OS_WIN32
 291                 g_warning("fd_open_inet(): socket() failed: %d\n",
 292                           WSAGetLastError());
 293 #else
 294                 perror("fd_open_inet(): socket");
 295 #endif
 296                 return -1;
 297         }
 298
 299         val = 1;
 300         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val,
 301                        sizeof(val)) < 0) {
 302                 perror("setsockopt");
 303                 fd_close(sock);
 304                 return -1;
 305         }
 306
 307         memset(&addr, 0, sizeof(addr));
 308         addr.sin_family = AF_INET;
 309         addr.sin_port = htons(port);
 310         addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 311
 312         if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 313                 perror("bind");
 314                 fd_close(sock);
 315                 return -1;
 316         }
 317
 318         if (listen(sock, 1) < 0) {
 319                 perror("listen");
 320                 fd_close(sock);
 321                 return -1;
 322         }
 323
 324         return sock;
 325 }
 326
 327 gint fd_connect_unix(const gchar *path)
 328 {
 329 #ifdef G_OS_UNIX
 330         gint sock;
 331         struct sockaddr_un addr;
 332
 333         sock = socket(PF_UNIX, SOCK_STREAM, 0);
 334         if (sock < 0) {
 335                 perror("sock_connect_unix(): socket");
 336                 return -1;
 337         }
 338
 339         memset(&addr, 0, sizeof(addr));
 340         addr.sun_family = AF_UNIX;
 341         strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
 342
 343         if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 344                 close(sock);
 345                 return -1;
 346         }
 347
 348         return sock;
 349 #else
 350         return -1;
 351 #endif
 352 }
 353
 354 gint fd_open_unix(const gchar *path)
 355 {
 356 #ifdef G_OS_UNIX
 357         gint sock;
 358         struct sockaddr_un addr;
 359
 360         sock = socket(PF_UNIX, SOCK_STREAM, 0);
 361
 362         if (sock < 0) {
 363                 perror("sock_open_unix(): socket");
 364                 return -1;
 365         }
 366
 367         memset(&addr, 0, sizeof(addr));
 368         addr.sun_family = AF_UNIX;
 369         strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
 370
 371         if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 372                 gchar *buf = g_strdup_printf("can't bind to %s", path);
 373                 perror(buf);
 374                 g_free(buf);
 375                 close(sock);
 376                 return -1;
 377         }
 378
 379         if (listen(sock, 1) < 0) {
 380                 gchar *buf = g_strdup_printf("can't listen on %s", path);
 381                 perror(buf);
 382                 g_free(buf);
 383                 close(sock);
 384                 return -1;
 385         }
 386
 387         return sock;
 388 #else
 389         return -1;
 390 #endif
 391 }
 392
 393 gint fd_accept(gint sock)
 394 {
 395         struct sockaddr_in caddr;
 396         guint caddr_len;
 397
 398         caddr_len = sizeof(caddr);
 399         return accept(sock, (struct sockaddr *)&caddr, &caddr_len);
 400 }
 401
 402
 403 static gint set_nonblocking_mode(gint fd, gboolean nonblock)
 404 {
 405 #ifdef G_OS_UNIX
 406         gint flags;
 407
 408         flags = fcntl(fd, F_GETFL, 0);
 409         if (flags < 0) {
 410                 perror("fcntl");
 411                 return -1;
 412         }
 413
 414         if (nonblock)
 415                 flags |= O_NONBLOCK;
 416         else
 417                 flags &= ~O_NONBLOCK;
 418
 419         return fcntl(fd, F_SETFL, flags);
 420 #else
 421         return -1;
 422 #endif
 423 }
 424
 425 gint sock_set_nonblocking_mode(SockInfo *sock, gboolean nonblock)
 426 {
 427         cm_return_val_if_fail(sock != NULL, -1);
 428
 429         return set_nonblocking_mode(sock->sock, nonblock);
 430 }
 431
 432 static gboolean is_nonblocking_mode(gint fd)
 433 {
 434 #ifdef G_OS_UNIX
 435         gint flags;
 436
 437         flags = fcntl(fd, F_GETFL, 0);
 438         if (flags < 0) {
 439                 perror("fcntl");
 440                 return FALSE;
 441         }
 442
 443         return ((flags & O_NONBLOCK) != 0);
 444 #else
 445         return FALSE;
 446 #endif
 447 }
 448
 449 gboolean sock_is_nonblocking_mode(SockInfo *sock)
 450 {
 451         cm_return_val_if_fail(sock != NULL, FALSE);
 452
 453         return is_nonblocking_mode(sock->sock);
 454 }
 455
 456
 457 #ifdef USE_GNUTLS
 458 static gboolean ssl_sock_prepare(GSource *source, gint *timeout)
 459 {
 460         *timeout = 1;
 461         return FALSE;
 462 }
 463
 464 static gboolean ssl_sock_check(GSource *source)
 465 {
 466         SockInfo *sock = ((SockSource *)source)->sock;
 467         struct timeval timeout = {0, 0};
 468         fd_set fds;
 469         GIOCondition condition = 0;
 470
 471         if (!sock || !sock->sock)
 472                 return FALSE;
 473
 474         condition = sock->condition;
 475
 476         if ((condition & G_IO_IN) == G_IO_IN &&
 477             gnutls_record_check_pending(sock->ssl) != 0)
 478                 return TRUE;
 479
 480         FD_ZERO(&fds);
 481         FD_SET(sock->sock, &fds);
 482
 483         select(sock->sock + 1,
 484                (condition & G_IO_IN)  ? &fds : NULL,
 485                (condition & G_IO_OUT) ? &fds : NULL,
 486                NULL, &timeout);
 487
 488         return FD_ISSET(sock->sock, &fds) != 0;
 489 }
 490
 491 static gboolean ssl_sock_dispatch(GSource *source, GSourceFunc callback,
 492                               gpointer user_data)
 493 {
 494         SockInfo *sock = ((SockSource *)source)->sock;
 495
 496         if (!sock || !sock->callback || !sock->data)
 497                 return FALSE;
 498
 499         return sock->callback(sock, sock->condition, sock->data);
 500 }
 501 #endif
 502
 503 static gboolean sock_watch_cb(GIOChannel *source, GIOCondition condition,
 504                               gpointer data)
 505 {
 506         SockInfo *sock = (SockInfo *)data;
 507
 508         if ((condition & sock->condition) == 0)
 509                 return TRUE;
 510
 511         return sock->callback(sock, sock->condition, sock->data);
 512 }
 513
 514 guint sock_add_watch(SockInfo *sock, GIOCondition condition, SockFunc func,
 515                      gpointer data)
 516 {
 517         if (!sock)
 518                 return FALSE;
 519
 520         sock->callback = func;
 521         sock->condition = condition;
 522         sock->data = data;
 523
 524 #ifdef USE_GNUTLS
 525         if (sock->ssl)
 526         {
 527                 GSource *source = g_source_new(&ssl_watch_funcs,
 528                                                sizeof(SockSource));
 529                 ((SockSource *) source)->sock = sock;
 530                 g_source_set_priority(source, G_PRIORITY_DEFAULT);
 531                 g_source_set_can_recurse(source, FALSE);
 532                 sock->g_source = g_source_attach(source, NULL);
 533                 g_source_unref (source); /* Refcount back down to 1 */
 534                 return sock->g_source;
 535         }
 536 #endif
 537
 538         return g_io_add_watch(sock->sock_ch, condition, sock_watch_cb, sock);
 539 }
 540
 541 static gint fd_check_io(gint fd, GIOCondition cond)
 542 {
 543         struct timeval timeout;
 544         fd_set fds;
 545
 546         if (is_nonblocking_mode(fd))
 547                 return 0;
 548
 549         timeout.tv_sec  = io_timeout;
 550         timeout.tv_usec = 0;
 551
 552         FD_ZERO(&fds);
 553         FD_SET(fd, &fds);
 554
 555         if (cond == G_IO_IN) {
 556                 select(fd + 1, &fds, NULL, NULL,
 557                        io_timeout > 0 ? &timeout : NULL);
 558         } else {
 559                 select(fd + 1, NULL, &fds, NULL,
 560                        io_timeout > 0 ? &timeout : NULL);
 561         }
 562
 563         if (FD_ISSET(fd, &fds)) {
 564                 return 0;
 565         } else {
 566                 g_warning("Socket IO timeout\n");
 567                 log_error(LOG_PROTOCOL, _("Socket IO timeout.\n"));
 568                 return -1;
 569         }
 570 }
 571
 572 #ifdef G_OS_UNIX
 573 static sigjmp_buf jmpenv;
 574
 575 static void timeout_handler(gint sig)
 576 {
 577         siglongjmp(jmpenv, 1);
 578 }
 579 #endif /*G_OS_UNIX*/
 580
 581 static gint sock_connect_with_timeout(gint sock,
 582                                       const struct sockaddr *serv_addr,
 583                                       gint addrlen,
 584                                       guint timeout_secs)
 585 {
 586         gint ret;
 587 #ifdef G_OS_UNIX
 588         void (*prev_handler)(gint);
 589
 590         alarm(0);
 591         prev_handler = signal(SIGALRM, timeout_handler);
 592         if (sigsetjmp(jmpenv, 1)) {
 593                 alarm(0);
 594                 signal(SIGALRM, prev_handler);
 595                 errno = ETIMEDOUT;
 596                 log_error(LOG_PROTOCOL, _("Connection timed out.\n"));
 597                 return -1;
 598         }
 599         alarm(timeout_secs);
 600 #endif
 601
 602         ret = connect(sock, serv_addr, addrlen);
 603
 604 #ifdef G_OS_UNIX
 605         alarm(0);
 606         signal(SIGALRM, prev_handler);
 607 #endif
 608
 609         return ret;
 610 }
 611
 612 static gint sock_connect_by_getaddrinfo(const gchar *hostname, gushort  port)
 613 {
 614         gint sock = -1, gai_error;
 615         struct addrinfo hints, *res, *ai;
 616         gchar port_str[6];
 617
 618         refresh_resolvers();
 619
 620         memset(&hints, 0, sizeof(hints));
 621         hints.ai_flags = AI_ADDRCONFIG;
 622
 623 #ifdef INET6
 624         hints.ai_family = AF_UNSPEC;
 625 #else
 626         hints.ai_family = AF_INET;
 627 #endif
 628
 629         hints.ai_socktype = SOCK_STREAM;
 630         hints.ai_protocol = IPPROTO_TCP;
 631
 632         /* convert port from integer to string. */
 633         g_snprintf(port_str, sizeof(port_str), "%d", port);
 634
 635         if ((gai_error = getaddrinfo(hostname, port_str, &hints, &res)) != 0) {
 636                 g_printerr("getaddrinfo for %s:%s failed: %s\n",
 637                         hostname, port_str, gai_strerror(gai_error));
 638                 return -1;
 639         }
 640
 641         for (ai = res; ai != NULL; ai = ai->ai_next) {
 642 #ifndef INET6
 643                 if (ai->ai_family == AF_INET6)
 644                         continue;
 645 #endif
 646
 647                 sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
 648                 if (sock < 0 )
 649                         continue;
 650 #ifdef G_OS_WIN32
 651                 if (sock == INVALID_SOCKET)
 652                         continue;
 653 #endif
 654
 655                 if (sock_connect_with_timeout
 656                         (sock, ai->ai_addr, ai->ai_addrlen, io_timeout) == 0)
 657                         break;
 658
 659                 close(sock);
 660         }
 661
 662         if (res != NULL)
 663                 freeaddrinfo(res);
 664
 665         if (ai == NULL)
 666                 return -1;
 667
 668         return sock;
 669 }
 670
 671 SockInfo *sock_connect(const gchar *hostname, gushort port)
 672 {
 673 #ifdef G_OS_WIN32
 674         SOCKET sock;
 675 #else
 676         gint sock;
 677 #endif
 678
 679         if ((sock = sock_connect_by_getaddrinfo(hostname, port)) < 0) {
 680                 return NULL;
 681         }
 682
 683         return sockinfo_from_fd(hostname, port, sock);
 684 }
 685
 686
 687 static void sock_address_list_free(GList *addr_list)
 688 {
 689         GList *cur;
 690
 691         for (cur = addr_list; cur != NULL; cur = cur->next) {
 692                 SockAddrData *addr_data = (SockAddrData *)cur->data;
 693                 g_free(addr_data->addr);
 694                 g_free(addr_data);
 695         }
 696
 697         g_list_free(addr_list);
 698 }
 699
 700 /* asynchronous TCP connection */
 701
 702 static gboolean sock_connect_async_cb(GIOChannel *source,
 703                                       GIOCondition condition, gpointer data)
 704 {
 705         SockConnectData *conn_data = (SockConnectData *)data;
 706         gint fd;
 707         gint val;
 708         guint len;
 709         SockInfo *sockinfo;
 710
 711         if (conn_data->io_tag == 0 && conn_data->channel == NULL)
 712                 return FALSE;
 713
 714         fd = g_io_channel_unix_get_fd(source);
 715
 716         conn_data->io_tag = 0;
 717         conn_data->channel = NULL;
 718         g_io_channel_unref(source);
 719
 720         len = sizeof(val);
 721         if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) < 0) {
 722                 perror("getsockopt");
 723                 close(fd);
 724                 sock_connect_address_list_async(conn_data);
 725                 return FALSE;
 726         }
 727
 728         if (val != 0) {
 729                 close(fd);
 730                 log_error(LOG_PROTOCOL, _("%s:%d: connection failed (%s).\n"),
 731                           conn_data->hostname, conn_data->port,
 732                           g_strerror(val));
 733                 sock_connect_address_list_async(conn_data);
 734                 return FALSE;
 735         }
 736
 737         sockinfo = g_new0(SockInfo, 1);
 738         sockinfo->sock = fd;
 739 #ifndef G_OS_WIN32
 740         sockinfo->sock_ch = g_io_channel_unix_new(fd);
 741 #else
 742         sockinfo->sock_ch = g_io_channel_win32_new_socket(fd);
 743 #endif
 744         sockinfo->hostname = g_strdup(conn_data->hostname);
 745         sockinfo->port = conn_data->port;
 746         sockinfo->state = CONN_ESTABLISHED;
 747         sockinfo->canonical_name = g_strdup(conn_data->canonical_name);
 748
 749         conn_data->func(sockinfo, conn_data->data);
 750
 751         sock_connect_async_cancel(conn_data->id);
 752
 753         return FALSE;
 754 }
 755
 756 static gint sock_connect_async_get_address_info_cb(GList *addr_list,
 757                                                    gpointer data)
 758 {
 759         SockConnectData *conn_data = (SockConnectData *)data;
 760
 761         conn_data->addr_list = addr_list;
 762         conn_data->cur_addr = addr_list;
 763         if (conn_data->lookup_data) {
 764                 conn_data->canonical_name = conn_data->lookup_data->canonical_name;
 765                 conn_data->lookup_data->canonical_name = NULL;
 766                 conn_data->lookup_data = NULL;
 767         }
 768         return sock_connect_address_list_async(conn_data);
 769 }
 770
 771 gint sock_connect_async(const gchar *hostname, gushort port,
 772                         SockConnectFunc func, gpointer data)
 773 {
 774         static gint id = 1;
 775         SockConnectData *conn_data;
 776
 777         conn_data = g_new0(SockConnectData, 1);
 778         conn_data->id = id++;
 779         conn_data->hostname = g_strdup(hostname);
 780         conn_data->port = port;
 781         conn_data->addr_list = NULL;
 782         conn_data->cur_addr = NULL;
 783         conn_data->io_tag = 0;
 784         conn_data->func = func;
 785         conn_data->data = data;
 786
 787         conn_data->lookup_data = sock_get_address_info_async
 788                 (hostname, port, sock_connect_async_get_address_info_cb,
 789                  conn_data);
 790
 791         if (conn_data->lookup_data == NULL) {
 792                 g_free(conn_data->hostname);
 793                 g_free(conn_data);
 794                 return -1;
 795         }
 796
 797         sock_connect_data_list = g_list_append(sock_connect_data_list,
 798                                                conn_data);
 799
 800         return conn_data->id;
 801 }
 802
 803 gint sock_connect_async_cancel(gint id)
 804 {
 805         SockConnectData *conn_data = NULL;
 806         GList *cur;
 807
 808         for (cur = sock_connect_data_list; cur != NULL; cur = cur->next) {
 809                 if (((SockConnectData *)cur->data)->id == id) {
 810                         conn_data = (SockConnectData *)cur->data;
 811                         break;
 812                 }
 813         }
 814
 815         if (conn_data) {
 816                 sock_connect_data_list = g_list_remove(sock_connect_data_list,
 817                                                        conn_data);
 818
 819                 if (conn_data->lookup_data)
 820                         sock_get_address_info_async_cancel
 821                                 (conn_data->lookup_data);
 822
 823                 if (conn_data->io_tag > 0)
 824                         g_source_remove(conn_data->io_tag);
 825                 if (conn_data->channel) {
 826                         GError *err = NULL;
 827                         g_io_channel_shutdown(conn_data->channel, TRUE, &err);
 828                         if (err)
 829                                 g_error_free(err);
 830                         g_io_channel_unref(conn_data->channel);
 831                 }
 832
 833                 sock_address_list_free(conn_data->addr_list);
 834                 g_free(conn_data->canonical_name);
 835                 g_free(conn_data->hostname);
 836                 g_free(conn_data);
 837         } else {
 838                 g_warning("sock_connect_async_cancel: id %d not found.\n", id);
 839                 return -1;
 840         }
 841
 842         return 0;
 843 }
 844
 845 static gint sock_connect_address_list_async(SockConnectData *conn_data)
 846 {
 847         SockAddrData *addr_data;
 848         gint sock = -1;
 849
 850         for (; conn_data->cur_addr != NULL;
 851              conn_data->cur_addr = conn_data->cur_addr->next) {
 852                 addr_data = (SockAddrData *)conn_data->cur_addr->data;
 853
 854                 if ((sock = socket(addr_data->family, addr_data->socktype,
 855                                    addr_data->protocol)) < 0) {
 856                         perror("socket");
 857
 858                         continue;
 859                 }
 860
 861                 set_nonblocking_mode(sock, TRUE);
 862
 863                 if (connect(sock, addr_data->addr, addr_data->addr_len) < 0) {
 864                         if (EINPROGRESS == errno) {
 865                                 break;
 866                         } else {
 867                                 perror("connect");
 868                                 close(sock);
 869                         }
 870                 } else {
 871                         break;
 872                 }
 873         }
 874
 875         if (conn_data->cur_addr == NULL) {
 876                 conn_data->func(NULL, conn_data->data);
 877                 sock_connect_async_cancel(conn_data->id);
 878                 return -1;
 879         }
 880
 881         conn_data->cur_addr = conn_data->cur_addr->next;
 882
 883 #ifndef G_OS_WIN32
 884         conn_data->channel = g_io_channel_unix_new(sock);
 885 #else
 886         conn_data->channel = g_io_channel_win32_new_socket(sock);
 887 #endif
 888         conn_data->io_tag = g_io_add_watch(conn_data->channel, G_IO_IN|G_IO_OUT,
 889                                            sock_connect_async_cb, conn_data);
 890
 891         return 0;
 892 }
 893
 894 /* asynchronous DNS lookup */
 895
 896 static gboolean sock_get_address_info_async_cb(GIOChannel *source,
 897                                                GIOCondition condition,
 898                                                gpointer data)
 899 {
 900         SockLookupData *lookup_data = (SockLookupData *)data;
 901         GList *addr_list = NULL;
 902         SockAddrData *addr_data;
 903         gsize bytes_read;
 904         gint ai_member[4];
 905         struct sockaddr *addr;
 906         gchar *canonical_name = NULL;
 907         gchar len = 0;
 908         GError *err = NULL;
 909
 910         g_io_channel_set_encoding(source, NULL, &err);
 911         if (err) {
 912                 g_warning("can unset encoding: %s\n", err->message);
 913                 g_error_free(err);
 914                 return FALSE;
 915         }
 916         g_io_channel_set_buffered(source, FALSE);
 917         if (g_io_channel_read_chars(source, &len, sizeof(len),
 918                               &bytes_read, &err) == G_IO_STATUS_NORMAL) {
 919                 if (err != NULL) {
 920                         g_warning("g_io_channel_read_chars: %s\n", err->message);
 921                         g_error_free(err);
 922                         return FALSE;
 923                 }
 924                 if (bytes_read == sizeof(len) && len > 0) {
 925                         gchar *cur = NULL;
 926                         gint todo = len;
 927                         canonical_name = g_malloc0(len + 1);
 928                         cur = canonical_name;
 929                         while (todo > 0) {
 930                                 if (g_io_channel_read_chars(source, cur, todo,
 931                                       &bytes_read, &err) != G_IO_STATUS_NORMAL) {
 932                                         if (err) {
 933                                               g_warning("canonical name not read %s\n", err->message);
 934                                               g_free(canonical_name);
 935                                               canonical_name = NULL;
 936                                               g_error_free(err);
 937                                               err = NULL;
 938                                               break;
 939                                         }
 940                                 } else {
 941                                         cur += bytes_read;
 942                                         todo -= bytes_read;
 943                                 }
 944                                 if (bytes_read == 0) {
 945                                       g_warning("canonical name not read\n");
 946                                       g_free(canonical_name);
 947                                       canonical_name = NULL;
 948                                       break;
 949                                 }
 950                         }
 951                 }
 952         }
 953         for (;;) {
 954                 if (g_io_channel_read_chars(source, (gchar *)ai_member,
 955                                       sizeof(ai_member), &bytes_read, &err)
 956                     != G_IO_STATUS_NORMAL) {
 957                         if (err != NULL) {
 958                                 g_warning("g_io_channel_read_chars: addr len %s\n", err->message);
 959                                 g_error_free(err);
 960                                 err = NULL;
 961                                 break;
 962                         }
 963                 }
 964
 965                 if (bytes_read == 0 || bytes_read != sizeof(ai_member))
 966                         break;
 967
 968                 if (ai_member[0] == AF_UNSPEC) {
 969                         g_warning("DNS lookup failed\n");
 970                         log_error(LOG_PROTOCOL, _("%s:%d: unknown host.\n"),
 971                                 lookup_data->hostname, lookup_data->port);
 972                         break;
 973                 }
 974
 975                 addr = g_malloc(ai_member[3]);
 976                 if (g_io_channel_read_chars(source, (gchar *)addr, ai_member[3],
 977                                       &bytes_read, &err)
 978                     != G_IO_STATUS_NORMAL) {
 979                         if (err != NULL) {
 980                                 g_warning("g_io_channel_read_chars: addr data read %s\n", err->message);
 981                                 g_error_free(err);
 982                                 err = NULL;
 983                                 g_free(addr);
 984                                 break;
 985                         }
 986                 }
 987
 988                 if (bytes_read != ai_member[3]) {
 989                         g_warning("sock_get_address_info_async_cb: "
 990                                   "incomplete address data\n");
 991                         g_free(addr);
 992                         break;
 993                 }
 994
 995                 addr_data = g_new0(SockAddrData, 1);
 996                 addr_data->family = ai_member[0];
 997                 addr_data->socktype = ai_member[1];
 998                 addr_data->protocol = ai_member[2];
 999                 addr_data->addr_len = ai_member[3];
1000                 addr_data->addr = addr;
1001
1002                 addr_list = g_list_append(addr_list, addr_data);
1003         }
1004
1005         g_io_channel_shutdown(source, TRUE, &err);
1006         if (err)
1007                 g_error_free(err);
1008         g_io_channel_unref(source);
1009
1010 #ifdef G_OS_WIN32
1011         /* FIXME: We would need to cancel the thread. */
1012 #else
1013         kill(lookup_data->child_pid, SIGKILL);
1014         waitpid(lookup_data->child_pid, NULL, 0);
1015 #endif
1016         lookup_data->canonical_name = canonical_name;
1017
1018         lookup_data->func(addr_list, lookup_data->data);
1019
1020         g_free(lookup_data->canonical_name);
1021         g_free(lookup_data->hostname);
1022         g_free(lookup_data);
1023
1024         return FALSE;
1025 }
1026
1027
1028 /* For better readability we use a separate function to implement the
1029    child code of sock_get_address_info_async.  Note, that under W32
1030    this is actually not a child but a thread and this is the reason
1031    why we pass only a void pointer. */
1032 static void address_info_async_child(void *opaque)
1033 {
1034         SockLookupData *parm = opaque;
1035         gint gai_err;
1036         struct addrinfo hints, *res, *ai;
1037         gchar port_str[6];
1038         gint ai_member[4] = {AF_UNSPEC, 0, 0, 0};
1039
1040 #ifndef G_OS_WIN32
1041         close(parm->pipe_fds[0]);
1042         parm->pipe_fds[0] = -1;
1043 #endif
1044
1045         memset(&hints, 0, sizeof(hints));
1046         hints.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
1047 #ifdef INET6
1048         hints.ai_family = AF_UNSPEC;
1049 #else
1050                                 hints.ai_family = AF_INET;
1051 #endif
1052         hints.ai_socktype = SOCK_STREAM;
1053         hints.ai_protocol = IPPROTO_TCP;
1054
1055         g_snprintf(port_str, sizeof(port_str), "%d", parm->port);
1056
1057         gai_err = getaddrinfo(parm->hostname, port_str, &hints, &res);
1058         if (gai_err != 0) {
1059                 gchar len = 0;
1060                 g_warning("getaddrinfo for %s:%s failed: %s\n",
1061                           parm->hostname, port_str, gai_strerror(gai_err));
1062                 log_error(LOG_PROTOCOL, _("%s:%s: host lookup failed (%s).\n"),
1063                           parm->hostname, port_str, gai_strerror(gai_err));
1064                 fd_write_all(parm->pipe_fds[1], &len,
1065                      sizeof(len));
1066                 fd_write_all(parm->pipe_fds[1], (gchar *)ai_member,
1067                              sizeof(ai_member));
1068                 close(parm->pipe_fds[1]);
1069                 parm->pipe_fds[1] = -1;
1070 #ifdef G_OS_WIN32
1071                 _endthread();
1072 #else
1073                 _exit(1);
1074 #endif
1075         }
1076
1077         if (res != NULL) {
1078                 if (res->ai_canonname && strlen(res->ai_canonname) < 255) {
1079                         gchar len = strlen(res->ai_canonname);
1080                         fd_write_all(parm->pipe_fds[1], &len,
1081                              sizeof(len));
1082                         fd_write_all(parm->pipe_fds[1], res->ai_canonname,
1083                              len);
1084                 } else {
1085                         gchar len = 0;
1086                         fd_write_all(parm->pipe_fds[1], &len,
1087                              sizeof(len));
1088                 }
1089         } else {
1090                 gchar len = 0;
1091                 fd_write_all(parm->pipe_fds[1], &len,
1092                      sizeof(len));
1093         }
1094
1095         for (ai = res; ai != NULL; ai = ai->ai_next) {
1096                 ai_member[0] = ai->ai_family;
1097                 ai_member[1] = ai->ai_socktype;
1098                 ai_member[2] = ai->ai_protocol;
1099                 ai_member[3] = ai->ai_addrlen;
1100
1101                 fd_write_all(parm->pipe_fds[1], (gchar *)ai_member,
1102                              sizeof(ai_member));
1103                 fd_write_all(parm->pipe_fds[1], (gchar *)ai->ai_addr,
1104                              ai->ai_addrlen);
1105         }
1106
1107         if (res != NULL)
1108                 freeaddrinfo(res);
1109
1110         close(parm->pipe_fds[1]);
1111         parm->pipe_fds[1] = -1;
1112
1113 #ifdef G_OS_WIN32
1114         _endthread();
1115 #else
1116         _exit(0);
1117 #endif
1118 }
1119
1120 static SockLookupData *sock_get_address_info_async(const gchar *hostname,
1121                                                    gushort port,
1122                                                    SockAddrFunc func,
1123                                                    gpointer data)
1124 {
1125         SockLookupData *lookup_data = NULL;
1126
1127         refresh_resolvers();
1128
1129         lookup_data = g_new0(SockLookupData, 1);
1130         lookup_data->hostname = g_strdup(hostname);
1131         lookup_data->func = func;
1132         lookup_data->data = data;
1133         lookup_data->port = port;
1134         lookup_data->child_pid = (pid_t)(-1);
1135         lookup_data->pipe_fds[0] = -1;
1136         lookup_data->pipe_fds[1] = -1;
1137
1138         if (pipe(lookup_data->pipe_fds) < 0) {
1139                 perror("pipe");
1140                 func(NULL, data);
1141                 g_free (lookup_data->hostname);
1142                 g_free (lookup_data);
1143                 return NULL;
1144         }
1145
1146 #ifndef G_OS_WIN32
1147         if ((lookup_data->child_pid = fork()) < 0) {
1148                 perror("fork");
1149                 func(NULL, data);
1150                 g_free (lookup_data->hostname);
1151                 g_free (lookup_data);
1152                 return NULL;
1153         }
1154
1155         if (lookup_data->child_pid == 0) {
1156                 /* Child process. */
1157                 address_info_async_child (lookup_data);
1158                 g_assert_not_reached ();
1159         }
1160         /* Parent process. */
1161         close(lookup_data->pipe_fds[1]);
1162         lookup_data->pipe_fds[1] = -1;
1163 #endif  /*!G_OS_WIN32 */
1164
1165 #ifndef G_OS_WIN32
1166         lookup_data->channel = g_io_channel_unix_new(lookup_data->pipe_fds[0]);
1167 #else
1168         lookup_data->channel = g_io_channel_win32_new_fd(lookup_data->pipe_fds[0]);
1169 #endif
1170         lookup_data->io_tag = g_io_add_watch(lookup_data->channel, G_IO_IN,
1171                                              sock_get_address_info_async_cb,
1172                                              lookup_data);
1173 #ifdef G_OS_WIN32
1174         lookup_data->child_pid = _beginthread(
1175                 address_info_async_child, 0, lookup_data);
1176 #endif
1177
1178         return lookup_data;
1179 }
1180
1181 static gint sock_get_address_info_async_cancel(SockLookupData *lookup_data)
1182 {
1183         if (lookup_data->io_tag > 0)
1184                 g_source_remove(lookup_data->io_tag);
1185         if (lookup_data->channel) {
1186                 GError *err = NULL;
1187                 g_io_channel_shutdown(lookup_data->channel, TRUE, &err);
1188                 if (err)
1189                         g_error_free(err);
1190
1191                 g_io_channel_unref(lookup_data->channel);
1192         }
1193
1194         if (lookup_data->child_pid > 0) {
1195 #ifdef G_OS_WIN32
1196                 /* FIXME: Need a way to cancel the thread. */
1197 #else
1198                 kill(lookup_data->child_pid, SIGKILL);
1199                 waitpid(lookup_data->child_pid, NULL, 0);
1200 #endif
1201         }
1202
1203         g_free(lookup_data->canonical_name);
1204         g_free(lookup_data->hostname);
1205         g_free(lookup_data);
1206
1207         return 0;
1208 }
1209
1210
1211 static SockInfo *sockinfo_from_fd(const gchar *hostname,
1212                                   gushort port,
1213                                   gint sock)
1214 {
1215         SockInfo *sockinfo;
1216
1217         sockinfo = g_new0(SockInfo, 1);
1218         sockinfo->sock = sock;
1219 #ifndef G_OS_WIN32
1220         sockinfo->sock_ch = g_io_channel_unix_new(sock);
1221 #else
1222         sockinfo->sock_ch = g_io_channel_win32_new_socket(sock);
1223 #endif
1224         sockinfo->hostname = g_strdup(hostname);
1225         sockinfo->port = port;
1226         sockinfo->state = CONN_ESTABLISHED;
1227
1228         return sockinfo;
1229 }
1230
1231 static gint fd_read(gint fd, gchar *buf, gint len)
1232 {
1233         if (fd_check_io(fd, G_IO_IN) < 0)
1234                 return -1;
1235
1236         if (fd_is_w32_socket(fd))
1237                 return recv(fd, buf, len, 0);
1238         return read(fd, buf, len);
1239 }
1240
1241 #if USE_GNUTLS
1242 static gint ssl_read(gnutls_session_t ssl, gchar *buf, gint len)
1243 {
1244         gint r;
1245
1246         if (gnutls_record_check_pending(ssl) == 0) {
1247                 if (fd_check_io(GPOINTER_TO_INT(gnutls_transport_get_ptr(ssl)), G_IO_IN) < 0)
1248                         return -1;
1249         }
1250
1251         while (1) {
1252                 r = gnutls_record_recv(ssl, buf, len);
1253                 if (r > 0)
1254                         return r;
1255
1256                 switch (r) {
1257                 case 0: /* closed connection */
1258                         return -1;
1259
1260                 case GNUTLS_E_REHANDSHAKE:
1261                         do {
1262                                 r = gnutls_handshake(ssl);
1263                         } while (r == GNUTLS_E_AGAIN || r == GNUTLS_E_INTERRUPTED);
1264                         break; /* re-receive */
1265                 case GNUTLS_E_AGAIN:
1266                 case GNUTLS_E_INTERRUPTED:
1267                         errno = EAGAIN;
1268                         return -1;
1269
1270                 default:
1271                         debug_print("Unexpected SSL read result %d\n", r);
1272                         errno = EIO;
1273                         return -1;
1274                 }
1275         }
1276
1277 }
1278 #endif
1279
1280 gint sock_read(SockInfo *sock, gchar *buf, gint len)
1281 {
1282         gint ret;
1283
1284         cm_return_val_if_fail(sock != NULL, -1);
1285
1286 #ifdef USE_GNUTLS
1287         if (sock->ssl)
1288                 ret = ssl_read(sock->ssl, buf, len);
1289         else
1290 #endif
1291                 ret = fd_read(sock->sock, buf, len);
1292
1293         if (ret < 0)
1294                 sock->state = CONN_DISCONNECTED;
1295         return ret;
1296 }
1297
1298 gint fd_write(gint fd, const gchar *buf, gint len)
1299 {
1300         if (fd_check_io(fd, G_IO_OUT) < 0)
1301                 return -1;
1302
1303         if (fd_is_w32_socket (fd))
1304                 return send(fd, buf, len, 0);
1305         return write(fd, buf, len);
1306 }
1307
1308 #if USE_GNUTLS
1309 static gint ssl_write(gnutls_session_t ssl, const gchar *buf, gint len)
1310 {
1311         gint ret;
1312
1313         if (fd_check_io(GPOINTER_TO_INT(gnutls_transport_get_ptr(ssl)), G_IO_OUT) < 0)
1314                 return -1;
1315
1316         ret = gnutls_record_send(ssl, buf, len);
1317
1318         switch (ret) {
1319         case 0:
1320                 return -1;
1321         case GNUTLS_E_AGAIN:
1322         case GNUTLS_E_INTERRUPTED:
1323                 return 0;
1324
1325         default:
1326                 return ret;
1327         }
1328 }
1329
1330 #endif
1331
1332 gint sock_write(SockInfo *sock, const gchar *buf, gint len)
1333 {
1334         gint ret;
1335
1336         cm_return_val_if_fail(sock != NULL, -1);
1337
1338 #ifdef USE_GNUTLS
1339         if (sock->ssl)
1340                 ret = ssl_write(sock->ssl, buf, len);
1341         else
1342 #endif
1343                 ret = fd_write(sock->sock, buf, len);
1344
1345         if (ret < 0)
1346                 sock->state = CONN_DISCONNECTED;
1347         return ret;
1348 }
1349
1350 gint fd_write_all(gint fd, const gchar *buf, gint len)
1351 {
1352         gint n, wrlen = 0;
1353
1354         while (len) {
1355                 if (fd_check_io(fd, G_IO_OUT) < 0)
1356                         return -1;
1357 #ifndef G_OS_WIN32
1358                 signal(SIGPIPE, SIG_IGN);
1359 #endif
1360                 if (fd_is_w32_socket(fd))
1361                         n = send(fd, buf, len, 0);
1362                 else
1363                         n = write(fd, buf, len);
1364
1365                 if (n <= 0) {
1366                         log_error(LOG_PROTOCOL, _("write on fd%d: %s\n"), fd, g_strerror(errno));
1367                         return -1;
1368                 }
1369                 len -= n;
1370                 wrlen += n;
1371                 buf += n;
1372         }
1373
1374         return wrlen;
1375 }
1376
1377 #ifdef USE_GNUTLS
1378 static gint ssl_write_all(gnutls_session_t ssl, const gchar *buf, gint len)
1379 {
1380         gint n, wrlen = 0;
1381
1382         while (len) {
1383                 n = ssl_write(ssl, buf, len);
1384                 if (n <= 0)
1385                         return -1;
1386                 len -= n;
1387                 wrlen += n;
1388                 buf += n;
1389         }
1390
1391         return wrlen;
1392 }
1393 #endif
1394
1395 gint sock_write_all(SockInfo *sock, const gchar *buf, gint len)
1396 {
1397         gint ret;
1398
1399         cm_return_val_if_fail(sock != NULL, -1);
1400
1401 #ifdef USE_GNUTLS
1402         if (sock->ssl)
1403                 ret = ssl_write_all(sock->ssl, buf, len);
1404         else
1405 #endif
1406                 ret = fd_write_all(sock->sock, buf, len);
1407
1408         if (ret < 0)
1409                 sock->state = CONN_DISCONNECTED;
1410         return ret;
1411 }
1412
1413 static gint fd_recv(gint fd, gchar *buf, gint len, gint flags)
1414 {
1415         if (fd_check_io(fd, G_IO_IN) < 0)
1416                 return -1;
1417
1418         return recv(fd, buf, len, flags);
1419 }
1420
1421 gint fd_gets(gint fd, gchar *buf, gint len)
1422 {
1423         gchar *newline, *bp = buf;
1424         gint n;
1425
1426         if (--len < 1)
1427                 return -1;
1428
1429 #ifdef G_OS_WIN32
1430         fd_check_io(fd, G_IO_IN);
1431         do {
1432 /*
1433 XXX:tm try nonblock
1434 MSKB Article ID: Q147714
1435 Windows Sockets 2 Service Provider Interface Limitations
1436 Polling with recv(MSG_PEEK) to determine when a complete message
1437 has arrived.
1438     Reason and Workaround not available.
1439
1440 Single-byte send() and recv().
1441     Reason: Couple one-byte sends with Nagle disabled.
1442     Workaround: Send modest amounts and receive as much as possible.
1443 (still unused)
1444 */
1445                 if (recv(fd, bp, 1, 0) <= 0)
1446                         return -1;
1447                 if (*bp == '\n')
1448                         break;
1449                 bp++;
1450                 len--;
1451         } while (0 < len);
1452 #else /*!G_OS_WIN32*/
1453         do {
1454                 if ((n = fd_recv(fd, bp, len, MSG_PEEK)) <= 0)
1455                         return -1;
1456                 if ((newline = memchr(bp, '\n', n)) != NULL)
1457                         n = newline - bp + 1;
1458                 if ((n = fd_read(fd, bp, n)) < 0)
1459                         return -1;
1460                 bp += n;
1461                 len -= n;
1462         } while (!newline && len);
1463 #endif /*!G_OS_WIN32*/
1464
1465         *bp = '\0';
1466         return bp - buf;
1467 }
1468
1469 gint sock_close(SockInfo *sock)
1470 {
1471         gint ret;
1472
1473         if (!sock)
1474                 return 0;
1475
1476         if (sock->sock_ch)
1477                 g_io_channel_unref(sock->sock_ch);
1478
1479 #ifdef USE_GNUTLS
1480         if (sock->ssl)
1481                 ssl_done_socket(sock);
1482         if (sock->g_source != 0 && g_main_context_find_source_by_id(NULL, sock->g_source) != NULL)
1483                 g_source_remove(sock->g_source);
1484         sock->g_source = 0;
1485 #endif
1486 #ifdef G_OS_WIN32
1487         shutdown(sock->sock, 1); /* complete transfer before close */
1488         ret = closesocket(sock->sock);
1489 #else
1490         ret = fd_close(sock->sock);
1491 #endif
1492
1493         g_free(sock->canonical_name);
1494         g_free(sock->hostname);
1495         g_free(sock);
1496
1497         return ret;
1498 }
1499
1500 gint fd_close(gint fd)
1501 {
1502         return close(fd);
1503 }