static void
send_printed3(char* format, char* p1, char* p2, int fl)
{
char* b = NULL;
char fn[100], * tmp = getenv("temp");
FILE* f;
int n, index = 0, ver;
ei_x_buff x;
ei_x_new(&x);
if (fl) {
ei_x_format(&x, format, *(float*)p1, *(float*)p2);
} else {
ei_x_format(&x, format, p1, p2);
}
#ifdef VXWORKS
tmp = ".";
#else
if (tmp == NULL) tmp = "/tmp";
#endif
strcpy(fn, tmp);
strcat(fn, "/ei_print_test.txt");
f = fopen(fn, "w+");
ei_decode_version(x.buff, &index, &ver);
n = ei_print_term(f, x.buff, &index);
fseek(f, 0, SEEK_SET);
b = malloc(n+1);
fread(b, 1, n, f);
b[n] = '\0';
fclose(f);
x.index = 0;
ei_x_format(&x, "~s", b);
send_bin_term(&x);
free(b);
ei_x_free(&x);
}
static ErlDrvSSizeT
do_call(ErlDrvData drv_data, unsigned int command, char *buf,
ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen, unsigned *ret_flags)
{
int nlen;
ei_x_buff x;
switch (command) {
case 0:
*rbuf = buf;
*ret_flags |= DRIVER_CALL_KEEP_BUFFER;
return len;
case 1:
ei_x_new(&x);
ei_x_format(&x, "{[], a, [], b, c}");
nlen = x.index;
if (nlen > rlen) {
*rbuf =driver_alloc(nlen);
}
memcpy(*rbuf,x.buff,nlen);
ei_x_free(&x);
return nlen;
case 2:
ei_x_new(&x);
ei_x_encode_version(&x);
ei_x_encode_tuple_header(&x,2);
ei_x_encode_atom(&x,"return");
ei_x_append_buf(&x,buf+1,len-1);
nlen = x.index;
if (nlen > rlen) {
*rbuf =driver_alloc(nlen);
}
memcpy(*rbuf,x.buff,nlen);
ei_x_free(&x);
return nlen;
default:
return -1;
}
}
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;
}
/**
* internal implementation
*/
int worker_rpc_impl(ei_cnode *ec, int s,int wpid)
{
str module = STR_NULL;
str function = STR_NULL;
ei_x_buff args;
ei_x_buff reply;
struct msghdr msgh;
struct iovec cnt[6];
int rc;
memset((void*)&args,0,sizeof(args));
memset((void*)&reply,0,sizeof(reply));
memset((void*)&msgh,0,sizeof(msgh));
/* module name length */
cnt[0].iov_base = &module.len;
cnt[0].iov_len = sizeof(int);
/* function name length */
cnt[1].iov_base = &function.len;
cnt[1].iov_len = sizeof(int);
/* Erlang args size */
cnt[2].iov_base = &args.buffsz;
cnt[2].iov_len = sizeof(int);
/* get data size */
msgh.msg_iov = cnt;
msgh.msg_iovlen = 3;
while ((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN)
;
if (rc == -1){
LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno));
goto err;
}
/* allocate space */
module.s = (char*)pkg_malloc(module.len+1);
if (!module.s) {
LM_ERR("not enough memory\n");
goto err;
}
function.s = (char*)pkg_malloc(function.len+1);
if (!function.s) {
LM_ERR("not enough memory\n");
goto err;
}
args.buff = (char*)malloc(args.buffsz);
if (!args.buff) {
LM_ERR("malloc: not enough memory\n");
goto err;
}
/* buffers */
cnt[3].iov_base = module.s;
cnt[3].iov_len = module.len;
cnt[4].iov_base = function.s;
cnt[4].iov_len = function.len;
cnt[5].iov_base = args.buff;
cnt[5].iov_len = args.buffsz;
/* get whole data */
msgh.msg_iovlen = 6;
while ((rc = recvmsg(s, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN)
;
if (rc == -1){
LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno));
goto err;
}
/* fix str */
module.s[module.len] = 0;
function.s[function.len] = 0;
LM_DBG("rpc: %.*s:%.*s(args)\n",STR_FMT(&module),STR_FMT(&function));
EI_X_BUFF_PRINT(&args);
if(!enode) {
LM_NOTICE("there is no connected Erlang node\n");
/* reply up with error */
ei_x_format(&reply, "{error,cnode,~a}", "no_erlang_node");
goto reply;
}
/* do RPC */
if ((rc = ei_rpc(ec,enode->sockfd,module.s,function.s,args.buff,args.buffsz,&reply)) == ERL_ERROR)
{
reply.index = 0; /* re-use reply buffer */
if (erl_errno)
{
ei_x_format(&reply, "{error,cnode,~s}", strerror(erl_errno));
LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno));
}
else if (errno)
{
ei_x_format(&reply, "{error,cnode,~s}", strerror(errno));
LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno));
}
else
{
ei_x_format(&reply, "{error,cnode,~s}", "Unknown error.");
LM_ERR("ei_rpc failed on node=<%s> socket=<%d>, Unknown error.\n",ec->thisalivename,enode->sockfd);
}
}
reply:
EI_X_BUFF_PRINT(&reply);
cnt[0].iov_base = (void*)&wpid;
cnt[0].iov_len = sizeof(int);
/* send reply to Kamailio worker */
cnt[1].iov_base = (void*)&reply.buffsz;
cnt[1].iov_len = sizeof(int);
cnt[2].iov_base = (void*)reply.buff;
cnt[2].iov_len = reply.buffsz;
msgh.msg_iovlen = 3;
while ((rc = sendmsg(s, &msgh, 0)) == -1 && errno == EAGAIN)
;
if (rc == -1) {
LM_ERR("sendmsg failed on socket=%d rpid_no=%d; %s\n",s, wpid, strerror(errno));
goto err;
};
pkg_free(module.s);
pkg_free(function.s);
free(args.buff);
ei_x_free(&reply);
return 0;
err:
pkg_free(module.s);
pkg_free(function.s);
free(args.buff);
ei_x_free(&reply);
abort(); /* cant't recover */
return -1;
}
int _impl_api_rpc_call(ei_x_buff *reply, const str *module,const str *function, const ei_x_buff *args)
{
struct msghdr msgh;
struct iovec cnt[8];
int pid_no = my_pid();
eapi_t api = API_RPC_CALL;
int buffsz=0;
int rc;
if (!csockfd) {
if (!enode) {
LM_NOTICE("there is no connected Erlang node\n");
/* reply up with error */
ei_x_format(reply, "{error,cnode,~a}", "no_erlang_node");
return -1;
}
if (rex_call_in_progress) {
LM_ERR("RPC loop detected\n");
ei_x_format(reply, "{badrpc,cnode,~a}", "rpc_loop_detected");
return -1;
}
/* do RPC from event route */
if (ei_rpc(&enode->ec,enode->sockfd,module->s,function->s,args->buff,args->index,reply) == ERL_ERROR)
{
reply->index = 0; /* re-use reply buffer */
if (erl_errno)
{
ei_x_format(reply, "{error,cnode,~s}", strerror(erl_errno));
LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno));
}
else if (errno)
{
ei_x_format(reply, "{error,cnode,~s}", strerror(errno));
LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno));
}
else
{
ei_x_format(reply, "{error,cnode,~s}", "Unknown error.");
LM_ERR("ei_rpc failed on node=<%s> socket=<%d>, Unknown error.\n",enode->ec.thisalivename,enode->sockfd);
}
return -1;
}
/* reset response */
enode->response.index = 0;
return 0;
}
memset(&msgh, 0, sizeof(msgh));
memset(&cnt, 0, sizeof(cnt));
/* Kamailio PID */
cnt[0].iov_base = (void*)&pid_no;
cnt[0].iov_len = sizeof(pid_no);
/* method */
cnt[1].iov_base = (void*)&api;
cnt[1].iov_len = sizeof(api);
/* put size of following data */
cnt[2].iov_base = (void*)&module->len;
cnt[2].iov_len = sizeof(int);
cnt[3].iov_base = (void*)&function->len;
cnt[3].iov_len = sizeof(int);
buffsz = args->index; /* occupied size */
cnt[4].iov_base = (void*) &buffsz;
cnt[4].iov_len = sizeof(buffsz);
/* module name */
cnt[5].iov_base = (void*)module->s;
cnt[5].iov_len = module->len;
/* function name */
cnt[6].iov_base = (void*)function->s;
cnt[6].iov_len = function->len;
/* Erlang arguments content */
cnt[7].iov_base = (void*)args->buff;
cnt[7].iov_len = buffsz; /* occupied size */
msgh.msg_iov = cnt;
msgh.msg_iovlen = 8;
while ((rc = sendmsg(csockfd, &msgh, 0)) == -1 && errno == EAGAIN)
;
if (rc == -1) {
LM_ERR("sendmsg failed: %s\n",strerror(errno));
return -1;
}
/*receive into reply buffer */
cnt[1].iov_base = &buffsz;
cnt[1].iov_len = sizeof(buffsz);
/* peek reply size safe */
msgh.msg_iovlen = 2;
while ((rc = recvmsg(csockfd, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN)
;
if (rc == -1) {
LM_ERR("recvmsg failed: %s\n",strerror(errno));
return -1;
}
if (reply->buffsz < buffsz) {
ei_x_free(reply);
reply->buffsz = buffsz + 1;
reply->buff = (char*)malloc(reply->buffsz);
}
cnt[2].iov_base = (void*)reply->buff;
cnt[2].iov_len = buffsz;
msgh.msg_iovlen = 3;
while ((rc = recvmsg(csockfd, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN)
;
if (rc == -1) {
LM_ERR("recvmsg failed: %s\n",strerror(errno));
return -1;
}
if(pid_no != my_pid()) {
/* should never happened */
LM_CRIT("BUG: got other process reply (pid_no=%d)\n",pid_no);
return -1;
}
return 0;
}
