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

 * Get a sock_fd pointer from a sock_fifo pointer

    29

 */

    30

#define FIFO_FD(sock_ptr) (&(sock_ptr)->base_fd)

    31

    32

/**

    33

 * Get a sock_base pointer from a sock_fifo pointer

    34

 */

    35

#define FIFO_TRANSPORT(sock_ptr) TRANSPORT_FD_BASE(FIFO_FD(sock_ptr))

    36

    37

    38

/**

    39

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

    40

 */

    41

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

    42

{

    43

    int _fd;

    44

    45

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

    46

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

    47

        RETURN_SET_ERROR_ERRNO(err, ERR_OPEN);

    48

    49

    // set the new fd

    50

    if ((ERROR_CODE(err) = transport_fd_set(FIFO_FD(fifo), _fd)))

    51

        return ERROR_CODE(err);

    52

    53

    // use default transport event-based behaviour

    54

    if ((ERROR_CODE(err) = transport_fd_defaults(FIFO_FD(fifo))))

    55

        return ERROR_CODE(err);

    56

    57

    // ok

    58

    return SUCCESS;

    59

}

    60

    61

/**

    62

 * Destroy the fifo, releasing all resources

    63

 */

    64

static void fifo_destroy (struct fifo *fifo)

    65

{

    66

    // destroy base

    67

    transport_fd_destroy(FIFO_FD(fifo));

    68

    69

    // release the path

    70

    free(fifo->path);

    71

}

    72

    73

/**

    74

 * sock_stream_methods::read implementation.

    75

 *

    76

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

    77

 */

    78

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

    79

{

    80

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

    81

    82

    // trap READ_EOF

    83

    if (transport_fd_methods_read(transport, buf, len, err) != ERR_EOF)

    84

        return ERROR_CODE(err);

    85

    86

    // re-open it

    87

    // XXX: re-add events?

    88

    if (fifo_open(fifo, err))

    89

        goto error;

    90

    91

    // ok, act as if it was EAGAIN

    92

    *len = 0;

    93

    94

    return SUCCESS;

    95

    96

error:

    97

    return ERROR_CODE(err);

    98

}

    99

   100

/**

   101

 * sock_stream_methods::release implementation

   102

 */

   103

static void _fifo_destroy (transport_t *transport)

   104

{

   105

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

   106

   107

    fifo_destroy(fifo);

   108

}

   109

   110

/*

   111

 * Our sock_stream_type

   112

 */

   113

const struct transport_type fifo_type = {

   115

    .methods                = {

   116

        .read               = fifo_read,

   117

        .write              = NULL,

   118

        .events             = transport_fd_methods_events,

   119

        .destroy            = _fifo_destroy,

   120

    },

   121

};

   122

   123

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

   124

        const char *path, error_t *err)

   125

{

   126

    struct fifo *fifo;

   127

   128

    // alloc

   129

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

   130

        return SET_ERROR(err, ERR_CALLOC);

   131

   132

    // copy the path

   133

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

   134

        return SET_ERROR(err, ERR_STRDUP);

   135

   136

    // init

   137

    transport_init(FIFO_TRANSPORT(fifo), &fifo_type, transport_info);

   138

    transport_fd_init(FIFO_FD(fifo), ev_base, TRANSPORT_FD_INVALID);

   139

   140

    // open the fifo

   141

    if (fifo_open(fifo, err))

   142

        goto error;

   143

   144

    // ok

   145

    *transport_ptr = FIFO_TRANSPORT(fifo);

   146

   147

    return SUCCESS;

   148

   149

error:

   150

    // cleanup

   151

    fifo_destroy(fifo);

   152

   153

    return ERROR_CODE(err);

   154

}