Node:Stream, Next:Iterator, Previous:Attribute, Up:libmailbox

Stream

#include <mailutils/stream.h>

These generic flags are interpreted as appropriate to the specific streams.

MU_STREAM_READ

The stream is open read only.

MU_STREAM_WRITE

The stream is open write only.

MU_STREAM_RDWR

The stream is open read and write.

MU_STREAM_APPEND

The stream is open in append mode for writing.

MU_STREAM_CREAT

The stream open will create the underlying resource (such as a file) if it doesn't exist already.

MU_STREAM_NONBLOCK

The stream is set non blocking.

MU_STREAM_NO_CHECK

Stream is destroyed without checking for the owner.

MU_STREAM_NO_CLOSE

Stream doesn't close it's underlying resource when it is closed or destroyed.

int file_stream_create (stream_t *pstream, const char *filename, int flags)

Function

int tcp_stream_create (stream_t *pstream, const char *host, int port, int flags)

Function

int mapfile_stream_create (stream_t *pstream, const char *filename, int flags)

Function

int memory_stream_create (stream_t *pstream, const char *filename, int flags)

Function

int encoder_stream_create (stream_t *pstream, stream_t iostream, const char *encoding)

Function

int decoder_stream_create (stream_t *pstream, stream_t iostream, const char *encoding)

Function

int stdio_stream_create (stream_t *pstream, FILE* stdio, int flags)

Function

If MU_STREAM_NO_CLOSE is specified, fclose() will not be called on stdio when the stream is closed.

void stream_destroy (stream_t *pstream, void *owner)

Function

int stream_open (stream_t stream)

Function

int stream_close (stream_t stream)

Function

int stream_is_seekable (stream_t stream)

Function

int stream_get_fd (stream_t stream, int *pfd)

Function

int stream_read (stream_t stream, char *buffer, size_t buflen, off_t offset, size_t *pwriten)

Function

int stream_readline (stream_t stream, char *buffer, size_t buflen, off_t offset, size_t *pwriten)

Function

int stream_size (stream_t stream, off_t *psize)

Function

int stream_truncate (stream_t stream, off_t size)

Function

int stream_write (stream_t stream, const char *buffer, size_t buflen, off_t offset, size_t *pwriten)

Function

int stream_setbufsiz (stream_t stream, size_t size)

Function

int stream_flush (stream_t stream)

Function

These functions will typically only be useful to implementors of streams.

int stream_create (stream_t *pstream, int flags, void *owner)

Function

Used to implement a new kind of stream.

int stream_get_flags (stream_t stream, int *pflags)

Function

int stream_get_state (stream_t stream, int *pstate)

Function

MU_STREAM_STATE_OPEN Last action was stream_open. MU_STREAM_STATE_READ Last action was stream_read or stream_readline. MU_STREAM_STATE_WRITE Last action was stream_write. MU_STREAM_STATE_CLOSE Last action was stream_close.

An example using tcp_stream_create to make a simple web client:

/* This is an example program to illustrate the use of stream functions.
   It connects to a remote HTTP server and prints the contents of its
   index page */
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>

#include <mailutils/mailutils.h>

const char *wbuf = "GET / HTTP/1.0\r\n\r\n";
char rbuf[1024];

int
main ()
{
  int ret, off = 0, fd;
  stream_t stream;
  size_t nb;
  fd_set fds;

  ret = tcp_stream_create (&stream, "www.gnu.org", 80, MU_STREAM_NONBLOCK);
  if (ret != 0)
    {
      mu_error ( "tcp_stream_create: %s\n", mu_errstring (ret));
      exit (EXIT_FAILURE);
    }

connect_again:
  ret = stream_open (stream);
  if (ret != 0)
    {
      if (ret == EAGAIN)
        {
          ret = stream_get_fd (stream, &fd);
          if (ret != 0)
            {
              mu_error ( "stream_get_fd: %s\n", mu_errstring (ret));
              exit (EXIT_FAILURE);
            }
          FD_ZERO (&fds);
          FD_SET (fd, &fds);
          select (fd + 1, NULL, &fds, NULL, NULL);
          goto connect_again;
        }
      mu_error ( "stream_open: %s\n", mu_errstring (ret));
      exit (EXIT_FAILURE);
    }

  ret = stream_get_fd (stream, &fd);
  if (ret != 0)
    {
      mu_error ( "stream_get_fd: %s\n", mu_errstring (ret));
      exit (EXIT_FAILURE);
    }

write_again:
  ret = stream_write (stream, wbuf + off, strlen (wbuf), 0, &nb);
  if (ret != 0)
    {
      if (ret == EAGAIN)
        {
          FD_ZERO (&fds);
          FD_SET (fd, &fds);
          select (fd + 1, NULL, &fds, NULL, NULL);
          off += nb;
          goto write_again;
        }
      mu_error ( "stream_write: %s\n", mu_errstring (ret));
      exit (EXIT_FAILURE);
    }

  if (nb != strlen (wbuf))
    {
      mu_error ( "stream_write: %s\n", "nb != wbuf length");
      exit (EXIT_FAILURE);
    }

  do
    {
      ret = stream_read (stream, rbuf, sizeof (rbuf), 0, &nb);
      if (ret != 0)
        {
          if (ret == EAGAIN)
            {
              FD_ZERO (&fds);
              FD_SET (fd, &fds);
              select (fd + 1, &fds, NULL, NULL, NULL);
            }
          else
            {
              mu_error ( "stream_read: %s\n", mu_errstring (ret));
              exit (EXIT_FAILURE);
            }
        }
      write (2, rbuf, nb);
    }
  while (nb || ret == EAGAIN);

  ret = stream_close (stream);
  if (ret != 0)
    {
      mu_error ( "stream_close: %s\n", mu_errstring (ret));
      exit (EXIT_FAILURE);
    }

  stream_destroy (&stream, NULL);
  exit (EXIT_SUCCESS);
}