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 count;
 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 }