raw.c File Reference

Low-level socket handling. More...

#include "config.h"
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "connaccount.h"
#include "connection.h"
#include "globals.h"
#include "address/lib.h"
#include <stdbool.h>

Include dependency graph for raw.c:

Go to the source code of this file.

Functions
static int	socket_connect (int fd, struct sockaddr *sa)
	Set up to connect to a socket fd.
int	raw_socket_open (struct Connection *conn)
	Open a socket - Implements Connection::open() -.
int	raw_socket_read (struct Connection *conn, char *buf, size_t count)
	Read data from a socket - Implements Connection::read() -.
int	raw_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to a socket - Implements Connection::write() -.
int	raw_socket_poll (struct Connection *conn, time_t wait_secs)
	Check if any data is waiting on a socket - Implements Connection::poll() -.
int	raw_socket_close (struct Connection *conn)
	Close a socket - Implements Connection::close() -.

Detailed Description

Low-level socket handling.

Authors

• Damien Riegel
• Richard Russon
• Pietro Cerutti

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 raw.c.

Function Documentation

socket_connect()

static int socket_connect ( int fd, struct sockaddr * sa )

static

Set up to connect to a socket fd.

Parameters

fd	File descriptor to connect with
sa	Address info

Return values

0	Success
>0	An errno, e.g. EPERM
-1	Error

Definition at line 68 of file raw.c.

{
  int sa_size;
  int save_errno;
  sigset_t set;
  struct sigaction oldalrm = { 0 };
  struct sigaction act = { 0 };
 
  if (sa->sa_family == AF_INET)
    sa_size = sizeof(struct sockaddr_in);
#ifdef HAVE_GETADDRINFO
  else if (sa->sa_family == AF_INET6)
    sa_size = sizeof(struct sockaddr_in6);
#endif
  else
  {
    mutt_debug(LL_DEBUG1, "Unknown address family!\n");
    return -1;
  }
 
  /* Batch mode does not call mutt_signal_init(), so ensure the alarm
   * interrupts the connect call */
  const short c_socket_timeout = cs_subset_number(NeoMutt->sub, "socket_timeout");
  if (c_socket_timeout > 0)
  {
    sigemptyset(&act.sa_mask);
    act.sa_handler = mutt_sig_empty_handler;
#ifdef SA_INTERRUPT
    act.sa_flags = SA_INTERRUPT;
#else
    act.sa_flags = 0;
#endif
    sigaction(SIGALRM, &act, &oldalrm);
    alarm(c_socket_timeout);
  }
 
  mutt_sig_allow_interrupt(true);
 
  /* FreeBSD's connect() does not respect SA_RESTART, meaning
   * a SIGWINCH will cause the connect to fail. */
  sigemptyset(&set);
  sigaddset(&set, SIGWINCH);
  sigprocmask(SIG_BLOCK, &set, NULL);
 
  save_errno = 0;
 
  if (c_socket_timeout > 0)
  {
    const struct timeval tv = { c_socket_timeout, 0 };
    if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0)
    {
      mutt_debug(LL_DEBUG2, "Cannot set socket receive timeout. errno: %d\n", errno);
    }
    if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0)
    {
      mutt_debug(LL_DEBUG2, "Cannot set socket send timeout. errno: %d\n", errno);
    }
  }
 
  if (connect(fd, sa, sa_size) < 0)
  {
    save_errno = errno;
    mutt_debug(LL_DEBUG2, "Connection failed. errno: %d\n", errno);
    SigInt = false; /* reset in case we caught SIGINTR while in connect() */
  }
 
  if (c_socket_timeout > 0)
  {
    alarm(0);
    sigaction(SIGALRM, &oldalrm, NULL);
  }
  mutt_sig_allow_interrupt(false);
  sigprocmask(SIG_UNBLOCK, &set, NULL);
 
  return save_errno;
}

Here is the call graph for this function:

Here is the caller graph for this function: