static void cmd_ei_rpc(char* buf, int len) { int index = 0, n; long fd; erlang_pid pid; ei_x_buff x, rpc_x; int r; char mod[MAXATOMLEN], func[MAXATOMLEN]; #if 0 && defined(__WIN32__) DebugBreak(); #endif if (ei_decode_long(buf, &index, &fd) < 0) fail("expected long"); if (ei_decode_pid(buf, &index, &pid) < 0) fail("expected pid (node)"); if (ei_decode_tuple_header(buf, &index, &n) < 0 && n < 2) fail("expected tuple {module, function}"); if (ei_decode_atom(buf, &index, mod) < 0) fail("expected atom (module)"); if (ei_decode_atom(buf, &index, func) < 0) fail("expected atom (function)"); message("pid %s %d %d %d\n", pid.node, pid.num, pid.serial, pid.creation); message("{%s, %s}\n", mod, func); if (ei_x_new(&rpc_x) < 0) fail("ei_x_new"); if (ei_rpc(&ec, fd, mod, func, &buf[index], len - index, &rpc_x) < 0) fail("ei_rpc"); if (ei_x_new_with_version(&x) < 0) fail("ei_x_new_with_version"); if (ei_x_append(&x, &rpc_x) < 0) fail("append"); send_bin_term(&x); /*send_errno_result(ei_send(&ec, fd, &pid, x.buff, x.index));*/ ei_x_free(&x); ei_x_free(&rpc_x); }
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; }
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; }