1

/**

     2

 * @file

     3

 *

     4

 * A read-only sock_stream implementation for linux fifo(7).

     5

 */

     6

#include "sock_fd.h"

     7

     8

#include <stdlib.h>

     9

#include <sys/types.h>

    10

#include <sys/stat.h>

    11

#include <fcntl.h>

    12

#include <string.h>

    13

    14

struct fifo {

    15

    /** The base fd operations */

    16

    struct sock_fd base_fd;

    17

    18

    /** The path to the fifo */

    19

    char *path;

    20

};

    21

    22

/**

    23

 * Get a sock_fd pointer from a sock_fifo pointer

    24

 */

    25

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

    26

    27

/**

    28

 * Get a sock_base pointer from a sock_fifo pointer

    29

 */

    30

#define FIFO_BASE(sock_ptr) SOCK_FD_BASE(FIFO_FD(sock_ptr))

    31

    32

/**

    33

 * Get the sock_stream.err pointer from a sock_fifo pointer

    34

 */

    35

#define FIFO_ERR(sock_ptr) SOCK_ERR(FIFO_BASE(sock_ptr))

    36

    37

    38

    39

/**

    40

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

    41

 */

    42

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

    43

{

    44

    int fd;

    45

    46

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

    47

    // XXX: hardoded read-only

    48

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

    49

        RETURN_SET_ERROR_ERRNO(err, ERR_OPEN);

    50

    51

    // set the new fd

    52

    if ((ERROR_CODE(err) = sock_fd_set(FIFO_FD(fifo), fd)))

    53

        return ERROR_CODE(err);

    54

    55

    // ok

    56

    return SUCCESS;

    57

}

    58

    59

/**

    60

 * Destroy the fifo, releasing all resources

    61

 */

    62

static void fifo_destroy (struct fifo *fifo)

    63

{

    64

    // close if open

    65

    if (FIFO_FD(fifo)->fd >= 0)

    66

        sock_fd_close(FIFO_FD(fifo));

    67

    68

    // release the path

    69

    free(fifo->path);

    70

    free(fifo);

    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 (struct sock_stream *base_sock, void *buf, size_t *len, struct error_info *err)

    79

{

    80

    struct fifo *fifo = SOCK_FROM_BASE(base_sock, struct fifo);

    81

    82

    // passthru ERR_READ_EOF unless it's READ_EOF

    83

    if (sock_fd_read(base_sock, buf, len, err) != ERR_READ_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_release (struct sock_stream *base_sock)

   104

{

   105

    struct fifo *fifo = SOCK_FROM_BASE(base_sock, struct fifo);

   106

   107

    fifo_destroy(fifo);

   108

}

   109

   110

/*

   111

 * Our sock_stream_type

   112

 */

   113

static struct sock_stream_type fifo_stream_type = {

   114

    .methods                = {

   115

        .read               = &fifo_read,

   116

        .write              = NULL,

   117

        .event_init         = &sock_fd_event_init,

   118

        .event_enable       = &sock_fd_event_enable,

   119

        .release            = &fifo_release,

   120

    },

   121

};

   122

   123

err_t fifo_open_read (struct sock_stream **stream_ptr, const char *path, struct error_info *err)

   124

{

   125

    struct fifo *fifo;

   126

   127

    // alloc

   128

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

   129

        return SET_ERROR(err, ERR_CALLOC);

   130

   131

    // copy the path

   132

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

   133

        return SET_ERROR(err, ERR_STRDUP);

   134

   135

    // init

   136

    sock_stream_init(FIFO_BASE(fifo), &fifo_stream_type, NULL, NULL);

   137

    sock_fd_init(FIFO_FD(fifo), -1);

   138

   139

    // open the fifo

   140

    if (fifo_open(fifo, err))

   141

        goto error;

   142

   143

    // ok

   144

    *stream_ptr = FIFO_BASE(fifo);

   145

   146

    return SUCCESS;

   147

   148

error:

   149

    // cleanup

   150

    fifo_destroy(fifo);

   151

   152

    return ERROR_CODE(err);

   153

}