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;

    51

    52

        // set offset to zero

    53

        req->buf.offset = 0;

    54

    }

    55

    56

    // store the other data

    57

    req->mc = mc;

    58

    req->cmd_type = cmd_type;

    59

    req->cb_arg = cb_arg;

    60

    61

    // success

    62

    return req;

    63

    64

error:

    65

    if (req) {

    66

        free(req->key.buf);

    67

        free(req);

    68

    }

    69

    70

    return NULL;

    71

}

    72

    73

// accessors

    75

    return req->state;

    76

}

    77

    78

enum memcache_command memcache_req_cmd (struct memcache_req *req) {

    79

    return req->cmd_type;

    80

}

    81

    82

enum memcache_reply memcache_req_reply (struct memcache_req *req) {

    83

    return req->reply_type;

    84

}

    85

    87

    return &req->key;

    88

}

    89

    90

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

    91

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

    92

}

    93

    94

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

    95

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

    96

}

    97

    98

// events

    99

static void _memcache_req_notify (struct memcache_req *req) {

   100

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

   101

}

   102

   103

void memcache_req_queued (struct memcache_req *req) {

   104

    req->state = MEMCACHE_STATE_QUEUED;

   105

   106

//    _memcache_req_notify(req);

   107

}

   108

   109

void memcache_req_send (struct memcache_req *req) {

   110

    req->state = MEMCACHE_STATE_SEND;

   111

   112

//    _memcache_req_notify(req);

   113

}

   114

   115

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

   118

    req->reply_type = reply_type;

   119

   120

    // we must surely have a valid obj now

   121

    req->have_obj = 1;

   122

   123

    _memcache_req_notify(req);

   124

}

   125

   126

void memcache_req_data (struct memcache_req *req) {

   127

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

   128

   129

    req->state = MEMCACHE_STATE_REPLY_DATA;

   130

   131

    // we must surely have a valid buf now

   132

    req->have_buf = 1;

   133

   134

    _memcache_req_notify(req);

   135

}

   136

   137

void memcache_req_done (struct memcache_req *req) {

   138

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

   139

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

   140

   143

   144

    // forget the connection

   145

    req->conn = NULL;

   146

   147

    _memcache_req_notify(req);

   148

}

   149

   150

void memcache_req_error (struct memcache_req *req) {

   151

    // forget our connection

   152

    req->conn = NULL;

   153

   154

    req->state = MEMCACHE_STATE_ERROR;

   155

   156

    _memcache_req_notify(req);

   157

}

   158

   159

void memcache_req_free (struct memcache_req *req) {

   160

    // must be unused

   161

    assert(req->conn == NULL);

   166

   167

    free(req->key.buf);

   168

    free(req);

   169

}

   170