static void
asc_process_verbosity(struct conn *c, struct token *token, int ntoken)
{
uint32_t level;
asc_set_noreply_maybe(c, token, ntoken);
if (ntoken != 3 && ntoken != 4) {
log_hexdump(LOG_NOTICE, c->req, c->req_len, "client error on c %d for "
"req of type %d with %d invalid tokens", c->sd,
c->req_type, ntoken);
asc_write_client_error(c);
return;
}
if (!mc_strtoul(token[TOKEN_SUBCOMMAND].val, &level)) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d with "
"invalid level '%.*s'", c->sd, c->req_type,
token[TOKEN_SUBCOMMAND].len, token[TOKEN_SUBCOMMAND].val);
asc_write_client_error(c);
return;
}
log_level_set(level);
asc_write_ok(c);
}
static void
asc_process_flushall(struct conn *c, struct token *token, int ntoken)
{
struct bound *t = &ntoken_bound[REQ_FLUSHALL];
int32_t exptime_int;
time_t exptime;
time_update();
asc_set_noreply_maybe(c, token, ntoken);
if (!asc_ntoken_valid(c, ntoken)) {
log_hexdump(LOG_NOTICE, c->req, c->req_len, "client error on c %d for "
"req of type %d with %d invalid tokens", c->sd,
c->req_type, ntoken);
asc_write_client_error(c);
return;
}
if (ntoken == t->b[c->noreply].min) {
settings.oldest_live = time_now() - 1;
item_flush_expired();
asc_write_ok(c);
return;
}
if (!mc_strtol(token[TOKEN_SUBCOMMAND].val, &exptime_int)) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d with "
"invalid numeric value '%.*s'", c->sd, c->req_type,
token[TOKEN_SUBCOMMAND].len, token[TOKEN_SUBCOMMAND].val);
asc_write_client_error(c);
return;
}
exptime = (time_t)exptime_int;
/*
* If exptime is zero time_reltime() would return zero too, and
* time_reltime(exptime) - 1 would overflow to the max unsigned value.
* So we process exptime == 0 the same way we do when no delay is
* given at all.
*/
if (exptime > 0) {
settings.oldest_live = time_reltime(exptime) - 1;
} else {
/* exptime == 0 */
settings.oldest_live = time_now() - 1;
}
item_flush_expired();
asc_write_ok(c);
}
static void
asc_process_delete(struct conn *c, struct token *token, int ntoken)
{
char *key; /* key to be deleted */
size_t nkey; /* # key bytes */
struct item *it; /* item for this key */
asc_set_noreply_maybe(c, token, ntoken);
if (!asc_ntoken_valid(c, ntoken)) {
log_hexdump(LOG_NOTICE, c->req, c->req_len, "client error on c %d for "
"req of type %d with %d invalid tokens", c->sd,
c->req_type, ntoken);
asc_write_client_error(c);
return;
}
key = token[TOKEN_KEY].val;
nkey = token[TOKEN_KEY].len;
if (nkey > KEY_MAX_LEN) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and %d "
"length key", c->sd, c->req_type, nkey);
asc_write_client_error(c);
return;
}
/*
* FIXME: This is not thread-safe, two threads could try to delete the same
* item twice after succeeding in item_get, leading to erroneous stats
*/
it = item_get(key, nkey);
if (it != NULL) {
stats_slab_incr(it->id, delete_hit);
item_delete(it);
asc_write_deleted(c);
} else {
stats_thread_incr(delete_miss);
asc_write_not_found(c);
}
}
static void
asc_process_delete(struct conn *c, struct token *token, int ntoken)
{
char *key; /* key to be deleted */
size_t nkey; /* # key bytes */
struct item *it; /* item for this key */
asc_set_noreply_maybe(c, token, ntoken);
if (!asc_ntoken_valid(c, ntoken)) {
log_hexdump(LOG_INFO, c->req, c->req_len, "client error on c %d for "
"req of type %d with %d invalid tokens", c->sd,
c->req_type, ntoken);
asc_write_client_error(c);
return;
}
key = token[TOKEN_KEY].val;
nkey = token[TOKEN_KEY].len;
if (nkey > KEY_MAX_LEN) {
log_debug(LOG_INFO, "client error on c %d for req of type %d and %d "
"length key", c->sd, c->req_type, nkey);
asc_write_client_error(c);
return;
}
it = item_get(key, nkey);
if (it != NULL) {
stats_slab_incr(it->id, delete_hit);
item_unlink(it);
item_remove(it);
asc_write_deleted(c);
} else {
stats_thread_incr(delete_miss);
asc_write_not_found(c);
}
}
static void
asc_process_arithmetic(struct conn *c, struct token *token, int ntoken)
{
item_delta_result_t res;
char temp[INCR_MAX_STORAGE_LEN];
uint64_t delta;
char *key;
size_t nkey;
bool incr;
asc_set_noreply_maybe(c, token, ntoken);
if (!asc_ntoken_valid(c, ntoken)) {
log_hexdump(LOG_NOTICE, c->req, c->req_len, "client error on c %d for "
"req of type %d with %d invalid tokens", c->sd,
c->req_type, ntoken);
asc_write_client_error(c);
return;
}
incr = (c->req_type == REQ_INCR) ? true : false;
key = token[TOKEN_KEY].val;
nkey = token[TOKEN_KEY].len;
if (nkey > KEY_MAX_LEN) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and %d "
"length key", c->sd, c->req_type, nkey);
asc_write_client_error(c);
return;
}
if (!mc_strtoull(token[TOKEN_DELTA].val, &delta)) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d with "
"invalid delta '%.*s'", c->sd, c->req_type,
token[TOKEN_DELTA].len, token[TOKEN_DELTA].val);
asc_write_client_error(c);
return;
}
res = item_add_delta(c, key, nkey, incr, delta, temp);
switch (res) {
case DELTA_OK:
asc_write_string(c, temp, strlen(temp));
klog_write(c->peer, c->req_type, c->req, c->req_len, res, strlen(temp));
break;
case DELTA_NON_NUMERIC:
log_debug(LOG_NOTICE, "client error on c %d for req of type %d with "
"non-numeric value", c->sd, c->req_type);
asc_write_client_error(c);
break;
case DELTA_EOM:
log_warn("server error on c %d for req of type %d because of oom",
c->sd, c->req_type);
asc_write_server_error(c);
break;
case DELTA_NOT_FOUND:
if (incr) {
stats_thread_incr(incr_miss);
} else {
stats_thread_incr(decr_miss);
}
asc_write_not_found(c);
break;
default:
NOT_REACHED();
break;
}
}
static void
asc_process_update(struct conn *c, struct token *token, int ntoken)
{
char *key;
size_t nkey;
uint32_t flags, vlen;
int32_t exptime_int;
time_t exptime;
uint64_t req_cas_id = 0;
struct item *it;
bool handle_cas;
req_type_t type;
uint8_t id;
asc_set_noreply_maybe(c, token, ntoken);
if (!asc_ntoken_valid(c, ntoken)) {
log_hexdump(LOG_NOTICE, c->req, c->req_len, "client error on c %d for "
"req of type %d with %d invalid tokens", c->sd,
c->req_type, ntoken);
asc_write_client_error(c);
return;
}
type = c->req_type;
handle_cas = (type == REQ_CAS) ? true : false;
key = token[TOKEN_KEY].val;
nkey = token[TOKEN_KEY].len;
if (nkey > KEY_MAX_LEN) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and %d "
"length key", c->sd, c->req_type, nkey);
asc_write_client_error(c);
return;
}
if (!mc_strtoul(token[TOKEN_FLAGS].val, &flags)) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and "
"invalid flags '%.*s'", c->sd, c->req_type,
token[TOKEN_FLAGS].len, token[TOKEN_FLAGS].val);
asc_write_client_error(c);
return;
}
if (!mc_strtol(token[TOKEN_EXPIRY].val, &exptime_int)) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and "
"invalid expiry '%.*s'", c->sd, c->req_type,
token[TOKEN_EXPIRY].len, token[TOKEN_EXPIRY].val);
asc_write_client_error(c);
return;
}
if (!mc_strtoul(token[TOKEN_VLEN].val, &vlen)) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and "
"invalid vlen '%.*s'", c->sd, c->req_type,
token[TOKEN_VLEN].len, token[TOKEN_VLEN].val);
asc_write_client_error(c);
return;
}
id = item_slabid(nkey, vlen);
if (id == SLABCLASS_INVALID_ID) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and "
"slab id out of range for key size %"PRIu8" and value size "
"%"PRIu32, c->sd, c->req_type, nkey, vlen);
asc_write_client_error(c);
return;
}
exptime = (time_t)exptime_int;
/* does cas value exist? */
if (handle_cas) {
if (!mc_strtoull(token[TOKEN_CAS].val, &req_cas_id)) {
log_debug(LOG_NOTICE, "client error on c %d for req of type %d and "
"invalid cas '%.*s'", c->sd, c->req_type,
token[TOKEN_CAS].len, token[TOKEN_CAS].val);
asc_write_client_error(c);
return;
}
}
it = item_alloc(id, key, nkey, flags, time_reltime(exptime), vlen);
if (it == NULL) {
log_warn("server error on c %d for req of type %d because of oom in "
"storing item", c->sd, c->req_type);
asc_write_server_error(c);
/* swallow the data line */
c->write_and_go = CONN_SWALLOW;
c->sbytes = vlen + CRLF_LEN;
/*
* Avoid stale data persisting in cache because we failed alloc.
* Unacceptable for SET. Anywhere else too?
*
* FIXME: either don't delete anything or should be unacceptable for
* all but add.
*/
if (type == REQ_SET) {
it = item_get(key, nkey);
if (it != NULL) {
item_delete(it);
}
}
return;
}
item_set_cas(it, req_cas_id);
c->item = it;
c->ritem = item_data(it);
c->rlbytes = it->nbyte + CRLF_LEN;
conn_set_state(c, CONN_NREAD);
}
static void
asc_process_update(struct conn *c, struct token *token, int ntoken)
{
char *key;
size_t nkey;
unsigned int flags;
int32_t exptime_int;
time_t exptime;
int vlen;
uint64_t req_cas_id = 0;
struct item *it;
bool handle_cas;
req_type_t type;
asc_set_noreply_maybe(c, token, ntoken);
if (!asc_ntoken_valid(c, ntoken)) {
log_hexdump(LOG_INFO, c->req, c->req_len, "client error on c %d for "
"req of type %d with %d invalid tokens", c->sd,
c->req_type, ntoken);
asc_write_client_error(c);
return;
}
type = c->req_type;
handle_cas = (type == REQ_CAS) ? true : false;
key = token[TOKEN_KEY].val;
nkey = token[TOKEN_KEY].len;
if (nkey > KEY_MAX_LEN) {
log_debug(LOG_INFO, "client error on c %d for req of type %d and %d "
"length key", c->sd, c->req_type, nkey);
asc_write_client_error(c);
return;
}
if (!mc_strtoul(token[TOKEN_FLAGS].val, (uint32_t *)&flags)) {
log_debug(LOG_INFO, "client error on c %d for req of type %d and "
"invalid flags '%.*s'", c->sd, c->req_type,
token[TOKEN_FLAGS].len, token[TOKEN_FLAGS].val);
asc_write_client_error(c);
return;
}
if (!mc_strtol(token[TOKEN_EXPIRY].val, &exptime_int)) {
log_debug(LOG_INFO, "client error on c %d for req of type %d and "
"invalid expiry '%.*s'", c->sd, c->req_type,
token[TOKEN_EXPIRY].len, token[TOKEN_EXPIRY].val);
asc_write_client_error(c);
return;
}
if (!mc_strtol(token[TOKEN_VLEN].val, (int32_t *)&vlen)) {
log_debug(LOG_INFO, "client error on c %d for req of type %d and "
"invalid vlen '%.*s'", c->sd, c->req_type,
token[TOKEN_VLEN].len, token[TOKEN_VLEN].val);
asc_write_client_error(c);
return;
}
exptime = (time_t)exptime_int;
/* does cas value exist? */
if (handle_cas) {
if (!mc_strtoull(token[TOKEN_CAS].val, &req_cas_id)) {
log_debug(LOG_INFO, "client error on c %d for req of type %d and "
"invalid cas '%.*s'", c->sd, c->req_type,
token[TOKEN_CAS].len, token[TOKEN_CAS].val);
asc_write_client_error(c);
return;
}
}
if (vlen < 0) {
log_debug(LOG_INFO, "client error on c %d for req of type %d and "
"invalid vlen %d", c->sd, c->req_type, vlen);
asc_write_client_error(c);
return;
}
vlen += CRLF_LEN;
it = item_alloc(key, nkey, flags, time_reltime(exptime), vlen);
if (it == NULL) {
log_debug(LOG_DEBUG, "server error on c %d for req of type %d because "
"of oom in storing item", c->sd, c->req_type);
asc_write_server_error(c);
/* swallow the data line */
c->write_and_go = CONN_SWALLOW;
c->sbytes = vlen;
/*
* Avoid stale data persisting in cache because we failed alloc.
* Unacceptable for SET. Anywhere else too?
*/
if (type == REQ_SET) {
it = item_get(key, nkey);
if (it != NULL) {
item_unlink(it);
item_remove(it);
}
}
return;
}
item_set_cas(it, req_cas_id);
c->item = it;
c->ritem = item_data(it);
c->rlbytes = it->nbyte;
conn_set_state(c, CONN_NREAD);
}