write()

Write to a socket Connection. More...

Collaboration diagram for write():

Functions
static int	tls_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to a TLS socket - Implements Connection::write() -.
static int	ssl_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to an SSL socket - Implements Connection::write() -.
int	raw_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to a socket - Implements Connection::write() -.
static int	mutt_sasl_conn_write (struct Connection *conn, const char *buf, size_t count)
	Write to an SASL connection - Implements Connection::write() -.
static int	tunnel_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to a tunnel socket - Implements Connection::write() -.
static int	zstrm_write (struct Connection *conn, const char *buf, size_t count)
	Write compressed data to a socket - Implements Connection::write() -.

Variables
int(*	SaslSockData::write )(struct Connection *conn, const char *buf, size_t count)
	Write to a socket Connection - Implements Connection::write() -.

Detailed Description

Write to a socket Connection.

Parameters

conn	Connection to a server
buf	Buffer to read into
count	Number of bytes to read

Return values

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

Function Documentation

tls_socket_write()

static int tls_socket_write ( struct Connection *  conn, const char *  buf, size_t  count  )

static

Write data to a TLS socket - Implements Connection::write() -.

Definition at line 1077 of file gnutls.c.

{
  struct TlsSockData *data = conn->sockdata;
  size_t sent = 0;
 
  if (!data)
  {
    mutt_error(_("Error: no TLS socket open"));
    return -1;
  }
 
  do
  {
    int rc;
    do
    {
      rc = gnutls_record_send(data->session, buf + sent, count - sent);
    } while ((rc == GNUTLS_E_AGAIN) || (rc == GNUTLS_E_INTERRUPTED));
 
    if (rc < 0)
    {
      mutt_error("tls_socket_write (%s)", gnutls_strerror(rc));
      return -1;
    }
 
    sent += rc;
  } while (sent < count);
 
  return sent;
}

Here is the caller graph for this function:

ssl_socket_write()

static int ssl_socket_write ( struct Connection *  conn, const char *  buf, size_t  count  )

static

Write data to an SSL socket - Implements Connection::write() -.

Definition at line 1368 of file openssl.c.

{
  if (!conn || !conn->sockdata || !buf || (count == 0))
    return -1;
 
  struct SslSockData *data = sockdata(conn);
  int rc;
 
retry:
  rc = SSL_write(data->ssl, buf, count);
  if (rc > 0)
    return rc;
 
  // User hit Ctrl-C
  if (SigInt && (errno == EINTR))
  {
    rc = -1;
  }
  else if (BIO_should_retry(SSL_get_wbio(data->ssl)))
  {
    // Temporary failure, e.g. signal received
    goto retry;
  }
 
  ssl_err(data, rc);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

raw_socket_write()

int raw_socket_write	(	struct Connection *	conn,
		const char *	buf,
		size_t	count
	)

Write data to a socket - Implements Connection::write() -.

Definition at line 325 of file raw.c.

{
  int rc;
  size_t sent = 0;
 
  mutt_sig_allow_interrupt(true);
  do
  {
    do
    {
      rc = write(conn->fd, buf + sent, count - sent);
    } while (rc < 0 && (errno == EINTR));
 
    if (rc < 0)
    {
      mutt_error(_("Error talking to %s (%s)"), conn->account.host, strerror(errno));
      mutt_sig_allow_interrupt(false);
      return -1;
    }
 
    sent += rc;
  } while ((sent < count) && !SigInt);
 
  mutt_sig_allow_interrupt(false);
  return sent;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sasl_conn_write()

static int mutt_sasl_conn_write ( struct Connection *  conn, const char *  buf, size_t  count  )

static

Write to an SASL connection - Implements Connection::write() -.

Definition at line 534 of file sasl.c.

{
  int rc;
  const char *pbuf = NULL;
  unsigned int olen, plen;
 
  struct SaslSockData *sasldata = conn->sockdata;
  conn->sockdata = sasldata->sockdata;
 
  /* encode data, if necessary */
  if (*sasldata->ssf != 0)
  {
    /* handle data larger than MAXOUTBUF */
    do
    {
      olen = (count > *sasldata->pbufsize) ? *sasldata->pbufsize : count;
 
      rc = sasl_encode(sasldata->saslconn, buf, olen, &pbuf, &plen);
      if (rc != SASL_OK)
      {
        mutt_debug(LL_DEBUG1, "SASL encoding failed: %s\n", sasl_errstring(rc, NULL, NULL));
        goto fail;
      }
 
      rc = sasldata->write(conn, pbuf, plen);
      if (rc != plen)
        goto fail;
 
      count -= olen;
      buf += olen;
    } while (count > *sasldata->pbufsize);
  }
  else
  {
    /* just write using the underlying socket function */
    rc = sasldata->write(conn, buf, count);
  }
 
  conn->sockdata = sasldata;
 
  return rc;
 
fail:
  conn->sockdata = sasldata;
  return -1;
}

Here is the caller graph for this function:

tunnel_socket_write()

static int tunnel_socket_write ( struct Connection *  conn, const char *  buf, size_t  count  )

static

Write data to a tunnel socket - Implements Connection::write() -.

Definition at line 169 of file tunnel.c.

{
  struct TunnelSockData *tunnel = conn->sockdata;
  int rc;
  size_t sent = 0;
 
  do
  {
    do
    {
      rc = write(tunnel->fd_write, buf + sent, count - sent);
    } while (rc < 0 && errno == EINTR);
 
    if (rc < 0)
    {
      mutt_error(_("Tunnel error talking to %s: %s"), conn->account.host, strerror(errno));
      return -1;
    }
 
    sent += rc;
  } while (sent < count);
 
  return sent;
}

Here is the caller graph for this function:

zstrm_write()

static int zstrm_write ( struct Connection *  conn, const char *  buf, size_t  count  )

static

Write compressed data to a socket - Implements Connection::write() -.

Definition at line 231 of file zstrm.c.

{
  struct ZstrmContext *zctx = conn->sockdata;
  int rc;
 
  zctx->write.z.avail_in = (uInt) count;
  zctx->write.z.next_in = (Bytef *) buf;
  zctx->write.z.avail_out = (uInt) zctx->write.len;
  zctx->write.z.next_out = (Bytef *) zctx->write.buf;
 
  do
  {
    int zrc = deflate(&zctx->write.z, Z_PARTIAL_FLUSH);
    if (zrc == Z_OK)
    {
      /* push out produced data to the underlying stream */
      zctx->write.pos = zctx->write.len - zctx->write.z.avail_out;
      char *wbufp = zctx->write.buf;
      mutt_debug(LL_DEBUG5, "deflate consumed %zu/%zu bytes\n",
                 count - zctx->write.z.avail_in, count);
      while (zctx->write.pos > 0)
      {
        rc = zctx->next_conn.write(&zctx->next_conn, wbufp, zctx->write.pos);
        mutt_debug(LL_DEBUG5, "next stream wrote: %d bytes\n", rc);
        if (rc < 0)
          return -1; /* we can't recover from write failure */
 
        wbufp += rc;
        zctx->write.pos -= rc;
      }
 
      /* see if there's more for us to do, retry if the output buffer
       * was full (there may be something in zlib buffers), and retry
       * when there is still available input data */
      if ((zctx->write.z.avail_out != 0) && (zctx->write.z.avail_in == 0))
        break;
 
      zctx->write.z.avail_out = (uInt) zctx->write.len;
      zctx->write.z.next_out = (Bytef *) zctx->write.buf;
    }
    else
    {
      /* compression went wrong, but this is basically impossible
       * according to the docs */
      return -1;
    }
  } while (true);
 
  rc = (int) count;
  return (rc <= 0) ? 1 : rc; /* avoid wrong behaviour due to overflow */
}

Here is the caller graph for this function:

Variable Documentation

write

int(* SaslSockData::write) (struct Connection *conn, const char *buf, size_t count)

Write to a socket Connection - Implements Connection::write() -.

Definition at line 90 of file sasl.c.