source: lib/proxy.c @ 777461b

Last change on this file since 777461b was ca8037e, checked in by Wilmer van der Gaast <wilmer@…>, at 2013-06-09T21:17:45Z

Add better handling of HTTP/1.1 and/or keepalive connections. This should
let me close #641, and more importantly, prepares the Twitter module for
an upcoming API change. https://dev.twitter.com/blog/deprecating-http-1.0-streaming-api

  • Property mode set to 100644
File size: 13.6 KB
Line 
1/*
2 * gaim
3 *
4 * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
5 * Copyright (C) 2002-2004, Wilmer van der Gaast, Jelmer Vernooij
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 as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20 *
21 */
22
23#define BITLBEE_CORE
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <sys/types.h>
28#ifndef _WIN32
29#include <sys/socket.h>
30#include <netdb.h>
31#include <netinet/in.h>
32#include <arpa/inet.h>
33#include <unistd.h>
34#else
35#include "sock.h"
36#define ETIMEDOUT WSAETIMEDOUT
37#define EINPROGRESS WSAEINPROGRESS
38#endif
39#include <fcntl.h>
40#include <errno.h>
41#include "nogaim.h"
42#include "proxy.h"
43#include "base64.h"
44
45char proxyhost[128] = "";
46int proxyport = 0;
47int proxytype = PROXY_NONE;
48char proxyuser[128] = "";
49char proxypass[128] = "";
50
51/* Some systems don't know this one. It's not essential, so set it to 0 then. */
52#ifndef AI_NUMERICSERV
53#define AI_NUMERICSERV 0
54#endif
55#ifndef AI_ADDRCONFIG
56#define AI_ADDRCONFIG 0
57#endif
58
59struct PHB {
60        b_event_handler func, proxy_func;
61        gpointer data, proxy_data;
62        char *host;
63        int port;
64        int fd;
65        gint inpa;
66        struct addrinfo *gai, *gai_cur;
67};
68
69static int proxy_connect_none(const char *host, unsigned short port_, struct PHB *phb);
70
71static gboolean gaim_io_connected(gpointer data, gint source, b_input_condition cond)
72{
73        struct PHB *phb = data;
74        unsigned int len;
75        int error = ETIMEDOUT;
76        len = sizeof(error);
77       
78#ifndef _WIN32
79        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0 || error) {
80                if ((phb->gai_cur = phb->gai_cur->ai_next)) {
81                        int new_fd;
82                        b_event_remove(phb->inpa);
83                        if ((new_fd = proxy_connect_none(NULL, 0, phb))) {
84                                b_event_remove(phb->inpa);
85                                closesocket(source);
86                                dup2(new_fd, source);
87                                closesocket(new_fd);
88                                phb->inpa = b_input_add(source, B_EV_IO_WRITE, gaim_io_connected, phb);
89                                return FALSE;
90                        }
91                }
92                freeaddrinfo(phb->gai);
93                closesocket(source);
94                b_event_remove(phb->inpa);
95                if( phb->proxy_func )
96                        phb->proxy_func(phb->proxy_data, -1, B_EV_IO_READ);
97                else {
98                        phb->func(phb->data, -1, B_EV_IO_READ);
99                        g_free(phb);
100                }
101                return FALSE;
102        }
103#endif
104        freeaddrinfo(phb->gai);
105        sock_make_blocking(source);
106        b_event_remove(phb->inpa);
107        if( phb->proxy_func )
108                phb->proxy_func(phb->proxy_data, source, B_EV_IO_READ);
109        else {
110                phb->func(phb->data, source, B_EV_IO_READ);
111                g_free(phb);
112        }
113       
114        return FALSE;
115}
116
117static int proxy_connect_none(const char *host, unsigned short port_, struct PHB *phb)
118{
119        struct sockaddr_in me;
120        int fd = -1;
121       
122        if (phb->gai_cur == NULL)
123        {
124                int ret;
125                char port[6];
126                struct addrinfo hints;
127       
128                g_snprintf(port, sizeof(port), "%d", port_);
129       
130                memset(&hints, 0, sizeof(struct addrinfo));
131                hints.ai_family = AF_UNSPEC;
132                hints.ai_socktype = SOCK_STREAM;
133                hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
134       
135                if (!(ret = getaddrinfo(host, port, &hints, &phb->gai)))
136                        phb->gai_cur = phb->gai;
137                else
138                        event_debug("gai(): %s\n", gai_strerror(ret));
139        }
140       
141        for (; phb->gai_cur; phb->gai_cur = phb->gai_cur->ai_next)
142        {
143                if ((fd = socket(phb->gai_cur->ai_family, phb->gai_cur->ai_socktype, phb->gai_cur->ai_protocol)) < 0) {
144                        event_debug( "socket failed: %d\n", errno);
145                        continue;
146                }
147
148                sock_make_nonblocking(fd);
149
150                if (global.conf->iface_out)
151                {
152                        me.sin_family = AF_INET;
153                        me.sin_port = 0;
154                        me.sin_addr.s_addr = inet_addr( global.conf->iface_out );
155                               
156                        if (bind(fd, (struct sockaddr *) &me, sizeof(me)) != 0)
157                                event_debug("bind( %d, \"%s\" ) failure\n", fd, global.conf->iface_out);
158                }
159
160                event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port_, fd);
161       
162                if (connect(fd, phb->gai_cur->ai_addr, phb->gai_cur->ai_addrlen) < 0 && !sockerr_again()) {
163                        event_debug( "connect failed: %s\n", strerror(errno));
164                        closesocket(fd);
165                        fd = -1;
166                        continue;
167                } else {
168                        phb->inpa = b_input_add(fd, B_EV_IO_WRITE, gaim_io_connected, phb);
169                        phb->fd = fd;
170                       
171                        break;
172                }
173        }
174       
175        if(fd < 0 && host)
176                g_free(phb);
177
178        return fd;
179}
180
181
182/* Connecting to HTTP proxies */
183
184#define HTTP_GOODSTRING "HTTP/1.0 200 Connection established"
185#define HTTP_GOODSTRING2 "HTTP/1.1 200 Connection established"
186
187static gboolean http_canread(gpointer data, gint source, b_input_condition cond)
188{
189        int nlc = 0;
190        int pos = 0;
191        struct PHB *phb = data;
192        char inputline[8192];
193
194        b_event_remove(phb->inpa);
195
196        while ((pos < sizeof(inputline)-1) && (nlc != 2) && (read(source, &inputline[pos++], 1) == 1)) {
197                if (inputline[pos - 1] == '\n')
198                        nlc++;
199                else if (inputline[pos - 1] != '\r')
200                        nlc = 0;
201        }
202        inputline[pos] = '\0';
203
204        if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) ||
205            (memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) {
206                phb->func(phb->data, source, B_EV_IO_READ);
207                g_free(phb->host);
208                g_free(phb);
209                return FALSE;
210        }
211
212        close(source);
213        phb->func(phb->data, -1, B_EV_IO_READ);
214        g_free(phb->host);
215        g_free(phb);
216       
217        return FALSE;
218}
219
220static gboolean http_canwrite(gpointer data, gint source, b_input_condition cond)
221{
222        char cmd[384];
223        struct PHB *phb = data;
224        unsigned int len;
225        int error = ETIMEDOUT;
226        if (phb->inpa > 0)
227                b_event_remove(phb->inpa);
228        len = sizeof(error);
229        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
230                close(source);
231                phb->func(phb->data, -1, B_EV_IO_READ);
232                g_free(phb->host);
233                g_free(phb);
234                return FALSE;
235        }
236        sock_make_blocking(source);
237
238        g_snprintf(cmd, sizeof(cmd), "CONNECT %s:%d HTTP/1.1\r\nHost: %s:%d\r\n", phb->host, phb->port,
239                   phb->host, phb->port);
240        if (send(source, cmd, strlen(cmd), 0) < 0) {
241                close(source);
242                phb->func(phb->data, -1, B_EV_IO_READ);
243                g_free(phb->host);
244                g_free(phb);
245                return FALSE;
246        }
247
248        if (strlen(proxyuser) > 0) {
249                char *t1, *t2;
250                t1 = g_strdup_printf("%s:%s", proxyuser, proxypass);
251                t2 = tobase64(t1);
252                g_free(t1);
253                g_snprintf(cmd, sizeof(cmd), "Proxy-Authorization: Basic %s\r\n", t2);
254                g_free(t2);
255                if (send(source, cmd, strlen(cmd), 0) < 0) {
256                        close(source);
257                        phb->func(phb->data, -1, B_EV_IO_READ);
258                        g_free(phb->host);
259                        g_free(phb);
260                        return FALSE;
261                }
262        }
263
264        g_snprintf(cmd, sizeof(cmd), "\r\n");
265        if (send(source, cmd, strlen(cmd), 0) < 0) {
266                close(source);
267                phb->func(phb->data, -1, B_EV_IO_READ);
268                g_free(phb->host);
269                g_free(phb);
270                return FALSE;
271        }
272
273        phb->inpa = b_input_add(source, B_EV_IO_READ, http_canread, phb);
274       
275        return FALSE;
276}
277
278static int proxy_connect_http(const char *host, unsigned short port, struct PHB *phb)
279{
280        phb->host = g_strdup(host);
281        phb->port = port;
282        phb->proxy_func = http_canwrite;
283        phb->proxy_data = phb;
284       
285        return( proxy_connect_none( proxyhost, proxyport, phb ) );
286}
287
288
289/* Connecting to SOCKS4 proxies */
290
291static gboolean s4_canread(gpointer data, gint source, b_input_condition cond)
292{
293        unsigned char packet[12];
294        struct PHB *phb = data;
295
296        b_event_remove(phb->inpa);
297
298        memset(packet, 0, sizeof(packet));
299        if (read(source, packet, 9) >= 4 && packet[1] == 90) {
300                phb->func(phb->data, source, B_EV_IO_READ);
301                g_free(phb->host);
302                g_free(phb);
303                return FALSE;
304        }
305
306        close(source);
307        phb->func(phb->data, -1, B_EV_IO_READ);
308        g_free(phb->host);
309        g_free(phb);
310       
311        return FALSE;
312}
313
314static gboolean s4_canwrite(gpointer data, gint source, b_input_condition cond)
315{
316        unsigned char packet[12];
317        struct hostent *hp;
318        struct PHB *phb = data;
319        unsigned int len;
320        int error = ETIMEDOUT;
321        if (phb->inpa > 0)
322                b_event_remove(phb->inpa);
323        len = sizeof(error);
324        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
325                close(source);
326                phb->func(phb->data, -1, B_EV_IO_READ);
327                g_free(phb->host);
328                g_free(phb);
329                return FALSE;
330        }
331        sock_make_blocking(source);
332
333        /* XXX does socks4 not support host name lookups by the proxy? */
334        if (!(hp = gethostbyname(phb->host))) {
335                close(source);
336                phb->func(phb->data, -1, B_EV_IO_READ);
337                g_free(phb->host);
338                g_free(phb);
339                return FALSE;
340        }
341
342        packet[0] = 4;
343        packet[1] = 1;
344        packet[2] = phb->port >> 8;
345        packet[3] = phb->port & 0xff;
346        packet[4] = (unsigned char)(hp->h_addr_list[0])[0];
347        packet[5] = (unsigned char)(hp->h_addr_list[0])[1];
348        packet[6] = (unsigned char)(hp->h_addr_list[0])[2];
349        packet[7] = (unsigned char)(hp->h_addr_list[0])[3];
350        packet[8] = 0;
351        if (write(source, packet, 9) != 9) {
352                close(source);
353                phb->func(phb->data, -1, B_EV_IO_READ);
354                g_free(phb->host);
355                g_free(phb);
356                return FALSE;
357        }
358
359        phb->inpa = b_input_add(source, B_EV_IO_READ, s4_canread, phb);
360       
361        return FALSE;
362}
363
364static int proxy_connect_socks4(const char *host, unsigned short port, struct PHB *phb)
365{
366        phb->host = g_strdup(host);
367        phb->port = port;
368        phb->proxy_func = s4_canwrite;
369        phb->proxy_data = phb;
370       
371        return( proxy_connect_none( proxyhost, proxyport, phb ) );
372}
373
374
375/* Connecting to SOCKS5 proxies */
376
377static gboolean s5_canread_again(gpointer data, gint source, b_input_condition cond)
378{
379        unsigned char buf[512];
380        struct PHB *phb = data;
381
382        b_event_remove(phb->inpa);
383
384        if (read(source, buf, 10) < 10) {
385                close(source);
386                phb->func(phb->data, -1, B_EV_IO_READ);
387                g_free(phb->host);
388                g_free(phb);
389                return FALSE;
390        }
391        if ((buf[0] != 0x05) || (buf[1] != 0x00)) {
392                close(source);
393                phb->func(phb->data, -1, B_EV_IO_READ);
394                g_free(phb->host);
395                g_free(phb);
396                return FALSE;
397        }
398
399        phb->func(phb->data, source, B_EV_IO_READ);
400        g_free(phb->host);
401        g_free(phb);
402       
403        return FALSE;
404}
405
406static void s5_sendconnect(gpointer data, gint source)
407{
408        unsigned char buf[512];
409        struct PHB *phb = data;
410        int hlen = strlen(phb->host);
411       
412        buf[0] = 0x05;
413        buf[1] = 0x01;          /* CONNECT */
414        buf[2] = 0x00;          /* reserved */
415        buf[3] = 0x03;          /* address type -- host name */
416        buf[4] = hlen;
417        memcpy(buf + 5, phb->host, hlen);
418        buf[5 + strlen(phb->host)] = phb->port >> 8;
419        buf[5 + strlen(phb->host) + 1] = phb->port & 0xff;
420
421        if (write(source, buf, (5 + strlen(phb->host) + 2)) < (5 + strlen(phb->host) + 2)) {
422                close(source);
423                phb->func(phb->data, -1, B_EV_IO_READ);
424                g_free(phb->host);
425                g_free(phb);
426                return;
427        }
428
429        phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread_again, phb);
430}
431
432static gboolean s5_readauth(gpointer data, gint source, b_input_condition cond)
433{
434        unsigned char buf[512];
435        struct PHB *phb = data;
436
437        b_event_remove(phb->inpa);
438
439        if (read(source, buf, 2) < 2) {
440                close(source);
441                phb->func(phb->data, -1, B_EV_IO_READ);
442                g_free(phb->host);
443                g_free(phb);
444                return FALSE;
445        }
446
447        if ((buf[0] != 0x01) || (buf[1] != 0x00)) {
448                close(source);
449                phb->func(phb->data, -1, B_EV_IO_READ);
450                g_free(phb->host);
451                g_free(phb);
452                return FALSE;
453        }
454
455        s5_sendconnect(phb, source);
456       
457        return FALSE;
458}
459
460static gboolean s5_canread(gpointer data, gint source, b_input_condition cond)
461{
462        unsigned char buf[512];
463        struct PHB *phb = data;
464
465        b_event_remove(phb->inpa);
466
467        if (read(source, buf, 2) < 2) {
468                close(source);
469                phb->func(phb->data, -1, B_EV_IO_READ);
470                g_free(phb->host);
471                g_free(phb);
472                return FALSE;
473        }
474
475        if ((buf[0] != 0x05) || (buf[1] == 0xff)) {
476                close(source);
477                phb->func(phb->data, -1, B_EV_IO_READ);
478                g_free(phb->host);
479                g_free(phb);
480                return FALSE;
481        }
482
483        if (buf[1] == 0x02) {
484                unsigned int i = strlen(proxyuser), j = strlen(proxypass);
485                buf[0] = 0x01;  /* version 1 */
486                buf[1] = i;
487                memcpy(buf + 2, proxyuser, i);
488                buf[2 + i] = j;
489                memcpy(buf + 2 + i + 1, proxypass, j);
490                if (write(source, buf, 3 + i + j) < 3 + i + j) {
491                        close(source);
492                        phb->func(phb->data, -1, B_EV_IO_READ);
493                        g_free(phb->host);
494                        g_free(phb);
495                        return FALSE;
496                }
497
498                phb->inpa = b_input_add(source, B_EV_IO_READ, s5_readauth, phb);
499        } else {
500                s5_sendconnect(phb, source);
501        }
502       
503        return FALSE;
504}
505
506static gboolean s5_canwrite(gpointer data, gint source, b_input_condition cond)
507{
508        unsigned char buf[512];
509        int i;
510        struct PHB *phb = data;
511        unsigned int len;
512        int error = ETIMEDOUT;
513        if (phb->inpa > 0)
514                b_event_remove(phb->inpa);
515        len = sizeof(error);
516        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
517                close(source);
518                phb->func(phb->data, -1, B_EV_IO_READ);
519                g_free(phb->host);
520                g_free(phb);
521                return FALSE;
522        }
523        sock_make_blocking(source);
524
525        i = 0;
526        buf[0] = 0x05;          /* SOCKS version 5 */
527        if (proxyuser[0]) {
528                buf[1] = 0x02;  /* two methods */
529                buf[2] = 0x00;  /* no authentication */
530                buf[3] = 0x02;  /* username/password authentication */
531                i = 4;
532        } else {
533                buf[1] = 0x01;
534                buf[2] = 0x00;
535                i = 3;
536        }
537
538        if (write(source, buf, i) < i) {
539                close(source);
540                phb->func(phb->data, -1, B_EV_IO_READ);
541                g_free(phb->host);
542                g_free(phb);
543                return FALSE;
544        }
545
546        phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread, phb);
547       
548        return FALSE;
549}
550
551static int proxy_connect_socks5(const char *host, unsigned short port, struct PHB *phb)
552{
553        phb->host = g_strdup(host);
554        phb->port = port;
555        phb->proxy_func = s5_canwrite;
556        phb->proxy_data = phb;
557       
558        return( proxy_connect_none( proxyhost, proxyport, phb ) );
559}
560
561
562/* Export functions */
563
564int proxy_connect(const char *host, int port, b_event_handler func, gpointer data)
565{
566        struct PHB *phb;
567       
568        if (!host || port <= 0 || !func || strlen(host) > 128) {
569                return -1;
570        }
571       
572        phb = g_new0(struct PHB, 1);
573        phb->func = func;
574        phb->data = data;
575       
576        if (proxytype == PROXY_NONE || !proxyhost[0] || proxyport <= 0)
577                return proxy_connect_none(host, port, phb);
578        else if (proxytype == PROXY_HTTP)
579                return proxy_connect_http(host, port, phb);
580        else if (proxytype == PROXY_SOCKS4)
581                return proxy_connect_socks4(host, port, phb);
582        else if (proxytype == PROXY_SOCKS5)
583                return proxy_connect_socks5(host, port, phb);
584       
585        g_free(phb);
586        return -1;
587}
Note: See TracBrowser for help on using the repository browser.