1

/*

     2

 * Test interoperability of tcp_client/tcp_server

     3

 */

     4

#include "../tcp.h"

     5

#include "test.h"

     6

     7

struct test_tcp_ctx {

     8

    service_t *service;

     9

    bool on_service_error;

    10

    bool on_client_connect;

    11

    bool on_service_client_error;

    12

    13

    transport_t *service_client, *client;

    14

    15

    char data;

    16

    17

    bool eof;

    18

};

    19

    20

static void on_service_error (service_t *service, const error_t *err, void *arg)

    21

{

    22

    struct test_tcp_ctx *ctx = arg;

    23

    24

    log_debug("%s", error_msg(err));

    25

    26

    assert(service == ctx->service);

    27

    assert(!ctx->on_service_error);

    28

    29

    ctx->on_service_error = true;

    30

}

    31

    32

static void on_service_client_connect (transport_t *transport, void *arg)

    33

{

    34

    struct test_tcp_ctx *ctx = arg;

    35

    36

    log_debug("%p", transport);

    37

    38

    assert(!ctx->service_client);

    39

    40

    ctx->service_client = transport;

    41

}

    42

    43

static void on_service_client_read (transport_t *transport, void *arg)

    44

{

    45

    struct test_tcp_ctx *ctx = arg;

    46

    char byte;

    47

    int ret;

    48

    error_t err;

    49

    50

    log_debug("%p", transport);

    51

    52

    assert(ctx->service_client == transport);

    53

    54

    if ((ret = transport_read(transport, &byte, sizeof(byte), &err)) == 1) {

    55

        assert(byte == ctx->data);

    56

    57

        ctx->data = 0;

    58

    59

    } else if (ERROR_CODE(&err) == ERR_EOF) {

    60

        assert(ctx->eof);

    61

    62

        ctx->eof = false;

    63

    64

    } else {

    65

        FATAL_ERROR(&err, "xxx");

    66

    }

    67

}

    68

    69

static void on_service_client_error (transport_t *transport, const error_t *err, void *arg)

    70

{

    71

    struct test_tcp_ctx *ctx = arg;

    72

    73

    log_debug("%p: %s", transport, error_msg(err));

    74

    75

    assert(ctx->service_client = transport);

    76

    77

    ctx->on_service_client_error = true;

    78

}

    79

    80

static void on_client_connect (transport_t *transport, void *arg)

    81

{

    82

    struct test_tcp_ctx *ctx = arg;

    83

    84

    log_debug("%p", transport);

    85

    86

    assert(transport == ctx->client);

    87

    88

    ctx->on_client_connect = true;

    89

}

    90

    91

static void on_client_read (transport_t *transport, void *arg)

    92

{

    93

    struct test_tcp_ctx *ctx = arg;

    94

    char byte;

    95

    int ret;

    96

    error_t err;

    97

    98

    log_debug("%p", transport);

    99

   100

    assert(transport == ctx->client);

   101

   102

    if ((ret = transport_read(transport, &byte, sizeof(byte), &err)) == 1) {

   103

        assert(byte == ctx->data);

   104

   105

        ctx->data = 0;

   106

   107

    } else if (ERROR_CODE(&err) == ERR_EOF) {

   108

        assert(ctx->eof);

   109

   110

        ctx->eof = false;

   111

   112

    } else {

   113

        FATAL_ERROR(&err, "xxx");

   114

    }

   115

}

   116

   117

static void on_client_error (transport_t *transport, const error_t *err, void *arg)

   118

{

   119

    struct test_tcp_ctx *ctx = arg;

   120

   121

    log_debug("%p", transport);

   122

   123

    assert(transport == ctx->client);

   124

   125

    // XXX

   126

}

   127

   128

static struct service_callbacks test_tcp_service_callbacks = {

   129

    .on_error   = on_service_error,

   130

};

   131

   132

static struct transport_callbacks test_tcp_service_transport_callbacks = {

   133

    .on_connect = on_service_client_connect,

   134

    .on_read    = on_service_client_read,

   135

    .on_write   = NULL,

   136

    .on_error   = on_service_client_error,

   137

};

   138

   139

static struct transport_callbacks test_tcp_client_callbacks = {

   140

    .on_connect = on_client_connect,

   141

    .on_read    = on_client_read,

   142

    .on_error   = on_client_error,

   143

};

   144

   145

void test_tcp (void)

   146

{

   147

    struct test_tcp_ctx ctx; memset(&ctx, 0, sizeof(ctx));

   148

    struct service_info serv_info = { 

   149

        &test_tcp_service_callbacks, &ctx, 

   150

        { &test_tcp_service_transport_callbacks, &ctx, TRANSPORT_READ } 

   151

    };

   152

    struct transport_info client_info = {

   153

        &test_tcp_client_callbacks, &ctx, TRANSPORT_READ

   154

    };

   155

    struct event_base *ev_base = _test_ctx.ev_base;

   156

    error_t err;

   157

   158

    // create the service

   159

    assert_success(tcp_listen(&serv_info, &ctx.service, "localhost", "3232", &err));

   160

   161

    // connect client -> server

   162

    assert_success(tcp_connect(&client_info, &ctx.client, "localhost", "3232", &err));

   163

    event_base_loop(ev_base, EVLOOP_ONCE);

   164

    assert(ctx.service_client);

   165

    assert(ctx.on_client_connect);

   166

   167

    // send client -> server

   168

    ctx.data = 'A';

   169

   170

    assert(transport_write(ctx.client, &ctx.data, sizeof(ctx.data), &err) == 1);

   171

    event_base_loop(ev_base, EVLOOP_ONCE);

   172

    assert(!ctx.data);

   173

   174

    // send server -> client

   175

    ctx.data = 'B';

   176

   177

    assert(transport_write(ctx.service_client, &ctx.data, sizeof(ctx.data), &err) == 1);

   178

    event_base_loop(ev_base, EVLOOP_ONCE);

   179

    assert(!ctx.data);

   180

   181

    // close client-side connection

   182

    ctx.eof = true;

   183

    transport_destroy(ctx.client);

   184

    event_base_loop(ev_base, EVLOOP_ONCE);

   185

    assert(ctx.on_service_client_error || !ctx.eof);

   186

   187

    // cleanup

   188

    transport_destroy(ctx.service_client);

   189

    service_destroy(ctx.service);

   190

}

   191