3.1.9 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_SEEKABLE

MU_STREAM_NO_CLOSE

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

MU_STREAM_ALLOW_LINKS

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 <stdio.h>
     #include <stdlib.h>
     #include <string.h>
     #include <errno.h>
     #include <unistd.h>
     
     #include <mailutils/mailutils.h>
     
     const char *wbuf = "GET / HTTP/1.0\r\n\r\n";
     char rbuf[1024];
     
     int
     main (void)
     {
       int ret, off = 0;
       stream_t stream;
       size_t nb;
     
       ret = tcp_stream_create (&stream, "www.gnu.org", 80, MU_STREAM_NONBLOCK);
       if (ret != 0)
         {
           mu_error ("tcp_stream_create: %s", mu_strerror (ret));
           exit (EXIT_FAILURE);
         }
     
     connect_again:
       ret = stream_open (stream);
       if (ret != 0)
         {
           if (ret == EAGAIN)
             {
     	  int wflags = MU_STREAM_READY_WR;
     	  stream_wait (stream, &wflags, NULL);
               goto connect_again;
             }
           mu_error ("stream_open: %s", mu_strerror (ret));
           exit (EXIT_FAILURE);
         }
     
     write_again:
       ret = stream_write (stream, wbuf + off, strlen (wbuf), 0, &nb);
       if (ret != 0)
         {
           if (ret == EAGAIN)
             {
     	  int wflags = MU_STREAM_READY_WR;
     	  stream_wait (stream, &wflags, NULL);
               off += nb;
               goto write_again;
             }
           mu_error ("stream_write: %s", mu_strerror (ret));
           exit (EXIT_FAILURE);
         }
     
       if (nb != strlen (wbuf))
         {
           mu_error ("stream_write: %s", "nb != wbuf length");
           exit (EXIT_FAILURE);
         }
     
       do
         {
           ret = stream_read (stream, rbuf, sizeof (rbuf), 0, &nb);
           if (ret != 0)
             {
               if (ret == EAGAIN)
                 {
     	      int wflags = MU_STREAM_READY_RD;
     	      stream_wait (stream, &wflags, NULL);
                 }
               else
                 {
                   mu_error ("stream_read: %s", mu_strerror (ret));
                   exit (EXIT_FAILURE);
                 }
             }
           write (1, rbuf, nb);
         }
       while (nb || ret == EAGAIN);
     
       ret = stream_close (stream);
       if (ret != 0)
         {
           mu_error ("stream_close: %s", mu_strerror (ret));
           exit (EXIT_FAILURE);
         }
     
       stream_destroy (&stream, NULL);
       exit (EXIT_SUCCESS);
     }