1

     2

#include <stdlib.h>

     3

#include <assert.h>

     4

     5

#include "request.h"

     6

#include "memcache.h"

     7

#include "../common.h"

     8

     9

struct memcache_req *memcache_req_alloc (struct memcache *mc, enum memcache_command cmd_type, const struct memcache_key *key, const struct memcache_obj *obj, const struct memcache_buf *buf, void *cb_arg) {

    10

    struct memcache_req *req = NULL;

    11

    12

    // ensure key is provided

    13

    assert(key != NULL);

    14

    15

    // allocate it

    16

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

    17

        ERROR("calloc");

    18

    19

    // state

    20

    req->state = MEMCACHE_STATE_INVALID;

    21

    22

    // key length?

    23

    if (key->len == 0)

    24

        req->key.len = strlen(key->buf);

    25

    else

    26

        req->key.len = key->len;

    27

    28

    if (req->key.len == 0)

    29

        ERROR("zero-length key");

    30

    31

    // copy the key

    32

    if ((req->key.buf = malloc(req->key.len)) == NULL)

    33

        ERROR("malloc key buf");

    34

    35

    memcpy(req->key.buf, key->buf, req->key.len);

    36

    37

    // copy the obj if provided

    38

    if (obj) {

    39

        memcpy(&req->obj, obj, sizeof(req->obj));

    40

        req->have_obj = 1;

    41

    }

    42

    43

    // copy the buf if provided, and reset the offset to zero

    44

    if (buf) {

    45

        // ensure that it is a valid buffer

    46

        assert(buf->data && buf->len > 0 && buf->offset == buf->len);

    47

    48

        memcpy(&req->buf, buf, sizeof(req->buf));

    49

        req->have_buf = 1;

    50

    51

        // set offset to zero

    52

        req->buf.offset = 0;

    53

    }

    54

    55

    // store the other data

    56

    req->mc = mc;

    57

    req->cmd_type = cmd_type;

    58

    req->cb_arg = cb_arg;

    59

    60

    // success

    61

    return req;

    62

    63

error:

    64

    if (req) {

    65

        free(req->key.buf);

    66

        free(req);

    67

    }

    68

    69

    return NULL;

    70

}

    71

    72

// accessors

    73

enum memcache_req_state memcache_req_state (struct memcache_req *req) {

    74

    return req->state;

    75

}

    76

    77

enum memcache_command memcache_req_cmd (struct memcache_req *req) {

    78

    return req->cmd_type;

    79

}

    80

    81

enum memcache_reply memcache_req_reply (struct memcache_req *req) {

    82

    return req->reply_type;

    83

}

    84

    85

const struct memcache_key *keymemcache_req_key (struct memcache_req *req) {

    86

    return &req->key;

    87

}

    88

    89

const struct memcache_obj *memcache_req_obj (struct memcache_req *req) {

    90

    return req->have_obj ? &req->obj : NULL;

    91

}

    92

    93

const struct memcache_buf *memcache_req_buf (struct memcache_req *req) {

    94

    return req->have_buf ? &req->buf : NULL;

    95

}

    96

    97

// events

    98

static void _memcache_req_notify (struct memcache_req *req) {

    99

    req->mc->cb_fn(req, req->cb_arg);

   100

}

   101

   102

void memcache_req_queued (struct memcache_req *req) {

   103

    req->state = MEMCACHE_STATE_QUEUED;

   104

   105

//    _memcache_req_notify(req);

   106

}

   107

   108

void memcache_req_send (struct memcache_req *req) {

   109

    req->state = MEMCACHE_STATE_SEND;

   110

   111

//    _memcache_req_notify(req);

   112

}

   113

   114

void memcache_req_recv (struct memcache_req *req, enum memcache_reply reply_type) {

   115

    req->state = MEMCACHE_STATE_REPLY;

   116

    req->reply_type = reply_type;

   117

   118

    // we must surely have a valid obj now

   119

    req->have_obj = 1;

   120

   121

    _memcache_req_notify(req);

   122

}

   123

   124

void memcache_req_data (struct memcache_req *req) {

   125

    assert(req->state == MEMCACHE_STATE_REPLY || req->state == MEMCACHE_STATE_REPLY_DATA);

   126

   127

    req->state = MEMCACHE_STATE_REPLY_DATA;

   128

   129

    // we must surely have a valid buf now

   130

    req->have_buf = 1;

   131

   132

    _memcache_req_notify(req);

   133

}

   134

   135

void memcache_req_done (struct memcache_req *req) {

   136

    // make sure we are in the REPLY/REPLY_DATA state

   137

    assert(req->state == MEMCACHE_STATE_REPLY || req->state == MEMCACHE_STATE_REPLY_DATA);

   138

   139

    // are we supposed to have data?

   140

    if (req->buf.data) {

   141

        // make sure we really have the full data, if applicable

   142

        assert(req->buf.offset == req->buf.len);

   143

   144

        // yes...

   145

        req->have_buf = 1;

   146

   147

        // have data

   148

        req->state = MEMCACHE_STATE_DATA_DONE;

   149

   150

    } else {

   151

        // no data

   152

        req->state = MEMCACHE_STATE_DONE;

   153

    }

   154

   155

    // forget the connection

   156

    req->conn = NULL;

   157

   158

    _memcache_req_notify(req);

   159

}

   160

   161

void memcache_req_error (struct memcache_req *req) {

   162

    // forget our connection

   163

    req->conn = NULL;

   164

   165

    req->state = MEMCACHE_STATE_ERROR;

   166

   167

    _memcache_req_notify(req);

   168

}

   169

   170

void memcache_req_free (struct memcache_req *req) {

   171

    // must be unused

   172

    assert(req->conn == NULL);

   173

    assert(req->state == MEMCACHE_STATE_INVALID || req->state == MEMCACHE_STATE_ERROR || req->state == MEMCACHE_STATE_DONE || req->state == MEMCACHE_STATE_DATA_DONE);

   174

   175

    free(req->key.buf);

   176

    free(req);

   177

}

   178