1 

     2 #include "fifo.h"

     3 #include "transport_fd.h"

     4 

     5 #include <stdlib.h>

     6 #include <sys/types.h>

     7 #include <sys/stat.h>

     8 #include <fcntl.h>

     9 #include <string.h>

    10 

    11 /**

    12  * Our transport_type

    13  */

    14 extern const struct transport_type fifo_type;

    15 

    16 /**

    17  * The fifo state

    18  */

    19 struct fifo {

    20     /** The FD-based state */

    21     struct transport_fd base_fd;

    22     

    23     /** Path to the fifo */

    24     char *path;

    25 };

    26 

    27 /**

    28  * (re)open the fifo, closing it if already open, and keeping any event callbacks registered.

    29  */

    30 static err_t fifo_open (struct fifo *fifo, error_t *err)

    31 {

    32     int _fd;

    33 

    34     // open(2) the path in non-blocking read-only mode

    35     if ((_fd = open(fifo->path, O_RDONLY | O_NONBLOCK)) < 0)

    36         RETURN_SET_ERROR_ERRNO(err, ERR_OPEN);

    37 

    38     // set the new fd

    39     if ((ERROR_CODE(err) = transport_fd_set(&fifo->base_fd, _fd)))

    40         return ERROR_CODE(err);

    41     

    42     // use default transport event-based behaviour

    43     if ((ERROR_CODE(err) = transport_fd_defaults(&fifo->base_fd)))

    44         return ERROR_CODE(err);

    45 

    46     // ok

    47     return SUCCESS;

    48 }

    49 

    50 /**

    51  * Deinit the fifo, releasing all resources

    52  */

    53 static void fifo_deinit (struct fifo *fifo)

    54 {

    55     // deinit base

    56     transport_fd_deinit(&fifo->base_fd);

    57 

    58     // release the path

    59     free(fifo->path);

    60 

    61     fifo->path = NULL;

    62 }

    63 

    64 /**

    65  * sock_stream_methods::read implementation.

    66  *

    67  * Try and do a normal sock_fd_read call, but re-open with EAGAIN on EOF

    68  */

    69 err_t fifo_read (transport_t *transport, void *buf, size_t *len, struct error_info *err)

    70 {

    71     struct fifo *fifo = transport_check(transport, &fifo_type);

    72 

    73     // trap READ_EOF

    74     if (transport_fd__read(transport, buf, len, err) != ERR_EOF)

    75         return ERROR_CODE(err);

    76     

    77     // re-open it

    78     // XXX: re-add events?

    79     if (fifo_open(fifo, err))

    80         goto error;

    81 

    82     // ok, act as if it was EAGAIN

    83     *len = 0;

    84 

    85     return SUCCESS;

    86 

    87 error:

    88     return ERROR_CODE(err);

    89 }

    90 

    91 /**

    92  * sock_stream_methods::release implementation

    93  */

    94 static void fifo__deinit (transport_t *transport)

    95 {

    96     struct fifo *fifo = transport_check(transport, &fifo_type);

    97     

    98     fifo_deinit(fifo);

    99 }

   100 

   101 /*

   102  * Our sock_stream_type

   103  */

   104 const struct transport_type fifo_type = {

   105     .base_type = {

   106         .parent     = &transport_fd_type.base_type,

   107     },

   108     .methods = {

   109         .read       = fifo_read,

   110         .write      = NULL,

   111         .events     = transport_fd__events,

   112         .deinit     = fifo__deinit,

   113     },

   114 };

   115 

   116 /**

   117  * Deinit and free

   118  */

   119 static void fifo_destroy (struct fifo *fifo)

   120 {

   121     fifo_deinit(fifo);

   122 

   123     free(fifo);

   124 }

   125 

   126 err_t fifo_open_read (struct transport_info *transport_info, transport_t **transport_ptr, struct event_base *ev_base,

   127         const char *path, error_t *err)

   128 {

   129     struct fifo *fifo;

   130 

   131     // alloc

   132     if ((fifo = calloc(1, sizeof(*fifo))) == NULL)

   133         return SET_ERROR(err, ERR_CALLOC);

   134 

   135     // copy the path

   136     if ((fifo->path = strdup(path)) == NULL)

   137         return SET_ERROR(err, ERR_STRDUP);

   138 

   139     // init

   140     transport_init(&fifo->base_fd.base, &fifo_type, transport_info);

   141     transport_fd_init(&fifo->base_fd, ev_base, TRANSPORT_FD_INVALID);

   142     

   143     // open the fifo

   144     if (fifo_open(fifo, err))

   145         goto error;

   146 

   147     // ok

   148     *transport_ptr = &fifo->base_fd.base;

   149 

   150     return SUCCESS;

   151 

   152 error:

   153     // cleanup

   154     fifo_destroy(fifo);

   155 

   156     return ERROR_CODE(err);

   157 }