1

#include <arpa/inet.h>

     2

#include <sys/socket.h>

     3

#include <sys/types.h>

     4

#include <fcntl.h>

     5

#include <netdb.h>

     6

#include <stdio.h>

     7

#include <unistd.h>

     8

#include <errno.h>

     9

#include <assert.h>

    10

    11

    12

#include "socket.h"

    13

#include "common.h"

    14

    15

#define _SOCKOP_SOCKET 0x01

    16

#define _SOCKOP_ENDPOINT_BIND 0x02

    17

#define _SOCKOP_ENDPOINT_CONNECT 0x04

    18

#define _SOCKOP_LISTEN 0x08

    19

#define _SOCKOP_FLAGS_PASSIVE 0x10

    20

#define _SOCKOP_FCNTL_NONBLOCK 0x20

    21

    22

enum socket_op {

    23

    /*

    24

     * Just resolve the address, don't create a socket

    25

     */

    26

    SOCKOP_RESOLVE = _SOCKOP_FLAGS_PASSIVE,

    27

    28

    /*

    29

     * Create a socket whose local end is bound to the given endpoint, and listening

    30

     */

    31

    SOCKOP_LISTEN = _SOCKOP_FLAGS_PASSIVE | _SOCKOP_SOCKET | _SOCKOP_ENDPOINT_BIND | _SOCKOP_LISTEN,

    32

    33

    /*

    34

     * Create a socket whose remote end is connected to the given endpoint, and connected

    35

     */

    36

    SOCKOP_CONNECT = _SOCKOP_SOCKET | _SOCKOP_ENDPOINT_CONNECT,

    37

    38

    /*

    39

     * Create a socket and initiate a nonblocking connect to the given endpoint

    40

     */

    41

    SOCKOP_CONNECT_ASYNC = _SOCKOP_SOCKET | _SOCKOP_FCNTL_NONBLOCK | _SOCKOP_ENDPOINT_CONNECT,

    42

};

    43

    44

static int _socket_do (struct config_endpoint *endpoint, int *sock, int sock_type, struct sockaddr_storage *addr, enum socket_op sockop);

    45

    46

/*

    47

 * Create a socket of the given type that's listening on the given endpoint

    48

 */

    49

int socket_listen (struct config_endpoint *endpoint, int sock_type) {

    50

    int sock = -1;

    51

    struct sockaddr_storage addr;

    52

    53

    // and then _socket_do

    54

    if (_socket_do(endpoint, &sock, sock_type, &addr, SOCKOP_LISTEN))

    55

        return -1;

    56

    57

    // just return the socket, discard addr

    58

    return sock;

    59

}

    60

    61

/*

    62

 * Initiate an async connect to the given endpoint for the given socket type. This should work for

    63

 * PF_INET and PF_LOCAL sockets, and in both cases, socket writeability should indicate that the

    64

 * connect succeeded.

    65

 *

    66

 * XXX: Currently it looks up the endpoint each time - the working addrinfo should be cached

    67

 */

    68

int socket_connect_async (struct config_endpoint *endpoint, int sock_type) {

    69

    int sock = -1;

    70

    struct sockaddr_storage addr;

    71

    72

    // and then _socket_do

    73

    if (_socket_do(endpoint, &sock, sock_type, &addr, SOCKOP_CONNECT_ASYNC))

    74

        return -1;

    75

    76

    // return the socket

    77

    return sock;

    78

}

    79

    80

/*

    81

 * Check if the given socket has an error condition set, mostly intended for use with socket_connect_async.

    82

 *

    83

 * Returns 0 and sets *error on success (zero = no error, nonzero = error), -1 on failure (invalid socket).

    84

 */

    85

int socket_check_error (int sock, int *error) {

    86

    socklen_t optlen = sizeof(*error);

    87

    88

    if (getsockopt(sock, SOL_SOCKET, SO_ERROR, error, &optlen))

    89

        PERROR("getsockopt");

    90

    91

    return 0;

    92

    93

error:

    94

    return -1;

    95

}

    96

    97

    98

/*

    99

 * Do something to apply an endpoint to a socket

   100

 */

   101

static int _socket_do (struct config_endpoint *endpoint, int *sock, int sock_type, struct sockaddr_storage *addr, enum socket_op sockop) {

   102

    struct addrinfo *res = NULL, *info, _fake_res;

   103

    struct sockaddr_un _fake_addr_un;

   104

    int err = -1;

   105

   106

    if (endpoint->family == PF_UNIX) {

   107

        // getaddrinfo doesn't handle PF_UNIX, so we need to build a fake result

   108

   109

        // build the sockaddr_un

   110

        _fake_addr_un.sun_family = endpoint->family;

   111

        memcpy(_fake_addr_un.sun_path, endpoint->af.local.path, sizeof(_fake_addr_un.sun_path));

   112

   113

        // build the fake addrinfo res

   114

        _fake_res.ai_flags = 0;

   115

        _fake_res.ai_family = PF_UNIX;

   116

        _fake_res.ai_socktype = sock_type;

   117

        _fake_res.ai_protocol = 0;

   118

        _fake_res.ai_addrlen = SUN_LEN(&_fake_addr_un);

   119

        _fake_res.ai_addr = (struct sockaddr *) &_fake_addr_un;

   120

        _fake_res.ai_canonname = (char *) endpoint->af.local.path;  /* XXX: not const */

   121

        _fake_res.ai_next = NULL;

   122

   123

        res = &_fake_res;

   124

   125

    } else if (endpoint->family == PF_INET) {

   126

        // use the real getaddrinfo

   127

   128

        struct addrinfo hints;

   129

        memset(&hints, 0, sizeof(hints));

   130

   131

        hints.ai_socktype = sock_type;

   132

        hints.ai_protocol = 0;

   133

        hints.ai_flags = (sockop & _SOCKOP_FLAGS_PASSIVE ? AI_PASSIVE : 0) | AI_CANONNAME;

   134

   135

        int err;

   136

   137

        // check that we have a service, doesn't make any sense without

   138

        if (!endpoint->af.inet.port)

   139

            ERROR("no service specified");

   140

   141

        if ((err = getaddrinfo(endpoint->af.inet.addr, endpoint->af.inet.port, &hints, &res)) != 0)

   142

            ERROR("getaddrinfo: %s#%s: %s", endpoint->af.inet.addr, endpoint->af.inet.port, gai_strerror(err));

   143

   144

    } else {

   145

        ERROR("invalid endpoint");

   146

    }

   147

   148

    for (info = res; info; info = info->ai_next) {

   149

        if (sockop & _SOCKOP_SOCKET && (*sock = socket(info->ai_family, info->ai_socktype, info->ai_protocol)) == -1) {

   150

            PWARNING("socket(%d, %s)", info->ai_family, info->ai_canonname);

   151

            continue;

   152

        }

   153

   154

        if (sockop & _SOCKOP_FCNTL_NONBLOCK && fcntl(*sock, F_SETFL, O_NONBLOCK) == -1) {

   155

            PWARNING("fcntl(%d, %s, F_SETFL O_NONBLOCK)", info->ai_family, info->ai_canonname);

   156

            close(*sock); *sock = -1;

   157

            continue;

   158

        }

   159

   160

        if (sockop & _SOCKOP_ENDPOINT_BIND && bind(*sock, info->ai_addr, info->ai_addrlen) == -1) {

   161

            PWARNING("bind(%d, %s)", info->ai_family, info->ai_canonname);

   162

            close(*sock); *sock = -1;

   163

            continue;

   164

        }

   165

   166

        if (sockop & _SOCKOP_LISTEN && listen(*sock, SOCKET_LISTEN_BACKLOG) == -1) {

   167

            PWARNING("listen(%d, %s)", info->ai_family, info->ai_canonname);

   168

            close(*sock); *sock = -1;

   169

            continue;

   170

        }

   171

   172

        if (sockop & _SOCKOP_ENDPOINT_CONNECT && connect(*sock, info->ai_addr, info->ai_addrlen) == -1) {

   173

            if (sockop & _SOCKOP_FCNTL_NONBLOCK && errno == EINPROGRESS) {

   174

                /* to be expected */

   175

   176

            } else {

   177

                PWARNING("connect(%d, %s)", info->ai_family, info->ai_canonname);

   178

                close(*sock); *sock = -1;

   179

                continue;

   180

            }

   181

        }

   182

   183

        // copy the succesfull address over

   184

        memcpy(addr, info->ai_addr, info->ai_addrlen);

   185

   186

        // exit the loop with a valid socket

   187

        assert(*sock != -1);

   188

        break;

   189

    }

   190

   191

    if (*sock == -1)

   192

        ERROR("no working results from getaddrinfo: %s#%s", endpoint->af.inet.addr, endpoint->af.inet.port);

   193

   194

    // success

   195

    err = 0;

   196

   197

error:

   198

    if (res != 0 && res != &_fake_res)

   199

        freeaddrinfo(res);

   200

   201

    return err;

   202

}   

   203