gio/gsocks5proxy.c

   1  /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2008, 2010 Collabora, Ltd.
   4  * Copyright (C) 2008 Nokia Corporation. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * Author:  Youness Alaoui <youness.alaoui@collabora.co.uk
  22  *
  23  * Contributors:
  24  *          Nicolas Dufresne <nicolas.dufresne@collabora.co.uk>
  25  */
  26
  27 #include "config.h"
  28
  29 #include "gsocks5proxy.h"
  30
  31 #include <string.h>
  32
  33 #include "giomodule.h"
  34 #include "giomodule-priv.h"
  35 #include "giostream.h"
  36 #include "ginetaddress.h"
  37 #include "ginputstream.h"
  38 #include "glibintl.h"
  39 #include "goutputstream.h"
  40 #include "gproxy.h"
  41 #include "gproxyaddress.h"
  42 #include "gsimpleasyncresult.h"
  43
  44 #define SOCKS5_VERSION            0x05
  45
  46 #define SOCKS5_CMD_CONNECT        0x01
  47 #define SOCKS5_CMD_BIND           0x02
  48 #define SOCKS5_CMD_UDP_ASSOCIATE  0x03
  49
  50 #define SOCKS5_ATYP_IPV4          0x01
  51 #define SOCKS5_ATYP_DOMAINNAME    0x03
  52 #define SOCKS5_ATYP_IPV6          0x04
  53
  54 #define SOCKS5_AUTH_VERSION       0x01
  55
  56 #define SOCKS5_AUTH_NONE          0x00
  57 #define SOCKS5_AUTH_GSSAPI        0x01
  58 #define SOCKS5_AUTH_USR_PASS      0x02
  59 #define SOCKS5_AUTH_NO_ACCEPT     0xff
  60
  61 #define SOCKS5_MAX_LEN            255
  62 #define SOCKS5_RESERVED           0x00
  63
  64 #define SOCKS5_REP_SUCCEEDED      0x00
  65 #define SOCKS5_REP_SRV_FAILURE    0x01
  66 #define SOCKS5_REP_NOT_ALLOWED    0x02
  67 #define SOCKS5_REP_NET_UNREACH    0x03
  68 #define SOCKS5_REP_HOST_UNREACH   0x04
  69 #define SOCKS5_REP_REFUSED        0x05
  70 #define SOCKS5_REP_TTL_EXPIRED    0x06
  71 #define SOCKS5_REP_CMD_NOT_SUP    0x07
  72 #define SOCKS5_REP_ATYPE_NOT_SUP  0x08
  73
  74
  75 struct _GSocks5Proxy
  76 {
  77   GObject parent;
  78 };
  79
  80 struct _GSocks5ProxyClass
  81 {
  82   GObjectClass parent_class;
  83 };
  84
  85 static void g_socks5_proxy_iface_init (GProxyInterface *proxy_iface);
  86
  87 #define g_socks5_proxy_get_type _g_socks5_proxy_get_type
  88 G_DEFINE_TYPE_WITH_CODE (GSocks5Proxy, g_socks5_proxy, G_TYPE_OBJECT,
  89                          G_IMPLEMENT_INTERFACE (G_TYPE_PROXY,
  90                                                 g_socks5_proxy_iface_init)
  91                          _g_io_modules_ensure_extension_points_registered ();
  92                          g_io_extension_point_implement (G_PROXY_EXTENSION_POINT_NAME,
  93                                                          g_define_type_id,
  94                                                          "socks5",
  95                                                          0))
  96
  97 static void
  98 g_socks5_proxy_finalize (GObject *object)
  99 {
 100   /* must chain up */
 101   G_OBJECT_CLASS (g_socks5_proxy_parent_class)->finalize (object);
 102 }
 103
 104 static void
 105 g_socks5_proxy_init (GSocks5Proxy *proxy)
 106 {
 107 }
 108
 109 /*
 110  * +----+----------+----------+
 111  * |VER | NMETHODS | METHODS  |
 112  * +----+----------+----------+
 113  * | 1  |    1     | 1 to 255 |
 114  * +----+----------+----------+
 115  */
 116 #define SOCKS5_NEGO_MSG_LEN       4
 117 static gint
 118 set_nego_msg (guint8 *msg, gboolean has_auth)
 119 {
 120   gint len = 3;
 121
 122   msg[0] = SOCKS5_VERSION;
 123   msg[1] = 0x01; /* number of methods supported */
 124   msg[2] = SOCKS5_AUTH_NONE;
 125
 126   /* add support for authentication method */
 127   if (has_auth)
 128     {
 129       msg[1] = 0x02; /* number of methods supported */
 130       msg[3] = SOCKS5_AUTH_USR_PASS;
 131       len++;
 132     }
 133
 134   return len;
 135 }
 136
 137
 138 /*
 139  * +----+--------+
 140  * |VER | METHOD |
 141  * +----+--------+
 142  * | 1  |   1    |
 143  * +----+--------+
 144  */
 145 #define SOCKS5_NEGO_REP_LEN       2
 146 static gboolean
 147 parse_nego_reply (const guint8 *data,
 148                   gboolean     has_auth,
 149                   gboolean    *must_auth,
 150                   GError     **error)
 151 {
 152   if (data[0] != SOCKS5_VERSION)
 153     {
 154       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 155                            _("The server is not a SOCKSv5 proxy server."));
 156       return FALSE;
 157     }
 158
 159   switch (data[1])
 160     {
 161       case SOCKS5_AUTH_NONE:
 162         *must_auth = FALSE;
 163         break;
 164
 165       case SOCKS5_AUTH_USR_PASS:
 166         if (!has_auth)
 167           {
 168             g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_NEED_AUTH,
 169                            _("The SOCKSv5 proxy requires authentication."));
 170             return FALSE;
 171           }
 172         *must_auth = TRUE;
 173         break;
 174
 175       case SOCKS5_AUTH_GSSAPI:
 176       case SOCKS5_AUTH_NO_ACCEPT:
 177       default:
 178         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_AUTH_FAILED,
 179                              _("The SOCKSv5 proxy requires an authentication method that is not "
 180                                "supported by GLib."));
 181         return FALSE;
 182         break;
 183     }
 184
 185   return TRUE;
 186 }
 187
 188 #define SOCKS5_AUTH_MSG_LEN       515
 189 static gint
 190 set_auth_msg (guint8      *msg,
 191               const gchar *username,
 192               const gchar *password,
 193               GError **error)
 194 {
 195   gint len = 0;
 196   gint ulen = 0; /* username length */
 197   gint plen = 0; /* Password length */
 198
 199   if (username)
 200     ulen = strlen (username);
 201
 202   if (password)
 203     plen = strlen (password);
 204
 205   if (ulen > SOCKS5_MAX_LEN || plen > SOCKS5_MAX_LEN)
 206     {
 207       g_set_error (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 208                    _("Username or password is too long for SOCKSv5 "
 209                      "protocol (max. is %i)."),
 210                    SOCKS5_MAX_LEN);
 211       return FALSE;
 212     }
 213
 214   msg[len++] = SOCKS5_AUTH_VERSION;
 215   msg[len++] = ulen;
 216
 217   if (ulen > 0)
 218     memcpy (msg + len, username, ulen);
 219
 220   len += ulen;
 221   msg[len++] = plen;
 222
 223   if (plen > 0)
 224     memcpy (msg + len, password, plen);
 225
 226   len += plen;
 227
 228   return len;
 229 }
 230
 231
 232 static gboolean
 233 check_auth_status (const guint8 *data, GError **error)
 234 {
 235   if (data[0] != SOCKS5_VERSION
 236       || data[1] != SOCKS5_REP_SUCCEEDED)
 237     {
 238       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_AUTH_FAILED,
 239                            _("SOCKSv5 authentication failed due to wrong "
 240                              "username or password."));
 241       return FALSE;
 242     }
 243   return TRUE;
 244 }
 245
 246 /*
 247  * +----+-----+-------+------+----------+----------+
 248  * |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
 249  * +----+-----+-------+------+----------+----------+
 250  * | 1  |  1  | X'00' |  1   | Variable |    2     |
 251  * +----+-----+-------+------+----------+----------+
 252  * DST.ADDR is a string with first byte being the size. So DST.ADDR may not be
 253  * longer then 256 bytes.
 254  */
 255 #define SOCKS5_CONN_MSG_LEN       262
 256 static gint
 257 set_connect_msg (guint8       *msg,
 258                  const gchar *hostname,
 259                  guint16      port,
 260                  GError     **error)
 261 {
 262   guint len = 0;
 263
 264   msg[len++] = SOCKS5_VERSION;
 265   msg[len++] = SOCKS5_CMD_CONNECT;
 266   msg[len++] = SOCKS5_RESERVED;
 267
 268   if (g_hostname_is_ip_address (hostname))
 269     {
 270       GInetAddress *addr = g_inet_address_new_from_string (hostname);
 271       gsize addr_len = g_inet_address_get_native_size (addr);
 272
 273       /* We are cheating for simplicity, here's the logic:
 274        *   1 = IPV4 = 4 bytes / 4
 275        *   4 = IPV6 = 16 bytes / 4 */
 276       msg[len++] = addr_len / 4;
 277       memcpy (msg + len, g_inet_address_to_bytes (addr), addr_len);
 278       len += addr_len;
 279
 280       g_object_unref (addr);
 281     }
 282   else
 283     {
 284       gsize host_len = strlen (hostname);
 285
 286       if (host_len > SOCKS5_MAX_LEN)
 287         {
 288           g_set_error (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 289                        _("Hostname '%s' too long for SOCKSv5 protocol "
 290                          "(maximum is %i bytes)"),
 291                        hostname, SOCKS5_MAX_LEN);
 292           return -1;
 293         }
 294
 295       msg[len++] = SOCKS5_ATYP_DOMAINNAME;
 296       msg[len++] = (guint8) host_len;
 297       memcpy (msg + len, hostname, host_len);
 298       len += host_len;
 299     }
 300
 301     {
 302       guint16 hp = g_htons (port);
 303       memcpy (msg + len, &hp, 2);
 304       len += 2;
 305     }
 306
 307   return len;
 308 }
 309
 310 /*
 311  * +----+-----+-------+------+----------+----------+
 312  * |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
 313  * +----+-----+-------+------+----------+----------+
 314  * | 1  |  1  | X'00' |  1   | Variable |    2     |
 315  * +----+-----+-------+------+----------+----------+
 316  * This reply need to be read by small part to determin size. Buffer
 317  * size is determined in function of the biggest part to read.
 318  *
 319  * The parser only requires 4 bytes.
 320  */
 321 #define SOCKS5_CONN_REP_LEN       255
 322 static gboolean
 323 parse_connect_reply (const guint8 *data, gint *atype, GError **error)
 324 {
 325   if (data[0] != SOCKS5_VERSION)
 326     {
 327       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 328                            _("The server is not a SOCKSv5 proxy server."));
 329       return FALSE;
 330     }
 331
 332   switch (data[1])
 333     {
 334       case SOCKS5_REP_SUCCEEDED:
 335         if (data[2] != SOCKS5_RESERVED)
 336           {
 337             g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 338                            _("The server is not a SOCKSv5 proxy server."));
 339             return FALSE;
 340           }
 341
 342         switch (data[3])
 343           {
 344           case SOCKS5_ATYP_IPV4:
 345           case SOCKS5_ATYP_IPV6:
 346           case SOCKS5_ATYP_DOMAINNAME:
 347             *atype = data[3];
 348             break;
 349
 350           default:
 351             g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 352                            _("The SOCKSv5 proxy server uses unkown address type."));
 353             return FALSE;
 354           }
 355         break;
 356
 357       case SOCKS5_REP_SRV_FAILURE:
 358         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 359                              _("Internal SOCKSv5 proxy server error."));
 360         return FALSE;
 361         break;
 362
 363       case SOCKS5_REP_NOT_ALLOWED:
 364         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_NOT_ALLOWED,
 365                              _("SOCKSv5 connection not allowed by ruleset."));
 366         return FALSE;
 367         break;
 368
 369       case SOCKS5_REP_TTL_EXPIRED:
 370       case SOCKS5_REP_HOST_UNREACH:
 371         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_HOST_UNREACHABLE,
 372                              _("Host unreachable through SOCKSv5 server."));
 373         return FALSE;
 374         break;
 375
 376       case SOCKS5_REP_NET_UNREACH:
 377         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NETWORK_UNREACHABLE,
 378                              _("Network unreachable through SOCKSv5 proxy."));
 379         return FALSE;
 380         break;
 381
 382       case SOCKS5_REP_REFUSED:
 383         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_REFUSED,
 384                              _("Connection refused through SOCKSv5 proxy."));
 385         return FALSE;
 386         break;
 387
 388       case SOCKS5_REP_CMD_NOT_SUP:
 389         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 390                              _("SOCKSv5 proxy does not support 'connect' command."));
 391         return FALSE;
 392         break;
 393
 394       case SOCKS5_REP_ATYPE_NOT_SUP:
 395         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 396                              _("SOCKSv5 proxy does not support provided address type."));
 397         return FALSE;
 398         break;
 399
 400       default: /* Unknown error */
 401         g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PROXY_FAILED,
 402                              _("Unknown SOCKSv5 proxy error."));
 403         return FALSE;
 404         break;
 405     }
 406
 407   return TRUE;
 408 }
 409
 410 static GIOStream *
 411 g_socks5_proxy_connect (GProxy            *proxy,
 412                         GIOStream         *io_stream,
 413                         GProxyAddress     *proxy_address,
 414                         GCancellable      *cancellable,
 415                         GError          **error)
 416 {
 417   gboolean has_auth;
 418   GInputStream *in;
 419   GOutputStream *out;
 420   const gchar *hostname;
 421   guint16 port;
 422   const gchar *username;
 423   const gchar *password;
 424
 425   hostname = g_proxy_address_get_destination_hostname (proxy_address);
 426   port = g_proxy_address_get_destination_port (proxy_address);
 427   username = g_proxy_address_get_username (proxy_address);
 428   password = g_proxy_address_get_password (proxy_address);
 429
 430   has_auth = username || password;
 431
 432   in = g_io_stream_get_input_stream (io_stream);
 433   out = g_io_stream_get_output_stream (io_stream);
 434
 435   /* Send SOCKS5 handshake */
 436     {
 437       guint8 msg[SOCKS5_NEGO_MSG_LEN];
 438       gint len;
 439
 440       len = set_nego_msg (msg, has_auth);
 441
 442       if (!g_output_stream_write_all (out, msg, len, NULL,
 443                                       cancellable, error))
 444         goto error;
 445     }
 446
 447   /* Recieve SOCKS5 response and reply with authentication if required */
 448     {
 449       guint8 data[SOCKS5_NEGO_REP_LEN];
 450       gboolean must_auth = FALSE;
 451
 452       if (!g_input_stream_read_all (in, data, sizeof (data), NULL,
 453                                     cancellable, error))
 454         goto error;
 455
 456       if (!parse_nego_reply (data, has_auth, &must_auth, error))
 457           goto error;
 458
 459       if (must_auth)
 460         {
 461           guint8 msg[SOCKS5_AUTH_MSG_LEN];
 462           gint len;
 463
 464           len = set_auth_msg (msg, username, password, error);
 465
 466           if (len < 0)
 467             goto error;
 468
 469           if (!g_output_stream_write_all (out, msg, len, NULL,
 470                                           cancellable, error))
 471             goto error;
 472
 473           if (!g_input_stream_read_all (in, data, sizeof (data), NULL,
 474                                         cancellable, error))
 475             goto error;
 476
 477           if (!check_auth_status (data, error))
 478             goto error;
 479         }
 480     }
 481
 482   /* Send SOCKS5 connection request */
 483     {
 484       guint8 msg[SOCKS5_CONN_MSG_LEN];
 485       gint len;
 486
 487       len = set_connect_msg (msg, hostname, port, error);
 488
 489       if (len < 0)
 490         goto error;
 491
 492       if (!g_output_stream_write_all (out, msg, len, NULL,
 493                                       cancellable, error))
 494         goto error;
 495     }
 496
 497   /* Read SOCKS5 response */
 498     {
 499       guint8 data[SOCKS5_CONN_REP_LEN];
 500       gint atype;
 501
 502       if (!g_input_stream_read_all (in, data, 4, NULL,
 503                                     cancellable, error))
 504         goto error;
 505
 506       if (!parse_connect_reply (data, &atype, error))
 507         goto error;
 508
 509       switch (atype)
 510         {
 511           case SOCKS5_ATYP_IPV4:
 512             if (!g_input_stream_read_all (in, data, 6, NULL,
 513                                           cancellable, error))
 514               goto error;
 515             break;
 516
 517           case SOCKS5_ATYP_IPV6:
 518             if (!g_input_stream_read_all (in, data, 18, NULL,
 519                                           cancellable, error))
 520               goto error;
 521             break;
 522
 523           case SOCKS5_ATYP_DOMAINNAME:
 524             if (!g_input_stream_read_all (in, data, 1, NULL,
 525                                           cancellable, error))
 526               goto error;
 527             if (!g_input_stream_read_all (in, data, data[0] + 2, NULL,
 528                                           cancellable, error))
 529               goto error;
 530             break;
 531         }
 532     }
 533
 534   return g_object_ref (io_stream);
 535
 536 error:
 537   return NULL;
 538 }
 539
 540
 541 typedef struct
 542 {
 543   GSimpleAsyncResult *simple;
 544   GIOStream *io_stream;
 545   gchar *hostname;
 546   guint16 port;
 547   gchar *username;
 548   gchar *password;
 549   guint8 *buffer;
 550   gssize length;
 551   gssize offset;
 552   GCancellable *cancellable;
 553 } ConnectAsyncData;
 554
 555 static void nego_msg_write_cb         (GObject          *source,
 556                                        GAsyncResult     *res,
 557                                        gpointer          user_data);
 558 static void nego_reply_read_cb        (GObject          *source,
 559                                        GAsyncResult     *res,
 560                                        gpointer          user_data);
 561 static void auth_msg_write_cb         (GObject          *source,
 562                                        GAsyncResult     *res,
 563                                        gpointer          user_data);
 564 static void auth_reply_read_cb        (GObject          *source,
 565                                        GAsyncResult     *result,
 566                                        gpointer          user_data);
 567 static void send_connect_msg          (ConnectAsyncData *data);
 568 static void connect_msg_write_cb      (GObject          *source,
 569                                        GAsyncResult     *result,
 570                                        gpointer          user_data);
 571 static void connect_reply_read_cb     (GObject          *source,
 572                                        GAsyncResult     *result,
 573                                        gpointer          user_data);
 574 static void connect_addr_len_read_cb  (GObject          *source,
 575                                        GAsyncResult     *result,
 576                                        gpointer          user_data);
 577 static void connect_addr_read_cb      (GObject          *source,
 578                                        GAsyncResult     *result,
 579                                        gpointer          user_data);
 580
 581 static void
 582 free_connect_data (ConnectAsyncData *data)
 583 {
 584   if (data->io_stream)
 585     g_object_unref (data->io_stream);
 586
 587   g_free (data->hostname);
 588   g_free (data->username);
 589   g_free (data->password);
 590   g_free (data->buffer);
 591
 592   if (data->cancellable)
 593     g_object_unref (data->cancellable);
 594
 595   g_slice_free (ConnectAsyncData, data);
 596 }
 597
 598 static void
 599 complete_async_from_error (ConnectAsyncData *data, GError *error)
 600 {
 601   GSimpleAsyncResult *simple = data->simple;
 602   g_simple_async_result_take_error (data->simple, error);
 603   g_simple_async_result_set_op_res_gpointer (simple, NULL, NULL);
 604   g_simple_async_result_complete (simple);
 605   g_object_unref (simple);
 606 }
 607
 608 static void
 609 do_read (GAsyncReadyCallback callback, ConnectAsyncData *data)
 610 {
 611    GInputStream *in;
 612    in = g_io_stream_get_input_stream (data->io_stream);
 613    g_input_stream_read_async (in,
 614                               data->buffer + data->offset,
 615                               data->length - data->offset,
 616                               G_PRIORITY_DEFAULT, data->cancellable,
 617                               callback, data);
 618 }
 619
 620 static void
 621 do_write (GAsyncReadyCallback callback, ConnectAsyncData *data)
 622 {
 623   GOutputStream *out;
 624   out = g_io_stream_get_output_stream (data->io_stream);
 625   g_output_stream_write_async (out,
 626                                data->buffer + data->offset,
 627                                data->length - data->offset,
 628                                G_PRIORITY_DEFAULT, data->cancellable,
 629                                callback, data);
 630 }
 631
 632 static void
 633 g_socks5_proxy_connect_async (GProxy               *proxy,
 634                               GIOStream            *io_stream,
 635                               GProxyAddress        *proxy_address,
 636                               GCancellable         *cancellable,
 637                               GAsyncReadyCallback   callback,
 638                               gpointer              user_data)
 639 {
 640   GSimpleAsyncResult *simple;
 641   ConnectAsyncData *data;
 642
 643   simple = g_simple_async_result_new (G_OBJECT (proxy),
 644                                       callback, user_data,
 645                                       g_socks5_proxy_connect_async);
 646
 647   data = g_slice_new0 (ConnectAsyncData);
 648
 649   data->simple = simple;
 650   data->io_stream = g_object_ref (io_stream);
 651
 652   if (cancellable)
 653     data->cancellable = g_object_ref (cancellable);
 654
 655   g_object_get (G_OBJECT (proxy_address),
 656                 "destination-hostname", &data->hostname,
 657                 "destination-port", &data->port,
 658                 "username", &data->username,
 659                 "password", &data->password,
 660                 NULL);
 661
 662   g_simple_async_result_set_op_res_gpointer (simple, data,
 663                                              (GDestroyNotify) free_connect_data);
 664
 665   data->buffer = g_malloc0 (SOCKS5_NEGO_MSG_LEN);
 666   data->length = set_nego_msg (data->buffer,
 667                                data->username || data->password);
 668   data->offset = 0;
 669
 670   do_write (nego_msg_write_cb, data);
 671 }
 672
 673
 674 static void
 675 nego_msg_write_cb (GObject      *source,
 676                    GAsyncResult *res,
 677                    gpointer      user_data)
 678 {
 679   GError *error = NULL;
 680   ConnectAsyncData *data = user_data;
 681   gssize written;
 682
 683   written = g_output_stream_write_finish (G_OUTPUT_STREAM (source),
 684                                           res, &error);
 685
 686   if (written < 0)
 687     {
 688       complete_async_from_error (data, error);
 689       return;
 690     }
 691
 692   data->offset += written;
 693
 694   if (data->offset == data->length)
 695     {
 696       g_free (data->buffer);
 697
 698       data->buffer = g_malloc0 (SOCKS5_NEGO_REP_LEN);
 699       data->length = SOCKS5_NEGO_REP_LEN;
 700       data->offset = 0;
 701
 702       do_read (nego_reply_read_cb, data);
 703     }
 704   else
 705     {
 706       do_write (nego_msg_write_cb, data);
 707     }
 708 }
 709
 710 static void
 711 nego_reply_read_cb (GObject      *source,
 712                     GAsyncResult *res,
 713                     gpointer      user_data)
 714 {
 715   GError *error = NULL;
 716   ConnectAsyncData *data = user_data;
 717   gssize read;
 718
 719   read = g_input_stream_read_finish (G_INPUT_STREAM (source),
 720                                      res, &error);
 721
 722   if (read < 0)
 723     {
 724       complete_async_from_error (data, error);
 725       return;
 726     }
 727
 728   data->offset += read;
 729
 730   if (data->offset == data->length)
 731     {
 732       GError *error;
 733       gboolean must_auth = FALSE;
 734       gboolean has_auth = data->username || data->password;
 735
 736       if (!parse_nego_reply (data->buffer, has_auth, &must_auth, &error))
 737         {
 738           complete_async_from_error (data, error);
 739           return;
 740         }
 741
 742       if (must_auth)
 743         {
 744           g_free (data->buffer);
 745
 746           data->buffer = g_malloc0 (SOCKS5_AUTH_MSG_LEN);
 747           data->length = set_auth_msg (data->buffer,
 748                                        data->username,
 749                                        data->password,
 750                                        &error);
 751           data->offset = 0;
 752
 753           if (data->length < 0)
 754             {
 755               complete_async_from_error (data, error);
 756               return;
 757             }
 758
 759           do_write (auth_msg_write_cb, data);
 760         }
 761       else
 762         {
 763           send_connect_msg (data);
 764         }
 765     }
 766   else
 767     {
 768       do_read (nego_reply_read_cb, data);
 769     }
 770 }
 771
 772 static void
 773 auth_msg_write_cb (GObject      *source,
 774                    GAsyncResult *result,
 775                    gpointer      user_data)
 776 {
 777   GError *error = NULL;
 778   ConnectAsyncData *data = user_data;
 779   gssize written;
 780
 781   written = g_output_stream_write_finish (G_OUTPUT_STREAM (source),
 782                                           result, &error);
 783
 784   if (written < 0)
 785     {
 786       complete_async_from_error (data, error);
 787       return;
 788     }
 789
 790   data->offset += written;
 791
 792   if (data->offset == data->length)
 793     {
 794       g_free (data->buffer);
 795
 796       data->buffer = g_malloc0 (SOCKS5_NEGO_REP_LEN);
 797       data->length = SOCKS5_NEGO_REP_LEN;
 798       data->offset = 0;
 799
 800       do_read (auth_reply_read_cb, data);
 801     }
 802   else
 803     {
 804       do_write (auth_msg_write_cb, data);
 805     }
 806 }
 807
 808 static void
 809 auth_reply_read_cb (GObject      *source,
 810                     GAsyncResult *result,
 811                     gpointer      user_data)
 812 {
 813   GError *error = NULL;
 814   ConnectAsyncData *data = user_data;
 815   gssize read;
 816
 817   read = g_input_stream_read_finish (G_INPUT_STREAM (source),
 818                                      result, &error);
 819
 820   if (read < 0)
 821     {
 822       complete_async_from_error (data, error);
 823       return;
 824     }
 825
 826   data->offset += read;
 827
 828   if (data->offset == data->length)
 829     {
 830       if (!check_auth_status (data->buffer, &error))
 831         {
 832           complete_async_from_error (data, error);
 833           return;
 834         }
 835
 836       send_connect_msg (data);
 837     }
 838   else
 839     {
 840       do_read (auth_reply_read_cb, data);
 841     }
 842 }
 843
 844 static void
 845 send_connect_msg (ConnectAsyncData *data)
 846 {
 847   GError *error = NULL;
 848
 849   g_free (data->buffer);
 850
 851   data->buffer = g_malloc0 (SOCKS5_CONN_MSG_LEN);
 852   data->length = set_connect_msg (data->buffer,
 853                                   data->hostname,
 854                                   data->port,
 855                                   &error);
 856   data->offset = 0;
 857
 858   if (data->length < 0)
 859     {
 860       complete_async_from_error (data, error);
 861       return;
 862     }
 863
 864   do_write (connect_msg_write_cb, data);
 865 }
 866
 867 static void
 868 connect_msg_write_cb (GObject      *source,
 869                       GAsyncResult *result,
 870                       gpointer      user_data)
 871 {
 872   GError *error = NULL;
 873   ConnectAsyncData *data = user_data;
 874   gssize written;
 875
 876   written = g_output_stream_write_finish (G_OUTPUT_STREAM (source),
 877                                           result, &error);
 878
 879   if (written < 0)
 880     {
 881       complete_async_from_error (data, error);
 882       return;
 883     }
 884
 885   data->offset += written;
 886
 887   if (data->offset == data->length)
 888     {
 889       g_free (data->buffer);
 890
 891       data->buffer = g_malloc0 (SOCKS5_CONN_REP_LEN);
 892       data->length = 4;
 893       data->offset = 0;
 894
 895       do_read (connect_reply_read_cb, data);
 896     }
 897   else
 898     {
 899       do_write (connect_msg_write_cb, data);
 900     }
 901 }
 902
 903 static void
 904 connect_reply_read_cb (GObject       *source,
 905                        GAsyncResult  *result,
 906                        gpointer       user_data)
 907 {
 908   GError *error = NULL;
 909   ConnectAsyncData *data = user_data;
 910   gssize read;
 911
 912   read = g_input_stream_read_finish (G_INPUT_STREAM (source),
 913                                      result, &error);
 914
 915   if (read < 0)
 916     {
 917       complete_async_from_error (data, error);
 918       return;
 919     }
 920
 921   data->offset += read;
 922
 923   if (data->offset == data->length)
 924     {
 925       gint atype;
 926
 927       if (!parse_connect_reply (data->buffer, &atype, &error))
 928         {
 929           complete_async_from_error (data, error);
 930           return;
 931         }
 932
 933       switch (atype)
 934         {
 935           case SOCKS5_ATYP_IPV4:
 936             data->length = 6;
 937             data->offset = 0;
 938             do_read (connect_addr_read_cb, data);
 939             break;
 940
 941           case SOCKS5_ATYP_IPV6:
 942             data->length = 18;
 943             data->offset = 0;
 944             do_read (connect_addr_read_cb, data);
 945             break;
 946
 947           case SOCKS5_ATYP_DOMAINNAME:
 948             data->length = 1;
 949             data->offset = 0;
 950             do_read (connect_addr_len_read_cb, data);
 951             break;
 952         }
 953     }
 954   else
 955     {
 956       do_read (connect_reply_read_cb, data);
 957     }
 958 }
 959
 960 static void
 961 connect_addr_len_read_cb (GObject      *source,
 962                           GAsyncResult *result,
 963                           gpointer      user_data)
 964 {
 965   GError *error = NULL;
 966   ConnectAsyncData *data = user_data;
 967   gssize read;
 968
 969   read = g_input_stream_read_finish (G_INPUT_STREAM (source),
 970                                      result, &error);
 971
 972   if (read < 0)
 973     {
 974       complete_async_from_error (data, error);
 975       return;
 976     }
 977
 978   data->length = data->buffer[0] + 2;
 979   data->offset = 0;
 980
 981   do_read (connect_addr_read_cb, data);
 982 }
 983
 984 static void
 985 connect_addr_read_cb (GObject      *source,
 986                       GAsyncResult *result,
 987                       gpointer      user_data)
 988 {
 989   GError *error = NULL;
 990   ConnectAsyncData *data = user_data;
 991   gssize read;
 992
 993   read = g_input_stream_read_finish (G_INPUT_STREAM (source),
 994                                      result, &error);
 995
 996   if (read < 0)
 997     {
 998       complete_async_from_error (data, error);
 999       return;
1000     }
1001
1002   data->offset += read;
1003
1004   if (data->offset == data->length)
1005     {
1006       GSimpleAsyncResult *simple = data->simple;
1007       g_simple_async_result_complete (simple);
1008       g_object_unref (simple);
1009     }
1010   else
1011     {
1012       do_read (connect_reply_read_cb, data);
1013     }
1014 }
1015
1016 static GIOStream *
1017 g_socks5_proxy_connect_finish (GProxy       *proxy,
1018                                GAsyncResult *result,
1019                                GError      **error)
1020 {
1021   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
1022   ConnectAsyncData *data = g_simple_async_result_get_op_res_gpointer (simple);
1023
1024   if (g_simple_async_result_propagate_error (simple, error))
1025     return NULL;
1026
1027   return g_object_ref (data->io_stream);
1028 }
1029
1030 static gboolean
1031 g_socks5_proxy_supports_hostname (GProxy *proxy)
1032 {
1033   return TRUE;
1034 }
1035
1036 static void
1037 g_socks5_proxy_class_init (GSocks5ProxyClass *class)
1038 {
1039   GObjectClass *object_class;
1040
1041   object_class = (GObjectClass *) class;
1042   object_class->finalize = g_socks5_proxy_finalize;
1043 }
1044
1045 static void
1046 g_socks5_proxy_iface_init (GProxyInterface *proxy_iface)
1047 {
1048   proxy_iface->connect  = g_socks5_proxy_connect;
1049   proxy_iface->connect_async = g_socks5_proxy_connect_async;
1050   proxy_iface->connect_finish = g_socks5_proxy_connect_finish;
1051   proxy_iface->supports_hostname = g_socks5_proxy_supports_hostname;
1052 }