mutt_socket.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1998 Michael R. Elkins <me@mutt.org>
   4  * Copyright (C) 1999-2005 Brendan Cully <brendan@kublai.com>
   5  * Copyright (C) 1999-2000 Tommi Komulainen <Tommi.Komulainen@iki.fi>
   6  *
   7  * This file is part of mutt-ng, see http://www.muttng.org/.
   8  * It's licensed under the GNU General Public License,
   9  * please see the file GPL in the top level source directory.
  10  */
  11
  12 #if HAVE_CONFIG_H
  13 # include "config.h"
  14 #endif
  15
  16 #include "mutt.h"
  17 #include "globals.h"
  18 #include "mutt_socket.h"
  19 #include "mutt_tunnel.h"
  20 #if defined(USE_SSL) || defined(USE_GNUTLS) || defined(USE_NSS)
  21 # include "mutt_ssl.h"
  22 #endif
  23
  24 #include "mutt_idna.h"
  25
  26 #include "lib/mem.h"
  27 #include "lib/intl.h"
  28 #include "lib/str.h"
  29 #include "lib/debug.h"
  30
  31 #include <unistd.h>
  32 #include <netinet/in.h>
  33 #include <netdb.h>
  34 #include <stdlib.h>
  35 #include <fcntl.h>
  36 #include <sys/types.h>
  37 #include <sys/socket.h>
  38 #include <string.h>
  39 #include <errno.h>
  40
  41 /* support for multiple socket connections */
  42 static CONNECTION *Connections = NULL;
  43
  44 /* forward declarations */
  45 static int socket_preconnect (void);
  46 static int socket_connect (int fd, struct sockaddr *sa);
  47 static CONNECTION *socket_new_conn ();
  48
  49 /* Wrappers */
  50 int mutt_socket_open (CONNECTION * conn)
  51 {
  52   if (socket_preconnect ())
  53     return -1;
  54
  55   return conn->conn_open (conn);
  56 }
  57
  58 int mutt_socket_close (CONNECTION * conn)
  59 {
  60   int rc = -1;
  61
  62   if (conn->fd < 0)
  63     debug_print (1, ("Attempt to close closed connection.\n"));
  64   else
  65     rc = conn->conn_close (conn);
  66
  67   conn->fd = -1;
  68   conn->ssf = 0;
  69
  70   return rc;
  71 }
  72
  73 int mutt_socket_read (CONNECTION * conn, char *buf, size_t len)
  74 {
  75   int rc;
  76
  77   if (conn->fd < 0) {
  78     debug_print (1, ("attempt to read from closed connection\n"));
  79     return -1;
  80   }
  81
  82   rc = conn->conn_read (conn, buf, len);
  83   /* EOF */
  84   if (rc == 0) {
  85     mutt_error (_("Connection to %s closed"), conn->account.host);
  86     mutt_sleep (2);
  87   }
  88   if (rc <= 0)
  89     mutt_socket_close (conn);
  90
  91   return rc;
  92 }
  93
  94 int mutt_socket_write_d (CONNECTION * conn, const char *buf, int dbg)
  95 {
  96   int rc;
  97   int len;
  98
  99   debug_print (dbg, ("> %s", buf));
 100
 101   if (conn->fd < 0) {
 102     debug_print (1, ("attempt to write to closed connection\n"));
 103     return -1;
 104   }
 105
 106   len = mutt_strlen (buf);
 107   if ((rc = conn->conn_write (conn, buf, len)) < 0) {
 108     debug_print (1, ("error writing, closing socket\n"));
 109     mutt_socket_close (conn);
 110
 111     return -1;
 112   }
 113
 114   if (rc < len) {
 115     debug_print (1, ("ERROR: wrote %d of %d bytes!\n", rc, len));
 116   }
 117
 118   return rc;
 119 }
 120
 121 /* simple read buffering to speed things up. */
 122 int mutt_socket_readchar (CONNECTION * conn, char *c)
 123 {
 124   if (conn->bufpos >= conn->available) {
 125     if (conn->fd >= 0)
 126       conn->available =
 127         conn->conn_read (conn, conn->inbuf, sizeof (conn->inbuf));
 128     else {
 129       debug_print (1, ("attempt to read from closed connection.\n"));
 130       return -1;
 131     }
 132     conn->bufpos = 0;
 133     if (conn->available == 0) {
 134       mutt_error (_("Connection to %s closed"), conn->account.host);
 135       mutt_sleep (2);
 136     }
 137     if (conn->available <= 0) {
 138       mutt_socket_close (conn);
 139       return -1;
 140     }
 141   }
 142   *c = conn->inbuf[conn->bufpos];
 143   conn->bufpos++;
 144   return 1;
 145 }
 146
 147 int mutt_socket_readln_d (char *buf, size_t buflen, CONNECTION * conn,
 148                           int dbg)
 149 {
 150   char ch;
 151   int i;
 152
 153   for (i = 0; i < buflen - 1; i++) {
 154     if (mutt_socket_readchar (conn, &ch) != 1) {
 155       buf[i] = '\0';
 156       return -1;
 157     }
 158
 159     if (ch == '\n')
 160       break;
 161     buf[i] = ch;
 162   }
 163
 164   /* strip \r from \r\n termination */
 165   if (i && buf[i - 1] == '\r')
 166     buf[--i] = '\0';
 167   else
 168     buf[i] = '\0';
 169
 170   debug_print (dbg, ("< %s\n", buf));
 171
 172   /* number of bytes read, not mutt_strlen */
 173   return i + 1;
 174 }
 175
 176 CONNECTION *mutt_socket_head (void)
 177 {
 178   return Connections;
 179 }
 180
 181 /* mutt_socket_free: remove connection from connection list and free it */
 182 void mutt_socket_free (CONNECTION * conn)
 183 {
 184   CONNECTION *iter;
 185   CONNECTION *tmp;
 186
 187   iter = Connections;
 188
 189   /* head is special case, doesn't need prev updated */
 190   if (iter == conn) {
 191     Connections = iter->next;
 192     FREE (&iter);
 193     return;
 194   }
 195
 196   while (iter->next) {
 197     if (iter->next == conn) {
 198       tmp = iter->next;
 199       iter->next = tmp->next;
 200       FREE (&tmp);
 201       return;
 202     }
 203     iter = iter->next;
 204   }
 205 }
 206
 207 /* mutt_conn_find: find a connection off the list of connections whose
 208  *   account matches account. If start is not null, only search for
 209  *   connections after the given connection (allows higher level socket code
 210  *   to make more fine-grained searches than account info - eg in IMAP we may
 211  *   wish to find a connection which is not in IMAP_SELECTED state) */
 212 CONNECTION *mutt_conn_find (const CONNECTION * start, const ACCOUNT * account)
 213 {
 214   CONNECTION *conn;
 215   ciss_url_t url;
 216   char hook[LONG_STRING];
 217
 218   /* account isn't actually modified, since url isn't either */
 219   mutt_account_tourl ((ACCOUNT *) account, &url);
 220   url.path = NULL;
 221   url_ciss_tostring (&url, hook, sizeof (hook), 0);
 222   mutt_account_hook (hook);
 223
 224   conn = start ? start->next : Connections;
 225   while (conn) {
 226     if (mutt_account_match (account, &(conn->account)))
 227       return conn;
 228     conn = conn->next;
 229   }
 230
 231   conn = socket_new_conn ();
 232   memcpy (&conn->account, account, sizeof (ACCOUNT));
 233
 234   conn->next = Connections;
 235   Connections = conn;
 236
 237   if (Tunnel && *Tunnel)
 238     mutt_tunnel_socket_setup (conn);
 239   else if (account->flags & M_ACCT_SSL) {
 240 #ifdef USE_SSL
 241     ssl_socket_setup (conn);
 242 #elif USE_NSS
 243     mutt_nss_socket_setup (conn);
 244 #elif USE_GNUTLS
 245     if (mutt_gnutls_socket_setup (conn) < 0) {
 246       mutt_socket_free (conn);
 247       return NULL;
 248     }
 249 #else
 250     mutt_error _("SSL is unavailable.");
 251
 252     mutt_sleep (2);
 253     mutt_socket_free (conn);
 254
 255     return NULL;
 256 #endif
 257   }
 258   else {
 259     conn->conn_read = raw_socket_read;
 260     conn->conn_write = raw_socket_write;
 261     conn->conn_open = raw_socket_open;
 262     conn->conn_close = raw_socket_close;
 263   }
 264
 265   return conn;
 266 }
 267
 268 static int socket_preconnect (void)
 269 {
 270   int rc;
 271   int save_errno;
 272
 273   if (mutt_strlen (Preconnect)) {
 274     debug_print (2, ("Executing preconnect: %s\n", Preconnect));
 275     rc = mutt_system (Preconnect);
 276     debug_print (2, ("Preconnect result: %d\n", rc));
 277     if (rc) {
 278       save_errno = errno;
 279       mutt_perror (_("Preconnect command failed."));
 280       mutt_sleep (1);
 281
 282       return save_errno;
 283     }
 284   }
 285
 286   return 0;
 287 }
 288
 289 /* socket_connect: set up to connect to a socket fd. */
 290 static int socket_connect (int fd, struct sockaddr *sa)
 291 {
 292   int sa_size;
 293   int save_errno;
 294
 295   if (sa->sa_family == AF_INET)
 296     sa_size = sizeof (struct sockaddr_in);
 297 #ifdef HAVE_GETADDRINFO
 298   else if (sa->sa_family == AF_INET6)
 299     sa_size = sizeof (struct sockaddr_in6);
 300 #endif
 301   else {
 302     debug_print (1, ("Unknown address family!\n"));
 303     return -1;
 304   }
 305
 306   if (ConnectTimeout > 0)
 307     alarm (ConnectTimeout);
 308
 309   mutt_allow_interrupt (1);
 310
 311   save_errno = 0;
 312
 313   if (connect (fd, sa, sa_size) < 0) {
 314     save_errno = errno;
 315     debug_print (2, ("Connection failed. errno: %d...\n", errno));
 316     SigInt = 0;                 /* reset in case we caught SIGINTR while in connect() */
 317   }
 318
 319   if (ConnectTimeout > 0)
 320     alarm (0);
 321   mutt_allow_interrupt (0);
 322
 323   return save_errno;
 324 }
 325
 326 /* socket_new_conn: allocate and initialise a new connection. */
 327 static CONNECTION *socket_new_conn ()
 328 {
 329   CONNECTION *conn;
 330
 331   conn = (CONNECTION *) safe_calloc (1, sizeof (CONNECTION));
 332   conn->fd = -1;
 333
 334   return conn;
 335 }
 336
 337 int raw_socket_close (CONNECTION * conn)
 338 {
 339   return close (conn->fd);
 340 }
 341
 342 int raw_socket_read (CONNECTION * conn, char *buf, size_t len)
 343 {
 344   int rc;
 345
 346   if ((rc = read (conn->fd, buf, len)) == -1) {
 347     mutt_error (_("Error talking to %s (%s)"), conn->account.host,
 348                 strerror (errno));
 349     mutt_sleep (2);
 350   }
 351
 352   return rc;
 353 }
 354
 355 int raw_socket_write (CONNECTION * conn, const char *buf, size_t count)
 356 {
 357   int rc;
 358
 359   if ((rc = write (conn->fd, buf, count)) == -1) {
 360     mutt_error (_("Error talking to %s (%s)"), conn->account.host,
 361                 strerror (errno));
 362     mutt_sleep (2);
 363   }
 364
 365   return rc;
 366 }
 367
 368 int raw_socket_open (CONNECTION * conn)
 369 {
 370   int rc;
 371   int fd;
 372
 373   char *host_idna = NULL;
 374
 375 #ifdef HAVE_GETADDRINFO
 376 /* --- IPv4/6 --- */
 377
 378   /* "65536\0" */
 379   char port[6];
 380   struct addrinfo hints;
 381   struct addrinfo *res;
 382   struct addrinfo *cur;
 383
 384   /* we accept v4 or v6 STREAM sockets */
 385   memset (&hints, 0, sizeof (hints));
 386
 387   if (option (OPTUSEIPV6))
 388     hints.ai_family = AF_UNSPEC;
 389   else
 390     hints.ai_family = AF_INET;
 391
 392   hints.ai_socktype = SOCK_STREAM;
 393
 394   snprintf (port, sizeof (port), "%d", conn->account.port);
 395
 396 # ifdef HAVE_LIBIDN
 397   if (idna_to_ascii_lz (conn->account.host, &host_idna, 1) != IDNA_SUCCESS) {
 398     mutt_error (_("Bad IDN \"%s\"."), conn->account.host);
 399     return -1;
 400   }
 401 # else
 402   host_idna = conn->account.host;
 403 # endif
 404
 405   mutt_message (_("Looking up %s..."), conn->account.host);
 406
 407
 408   rc = getaddrinfo (host_idna, port, &hints, &res);
 409
 410 # ifdef HAVE_LIBIDN
 411   FREE (&host_idna);
 412 # endif
 413
 414   if (rc) {
 415     mutt_error (_("Could not find the host \"%s\""), conn->account.host);
 416     return -1;
 417   }
 418
 419   mutt_message (_("Connecting to %s..."), conn->account.host);
 420
 421   rc = -1;
 422   for (cur = res; cur != NULL; cur = cur->ai_next) {
 423     fd = socket (cur->ai_family, cur->ai_socktype, cur->ai_protocol);
 424     if (fd >= 0) {
 425       if ((rc = socket_connect (fd, cur->ai_addr)) == 0) {
 426         fcntl (fd, F_SETFD, FD_CLOEXEC);
 427         conn->fd = fd;
 428         break;
 429       }
 430       else
 431         close (fd);
 432     }
 433   }
 434
 435   freeaddrinfo (res);
 436
 437 #else
 438   /* --- IPv4 only --- */
 439
 440   struct sockaddr_in sin;
 441   struct hostent *he;
 442   int i;
 443
 444   memset (&sin, 0, sizeof (sin));
 445   sin.sin_port = htons (conn->account.port);
 446   sin.sin_family = AF_INET;
 447
 448 # ifdef HAVE_LIBIDN
 449   if (idna_to_ascii_lz (conn->account.host, &host_idna, 1) != IDNA_SUCCESS) {
 450     mutt_error (_("Bad IDN \"%s\"."), conn->account.host);
 451     return -1;
 452   }
 453 # else
 454   host_idna = conn->account.host;
 455 # endif
 456
 457   mutt_message (_("Looking up %s..."), conn->account.host);
 458
 459   if ((he = gethostbyname (host_idna)) == NULL) {
 460 # ifdef HAVE_LIBIDN
 461     FREE (&host_idna);
 462 # endif
 463     mutt_error (_("Could not find the host \"%s\""), conn->account.host);
 464
 465     return -1;
 466   }
 467
 468 # ifdef HAVE_LIBIDN
 469   FREE (&host_idna);
 470 # endif
 471
 472   mutt_message (_("Connecting to %s..."), conn->account.host);
 473
 474   rc = -1;
 475   for (i = 0; he->h_addr_list[i] != NULL; i++) {
 476     memcpy (&sin.sin_addr, he->h_addr_list[i], he->h_length);
 477     fd = socket (PF_INET, SOCK_STREAM, IPPROTO_IP);
 478
 479     if (fd >= 0) {
 480       if ((rc = socket_connect (fd, (struct sockaddr *) &sin)) == 0) {
 481         conn->fd = fd;
 482         break;
 483       }
 484       else
 485         close (fd);
 486     }
 487   }
 488
 489 #endif
 490   if (rc) {
 491     mutt_error (_("Could not connect to %s (%s)."), conn->account.host,
 492                 (rc > 0) ? strerror (rc) : _("unknown error"));
 493     mutt_sleep (2);
 494     return -1;
 495   }
 496
 497   return 0;
 498 }