static void asc_process_evict(struct conn *c, struct token *token, int ntoken) { int32_t option; if (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_strtol(token[TOKEN_EVICT_COMMAND].val, &option)) { log_debug(LOG_NOTICE, "client error on c %d for req of type %d with " "invalid option '%.*s'", c->sd, c->req_type, token[TOKEN_EVICT_COMMAND].len,token[TOKEN_EVICT_COMMAND].val); asc_write_client_error(c); return; } if (option >= EVICT_NONE && option < EVICT_INVALID) { settings.evict_opt = option; asc_write_ok(c); return; } log_debug(LOG_NOTICE, "client error on c %d for req of type %d with " "invalid option %"PRId32"", c->sd, c->req_type, option); asc_write_client_error(c); }
static void asc_process_aggregate(struct conn *c, struct token *token, int ntoken) { int32_t interval; if (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_strtol(token[TOKEN_AGGR_COMMAND].val, &interval)) { log_debug(LOG_NOTICE, "client error on c %d for req of type %d with " "invalid option '%.*s'", c->sd, c->req_type, token[TOKEN_AGGR_COMMAND].len, token[TOKEN_AGGR_COMMAND].val); asc_write_client_error(c); return; } if (interval > 0) { stats_set_interval(interval); asc_write_ok(c); } else if (interval == 0) { stats_set_interval(STATS_DEFAULT_INTVL); asc_write_ok(c); } else { stats_set_interval(-1000000); 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_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_klog(struct conn *c, struct token *token, int ntoken) { struct token *t; 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; } t = &token[TOKEN_KLOG_COMMAND]; if (strncmp(t->val, "run", t->len) == 0) { if (settings.klog_name == NULL) { log_debug(LOG_NOTICE, "client error on c %d for req of type %d " "with klog filename not set", c->sd, c->req_type); asc_write_client_error(c); return; } t = &token[TOKEN_KLOG_SUBCOMMAND]; if (strncmp(t->val, "start", t->len) == 0) { log_debug(LOG_NOTICE, "klog start at epoch %u", time_now()); settings.klog_running = true; asc_write_ok(c); } else if (strncmp(t->val, "stop", t->len) == 0) { log_debug(LOG_NOTICE, "klog stops at epoch %u", time_now()); settings.klog_running = false; asc_write_ok(c); } else { log_debug(LOG_NOTICE, "client error on c %d for req of type %d " "with invalid klog run subcommand '%.*s'", c->sd, c->req_type, t->len, t->val); asc_write_client_error(c); } } else if (strncmp(t->val, "interval", t->len) == 0) { t = &token[TOKEN_KLOG_SUBCOMMAND]; if (strncmp(t->val, "reset", t->len) == 0) { stats_set_interval(STATS_DEFAULT_INTVL); asc_write_ok(c); } else { int32_t interval; if (!mc_strtol(t->val, &interval)) { log_debug(LOG_NOTICE, "client error on c %d for req of type %d " "with invalid klog interval '%.*s'", c->sd, c->req_type, t->len, t->val); asc_write_client_error(c); } else if (interval < KLOG_MIN_INTVL) { log_debug(LOG_NOTICE, "client error on c %d for req of type %d " "with invalid klog interval %"PRId32"", c->sd, c->req_type, interval); asc_write_client_error(c); } else { stats_set_interval(interval); asc_write_ok(c); } } } else if (strncmp(t->val, "sampling", t->len) == 0) { t = &token[TOKEN_KLOG_SUBCOMMAND]; if (strncmp(t->val, "reset", t->len) == 0) { settings.klog_sampling_rate = KLOG_DEFAULT_SMP_RATE; asc_write_ok(c); } else { int32_t sampling; if (!mc_strtol(t->val, &sampling)) { log_debug(LOG_NOTICE, "client error on c %d for req of type %d " "with invalid klog sampling '%.*s'", c->sd, c->req_type, t->len, t->val); asc_write_client_error(c); } else if (sampling <= 0) { log_debug(LOG_NOTICE, "client error on c %d for req of type %d " "with invalid klog sampling %"PRId32"", c->sd, c->req_type, sampling); asc_write_client_error(c); } else { settings.klog_sampling_rate = sampling; asc_write_ok(c); } } } else { log_debug(LOG_NOTICE, "client error on c %d for req of type %d with " "invalid klog subcommand '%.*s'", c->sd, c->req_type, t->len, t->val); asc_write_client_error(c); } }
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); }