1

#ifndef SOCK_H

     2

#define SOCK_H

     3

     4

/*

     5

 * Low-level socket-related functions

     6

 */

     7

#include "error.h"

     8

#include <sys/types.h>

     9

#include <event2/event.h>

    10

    11

/*

    12

 * The generic socket handle

    13

 */

    14

struct sock_stream;

    15

    16

/*

    17

 * Async callbacks for socket operation

    18

 */

    19

struct sock_stream_callbacks {

    20

    /* Sockeet is readable */

    21

    void (*on_read)(struct sock_stream *sock, void *arg);

    22

    23

    /* Socket is writeable */

    24

    void (*on_write)(struct sock_stream *sock, void *arg);

    25

};

    26

    27

enum sock_error_code {

    28

    _ERR_SOCK_BEGIN = _ERR_SOCK,

    29

    30

    /** socket() error */

    31

    ERR_SOCKET,

    32

    33

    /** connect() error */

    34

    ERR_CONNECT,

    35

    36

    /** read() error */

    37

    ERR_READ,

    38

    39

    /** EOF on read() */

    40

    ERR_READ_EOF,

    41

    42

    /** write() error */

    43

    ERR_WRITE,

    44

    45

    /** EOF on write()  */

    46

    ERR_WRITE_EOF,

    47

    48

    /** Error on fcntl() */

    49

    ERR_FCNTL,

    50

    51

    /** Lingering error on close() */

    52

    ERR_CLOSE,

    53

};

    54

    55

/*

    56

 * Initialize the socket module's global state. Call this before calling any other sock_* functions.

    57

 *

    58

 * The given \a ev_base is the libevent base to use for nonblocking operation.

    59

 */

    60

err_t sock_init (struct event_base *ev_base, struct error_info *err);

    61

    62

/*

    63

 * A simple blocking TCP connect to the given host/service, using getaddrinfo. The connected socket is returned via

    64

 * *sock_ptr. In case of errors, additional error information is stored in *err.

    65

 *

    66

 * @return zero on success, nonzero on error

    67

 *

    68

 * XXX: blocking

    69

 */

    70

err_t sock_tcp_connect (struct sock_stream **sock_ptr, const char *host, const char *service, struct error_info *err);

    71

    72

/*

    73

 * A simple blocking SSL connect to the given host/service. The connected/handshake'd SSL socket is returned via

    74

 * *sock_ptr. In case of errors, additional error information is stored in *err.

    75

 *

    76

 * XXX: blocking

    77

 * XXX: doesn't do any certificate verification.

    78

 */

    79

err_t sock_ssl_connect (struct sock_stream **sock_ptr, const char *host, const char *service, struct error_info *err);

    80

    81

/*

    82

 * The generic read/write API for stream sockets. These are mostly identical to the equivalent read/write syscalls, but

    83

 * the handling of EOF and EAGAIN is different. Normally, these return the (positive) number of bytes written. For

    84

 * EAGAIN, these return zero. For EOF, these return -ERR_READ_EOF/ERR_WRITE_EOF. Otherwise, these return the -ERR_*

    85

 * code.

    86

 */

    87

int sock_stream_read (struct sock_stream *sock, void *buf, size_t len);

    88

int sock_stream_write (struct sock_stream *sock, const void *buf, size_t len);

    89

    90

/*

    91

 * Initialize event-based operation for this sock_stream. This will set the stream into nonblocking mode, and the given

    92

 * callbacks will be fired once enabled using sock_stream_event_enable().

    93

 *

    94

 * Note that the callbacks struct isn't copied - it's used as-is-given.

    95

 */

    96

err_t sock_stream_event_init (struct sock_stream *sock, const struct sock_stream_callbacks *callbacks, void *arg);

    97

    98

/*

    99

 * Enable the events for this sock, as set up earlier with event_init. Mask should contain EV_READ/EV_WRITE.

   100

 *

   101

 * The implementation of this is slightly hazy for complex protocols; this should only be used to map from

   102

 * sock_stream_read/write to the corresponding sock_stream_callback. That is, if sock_stream_read returns zero, then

   103

 * call event_enable(EV_READ), wherepon on_read will later be called.

   104

 */

   105

err_t sock_stream_event_enable (struct sock_stream *sock, short mask);

   106

   107

/**

   108

 * Get current error_info for \a sock.

   109

 */

   110

const struct error_info* sock_stream_error (struct sock_stream *sock);

   111

   112

/**

   113

 * Close and release the given socket, ignoring errors. It must not be used anymore after this.

   114

 *

   115

 * This is intended to be used to abort in case of errors, and does not close the connection cleanly.

   116

 */

   117

void sock_stream_release (struct sock_stream *sock);

   118

   119

#endif