1 #include "tcp_internal.h"

     2 #include "log.h"

     3 

     4 /*

     5  * Our transport methods

     6  */

     7 static void tcp_client__deinit (transport_t *transport)

     8 {

     9     struct tcp_client *client = transport_check(transport, &tcp_client_type);

    10     

    11     // proxy

    12     tcp_client_deinit(client);

    13 }

    14 

    15 /*

    16  * Our transport_type

    17  */

    18 const struct transport_type tcp_client_type = {

    19     .base_type = {

    20         .parent             = &tcp_transport_type.base_type,

    21     },

    22     .methods                = {

    23         .read               = transport_fd__read,

    24         .write              = transport_fd__write,

    25         .events             = transport_fd__events,

    26         .deinit             = tcp_client__deinit,

    27     },

    28 };

    29 

    30 /*

    31  * Forward-declare 

    32  */

    33 static void tcp_client_on_connect (struct transport_fd *fd, short what, void *arg);

    34 

    35 /*

    36  * Function implementations

    37  */

    38 void tcp_client_init (struct tcp_client *client)

    39 {

    40     tcp_transport_init(&client->base_trans, -1);

    41     

    42     resolve_result_init(&client->rr);

    43 }

    44 

    45 /*

    46  * Start connecting to the given address in a non-blocking fashion. Returns any errors that immediately crop up,

    47  * otherwise eventually calls tcp_client_connect_done().

    48  */

    49 static err_t tcp_client_connect_addr (struct tcp_client *client, struct addrinfo *addr, error_t *err)

    50 {

    51     struct transport_fd *_fd = &client->base_trans.base_fd;

    52     int ret;

    53     evutil_socket_t sock;

    54     err_t tmp;

    55 

    56     // first, create the socket

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

    58         return ERROR_CODE(err);

    59 

    60     // set it as our sock

    61     if ((ERROR_CODE(err) = transport_fd_set(_fd, sock)))

    62         goto error;

    63 

    64     // then, set it up as nonblocking

    65     if ((ERROR_CODE(err) = transport_fd_nonblock(_fd, true)))

    66         goto error;

    67 

    68     // then, initiate the connect

    69     if ((ret = connect(sock, addr->ai_addr, addr->ai_addrlen)) < 0 && errno != EINPROGRESS) 

    70         JUMP_SET_ERROR_ERRNO(err, ERR_CONNECT);

    71     

    72     if (ret < 0) {

    73         // ok, connect started, setup our completion callback

    74         if ((ERROR_CODE(err) = transport_fd_setup(_fd, tcp_client_on_connect, client)))

    75             goto error;

    76     

    77         // enable for write

    78         if ((ERROR_CODE(err) = transport_fd_enable(_fd, TRANSPORT_WRITE)))

    79             goto error;

    80 

    81     } else {

    82         // oops... blocking connect - fail to avoid confusion

    83         // XXX: come up with a better error name to use

    84         // XXX: support non-async connects as well

    85         JUMP_SET_ERROR_EXTRA(err, ERR_CONNECT, EINPROGRESS);

    86     }

    87     

    88     // ok

    89     return SUCCESS;

    90 

    91 error:

    92     // close the stuff we did open

    93     if ((tmp = transport_fd_close(_fd)))

    94         log_warn("error closing socket after connect error: %s", error_name(tmp));

    95 

    96     return ERROR_CODE(err);

    97 }

    98 

    99 

   100 /*

   101  * Attempt to connect to the next addrinfo, or the next one, if that fails, etc.

   102  *

   103  * This does not call transport_connected().

   104  */

   105 static err_t tcp_client_connect_continue (struct tcp_client *client, error_t *err)

   106 {

   107     struct addrinfo *addr;

   108 

   109     // try and connect to each one until we find one that works

   110     while ((addr = resolve_result_next(&client->rr))) {

   111         // attempt to start connect

   112         if (tcp_client_connect_addr(client, addr, err) == SUCCESS)

   113             break;

   114 

   115         // log a warning on the failed connect

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

   117     }

   118     

   119 

   120     if (addr)

   121         // we succesfully did a tcp_client_connect_addr on valid address

   122         return SUCCESS;

   123 

   124     else

   125         // all of the connect_async_addr's failed, return the last error

   126         return ERROR_CODE(err);

   127 }

   128 

   129 /*

   130  * Cleanup our resolver state and any connect callbacks after a connect

   131  */

   132 static void tcp_client_connect_cleanup (struct tcp_client *client)

   133 {

   134     // drop the resolver stuff

   135     resolve_result_deinit(&client->rr);

   136     

   137     // remove our event handler

   138     transport_fd_clear(&client->base_trans.base_fd);

   139 }

   140 

   141 /*

   142  * Our async connect operation has completed, clean up, set up state for event-based operation with user callbacks, and

   143  * invoke transport_connected().

   144  *

   145  * The given \a err should be NULL for successful completion, or the error for failures.

   146  */

   147 static void tcp_client_connect_done (struct tcp_client *client, error_t *conn_err)

   148 {

   149     error_t err;

   150 

   151     // cleanup

   152     tcp_client_connect_cleanup(client);

   153 

   154     if (conn_err)

   155         JUMP_SET_ERROR_INFO(&err, conn_err);

   156 

   157     // let the transport handle the rest

   158     if (tcp_transport_connected(&client->base_trans, &err))

   159         goto error;

   160     

   161     // ok

   162     return;

   163 

   164 error:    

   165     // pass the error on to transport

   166     transport_connected(&client->base_trans.base_fd.base, &err, false);

   167 }

   168 

   169 /*

   170  * Our async connect callback

   171  */

   172 static void tcp_client_on_connect (struct transport_fd *fd, short what, void *arg)

   173 {

   174     struct tcp_client *client = arg;

   175     error_t err;

   176     err_t tmp;

   177 

   178     // XXX: timeouts

   179     (void) what;

   180     

   181     // read socket error code

   182     if (tcp_sock_error(client->base_trans.base_fd.fd, &err))

   183         goto error;

   184 

   185     // did the connect fail?

   186     if (ERROR_EXTRA(&err))

   187         JUMP_SET_ERROR(&err, ERR_CONNECT);

   188     

   189     // done, success

   190     return tcp_client_connect_done(client, NULL);

   191 

   192 error:

   193     // close the socket

   194     if ((tmp = transport_fd_close(fd)))

   195         log_warn("error closing socket after connect error: %s", error_name(tmp));

   196 

   197     // log a warning

   198     log_warn_error(&err, "connect to %s failed", "???");

   199 

   200     // try the next one or fail completely

   201     if (tcp_client_connect_continue(client, &err))

   202         tcp_client_connect_done(client, &err);

   203 }

   204 

   205 err_t tcp_client_connect_async (struct tcp_client *client, const char *hostname, const char *service, error_t *err)

   206 {

   207     // do the resolving

   208     if (resolve_addr(&client->rr, hostname, service, SOCK_STREAM, 0, err))

   209         return ERROR_CODE(err);

   210 

   211     // start connecting with the first result

   212     if (tcp_client_connect_continue(client, err))

   213         goto error;

   214 

   215     // ok

   216     return SUCCESS;

   217 

   218 error:

   219     // cleanup

   220     resolve_result_deinit(&client->rr);

   221     

   222     return ERROR_CODE(err);

   223 }

   224 

   225 void tcp_client_deinit (struct tcp_client *client)

   226 {

   227     // cleanup our stuff

   228     resolve_result_deinit(&client->rr);

   229     

   230     // deinit lower transport

   231     tcp_transport_deinit(&client->base_trans);

   232 }

   233 

   234 /*

   235  * Deinit and free, not using the transport interface

   236  */

   237 static void tcp_client_destroy (struct tcp_client *client)

   238 {

   239     tcp_client_deinit(client);

   240 

   241     free(client);

   242 }

   243 

   244 /*

   245  * Public interface

   246  */

   247 err_t tcp_connect (const struct transport_info *info, transport_t **transport_ptr, 

   248         const char *host, const char *service, error_t *err)

   249 {

   250     struct tcp_client *client;

   251  

   252     // alloc

   253     if ((client = calloc(1, sizeof(*client))) == NULL)

   254         return ERR_CALLOC;

   255 

   256     // init transport

   257     transport_init(&client->base_trans.base_fd.base, &tcp_client_type, info);

   258     

   259     // init our state

   260     tcp_client_init(client);

   261  

   262     // begin connect

   263     if (tcp_client_connect_async(client, host, service, err))

   264         goto error;

   265 

   266     // good

   267     *transport_ptr = &client->base_trans.base_fd.base;

   268 

   269     return 0;

   270 

   271 error:

   272     // cleanup

   273     tcp_client_destroy(client);

   274         

   275     // return error code

   276     return ERROR_CODE(err);

   277 }

   278