void *erlXML_CharacterDataHandler(expat_data *d,
const XML_Char *s,
int len)
{
ei_x_encode_list_header(&event_buf, 1);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_long(&event_buf, XML_CDATA);
ei_x_encode_binary(&event_buf, s, len);
return NULL;
}
/* format a string into an ei_x_buff, except the version token */
static int eiformat(const char** fmt, union arg** args, ei_x_buff* x)
{
const char* p = *fmt;
int res;
ei_x_buff x2;
while (isspace((int)*p))
++p;
switch (*p) {
case '~':
res = pformat(&p, args, x);
break;
case '[':
res = ei_x_new(&x2);
if (res >= 0)
res = plist(&p, args, &x2, 0);
if (res > 0)
res = ei_x_encode_list_header(x, res);
if (res >= 0)
res = ei_x_append(x, &x2);
ei_x_free(&x2);
break;
case '{':
res = ei_x_new(&x2);
if (res >= 0)
res = ptuple(&p, args, &x2, 0);
if (res >= 0)
res = ei_x_encode_tuple_header(x, res);
if (res >= 0)
res = ei_x_append(x, &x2);
ei_x_free(&x2);
break;
case '"':
res = pstring(&p, x);
break;
case '\'':
res = pquotedatom(&p, x);
break;
default:
if (isdigit((int)*p))
res = pdigit(&p, x);
else if ((*p == '-' || *p == '+') && isdigit((int)*(p+1)))
res = pdigit(&p, x);
else if (islower((int)*p))
res = patom(&p, x);
else
res = -1;
break;
/*
Variables
*/
}
*fmt = p;
return res;
}
static int erl_json_ei_start_array(void* ctx) {
State* pState = (State*) ctx;
flog(stderr, "start array", 0, 0, 0);
list_header_for_value(pState);
pState->skip_list_header_for_value = pState->ei_buf.index;
ei_x_encode_list_header(&pState->ei_buf, 1);
return 1;
}
int ei_x_encode_general_list(ei_x_buff* types, ei_x_buff* values, K r, QOpts* opts) {
LOG("ei_x_encode_general_list length "FMT_KN"\n", r->n);
EI(ei_x_encode_tuple_header(types, 2));
EI(ei_x_encode_atom(types, "list"));
if(r->n > 0) {
int all_strings = 1;
EI(ei_x_encode_list_header(values, r->n));
int i;
for(i=0; i<r->n; ++i) {
K elem = kK(r)[i];
if(elem->t != KC) {
all_strings = 0;
break;
}
EI(ei_x_encode_string_len(values, (const char*)kC(elem), elem->n));
}
if(all_strings) {
EI(ei_x_encode_atom(types, "string"));
} else {
EI(ei_x_encode_list_header(types, r->n));
int j;
for(j=0; j<i; ++j) {
EI(ei_x_encode_atom(types, "string"));
}
for(; i<r->n; ++i) {
EI(ei_x_encode_k_tv(types, values, kK(r)[i], opts));
}
EI(ei_x_encode_empty_list(types));
}
} else {
EI(ei_x_encode_empty_list(types));
}
EI(ei_x_encode_empty_list(values));
return 0;
}
/* function to make rpc call to remote node to retrieve a pid -
calls module:function(Ref). The response comes back as
{rex, {Ref, Pid}}
*/
int ei_pid_from_rpc(struct ei_cnode_s *ec, int sockfd, erlang_ref * ref, char *module, char *function)
{
ei_x_buff buf;
ei_x_new(&buf);
ei_x_encode_list_header(&buf, 1);
ei_x_encode_ref(&buf, ref);
ei_x_encode_empty_list(&buf);
ei_rpc_to(ec, sockfd, module, function, buf.buff, buf.index);
ei_x_free(&buf);
return 0;
}
int srdb1_encode_c(const db_key_t* _c, const int _nc, ei_x_buff *argbuf){
int i;
if(_c) {
ei_x_encode_list_header(argbuf, _nc);
for(i = 0; i < _nc; i++) {
ei_x_encode_atom_len(argbuf,_c[i]->s,_c[i]->len);
}
ei_x_encode_empty_list(argbuf);
} else {
ei_x_encode_atom(argbuf,"all");
}
return 0;
}
void encode_result(ei_x_buff* x, PGresult* res, PGconn* conn)
{
int row, n_rows, col, n_cols, fsize;
switch (PQresultStatus(res)) {
case PGRES_TUPLES_OK:
n_rows = PQntuples(res);
n_cols = PQnfields(res);
ei_x_encode_tuple_header(x, 2);
encode_ok(x);
ei_x_encode_list_header(x, 1);
for (col = 0; col < n_cols; ++col) {
ei_x_encode_list_header(x, 1);
ei_x_encode_string(x, PQfname(res, col));
}
ei_x_encode_empty_list(x);
for (row = 0; row < n_rows; ++row) {
ei_x_encode_list_header(x, 1);
for (col = 0; col < n_cols; ++col) {
ei_x_encode_list_header(x, 1);
fsize = PQgetlength(res, row, col);
ei_x_encode_binary(x, PQgetvalue(res, row, col), fsize);
}
ei_x_encode_empty_list(x);
}
ei_x_encode_empty_list(x);
break;
case PGRES_COMMAND_OK:
ei_x_encode_tuple_header(x, 2);
encode_ok(x);
ei_x_encode_string(x, PQcmdTuples(res));
break;
default:
encode_error(x, conn);
break;
}
}
static void make_reply_list(ei_x_buff *xbuf, char *buff, int *index) {
gint arity, i;
if ( ! ((arity = gn_get_list(xbuf, buff, index)) > -1) )
return;
gn_wrap_ans("reply",xbuf);
for (i = 0; i < arity; i++) {
ei_x_encode_list_header(xbuf, 1);
if ( ! make_reply(xbuf, buff, index) )
break;
}
ei_x_encode_empty_list(xbuf);
}
static ErlDrvSSizeT expat_erl_control(ErlDrvData drv_data,
unsigned int command,
char *buf, ErlDrvSizeT len,
char **rbuf, ErlDrvSizeT rlen)
{
expat_data* d = (expat_data*)drv_data;
int res, errcode;
char *errstring;
ErlDrvBinary *b;
size_t size;
switch (command)
{
case PARSE_COMMAND:
case PARSE_FINAL_COMMAND:
ei_x_new_with_version(&event_buf);
ei_x_new(&xmlns_buf);
res = XML_Parse(d->parser, buf, len, command == PARSE_FINAL_COMMAND);
if(!res)
{
errcode = XML_GetErrorCode(d->parser);
errstring = (char *)XML_ErrorString(errcode);
ei_x_encode_list_header(&event_buf, 1);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_long(&event_buf, XML_ERROR);
ei_x_encode_tuple_header(&event_buf, 2);
ei_x_encode_long(&event_buf, errcode);
ei_x_encode_binary(&event_buf, errstring, strlen(errstring));
}
ei_x_encode_empty_list(&event_buf);
size = event_buf.index;
b = driver_alloc_binary(size);
memcpy(b->orig_bytes, event_buf.buff, size);
ei_x_free(&event_buf);
ei_x_free(&xmlns_buf);
*rbuf = (char *)b;
return size;
default:
return 0;
}
}
static ei_x_buff pack_parse_data(parse_result parse_result_){
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x,2);
//{caly_tekst,[link]} kodujemy caly tekst
ei_x_encode_string(&x, parse_result_.second.c_str());
int link_list_length = parse_result_.first.size();
ei_x_encode_list_header(&x,link_list_length);
vector<std::string>& links = parse_result_.first;
for (vector<std::string>::iterator it = links.begin(); it != links.end(); it++){
ei_x_encode_string_len(&x,(*it).c_str(),(*it).size());
}
ei_x_encode_empty_list(&x);
return x;
}
int ei_x_encode_same_list_datetime(ei_x_buff* types, ei_x_buff* values, K r, QOpts* opts) {
if(opts->unix_timestamp_is_q_datetime) {
EI(ei_x_encode_tuple_header(types, 2));
EI(ei_x_encode_atom(types, "list"));
EI(ei_x_encode_atom(types, "datetime"));
if(r->n > 0) {
EI(ei_x_encode_list_header(values, r->n));
int i;
for(i=0; i<r->n; ++i) {
EI(ei_x_encode_longlong(values, datetime_to_unix_timestamp(kF(r)[i])));
}
}
EI(ei_x_encode_empty_list(values));
} else {
EI(ei_x_encode_same_list_float(types, values, "datetime", r, opts));
}
return 0;
}
int ei_x_encode_same_list_time(ei_x_buff* types, ei_x_buff* values, K r, QOpts* opts) {
if(opts->day_seconds_is_q_time) {
EI(ei_x_encode_tuple_header(types, 2));
EI(ei_x_encode_atom(types, "list"));
EI(ei_x_encode_atom(types, "time"));
if(r->n > 0) {
EI(ei_x_encode_list_header(values, r->n));
int i;
for(i=0; i<r->n; ++i) {
EI(ei_x_encode_ki_val(values, msec_to_sec(kI(r)[i])));
}
}
EI(ei_x_encode_empty_list(values));
} else {
EI(ei_x_encode_same_list_integer(types, values, "time", r, opts));
}
return 0;
}
/* function to spawn a process on a remote node */
int ei_spawn(struct ei_cnode_s *ec, int sockfd, erlang_ref * ref, char *module, char *function, int argc, char **argv)
{
int i;
ei_x_buff buf;
ei_x_new_with_version(&buf);
ei_x_encode_tuple_header(&buf, 3);
ei_x_encode_atom(&buf, "$gen_call");
ei_x_encode_tuple_header(&buf, 2);
ei_x_encode_pid(&buf, ei_self(ec));
ei_init_ref(ec, ref);
ei_x_encode_ref(&buf, ref);
ei_x_encode_tuple_header(&buf, 5);
ei_x_encode_atom(&buf, "spawn");
ei_x_encode_atom(&buf, module);
ei_x_encode_atom(&buf, function);
/* argument list */
if (argc < 0) {
ei_x_encode_list_header(&buf, argc);
for (i = 0; i < argc && argv[i]; i++) {
ei_x_encode_atom(&buf, argv[i]);
}
}
ei_x_encode_empty_list(&buf);
/*if (i != argc - 1) { */
/* horked argument list */
/*} */
ei_x_encode_pid(&buf, ei_self(ec)); /* should really be a valid group leader */
#ifdef EI_DEBUG
ei_x_print_reg_msg(&buf, "net_kernel", 1);
#endif
return ei_reg_send(ec, sockfd, "net_kernel", buf.buff, buf.index);
}
int
make_attribute_legacy(struct exmpp_xml_ctx *ctx,
const char *attr, int attr_len,
const char *value, int value_len)
{
ei_x_buff *tree;
tree = ctx->current_tree;
/* Start a simple tuple. */
ei_x_encode_list_header(tree, 1);
ei_x_encode_tuple_header(tree, 2);
/* Check if the attribute is known and encode it. */
encode_attr(ctx, tree, attr, attr_len);
/* Encode the value. */
if (value_len == -1)
ei_x_encode_string(tree, value);
else
ei_x_encode_string_len(tree, value, value_len);
return (0);
}
int
make_declared_ns_in_buf(struct exmpp_xml_ctx *ctx, ei_x_buff *buf,
const char *ns, int ns_len,
const char *prefix, int prefix_len)
{
/* Start declared namespace entry. */
ei_x_encode_list_header(buf, 1);
ei_x_encode_tuple_header(buf, 2);
/* Check if the namespace is known and encode it. */
encode_ns(ctx, buf, ns, ns_len);
/* Encode prefix. */
if (prefix != NULL)
if (prefix_len == -1)
ei_x_encode_string(buf, prefix);
else
ei_x_encode_string_len(buf, prefix, prefix_len);
else
ei_x_encode_atom(buf, "none");
return (0);
}
int erlang_srdb2_cmd_exec(db_res_t* res, db_cmd_t* cmd) {
LM_DBG("erlang_srdb2_cmd_exec %p %p\n",res ,cmd);
db_fld_t* fld;
ei_x_buff argbuf;
int i,cnt;
char *pbuf=NULL;
static str con=STR_STATIC_INIT("con1");
static str regname=STR_STATIC_INIT("echo_server");
LM_DBG("erlang_srdb2_cmd %p\n",cmd);
// for(i = 0, fld = cmd->vals; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i]); i++) {
// rv |= sb_add(&sql_buf, set_str(&tmpstr, fld[i].name));
// if (!DB_FLD_LAST(fld[i + 1])) rv |= sb_add(&sql_buf, set_str(&tmpstr, ","));
// }
ei_x_new(&argbuf);
//encode tuple {db_op, table, [cols], [params]}
ei_x_encode_tuple_header(&argbuf, 5);
switch(cmd->type) {
case DB_PUT: ei_x_encode_atom(&argbuf,"insert"); break;
case DB_DEL: ei_x_encode_atom(&argbuf,"delete"); break;
case DB_GET: ei_x_encode_atom(&argbuf,"select"); break;
case DB_UPD: ei_x_encode_atom(&argbuf,"update"); break;
case DB_SQL: ei_x_encode_atom(&argbuf,"rawquery"); break;
}
ei_x_encode_atom_len(&argbuf,cmd->table.s,cmd->table.len);
for(i = 0, fld = cmd->result; !DB_FLD_LAST(fld[i]); i++) {}
ei_x_encode_list_header(&argbuf, i);
for(i = 0, fld = cmd->result; !DB_FLD_LAST(fld[i]); i++) {
ei_x_encode_atom(&argbuf,fld[i].name);
}
ei_x_encode_empty_list(&argbuf);
if(cmd->match) {
for(i = 0, fld = cmd->match; !DB_FLD_LAST(fld[i]); i++) {}
ei_x_encode_list_header(&argbuf, i);
for(i = 0, fld = cmd->match; !DB_FLD_LAST(fld[i]); i++) {
ei_x_encode_tuple_header(&argbuf, 3);
ei_x_encode_atom(&argbuf,fld[i].name);
switch(fld[i].op) {
case DB_EQ: ei_x_encode_atom(&argbuf,"="); break;
case DB_NE: ei_x_encode_atom(&argbuf,"!="); break;
case DB_LT: ei_x_encode_atom(&argbuf,"<"); break;
case DB_GT: ei_x_encode_atom(&argbuf,">"); break;
case DB_LEQ: ei_x_encode_atom(&argbuf,"<="); break;
case DB_GEQ: ei_x_encode_atom(&argbuf,">="); break;
}
ei_x_encode_atom_len(&argbuf,fld[i].v.lstr.s,fld[i].v.lstr.len);
}
ei_x_encode_empty_list(&argbuf);
} else {
ei_x_encode_list_header(&argbuf, 0);
}
if(cmd->vals) {
for(i = 0, fld = cmd->vals; !DB_FLD_LAST(fld[i]); i++) {}
ei_x_encode_list_header(&argbuf, i);
for(i = 0, fld = cmd->result; !DB_FLD_LAST(fld[i]); i++) {
ei_x_encode_atom(&argbuf,fld[i].name);
}
ei_x_encode_empty_list(&argbuf);
} else {
ei_x_encode_list_header(&argbuf, 0);
}
i=0;
ei_s_print_term(&pbuf, argbuf.buff, &i);
LM_DBG("message is pbuf='%s' buf.buffsz=%d buf.index=%d i=%d\n", pbuf, argbuf.buffsz,argbuf.index,i );
free(pbuf);pbuf=NULL;
erl_bind.do_erlang_call(&con,®name, &argbuf, NULL);
ei_x_free(&argbuf);
return 0;
};
int srdb1_encode_kv(int tupsize,const db_key_t* _k, const db_op_t* _op, const db_val_t* _v,
const int _n, ei_x_buff *argbuf) {
int i;
struct tm* tt;
time_t t_t;
if(_k) {
ei_x_encode_list_header(argbuf, _n);
for(i = 0; i < _n; i++) {
db_val_t *vv;
ei_x_encode_tuple_header(argbuf, tupsize);
ei_x_encode_atom_len(argbuf,_k[i]->s,_k[i]->len);
if(tupsize == 3 ) {
if (_op) {
ei_x_encode_atom(argbuf,_op[i]);
} else {
ei_x_encode_atom(argbuf,"=");
}
}
vv=&(_v[i]);
if (VAL_NULL(vv)) {
ei_x_encode_atom(argbuf,"undefined");
} else {
switch(VAL_TYPE(vv)) {
case DB1_INT:
ei_x_encode_ulong(argbuf, VAL_INT(vv));
break;
case DB1_BIGINT:
ei_x_encode_longlong(argbuf, VAL_BIGINT(vv));
break;
case DB1_DOUBLE:
ei_x_encode_double(argbuf, VAL_DOUBLE(vv));
break;
case DB1_STRING:
ei_x_encode_string(argbuf,VAL_STRING(vv));
break;
case DB1_STR:
ei_x_encode_string_len(argbuf,VAL_STR(vv).s,VAL_STR(vv).len);
break;
case DB1_DATETIME:
t_t=VAL_TIME(vv);
tt= localtime(&t_t);
ei_x_encode_tuple_header(argbuf, 2);
ei_x_encode_tuple_header(argbuf, 3);
ei_x_encode_long(argbuf, tt->tm_year + 1900);
ei_x_encode_long(argbuf, tt->tm_mon +1);
ei_x_encode_long(argbuf, tt->tm_mday);
ei_x_encode_tuple_header(argbuf, 3);
ei_x_encode_long(argbuf, tt->tm_hour);
ei_x_encode_long(argbuf, tt->tm_min);
ei_x_encode_long(argbuf, tt->tm_sec);
break;
case DB1_BLOB:
ei_x_encode_binary(argbuf,VAL_BLOB(vv).s,VAL_BLOB(vv).len);
break;
case DB1_BITMAP:
ei_x_encode_ulong(argbuf,VAL_BITMAP(vv));
break;
}
}
}
ei_x_encode_empty_list(argbuf);
} else {
ei_x_encode_list_header(argbuf, 0);
}
return 0;
}
void *
record(void *args) {
int error;
pa_sample_spec ss;
char ss_a[PA_SAMPLE_SPEC_SNPRINT_MAX];
memset(pa_buff, 0, ABUFF_SIZE);
ss.format = PA_SAMPLE_FLOAT32LE;
ss.channels = CHANNELS;
ss.rate = frequency;
pa_s = pa_simple_new(NULL, /* PulseAudio server. */
"Recorder", /* Application's name. */
PA_STREAM_RECORD, /* Stream direction. */
NULL, /* Sink Device. */
"PulseAudio-read", /* Stream description. */
&ss, /* Sample format. */
NULL, /* Channel map */
NULL, /* Buffering attributes. */
&error /* Error code. */
);
if (NULL == pa_s) {
fprintf(stderr, __FILE__": pa_simple_new() failed: %s\n",
pa_strerror(error));
exit(1);
}
pa_sample_spec_snprint(ss_a, sizeof(ss_a), &ss);
D("Opening the recording stream with sample specification '%s'", ss_a);
D("%s", "Start recording");
while (recording) {
int n;
int error;
n = pa_simple_read(pa_s, (void *)pa_buff, ABUFF_SIZE, &error);
if (-1 != n) {
int i;
ei_x_buff result;
/* Prepare the output buffer that will hold the result */
check(ei_x_new_with_version(&result));
/* List size */
check(ei_x_encode_list_header(&result, INSIZE));
/* List elements */
for (i = 0; i < NSAMPLES; i++)
check(ei_x_encode_double(&result, pa_buff[i]));
/* Make a proper list */
check(ei_x_encode_empty_list(&result));
// D("%s", "Sending data");
write_cmd(&result);
ei_x_free(&result);
}
}
pa_simple_free(pa_s);
pthread_exit(NULL);
}
int
enter_element_legacy(struct exmpp_xml_ctx *ctx,
const char *elem, int elem_len,
void *attributes)
{
int ret;
ei_x_buff *tree;
/*
* This function build the legacy #xmlelement record:
* {xmlelement, Name, Attributes, Children}
*
* Construction of "Attributes" is made by a helper function
* but it's walked through by a callback inside driver's code.
*
* Note that "Children" may not be built here but by following
* calls to this same function.
*/
tree = ctx->current_tree;
/*
* If we're not at the required depth, we treat each node
* independently.
*
* For instance in XMPP, if ctx->root_depth is 1, a stand-alone
* term will be made right away with a <stream> opening tag. But
* for a <message> element, we will build a complete tree including
* children.
*/
if (ctx->root_depth == -1 ||
ctx->depth <= ctx->root_depth) {
/* We're above root depth (or the feature is disabled),
* so we start a new Erlang term each time. */
/* The current_tree buffer was reset by
* current_tree_finished(). */
} else {
/* We're under root depth, thus we continue with the
* current tree. */
ei_x_encode_list_header(tree, 1);
}
/* Start an #xmlel record. */
ei_x_encode_tuple_header(tree, 4);
ei_x_encode_atom(tree, "xmlelement");
/* Check if the element is known and encode it. */
encode_elem(ctx, tree, elem, elem_len);
/* Call a caller-provided function to walk the attributes list. */
if (ctx->make_attributes_legacy != NULL) {
ret = ctx->make_attributes_legacy(ctx, attributes);
if (ret != 0)
return (ret);
}
/* Terminate the attributes Erlang list. */
ei_x_encode_empty_list(tree);
/* Handle the tree if it's ready to ship. */
if (ctx->root_depth == -1 ||
ctx->depth < ctx->root_depth) {
/* Stand-alone elements are moved to the final list. */
ei_x_encode_atom(tree, "undefined");
current_tree_finished(ctx);
}
/* Update depth. */
ctx->depth++;
return (0);
}
/**
* Query a table for specified rows.
* \param _h structure representing database connection
* \param _k key names
* \param _op operators
*\param _v values of the keys that must match
* \param _c column names to return
* \param _n number of key=values pairs to compare
* \param _nc number of columns to return
* \param _o order by the specified column
* \param _r pointer to a structure representing the result
* \return zero on success, negative value on failure
*/
int erlang_srdb1_query(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _op,
const db_val_t* _v, const db_key_t* _c, const int _n, const int _nc,
const db_key_t _o, db1_res_t** _r) {
ei_x_buff argbuf,retbuf;
int retcode,i,j,x;
int n_cols,n_rows,len;
db1_res_t *res;
db_row_t *rows = NULL, *row;
db_val_t *val;
char atom[MAXATOMLEN], *p;
ei_term term;
int ei_type,size;
str *sname;
if (!_h || !_r) {
LM_ERR("invalid parameter value\n");
return -1;
}
*_r=NULL;
LM_DBG("erlang_srdb1_query table %.*s\n",CON_TABLE(_h)->len, CON_TABLE(_h)->s);
ei_x_new(&argbuf);
//encode tuple {db_op, table, [cols], [params]}
ei_x_encode_tuple_header(&argbuf, 5);
ei_x_encode_atom(&argbuf,"select");
ei_x_encode_atom_len(&argbuf,CON_TABLE(_h)->s,CON_TABLE(_h)->len);
srdb1_encode_c(_c, _nc, &argbuf);
srdb1_encode_k(_k, _op, _v, _n, &argbuf);
// ei_x_encode_atom_len(&argbuf,_o->s,_o->len);
ei_x_encode_list_header(&argbuf, 0);
retcode=erl_bind.do_erlang_call(&(CON_ERLANG(_h)->con),&(CON_ERLANG(_h)->regname), &argbuf, &retbuf);
ei_x_free(&argbuf);
if (retcode<0) {
if(retbuf.buff) shm_free(retbuf.buff);
return retcode;
}
// we have a tuple there:
ei_decode_tuple_header(retbuf.buff, &(retbuf.index), &i);
x=retbuf.index;
ei_skip_term(retbuf.buff, &x);
LM_DBG("erlang_srdb1_query: position of end of field list should be %d\n",x);
//first is list of 5-element tuples containing name and type of field
ei_decode_list_header(retbuf.buff, &(retbuf.index), &n_cols);
LM_DBG("erlang_srdb1_query: length -f field_list is %d\n",n_cols);
res=db_new_result();
if (db_allocate_columns(res, n_cols) != 0) {
LM_ERR("erlang_srdb1_query: db_allocate_columns failed\n");
goto error;
}
RES_COL_N(res) = n_cols;
for(i=0; i < n_cols; i++) {
x=retbuf.index;
ei_skip_term(retbuf.buff, &x);
LM_DBG("erlang_srdb1_query: position of end of this field should be %d\n",x);
ei_decode_tuple_header(retbuf.buff, &(retbuf.index), &j);
if( j!=5) LM_ERR("erlang_srdb1_query name&type list element tuple is not 5\n");
ei_decode_atom(retbuf.buff, &(retbuf.index), atom); //1 name
len=strlen(atom);
sname = (str*)pkg_malloc(sizeof(str)+len+1);
if (!sname) {
LM_ERR("no private memory left\n");
goto error;
}
sname->len = len;
sname->s = (char*)sname + sizeof(str);
memcpy(sname->s, atom, len);
sname->s[len] = '\0';
RES_NAMES(res)[i] = sname;
LM_DBG("decoded header %d, fieled 1: %s\n",i,atom);
ei_decode_atom(retbuf.buff, &(retbuf.index), atom); //2 type atom
if(strcmp("int",atom)==0) { RES_TYPES(res)[i]=DB1_INT; }
if(strcmp("string",atom)==0) { RES_TYPES(res)[i]=DB1_STRING; }
if(strcmp("float",atom)==0) { RES_TYPES(res)[i]=DB1_DOUBLE; }
if(strcmp("datetime",atom)==0) { RES_TYPES(res)[i]=DB1_DATETIME; }
// if(strcmp("string",atom)==0) { RES_TYPES(res)[i]=DB1_BLOB; }
ei_skip_term(retbuf.buff, &(retbuf.index)); //3 size (ignored)
ei_skip_term(retbuf.buff, &(retbuf.index)); //4 default value (ignored)
ei_skip_term(retbuf.buff, &(retbuf.index)); //3 null status (ignored)
LM_DBG("end of %d record: %d\n",i,retbuf.index);
}
ei_decode_ei_term(retbuf.buff, &(retbuf.index), &term); // List tail,
LM_DBG("erlang_srdb1_query: position after scanning is %d\n",retbuf.index);
//now rows, list of tuples
ei_decode_list_header(retbuf.buff, &(retbuf.index), &n_rows);
LM_DBG("erlang_srdb1_query values list size is %d\n",n_rows);
if (n_rows<=0) {
LM_DBG("erlang_srdb1_query no rows returned\n");
RES_ROWS(res) = NULL;
RES_NUM_ROWS(res)=0;
*_r=res;
return 0;
}
RES_NUM_ROWS(res)=n_rows;
rows = pkg_realloc(rows, sizeof(db_row_t) * n_rows);
if (rows == NULL) {
LM_ERR("erlang_srdb1_query: pkg_realloc rows failed\n");
goto error;
}
RES_ROWS(res) = rows;
for(i=0; i < n_rows; i++) {
RES_ROW_N(res)=i+1;
row = &RES_ROWS(res)[i];
if (db_allocate_row(res, row) != 0) {
LM_ERR("erlang_srdb1_query: db_allocate_row failed for row %d\n",i);
goto error;
}
ei_decode_tuple_header(retbuf.buff, &(retbuf.index), &j);
if(j!=n_cols) {
LM_ERR("erlang_srdb1_query: mismatch:values list element tuple size is %d n_cols from header was %d\n",j, n_cols);
}
for (j = 0, val = ROW_VALUES(row); j < RES_COL_N(res); j++, val++) {
VAL_TYPE(val) = RES_TYPES(res)[j];
VAL_NULL(val) = 0;
VAL_FREE(val) = 0;
retcode=ei_get_type_internal(retbuf.buff, &(retbuf.index), &ei_type, &size);
if (retcode < 0) {
LM_ERR("erlang_srdb1_query: error getting type for element %d %d\n",i,j);
goto error;
}
LM_DBG("erlang_srdb1_query: element %d %d ei_type=%d size=%d\n",i,j,ei_type, size);
switch(ei_type) {
case ERL_SMALL_INTEGER_EXT:
case ERL_INTEGER_EXT:
retcode=ei_decode_long(retbuf.buff, &(retbuf.index), &VAL_INT(val));
if(retcode < 0) goto error;
LM_DBG("decoded interger %d\n",VAL_INT(val));
break;
case ERL_FLOAT_EXT:
case NEW_FLOAT_EXT:
retcode=ei_decode_double(retbuf.buff, &(retbuf.index), &VAL_DOUBLE(val));
if(retcode < 0) goto error;
LM_DBG("decoded float %f\n",VAL_DOUBLE(val));
break;
case ERL_ATOM_EXT:
case ERL_SMALL_ATOM_EXT:
case ERL_ATOM_UTF8_EXT:
case ERL_SMALL_ATOM_UTF8_EXT:
p=pkg_malloc(size+1);
if(!p) { LM_ERR("erlang_srdb1_query: no memory\n"); goto error; }
retcode=ei_decode_atom(retbuf.buff, &(retbuf.index), p);
if(retcode < 0) {
pkg_free(p);
goto error;
}
LM_DBG("decoded small_atom_utf %s\n",p);
VAL_STRING(val)=p;
VAL_FREE(val)=1;
break;
case ERL_STRING_EXT:
p=pkg_malloc(size+1);
if(!p) { LM_ERR("erlang_srdb1_query: no memory\n"); goto error; }
retcode=ei_decode_string(retbuf.buff, &(retbuf.index), p);
if(retcode < 0) {
pkg_free(p);
goto error;
}
LM_DBG("decoded string %s\n",p);
VAL_STRING(val)=p;
VAL_FREE(val)=1;
break;
case ERL_SMALL_TUPLE_EXT:
case ERL_LARGE_TUPLE_EXT:
LM_DBG("got tuple)\n");
if (VAL_TYPE(val)==DB1_DATETIME) {
struct tm tm;
LM_DBG("and col type is datetime\n");
retcode=ei_decode_tuple_header(retbuf.buff, &(retbuf.index), &x);
if(retcode < 0) goto error;
retcode=ei_decode_tuple_header(retbuf.buff, &(retbuf.index), &x);
if(retcode < 0) goto error;
retcode=ei_decode_long(retbuf.buff, &(retbuf.index), (long int *)&tm.tm_year);tm.tm_year -=1900;
if(retcode < 0) goto error;
retcode=ei_decode_long(retbuf.buff, &(retbuf.index), (long int *)&tm.tm_mon); tm.tm_mon -=1;
if(retcode < 0) goto error;
retcode=ei_decode_long(retbuf.buff, &(retbuf.index), (long int *)&tm.tm_mday);
if(retcode < 0) goto error;
retcode=ei_decode_tuple_header(retbuf.buff, &(retbuf.index), &x);
if(retcode < 0) goto error;
retcode=ei_decode_long(retbuf.buff, &(retbuf.index), (long int *)&tm.tm_hour);
if(retcode < 0) goto error;
retcode=ei_decode_long(retbuf.buff, &(retbuf.index), (long int *)&tm.tm_min);
if(retcode < 0) goto error;
retcode=ei_decode_long(retbuf.buff, &(retbuf.index), (long int *)&tm.tm_sec);
if(retcode < 0) goto error;
VAL_TIME(val)=mktime(&tm);
break;
}
LM_ERR("erlang_srdb1_query: got tuple but valtype is not datetime element %d in row %d in response\n",j,i);
break;
case ERL_REFERENCE_EXT:
case ERL_NEW_REFERENCE_EXT:
case ERL_PORT_EXT:
case ERL_PID_EXT:
case ERL_NIL_EXT:
case ERL_LIST_EXT:
case ERL_BINARY_EXT:
case ERL_SMALL_BIG_EXT:
case ERL_LARGE_BIG_EXT:
case ERL_NEW_FUN_EXT:
case ERL_FUN_EXT:
default:
LM_ERR("erlang_srdb1_query: don't know how to handle element %d in row %d in response\n",j,i);
}
}
}
ei_decode_ei_term(retbuf.buff, &(retbuf.index), &term); // List tail,
*_r=res;
return 0;
error:
if (res)
db_free_result(res);
LM_ERR("erlang_srdb1_query: Failed\n");
return -1;
}
static void inline list_header_for_value(State* pState) {
if(!pState->skip_list_header_for_value)
ei_x_encode_list_header(&pState->ei_buf, 1);
else
pState->skip_list_header_for_value = 0;
}
static inline void write_list_header(State *p, unsigned n)
{ ei_x_encode_list_header(&p->ei_buf, n); }
static int
erlang_query(DICT_ERLANG *dict_erlang, const char *key, ARGV *nodes,
char *cookie, char *mod, char *fun, char **res)
{
int cur_node;
int err, index, retries;
int res_version, res_type, res_size;
int fd;
ei_cnode ec;
ei_x_buff args;
ei_x_buff resp;
VSTRING *node_name;
node_name = vstring_alloc(15);
/* Get an "unique" name for the node */
vstring_sprintf(node_name, "dict_erlang%u", getpid() % 999);
err = ei_connect_init(&ec, vstring_str(node_name), cookie, 0);
if (err != 0) {
msg_warn_erl("ei_connect_init");
return -1;
}
retries = 3;
retry:
cur_node = dict_erlang->active_node;
do {
fd = ei_connect(&ec, nodes->argv[cur_node]);
if (fd >= 0) {
dict_erlang->active_node = cur_node;
if (msg_verbose)
msg_info("connected to node %s", nodes->argv[cur_node]);
break;
}
cur_node = (cur_node + 1) % nodes->argc;
} while (cur_node != dict_erlang->active_node);
if (fd < 0) {
if (retries > 0 && erl_errno == EIO) {
msg_warn_erl("no suitable nodes found, retrying");
retries--;
goto retry;
}
msg_warn_erl("no suitable nodes found, failing");
return -1;
}
ei_x_new(&args);
ei_x_new(&resp);
ei_x_encode_list_header(&args, 1);
ei_x_encode_binary(&args, key, strlen(key));
ei_x_encode_empty_list(&args);
err = ei_rpc(&ec, fd, mod, fun, args.buff, args.index, &resp);
if (err == -1) {
msg_warn_erl("ei_rpc");
goto cleanup;
}
err = handle_response(dict_erlang, key, &resp, res);
cleanup:
close(fd);
ei_x_free(&args);
ei_x_free(&resp);
return err;
}
int my_x_encode_list_header(ei_x_buff* x, struct my_obj* obj)
{
return ei_x_encode_list_header(x, (long)obj->u.arity);
}
/*
* Function returns always success - we uses EPMD for transport
*/
int erl_rpc_send(erl_rpc_ctx_t *ctx, int depth)
{
if (ctx->response_sent) return 0;
ctx->response_sent = 1;
erl_rpc_ctx_t *handler;
erl_rpc_param_t *fault = *(ctx->fault_p);
if (fault)
{
LM_ERR("fault: %d %.*s\n",fault->type, STR_FMT(&fault->value.S));
/* restore clear point */
ctx->response->index = ctx->response_index;
/* {error,{struct,[ {"code", 400}, {"error","Error message"}]}}*/
if (ei_x_encode_tuple_header(ctx->response,1)) goto error; /* {error,{_,_}} */
if (rpc_reply_with_struct && ei_x_encode_atom(ctx->response,"struct")) goto error; /* {error,{struct,_}} */
if (ei_x_encode_list_header(ctx->response,2)) goto error; /* {error,{struct,[_,_]}} */
if (ei_x_encode_tuple_header(ctx->response,2)) goto error; /* {error,{struct,[{_,_},_]}} */
if (ei_x_encode_atom(ctx->response,"code")) goto error; /* {error,{struct,[{code,_},_]}} */
if (ei_x_encode_long(ctx->response,fault->type)) goto error;/* {error,{struct,[{code,400},_]}} */
if (ei_x_encode_tuple_header(ctx->response,2)) goto error; /* {error,{struct,[{code,400},{_,_}]}} */
if (ei_x_encode_binary(ctx->response,"error",sizeof("error")-1)) goto error; /* {error,{struct,[{code,400},{<<"error">>,_}]}} */
if (ei_x_encode_binary(ctx->response,(void*)fault->value.S.s,fault->value.S.len)) /* {error,{struct,[{code,400},{<<"error">>,<<Msg>>}]}} */
goto error;
if (ei_x_encode_empty_list(ctx->response)) goto error;
}
else if (ctx->reply_params)
{
while(ctx->reply_params)
{
if (ctx->reply_params->member_name)
{
/* {"member_name", _} */
if (ei_x_encode_tuple_header(ctx->response,2)) goto error;
if (ei_x_encode_binary(ctx->response,ctx->reply_params->member_name, strlen(ctx->reply_params->member_name)))
goto error;
}
/* {"member_name", MemberValue} */
switch (ctx->reply_params->type) {
case ERL_INTEGER_EXT:
if(ei_x_encode_long(ctx->response,ctx->reply_params->value.n)) goto error;
break;
case ERL_FLOAT_EXT:
if(ei_x_encode_double(ctx->response,ctx->reply_params->value.d)) goto error;
break;
case ERL_STRING_EXT:
if(ei_x_encode_binary(ctx->response,ctx->reply_params->value.S.s,ctx->reply_params->value.S.len)) goto error;
break;
case ERL_SMALL_TUPLE_EXT: /* add as {struct,list(no_params)} */
handler = (erl_rpc_ctx_t*)ctx->reply_params->value.handler;
if (ei_x_encode_tuple_header(ctx->response,1)) goto error;
if (rpc_reply_with_struct && ei_x_encode_atom(ctx->response,"struct")) goto error;
if (ei_x_encode_list_header(ctx->response,handler->no_params)) goto error;
if (erl_rpc_send(handler, depth++)) goto error;
if (ei_x_encode_empty_list(ctx->response)) goto error;
break;
case ERL_LIST_EXT: /* add as [list(no_params)] */
handler = (erl_rpc_ctx_t*)ctx->reply_params->value.handler;
if (ei_x_encode_list_header(ctx->response,handler->no_params)) goto error;
if (erl_rpc_send(handler, depth++)) goto error;
if (handler->no_params)
if (ei_x_encode_empty_list(ctx->response)) goto error;
break;
default:
LM_ERR("Unknown type '%c' for encoding RPC reply\n",ctx->reply_params->type);
break;
}
ctx->reply_params=ctx->reply_params->next;
}
}
else if (!depth)
{
/* restore start point */
LM_WARN("encode empty response -> ok");
ctx->response->index = ctx->response_index;
if (ei_x_encode_atom(ctx->response,"ok")) goto error;
}
return 0;
error:
LM_ERR("error while encoding response\n");
return -1;
}
static int control(ErlDrvData handle, unsigned int command, char* buf, int count, char** res, int res_size) {
tcbdb_drv_t *driver = (tcbdb_drv_t*)handle;
TCBDB *bdb = driver->bdb;
int index = 1, tp, sz, version;
char key[MAX_KEY_SIZE], value[MAX_VALUE_SIZE];
long key_size, value_size;
long long long_tmp;
bool rs;
const char *value_tmp = NULL;
ei_x_buff x;
ei_x_new_with_version(&x);
if (bdb == NULL && command != OPEN)
return ei_error(&x, "database_not_opened", res, res_size);
ei_decode_version(buf, &index, &version);
switch (command) {
case OPEN:
// open(Filepath::string())
if (bdb == NULL) {
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_STRING_EXT)
return ei_error(&x, "invalid_argument", res, res_size);
TCBDB *bdb = tcbdbnew();
tcbdbsetmutex(bdb);
tcbdbsetcache(bdb, 104800, 51200);
tcbdbsetxmsiz(bdb, 1048576);
tcbdbtune(bdb, 0, 0, 0, 7, -1, BDBTLARGE);
char *file = driver_alloc(sz + 1);
ei_decode_string(buf, &index, file);
rs = tcbdbopen(bdb, file, BDBOWRITER | BDBOCREAT);
driver_free(file);
if (!rs)
return ei_error(&x, tcbdberrmsg(tcbdbecode(bdb)), res, res_size);
driver->bdb = bdb;
ei_x_encode_atom(&x, "ok");
} else
return ei_error(&x, "database already opened", res, res_size);
break;
case CLOSE:
tcbdbclose(bdb);
tcbdbdel(bdb);
driver->bdb = NULL;
ei_x_encode_atom(&x, "ok");
break;
case PUT:
case PUTDUP:
case PUTCAT:
case PUTKEEP:
// put({Key::binary(), Value::binary()})
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_SMALL_TUPLE_EXT || sz != 2)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_tuple_header(buf, &index, &sz);
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT || sz > MAX_KEY_SIZE)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_binary(buf, &index, &key[0], &key_size);
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT)
return ei_error(&x, "invalid_argument", res, res_size);
if (sz <= MAX_VALUE_SIZE) {
ei_decode_binary(buf, &index, &value[0], &value_size);
switch (command) {
case PUT: rs = tcbdbput(bdb, &key[0], key_size, &value[0], value_size); break;
case PUTDUP: rs = tcbdbputdup(bdb, &key[0], key_size, &value[0], value_size); break;
case PUTCAT: rs = tcbdbputcat(bdb, &key[0], key_size, &value[0], value_size); break;
default: rs = tcbdbputkeep(bdb, &key[0], key_size, &value[0], value_size);
}
} else {
void *p = driver_alloc(sz);
if (p) {
ei_decode_binary(buf, &index, p, &value_size);
switch (command) {
case PUT: rs = tcbdbput(bdb, &key[0], key_size, p, value_size); break;
case PUTDUP: rs = tcbdbputdup(bdb, &key[0], key_size, p, value_size); break;
case PUTCAT: rs = tcbdbputcat(bdb, &key[0], key_size, p, value_size); break;
default: rs = tcbdbputkeep(bdb, &key[0], key_size, p, value_size);
}
driver_free(p);
} else
return ei_error(&x, "too long value", res, res_size);
};
if (!rs)
return ei_error(&x, tcbdberrmsg(tcbdbecode(bdb)), res, res_size);
ei_x_encode_atom(&x, "ok");
break;
case GET:
// get(Key::binary()) -> {ok, Value} | {error, not_found}
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT || sz > MAX_KEY_SIZE)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_binary(buf, &index, &key[0], &key_size);
value_tmp = tcbdbget3(bdb, &key[0], key_size, &sz);
ei_x_encode_tuple_header(&x, 2);
if (value_tmp != NULL) {
ei_x_encode_atom(&x, "ok");
ei_x_encode_binary(&x, value_tmp, sz);
} else {
ei_x_encode_atom(&x, "error");
ei_x_encode_atom(&x, "not_found");
}
break;
case GETDUP:
// get(Key::binary()) -> {ok, Values}
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT || sz > MAX_KEY_SIZE)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_binary(buf, &index, &key[0], &key_size);
TCLIST *vals = tcbdbget4(bdb, key, key_size);
if (vals) {
ei_x_encode_tuple_header(&x, 2);
ei_x_encode_atom(&x, "ok");
int j;
for (j=0; j<tclistnum(vals); j++) {
value_tmp = tclistval(vals, j, &sz);
ei_x_encode_list_header(&x, 1);
ei_x_encode_binary(&x, value_tmp, sz);
}
tclistdel(vals);
ei_x_encode_empty_list(&x);
} else {
ei_x_encode_tuple_header(&x, 2);
ei_x_encode_atom(&x, "ok");
ei_x_encode_empty_list(&x);
}
break;
case REMOVE:
// remove(Keys::list())
// remove(Key::binary())
// remove({Key::binary(), Value::binary()})
ei_get_type(buf, &index, &tp, &sz);
if (tp == ERL_LIST_EXT) {
int count, j;
ei_decode_list_header(buf, &index, &count);
for (j=0; j<count; j++) {
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT || sz > MAX_KEY_SIZE)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_binary(buf, &index, &key[0], &key_size);
if (!tcbdbout3(bdb, &key[0], key_size))
return ei_error(&x, tcbdberrmsg(tcbdbecode(bdb)), res, res_size);
}
ei_x_encode_atom(&x, "ok");
} else if (tp == ERL_BINARY_EXT && sz <= MAX_KEY_SIZE) {
ei_decode_binary(buf, &index, &key[0], &key_size);
tcbdbout3(bdb, &key[0], key_size);
ei_x_encode_atom(&x, "ok");
} else if (tp == ERL_SMALL_TUPLE_EXT && sz == 2) {
ei_decode_tuple_header(buf, &index, &sz);
// get key
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT || sz > MAX_KEY_SIZE)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_binary(buf, &index, &key[0], &key_size);
// get value
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT || sz > MAX_VALUE_SIZE)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_binary(buf, &index, &value[0], &value_size);
// remove by key&value
BDBCUR *cur = tcbdbcurnew(bdb);
if (!tcbdbcurjump(cur, &key[0], key_size))
return ei_error(&x, "record_not_found", res, res_size);
bool removed = false, not_found = false;
while (!removed && !not_found) {
int cur_key_size, cur_val_size;
const void *curkey = tcbdbcurkey3(cur, &cur_key_size);
if (cur_key_size == key_size && memcmp(curkey, key, key_size) == 0) {
const void *curval = tcbdbcurval3(cur, &cur_val_size);
if (cur_val_size == value_size && memcmp(curval, value, value_size) == 0) {
tcbdbcurout(cur);
removed = true;
} else
if (!tcbdbcurnext(cur))
not_found = true;
} else not_found = true;
}
if (not_found) ei_x_encode_atom(&x, "not_found");
else ei_x_encode_atom(&x, "ok");
} else
return ei_error(&x, "invalid_argument", res, res_size);
break;
case RANGE:
/*
* range({Prefix::binary(), limit:integer()})
* range({StartKey::binary(), BeginInclusion::boolean(), EndKey::binary(), EndInclusion::binary(), limit:integer()})
*/
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_SMALL_TUPLE_EXT || sz < 2)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_tuple_header(buf, &index, &sz);
ei_get_type(buf, &index, &tp, &sz);
if (tp == ERL_BINARY_EXT && sz <= MAX_KEY_SIZE) {
char keys[MAX_KEY_SIZE], keyf[MAX_KEY_SIZE];
long keys_size, keyf_size;
int keys_inc, keyf_inc;
long max = -1;
TCLIST *range;
ei_decode_binary(buf, &index, &keys[0], &keys_size);
ei_get_type(buf, &index, &tp, &sz);
if (tp == ERL_ATOM_EXT) {
// range
ei_decode_boolean(buf, &index, &keys_inc);
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_BINARY_EXT || sz > MAX_KEY_SIZE)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_binary(buf, &index, &keyf[0], &keyf_size);
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_ATOM_EXT)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_boolean(buf, &index, &keyf_inc);
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_INTEGER_EXT)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_long(buf, &index, &max);
range = tcbdbrange(bdb, &keys[0], keys_size, keys_inc == 1, &keyf[0], keyf_size, keyf_inc == 1, max);
} else if (tp == ERL_INTEGER_EXT) {
// prefix
ei_get_type(buf, &index, &tp, &sz);
if (tp != ERL_INTEGER_EXT)
return ei_error(&x, "invalid_argument", res, res_size);
ei_decode_long(buf, &index, &max);
range = tcbdbfwmkeys(bdb, &keys[0], keys_size, max);
} else
return ei_error(&x, "invalid_argument", res, res_size);
const char *key;
int key_size, value_size;
int idx, cnt = 0, rcount = tclistnum(range);
ei_x_encode_tuple_header(&x, 2);
ei_x_encode_atom(&x, "ok");
BDBCUR *cur = tcbdbcurnew(bdb);
for (idx=0; idx<rcount; idx++) {
key = tclistval(range, idx, &key_size);
TCLIST *vals = tcbdbget4(bdb, key, key_size);
if (vals) {
int j;
for (j=0; j<tclistnum(vals); j++) {
ei_x_encode_list_header(&x, 1);
value_tmp = tclistval(vals, j, &value_size);
ei_x_encode_binary(&x, value_tmp, value_size);
if (max >= 0 && ++cnt >= max) break;
}
tclistdel(vals);
}
idx++;
}
tcbdbcurdel(cur);
tclistdel(range);
ei_x_encode_empty_list(&x);
} else
return ei_error(&x, "invalid_argument", res, res_size);
break;
case SYNC:
// sync()
if (!tcbdbsync(bdb))
return ei_error(&x, tcbdberrmsg(tcbdbecode(bdb)), res, res_size);
ei_x_encode_atom(&x, "ok");
break;
case INFO:
// info()
ei_x_encode_tuple_header(&x, 3);
ei_x_encode_atom(&x, "ok");
long_tmp = tcbdbrnum(bdb);
ei_x_encode_longlong(&x, long_tmp);
long_tmp = tcbdbfsiz(bdb);
ei_x_encode_longlong(&x, long_tmp);
break;
case ITERATE:
// Read(none) -> {ok, Key} | {error, not_found}
// Read(Key::binary()) -> {ok, Key} | {error, not_found}
ei_get_type(buf, &index, &tp, &sz);
BDBCUR *cur = tcbdbcurnew(bdb);
if (tp == ERL_BINARY_EXT && sz <= MAX_KEY_SIZE) {
ei_decode_binary(buf, &index, &key[0], &key_size);
rs = tcbdbcurjump(cur, &key[0], key_size) && tcbdbcurnext(cur);
} else
rs = tcbdbcurfirst(cur);
if (rs) {
int key_size;
const char *key = tcbdbcurkey3(cur, &key_size);
ei_x_encode_tuple_header(&x, 2);
ei_x_encode_atom(&x, "ok");
ei_x_encode_binary(&x, key, key_size);
tcbdbcurdel(cur);
} else {
tcbdbcurdel(cur);
return ei_error(&x, "not_found", res, res_size);
}
break;
case VANISH:
// vanish() -> ok
if (!tcbdbvanish(bdb))
return ei_error(&x, tcbdberrmsg(tcbdbecode(bdb)), res, res_size);
ei_x_encode_atom(&x, "ok");
break;
case BACKUP:
// backup(path::string()) -> ok | {error, Reason}
ei_get_type(buf, &index, &tp, &sz);
if (tp == ERL_STRING_EXT) {
char *file = driver_alloc(sz + 1);
ei_decode_string(buf, &index, file);
if (tcbdbcopy(driver->bdb, file))
ei_x_encode_atom(&x, "ok");
else
return ei_error(&x, tcbdberrmsg(tcbdbecode(bdb)), res, res_size);
} else
return ei_error(&x, "invalid_argument", res, res_size);
break;
default:
return ei_error(&x, "invalid_command", res, res_size);
}
if (res_size < x.index)
(*res) = (char *)driver_alloc(x.index);
int n = x.index;
memcpy(*res, x.buff, x.index);
ei_x_free(&x);
return n;
};
int main(void)
#endif
{
ErlConnect conp;
Erl_IpAddr thisipaddr = (Erl_IpAddr)0;
FILE *fp = (FILE *)0;
char* charp = "foo";
double *doublep = NULL;
double doublex = 0.0;
ei_cnode xec;
ei_reg *ei_regp = NULL;
ei_term eterm;
ei_x_buff eix;
erlang_big *bigp = NULL;
erlang_fun efun;
erlang_msg *msgp = NULL;
erlang_msg emsg;
erlang_pid *pidp = NULL;
erlang_pid epid;
erlang_port eport;
erlang_ref eref;
erlang_trace etrace;
int *intp = NULL;
int intx = 0;
long *longp = NULL;
long longx = 0;
short creation = 0;
struct ei_reg_stat *ei_reg_statp = NULL;
struct ei_reg_tabstat *ei_reg_tabstatp = NULL;
struct hostent *hostp = NULL;
unsigned char * ucharp = (unsigned char *)"foo";
unsigned long *ulongp = NULL;
unsigned long ulongx = 0;
void *voidp = NULL;
#ifndef VXWORKS
EI_LONGLONG *longlongp = (EI_LONGLONG*)NULL;
EI_LONGLONG longlongx = 0;
EI_ULONGLONG *ulonglongp = (EI_ULONGLONG*)NULL;
EI_ULONGLONG ulonglongx = 0;
#endif
enum erlang_char_encoding enc;
intx = erl_errno;
ei_connect_init(&xec, charp, charp, creation);
ei_connect_xinit (&xec, charp, charp, charp, thisipaddr, charp, creation);
ei_connect(&xec, charp);
ei_xconnect (&xec, thisipaddr, charp);
ei_receive(intx, ucharp, intx);
ei_receive_msg(intx, &emsg, &eix);
ei_xreceive_msg(intx, &emsg, &eix);
ei_send(intx, &epid, charp, intx);
ei_reg_send(&xec, intx, charp, charp, intx);
ei_rpc(&xec, intx, charp, charp, charp, intx, &eix);
ei_rpc_to(&xec, intx, charp, charp, charp, intx);
ei_rpc_from(&xec, intx, intx, &emsg, &eix);
ei_publish(&xec, intx);
ei_accept(&xec, intx, &conp);
ei_unpublish(&xec);
ei_thisnodename(&xec);
ei_thishostname(&xec);
ei_thisalivename(&xec);
ei_self(&xec);
ei_gethostbyname(charp);
ei_gethostbyaddr(charp, intx, intx);
ei_gethostbyname_r(charp, hostp, charp, intx, intp);
ei_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
ei_encode_version(charp, intp);
ei_x_encode_version(&eix);
ei_encode_long(charp, intp, longx);
ei_x_encode_long(&eix, longx);
ei_encode_ulong(charp, intp, ulongx);
ei_x_encode_ulong(&eix, ulongx);
ei_encode_double(charp, intp, doublex);
ei_x_encode_double(&eix, doublex);
ei_encode_boolean(charp, intp, intx);
ei_x_encode_boolean(&eix, intx);
ei_encode_char(charp, intp, 'a');
ei_x_encode_char(&eix, 'a');
ei_encode_string(charp, intp, charp);
ei_encode_string_len(charp, intp, charp, intx);
ei_x_encode_string(&eix, charp);
ei_x_encode_string_len(&eix, charp, intx);
ei_encode_atom(charp, intp, charp);
ei_encode_atom_as(charp, intp, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_atom_len(charp, intp, charp, intx);
ei_encode_atom_len_as(charp, intp, charp, intx, ERLANG_ASCII, ERLANG_LATIN1);
ei_x_encode_atom(&eix, charp);
ei_x_encode_atom_as(&eix, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_x_encode_atom_len(&eix, charp, intx);
ei_x_encode_atom_len_as(&eix, charp, intx, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_binary(charp, intp, (void *)0, longx);
ei_x_encode_binary(&eix, (void*)0, intx);
ei_encode_pid(charp, intp, &epid);
ei_x_encode_pid(&eix, &epid);
ei_encode_fun(charp, intp, &efun);
ei_x_encode_fun(&eix, &efun);
ei_encode_port(charp, intp, &eport);
ei_x_encode_port(&eix, &eport);
ei_encode_ref(charp, intp, &eref);
ei_x_encode_ref(&eix, &eref);
ei_encode_trace(charp, intp, &etrace);
ei_x_encode_trace(&eix, &etrace);
ei_encode_tuple_header(charp, intp, intx);
ei_x_encode_tuple_header(&eix, longx);
ei_encode_list_header(charp, intp, intx);
ei_x_encode_list_header(&eix, longx);
/* #define ei_encode_empty_list(buf,i) ei_encode_list_header(buf,i,0) */
ei_x_encode_empty_list(&eix);
ei_get_type(charp, intp, intp, intp);
ei_get_type_internal(charp, intp, intp, intp);
ei_decode_version(charp, intp, intp);
ei_decode_long(charp, intp, longp);
ei_decode_ulong(charp, intp, ulongp);
ei_decode_double(charp, intp, doublep);
ei_decode_boolean(charp, intp, intp);
ei_decode_char(charp, intp, charp);
ei_decode_string(charp, intp, charp);
ei_decode_atom(charp, intp, charp);
ei_decode_atom_as(charp, intp, charp, MAXATOMLEN_UTF8, ERLANG_WHATEVER, &enc, &enc);
ei_decode_binary(charp, intp, (void *)0, longp);
ei_decode_fun(charp, intp, &efun);
free_fun(&efun);
ei_decode_pid(charp, intp, &epid);
ei_decode_port(charp, intp, &eport);
ei_decode_ref(charp, intp, &eref);
ei_decode_trace(charp, intp, &etrace);
ei_decode_tuple_header(charp, intp, intp);
ei_decode_list_header(charp, intp, intp);
ei_decode_ei_term(charp, intp, &eterm);
ei_print_term(fp, charp, intp);
ei_s_print_term(&charp, charp, intp);
ei_x_format(&eix, charp);
ei_x_format_wo_ver(&eix, charp);
ei_x_new(&eix);
ei_x_new_with_version(&eix);
ei_x_free(&eix);
ei_x_append(&eix, &eix);
ei_x_append_buf(&eix, charp, intx);
ei_skip_term(charp, intp);
ei_reg_open(intx);
ei_reg_resize(ei_regp, intx);
ei_reg_close(ei_regp);
ei_reg_setival(ei_regp, charp, longx);
ei_reg_setfval(ei_regp, charp, doublex);
ei_reg_setsval(ei_regp, charp, charp);
ei_reg_setpval(ei_regp, charp, voidp, intx);
ei_reg_setval(ei_regp, charp, intx);
ei_reg_getival(ei_regp, charp);
ei_reg_getfval(ei_regp, charp);
ei_reg_getsval(ei_regp, charp);
ei_reg_getpval(ei_regp, charp, intp);
ei_reg_getval(ei_regp, charp, intx);
ei_reg_markdirty(ei_regp, charp);
ei_reg_delete(ei_regp, charp);
ei_reg_stat(ei_regp, charp, ei_reg_statp);
ei_reg_tabstat(ei_regp, ei_reg_tabstatp);
ei_reg_dump(intx, ei_regp, charp, intx);
ei_reg_restore(intx, ei_regp, charp);
ei_reg_purge(ei_regp);
#if defined(HAVE_GMP_H) && defined(HAVE_LIBGMP)
{
mpz_t obj;
ei_decode_bignum(charp, intp, obj);
ei_encode_bignum(charp, intp, obj);
ei_x_encode_bignum(&eix, obj);
}
#endif /* HAVE_GMP_H && HAVE_LIBGMP */
#ifndef VXWORKS
ei_decode_longlong(charp, intp, longlongp);
ei_decode_ulonglong(charp, intp, ulonglongp);
ei_encode_longlong(charp, intp, longlongx);
ei_encode_ulonglong(charp, intp, ulonglongx);
ei_x_encode_longlong(&eix, longlongx);
ei_x_encode_ulonglong(&eix, ulonglongx);
#endif
#ifdef USE_EI_UNDOCUMENTED
ei_decode_intlist(charp, intp, longp, intp);
ei_receive_encoded(intx, &charp, intp, msgp, intp);
ei_send_encoded(intx, pidp, charp, intx);
ei_send_reg_encoded(intx, pidp, charp, charp, intx);
ei_decode_big(charp, intp, bigp);
ei_big_comp(bigp, bigp);
ei_big_to_double(bigp, doublep);
ei_small_to_big(intx, bigp);
ei_alloc_big(intx);
ei_free_big(bigp);
#endif /* USE_EI_UNDOCUMENTED */
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EIO +
EI_BIN +
EI_DELET +
EI_DIRTY +
EI_FLT +
EI_FORCE +
EI_INT +
EI_NOPURGE +
EI_STR +
EMSGSIZE +
ENOMEM +
ERL_ERROR +
ERL_EXIT +
ERL_LINK +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_REG_SEND +
ERL_SEND +
ERL_TICK +
ERL_TIMEOUT +
ERL_UNLINK +
ETIMEDOUT +
MAXATOMLEN;
}
static int ei_x_encode_list_header_log(ei_x_buff* x, int arity) {
fprintf(stderr, "<< list header: %d\n", arity);
return ei_x_encode_list_header(x, arity);
}
