1

     2

#include <assert.h>

     3

     4

#include "command.h"

     5

#include "../common.h"

     6

     7

static char *memcache_cmd_names[MEMCACHE_CMD_MAX] = {

     8

    NULL,       // MEMCACHE_CMD_INVALID

     9

    "get",      // MEMCACHE_CMD_FETCH_GET

    10

    "set",      // MEMCACHE_CMD_STORE_SET

    11

    "add",      // MEMCACHE_CMD_STORE_ADD

    12

    "replace",  // MEMCACHE_CMD_STORE_REPLACE

    13

    "append",   // MEMCACHE_CMD_STORE_APPEND

    14

    "prepend"   // MEMCACHE_CMD_STORE_PREPEND

    15

};

    16

    17

/*

    18

static struct memcache_reply_info {

    19

    enum memcache_reply type;

    20

    char *name;

    21

    int has_data;

    22

    23

} *memcache_cmd_replies[MEMCACHE_RPL_MAX] = {

    24

    MEMCACHE_RPL_INVALID,

    25

    26

    MEMCACHE_RPL_ERROR,

    27

    MEMCACHE_RPL_CLIENT_ERROR,

    28

    MEMCACHE_RPL_SERVER_ERROR,

    29

    30

    // MEMCACHE_CMD_FETCH_*

    31

    MEMCACHE_RPL_VALUE,

    32

    MEMCACHE_RPL_END,

    33

    34

    // MEMCACHE_CMD_STORE_*

    35

    MEMCACHE_RPL_STORED,

    36

    MEMCACHE_RPL_NOT_STORED,

    37

    MEMCACHE_RPL_EXISTS,

    38

    MEMCACHE_RPL_NOT_FOUND,

    39

    40

};

    41

    42

*/

    43

    44

int memcache_cmd_init (struct memcache_cmd *cmd, enum memcache_command cmd_type, struct memcache_key *key, struct memcache_obj *obj) {

    45

    // shouldn't already have a request header yet?

    46

    assert(cmd->req_header == NULL);

    47

    48

    // allocate the request header

    49

    if ((cmd->req_header = evbuffer_new()) == NULL)

    50

        ERROR("evbuffer_new");

    51

    52

    // format the command

    53

    if (memcache_cmd_format_header(cmd->req_header, cmd_type, key, obj))

    54

        goto error;

    55

    56

    // XXX: prepare the rest

    57

    58

    // success

    59

    return 0;

    60

    61

error:    

    62

    if (cmd->req_header)

    63

        evbuffer_free(cmd->req_header);

    64

    65

    return -1;

    66

}

    67

    68

int memcache_cmd_format_header (struct evbuffer *buf, enum memcache_command cmd_type, struct memcache_key *key, struct memcache_obj *obj) {

    69

    char *cmd_name;

    70

    71

    // valid command

    72

    assert(cmd_type < MEMCACHE_CMD_MAX);

    73

    74

    if (cmd_type == MEMCACHE_CMD_INVALID)

    75

        ERROR("invalid command");

    76

    77

    // map the command to a string

    78

    cmd_name = memcache_cmd_names[cmd_type];

    79

    80

    // format the request header

    81

    switch (cmd_type) {

    82

        case MEMCACHE_CMD_FETCH_GET:

    83

            assert(key != NULL && obj == NULL);

    84

            assert(key->len > 0 && key->buf != NULL);

    85

    86

            if (evbuffer_add_printf(buf, "%s %*s\r\n", cmd_name, (int) key->len, key->buf) == -1)

    87

                ERROR("evbuffer_add_printf");

    88

    89

            break;

    90

    91

        case MEMCACHE_CMD_STORE_SET:

    92

        case MEMCACHE_CMD_STORE_ADD:

    93

        case MEMCACHE_CMD_STORE_REPLACE:

    94

        case MEMCACHE_CMD_STORE_APPEND:

    95

        case MEMCACHE_CMD_STORE_PREPEND:

    96

            assert(key != NULL && obj != NULL);

    97

            assert(key->len > 0 && key->buf != NULL);

    98

            assert(obj->bytes > 0);

    99

   100

            if (evbuffer_add_printf(buf, "%s %*s %u %lu %zu\r\n", cmd_name, (int) key->len, key->buf, obj->flags, obj->exptime, obj->bytes))

   101

                ERROR("evbuffer_add_printf");

   102

   103

            break;

   104

   105

        case MEMCACHE_CMD_STORE_CAS:

   106

        default:

   107

            // XXX: not supported yet/invalid

   108

            assert(0);

   109

    };

   110

   111

    // success

   112

    return 0;

   113

   114

error:

   115

    return -1;

   116

   117

}

   118

   119

int memcache_cmd_parse_header (struct evbuffer *buf, char **header_data, enum memcache_reply *reply_type, struct memcache_key *key, struct memcache_obj *obj, int *has_data) {

   120

    // XXX: implement

   121

    assert(0);

   122

}

   123