/* * Sends an Erlang message to a process at an Erlang node */ int erl_send(int fd, ETERM *to ,ETERM *msg) { erlang_pid topid; ei_x_buff x; int r; ei_x_new_with_version(&x); ei_x_encode_term(&x, msg); /* make the to-pid */ if (!ERL_IS_PID(to)) { ei_x_free(&x); erl_errno = EINVAL; return -1; } if (to->uval.pidval.node.latin1) { strcpy(topid.node, to->uval.pidval.node.latin1); } else { strcpy(topid.node, to->uval.pidval.node.utf8); } topid.num = ERL_PID_NUMBER(to); topid.serial = ERL_PID_SERIAL(to); topid.creation = ERL_PID_CREATION(to); r = ei_send(fd, &topid, x.buff, x.index); ei_x_free(&x); return r == 0; }
static void cmd_ei_send_funs(char* buf, int len) { int index = 0, n; long fd; erlang_pid pid; ei_x_buff x; erlang_fun fun1, fun2; 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) fail("expected tuple"); if (n != 2) fail("expected tuple"); if (ei_decode_fun(buf, &index, &fun1) < 0) fail("expected Fun1"); if (ei_decode_fun(buf, &index, &fun2) < 0) fail("expected Fun2"); if (ei_x_new_with_version(&x) < 0) fail("ei_x_new_with_version"); if (ei_x_encode_tuple_header(&x, 2) < 0) fail("encode tuple header"); if (ei_x_encode_fun(&x, &fun1) < 0) fail("encode fun1"); if (ei_x_encode_fun(&x, &fun2) < 0) fail("encode fun2"); free_fun(&fun1); free_fun(&fun2); send_errno_result(ei_send(fd, &pid, x.buff, x.index)); ei_x_free(&x); }
int ei_helper_send(ei_node_t *ei_node, erlang_pid *to, ei_x_buff *buf) { int ret = 0; if (ei_node->nodefd) { #ifdef EI_DEBUG ei_x_print_msg(buf, to, 1); #endif ret = ei_send(ei_node->nodefd, to, buf->buff, buf->index); } return ret; }
static void cmd_ei_format_pid(char* buf, int len) { int index = 0; long fd; erlang_pid pid; ei_x_buff x; 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_x_new_with_version(&x) < 0) fail("ei_x_new_with_version"); if (ei_x_format_wo_ver(&x, "~p", &pid) < 0) fail("ei_x_format_wo_ver"); send_errno_result(ei_send(fd, &pid, x.buff, x.index)); ei_x_free(&x); }
int ei_sendto(ei_cnode * ec, int fd, struct erlang_process *process, ei_x_buff * buf) { int ret; if (process->type == ERLANG_PID) { ret = ei_send(fd, &process->pid, buf->buff, buf->index); #ifdef EI_DEBUG ei_x_print_msg(buf, &process->pid, 1); #endif } else if (process->type == ERLANG_REG_PROCESS) { ret = ei_reg_send(ec, fd, process->reg_name, buf->buff, buf->index); #ifdef EI_DEBUG ei_x_print_reg_msg(buf, process->reg_name, 1); #endif } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid process type!\n"); /* wuh-oh */ ret = -1; } return ret; }
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; }
void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) { int etype, esize; int arity; char *gen_call; char *module; char *call; char buffer[0xffff]; char *argv[256] ; uint16_t argvs[256] ; int argc = 0; uint16_t ret; ei_x_buff xr; erlang_ref eref; ei_get_type(x->buff, &x->index, &etype, &esize); #ifdef UWSGI_DEBUG uwsgi_log("%d %c %c %c\n", etype, etype, ERL_SMALL_TUPLE_EXT, ERL_LARGE_TUPLE_EXT); #endif if (etype != ERL_SMALL_TUPLE_EXT && etype != ERL_LARGE_TUPLE_EXT) return; ei_decode_tuple_header(x->buff, &x->index, &arity); #ifdef UWSGI_DEBUG uwsgi_log("rpc arity %d\n", arity); #endif if (arity != 3) return ; ei_get_type(x->buff, &x->index, &etype, &esize); if (etype != ERL_ATOM_EXT && etype != ERL_STRING_EXT) return ; gen_call = uwsgi_malloc(esize); if (etype == ERL_ATOM_EXT) { ei_decode_atom(x->buff, &x->index, gen_call); } else { ei_decode_string(x->buff, &x->index, gen_call); } #ifdef UWSGI_DEBUG uwsgi_log("gen call = %s\n", gen_call); #endif ei_get_type(x->buff, &x->index, &etype, &esize); if (etype != ERL_SMALL_TUPLE_EXT) return ; ei_decode_tuple_header(x->buff, &x->index, &arity); if (arity != 2) return ; ei_get_type(x->buff, &x->index, &etype, &esize); ei_skip_term(x->buff, &x->index); ei_get_type(x->buff, &x->index, &etype, &esize); ei_decode_ref(x->buff, &x->index, &eref); ei_get_type(x->buff, &x->index, &etype, &esize); module = uwsgi_malloc(esize); if (etype == ERL_ATOM_EXT) { ei_decode_atom(x->buff, &x->index, module); } else { ei_decode_string(x->buff, &x->index, module); } ei_get_type(x->buff, &x->index, &etype, &esize); if (etype != ERL_SMALL_TUPLE_EXT) return ; ei_decode_tuple_header(x->buff, &x->index, &arity); #ifdef UWSGI_DEBUG uwsgi_log("arity: %d\n", arity); #endif if (arity != 5) return ; ei_get_type(x->buff, &x->index, &etype, &esize); char *method = uwsgi_malloc(esize); if (etype == ERL_ATOM_EXT) { ei_decode_atom(x->buff, &x->index, method); } else { ei_decode_string(x->buff, &x->index, method); } if (strcmp(method, "call")) return; ei_get_type(x->buff, &x->index, &etype, &esize); if (etype != ERL_ATOM_EXT && etype != ERL_STRING_EXT) return ; module = uwsgi_malloc(esize); if (etype == ERL_ATOM_EXT) { ei_decode_atom(x->buff, &x->index, module); } else { ei_decode_string(x->buff, &x->index, module); } ei_get_type(x->buff, &x->index, &etype, &esize); if (etype != ERL_ATOM_EXT && etype != ERL_STRING_EXT) return ; call = uwsgi_malloc(esize); if (etype == ERL_ATOM_EXT) { ei_decode_atom(x->buff, &x->index, call); } else { ei_decode_string(x->buff, &x->index, call); } #ifdef UWSGI_DEBUG uwsgi_log("RPC %s %s\n", module, call); #endif ei_get_type(x->buff, &x->index, &etype, &esize); if (etype == ERL_ATOM_EXT) { argc = 1; argv[0] = uwsgi_malloc(esize+1); ei_decode_atom(x->buff, &x->index, argv[0]); argvs[1] = esize; } else if (etype == ERL_STRING_EXT) { argc = 1; argv[0] = uwsgi_malloc(esize+1); ei_decode_string(x->buff, &x->index, argv[0]); argvs[1] = esize; } ret = uwsgi_rpc(call, argc, argv, argvs, buffer); #ifdef UWSGI_DEBUG uwsgi_log("buffer: %.*s\n", ret, buffer); #endif ei_x_new_with_version(&xr); ei_x_encode_tuple_header(&xr, 2); //ei_x_encode_atom(&xr, "rex"); ei_x_encode_ref(&xr, &eref); ei_x_encode_string_len(&xr, buffer, ret); uwsgi_log("ei_send to %d %s %d %d %d: %d %d\n", fd, from->node, from->num , from->serial, from->creation, xr.index, ei_send(fd, from, xr.buff, xr.index)); //uwsgi_log("ei_send to %d %s %d %d %d: %d %d\n", fd, from->node, from->num , from->serial, from->creation, xr.index, ei_reg_send(&uerl.cnode, fd, "rex", xr.buff, xr.index)); }
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; }
/* {'$gen_call', {<[email protected]>, #Ref<254770.4.0>}, {is_auth, cpx@freecpx} */ static switch_status_t handle_net_kernel_msg(listener_t *listener, erlang_msg * msg, ei_x_buff * buf, ei_x_buff * rbuf) { int version, size, type, arity; char atom[MAXATOMLEN]; erlang_ref ref; erlang_pid pid; buf->index = 0; ei_decode_version(buf->buff, &buf->index, &version); ei_get_type(buf->buff, &buf->index, &type, &size); if (type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "not a tuple\n"); return SWITCH_STATUS_FALSE; } ei_decode_tuple_header(buf->buff, &buf->index, &arity); if (arity != 3) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "wrong arity\n"); return SWITCH_STATUS_FALSE; } if (ei_decode_atom(buf->buff, &buf->index, atom) || strncmp(atom, "$gen_call", MAXATOMLEN)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "not gen_call\n"); return SWITCH_STATUS_FALSE; } ei_get_type(buf->buff, &buf->index, &type, &size); if (type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "not a tuple\n"); return SWITCH_STATUS_FALSE; } ei_decode_tuple_header(buf->buff, &buf->index, &arity); if (arity != 2) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "wrong arity\n"); return SWITCH_STATUS_FALSE; } if (ei_decode_pid(buf->buff, &buf->index, &pid) || ei_decode_ref(buf->buff, &buf->index, &ref)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "decoding pid and ref error\n"); return SWITCH_STATUS_FALSE; } ei_get_type(buf->buff, &buf->index, &type, &size); if (type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "not a tuple\n"); return SWITCH_STATUS_FALSE; } ei_decode_tuple_header(buf->buff, &buf->index, &arity); if (arity != 2) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "bad arity\n"); return SWITCH_STATUS_FALSE; } if (ei_decode_atom(buf->buff, &buf->index, atom) || strncmp(atom, "is_auth", MAXATOMLEN)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "not is_auth\n"); return SWITCH_STATUS_FALSE; } /* To ! {Tag, Reply} */ ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_ref(rbuf, &ref); ei_x_encode_atom(rbuf, "yes"); switch_mutex_lock(listener->sock_mutex); ei_send(listener->sockfd, &pid, rbuf->buff, rbuf->index); switch_mutex_unlock(listener->sock_mutex); #ifdef EI_DEBUG ei_x_print_msg(rbuf, &pid, 1); #endif return SWITCH_STATUS_FALSE; }
static void *SWITCH_THREAD_FUNC api_exec(switch_thread_t *thread, void *obj) { switch_bool_t r = SWITCH_TRUE; struct api_command_struct *acs = (struct api_command_struct *) obj; switch_stream_handle_t stream = { 0 }; char *reply, *freply = NULL; switch_status_t status; if (!acs) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Internal error.\n"); return NULL; } if (!acs->listener || !acs->listener->rwlock || switch_thread_rwlock_tryrdlock(acs->listener->rwlock) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error! cannot get read lock.\n"); goto done; } SWITCH_STANDARD_STREAM(stream); if ((status = switch_api_execute(acs->api_cmd, acs->arg, NULL, &stream)) == SWITCH_STATUS_SUCCESS) { reply = stream.data; } else { freply = switch_mprintf("%s: Command not found!\n", acs->api_cmd); reply = freply; r = SWITCH_FALSE; } if (!reply) { reply = "Command returned no output!"; r = SWITCH_FALSE; } if (*reply == '-') r = SWITCH_FALSE; if (acs->bg) { switch_event_t *event; if (switch_event_create(&event, SWITCH_EVENT_BACKGROUND_JOB) == SWITCH_STATUS_SUCCESS) { ei_x_buff ebuf; switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Job-UUID", acs->uuid_str); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Job-Command", acs->api_cmd); ei_x_new_with_version(&ebuf); if (acs->arg) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Job-Command-Arg", acs->arg); } switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Job-Successful", r ? "true" : "false"); switch_event_add_body(event, "%s", reply); switch_event_fire(&event); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sending bgapi reply to %s\n", acs->pid.node); ei_x_encode_tuple_header(&ebuf, 3); if (r) ei_x_encode_atom(&ebuf, "bgok"); else ei_x_encode_atom(&ebuf, "bgerror"); _ei_x_encode_string(&ebuf, acs->uuid_str); _ei_x_encode_string(&ebuf, reply); switch_mutex_lock(acs->listener->sock_mutex); ei_send(acs->listener->sockfd, &acs->pid, ebuf.buff, ebuf.index); switch_mutex_unlock(acs->listener->sock_mutex); #ifdef EI_DEBUG ei_x_print_msg(&ebuf, &acs->pid, 1); #endif ei_x_free(&ebuf); } } else { ei_x_buff rbuf; ei_x_new_with_version(&rbuf); ei_x_encode_tuple_header(&rbuf, 2); if (!strlen(reply)) { reply = "Command returned no output!"; r = SWITCH_FALSE; } if (r) { ei_x_encode_atom(&rbuf, "ok"); } else { ei_x_encode_atom(&rbuf, "error"); } _ei_x_encode_string(&rbuf, reply); switch_mutex_lock(acs->listener->sock_mutex); ei_send(acs->listener->sockfd, &acs->pid, rbuf.buff, rbuf.index); switch_mutex_unlock(acs->listener->sock_mutex); #ifdef EI_DEBUG ei_x_print_msg(&rbuf, &acs->pid, 1); #endif ei_x_free(&rbuf); } switch_safe_free(stream.data); switch_safe_free(freply); if (acs->listener->rwlock) { switch_thread_rwlock_unlock(acs->listener->rwlock); } done: if (acs->bg) { switch_memory_pool_t *pool = acs->pool; acs = NULL; switch_core_destroy_memory_pool(&pool); pool = NULL; } return NULL; }
int handle_msg(listener_t *listener, erlang_msg * msg, ei_x_buff * buf, ei_x_buff * rbuf) { int type, type2, size, version, arity, tmpindex; switch_status_t ret = SWITCH_STATUS_SUCCESS; if (msg->msgtype == ERL_REG_SEND && !strncmp(msg->toname, "net_kernel", MAXATOMLEN)) { /* try to respond to ping stuff */ ret = handle_net_kernel_msg(listener, msg, buf, rbuf); } else { buf->index = 0; ei_decode_version(buf->buff, &buf->index, &version); ei_get_type(buf->buff, &buf->index, &type, &size); switch (type) { case ERL_SMALL_TUPLE_EXT: case ERL_LARGE_TUPLE_EXT: tmpindex = buf->index; ei_decode_tuple_header(buf->buff, &tmpindex, &arity); ei_get_type(buf->buff, &tmpindex, &type2, &size); switch (type2) { case ERL_ATOM_EXT: ret = handle_msg_tuple(listener, msg, buf, rbuf); break; case ERL_REFERENCE_EXT: case ERL_NEW_REFERENCE_EXT: ret = handle_ref_tuple(listener, msg, buf, rbuf); break; default: switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "WEEEEEEEE %d %d\n", type, type2); /* some other kind of erlang term */ ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_atom(rbuf, "error"); ei_x_encode_atom(rbuf, "undef"); break; } break; case ERL_ATOM_EXT: ret = handle_msg_atom(listener, msg, buf, rbuf); break; default: /* some other kind of erlang term */ ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_atom(rbuf, "error"); ei_x_encode_atom(rbuf, "undef"); break; } } if (SWITCH_STATUS_FALSE == ret) { return 0; } else if (rbuf->index > 1) { switch_mutex_lock(listener->sock_mutex); ei_send(listener->sockfd, &msg->from, rbuf->buff, rbuf->index); switch_mutex_unlock(listener->sock_mutex); #ifdef EI_DEBUG ei_x_print_msg(rbuf, &msg->from, 1); #endif if (SWITCH_STATUS_SUCCESS == ret) return 0; else /* SWITCH_STATUS_TERM */ return 1; } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Empty reply, supressing\n"); return 0; } }
int worker_send_impl(ei_cnode *ec, int s,int wpid) { erlang_pid pid; ei_x_buff emsg; struct msghdr msgh; struct iovec cnt[6]; int rc; memset((void*)&emsg,0,sizeof(emsg)); memset((void*)&msgh,0,sizeof(msgh)); /* Erlang args size */ cnt[0].iov_base = &emsg.buffsz; cnt[0].iov_len = sizeof(int); /* get data size */ msgh.msg_iov = cnt; msgh.msg_iovlen = 1; while ((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) ; if (rc == -1){ LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno)); return -1; } emsg.buff = (char*)malloc(emsg.buffsz); if (!emsg.buff) { LM_ERR("malloc: not enough memory\n"); goto err; } /* buffers */ cnt[1].iov_base = &pid; cnt[1].iov_len = sizeof(erlang_pid); cnt[2].iov_base = emsg.buff; cnt[2].iov_len = emsg.buffsz; /* get whole data */ msgh.msg_iovlen = 3; 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; } if(!enode) { LM_NOTICE("there is no connected Erlang node\n"); goto err; } LM_DBG(">> <%s.%d.%d> ! emsg\n",pid.node,pid.num,pid.serial); EI_X_BUFF_PRINT(&emsg); /* do ERL_SEND */ if ((rc = ei_send(enode->sockfd,&pid,emsg.buff,emsg.buffsz)) == ERL_ERROR) { if (erl_errno) { LM_ERR("ei_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno)); } else if (errno) { LM_ERR("ei_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno)); } else { LM_ERR("ei_send failed on node=<%s> socket=<%d>, Unknown error.\n",ec->thisalivename,enode->sockfd); } } free(emsg.buff); return 0; err: free(emsg.buff); return -1; }