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, struct memcache_key *key, void *cb_arg) {

    10

    struct memcache_req *req = NULL;

    11

    12

    // allocate it

    13

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

    14

        ERROR("calloc");

    15

    16

    // state

    17

    req->state = STATE_INVALID;

    18

    19

    // copy the key

    20

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

    21

        ERROR("malloc key buf");

    22

    23

    // copy over the key

    24

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

    25

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

    26

    27

    // store the mc + callback argument

    28

    req->mc = mc;

    29

    req->cb_arg = cb_arg;

    30

    31

    // success

    32

    return req;

    33

    34

error:

    35

    if (req) {

    36

        free(req->key.buf);

    37

        free(req);

    38

    }

    39

    40

    return NULL;

    41

}

    42

    43

static int _memcache_req_notify (struct memcache_req *req) {

    44

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

    45

}

    46

    47

void memcache_req_error (struct memcache_req *req) {

    48

    // forget our connection

    49

    req->conn = NULL;

    50

    51

    // enter ERROR state

    52

    req->state = STATE_ERROR;

    53

    54

    // notify

    55

    if (_memcache_req_notify(req))

    56

        WARNING("req error callback failed, ignoring");

    57

}

    58

    59

void memcache_req_free (struct memcache_req *req) {

    60

    // must be unused

    61

    assert(req->conn == NULL);

    62

    assert(req->state == STATE_INVALID || req->state == STATE_ERROR);

    63

    64

    free(req->key.buf);

    65

    free(req);

    66

}

    67