0.8.6claws75
[claws.git] / src / common / socket.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto
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 2 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, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include <glib.h>
25 #include <sys/time.h>
26 #include <sys/types.h>
27 #include <sys/socket.h>
28 #include <sys/un.h>
29 #include <netinet/in.h>
30 #include <arpa/inet.h>
31 #include <netdb.h>
32 #include <unistd.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <stdarg.h>
36 #include <fcntl.h>
37 #include <errno.h>
38 #include <signal.h>
39 #include <setjmp.h>
40 #if HAVE_SYS_SELECT_H
41 #  include <sys/select.h>
42 #endif
43
44 #include "socket.h"
45 #include "utils.h"
46 #include "log.h"
47 #if USE_SSL
48 #  include "ssl.h"
49 #endif
50
51 #if USE_GIO
52 #error USE_GIO is currently not supported
53 #endif
54
55 #define BUFFSIZE        8192
56 #define IO_TIMEOUT      60
57
58 static gint sock_connect_with_timeout   (gint                    sock,
59                                          const struct sockaddr  *serv_addr,
60                                          gint                    addrlen,
61                                          guint                   timeout_secs);
62
63 #ifndef INET6
64 static gint sock_connect_by_hostname    (gint            sock,
65                                          const gchar    *hostname,
66                                          gushort         port);
67 #else
68 static gint sock_connect_by_getaddrinfo (const gchar    *hostname,
69                                          gushort         port);
70 #endif
71
72 static SockInfo *sockinfo_from_fd(const gchar *hostname,
73                                   gushort port,
74                                   gint sock);
75
76 gint fd_connect_unix(const gchar *path)
77 {
78         gint sock;
79         struct sockaddr_un addr;
80
81         sock = socket(PF_UNIX, SOCK_STREAM, 0);
82         if (sock < 0) {
83                 perror("sock_connect_unix(): socket");
84                 return -1;
85         }
86
87         memset(&addr, 0, sizeof(addr));
88         addr.sun_family = AF_UNIX;
89         strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
90
91         if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
92                 close(sock);
93                 return -1;
94         }
95
96         return sock;
97 }
98
99 gint fd_open_unix(const gchar *path)
100 {
101         gint sock;
102         struct sockaddr_un addr;
103
104         sock = socket(PF_UNIX, SOCK_STREAM, 0);
105
106         if (sock < 0) {
107                 perror("sock_open_unix(): socket");
108                 return -1;
109         }
110
111         memset(&addr, 0, sizeof(addr));
112         addr.sun_family = AF_UNIX;
113         strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
114
115         if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
116                 perror("bind");
117                 close(sock);
118                 return -1;
119         }
120
121         if (listen(sock, 1) < 0) {
122                 perror("listen");
123                 close(sock);
124                 return -1;              
125         }
126
127         return sock;
128 }
129
130 gint fd_accept(gint sock)
131 {
132         struct sockaddr_in caddr;
133         gint caddr_len;
134
135         caddr_len = sizeof(caddr);
136         return accept(sock, (struct sockaddr *)&caddr, &caddr_len);
137 }
138
139
140 static gint set_nonblocking_mode(gint fd, gboolean nonblock)
141 {
142         gint flags;
143
144         flags = fcntl(fd, F_GETFL, 0);
145         if (flags < 0) {
146                 perror("fcntl");
147                 return -1;
148         }
149
150         if (nonblock)
151                 flags |= O_NONBLOCK;
152         else
153                 flags &= ~O_NONBLOCK;
154
155         return fcntl(fd, F_SETFL, flags);
156 }
157
158 gint sock_set_nonblocking_mode(SockInfo *sock, gboolean nonblock)
159 {
160         g_return_val_if_fail(sock != NULL, -1);
161
162         return set_nonblocking_mode(sock->sock, nonblock);
163 }
164
165
166 static gboolean is_nonblocking_mode(gint fd)
167 {
168         gint flags;
169
170         flags = fcntl(fd, F_GETFL, 0);
171         if (flags < 0) {
172                 perror("fcntl");
173                 return FALSE;
174         }
175
176         return ((flags & O_NONBLOCK) != 0);
177 }
178
179 gboolean sock_is_nonblocking_mode(SockInfo *sock)
180 {
181         g_return_val_if_fail(sock != NULL, FALSE);
182
183         return is_nonblocking_mode(sock->sock);
184 }
185
186 static gint fd_check_io(gint fd, GIOCondition cond)
187 {
188         struct timeval timeout;
189         fd_set fds;
190
191         timeout.tv_sec  = IO_TIMEOUT;
192         timeout.tv_usec = 0;
193
194         FD_ZERO(&fds);
195         FD_SET(fd, &fds);
196
197         if (cond == G_IO_IN) {
198                 select(fd + 1, &fds, NULL, NULL, &timeout);
199         } else {
200                 select(fd + 1, NULL, &fds, NULL, &timeout);
201         }
202
203         if (FD_ISSET(fd, &fds)) {
204                 return 0;
205         } else {
206                 g_warning("Socket IO timeout\n");
207                 return -1;
208         }
209 }
210
211 static sigjmp_buf jmpenv;
212
213 static void timeout_handler(gint sig)
214 {
215         siglongjmp(jmpenv, 1);
216 }
217
218 static gint sock_connect_with_timeout(gint sock,
219                                       const struct sockaddr *serv_addr,
220                                       gint addrlen,
221                                       guint timeout_secs)
222 {
223         gint ret;
224         void (*prev_handler)(gint);
225
226         alarm(0);
227         prev_handler = signal(SIGALRM, timeout_handler);
228         if (sigsetjmp(jmpenv, 1)) {
229                 alarm(0);
230                 signal(SIGALRM, prev_handler);
231                 errno = ETIMEDOUT;
232                 return -1;
233         }
234         alarm(timeout_secs);
235
236         ret = connect(sock, serv_addr, addrlen);
237
238         alarm(0);
239         signal(SIGALRM, prev_handler);
240
241         return ret;
242 }
243
244 struct hostent *my_gethostbyname(const gchar *hostname)
245 {
246         struct hostent *hp;
247         void (*prev_handler)(gint);
248         guint timeout_secs = IO_TIMEOUT;
249
250         alarm(0);
251         prev_handler = signal(SIGALRM, timeout_handler);
252         if (sigsetjmp(jmpenv, 1)) {
253                 alarm(0);
254                 signal(SIGALRM, prev_handler);
255                 fprintf(stderr, "%s: host lookup timed out.\n", hostname);
256                 errno = 0;
257                 return NULL;
258         }
259         alarm(timeout_secs);
260
261         if ((hp = gethostbyname(hostname)) == NULL) {
262                 alarm(0);
263                 signal(SIGALRM, prev_handler);
264                 fprintf(stderr, "%s: unknown host.\n", hostname);
265                 errno = 0;
266                 return NULL;
267         }
268
269         alarm(0);
270         signal(SIGALRM, prev_handler);
271
272         return hp;
273 }
274
275 #ifndef INET6
276 static gint my_inet_aton(const gchar *hostname, struct in_addr *inp)
277 {
278 #if HAVE_INET_ATON
279         return inet_aton(hostname, inp);
280 #else
281 #if HAVE_INET_ADDR
282         guint32 inaddr;
283
284         inaddr = inet_addr(hostname);
285         if (inaddr != -1) {
286                 memcpy(inp, &inaddr, sizeof(inaddr));
287                 return 1;
288         } else
289                 return 0;
290 #else
291         return 0;
292 #endif
293 #endif /* HAVE_INET_ATON */
294 }
295
296 static gint sock_connect_by_hostname(gint sock, const gchar *hostname,
297                                      gushort port)
298 {
299         struct hostent *hp;
300         struct sockaddr_in ad;
301         guint timeout_secs = IO_TIMEOUT;
302
303         memset(&ad, 0, sizeof(ad));
304         ad.sin_family = AF_INET;
305         ad.sin_port = htons(port);
306
307         if (!my_inet_aton(hostname, &ad.sin_addr)) {
308                 if ((hp = my_gethostbyname(hostname)) == NULL) {
309                         fprintf(stderr, "%s: unknown host.\n", hostname);
310                         errno = 0;
311                         return -1;
312                 }
313
314                 if (hp->h_length != 4 && hp->h_length != 8) {
315                         fprintf(stderr, "illegal address length received for host %s\n", hostname);
316                         errno = 0;
317                         return -1;
318                 }
319
320                 memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);
321         }
322
323         return sock_connect_with_timeout(sock, (struct sockaddr *)&ad,
324                                          sizeof(ad), timeout_secs);
325 }
326
327 #else /* INET6 */
328 static gint sock_connect_by_getaddrinfo(const gchar *hostname, gushort  port)
329 {
330         gint sock = -1, gai_error;
331         struct addrinfo hints, *res, *ai;
332         guint timeout_secs = IO_TIMEOUT;
333         gchar port_str[6];
334
335         memset(&hints, 0, sizeof(hints));
336         /* hints.ai_flags = AI_CANONNAME; */
337         hints.ai_family = AF_UNSPEC;
338         hints.ai_socktype = SOCK_STREAM;
339         hints.ai_protocol = IPPROTO_TCP;
340
341         /* convert port from integer to string. */
342         g_snprintf(port_str, sizeof(port_str), "%d", port);
343
344         if ((gai_error = getaddrinfo(hostname, port_str, &hints, &res)) != 0) {
345                 fprintf(stderr, "getaddrinfo for %s:%s failed: %s\n",
346                         hostname, port_str, gai_strerror(gai_error));
347                 return -1;
348         }
349
350         for (ai = res; ai != NULL; ai = ai->ai_next) {
351                 sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
352                 if (sock < 0)
353                         continue;
354
355                 if (sock_connect_with_timeout
356                         (sock, ai->ai_addr, ai->ai_addrlen, timeout_secs) == 0)
357                         break;
358
359                 close(sock);
360         }
361
362         if (res != NULL)
363                 freeaddrinfo(res);
364
365         if (ai == NULL)
366                 return -1;
367
368         return sock;
369 }
370 #endif /* !INET6 */
371
372
373 /* Open a connection using an external program.  May be useful when
374  * you need to tunnel through a SOCKS or other firewall, or to
375  * establish an IMAP-over-SSH connection. */
376 /* TODO: Recreate this for sock_connect_thread() */
377 SockInfo *sock_connect_cmd(const gchar *hostname, const gchar *tunnelcmd)
378 {
379         gint fd[2];
380         int r;
381                      
382         if ((r = socketpair(AF_UNIX, SOCK_STREAM, 0, fd)) == -1) {
383                 perror("socketpair");
384                 return NULL;
385         }
386         log_message("launching tunnel command \"%s\"\n", tunnelcmd);
387         if (fork() == 0) {
388                 close(fd[0]);
389                 close(0);
390                 close(1);
391                 dup(fd[1]);     /* set onto stdin */
392                 dup(fd[1]);
393                 execlp("/bin/sh", "/bin/sh", "-c", tunnelcmd, NULL);
394         }
395
396         close(fd[1]);
397         return sockinfo_from_fd(hostname, 0, fd[0]);
398 }
399
400
401 SockInfo *sock_connect(const gchar *hostname, gushort port)
402 {
403         gint sock;
404
405 #ifdef INET6
406         if ((sock = sock_connect_by_getaddrinfo(hostname, port)) < 0)
407                 return NULL;
408 #else
409         if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
410                 perror("socket");
411                 return NULL;
412         }
413
414         if (sock_connect_by_hostname(sock, hostname, port) < 0) {
415                 if (errno != 0) perror("connect");
416                 close(sock);
417                 return NULL;
418         }
419 #endif /* INET6 */
420
421         return sockinfo_from_fd(hostname, port, sock);
422 }
423
424
425 static SockInfo *sockinfo_from_fd(const gchar *hostname,
426                                   gushort port,
427                                   gint sock)
428 {
429         SockInfo *sockinfo;
430         
431         sockinfo = g_new0(SockInfo, 1);
432         sockinfo->sock = sock;
433         sockinfo->hostname = g_strdup(hostname);
434         sockinfo->port = port;
435         sockinfo->state = CONN_ESTABLISHED;
436
437         usleep(100000);
438
439         return sockinfo;
440 }
441
442 gint sock_printf(SockInfo *sock, const gchar *format, ...)
443 {
444         va_list args;
445         gchar buf[BUFFSIZE];
446
447         va_start(args, format);
448         g_vsnprintf(buf, sizeof(buf), format, args);
449         va_end(args);
450
451         return sock_write(sock, buf, strlen(buf));
452 }
453
454 gint sock_read(SockInfo *sock, gchar *buf, gint len)
455 {
456         g_return_val_if_fail(sock != NULL, -1);
457
458 #if USE_SSL
459         if (sock->ssl)
460                 return ssl_read(sock->ssl, buf, len);
461 #endif
462         return fd_read(sock->sock, buf, len);
463 }
464
465 gint fd_read(gint fd, gchar *buf, gint len)
466 {
467         if (fd_check_io(fd, G_IO_IN) < 0)
468                 return -1;
469
470         return read(fd, buf, len);
471 }
472
473 #if USE_SSL
474 gint ssl_read(SSL *ssl, gchar *buf, gint len)
475 {
476         return SSL_read(ssl, buf, len);
477 }
478 #endif
479
480 gint sock_write(SockInfo *sock, const gchar *buf, gint len)
481 {
482         g_return_val_if_fail(sock != NULL, -1);
483
484 #if USE_SSL
485         if (sock->ssl)
486                 return ssl_write(sock->ssl, buf, len);
487 #endif
488         return fd_write(sock->sock, buf, len);
489 }
490
491 gint fd_write(gint fd, const gchar *buf, gint len)
492 {
493         gint n, wrlen = 0;
494
495         while (len) {
496                 if (fd_check_io(fd, G_IO_OUT) < 0)
497                         return -1;
498                 signal(SIGPIPE, SIG_IGN);
499                 n = write(fd, buf, len);
500                 if (n <= 0) {
501                         log_error("write on fd%d: %s\n", fd, strerror(errno));
502                         return -1;
503                 }
504                 len -= n;
505                 wrlen += n;
506                 buf += n;
507         }
508
509         return wrlen;
510 }
511
512 #if USE_SSL
513 gint ssl_write(SSL *ssl, const gchar *buf, gint len)
514 {
515         gint n, wrlen = 0;
516
517         while (len) {
518                 n = SSL_write(ssl, buf, len);
519                 if (n <= 0)
520                         return -1;
521                 len -= n;
522                 wrlen += n;
523                 buf += n;
524         }
525
526         return wrlen;
527 }
528 #endif
529
530 gint fd_recv(gint fd, gchar *buf, gint len, gint flags)
531 {
532         if (fd_check_io(fd, G_IO_IN) < 0)
533                 return -1;
534
535         return recv(fd, buf, len, flags);
536 }
537
538 gint fd_gets(gint fd, gchar *buf, gint len)
539 {
540         gchar *newline, *bp = buf;
541         gint n;
542
543         if (--len < 1)
544                 return -1;
545         do {
546                 if ((n = fd_recv(fd, bp, len, MSG_PEEK)) <= 0)
547                         return -1;
548                 if ((newline = memchr(bp, '\n', n)) != NULL)
549                         n = newline - bp + 1;
550                 if ((n = fd_read(fd, bp, n)) < 0)
551                         return -1;
552                 bp += n;
553                 len -= n;
554         } while (!newline && len);
555
556         *bp = '\0';
557         return bp - buf;
558 }
559
560 #if USE_SSL
561 gint ssl_gets(SSL *ssl, gchar *buf, gint len)
562 {
563         gchar *newline, *bp = buf;
564         gint n;
565
566         if (--len < 1)
567                 return -1;
568         do {
569                 if ((n = SSL_peek(ssl, bp, len)) <= 0)
570                         return -1;
571                 if ((newline = memchr(bp, '\n', n)) != NULL)
572                         n = newline - bp + 1;
573                 if ((n = SSL_read(ssl, bp, n)) < 0)
574                         return -1;
575                 bp += n;
576                 len -= n;
577         } while (!newline && len);
578
579         *bp = '\0';
580         return bp - buf;
581 }
582 #endif
583
584 gint sock_gets(SockInfo *sock, gchar *buf, gint len)
585 {
586         g_return_val_if_fail(sock != NULL, -1);
587
588 #if USE_SSL
589         if (sock->ssl)
590                 return ssl_gets(sock->ssl, buf, len);
591 #endif
592         return fd_gets(sock->sock, buf, len);
593 }
594
595 gchar *fd_getline(gint fd)
596 {
597         gchar buf[BUFFSIZE];
598         gchar *str = NULL;
599         gint len;
600         gulong size = 1;
601
602         while ((len = fd_gets(fd, buf, sizeof(buf))) > 0) {
603                 size += len;
604                 if (!str)
605                         str = g_strdup(buf);
606                 else {
607                         str = g_realloc(str, size);
608                         strcat(str, buf);
609                 }
610                 if (buf[len - 1] == '\n')
611                         break;
612         }
613         if (len == -1) {
614                 log_error("Read from socket fd%d failed: %s\n",
615                           fd, strerror(errno));
616                 if (str)
617                         g_free(str);
618                 return NULL;
619         }
620
621         return str;
622 }
623
624 #if USE_SSL
625 gchar *ssl_getline(SSL *ssl)
626 {
627         gchar buf[BUFFSIZE];
628         gchar *str = NULL;
629         gint len;
630         gulong size = 1;
631
632         while ((len = ssl_gets(ssl, buf, sizeof(buf))) > 0) {
633                 size += len;
634                 if (!str)
635                         str = g_strdup(buf);
636                 else {
637                         str = g_realloc(str, size);
638                         strcat(str, buf);
639                 }
640                 if (buf[len - 1] == '\n')
641                         break;
642         }
643
644         return str;
645 }
646 #endif
647
648 gchar *sock_getline(SockInfo *sock)
649 {
650         g_return_val_if_fail(sock != NULL, NULL);
651
652 #if USE_SSL
653         if (sock->ssl)
654                 return ssl_getline(sock->ssl);
655 #endif
656         return fd_getline(sock->sock);
657 }
658
659 gint sock_puts(SockInfo *sock, const gchar *buf)
660 {
661         gint ret;
662
663         if ((ret = sock_write(sock, buf, strlen(buf))) < 0)
664                 return ret;
665         return sock_write(sock, "\r\n", 2);
666 }
667
668 /* peek at the next socket character without actually reading it */
669 gint sock_peek(SockInfo *sock)
670 {
671         gint n;
672         gchar ch;
673
674         g_return_val_if_fail(sock != NULL, -1);
675
676 #if USE_SSL
677         if (sock->ssl) {
678                 if ((n = SSL_peek(sock->ssl, &ch, 1)) < 0)
679                         return -1;
680                 else
681                         return ch;
682         }
683 #endif
684         if ((n = recv(sock->sock, &ch, 1, MSG_PEEK)) < 0)
685                 return -1;
686         else
687                 return ch;
688 }
689
690 gint sock_close(SockInfo *sock)
691 {
692         gint ret;
693
694         if (!sock)
695                 return 0;
696
697 #if USE_SSL
698         if (sock->ssl)
699                 ssl_done_socket(sock);
700 #endif
701         ret = fd_close(sock->sock); 
702         g_free(sock->hostname);
703         g_free(sock);
704
705         return ret;
706 }
707
708 gint fd_close(gint fd)
709 {
710         return close(fd);
711 }
712
713 gint sock_input_add(SockInfo *sock,
714                     GIOCondition condition,
715                     GIOFunc function,
716                     gpointer data)
717 {
718         GIOChannel *channel;
719         guint result;
720
721         g_return_val_if_fail(sock != NULL, -1);
722
723         channel = g_io_channel_unix_new(sock->sock);
724         /* :WK: We have to change some things here becuse most likey
725            function() does take SockInfo * and not an gint */
726         result = g_io_add_watch(channel, condition, function, data);
727         g_io_channel_unref(channel);
728
729         return result;
730 }