1

     2

#include "sock_tcp.h"

     3

     4

#include <stdlib.h>

     5

#include <sys/types.h>

     6

#include <sys/socket.h>

     7

#include <netdb.h>

     8

#include <unistd.h>

     9

#include <string.h>

    10

#include <assert.h>

    11

    12

/*

    13

 * Our sock_stream_methods.read method

    14

 */

    15

static err_t sock_tcp_read (struct sock_stream *base_sock, void *buf, size_t len)

    16

{

    17

    struct sock_tcp *sock = SOCK_FROM_BASE(base_sock, struct sock_tcp);

    18

    int ret;

    19

    20

    // map directly to read(2)

    21

    if ((ret = read(sock->fd, buf, len)) < 0)

    22

        // errno

    23

        RETURN_SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_READ);

    24

    25

    else 

    26

        // bytes read

    27

        return ret;

    28

}

    29

    30

/*

    31

 * Our sock_stream_methods.write method

    32

 */

    33

static err_t sock_tcp_write (struct sock_stream *base_sock, const void *buf, size_t len)

    34

{

    35

    struct sock_tcp *sock = SOCK_FROM_BASE(base_sock, struct sock_tcp);

    36

    int ret;

    37

    38

    // map directly to write(2)

    39

    if ((ret = write(sock->fd, buf, len)) < 0)

    40

        // errno

    41

        RETURN_SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_WRITE);

    42

    43

    else

    44

        // bytes read

    45

        return ret;

    46

}

    47

    48

/*

    49

 * Our sock_stream_type

    50

 */

    51

struct sock_stream_type sock_tcp_type = {

    52

    .methods.read   = &sock_tcp_read,

    53

    .methods.write  = &sock_tcp_write,

    54

};

    55

    56

err_t sock_tcp_alloc (struct sock_tcp **sock_ptr)

    57

{

    58

    // alloc

    59

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

    60

        return ERR_CALLOC;

    61

    62

    // initialize base with sock_tcp_type

    63

    sock_stream_init(SOCK_TCP_BASE(*sock_ptr), &sock_tcp_type);

    64

    65

    // done

    66

    return SUCCESS;

    67

}

    68

    69

err_t sock_tcp_init_fd (struct sock_tcp *sock, int fd)

    70

{

    71

    // valid fd -XXX: err instead?

    72

    assert(fd >= 0);

    73

    74

    // initialize

    75

    sock->fd = fd;

    76

    77

    // done

    78

    return SUCCESS;

    79

}

    80

    81

err_t sock_tcp_init_connect (struct sock_tcp *sock, const char *hostname, const char *service)

    82

{

    83

    struct addrinfo hints, *res, *r;

    84

    int err;

    85

    RESET_ERROR(SOCK_TCP_ERR(sock));

    86

    87

    // hints

    88

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

    89

    hints.ai_family = AF_UNSPEC;

    90

    hints.ai_socktype = SOCK_STREAM;

    91

    92

    // resolve

    93

    if ((err = getaddrinfo(hostname, service, &hints, &res)))

    94

        RETURN_SET_ERROR_EXTRA(SOCK_TCP_ERR(sock), ERR_GETADDRINFO, err);

    95

    96

    // try each result in turn

    97

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

    98

        // create the socket

    99

        if ((sock->fd = socket(r->ai_family, r->ai_socktype, r->ai_protocol)) < 0) {

   100

            // remember error

   101

            SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_SOCKET);

   102

   103

            // skip to next one

   104

            continue;

   105

        }

   106

   107

        // connect to remote address

   108

        if (connect(sock->fd, r->ai_addr, r->ai_addrlen)) {

   109

            // remember error

   110

            SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_CONNECT);

   111

   112

            // close/invalidate socket

   113

            close(sock->fd);

   114

            sock->fd = -1;

   115

   116

            // skip to next one

   117

            continue;

   118

        }

   119

   120

        // valid socket, use this

   121

        break;

   122

    }

   123

   124

    // ensure we got some valid socket, else return last error code

   125

    if (sock->fd < 0) {

   126

        // did we hit some error?

   127

        if (IS_ERROR(SOCK_TCP_ERR(sock)))

   128

            // return last error

   129

            return ERROR_CODE(SOCK_TCP_ERR(sock));

   130

   131

        else

   132

            // no results

   133

            return SET_ERROR(SOCK_TCP_ERR(sock), ERR_GETADDRINFO_EMPTY);

   134

    }

   135

   136

    // ok, done

   137

    return 0;    

   138

}

   139

   140

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

   141

{

   142

    struct sock_tcp *sock;

   143

    err_t err;

   144

   145

    // allocate

   146

    if ((err = sock_tcp_alloc(&sock)))

   147

        return err;

   148

   149

    // connect

   150

    if ((err = sock_tcp_init_connect(sock, host, service))) {

   153

   154

        // cleanup

   155

        sock_tcp_release(sock);

   156

   157

        // return error code

   158

        return err;

   159

    }

   160

   161

    // good

   162

    *sock_ptr = SOCK_TCP_BASE(sock);

   163

   164

    return 0;

   165

}

   166

   167

void sock_tcp_release (struct sock_tcp *sock)

   168

{

   169

    // must not be connected

   170

    assert(sock->fd < 0);

   171

   172

    // free

   173

    free(sock);

   174

}