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); }