/* * 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 */
void Client::sendPid(QByteArray procName) { ei_x_buff x; ei_x_new_with_version(&x); ei_x_encode_pid(&x, &(m_ec->self)); ei_reg_send(m_ec, m_fd, procName.data(), x.buff, x.index); ei_x_free(&x); }
/* 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); }
static void ei_x_print_msg(ei_x_buff *buf, erlang_pid *pid, int send) { char *pbuf = NULL; int i = 0; ei_x_buff pidbuf; ei_x_new(&pidbuf); ei_x_encode_pid(&pidbuf, pid); ei_s_print_term(&pbuf, pidbuf.buff, &i); ei_x_print_reg_msg(buf, pbuf, send); free(pbuf); }
/* tests de tipos simples */ int test_performance_atom(char *atom, int times) { ei_x_buff output; ei_x_buff input; erlang_msg msg; int version; int ei_res; int index; char decoded_atom[MAXATOMLEN]; // Inicializa buffers ei_x_new_with_version(&output); ei_x_new(&input); // Codifica ei_x_encode_tuple_header(&output, 2); ei_x_encode_pid(&output, &local_pid); ei_x_encode_atom(&output, atom); for (int i = 0; i<times; i++) { if (ei_reg_send(&ec, connection_fd, REMOTE_SERVER_NAME, output.buff, output.index) < 0) { return 1; } do { ei_res = ei_xreceive_msg(connection_fd, &msg, &input); } while(ei_res == ERL_TICK); if (ei_res == ERL_ERROR) { return -1; } index = 0; if (ei_decode_version(input.buff, &index, &version) < 0) { std::cout << "failed decoding version \n"; return 1; } if (ei_decode_atom(input.buff, &index, decoded_atom) < 0) { std::cout << "failed decoding atom \n"; return 1; } } return 0; }
/* * The format letters are: * a - An atom * c - A character * s - A string * i - An integer * l - A long integer * u - An unsigned long integer * f - A float * d - A double float * p - An Erlang PID */ static int pformat(const char** fmt, union arg** args, ei_x_buff* x) { int res = 0; ++(*fmt); /* skip tilde */ switch (*(*fmt)++) { case 'a': res = ei_x_encode_atom(x, (*args)->s); (*args)++; break; case 'c': res = ei_x_encode_char(x, (*args)->c); (*args)++; break; case 's': res = ei_x_encode_string(x, (*args)->s); (*args)++; break; case 'i': res = ei_x_encode_long(x, (*args)->l); (*args)++; break; case 'l': res = ei_x_encode_long(x, (*args)->l); (*args)++; break; case 'u': res = ei_x_encode_ulong(x, (*args)->u); (*args)++; break; case 'f': /* float is expanded to double (C calling conventions) */ case 'd': res = ei_x_encode_double(x, (*args)->d); (*args)++; break; case 'p': res = ei_x_encode_pid(x, (*args)->pid); (*args)++; break; default: res = -1; break; } return res; }
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 DWORD WINAPI #else static void* #endif einode_thread(void* num) { int n = (int)num; ei_cnode ec; char myname[100], destname[100]; int r, fd, listen; ErlConnect conn; erlang_msg msg; /* FILE* f;*/ sprintf(myname, "eiacc%d", n); printf("thread %d (%s) listening\n", n, myname, destname); r = ei_connect_init(&ec, myname, cookie, 0); if ((listen = my_listen(port+n)) <= 0) { printf("listen err\n"); exit(7); } if (ei_publish(&ec, port + n) == -1) { printf("ei_publish port %d\n", port+n); exit(8); } fd = ei_accept(&ec, listen, &conn); printf("ei_accept %d\n", fd); if (fd >= 0) { ei_x_buff x, xs; int index, version; erlang_pid pid; ei_x_new(&x); for (;;) { int got = ei_xreceive_msg(fd, &msg, &x); if (got == ERL_TICK) continue; if (got == ERL_ERROR) { printf("receive error %d\n", n); return 0; } printf("received %d\n", got); break; } index = 0; if (ei_decode_version(x.buff, &index, &version) != 0) { printf("ei_decode_version %d\n", n); return 0; } if (ei_decode_pid(x.buff, &index, &pid) != 0) { printf("ei_decode_pid %d\n", n); return 0; } /* fprintf(f, "got pid from %s \n", pid.node);*/ ei_x_new_with_version(&xs); ei_x_encode_tuple_header(&xs, 2); ei_x_encode_long(&xs, n); ei_x_encode_pid(&xs, &pid); r = ei_send(fd, &pid, xs.buff, xs.index); /* fprintf(f, "sent %d bytes %d\n", xs.index, r);*/ shutdown(fd, SD_SEND); closesocket(fd); ei_x_free(&x); ei_x_free(&xs); } else { printf("coudn't connect fd %d r %d\n", fd, r); } printf("done thread %d\n", n); /* fclose(f);*/ return 0; }
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; }