1

#ifndef SOCK_H

     2

#define SOCK_H

     3

     7

 * Low-level socket-related functions

     8

 */

     9

#include "error.h"

    10

#include <sys/types.h>

    11

#include <event2/event.h>

    12

    15

 */

    16

struct sock_stream;

    17

    19

 * Async callbacks for socket operation

    20

 */

    21

struct sock_stream_callbacks {

    23

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

    24

    26

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

    27

};

    28

    32

enum sock_error_code {

    33

    _ERR_SOCK_BEGIN = _ERR_SOCK,

    34

    35

    /** socket() error */

    36

    ERR_SOCKET,

    37

    38

    /** connect() error */

    39

    ERR_CONNECT,

    40

    41

    /** read() error */

    42

    ERR_READ,

    43

    44

    /** EOF on read() */

    45

    ERR_READ_EOF,

    46

    47

    /** write() error */

    48

    ERR_WRITE,

    49

    50

    /** EOF on write()  */

    51

    ERR_WRITE_EOF,

    52

    53

    /** Error on fcntl() */

    54

    ERR_FCNTL,

    55

    56

    /** Lingering error on close() */

    57

    ERR_CLOSE,

    58

};

    59

    61

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

    62

 *

    63

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

    67

 */

    68

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

    69

    71

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

    72

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

    73

 *

    78

 *

    79

 * XXX: blocking

    80

 */

    81

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

    82

    83

/*

    84

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

    85

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

    86

 *

    92

 * XXX: blocking

    93

 * XXX: doesn't do any certificate verification.

    94

 */

    95

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

    96

   110

 */

   111

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

   127

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

   128

   130

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

   131

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

   132

 *

   133

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

   138

 */

   139

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

   140

   143

 *

   144

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

   145

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

   148

 */

   149

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

   150

   151

/**

   152

 * Get current error_info for \a sock.

   153

 */

   154

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

   155

   156

/**

   157

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

   158

 *

   159

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

   160

 */

   161

void sock_stream_release (struct sock_stream *sock);

   162

   163

#endif