added SSL support for POP using OpenSSL
[claws.git] / src / socket.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2001 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
39 #if USE_THREADS
40 #  include <pthread.h>
41 #endif
42
43 #include "socket.h"
44
45 #if USE_GIO
46 #error USE_GIO is currently not supported
47 #endif
48
49 #define BUFFSIZE        8192
50
51 #ifndef INET6
52 static gint sock_connect_by_hostname    (gint            sock,
53                                          const gchar    *hostname,
54                                          gushort         port);
55 #else
56 static gint sock_connect_by_getaddrinfo (const gchar    *hostname,
57                                          gushort         port);
58 #endif
59
60
61 gint fd_connect_unix(const gchar *path)
62 {
63         gint sock;
64         struct sockaddr_un addr;
65
66         sock = socket(PF_UNIX, SOCK_STREAM, 0);
67         if (sock < 0) {
68                 perror("sock_connect_unix(): socket");
69                 return -1;
70         }
71
72         memset(&addr, 0, sizeof(addr));
73         addr.sun_family = AF_UNIX;
74         strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
75
76         if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
77                 close(sock);
78                 return -1;
79         }
80
81         return sock;
82 }
83
84 gint fd_open_unix(const gchar *path)
85 {
86         gint sock;
87         struct sockaddr_un addr;
88
89         sock = socket(PF_UNIX, SOCK_STREAM, 0);
90
91         if (sock < 0) {
92                 perror("sock_open_unix(): socket");
93                 return -1;
94         }
95
96         memset(&addr, 0, sizeof(addr));
97         addr.sun_family = AF_UNIX;
98         strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
99
100         if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
101                 perror("bind");
102                 close(sock);
103                 return -1;
104         }
105
106         if (listen(sock, 1) < 0) {
107                 perror("listen");
108                 close(sock);
109                 return -1;              
110         }
111
112         return sock;
113 }
114
115 gint fd_accept(gint sock)
116 {
117         struct sockaddr_in caddr;
118         gint caddr_len;
119
120         caddr_len = sizeof(caddr);
121         return accept(sock, (struct sockaddr *)&caddr, &caddr_len);
122 }
123
124
125 static gint set_nonblocking_mode(gint fd, gboolean nonblock)
126 {
127         gint flags;
128
129         flags = fcntl(fd, F_GETFL, 0);
130         if (flags < 0) {
131                 perror("fcntl");
132                 return -1;
133         }
134
135         if (nonblock)
136                 flags |= O_NONBLOCK;
137         else
138                 flags &= ~O_NONBLOCK;
139
140         return fcntl(fd, F_SETFL, flags);
141 }
142
143 gint sock_set_nonblocking_mode(SockInfo *sock, gboolean nonblock)
144 {
145         g_return_val_if_fail(sock != NULL, -1);
146
147         return set_nonblocking_mode(sock->sock, nonblock);
148 }
149
150
151 static gboolean is_nonblocking_mode(gint fd)
152 {
153         gint flags;
154
155         flags = fcntl(fd, F_GETFL, 0);
156         if (flags < 0) {
157                 perror("fcntl");
158                 return FALSE;
159         }
160
161         return ((flags & O_NONBLOCK) != 0);
162 }
163
164 gboolean sock_is_nonblocking_mode(SockInfo *sock)
165 {
166         g_return_val_if_fail(sock != NULL, FALSE);
167
168         return is_nonblocking_mode(sock->sock);
169 }
170
171
172 #ifndef INET6
173 static gint sock_connect_by_hostname(gint sock, const gchar *hostname,
174                                      gushort port)
175 {
176         struct hostent *hp;
177         struct sockaddr_in ad;
178 #ifndef HAVE_INET_ATON
179 #if HAVE_INET_ADDR
180         guint32 inaddr;
181 #endif
182 #endif /* HAVE_INET_ATON */
183
184         memset(&ad, 0, sizeof(ad));
185         ad.sin_family = AF_INET;
186         ad.sin_port = htons(port);
187
188 #if HAVE_INET_ATON
189         if (!inet_aton(hostname, &ad.sin_addr)) {
190 #else
191 #if HAVE_INET_ADDR
192         inaddr = inet_addr(hostname);
193         if (inaddr != -1)
194                 memcpy(&ad.sin_addr, &inaddr, sizeof(inaddr));
195         else {
196 #else
197         {
198 #endif
199 #endif /* HAVE_INET_ATON */
200                 if ((hp = gethostbyname(hostname)) == NULL) {
201                         fprintf(stderr, "%s: unknown host.\n", hostname);
202                         errno = 0;
203                         return -1;
204                 }
205
206                 if (hp->h_length != 4 && hp->h_length != 8) {
207                         h_errno = errno = 0;
208                         fprintf(stderr, "illegal address length received for host %s\n", hostname);
209                         return -1;
210                 }
211
212                 memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);
213         }
214
215         return connect(sock, (struct sockaddr *)&ad, sizeof(ad));
216 }
217
218 #else /* INET6 */
219 static gint sock_connect_by_getaddrinfo(const gchar *hostname, gushort  port)
220 {
221         gint sock = -1, gai_error;
222         struct addrinfo hints, *res, *ai;
223         gchar port_str[6];
224
225         memset(&hints, 0, sizeof(hints));
226         /* hints.ai_flags = AI_CANONNAME; */
227         hints.ai_family = AF_UNSPEC;
228         hints.ai_socktype = SOCK_STREAM;
229         hints.ai_protocol = IPPROTO_TCP;
230
231         /* convert port from integer to string. */
232         g_snprintf(port_str, sizeof(port_str), "%d", port);
233
234         if ((gai_error = getaddrinfo(hostname, port_str, &hints, &res)) != 0) {
235                 fprintf(stderr, "getaddrinfo for %s:%s failed: %s\n",
236                         hostname, port_str, gai_strerror(gai_error));
237                 return -1;
238         }
239
240         for (ai = res; ai != NULL; ai = ai->ai_next) {
241                 sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
242                 if (sock < 0)
243                         continue;
244
245                 if (connect(sock, ai->ai_addr, ai->ai_addrlen) == 0)
246                         break;
247
248                 close(sock);
249         }
250
251         if (res != NULL)
252                 freeaddrinfo(res);
253
254         if (ai == NULL)
255                 return -1;
256
257         return sock;
258 }
259 #endif /* !INET6 */
260
261 #if 0
262 SockInfo *sock_connect_nb(const gchar *hostname, gushort port)
263 {
264         gint sock;
265         gint ret;
266         SockInfo *sockinfo;
267
268 #ifdef INET6
269         if ((sock = sock_connect_by_getaddrinfo(hostname, port)) < 0)
270                 return NULL;
271         if (set_nonblocking_mode(sock, TRUE) < 0) return NULL;
272         ret = sock;
273 #else
274         if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
275                 perror("socket");
276                 return NULL;
277         }
278
279         if (set_nonblocking_mode(sock, TRUE) < 0) return NULL;
280
281         ret = sock_connect_by_hostname(sock, hostname, port);
282
283         if (ret < 0 && errno != EINPROGRESS) {
284                 if (errno != 0) perror("connect");
285                 close(sock);
286                 return NULL;
287         }
288 #endif /* INET6 */
289
290         sockinfo = g_new0(SockInfo, 1);
291         sockinfo->sock = sock;
292         sockinfo->hostname = g_strdup(hostname);
293         sockinfo->port = port;
294         sockinfo->state = CONN_LOOKUPSUCCESS;
295
296         if (ret < 0 && errno == EINPROGRESS) return sockinfo;
297
298         sockinfo->state = CONN_ESTABLISHED;
299         return sockinfo;
300 }
301 #endif
302
303 SockInfo *sock_connect(const gchar *hostname, gushort port)
304 {
305         gint sock;
306         SockInfo *sockinfo;
307
308 #ifdef INET6
309         if ((sock = sock_connect_by_getaddrinfo(hostname, port)) < 0)
310                 return NULL;
311 #else
312         if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
313                 perror("socket");
314                 return NULL;
315         }
316
317         if (sock_connect_by_hostname(sock, hostname, port) < 0) {
318                 if (errno != 0) perror("connect");
319                 close(sock);
320                 return NULL;
321         }
322 #endif /* INET6 */
323
324         sockinfo = g_new0(SockInfo, 1);
325         sockinfo->sock = sock;
326         sockinfo->hostname = g_strdup(hostname);
327         sockinfo->port = port;
328         sockinfo->state = CONN_ESTABLISHED;
329
330         usleep(100000);
331
332         return sockinfo;
333 }
334
335 #if USE_THREADS
336 static void sock_connect_thread(SockInfo *sockinfo)
337 {
338 #ifdef INET6
339         if ((sockinfo->sock = sock_connect_by_getaddrinfo
340                 (sockinfo->hostname, sockinfo->port)) < 0)
341                 pthread_exit((void *)1);
342 #else
343         if (sock_connect_by_hostname(sockinfo->sock, sockinfo->hostname,
344                                      sockinfo->port) < 0) {
345                 if (errno != 0) perror("connect");
346                 sockinfo->state = CONN_FAILED;
347                 pthread_exit((void *)1);
348         }
349 #endif /* INET6 */
350         sockinfo->state = CONN_ESTABLISHED;
351
352         pthread_exit(0);
353 }
354
355 SockInfo *sock_connect_with_thread(const gchar *hostname, gushort port)
356 {
357         gint sock = 0;
358         SockInfo *sockinfo;
359
360 #ifndef INET6
361         if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
362                 perror("socket");
363                 return NULL;
364         }
365 #endif /* !INET6 */
366
367         sockinfo = g_new0(SockInfo, 1);
368         sockinfo->sock = sock;
369         sockinfo->hostname = g_strdup(hostname);
370         sockinfo->port = port;
371         sockinfo->state = CONN_READY;
372
373         pthread_create(&sockinfo->connect_thr, NULL,
374                        (void *)sock_connect_thread,
375                        sockinfo);
376         pthread_mutex_init(&sockinfo->mutex, NULL);
377         pthread_detach(sockinfo->connect_thr);
378
379         return sockinfo;
380 }
381 #endif
382
383
384 gint sock_printf(SockInfo *sock, const gchar *format, ...)
385 {
386         va_list args;
387         gchar buf[BUFFSIZE];
388
389         va_start(args, format);
390         g_vsnprintf(buf, sizeof(buf), format, args);
391         va_end(args);
392
393         return sock_write(sock, buf, strlen(buf));
394 }
395
396 gint sock_read(SockInfo *sock, gchar *buf, gint len)
397 {
398         g_return_val_if_fail(sock != NULL, -1);
399
400 #if USE_SSL
401         if(sock->ssl) {
402                 return ssl_read(sock->ssl, buf, len);
403         }
404 #endif
405         return fd_read(sock->sock, buf, len);
406 }
407
408 gint fd_read(gint fd, gchar *buf, gint len)
409 {
410         return read(fd, buf, len);
411 }
412
413 #ifdef USE_SSL
414 gint ssl_read(SSL *ssl, gchar *buf, gint len)
415 {
416         return SSL_read(ssl, buf, len);
417 }
418 #endif
419
420 gint sock_write(SockInfo *sock, const gchar *buf, gint len)
421 {
422         g_return_val_if_fail(sock != NULL, -1);
423
424 #if USE_SSL
425         if(sock->ssl) {
426                 return ssl_write(sock->ssl, buf, len);
427         }
428 #endif
429         return fd_write(sock->sock, buf, len);
430 }
431
432 gint fd_write(gint fd, const gchar *buf, gint len)
433 {
434         gint n, wrlen = 0;
435
436         while (len) {
437                 n = write(fd, buf, len);
438                 if (n <= 0)
439                         return -1;
440                 len -= n;
441                 wrlen += n;
442                 buf += n;
443         }
444
445         return wrlen;
446 }
447
448 #ifdef USE_SSL
449 gint ssl_write(SSL *ssl, const gchar *buf, gint len)
450 {
451         gint n, wrlen = 0;
452
453         while (len) {
454                 n = SSL_write(ssl, buf, len);
455                 if (n <= 0)
456                         return -1;
457                 len -= n;
458                 wrlen += n;
459                 buf += n;
460         }
461
462         return wrlen;
463 }
464 #endif
465
466 gint fd_gets(gint fd, gchar *buf, gint len)
467 {
468         gchar *newline, *bp = buf;
469         gint n;
470
471         if (--len < 1)
472                 return -1;
473         do {
474                 if ((n = recv(fd, bp, len, MSG_PEEK)) <= 0)
475                         return -1;
476                 if ((newline = memchr(bp, '\n', n)) != NULL)
477                         n = newline - bp + 1;
478                 if ((n = read(fd, bp, n)) < 0)
479                         return -1;
480                 bp += n;
481                 len -= n;
482         } while (!newline && len);
483
484         *bp = '\0';
485         return bp - buf;
486 }
487
488 #if USE_SSL
489 gint ssl_gets(SSL *ssl, gchar *buf, gint len)
490 {
491         gchar *buf2 = buf;
492         gboolean newline = FALSE;
493         gint n, count = 0;
494
495         if (--len < 1)
496                 return -1;
497         while(len > 0 && !newline) {
498                 *buf2 = '\0';
499                 if((n = SSL_read(ssl, buf2, 1)) < 0)
500                         return -1;
501                 if(*buf2 == '\n')
502                         newline = TRUE;
503                 buf2 += n;
504                 count += n;
505         }
506
507         *buf2 = '\0';
508         return n;
509 }
510 #endif
511
512 gint sock_gets(SockInfo *sock, gchar *buf, gint len)
513 {
514         g_return_val_if_fail(sock != NULL, -1);
515
516 #if USE_SSL
517         if(sock->ssl) {
518                 return ssl_gets(sock->ssl, buf, len);
519         }
520 #endif
521         return fd_gets(sock->sock, buf, len);
522 }
523
524 gchar *fd_getline(gint fd)
525 {
526         gchar buf[BUFFSIZE];
527         gchar *str = NULL;
528         gint len;
529         gulong size = 1;
530
531         while ((len = fd_gets(fd, buf, sizeof(buf))) > 0) {
532                 size += len;
533                 if (!str)
534                         str = g_strdup(buf);
535                 else {
536                         str = g_realloc(str, size);
537                         strcat(str, buf);
538                 }
539                 if (buf[len - 1] == '\n')
540                         break;
541         }
542
543         return str;
544 }
545
546 #if USE_SSL
547 gchar *ssl_getline(SSL *ssl)
548 {
549         gchar buf[BUFFSIZE];
550         gchar *str = NULL;
551         gint len;
552         gulong size = 1;
553
554         while ((len = ssl_gets(ssl, buf, sizeof(buf))) > 0) {
555                 size += len;
556                 if (!str)
557                         str = g_strdup(buf);
558                 else {
559                         str = g_realloc(str, size);
560                         strcat(str, buf);
561                 }
562                 if (buf[len - 1] == '\n')
563                         break;
564         }
565
566         return str;
567 }
568 #endif
569
570 gchar *sock_getline(SockInfo *sock)
571 {
572         g_return_val_if_fail(sock != NULL, NULL);
573
574 #if USE_SSL
575         if(sock->ssl) {
576                 return ssl_getline(sock->ssl);
577         }
578 #endif
579         return fd_getline(sock->sock);
580 }
581
582 gint sock_puts(SockInfo *sock, const gchar *buf)
583 {
584         gint ret;
585
586         if ((ret = sock_write(sock, buf, strlen(buf))) < 0)
587                 return ret;
588         return sock_write(sock, "\r\n", 2);
589 }
590
591 /* peek at the next socket character without actually reading it */
592 gint sock_peek(SockInfo *sock)
593 {
594         gint n;
595         gchar ch;
596
597         g_return_val_if_fail(sock != NULL, -1);
598
599         if ((n = recv(sock->sock, &ch, 1, MSG_PEEK)) < 0)
600                 return -1;
601         else
602                 return ch;
603 }
604
605 gint sock_close(SockInfo *sock)
606 {
607         gint ret;
608
609         if (!sock)
610                 return 0;
611
612         ret = fd_close(sock->sock); 
613         g_free(sock->hostname);
614         g_free(sock);
615
616         return ret;
617 }
618
619 gint fd_close(gint fd)
620 {
621         return close(fd);
622 }
623
624 gint sock_gdk_input_add(SockInfo *sock,
625                         GdkInputCondition condition,
626                         GdkInputFunction function,
627                         gpointer data)
628 {
629         g_return_val_if_fail(sock != NULL, -1);
630
631         /* :WK: We have to change some things here becuse most likey
632            function() does take SockInfo * and not an gint */
633         return gdk_input_add(sock->sock, condition, function, data);
634 }