int process_update_command ( char *key, size_t nkey, uint32_t flags, char *value, size_t nbytes, int32_t exptime_int, int comm )
{
item *it;
enum store_item_type ret;
int32_t vlen = ( int32_t ) nbytes;
if ( exptime_int < 0 )
exptime_int = REALTIME_MAXDELTA + 1;
vlen += 2;
if ( vlen < 0 || vlen - 2 < 0 )
{
return false;
}
it = item_alloc (key, nkey, flags, realtime (exptime_int), value, vlen);
if ( it == 0 )
{
if ( comm == NREAD_SET )
{
it = item_get (key, nkey);
if ( it )
{
item_unlink (it);
item_remove (it);
}
}
return false;
}
ret = store_item (it, comm);
item_remove (it);
if ( ret != STORED )
{
return false;
}
return true;
}
int ptslist_chekin(ptslist_mgr_t *mgr, int64_t off, int64_t pts)
{
struct item *newitem;
int ret;
if (off < 0 || pts < 0) {
return -1; //not valied off and pts;
}
newitem = item_alloc(mgr->ptsitem.item_ext_buf_size);
if (!newitem) {
av_log(NULL, AV_LOG_INFO, "ptslist_chekin-fialed,no memory!\n");
return AVERROR(ENOMEM);
}
newitem->item_data = mgr->index++;
ITEM_OFF(newitem) = off;
ITEM_PTS(newitem) = pts;
mgr->lastoffset = off;
ret = itemlist_add_tail(&mgr->ptsitem, newitem);
if (ret) { /*item list fulled,del oldest one.*/
struct item *t;
t = itemlist_get_head(&mgr->ptsitem);
if (t) {
item_free(t);
}
ret = itemlist_add_tail(&mgr->ptsitem, newitem);
}
return ret;
}
/*
margin:
in:
<0,any,
0,real matched,
>0: pts-off>=off && (pts->off-off)<=margin
out:
(pts->off-off)
pts:
out;
*/
int ptslist_lookup(ptslist_mgr_t *mgr, int64_t off, int64_t *pts, int *margin)
{
struct item *temp;
struct item *find;
int reverse = 0;
int omargin = *margin;
int err = -1;
temp = item_alloc(mgr->ptsitem.item_ext_buf_size);
if (!temp) {
return -1;
}
ITEM_OFF(temp) = off;
if (mgr->lastoffset - off < off) {
reverse = 1;
}
find = itemlist_find_match_item_ex(&mgr->ptsitem, temp, ptslist_is_wanted, reverse);
if (!find) {
err = -2;
goto errout;
}
*pts = ITEM_PTS(find);
*margin = (int)(ITEM_OFF(find) - off);
if (omargin < 0 || *margin <= omargin) {
err = -0;
} else {
err = -3;
}
errout:
item_free(temp);
return err;
}
void
Add_Item_Dup ( LNK_LST *lst, tlst_val val )
{
LST_ITM *p;
LST_ITM *last;
if (LST_Empty(lst)) {
LST_first(lst) = p = item_alloc();
LST_val(p) = val;
incr_LST_len(lst);
return;
}
/*
* Find the end of the list.
*/
last = NULL; /* unnecessary except to eliminate warning msg */
for (p=LST_first(lst); p!=NULL; p=LST_next(p))
last = p;
/*
* Append a new item to the end of the list.
*/
LST_next(last) = p = item_alloc();
LST_val(p) = val;
incr_LST_len(lst);
/*
* If the pointer to the next item in the list is NULL, i.e. when
* stepping through the list the end was reached, then make the next
* item be this new item.
*/
if (LST_nxt(lst) == NULL)
LST_nxt(lst) = p;
#ifdef BB_VALIDATE_LIST
Validate_List ( lst );
#endif
return;
}
void
Add_First_Item ( LNK_LST *lst, tlst_val val )
{
register LST_ITM *p;
p = item_alloc();
LST_val(p) = val;
LST_next(p) = LST_first(lst);
LST_first(lst) = p;
incr_LST_len(lst);
}
BOOL
Add_Item ( LNK_LST *lst, tlst_val val)
{
register LST_ITM *p, *last;
if (LST_Empty(lst)) {
LST_first(lst) = p = item_alloc();
LST_val(p) = val;
incr_LST_len(lst);
return TRUE;
}
last = NULL; /* unnecessary except to eliminate warning msg */
for (p=LST_first(lst); p!=NULL; p=LST_next(p)) {
if (LST_val(p) == val)
return FALSE; /* already in the list => return FALSE */
last = p;
}
/*
* If we get to here, we went through the list without finding a
* matching item. Append a new item to the end of the list.
*/
LST_next(last) = p = item_alloc();
LST_val(p) = val;
incr_LST_len(lst);
/*
* If the pointer to the next item in the list is NULL, i.e. when
* stepping through the list the end was reached, then make the next
* item be this new item.
*/
if (LST_nxt(lst) == NULL)
LST_nxt(lst) = p;
return TRUE;
}
int ffmpeg_pthread_create(pthread_t *thread_out, pthread_attr_t const * attr,
void *(*start_routine)(void *), void * arg)
{
int ret;
pthread_t pid;
ret=pthread_create(&pid,attr,start_routine,arg);
if(ret==0){
*thread_out=pid;
struct item *piditem= item_alloc(4);
if(piditem){
piditem->item_data=pid;
piditem->extdata[0]=pthread_self();
av_log(NULL, AV_LOG_INFO, "ffmpeg_pthread_create add map tid=%u,ptid=%u\n",pid,piditem->extdata[0]);
if(itemlist_add_tail(&pidlist,piditem)!=0)
item_free(piditem);
/*ignore all errors...*/
}
}
return ret;
}
void cproxy_process_upstream_binary(conn *c) {
cb_assert(c != NULL);
cb_assert(c->cmd >= 0);
cb_assert(c->next == NULL);
cb_assert(c->item == NULL);
cb_assert(IS_BINARY(c->protocol));
cb_assert(IS_PROXY(c->protocol));
proxy_td *ptd = c->extra;
cb_assert(ptd != NULL);
if (!cproxy_prep_conn_for_write(c)) {
ptd->stats.stats.err_upstream_write_prep++;
conn_set_state(c, conn_closing);
return;
}
c->cmd_curr = -1;
c->cmd_start = NULL;
c->cmd_start_time = msec_current_time;
c->cmd_retries = 0;
int extlen = c->binary_header.request.extlen;
int keylen = c->binary_header.request.keylen;
uint32_t bodylen = c->binary_header.request.bodylen;
cb_assert(bodylen >= (uint32_t) keylen + extlen);
if (settings.verbose > 2) {
moxi_log_write("<%d cproxy_process_upstream_binary %x %d %d %u\n",
c->sfd, c->cmd, extlen, keylen, bodylen);
}
process_bin_noreply(c); /* Map quiet c->cmd values into non-quiet. */
if (c->cmd == PROTOCOL_BINARY_CMD_VERSION ||
c->cmd == PROTOCOL_BINARY_CMD_QUIT) {
dispatch_bin_command(c);
return;
}
/* Alloc an item and continue with an rest-of-body nread if */
/* necessary. The item will hold the entire request message */
/* (the header + body). */
char *ikey = "u";
int ikeylen = 1;
c->item = item_alloc(ikey, ikeylen, 0, 0,
sizeof(c->binary_header) + bodylen);
if (c->item != NULL) {
item *it = c->item;
void *rb = c->rcurr;
cb_assert(it->refcount == 1);
memcpy(ITEM_data(it), rb, sizeof(c->binary_header));
if (bodylen > 0) {
c->ritem = ITEM_data(it) + sizeof(c->binary_header);
c->rlbytes = bodylen;
c->substate = bin_read_set_value;
conn_set_state(c, conn_nread);
} else {
/* Since we have no body bytes, we can go immediately to */
/* the nread completed processing step. */
if (c->binary_header.request.opcode == PROTOCOL_BINARY_CMD_SASL_LIST_MECHS) {
/* TODO: One day handle more than just PLAIN sasl auth. */
write_bin_response(c, "PLAIN", 0, 0, strlen("PLAIN"));
return;
}
cproxy_pause_upstream_for_downstream(ptd, c);
}
} else {
if (settings.verbose > 2) {
moxi_log_write("<%d cproxy_process_upstream_binary OOM\n",
c->sfd);
}
ptd->stats.stats.err_oom++;
cproxy_close_conn(c);
}
}
/* Called when we receive a binary response header from
* a downstream server, via try_read_command()/drive_machine().
*/
void cproxy_process_b2b_downstream(conn *c) {
char *ikey;
int ikeylen;
downstream *d;
int extlen;
int keylen;
uint32_t bodylen;
cb_assert(c != NULL);
cb_assert(c->cmd >= 0);
cb_assert(c->next == NULL);
cb_assert(c->item == NULL);
cb_assert(IS_BINARY(c->protocol));
cb_assert(IS_PROXY(c->protocol));
cb_assert(c->substate == bin_no_state);
d = c->extra;
cb_assert(d);
c->cmd_curr = -1;
c->cmd_start = NULL;
c->cmd_start_time = msec_current_time;
c->cmd_retries = 0;
extlen = c->binary_header.request.extlen;
keylen = c->binary_header.request.keylen;
bodylen = c->binary_header.request.bodylen;
if (settings.verbose > 2) {
moxi_log_write("<%d cproxy_process_b2b_downstream %x %d %d %u\n",
c->sfd, c->cmd, extlen, keylen, bodylen);
}
cb_assert(bodylen >= (uint32_t) keylen + extlen);
process_bin_noreply(c); /* Map quiet c->cmd values into non-quiet. */
/* Our approach is to read everything we can before */
/* getting into big switch/case statements for the */
/* actual processing. */
/* Alloc an item and continue with an rest-of-body nread if */
/* necessary. The item will hold the entire response message */
/* (the header + body). */
ikey = "q";
ikeylen = 1;
c->item = item_alloc(ikey, ikeylen, 0, 0,
sizeof(c->binary_header) + bodylen);
if (c->item != NULL) {
item *it = c->item;
void *rb = c->rcurr;
cb_assert(it->refcount == 1);
memcpy(ITEM_data(it), rb, sizeof(c->binary_header));
if (bodylen > 0) {
c->ritem = ITEM_data(it) + sizeof(c->binary_header);
c->rlbytes = bodylen;
c->substate = bin_read_set_value;
conn_set_state(c, conn_nread);
} else {
/* Since we have no body bytes, we can go immediately to */
/* the nread completed processing step. */
cproxy_process_b2b_downstream_nread(c);
}
} else {
d->ptd->stats.stats.err_oom++;
cproxy_close_conn(c);
}
}
/* Used for broadcast commands, like no-op, flush_all or stats.
*/
bool cproxy_broadcast_b2b_downstream(downstream *d, conn *uc) {
int nwrite = 0;
int nconns;
int i;
cb_assert(d != NULL);
cb_assert(d->ptd != NULL);
cb_assert(d->ptd->proxy != NULL);
cb_assert(d->downstream_conns != NULL);
cb_assert(uc != NULL);
cb_assert(uc->next == NULL);
cb_assert(uc->noreply == false);
nconns = mcs_server_count(&d->mst);
for (i = 0; i < nconns; i++) {
conn *c = d->downstream_conns[i];
if (c != NULL &&
c != NULL_CONN &&
b2b_forward_item_vbucket(uc, d, uc->item, c, -1) == true) {
nwrite++;
}
}
if (settings.verbose > 2) {
moxi_log_write("%d: b2b broadcast nwrite %d out of %d\n",
uc->sfd, nwrite, nconns);
}
if (nwrite > 0) {
/* TODO: Handle binary 'stats reset' sub-command. */
item *it;
if (uc->cmd == PROTOCOL_BINARY_CMD_STAT &&
d->merger == NULL) {
d->merger = genhash_init(128, skeyhash_ops);
}
it = item_alloc("h", 1, 0, 0,
sizeof(protocol_binary_response_header));
if (it != NULL) {
protocol_binary_response_header *header =
(protocol_binary_response_header *) ITEM_data(it);
memset(ITEM_data(it), 0, it->nbytes);
header->response.magic = (uint8_t) PROTOCOL_BINARY_RES;
header->response.opcode = uc->binary_header.request.opcode;
header->response.opaque = uc->opaque;
if (add_conn_item(uc, it)) {
d->upstream_suffix = ITEM_data(it);
d->upstream_suffix_len = it->nbytes;
d->upstream_status = PROTOCOL_BINARY_RESPONSE_SUCCESS;
d->target_host_ident = NULL;
if (settings.verbose > 2) {
moxi_log_write("%d: b2b broadcast upstream_suffix", uc->sfd);
cproxy_dump_header(uc->sfd, ITEM_data(it));
}
/* TODO: Handle FLUSHQ (quiet binary flush_all). */
d->downstream_used_start = nwrite;
d->downstream_used = nwrite;
cproxy_start_downstream_timeout(d, NULL);
return true;
}
item_remove(it);
}
}
return false;
}
void
Add_Ordered_Item_Dupl ( LNK_LST *lst, tlst_val val )
{
register LST_ITM *p, *last;
register tlst_val this_val;
if (LST_Empty(lst)) {
LST_first(lst) = p = item_alloc();
LST_val(p) = val;
incr_LST_len(lst);
return;
}
p = LST_first(lst);
this_val = LST_val(p);
if ( val <= this_val ) { /* insert at beginning of the list */
register LST_ITM *new = item_alloc();
LST_next(new) = p;
LST_first(lst) = new;
LST_val(new) = val;
incr_LST_len(lst);
return;
}
last = p;
for ( p=LST_next(p); p!=NULL; p=LST_next(p)) {
#ifdef LNK_LST_CHECK
Is_True ( this_val <= LST_val(p),
("ordered list not sorted: elems %d and %d",this_val,LST_val(p)));
#endif /* LNK_LST_CHECK */
this_val = LST_val(p);
if ( val <= this_val ) { /* insert here */
register LST_ITM *new = item_alloc();
LST_next(new) = p;
LST_next(last) = new;
LST_val(new) = val;
incr_LST_len(lst);
return;
}
last = p;
}
/*
* If we get to here, we went through the list without finding a
* matching item, and all items in the list have values less than
* the new value. Append a new item to the end of the list.
*/
LST_next(last) = p = item_alloc();
LST_val(p) = val;
incr_LST_len(lst);
/*
* If the pointer to the next item in the list is NULL, i.e. when
* stepping through the list the end was reached, then make the next
* item be this new item.
*/
if (LST_nxt(lst) == NULL)
LST_nxt(lst) = p;
}
void process_command(conn *c, char *command) {
int comm = 0;
int incr = 0;
/*
* for commands set/add/replace, we build an item and read the data
* directly into it, then continue in nread_complete().
*/
if (settings.verbose > 1)
fprintf(stderr, "<%d %s\n", c->sfd, command);
/* All incoming commands will require a response, so we cork at the beginning,
and uncork at the very end (usually by means of out_string) */
set_cork(c, 1);
if ((strncmp(command, "add ", 4) == 0 && (comm = NREAD_ADD)) ||
(strncmp(command, "set ", 4) == 0 && (comm = NREAD_SET)) ||
(strncmp(command, "replace ", 8) == 0 && (comm = NREAD_REPLACE))) {
char key[251];
int flags;
time_t expire;
int len, res;
item *it;
res = sscanf(command, "%*s %250s %u %ld %d\n", key, &flags, &expire, &len);
if (res!=4 || strlen(key)==0 ) {
out_string(c, "CLIENT_ERROR bad command line format");
return;
}
expire = realtime(expire);
it = item_alloc(key, flags, expire, len+2);
if (it == 0) {
out_string(c, "SERVER_ERROR out of memory");
/* swallow the data line */
c->write_and_go = conn_swallow;
c->sbytes = len+2;
return;
}
c->item_comm = comm;
c->item = it;
c->rcurr = ITEM_data(it);
c->rlbytes = it->nbytes;
c->state = conn_nread;
return;
}
if ((strncmp(command, "incr ", 5) == 0 && (incr = 1)) ||
(strncmp(command, "decr ", 5) == 0)) {
char temp[32];
unsigned int value;
item *it;
unsigned int delta;
char key[251];
int res;
char *ptr;
time_t now = time(0);
res = sscanf(command, "%*s %250s %u\n", key, &delta);
if (res!=2 || strlen(key)==0 ) {
out_string(c, "CLIENT_ERROR bad command line format");
return;
}
it = assoc_find(key);
if (it && (it->it_flags & ITEM_DELETED)) {
it = 0;
}
if (it && it->exptime && it->exptime < now) {
item_unlink(it);
it = 0;
}
if (!it) {
out_string(c, "NOT_FOUND");
return;
}
ptr = ITEM_data(it);
while (*ptr && (*ptr<'0' && *ptr>'9')) ptr++;
value = atoi(ptr);
if (incr)
value+=delta;
else {
if (delta >= value) value = 0;
else value-=delta;
}
sprintf(temp, "%u", value);
res = strlen(temp);
if (res + 2 > it->nbytes) { /* need to realloc */
item *new_it;
new_it = item_alloc(ITEM_key(it), it->flags, it->exptime, res + 2 );
if (new_it == 0) {
out_string(c, "SERVER_ERROR out of memory");
return;
}
memcpy(ITEM_data(new_it), temp, res);
memcpy(ITEM_data(new_it) + res, "\r\n", 2);
item_replace(it, new_it);
} else { /* replace in-place */
memcpy(ITEM_data(it), temp, res);
memset(ITEM_data(it) + res, ' ', it->nbytes-res-2);
}
out_string(c, temp);
return;
}
if (strncmp(command, "get ", 4) == 0) {
char *start = command + 4;
char key[251];
int next;
int i = 0;
item *it;
time_t now = time(0);
while(sscanf(start, " %250s%n", key, &next) >= 1) {
start+=next;
stats.get_cmds++;
it = assoc_find(key);
if (it && (it->it_flags & ITEM_DELETED)) {
it = 0;
}
if (settings.oldest_live && it &&
it->time <= settings.oldest_live) {
item_unlink(it);
it = 0;
}
if (it && it->exptime && it->exptime < now) {
item_unlink(it);
it = 0;
}
if (it) {
if (i >= c->isize) {
item **new_list = realloc(c->ilist, sizeof(item *)*c->isize*2);
if (new_list) {
c->isize *= 2;
c->ilist = new_list;
} else break;
}
stats.get_hits++;
it->refcount++;
item_update(it);
*(c->ilist + i) = it;
i++;
} else stats.get_misses++;
}
c->icurr = c->ilist;
c->ileft = i;
if (c->ileft) {
c->ipart = 0;
c->state = conn_mwrite;
c->ibytes = 0;
return;
} else {
out_string(c, "END");
return;
}
}
if (strncmp(command, "delete ", 7) == 0) {
char key[251];
item *it;
int res;
time_t exptime = 0;
res = sscanf(command, "%*s %250s %ld", key, &exptime);
it = assoc_find(key);
if (!it) {
out_string(c, "NOT_FOUND");
return;
}
if (exptime == 0) {
item_unlink(it);
out_string(c, "DELETED");
return;
}
if (delcurr >= deltotal) {
item **new_delete = realloc(todelete, sizeof(item *) * deltotal * 2);
if (new_delete) {
todelete = new_delete;
deltotal *= 2;
} else {
/*
* can't delete it immediately, user wants a delay,
* but we ran out of memory for the delete queue
*/
out_string(c, "SERVER_ERROR out of memory");
return;
}
}
exptime = realtime(exptime);
it->refcount++;
/* use its expiration time as its deletion time now */
it->exptime = exptime;
it->it_flags |= ITEM_DELETED;
todelete[delcurr++] = it;
out_string(c, "DELETED");
return;
}
if (strncmp(command, "stats", 5) == 0) {
process_stat(c, command);
return;
}
if (strcmp(command, "flush_all") == 0) {
settings.oldest_live = time(0);
out_string(c, "OK");
return;
}
if (strcmp(command, "version") == 0) {
out_string(c, "VERSION " VERSION);
return;
}
if (strcmp(command, "quit") == 0) {
c->state = conn_closing;
return;
}
if (strncmp(command, "slabs reassign ", 15) == 0) {
int src, dst;
char *start = command+15;
if (sscanf(start, "%u %u\r\n", &src, &dst) == 2) {
int rv = slabs_reassign(src, dst);
if (rv == 1) {
out_string(c, "DONE");
return;
}
if (rv == 0) {
out_string(c, "CANT");
return;
}
if (rv == -1) {
out_string(c, "BUSY");
return;
}
}
out_string(c, "CLIENT_ERROR bogus command");
return;
}
out_string(c, "ERROR");
return;
}
void process_command(conn *c, char *command) {
int comm = 0;
/*
* for commands set/add/replace, we build an item and read the data
* directly into it, then continue in nread_complete().
*/
if ((strncmp(command, "add ", 4) == 0 && (comm = NREAD_ADD)) ||
(strncmp(command, "set ", 4) == 0 && (comm = NREAD_SET)) ||
(strncmp(command, "replace ", 8) == 0 && (comm = NREAD_REPLACE))) {
char s_comm[10];
char key[256];
int flags;
time_t expire;
int len, res;
item *it;
res = sscanf(command, "%s %s %u %u %d\n", s_comm, key, &flags, &expire, &len);
if (res!=5 || strlen(key)==0 ) {
out_string(c, "CLIENT_ERROR bad command line format");
return;
}
it = item_alloc(key, flags, expire, len+2);
if (it == 0) {
out_string(c, "SERVER_ERROR out of memory");
c->write_and_close = 1;
return;
}
c->item_comm = comm;
c->item = it;
c->rcurr = it->data;
c->rlbytes = it->nbytes;
c->state = conn_nread;
return;
}
if (strncmp(command, "get ", 4) == 0) {
char *start = command + 4;
char key[256];
int next;
int i = 0;
item *it;
time_t now = time(0);
while(sscanf(start, " %s%n", key, &next) >= 1) {
start+=next;
stats.get_cmds++;
it = (item *)assoc_find(key);
if (it && (it->it_flags & ITEM_DELETED)) {
it = 0;
}
if (it && it->exptime && it->exptime < now) {
item_unlink(it);
it = 0;
}
if (it) {
stats.get_hits++;
it->usecount++;
item_update(it);
*(c->ilist + i) = it;
i++;
if (i > c->isize) {
c->isize *= 2;
c->ilist = realloc(c->ilist, sizeof(item *)*c->isize);
}
} else stats.get_misses++;
}
c->icurr = c->ilist;
c->ileft = i;
if (c->ileft) {
c->ipart = 0;
c->state = conn_mwrite;
c->ibytes = 0;
return;
} else {
out_string(c, "END");
return;
}
}
if (strncmp(command, "delete ", 7) == 0) {
char key [256];
char *start = command+7;
item *it;
sscanf(start, " %s", key);
it = assoc_find(key);
if (!it) {
out_string(c, "NOT_FOUND");
return;
} else {
it->usecount++;
/* use its expiration time as its deletion time now */
it->exptime = time(0) + 4;
it->it_flags |= ITEM_DELETED;
todelete[delcurr++] = it;
if (delcurr >= deltotal) {
deltotal *= 2;
todelete = realloc(todelete, sizeof(item *)*deltotal);
}
}
out_string(c, "DELETED");
return;
}
if (strncmp(command, "stats", 5) == 0) {
process_stat(c, command);
return;
}
if (strcmp(command, "version") == 0) {
out_string(c, "VERSION 2.0");
return;
}
out_string(c, "ERROR");
return;
}
void protocol_stats_foreach_write(const void *key,
const void *value,
void *user_data) {
char *line = (char *) value;
conn *uc = (conn *) user_data;
int nline;
cb_assert(line != NULL);
cb_assert(uc != NULL);
(void)key;
nline = strlen(line);
if (nline > 0) {
item *it;
if (settings.verbose > 2) {
moxi_log_write("%d: cproxy_stats writing: %s\n", uc->sfd, line);
}
if (IS_BINARY(uc->protocol)) {
token_t line_tokens[MAX_TOKENS];
size_t line_ntokens = scan_tokens(line, line_tokens, MAX_TOKENS, NULL);
if (line_ntokens == 4) {
uint16_t key_len = line_tokens[NAME_TOKEN].length;
uint32_t data_len = line_tokens[VALUE_TOKEN].length;
it = item_alloc("s", 1, 0, 0,
sizeof(protocol_binary_response_stats) + key_len + data_len);
if (it != NULL) {
protocol_binary_response_stats *header =
(protocol_binary_response_stats *) ITEM_data(it);
memset(ITEM_data(it), 0, it->nbytes);
header->message.header.response.magic = (uint8_t) PROTOCOL_BINARY_RES;
header->message.header.response.opcode = uc->binary_header.request.opcode;
header->message.header.response.keylen = (uint16_t) htons(key_len);
header->message.header.response.bodylen = htonl(key_len + data_len);
header->message.header.response.opaque = uc->opaque;
memcpy((ITEM_data(it)) + sizeof(protocol_binary_response_stats),
line_tokens[NAME_TOKEN].value, key_len);
memcpy((ITEM_data(it)) + sizeof(protocol_binary_response_stats) + key_len,
line_tokens[VALUE_TOKEN].value, data_len);
if (add_conn_item(uc, it)) {
add_iov(uc, ITEM_data(it), it->nbytes);
if (settings.verbose > 2) {
moxi_log_write("%d: cproxy_stats writing binary", uc->sfd);
cproxy_dump_header(uc->sfd, ITEM_data(it));
}
return;
}
item_remove(it);
}
}
return;
}
it = item_alloc("s", 1, 0, 0, nline + 2);
if (it != NULL) {
strncpy(ITEM_data(it), line, nline);
strncpy(ITEM_data(it) + nline, "\r\n", 2);
if (add_conn_item(uc, it)) {
add_iov(uc, ITEM_data(it), nline + 2);
return;
}
item_remove(it);
}
}
}
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);
}
void cproxy_process_a2a_downstream(conn *c, char *line) {
assert(c != NULL);
assert(c->next == NULL);
assert(c->extra != NULL);
assert(c->cmd == -1);
assert(c->item == NULL);
assert(line != NULL);
assert(line == c->rcurr);
assert(IS_ASCII(c->protocol));
assert(IS_PROXY(c->protocol));
if (settings.verbose > 1)
fprintf(stderr, "<%d cproxy_process_a2a_downstream %s\n",
c->sfd, line);
downstream *d = c->extra;
assert(d != NULL);
assert(d->ptd != NULL);
assert(d->ptd->proxy != NULL);
if (strncmp(line, "VALUE ", 6) == 0) {
token_t tokens[MAX_TOKENS];
size_t ntokens;
unsigned int flags;
int clen = 0;
int vlen;
uint64_t cas = CPROXY_NOT_CAS;
ntokens = scan_tokens(line, tokens, MAX_TOKENS, &clen);
if (ntokens >= 5 && // Accounts for extra termimation token.
ntokens <= 6 &&
tokens[KEY_TOKEN].length <= KEY_MAX_LENGTH &&
safe_strtoul(tokens[2].value, (uint32_t *) &flags) &&
safe_strtoul(tokens[3].value, (uint32_t *) &vlen)) {
char *key = tokens[KEY_TOKEN].value;
size_t nkey = tokens[KEY_TOKEN].length;
item *it = item_alloc(key, nkey, flags, 0, vlen + 2);
if (it != NULL) {
if (ntokens == 5 ||
safe_strtoull(tokens[4].value, &cas)) {
ITEM_set_cas(it, cas);
c->item = it;
c->ritem = ITEM_data(it);
c->rlbytes = it->nbytes;
c->cmd = -1;
conn_set_state(c, conn_nread);
return; // Success.
} else {
if (settings.verbose > 1)
fprintf(stderr, "cproxy could not parse cas\n");
}
} else {
if (settings.verbose > 1)
fprintf(stderr, "cproxy could not item_alloc size %u\n",
vlen + 2);
}
if (it != NULL)
item_remove(it);
it = NULL;
c->sbytes = vlen + 2; // Number of bytes to swallow.
conn_set_state(c, conn_swallow);
// Note, eventually, we'll see an END later.
} else {
// We don't know how much to swallow, so close the downstream.
// The conn_closing should release the downstream,
// which should write a suffix/error to the upstream.
//
conn_set_state(c, conn_closing);
}
} else if (strncmp(line, "END", 3) == 0) {
conn_set_state(c, conn_pause);
} else if (strncmp(line, "OK", 2) == 0) {
conn_set_state(c, conn_pause);
// TODO: Handle flush_all's expiration parameter against
// the front_cache.
//
// TODO: We flush the front_cache too often, inefficiently
// on every downstream flush_all OK response, rather than
// on just the last flush_all OK response.
//
conn *uc = d->upstream_conn;
if (uc != NULL &&
uc->cmd_curr == PROTOCOL_BINARY_CMD_FLUSH) {
mcache_flush_all(&d->ptd->proxy->front_cache, 0);
}
} else if (strncmp(line, "STAT ", 5) == 0 ||
strncmp(line, "ITEM ", 5) == 0 ||
strncmp(line, "PREFIX ", 7) == 0) {
assert(d->merger != NULL);
conn *uc = d->upstream_conn;
if (uc != NULL) {
assert(uc->next == NULL);
if (protocol_stats_merge_line(d->merger, line) == false) {
// Forward the line as-is if we couldn't merge it.
//
int nline = strlen(line);
item *it = item_alloc("s", 1, 0, 0, nline + 2);
if (it != NULL) {
strncpy(ITEM_data(it), line, nline);
strncpy(ITEM_data(it) + nline, "\r\n", 2);
if (add_conn_item(uc, it)) {
add_iov(uc, ITEM_data(it), nline + 2);
it = NULL;
}
if (it != NULL)
item_remove(it);
}
}
}
conn_set_state(c, conn_new_cmd);
} else {
conn_set_state(c, conn_pause);
// The upstream conn might be NULL when closed already
// or while handling a noreply.
//
conn *uc = d->upstream_conn;
if (uc != NULL) {
assert(uc->next == NULL);
out_string(uc, line);
if (!update_event(uc, EV_WRITE | EV_PERSIST)) {
if (settings.verbose > 1)
fprintf(stderr,
"Can't update upstream write event\n");
d->ptd->stats.stats.err_oom++;
cproxy_close_conn(uc);
}
cproxy_del_front_cache_key_ascii_response(d, line,
uc->cmd_start);
}
}
}
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);
}
