socket.c File Reference

Low-level socket handling. More...

#include "config.h"
#include <errno.h>
#include <stdbool.h>
#include <string.h>
#include <time.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "socket.h"
#include "connaccount.h"
#include "connection.h"
#include "protos.h"
#include "ssl.h"

Include dependency graph for socket.c:

Go to the source code of this file.

Functions
static int	socket_preconnect (void)
	Execute a command before opening a socket.
int	mutt_socket_open (struct Connection *conn)
	Simple wrapper.
int	mutt_socket_close (struct Connection *conn)
	Close a socket.
int	mutt_socket_read (struct Connection *conn, char *buf, size_t len)
	Read from a Connection.
int	mutt_socket_write_d (struct Connection *conn, const char *buf, int len, int dbg)
	Write data to a socket.
int	mutt_socket_poll (struct Connection *conn, time_t wait_secs)
	Checks whether reads would block.
int	mutt_socket_readchar (struct Connection *conn, char *c)
	Simple read buffering to speed things up.
int	mutt_socket_readln_d (char *buf, size_t buflen, struct Connection *conn, int dbg)
	Read a line from a socket.
struct Connection *	mutt_socket_new (enum ConnectionType type)
	Allocate and initialise a new connection.
void	mutt_socket_empty (struct Connection *conn)
	Clear out any queued data.
int	mutt_socket_buffer_readln_d (struct Buffer *buf, struct Connection *conn, int dbg)
	Read a line from a socket into a Buffer.

Detailed Description

Low-level socket handling.

Authors

• Damien Riegel
• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file socket.c.

Function Documentation

socket_preconnect()

static int socket_preconnect ( void  )

static

Execute a command before opening a socket.

Return values

0	Success
>0	An errno, e.g. EPERM

Definition at line 50 of file socket.c.

{
  const char *const c_preconnect = cs_subset_string(NeoMutt->sub, "preconnect");
  if (!c_preconnect)
    return 0;
 
  mutt_debug(LL_DEBUG2, "Executing preconnect: %s\n", c_preconnect);
  const int rc = mutt_system(c_preconnect);
  mutt_debug(LL_DEBUG2, "Preconnect result: %d\n", rc);
  if (rc != 0)
  {
    const int save_errno = errno;
    mutt_perror(_("Preconnect command failed"));
 
    return save_errno;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_socket_open()

int mutt_socket_open

(

struct Connection *

conn

)

Simple wrapper.

Parameters

conn	Connection to a server

Return values

0	Success
-1	Error

Definition at line 76 of file socket.c.

{
  int rc;
 
  if (socket_preconnect())
    return -1;
 
  rc = conn->open(conn);
 
  if (rc >= 0)
  {
    mutt_debug(LL_DEBUG2, "Connected to %s:%d on fd=%d\n", conn->account.host,
               conn->account.port, conn->fd);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_socket_close()

int mutt_socket_close

(

struct Connection *

conn

)

Close a socket.

Parameters

conn	Connection to a server

Return values

0	Success
-1	Error

Definition at line 100 of file socket.c.

{
  if (!conn)
    return 0;
 
  int rc = -1;
 
  if (conn->fd < 0)
    mutt_debug(LL_DEBUG1, "Attempt to close closed connection\n");
  else
    rc = conn->close(conn);
 
  conn->fd = -1;
  conn->ssf = 0;
  conn->bufpos = 0;
  conn->available = 0;
 
  return rc;
}

Here is the caller graph for this function:

mutt_socket_read()

int mutt_socket_read	(	struct Connection *	conn,
		char *	buf,
		size_t	len
	)

Read from a Connection.

Parameters

conn	Connection a server
buf	Buffer to store read data
len	length of the buffer

Return values

>0	Success, number of bytes read
-1	Error, see errno

Definition at line 128 of file socket.c.

{
  return conn->read(conn, buf, len);
}

Here is the caller graph for this function:

mutt_socket_write_d()

int mutt_socket_write_d	(	struct Connection *	conn,
		const char *	buf,
		int	len,
		int	dbg
	)

Write data to a socket.

Parameters

conn	Connection to a server
buf	Buffer with data to write
len	Length of data to write
dbg	Debug level for logging

Return values

>0	Number of bytes written
-1	Error

Definition at line 142 of file socket.c.

{
  int sent = 0;
 
  mutt_debug(dbg, "%d> %s", conn->fd, buf);
 
  if (conn->fd < 0)
  {
    mutt_debug(LL_DEBUG1, "attempt to write to closed connection\n");
    return -1;
  }
 
  while (sent < len)
  {
    const int rc = conn->write(conn, buf + sent, len - sent);
    if (rc < 0)
    {
      mutt_debug(LL_DEBUG1, "error writing (%s), closing socket\n", strerror(errno));
      mutt_socket_close(conn);
 
      return -1;
    }
 
    if (rc < len - sent)
      mutt_debug(LL_DEBUG3, "short write (%d of %d bytes)\n", rc, len - sent);
 
    sent += rc;
  }
 
  return sent;
}

Here is the call graph for this function:

mutt_socket_poll()

int mutt_socket_poll	(	struct Connection *	conn,
		time_t	wait_secs
	)

Checks whether reads would block.

Parameters

conn	Connection to a server
wait_secs	How long to wait for a response

Return values

>0	There is data to read
0	Read would block
-1	Connection doesn't support polling

Definition at line 182 of file socket.c.

{
  if (conn->bufpos < conn->available)
    return conn->available - conn->bufpos;
 
  if (conn->poll)
    return conn->poll(conn, wait_secs);
 
  return -1;
}

Here is the caller graph for this function:

mutt_socket_readchar()

int mutt_socket_readchar	(	struct Connection *	conn,
		char *	c
	)

Simple read buffering to speed things up.

Parameters

[in]	conn	Connection to a server
[out]	c	Character that was read

Return values

1	Success
-1	Error

Definition at line 200 of file socket.c.

{
  if (conn->bufpos >= conn->available)
  {
    if (conn->fd >= 0)
    {
      conn->available = conn->read(conn, conn->inbuf, sizeof(conn->inbuf));
    }
    else
    {
      mutt_debug(LL_DEBUG1, "attempt to read from closed connection\n");
      return -1;
    }
    conn->bufpos = 0;
    if (conn->available == 0)
    {
      mutt_error(_("Connection to %s closed"), conn->account.host);
    }
    if (conn->available <= 0)
    {
      mutt_socket_close(conn);
      return -1;
    }
  }
  *c = conn->inbuf[conn->bufpos];
  conn->bufpos++;
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_socket_readln_d()

int mutt_socket_readln_d	(	char *	buf,
		size_t	buflen,
		struct Connection *	conn,
		int	dbg
	)

Read a line from a socket.

Parameters

buf	Buffer to store the line
buflen	Length of data to write
conn	Connection to a server
dbg	Debug level for logging

Return values

>0	Success, number of bytes read
-1	Error

Definition at line 238 of file socket.c.

{
  char ch;
  int i;
 
  for (i = 0; i < buflen - 1; i++)
  {
    if (mutt_socket_readchar(conn, &ch) != 1)
    {
      buf[i] = '\0';
      return -1;
    }
 
    if (ch == '\n')
      break;
    buf[i] = ch;
  }
 
  /* strip \r from \r\n termination */
  if (i && (buf[i - 1] == '\r'))
    i--;
  buf[i] = '\0';
 
  mutt_debug(dbg, "%d< %s\n", conn->fd, buf);
 
  /* number of bytes read, not strlen */
  return i + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_socket_new()

struct Connection * mutt_socket_new

(

enum ConnectionType

type

)

Allocate and initialise a new connection.

Parameters

type	Type of the new Connection

Return values

ptr	New Connection

Definition at line 272 of file socket.c.

{
  struct Connection *conn = MUTT_MEM_CALLOC(1, struct Connection);
  conn->fd = -1;
 
  if (type == MUTT_CONNECTION_TUNNEL)
  {
    mutt_tunnel_socket_setup(conn);
  }
  else if (type == MUTT_CONNECTION_SSL)
  {
    int rc = mutt_ssl_socket_setup(conn);
    if (rc < 0)
      FREE(&conn);
  }
  else
  {
    conn->read = raw_socket_read;
    conn->write = raw_socket_write;
    conn->open = raw_socket_open;
    conn->close = raw_socket_close;
    conn->poll = raw_socket_poll;
  }
 
  return conn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_socket_empty()

void mutt_socket_empty

(

struct Connection *

conn

)

Clear out any queued data.

Parameters

conn	Connection to a server

The internal buffer is emptied and any data that has already arrived at this machine (in kernel buffers) is read and dropped.

Definition at line 306 of file socket.c.

{
  if (!conn)
    return;
 
  char buf[1024] = { 0 };
  int bytes;
 
  while ((bytes = mutt_socket_poll(conn, 0)) > 0)
  {
    mutt_socket_read(conn, buf, MIN(bytes, sizeof(buf)));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_socket_buffer_readln_d()

int mutt_socket_buffer_readln_d	(	struct Buffer *	buf,
		struct Connection *	conn,
		int	dbg
	)

Read a line from a socket into a Buffer.

Parameters

buf	Buffer to store the line
conn	Connection to a server
dbg	Debug level for logging

Return values

>0	Success, number of bytes read
-1	Error

Definition at line 328 of file socket.c.

{
  char ch;
  bool has_cr = false;
 
  buf_reset(buf);
 
  while (true)
  {
    if (mutt_socket_readchar(conn, &ch) != 1)
      return -1;
 
    if (ch == '\n')
      break;
 
    if (has_cr)
    {
      buf_addch(buf, '\r');
      has_cr = false;
    }
 
    if (ch == '\r')
      has_cr = true;
    else
      buf_addch(buf, ch);
  }
 
  mutt_debug(dbg, "%d< %s\n", conn->fd, buf_string(buf));
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: