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)
  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 (void);
  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 = str_len (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 str_len */
 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     mem_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       mem_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_GNUTLS
 243     if (mutt_gnutls_socket_setup (conn) < 0) {
 244       mutt_socket_free (conn);
 245       return NULL;
 246     }
 247 #else
 248     mutt_error _("SSL is unavailable.");
 249
 250     mutt_sleep (2);
 251     mutt_socket_free (conn);
 252
 253     return NULL;
 254 #endif
 255   }
 256   else {
 257     conn->conn_read = raw_socket_read;
 258     conn->conn_write = raw_socket_write;
 259     conn->conn_open = raw_socket_open;
 260     conn->conn_close = raw_socket_close;
 261   }
 262
 263   return conn;
 264 }
 265
 266 static int socket_preconnect (void)
 267 {
 268   int rc;
 269   int save_errno;
 270
 271   if (str_len (Preconnect)) {
 272     debug_print (2, ("Executing preconnect: %s\n", Preconnect));
 273     rc = mutt_system (Preconnect);
 274     debug_print (2, ("Preconnect result: %d\n", rc));
 275     if (rc) {
 276       save_errno = errno;
 277       mutt_perror (_("Preconnect command failed."));
 278       mutt_sleep (1);
 279
 280       return save_errno;
 281     }
 282   }
 283
 284   return 0;
 285 }
 286
 287 /* socket_connect: set up to connect to a socket fd. */
 288 static int socket_connect (int fd, struct sockaddr *sa)
 289 {
 290   int sa_size;
 291   int save_errno;
 292
 293   if (sa->sa_family == AF_INET)
 294     sa_size = sizeof (struct sockaddr_in);
 295 #ifdef HAVE_GETADDRINFO
 296   else if (sa->sa_family == AF_INET6)
 297     sa_size = sizeof (struct sockaddr_in6);
 298 #endif
 299   else {
 300     debug_print (1, ("Unknown address family!\n"));
 301     return -1;
 302   }
 303
 304   if (ConnectTimeout > 0)
 305     alarm (ConnectTimeout);
 306
 307   mutt_allow_interrupt (1);
 308
 309   save_errno = 0;
 310
 311   if (connect (fd, sa, sa_size) < 0) {
 312     save_errno = errno;
 313     debug_print (2, ("Connection failed. errno: %d...\n", errno));
 314     SigInt = 0;                 /* reset in case we caught SIGINTR while in connect() */
 315   }
 316
 317   if (ConnectTimeout > 0)
 318     alarm (0);
 319   mutt_allow_interrupt (0);
 320
 321   return save_errno;
 322 }
 323
 324 /* socket_new_conn: allocate and initialise a new connection. */
 325 static CONNECTION *socket_new_conn (void)
 326 {
 327   CONNECTION *conn;
 328
 329   conn = (CONNECTION *) mem_calloc (1, sizeof (CONNECTION));
 330   conn->fd = -1;
 331
 332   return conn;
 333 }
 334
 335 int raw_socket_close (CONNECTION * conn)
 336 {
 337   return close (conn->fd);
 338 }
 339
 340 int raw_socket_read (CONNECTION * conn, char *buf, size_t len)
 341 {
 342   int rc;
 343
 344   if ((rc = read (conn->fd, buf, len)) == -1) {
 345     mutt_error (_("Error talking to %s (%s)"), conn->account.host,
 346                 strerror (errno));
 347     mutt_sleep (2);
 348   }
 349
 350   return rc;
 351 }
 352
 353 int raw_socket_write (CONNECTION * conn, const char *buf, size_t count)
 354 {
 355   int rc;
 356
 357   if ((rc = write (conn->fd, buf, count)) == -1) {
 358     mutt_error (_("Error talking to %s (%s)"), conn->account.host,
 359                 strerror (errno));
 360     mutt_sleep (2);
 361   }
 362
 363   return rc;
 364 }
 365
 366 int raw_socket_open (CONNECTION * conn)
 367 {
 368   int rc;
 369   int fd;
 370
 371   char *host_idna = NULL;
 372
 373 #ifdef HAVE_GETADDRINFO
 374 /* --- IPv4/6 --- */
 375
 376   /* "65536\0" */
 377   char port[6];
 378   struct addrinfo hints;
 379   struct addrinfo *res;
 380   struct addrinfo *cur;
 381
 382   /* we accept v4 or v6 STREAM sockets */
 383   memset (&hints, 0, sizeof (hints));
 384
 385   if (option (OPTUSEIPV6))
 386     hints.ai_family = AF_UNSPEC;
 387   else
 388     hints.ai_family = AF_INET;
 389
 390   hints.ai_socktype = SOCK_STREAM;
 391
 392   snprintf (port, sizeof (port), "%d", conn->account.port);
 393
 394 # ifdef HAVE_LIBIDN
 395   if (idna_to_ascii_lz (conn->account.host, &host_idna, 1) != IDNA_SUCCESS) {
 396     mutt_error (_("Bad IDN \"%s\"."), conn->account.host);
 397     return -1;
 398   }
 399 # else
 400   host_idna = conn->account.host;
 401 # endif
 402
 403   mutt_message (_("Looking up %s..."), conn->account.host);
 404
 405
 406   rc = getaddrinfo (host_idna, port, &hints, &res);
 407
 408 # ifdef HAVE_LIBIDN
 409   mem_free (&host_idna);
 410 # endif
 411
 412   if (rc) {
 413     mutt_error (_("Could not find the host \"%s\""), conn->account.host);
 414     mutt_sleep (2);
 415     return -1;
 416   }
 417
 418   mutt_message (_("Connecting to %s..."), conn->account.host);
 419
 420   rc = -1;
 421   for (cur = res; cur != NULL; cur = cur->ai_next) {
 422     fd = socket (cur->ai_family, cur->ai_socktype, cur->ai_protocol);
 423     if (fd >= 0) {
 424       if ((rc = socket_connect (fd, cur->ai_addr)) == 0) {
 425         fcntl (fd, F_SETFD, FD_CLOEXEC);
 426         conn->fd = fd;
 427         break;
 428       }
 429       else
 430         close (fd);
 431     }
 432   }
 433
 434   freeaddrinfo (res);
 435
 436 #else
 437   /* --- IPv4 only --- */
 438
 439   struct sockaddr_in sin;
 440   struct hostent *he;
 441   int i;
 442
 443   memset (&sin, 0, sizeof (sin));
 444   sin.sin_port = htons (conn->account.port);
 445   sin.sin_family = AF_INET;
 446
 447 # ifdef HAVE_LIBIDN
 448   if (idna_to_ascii_lz (conn->account.host, &host_idna, 1) != IDNA_SUCCESS) {
 449     mutt_error (_("Bad IDN \"%s\"."), conn->account.host);
 450     return -1;
 451   }
 452 # else
 453   host_idna = conn->account.host;
 454 # endif
 455
 456   mutt_message (_("Looking up %s..."), conn->account.host);
 457
 458   if ((he = gethostbyname (host_idna)) == NULL) {
 459 # ifdef HAVE_LIBIDN
 460     mem_free (&host_idna);
 461 # endif
 462     mutt_error (_("Could not find the host \"%s\""), conn->account.host);
 463
 464     return -1;
 465   }
 466
 467 # ifdef HAVE_LIBIDN
 468   mem_free (&host_idna);
 469 # endif
 470
 471   mutt_message (_("Connecting to %s..."), conn->account.host);
 472
 473   rc = -1;
 474   for (i = 0; he->h_addr_list[i] != NULL; i++) {
 475     memcpy (&sin.sin_addr, he->h_addr_list[i], he->h_length);
 476     fd = socket (PF_INET, SOCK_STREAM, IPPROTO_IP);
 477
 478     if (fd >= 0) {
 479       if ((rc = socket_connect (fd, (struct sockaddr *) &sin)) == 0) {
 480         conn->fd = fd;
 481         break;
 482       }
 483       else
 484         close (fd);
 485     }
 486   }
 487
 488 #endif
 489   if (rc) {
 490     mutt_error (_("Could not connect to %s (%s)."), conn->account.host,
 491                 (rc > 0) ? strerror (rc) : _("unknown error"));
 492     mutt_sleep (2);
 493     return -1;
 494   }
 495
 496   return 0;
 497 }