1

#include <string.h>

     2

#include <stdlib.h>

     3

#include <assert.h>

     4

     5

#include "command.h"

     6

#include "../common.h"

     7

     8

static char *memcache_cmd_names[MEMCACHE_CMD_MAX] = {

     9

    NULL,       // MEMCACHE_CMD_INVALID

    10

    "get",      // MEMCACHE_CMD_FETCH_GET

    11

    "set",      // MEMCACHE_CMD_STORE_SET

    12

    "add",      // MEMCACHE_CMD_STORE_ADD

    13

    "replace",  // MEMCACHE_CMD_STORE_REPLACE

    14

    "append",   // MEMCACHE_CMD_STORE_APPEND

    15

    "prepend"   // MEMCACHE_CMD_STORE_PREPEND

    16

};

    17

    18

static struct memcache_reply_info {

    19

    enum memcache_reply type;

    20

    char *name;

    21

    22

} memcache_cmd_replies[MEMCACHE_RPL_MAX] = {

    23

    {   MEMCACHE_RPL_INVALID,       NULL            },

    24

    {   MEMCACHE_RPL_ERROR,         "ERROR"         },

    25

    {   MEMCACHE_RPL_CLIENT_ERROR,  "CLIENT_ERROR"  },

    26

    {   MEMCACHE_RPL_SERVER_ERROR,  "SERVER_ERROR"  },

    27

    28

    // MEMCACHE_CMD_FETCH_*

    29

    {   MEMCACHE_RPL_VALUE,         "VALUE"         },

    30

    {   MEMCACHE_RPL_END,           "END"           },

    31

    32

    // MEMCACHE_CMD_STORE_*

    33

    {   MEMCACHE_RPL_STORED,        "STORED"        },

    34

    {   MEMCACHE_RPL_NOT_STORED,    "NOT_STORED"    },

    35

    {   MEMCACHE_RPL_EXISTS,        "EXISTS"        },

    36

    {   MEMCACHE_RPL_NOT_FOUND,     "NOT_FOUND"     }

    37

};

    38

    39

    40

    41

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

    42

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

    43

    assert(cmd->req_header == NULL);

    44

    45

    // allocate the request header

    46

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

    47

        ERROR("evbuffer_new");

    48

    49

    // format the command

    50

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

    51

        goto error;

    52

    53

    // XXX: prepare the rest

    54

    55

    // success

    56

    return 0;

    57

    58

error:    

    59

    if (cmd->req_header)

    60

        evbuffer_free(cmd->req_header);

    61

    62

    return -1;

    63

}

    64

    66

    char *cmd_name;

    67

    68

    // valid command

    69

    assert(cmd_type < MEMCACHE_CMD_MAX);

    70

    71

    if (cmd_type == MEMCACHE_CMD_INVALID)

    72

        ERROR("invalid command");

    73

    74

    // map the command to a string

    75

    cmd_name = memcache_cmd_names[cmd_type];

    76

    77

    // format the request header

    78

    switch (cmd_type) {

    79

        case MEMCACHE_CMD_FETCH_GET:

    80

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

    81

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

    82

    84

                ERROR("evbuffer_add_printf");

    85

    86

            break;

    87

    88

        case MEMCACHE_CMD_STORE_SET:

    89

        case MEMCACHE_CMD_STORE_ADD:

    90

        case MEMCACHE_CMD_STORE_REPLACE:

    91

        case MEMCACHE_CMD_STORE_APPEND:

    92

        case MEMCACHE_CMD_STORE_PREPEND:

    93

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

    94

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

    95

            // XXX: ensure that we have a valid buf

    96

    98

                ERROR("evbuffer_add_printf");

    99

   100

            break;

   101

   102

        case MEMCACHE_CMD_STORE_CAS:

   103

        default:

   104

            // XXX: not supported yet/invalid

   105

            assert(0);

   106

    };

   107

   108

    // success

   109

    return 0;

   110

   111

error:

   112

    return -1;

   113

   114

}

   115

   116

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) {

   117

    size_t line_length, buf_size;

   118

    char *line = NULL, *token_cursor, *token, *invalid;

   119

    int i;

   120

   121

    // read lines until we find one that isn't empty

   122

    do {

   123

        // take note of how long the buffer is

   124

        buf_size = evbuffer_get_length(buf);

   125

   126

        // free the prvious line in case it was empty

   127

        free(line);

   128

   129

        // try and read a line

   130

        if ((line = evbuffer_readln(buf, &line_length, EVBUFFER_EOL_CRLF_STRICT)) == NULL) {

   131

            // check if any data was consumed

   132

            if (evbuffer_get_length(buf) != buf_size) {

   133

                // faaaail!

   134

                return -1;

   135

   136

            } else {

   137

                // no complete line found

   138

                return 0;

   139

            }

   140

        }

   141

   142

    } while (line_length == 0);

   143

   144

    // just check to make sure that it really is null-delimited

   145

    assert(line[line_length] == '\0');

   146

   147

    // use strsep

   148

    token_cursor = line;

   149

   150

    // the first token should be the reply name

   151

    if ((token = strsep(&token_cursor, " ")) == NULL)

   152

        ERROR("no reply name in response line: %s", line);

   153

   154

    // figure out the reply type

   155

    for (i = MEMCACHE_RPL_INVALID + 1; i < MEMCACHE_RPL_MAX; i++) {

   156

        if (strcmp(token, memcache_cmd_replies[i].name) == 0)

   157

            break;

   158

    }

   159

   160

    // did we figure out what this reply means?

   161

    if (i == MEMCACHE_RPL_MAX)

   162

        ERROR("unrecognized reply: %s", line);

   163

   164

    // we found the type

   165

    *reply_type = memcache_cmd_replies[i].type;

   166

   167

    // default to no data

   168

    *has_data = 0;

   169

   170

    switch (*reply_type) {

   171

        case MEMCACHE_RPL_ERROR:

   172

            // no additional data

   173

   174

            break;

   175

   176

        case MEMCACHE_RPL_CLIENT_ERROR:

   177

        case MEMCACHE_RPL_SERVER_ERROR:

   178

            // the rest of the line is a human-readable error message

   179

            WARNING("received a %s reply: %s", token, token_cursor);

   180

   181

            break;

   182

   183

        case MEMCACHE_RPL_VALUE:

   184

            // <key> <flags> <bytes> [<cas unique>]

   185

   186

            // the key field

   187

            if ((key->buf = strsep(&token_cursor, " ")) == NULL)

   188

                ERROR("missing key in VALUE reply");

   189

   190

            if ((key->len = strlen(key->buf)) == 0)

   191

                ERROR("zero-length key in VALUE reply");

   192

   193

            // the flags field

   194

            if ((token = strsep(&token_cursor, " ")) == NULL)

   195

                ERROR("missing flags in VALUE reply");

   196

   197

            obj->flags = (u_int32_t) strtol(token, &invalid, 10);

   198

   199

            if (*invalid != '\0')

   200

                ERROR("invalid flags in VALUE reply: %s (%s)", token, invalid);

   201

   202

            // the bytes field

   203

            if ((token = strsep(&token_cursor, " ")) == NULL)

   204

                ERROR("missing bytes in VALUE reply");

   205

   206

            obj->bytes = (u_int32_t) strtol(token, &invalid, 10);

   207

   208

            if (*invalid != '\0')

   209

                ERROR("invalid bytes in VALUE reply: %s (%s)", token, invalid);

   210

   211

            // the optional cas field

   212

            if ((token = strsep(&token_cursor, " ")) != NULL) {

   213

                // there is a cas value present

   214

                obj->cas = (u_int64_t) strtoll(token, &invalid, 10);

   215

   216

                if (*invalid != '\0')

   217

                    ERROR("invalid cas value in VALUE reply: %s (%s)", token, invalid);

   218

   219

            } else {

   220

                obj->cas = 0;

   221

   222

            }

   223

   224

            // and we do have data following this

   225

            *has_data = 1;

   226

   227

            break;

   228

   229

        case MEMCACHE_RPL_END:

   230

            // no additional data

   231

   232

            break;

   233

   234

        case MEMCACHE_RPL_STORED:

   235

        case MEMCACHE_RPL_NOT_STORED:

   236

        case MEMCACHE_RPL_EXISTS:

   237

        case MEMCACHE_RPL_NOT_FOUND:

   238

            // no additional data

   239

   240

            break;

   241

   242

        default:

   243

            assert(0);

   244

    };

   245

   246

    // success

   247

    *header_data = line;

   248

   249

    return 0;

   250

   251

error:

   252

    free(line);

   253

   254

    return -1;

   255

}

   256