1

#include "tcp_internal.h"

     2

#include "sock_internal.h"

     3

#include "log.h"

     4

     5

#include <unistd.h>

     6

     7

/*

     8

 * Service methods

     9

 */

    10

void tcp_server__deinit (service_t *service)

    11

{

    12

    struct tcp_server *serv = service_check(service, &tcp_server_type);

    13

    14

    tcp_server_deinit(serv);

    15

}

    16

    17

/*

    18

 * Service type

    19

 */

    20

const struct service_type tcp_server_type = {

    21

    .base_type = {

    22

        .parent = &service_type_type,

    23

    },

    24

    .methods = {

    25

        .deinit = tcp_server__deinit,

    26

    },

    27

};

    28

    29

/*

    30

 * We got a new client, build a transport for it and give it to the user

    31

 */

    32

static err_t tcp_server_client (struct tcp_server *serv, evutil_socket_t sock, error_t *err)

    33

{

    34

    struct tcp_transport *trans;

    35

    36

    // create a new transport for it, this also makes it nonblocking

    37

    if (tcp_transport_create(&trans, &serv->base_service.info.trans_info, sock, err))

    38

        goto error;

    39

    40

    // make it connected

    41

    // this will call transport_callbacks::on_connect, which is all the user needs

    42

    if (tcp_transport_connected(trans, err))

    43

        goto error;

    44

    45

    // ok

    46

    return SUCCESS;

    47

    48

error:

    49

    // cleanup

    50

    if (trans)

    51

        tcp_transport_destroy(trans);

    52

    53

    return ERROR_CODE(err);    

    54

}

    55

    56

/*

    57

 * Libevent callback

    58

 */

    59

static void tcp_server_on_accept (evutil_socket_t sock, short what, void *arg)

    60

{

    61

    struct tcp_server *serv = arg;

    62

    evutil_socket_t client_sock;

    63

    error_t err;

    64

    65

    (void) what;

    66

    67

    // accept as a new client connection

    68

    if ((client_sock = accept(sock, NULL, NULL)) < 0 && errno != EAGAIN)

    69

        JUMP_SET_ERROR_ERRNO(&err, ERR_ACCEPT);

    70

    71

    // spurious read event?

    72

    if (client_sock < 0)

    73

        return;

    74

    75

    // handle it

    76

    if (tcp_server_client(serv, client_sock, &err))

    77

        goto error;

    78

    79

    // ok

    80

    return;

    81

    82

error:

    83

    if (client_sock >= 0)

    84

        EVUTIL_CLOSESOCKET(client_sock);

    85

    86

    // faaail

    87

    service_error(&serv->base_service, &err);

    88

}

    89

    90

/*

    91

 * Attempts to construct a listen()'d socket with the given addr, and return it

    92

 *

    93

 * @param addr the addrinfo to try and create a socket for

    94

 * @param err returned error info

    95

 * @return listening socket, or -err_t on error

    96

 */

    97

static int tcp_server_sock_addr (struct addrinfo *addr, error_t *err)

    98

{

    99

    evutil_socket_t sock;

   100

   101

    // create the sock

   102

    if ((sock = tcp_sock_create(addr, err)) < 0)

   103

        goto error;

   104

   105

    // bind it

   106

    if (bind(sock, addr->ai_addr, addr->ai_addrlen) < 0)

   107

        JUMP_SET_ERROR_ERRNO(err, ERR_BIND);

   108

   109

    // listen

   110

    if (listen(sock, TCP_SERVER_BACKLOG) < 0)

   111

        JUMP_SET_ERROR_ERRNO(err, ERR_LISTEN);

   112

   113

    // ok, valid socket

   114

    return sock;

   115

   116

error:

   117

    if (sock >= 0)

   118

        // cleanup

   119

        EVUTIL_CLOSESOCKET(sock);

   120

   121

    return -ERROR_CODE(err);

   122

}

   123

   124

/*

   125

 * Construct a listen()'d socket with the given resolver result, and return it.

   126

 *

   127

 * @param rr the resolver lookup result to create a socket for

   128

 * @param err returned error info

   129

 * @return listening socket, or -err_t on error

   130

 */

   131

static int tcp_server_sock (struct resolve_result *rr, error_t *err)

   132

{

   133

    struct addrinfo *addr;

   134

    evutil_socket_t sock;

   135

   136

    // try each addrinfo

   137

    while ((addr = resolve_result_next(rr))) {

   138

        // attempt to construct given socket

   139

        if ((sock = tcp_server_sock_addr(addr, err)) < 0)

   140

            // log an informative error warning

   141

            log_warn_error(err, "%s", resolve_addr_text(addr)); 

   142

   143

        else

   144

            // got a valid socket 

   145

            break;

   146

    }

   147

   148

    if (sock >= 0)

   149

        // valid socket

   150

        return sock;

   151

   152

    else

   153

        // some error occured

   154

        return -ERROR_CODE(err);

   155

}

   156

   157

err_t tcp_server_listen (struct tcp_server *serv, const char *interface, const char *service, error_t *err)

   158

{

   159

    struct resolve_result rr;

   160

    evutil_socket_t sock;

   161

   162

    // get the global event_base

   163

    struct event_base *ev_base = _sock_stream_ctx.ev_base;

   164

   165

    // init the resolver

   166

    resolve_result_init(&rr);

   167

   168

    // resolve the interface/service

   169

    if (resolve_addr(&rr, interface, service, SOCK_STREAM, AI_PASSIVE, err))

   170

        return ERROR_CODE(err);

   171

   172

    // create the socket

   173

    if ((sock = tcp_server_sock(&rr, err)) < 0)

   174

        goto error;

   175

   176

    // deinit lookup results

   177

    resolve_result_deinit(&rr);

   178

   179

    // make it nonblocking

   180

    if (evutil_make_socket_nonblocking(sock))

   181

        JUMP_SET_ERROR_STR(err, ERR_MISC, "evutil_make_socket_nonblocking");

   182

   183

    // construct event for the sock

   184

    if ((serv->ev = event_new(ev_base, sock, EV_READ | EV_PERSIST, tcp_server_on_accept, serv)) == NULL)

   185

        JUMP_SET_ERROR(err, ERR_EVENT_NEW);

   186

   187

    // add it

   188

    if (event_add(serv->ev, NULL))

   189

        JUMP_SET_ERROR(err, ERR_EVENT_ADD);

   190

   191

    // ok

   192

    return SUCCESS;

   193

   194

error:

   195

    // deinit results just to be sure

   196

    resolve_result_deinit(&rr);

   197

   198

    if (sock >= 0 && !serv->ev)

   199

        // need to close socket ourselves, because we couldn't register our event for it

   200

        EVUTIL_CLOSESOCKET(sock);

   201

   202

    // general cleanup

   203

    tcp_server_deinit(serv);

   204

   205

    return ERROR_CODE(err);

   206

}

   207

   208

void tcp_server_deinit (struct tcp_server *serv)

   209

{

   210

    if (serv->ev) {

   211

        // ignore errors

   212

        event_del(serv->ev);

   213

   214

        // ignore errors

   215

        close(event_get_fd(serv->ev));

   216

   217

        // release event

   218

        event_free(serv->ev);

   219

   220

        // invalidate

   221

        serv->ev = NULL;

   222

    }

   223

}

   224

   225

static void tcp_server_destroy (struct tcp_server *serv)

   226

{

   227

    tcp_server_deinit(serv);

   228

   229

    free(serv);

   230

}

   231

   232

/*

   233

 * Public interface

   234

 */

   235

err_t tcp_listen (const struct service_info *info, service_t **service_ptr, 

   236

        const char *interface, const char *service, error_t *err)

   237

{

   238

    struct tcp_server *serv;

   239

   240

    // alloc

   241

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

   242

        return SET_ERROR(err, ERR_MEM);

   243

   244

    // init service

   245

    service_init(&serv->base_service, &tcp_server_type, info);

   246

   247

    // init ourselves

   248

    if (tcp_server_listen(serv, interface, service, err))

   249

        goto error;

   250

   251

    // ok

   252

    *service_ptr = &serv->base_service;

   253

   254

    return SUCCESS;

   255

   256

error:

   257

    tcp_server_destroy(serv);

   258

   259

    return ERROR_CODE(err);

   260

}