open()

Open a socket Connection. More...

Collaboration diagram for open():

Functions
static int	tls_socket_open (struct Connection *conn)
	Open a TLS socket - Implements Connection::open() -.
static int	ssl_socket_open_err (struct Connection *conn)
	Error callback for opening an SSL connection - Implements Connection::open() -.
static int	ssl_socket_open (struct Connection *conn)
	Open an SSL socket - Implements Connection::open() -.
int	raw_socket_open (struct Connection *conn)
	Open a socket - Implements Connection::open() -.
static int	mutt_sasl_conn_open (struct Connection *conn)
	Empty wrapper for underlying open function - Implements Connection::open() -.
static int	tunnel_socket_open (struct Connection *conn)
	Open a tunnel socket - Implements Connection::open() -.
static int	zstrm_open (struct Connection *conn)
	Open a socket - Implements Connection::open() -.

Variables
int(*	SaslSockData::open )(struct Connection *conn)
	Open a socket Connection - Implements Connection::open() -.

Detailed Description

Open a socket Connection.

Parameters

conn	Connection to a server

Return values

0	Success
-1	Error

Function Documentation

tls_socket_open()

static int tls_socket_open ( struct Connection *  conn )

static

Open a TLS socket - Implements Connection::open() -.

Definition at line 1032 of file gnutls.c.

{
  if (raw_socket_open(conn) < 0)
    return -1;
 
  if (tls_negotiate(conn) < 0)
  {
    tls_socket_close(conn);
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ssl_socket_open_err()

static int ssl_socket_open_err ( struct Connection *  conn )

static

Error callback for opening an SSL connection - Implements Connection::open() -.

Return values

-1

Always

Definition at line 356 of file openssl.c.

{
  mutt_error(_("SSL disabled due to the lack of entropy"));
  return -1;
}

Here is the caller graph for this function:

ssl_socket_open()

static int ssl_socket_open ( struct Connection *  conn )

static

Open an SSL socket - Implements Connection::open() -.

Definition at line 1324 of file openssl.c.

{
  if (raw_socket_open(conn) < 0)
    return -1;
 
  int rc = ssl_setup(conn);
  if (rc)
    raw_socket_close(conn);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

raw_socket_open()

int raw_socket_open

(

struct Connection *

conn

)

Open a socket - Implements Connection::open() -.

Definition at line 148 of file raw.c.

{
  int rc;
 
  char *host_idna = NULL;
 
#ifdef HAVE_GETADDRINFO
  /* --- IPv4/6 --- */
 
  /* "65536\0" */
  char port[6] = { 0 };
  struct addrinfo hints = { 0 };
  struct addrinfo *res = NULL;
  struct addrinfo *cur = NULL;
 
  /* we accept v4 or v6 STREAM sockets */
  const bool c_use_ipv6 = cs_subset_bool(NeoMutt->sub, "use_ipv6");
  if (c_use_ipv6)
    hints.ai_family = AF_UNSPEC;
  else
    hints.ai_family = AF_INET;
 
  hints.ai_socktype = SOCK_STREAM;
 
  snprintf(port, sizeof(port), "%d", conn->account.port);
 
#ifdef HAVE_LIBIDN
  if (mutt_idna_to_ascii_lz(conn->account.host, &host_idna, 1) != 0)
  {
    mutt_error(_("Bad IDN: '%s'"), conn->account.host);
    return -1;
  }
#else
  host_idna = conn->account.host;
#endif
 
  if (!OptNoCurses)
    mutt_message(_("Looking up %s..."), conn->account.host);
 
  rc = getaddrinfo(host_idna, port, &hints, &res);
 
#ifdef HAVE_LIBIDN
  FREE(&host_idna);
#endif
 
  if (rc)
  {
    mutt_error(_("Could not find the host \"%s\""), conn->account.host);
    return -1;
  }
 
  if (!OptNoCurses)
    mutt_message(_("Connecting to %s..."), conn->account.host);
 
  rc = -1;
  for (cur = res; cur; cur = cur->ai_next)
  {
    int fd = socket(cur->ai_family, cur->ai_socktype, cur->ai_protocol);
    if (fd >= 0)
    {
      rc = socket_connect(fd, cur->ai_addr);
      if (rc == 0)
      {
        (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
        conn->fd = fd;
        break;
      }
      else
      {
        close(fd);
      }
    }
  }
 
  freeaddrinfo(res);
#else
  /* --- IPv4 only --- */
 
  struct hostent *he = NULL;
  struct sockaddr_in sin = { 0 };
  sin.sin_port = htons(conn->account.port);
  sin.sin_family = AF_INET;
 
#ifdef HAVE_LIBIDN
  if (mutt_idna_to_ascii_lz(conn->account.host, &host_idna, 1) != 0)
  {
    mutt_error(_("Bad IDN: '%s'"), conn->account.host);
    return -1;
  }
#else
  host_idna = conn->account.host;
#endif
 
  if (!OptNoCurses)
    mutt_message(_("Looking up %s..."), conn->account.host);
 
  he = gethostbyname(host_idna);
 
#ifdef HAVE_LIBIDN
  FREE(&host_idna);
#endif
 
  if (!he)
  {
    mutt_error(_("Could not find the host \"%s\""), conn->account.host);
 
    return -1;
  }
 
  if (!OptNoCurses)
    mutt_message(_("Connecting to %s..."), conn->account.host);
 
  rc = -1;
  for (int i = 0; he->h_addr_list[i]; i++)
  {
    memcpy(&sin.sin_addr, he->h_addr_list[i], he->h_length);
    int fd = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
 
    if (fd >= 0)
    {
      rc = socket_connect(fd, (struct sockaddr *) &sin);
      if (rc == 0)
      {
        fcntl(fd, F_SETFD, FD_CLOEXEC);
        conn->fd = fd;
        break;
      }
      else
      {
        close(fd);
      }
    }
  }
#endif
  if (rc)
  {
    mutt_error(_("Could not connect to %s (%s)"), conn->account.host,
               (rc > 0) ? strerror(rc) : _("unknown error"));
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sasl_conn_open()

static int mutt_sasl_conn_open ( struct Connection *  conn )

static

Empty wrapper for underlying open function - Implements Connection::open() -.

We don't know in advance that a connection will use SASL, so we replace conn's methods with sasl methods when authentication is successful, using mutt_sasl_setup_conn

Definition at line 427 of file sasl.c.

{
  struct SaslSockData *sasldata = conn->sockdata;
  conn->sockdata = sasldata->sockdata;
  int rc = sasldata->open(conn);
  conn->sockdata = sasldata;
 
  return rc;
}

Here is the caller graph for this function:

tunnel_socket_open()

static int tunnel_socket_open ( struct Connection *  conn )

static

Open a tunnel socket - Implements Connection::open() -.

Definition at line 58 of file tunnel.c.

{
  int pin[2], pout[2];
 
  struct TunnelSockData *tunnel = MUTT_MEM_MALLOC(1, struct TunnelSockData);
  conn->sockdata = tunnel;
 
  const char *const c_tunnel = cs_subset_string(NeoMutt->sub, "tunnel");
  mutt_message(_("Connecting with \"%s\"..."), c_tunnel);
 
  int rc = pipe(pin);
  if (rc == -1)
  {
    mutt_perror("pipe");
    FREE(&conn->sockdata);
    return -1;
  }
  rc = pipe(pout);
  if (rc == -1)
  {
    mutt_perror("pipe");
    close(pin[0]);
    close(pin[1]);
    FREE(&conn->sockdata);
    return -1;
  }
 
  mutt_sig_block_system();
  int pid = fork();
  if (pid == 0)
  {
    mutt_sig_unblock_system(false);
    mutt_sig_reset_child_signals();
    const int fd_null = open("/dev/null", O_RDWR);
    if ((fd_null < 0) || (dup2(pout[0], STDIN_FILENO) < 0) ||
        (dup2(pin[1], STDOUT_FILENO) < 0) || (dup2(fd_null, STDERR_FILENO) < 0))
    {
      _exit(127);
    }
    close(pin[0]);
    close(pin[1]);
    close(pout[0]);
    close(pout[1]);
    close(fd_null);
 
    /* Don't let the subprocess think it can use the controlling tty */
    setsid();
 
    execle(EXEC_SHELL, "sh", "-c", c_tunnel, NULL, NeoMutt->env);
    _exit(127);
  }
  mutt_sig_unblock_system(true);
 
  if (pid == -1)
  {
    mutt_perror("fork");
    close(pin[0]);
    close(pin[1]);
    close(pout[0]);
    close(pout[1]);
    FREE(&conn->sockdata);
    return -1;
  }
  if ((close(pin[1]) < 0) || (close(pout[0]) < 0))
    mutt_perror("close");
 
  // These are unlikely to fail
  (void) fcntl(pin[0], F_SETFD, FD_CLOEXEC);
  (void) fcntl(pout[1], F_SETFD, FD_CLOEXEC);
 
  tunnel->fd_read = pin[0];
  tunnel->fd_write = pout[1];
  tunnel->pid = pid;
 
  conn->fd = 42; /* stupid hack */
 
  /* Note we are using ssf as a boolean in this case.  See the notes in
   * conn/connection.h */
  const bool c_tunnel_is_secure = cs_subset_bool(NeoMutt->sub, "tunnel_is_secure");
  if (c_tunnel_is_secure)
    conn->ssf = 1;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zstrm_open()

static int zstrm_open ( struct Connection *  conn )

static

Open a socket - Implements Connection::open() -.

Return values

-1

Always

Cannot open a zlib connection, must wrap an existing one

Definition at line 92 of file zstrm.c.

{
  return -1;
}

Here is the caller graph for this function:

Variable Documentation

open

int(* SaslSockData::open) (struct Connection *conn)

Open a socket Connection - Implements Connection::open() -.

Definition at line 80 of file sasl.c.