3

     4

/**

     5

 * @file

     6

 *

     7

 * Internal TCP interface for implementations

     8

 */

     9

#include "tcp.h"

    10

#include "resolve.h"

    11

#include "transport_fd.h"

    12

#include "transport_internal.h"

    13

#include "service_internal.h"

    14

#include "error.h"

    15

    16

#include <event2/event.h>

    17

#include <event2/util.h>

    18

    19

/**

    20

 * Create a new socket() using the given addr's family/socktype/protocol and return it.

    21

 *

    22

 * In case of errors, this returns -err_t

    23

 *

    24

 * @param addr the addrinfo to create the socket for

    25

 * @param err returned error info

    26

 * @return new fd on success, -err_t on error

    27

 */

    28

int tcp_sock_create (const struct addrinfo *addr, error_t *err);

    29

    30

/**

    31

 * Return the socket's current error code via err->extra.

    32

 *

    33

 * In case getting the socket error code itself fails, this will return normal error code/info.

    34

 *

    35

 * Otherwise, this will return SUCCESS, with the errno value stored in err->extra.

    36

 */

    37

err_t tcp_sock_error (evutil_socket_t sock, error_t *err);

    38

    39

    40

/**

    41

 * TCP transport type

    42

 */

    43

extern const struct transport_type tcp_transport_type;

    44

    45

/**

    46

 * Base TCP transport 

    47

 *

    48

 * XXX: currently just the same as transport_fd, but this will probably change

    49

 */

    50

struct tcp_transport {

    51

    /** Base FD-based implementation */

    52

    struct transport_fd base_fd;

    53

};

    54

    55

/**

    56

 * Initialize the tcp_transport state.

    57

 *

    58

 * This initializes the transport_fd base using the global sock_ctx::ev_base and the given socket.

    59

 */

    60

void tcp_transport_init (struct tcp_transport *trans, evutil_socket_t sock);

    61

    62

/**

    63

 * Create a new tcp_transport with the given sock.

    64

 *

    65

 * For convenience, this will also make the sock nonblocking.

    66

 *

    67

 * In case of errors, this will the socket.

    68

 *

    69

 * @param trans_ptr returned tcp_transport

    70

 * @param info the transport user settings

    71

 * @param sock the unused TCP socket

    72

 * @param err returned error info

    73

 */

    74

err_t tcp_transport_create (struct tcp_transport **trans_ptr, const struct transport_info *info, evutil_socket_t sock, error_t *err);

    75

    76

/**

    77

 * The transport as now connected, this sets up the intitial user settings, and invokes the callback.

    78

 *

    79

 * XXX: this does an 'indirect' call to transport_connected().

    80

 *

    81

 * @param err returned error info

    82

 */

    83

err_t tcp_transport_connected (struct tcp_transport *trans, error_t *err);

    84

    85

/**

    86

 * Deinitialize the transport state, terminating the connection and releasing resources.

    87

 */

    88

void tcp_transport_deinit (struct tcp_transport *trans);

    89

    90

/**

    91

 * Deinitialize and free the given tcp_transport

    92

 */

    93

void tcp_transport_destroy (struct tcp_transport *trans);

    94

    95

/**

    96

 * TCP client transport type

    97

 */

    98

extern const struct transport_type tcp_client_type;

    99

   100

/**

   101

 * TCP client state

   102

 */

   103

struct tcp_client {

   104

    /** Base transport stuff */

   105

    struct tcp_transport base_trans;

   106

   107

    /** The resolver lookup result for the async connect process */

   108

    struct resolve_result rr;

   109

};

   110

   111

/**

   112

 * Initialize the tcp_client state

   113

 */

   114

void tcp_client_init (struct tcp_client *client);

   115

   116

/**

   117

 * Attempt to connect asyncronously to the given hostname/service. Once a connection has been established, this will

   118

 * call transport_connected(), so you can register transport_methods::_connected if layering on top of TCP.

   119

 *

   120

 * In case of errors while starting the async connect process, an error code will be returned. If the connect fails

   121

 * later on, transport_connected() will be called with the error code.

   122

 *

   123

 * The sock must have been initialized using sock_tcp_init().

   124

 *

   125

 * @param client the unconnected TCP client socket to connect with

   126

 * @param hostname the hostname to resolve

   127

 * @param service the service to connect to

   128

 * @param err returned error info for immediate errors

   129

 */

   130

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

   131

   132

/**

   133

 * Deinitialize the tcp_client's state, including the tcp_transport state.

   134

 */

   135

void tcp_client_deinit (struct tcp_client *client);

   136

   137

   138

   139

/**

   140

 * TCP service type

   141

 */

   142

extern const struct service_type tcp_server_type;

   143

   144

/**

   145

 * TCP service state

   146

 */

   147

struct tcp_server {

   148

    /** Base service state */

   149

    struct service base_service;

   150

   151

    /** The input event with our listen() socket */

   152

    struct event *ev;

   153

};

   154

   155

/**

   156

 * The listen() backlog

   157

 */

   158

#define TCP_SERVER_BACKLOG 5

   159

   160

/**

   161

 * Open the listening socket on the given interface/service.

   162

 */

   163

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

   164

   165

/**

   166

 * Release the tcp_server's state, and cleanup the struct.

   167

 */

   168

void tcp_server_deinit (struct tcp_server *serv);

   169

   170

#endif /* TCP_INTERNAL_H */