static void handle_mget_put(tcp_client* c, struct evbuffer* buffer) {
int rv, i, n;
int ksize, vsize;
char k[MAX_TRANSACTION_SIZE];
char v[MAX_TRANSACTION_SIZE];
val* tmp;
struct evbuffer* b = evbuffer_copy(buffer);
transaction_set_get_cb(c->t, on_mget_put, c);
evbuffer_remove(b, &n, sizeof(int));
for (i = 0; i < n; i++) {
evbuffer_remove(b, &ksize, sizeof(int));
evbuffer_remove(b, k, ksize);
evbuffer_remove(b, &vsize, sizeof(int));
evbuffer_remove(b, v, vsize);
tmp = execute_get(c->t, k, ksize);
if (tmp == NULL) {
evbuffer_free(b);
return;
}
val_free(tmp);
execute_put(c->t, k, ksize, v, vsize);
}
evbuffer_free(b);
evbuffer_drain(buffer, evbuffer_get_length(buffer));
rv = transaction_commit(c->t, c->id, on_commit);
if (rv < 0) {
transaction_clear(c->t);
send_result(c->buffer_ev, -1);
return;
}
evtimer_add(&c->timeout_ev, &commit_timeout);
}
static void handle_mget(tcp_client* c, struct evbuffer* buffer) {
int i, n, ksize;
char k[MAX_TRANSACTION_SIZE];
val* values[64];
struct evbuffer* b = evbuffer_copy(buffer);
for (i = 0; i < 64; i++) values[i] = NULL;
transaction_set_get_cb(c->t, on_mget, c);
evbuffer_remove(b, &n, sizeof(int));
for (i = 0; i < n; i++) {
evbuffer_remove(b, &ksize, sizeof(int));
evbuffer_remove(b, k, ksize);
values[i] = execute_get(c->t, k, ksize);
if (values[i] == NULL)
goto cleanup;
}
// assert(transaction_read_only(c->t));
int rv = transaction_remote_count(c->t);
send_mget_result(c, rv, n, values);
//transaction_clear(c->t);
evbuffer_drain(buffer, evbuffer_get_length(buffer));
cleanup:
evbuffer_free(b);
for (i = 0; i < 64; i++)
if (values[i] != NULL)
val_free(values[i]);
}
void val_destroy(struct value_stack *vg_ptr) {
if(vg_ptr) {
val_free(vg_ptr);
free((void*)vg_ptr);
}
}
/**
* Called from callout queue when it's time to destroy the record.
*/
static void
val_destroy(cqueue_t *unused_cq, void *obj)
{
struct used_val *v = obj;
(void) unused_cq;
g_assert(v);
g_assert(is_host_addr(v->addr));
hevset_remove(used, &v->addr);
v->cq_ev = NULL;
val_free(v);
}
void val_free(val_ptr v) {
switch(v->type) {
case T_STRING:
for (int i = 0; i < v->nkid; i++) {
val_free(v->kid[i]);
}
free(v->s);
free(v->kid);
break;
case T_INT:
break;
}
free(v);
}
static void handle_get(tcp_client* c, struct evbuffer* buffer) {
int ksize;
char k[MAX_TRANSACTION_SIZE];
val* v;
struct evbuffer* b = evbuffer_copy(buffer);
evbuffer_remove(b, &ksize, sizeof(int));
evbuffer_remove(b, k, ksize);
transaction_set_get_cb(c->t, on_get, c);
v = execute_get(c->t, k, ksize);
if (v != NULL) {
evbuffer_drain(buffer, evbuffer_get_length(buffer));
send_get_result(c, v);
val_free(v);
}
evbuffer_free(b);
}
static Klass* _klass_new(uint32_t klass_id, Val name, uint32_t parent_id) {
Klass* k = val_alloc(KLASS_KLASS, sizeof(Klass));
k->id = klass_id;
k->name = name;
k->parent_id = parent_id;
IdMethods.init(&k->id_methods);
Includes.init(&k->includes, 0);
IdFieldIndexes.init(&k->id_field_indexes);
Fields.init(&k->fields, 0);
k->hash_func = NULL;
k->eq_func = NULL;
k->destruct_func = NULL;
k->delete_func = NULL;
k->debug_func = NULL;
val_perm(k);
ConstSearchKey key = {.parent = k->parent_id, .name_str = VAL_TO_STR(k->name)};
KlassSearchMap.insert(&runtime.klass_search_map, key, k->id);
ConstSearchMap.insert(&runtime.const_search_map, key, (Val)k);
return k;
}
static void _klass_delete(Klass* k) {
ConstSearchKey key = {.parent = k->parent_id, .name_str = VAL_TO_STR(k->name)};
KlassSearchMap.remove(&runtime.klass_search_map, key);
ConstSearchMap.remove(&runtime.const_search_map, key);
IdMethods.cleanup(&k->id_methods);
Includes.cleanup(&k->includes);
IdFieldIndexes.cleanup(&k->id_field_indexes);
Fields.cleanup(&k->fields);
val_free(k);
}
static Method* _method_new(uint32_t method_id, int32_t min_argc, int32_t max_argc, bool is_final) {
Method* meth = val_alloc(KLASS_METHOD, sizeof(Method));
METHOD_ID(meth) = method_id;
METHOD_IS_FINAL(meth) = is_final;
METHOD_MIN_ARGC(meth) = min_argc;
METHOD_MAX_ARGC(meth) = max_argc;
val_perm(meth);
return meth;
}
int
p_assign(const char *name, struct value *v, int flag)
{
(void) s_gettok();
if (p_expr(v, flag) < 0) {
p_synerror();
return -1;
}
switch (v->v_type) {
case V_STR:
case V_NUM:
if (name && flag && var_set(name, v) == 0) {
p_memerror();
val_free(*v);
return -1;
}
break;
}
return 0;
}
/*
* name == 0 means we don't have a function name but
* want to parse the arguments anyway. flag == 0 in this case.
*/
int
p_function(const char *name, struct value *v, int flag)
{
struct value t;
struct lcmd_tab *c = NULL;
struct alias *a = NULL;
struct lcmd_arg *ap; /* this arg */
struct lcmd_arg *lp = NULL; /* list arg */
int i;
struct value av[LCMD_NARG + 1];
struct value *vp;
if (name != NULL) {
if ((c = lcmd_lookup(name)))
name = c->lc_name;
else if ((a = alias_lookup(name)))
name = a->a_name;
else {
p_error("%s: No such command or alias.", name);
flag = 0;
}
}
for (vp = av; vp < &av[LCMD_NARG + 1]; vp++)
vp->v_type = V_ERR;
if (token == T_LP)
(void) s_gettok();
i = 0;
for (;;) {
ap = NULL;
vp = NULL;
if (token == T_COMMA) /* null argument */
t.v_type = V_ERR;
else {
if (p_expr0(&t, flag) < 0)
break;
if (t.v_type == V_ERR)
flag = 0;
}
if (token != T_ASSIGN) {
if (i >= LCMD_NARG ||
(c != NULL && (ap = lp) == NULL &&
(ap = c->lc_arg + i)->arg_name == 0)) {
p_error("%s: Too many arguments.", name);
flag = 0;
} else
vp = &av[i++];
} else {
char *tmp;
if (p_convstr(&t) < 0)
goto abort;
tmp = t.v_type == V_STR ? t.v_str : 0;
(void) s_gettok();
if (p_expr(&t, flag) < 0) {
if (tmp)
str_free(tmp);
p_synerror();
goto abort;
}
if (t.v_type == V_ERR)
flag = 0;
if (tmp) {
if (c == NULL) {
/* an aliase */
p_error("%s: Bad alias syntax.", name);
flag = 0;
} else {
for (ap = c->lc_arg, vp = av;
ap != NULL && ap->arg_name != 0 &&
(*ap->arg_name == '\0' ||
!str_match(tmp, ap->arg_name,
ap->arg_minlen));
ap++, vp++)
;
if (ap == NULL || ap->arg_name == 0) {
p_error("%s: Unknown argument \"%s\".",
name, tmp);
flag = 0;
ap = NULL;
vp = NULL;
}
}
str_free(tmp);
}
}
if (ap != NULL) {
if (ap->arg_flags & ARG_LIST) {
i = vp - av + 1;
lp = ap;
}
if (vp && vp->v_type != V_ERR) {
if (*ap->arg_name)
p_error("%s: Argument %d (%s) duplicated.",
name, (int)(vp - av + 1),
ap->arg_name);
else
p_error("%s: Argument %d duplicated.",
name, (int)(vp - av + 1));
flag = 0;
vp = NULL;
} else if (t.v_type == V_ERR) {
/* do nothing */
} else if (((ap->arg_flags&ARG_TYPE) == ARG_NUM &&
t.v_type != V_NUM) ||
((ap->arg_flags&ARG_TYPE) == ARG_STR &&
t.v_type != V_STR)) {
if (*ap->arg_name)
p_error("%s: Argument %d (%s) type mismatch.",
name, (int)(vp - av + 1),
ap->arg_name);
else
p_error("%s: Argument %d type mismatch.",
name, (int)(vp - av + 1));
flag = 0;
vp = NULL;
}
}
if (vp != NULL)
*vp = t;
else
val_free(t);
if (token == T_COMMA)
(void) s_gettok();
}
if (p_erred())
flag = 0;
if (token == T_RP)
(void) s_gettok();
else if (token != T_EOL && token != T_EOF)
flag = 0; /* look for legal follow set */
v->v_type = V_ERR;
if (flag) {
if (c != NULL)
(*c->lc_func)(v, av);
else {
if (a->a_flags & A_INUSE)
p_error("%s: Recursive alias.", a->a_name);
else {
a->a_flags |= A_INUSE;
if (dolongcmd(a->a_buf, av, i) < 0)
p_memerror();
a->a_flags &= ~A_INUSE;
}
}
}
if (p_abort()) {
val_free(*v);
v->v_type = V_ERR;
goto abort;
}
for (vp = av; vp < &av[LCMD_NARG]; vp++)
val_free(*vp);
return 0;
abort:
for (vp = av; vp < &av[LCMD_NARG]; vp++)
val_free(*vp);
return -1;
}
