/*
* Now returns non-negative number for success, negative for failure.
*/
int ei_rpc_to(ei_cnode *ec, int fd, char *mod, char *fun,
const char *buf, int len)
{
ei_x_buff x;
erlang_pid *self = ei_self(ec);
self->num = fd;
/* encode header */
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x, 2); /* A */
self->num = fd;
ei_x_encode_pid(&x, self); /* A 1 */
ei_x_encode_tuple_header(&x, 5); /* B A 2 */
ei_x_encode_atom(&x, "call"); /* B 1 */
ei_x_encode_atom(&x, mod); /* B 2 */
ei_x_encode_atom(&x, fun); /* B 3 */
ei_x_append_buf(&x, buf, len); /* B 4 */
ei_x_encode_atom(&x, "user"); /* B 5 */
/* ei_x_encode_atom(&x,"user"); */
ei_send_reg_encoded(fd, self, "rex", x.buff, x.index);
ei_x_free(&x);
return 0;
} /* rpc_to */
int gn_start_cnode(char **argv) {
extern ei_cnode ec;
char rem_node_name[MAXATOMLEN] = ""; /* other node name */
ei_x_buff xbuf;
erlang_pid *self = ei_self(&ec);
strcat(rem_node_name,REMNODE);
strcat(rem_node_name,"@");
strcat(rem_node_name,REMHOST);
rem_regname = g_strdup(REMREG);
g_print("I am %s, you are %s (%d)\n", NODE_NAME, rem_node_name, ERL_DIST_VSN);
ei_set_compat_rel(ERL_DIST_VSN); /* erlnode version of dist. protocol */
if ( ei_connect_init(&ec, NODE_NAME, COOKIE, CREATION) < 0 )
g_critical("ei_connect_init");
if ( (fd = ei_connect(&ec, rem_node_name)) < 0 )
g_critical("ei_connect failed.\nwrong cookie? erl-dist version mismatch?");
self->num = fd; /* bug?? in ei_reg_send_tmo */
ei_x_new_with_version(&xbuf);
gn_wrap_ans("handshake", &xbuf);
ei_x_encode_empty_list(&xbuf);
gn_send(&xbuf);
ei_x_free(&xbuf);
return fd;
}
int ei_reg_send_tmo(ei_cnode* ec, int fd, char *server_name,
char* buf, int len, unsigned ms)
{
erlang_pid *self = ei_self(ec);
self->num = fd;
/* erl_errno and return code is set by ei_reg_send_encoded_tmo() */
return ei_send_reg_encoded_tmo(fd, self, server_name, buf, len, ms);
}
/* 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);
}
switch_status_t add_fetch_handler(ei_node_t *ei_node, erlang_pid *from, switch_xml_binding_t *binding) {
ei_xml_agent_t *agent;
ei_xml_client_t *client;
fetch_handler_t *fetch_handler;
agent = (ei_xml_agent_t *)switch_xml_get_binding_user_data(binding);
/* write-lock the agent */
switch_thread_rwlock_wrlock(agent->lock);
if (!(client = find_xml_client(ei_node, agent))) {
client = add_xml_client(ei_node, agent);
}
fetch_handler = client->fetch_handlers;
while (fetch_handler != NULL) {
if (ei_compare_pids(&fetch_handler->pid, from) == SWITCH_STATUS_SUCCESS) {
switch_thread_rwlock_unlock(agent->lock);
return SWITCH_STATUS_SUCCESS;
}
fetch_handler = fetch_handler->next;
}
switch_malloc(fetch_handler, sizeof(*fetch_handler));
memcpy(&fetch_handler->pid, from, sizeof(erlang_pid));;
fetch_handler->next = NULL;
if (client->fetch_handlers) {
fetch_handler->next = client->fetch_handlers;
}
client->fetch_handlers = fetch_handler;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Added %s XML handler %s <%d.%d.%d>\n"
,xml_section_to_string(agent->section)
,fetch_handler->pid.node
,fetch_handler->pid.creation
,fetch_handler->pid.num
,fetch_handler->pid.serial);
switch_thread_rwlock_unlock(agent->lock);
ei_link(ei_node, ei_self(&globals.ei_cnode), from);
return SWITCH_STATUS_SUCCESS;
}
static switch_status_t handle_msg_bind(listener_t *listener, erlang_msg * msg, ei_x_buff * buf, ei_x_buff * rbuf)
{
/* format is (result|config|directory|dialplan|phrases) */
char sectionstr[MAXATOMLEN];
switch_xml_section_t section;
if (ei_decode_atom(buf->buff, &buf->index, sectionstr) || !(section = switch_xml_parse_section_string(sectionstr))) {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "badarg");
} else {
struct erlang_binding *binding, *ptr;
if (!(binding = switch_core_alloc(listener->pool, sizeof(*binding)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error\n");
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "badmem");
} else {
binding->section = section;
binding->process.type = ERLANG_PID;
binding->process.pid = msg->from;
binding->listener = listener;
switch_thread_rwlock_wrlock(globals.listener_rwlock);
for (ptr = bindings.head; ptr && ptr->next; ptr = ptr->next);
if (ptr) {
ptr->next = binding;
} else {
bindings.head = binding;
}
switch_xml_set_binding_sections(bindings.search_binding, switch_xml_get_binding_sections(bindings.search_binding) | section);
switch_thread_rwlock_unlock(globals.listener_rwlock);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "sections %d\n", switch_xml_get_binding_sections(bindings.search_binding));
ei_link(listener, ei_self(listener->ec), &msg->from);
ei_x_encode_atom(rbuf, "ok");
}
}
return SWITCH_STATUS_SUCCESS;
}
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;
}
erlang_pid *erl_self(void)
{
return ei_self(&erl_if_ec);
}
static switch_status_t handle_msg_atom(listener_t *listener, erlang_msg * msg, ei_x_buff * buf, ei_x_buff * rbuf)
{
char atom[MAXATOMLEN];
switch_status_t ret = SWITCH_STATUS_SUCCESS;
if (ei_decode_atom(buf->buff, &buf->index, atom)) {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "badarg");
} else if (!strncmp(atom, "nolog", MAXATOMLEN)) {
if (switch_test_flag(listener, LFLAG_LOG)) {
void *pop;
/*purge the log queue */
while (switch_queue_trypop(listener->log_queue, &pop) == SWITCH_STATUS_SUCCESS);
switch_clear_flag_locked(listener, LFLAG_LOG);
}
ei_x_encode_atom(rbuf, "ok");
} else if (!strncmp(atom, "register_log_handler", MAXATOMLEN)) {
ei_link(listener, ei_self(listener->ec), &msg->from);
listener->log_process.type = ERLANG_PID;
memcpy(&listener->log_process.pid, &msg->from, sizeof(erlang_pid));
listener->level = SWITCH_LOG_DEBUG;
switch_set_flag(listener, LFLAG_LOG);
ei_x_encode_atom(rbuf, "ok");
} else if (!strncmp(atom, "register_event_handler", MAXATOMLEN)) {
ei_link(listener, ei_self(listener->ec), &msg->from);
listener->event_process.type = ERLANG_PID;
memcpy(&listener->event_process.pid, &msg->from, sizeof(erlang_pid));
if (!switch_test_flag(listener, LFLAG_EVENTS)) {
switch_set_flag_locked(listener, LFLAG_EVENTS);
}
ei_x_encode_atom(rbuf, "ok");
} else if (!strncmp(atom, "noevents", MAXATOMLEN)) {
void *pop;
/*purge the event queue */
while (switch_queue_trypop(listener->event_queue, &pop) == SWITCH_STATUS_SUCCESS);
if (switch_test_flag(listener, LFLAG_EVENTS)) {
uint8_t x = 0;
switch_clear_flag_locked(listener, LFLAG_EVENTS);
for (x = 0; x <= SWITCH_EVENT_ALL; x++) {
listener->event_list[x] = 0;
}
/* wipe the hash */
switch_core_hash_destroy(&listener->event_hash);
switch_core_hash_init(&listener->event_hash, listener->pool);
ei_x_encode_atom(rbuf, "ok");
} else {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "notlistening");
}
} else if (!strncmp(atom, "session_noevents", MAXATOMLEN)) {
session_elem_t *session;
if ((session = find_session_elem_by_pid(listener, &msg->from))) {
void *pop;
uint8_t x = 0;
/*purge the event queue */
while (switch_queue_trypop(session->event_queue, &pop) == SWITCH_STATUS_SUCCESS);
for (x = 0; x <= SWITCH_EVENT_ALL; x++) {
session->event_list[x] = 0;
}
/* wipe the hash */
switch_core_hash_destroy(&session->event_hash);
switch_core_hash_init(&session->event_hash, session->pool);
ei_x_encode_atom(rbuf, "ok");
} else {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "notlistening");
}
} else if (!strncmp(atom, "exit", MAXATOMLEN)) {
ei_x_encode_atom(rbuf, "ok");
ret = SWITCH_STATUS_TERM;
} else if (!strncmp(atom, "getpid", MAXATOMLEN)) {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "ok");
ei_x_encode_pid(rbuf, ei_self(listener->ec));
} else if (!strncmp(atom, "link", MAXATOMLEN)) {
/* debugging */
ei_link(listener, ei_self(listener->ec), &msg->from);
ret = SWITCH_STATUS_FALSE;
} else {
ei_x_encode_tuple_header(rbuf, 2);
ei_x_encode_atom(rbuf, "error");
ei_x_encode_atom(rbuf, "undef");
}
return ret;
}
int cmd_erlang_info(struct sip_msg* msg, char *cn, char *rp, char *ar) {
#define AVP_PRINTBUF_SIZE 1024
static char printbuf[AVP_PRINTBUF_SIZE];
int printbuf_len, bytessent;
ei_x_buff argbuf;
struct nodes_list* node;
struct erlang_cmd *erl_cmd;
erlang_pid erl_pid;
str conname, regproc;
int retcode = -1;
if(msg==NULL) {
LM_ERR("cmd_erlang_info: received null msg\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)cn, &conname)<0) {
LM_ERR("cmd_erlang_info: cannot get the connection name\n");
return -1;
}
for(node=nodes_lst;node;node=node->next) {
LM_DBG("cmd_erlang_info: matching %s with %.*s\n",node->name,conname.len,conname.s);
if(strcmp(node->name, conname.s)==0) break;
}
if(node==0){
LM_ERR("cmd_erlang_info: no such connection %.*s\n",conname.len,conname.s);
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)rp, ®proc)<0) {
LM_ERR("cmd_erlang_info: cannot get the regproc name\n");
return -1;
}
printbuf_len = AVP_PRINTBUF_SIZE-1;
if(pv_printf(msg, (pv_elem_p)ar, printbuf, &printbuf_len)<0 || printbuf_len<=0)
{
LM_ERR("cmd_erlang_info: cannot expand erlang message body\n");
return -1;
}
erl_cmd=shm_malloc(sizeof(struct erlang_cmd));
if(!erl_cmd) {
LM_ERR("no shm");
return -1;
}
memset(erl_cmd,0,sizeof(struct erlang_cmd));
erl_cmd->erlbuf=shm_malloc(AVP_PRINTBUF_SIZE);
if (!erl_cmd->erlbuf) {
LM_ERR("no shm memory\n\n");
goto error;
}
if(lock_init(&(erl_cmd->lock))==NULL) {
LM_ERR("cannot init the lock\n");
goto error;
}
erl_cmd->reg_name=shm_strdup(®proc);
if (!erl_cmd->reg_name) {
LM_ERR("no shm memory\n\n");
goto error;
}
LM_DBG("cmd_erlang_info: %.*s %.*s %.*s\n",conname.len,conname.s,
regproc.len,regproc.s, printbuf_len,printbuf);
erl_cmd->cmd=ERLANG_INFO;
erl_cmd->node=node;
argbuf.buff=erl_cmd->erlbuf;
argbuf.buffsz=AVP_PRINTBUF_SIZE-1;
argbuf.index=0;
ei_x_encode_version(&argbuf);
//User passed term will be sedond element of tuple, first is our erlang pid
ei_x_encode_tuple_header(&argbuf, 2);
// we are hacking erlang pid so we can have worker system pid here
memcpy(&erl_pid,ei_self(&(node->ec)),sizeof(erlang_pid));
erl_pid.num=getpid();
ei_x_encode_pid(&argbuf, &erl_pid);
//so much for pid, now encode term
if(ei_x_format_wo_ver(&argbuf, printbuf)!=0) {
LM_ERR("cannot fromat erlang binary from arg string\n");
goto error;
}
// ei_x_encode_atom(&argbuf,"user");
erl_cmd->erlbuf_len=argbuf.index;
lock_get(&(erl_cmd->lock));
bytessent=write(pipe_fds[1], &erl_cmd, sizeof(erl_cmd));
LM_DBG("cmd_erlang_info: locked, sent %d %d %s %d %p %p, waiting for release\n",bytessent,
erl_cmd->cmd,erl_cmd->reg_name,erl_cmd->erlbuf_len,erl_cmd->erlbuf, erl_cmd);
lock_get(&(erl_cmd->lock));
LM_DBG("after lock\n");
if (erl_cmd->retcode <0) {
retcode=erl_cmd->retcode;
LM_DBG("cmd_erlang_info: failed %d\n",retcode);
goto error;
}
retcode=1;
error:
if(erl_cmd) {
if(erl_cmd->erlbuf) shm_free(erl_cmd->erlbuf);
if(erl_cmd->reg_name) shm_free(erl_cmd->reg_name);
shm_free(erl_cmd);
}
return retcode;
}
int cmd_erlang_rex(struct sip_msg* msg, char *cn , char *mo, char *fu, char *ar, char *_ret_pv) {
#define AVP_PRINTBUF_SIZE 1024
static char printbuf[AVP_PRINTBUF_SIZE];
int printbuf_len, bytessent;
ei_x_buff argbuf;
struct nodes_list* node;
struct erlang_cmd *erl_cmd;
erlang_pid erl_pid;
str conname, regproc;
str mod, fun;
int retcode = -1;
if(msg==NULL) {
LM_ERR("cmd_erlang_rex: received null msg\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)cn, &conname)<0) {
LM_ERR("cmd_erlang_rex: cannot get the connection name\n");
return -1;
}
for(node=nodes_lst;node;node=node->next) {
LM_DBG("matching %s with %.*s\n",node->name,conname.len,conname.s);
if(strcmp(node->name, conname.s)==0) break;
}
if(node==0){
LM_ERR("cmd_erlang_rex: no such connection %.*s\n",conname.len,conname.s);
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)mo, &mod)<0) {
LM_ERR("cmd_erlang_rex: cannot get the mod name\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)fu, &fun)<0) {
LM_ERR("cmd_erlang_rex: cannot get the fun name\n");
return -1;
}
printbuf_len = AVP_PRINTBUF_SIZE-1;
if(pv_printf(msg, (pv_elem_p)ar, printbuf, &printbuf_len)<0 || printbuf_len<=0)
{
LM_ERR("erlang_cmd_rex: cannot expand args expression.\n");
return -1;
}
erl_cmd=shm_malloc(sizeof(struct erlang_cmd));
if(!erl_cmd) {
LM_ERR("no shm");
return -1;
}
memset(erl_cmd,0,sizeof(struct erlang_cmd));
erl_cmd->erlbuf=shm_malloc(AVP_PRINTBUF_SIZE);
if (!erl_cmd->erlbuf) {
LM_ERR("no shm memory\n\n");
goto error;
}
erl_cmd->ret_pv = (pv_spec_t*)shm_malloc(sizeof(pv_spec_t));
if (!erl_cmd->ret_pv) {
LM_ERR("no shm memory\n\n");
goto error;
}
memcpy(erl_cmd->ret_pv, (pv_spec_t *)_ret_pv, sizeof(pv_spec_t));
if(lock_init(&(erl_cmd->lock))==NULL) {
LM_ERR("cannot init the lock\n");
goto error;
}
regproc.s="rex";
regproc.len=3;
erl_cmd->reg_name=shm_strdup(®proc);
if (!erl_cmd->reg_name) {
LM_ERR("no shm memory\n\n");
goto error;
}
LM_DBG("cmd_erlang_rex: %.*s rex %.*s\n",conname.len,conname.s,
printbuf_len,printbuf);
erl_cmd->cmd=ERLANG_REX;
erl_cmd->node=node;
argbuf.buff=erl_cmd->erlbuf;
argbuf.buffsz=AVP_PRINTBUF_SIZE-1;
argbuf.index=0;
ei_x_encode_version(&argbuf);
//User passed term will be second element of tuple, first is our (hacked) erlang pid
ei_x_encode_tuple_header(&argbuf, 2);
// we are hacking erlang pid so we can have worker system pid here
memcpy(&erl_pid,ei_self(&(node->ec)),sizeof(erlang_pid));
erl_pid.num=getpid();
ei_x_encode_pid(&argbuf, &erl_pid);
erl_cmd->num=erl_pid.num;
erl_cmd->serial=erl_pid.serial;
//so much for pid, now encode rex call tuple {call, mod, fun, arg, user}
ei_x_encode_tuple_header(&argbuf, 5);
ei_x_encode_atom(&argbuf,"call");
ei_x_encode_atom_len(&argbuf, mod.s, mod.len);
ei_x_encode_atom_len(&argbuf, fun.s, fun.len);
if(ei_x_format_wo_ver(&argbuf, printbuf)!=0) {
LM_ERR("cannot fromat erlang binary from arg string\n");
goto error;
}
ei_x_encode_atom(&argbuf,"user");
erl_cmd->erlbuf_len=argbuf.index;
lock_get(&(erl_cmd->lock));
bytessent=write(pipe_fds[1], &erl_cmd, sizeof(erl_cmd));
LM_DBG("cmd_erlang_call: locked, sent %d %d %s %d %p %p, waiting for release\n",bytessent,
erl_cmd->cmd,erl_cmd->reg_name,erl_cmd->erlbuf_len,erl_cmd->erlbuf, erl_cmd);
lock_get(&(erl_cmd->lock));
LM_DBG("after lock\n");
if (erl_cmd->retcode <0) {
retcode=erl_cmd->retcode;
LM_DBG("cmd_erlang_call: failed %d\n",retcode);
goto error;
}
//reuse
argbuf.buff=erl_cmd->erlbuf;
argbuf.buffsz=erl_cmd->erlbuf_len;
argbuf.index=erl_cmd->decode_index;
fill_retpv(erl_cmd->ret_pv,&argbuf,&(argbuf.index));
retcode=1;
error:
if(erl_cmd) {
if(erl_cmd->ret_pv) shm_free(erl_cmd->ret_pv);
if(erl_cmd->erlbuf) shm_free(erl_cmd->erlbuf);
if(erl_cmd->reg_name) shm_free(erl_cmd->reg_name);
shm_free(erl_cmd);
}
return retcode;
}
