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() -. More...
static int	ssl_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to an SSL socket - Implements Connection::write() -. More...
int	raw_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to a socket - Implements Connection::write() -. More...
static int	mutt_sasl_conn_write (struct Connection *conn, const char *buf, size_t count)
	Write to an SASL connection - Implements Connection::write() -. More...
static int	tunnel_socket_write (struct Connection *conn, const char *buf, size_t count)
	Write data to a tunnel socket - Implements Connection::write() -. More...
static int	zstrm_write (struct Connection *conn, const char *buf, size_t count)
	Write compressed data to a socket - Implements Connection::write() -. More...

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

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 1094 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 ret;
    do
    {
      ret = gnutls_record_send(data->state, buf + sent, count - sent);
    } while ((ret == GNUTLS_E_AGAIN) || (ret == GNUTLS_E_INTERRUPTED));

    if (ret < 0)
    {
      mutt_error("tls_socket_write (%s)", gnutls_strerror(ret));
      return -1;
    }

    sent += ret;
  } 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 1369 of file openssl.c.

{
  if (!conn || !conn->sockdata || !buf || (count == 0))
    return -1;

  int rc = SSL_write(sockdata(conn)->ssl, buf, count);
  if ((rc <= 0) || (errno == EINTR))
  {
    if (errno == EINTR)
    {
      rc = -1;
    }
    ssl_err(sockdata(conn), 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 297 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 531 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 159 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 228 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 %d/%d 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 86 of file sasl.c.