void vaskerl_loop (int fd) { unsigned char buf[MAX_BUF]; while (1) { ErlMessage emsg; int got = erl_receive_msg(fd, buf, MAX_BUF, &emsg); if (got == ERL_TICK) continue; else if (got == ERL_ERROR) { fprintf(stderr, "erl_error\n"); break; } if (emsg.type == ERL_REG_SEND) { printf("Got something...\n"); ETERM *resp = erl_format("{cnode, \"hello\"}"); erl_send(fd, emsg.from, resp); erl_free_term(resp); erl_free_term(emsg.from); erl_free_term(emsg.msg); } } }
int main(int argc, char **argv) { int fd; /* fd to Erlang node */ int loop = 1; /* Loop flag */ int got; /* Result of receive */ unsigned char buf[BUFSIZE]; /* Buffer for incoming message */ ErlMessage emsg; /* Incoming message */ ETERM *fromp, *tuplep, *fnp, *argp, *resp; int res; erl_init(NULL, 0); if (erl_connect_init(1, "secretcookie", 0) == -1) erl_err_quit("erl_connect_init"); if ((fd = erl_connect("e1@hostname")) < 0) erl_err_quit("erl_connect"); fprintf(stderr, "Connected to e1@hostname\n\r"); while (loop) { got = erl_receive_msg(fd, buf, BUFSIZE, &emsg); if (got == ERL_TICK) { /* ignore */ } else if (got == ERL_ERROR) { loop = 0; } else { if (emsg.type == ERL_REG_SEND) { fromp = erl_element(1, emsg.msg); tuplep = erl_element(2, emsg.msg); fnp = erl_element(1, tuplep); argp = erl_element(2, tuplep); if (strncmp(ERL_ATOM_PTR(fnp), "foo", 3) == 0) { res = foo(ERL_INT_VALUE(argp)); } else if (strncmp(ERL_ATOM_PTR(fnp), "bar", 3) == 0) { res = bar(ERL_INT_VALUE(argp)); } resp = erl_format("{cnode, ~i}", res); erl_send(fd, fromp, resp); erl_free_term(emsg.from); erl_free_term(emsg.msg); erl_free_term(fromp); erl_free_term(tuplep); erl_free_term(fnp); erl_free_term(argp); erl_free_term(resp); } } } }
int main(int argc, char **argv) { int fd; /* file descriptor of Erlang node */ int loop = 1; /* Loop flag */ int got; /* Result of receive */ unsigned char buf[BUFSIZE]; /* Buffer for incoming message */ ErlMessage emsg; /* Incoming message */ ETERM *fromp, *argp, *resp; /* Reps of Erlang terms */ int res; /* Result of the fac call */ /* initialize erl_interface (once only) */ erl_init(NULL, 0); /* initialize the connection mechanism */ if (erl_connect_init(1, "refactorcookie", 0) == -1) erl_err_quit("erl_connect_init"); /* connect to a running Erlang node */ if ((fd = erl_connect("blah@Simon-Thompsons-Computer-2")) < 0) erl_err_quit("erl_connect"); while (loop) { /* message received */ got = erl_receive_msg(fd, buf, BUFSIZE, &emsg); if (got == ERL_TICK) { /* ignore */ } else if (got == ERL_ERROR) { loop = 0; } else { if (emsg.type == ERL_REG_SEND) { /* unpack message fields */ fromp = erl_element(1, emsg.msg); argp = erl_element(2, emsg.msg); /* call fac and send result back */ resp = erl_format("{ok, ~i}", fac(ERL_INT_VALUE(argp))); erl_send(fd, fromp, resp); /* free the term storage used */ erl_free_term(emsg.from); erl_free_term(emsg.msg); erl_free_term(fromp); erl_free_term(argp); erl_free_term(resp); } } } }
static cpBool handle_collision(cpArbiter *arbiter, cpSpace *space, cpDataPointer user_data) { CP_ARBITER_GET_BODIES(arbiter, b1, b2); erlmunk_subscriber *subscriber = (erlmunk_subscriber *) user_data; erlmunk_body_data *data1 = cpBodyGetUserData(b1); erlmunk_body_data *data2 = cpBodyGetUserData(b2); // DEBUGF(("collision detected between %d and %d\n", data1->id, data2->id)); ETERM **data1_array = (ETERM **) malloc(sizeof(ETERM) * 2); data1_array[0] = erl_mk_int(data1->id); data1_array[1] = data1->term; ETERM *data1_term = erl_mk_tuple(data1_array, 2); free(data1_array); ETERM **data2_array = (ETERM **) malloc(sizeof(ETERM) * 2); data2_array[0] = erl_mk_int(data2->id); data2_array[1] = data2->term; ETERM *data2_term = erl_mk_tuple(data2_array, 2); free(data2_array); ETERM *a = erl_mk_atom("erlmunk_collision"); ETERM **data_array = (ETERM **) malloc(sizeof(ETERM) * 3); data_array[0] = a; data_array[1] = data1_term; data_array[2] = data2_term; ETERM *data = erl_mk_tuple(data_array, 3); free(data_array); ETERM *gen_cast = erl_mk_gen_cast(data); if (erl_send(subscriber->client->fd, subscriber->from, gen_cast) != 1) { DEBUGF(("failed to send data to subscriber")); } return cpFalse; }
void process_call(ETERM* master_pattern, int erl_fd) { TRACE(("cnode called")); ETERM* msg_frompid = erl_var_content(master_pattern, "Pid"); ETERM* msg_tuple = erl_var_content(master_pattern, "Cmd"); ETERM* response; if (msg_frompid == NULL || msg_tuple == NULL) { erl_err_msg("could not get Pid or Cmd vars"); fprintf(stderr, "how do i erl_var_content lol\n"); return; } ETERM* init_cmd_pattern = erl_format("{init, Arg}"); if (erl_match(init_cmd_pattern, msg_tuple)) { TRACE(("matched init command")); process_init_cmd(init_cmd_pattern, erl_fd, msg_frompid); } else { erl_err_msg("got unknown function call."); response = erl_format("{ecap_node, {error, {function_clause, ~w}}}", msg_tuple); erl_send(erl_fd, msg_frompid, response); } TRACE(("cleaning up process call")); erl_free_term(response); erl_free_term(init_cmd_pattern); //erl_free_term(msg_frompid); //this needs to be freed by the watcher, I think erl_free_term(msg_tuple); TRACE(("leaving process_call")); }
void *erl_message_read_loop(void *arg_data) { thread_data_t *data = (thread_data_t *)arg_data; ErlMessage emsg; // Incoming message unsigned char buf[BUFSIZE]; // Buffer for incoming message int got; // Result of receive ETERM *fromp, *tuplep, *fun, *arg, *resp; // Erlang terms int loop = 1; // Loop flag char *f_name_atom; int q_num; int i = 0, temp; q_data_t *q_data[MAX_Q_NUMS]; // Per queue data response_t r; /* Exepected Erlang term: {from_pid(), {fun_name_atom, argument}}} or {from_pid(), {fun_name_atom, argument1, argument2}}} and returned term: {call_state, response} */ syslog(LOG_NOTICE,"[%d] Connection with node: %s\n\r",data->idx, data->node); for(i = 0; i < MAX_Q_NUMS; i++) { q_data[i] = malloc(sizeof(q_data_t)); q_data[i]->q_num = -1; q_data[i]->h = NULL; q_data[i]->qh = NULL; q_data[i]->pid = 0; } pthread_setname_np(pthread_self(), "msg_read_loop"); while (loop) { got = erl_receive_msg(data->fd, buf, BUFSIZE, &emsg); switch (got) { case ERL_TICK: syslog(LOG_NOTICE,"[%d] %s tick\n\r",data->idx, data->node); break; case ERL_ERROR: syslog(LOG_NOTICE,"[%d] %s erl_receive_msg error or node down\n\r",data->idx, data->node); loop = 0; break; case ERL_MSG: if (emsg.type == ERL_REG_SEND || emsg.type == ERL_SEND) { fromp = erl_element(1, emsg.msg); tuplep = erl_element(2, emsg.msg); fun = erl_element(1, tuplep); arg = erl_element(2, tuplep); f_name_atom = ERL_ATOM_PTR(fun); syslog(LOG_NOTICE,"[%d] %s %s()\n\r", data->idx, data->node, f_name_atom); if(strcmp(f_name_atom, "create_queue") == 0) { q_num = ERL_INT_VALUE(arg); r = create_queue(q_num, q_data, data); } else if(strcmp(f_name_atom, "destroy_queue") == 0) { q_num = ERL_INT_VALUE(arg); r = destroy_queue(q_num, q_data, data); } else if(strcmp(f_name_atom, "queue_list") == 0) { r = queue_list(q_data); } else if(strcmp(f_name_atom, "set_mode") == 0) { temp = ERL_INT_VALUE(arg); r = set_mode(temp, tuplep, q_data, data); } else if(strcmp(f_name_atom, "set_queue_len") == 0) { temp = ERL_INT_VALUE(arg); r = set_queue_len(temp, tuplep, q_data, data); } else if(strcmp(f_name_atom, "read_pkt_start") == 0) { q_num = ERL_INT_VALUE(arg); r = read_pkt_start(q_num, q_data, data); } else if(strcmp(f_name_atom, "read_pkt_stop") == 0) { q_num = ERL_INT_VALUE(arg); r = read_pkt_stop(q_num, q_data, data); } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such function", strlen("no such function")); } if ((resp = erl_format("{cnode, {reply, {~w, ~w}}}", r.cs, r.rsp)) != NULL) { if(!erl_send(data->fd, fromp, resp)) { syslog(LOG_ERR,"[%d] %s send reply error, exit loop\n\r", data->idx, data->node); loop = 0; } } else { syslog(LOG_ERR,"[%d] %s term format error\n\r", data->idx, data->node); loop = 0; } erl_free_term(emsg.from); erl_free_term(emsg.msg); erl_free_term(fromp); erl_free_term(tuplep); erl_free_term(fun); erl_free_term(arg); erl_free_term(resp); erl_free_term(r.rsp); erl_free_term(r.cs); } break; default: syslog(LOG_ERR,"[%d] %s something wrong! :(\n\r", data->idx, data->node); loop = 0; break; } } /* while */ for(i = 0; i < MAX_Q_NUMS; i++) { if(q_data[i]->pid > 0) pthread_cancel(q_data[i]->thread); if (q_data[i]->q_num >= 0) { nfq_destroy_queue(q_data[i]->qh); nfq_close(q_data[i]->h); } free(q_data[i]); } syslog(LOG_ERR,"[%d] %s thread stop\n\r", data->idx, data->node); free(data->node); free(data); pthread_exit(NULL); }
int main(void) #endif { ei_x_buff eix; int index = 0; ETERM **etermpp = NULL, *etermp = NULL; char *charp = NULL; unsigned char uchar, **ucharpp = NULL, *ucharp = NULL; void *voidp = NULL; Erl_Heap *erl_heapp = NULL; int intx = 0; int *intp = NULL; unsigned int uintx, *uintp; unsigned long *ulongp = NULL; long longx = 0; double doublex = 0.0; short shortx = 42; FILE *filep = NULL; Erl_IpAddr erl_ipaddr = NULL; ErlMessage *erlmessagep = NULL; ErlConnect *erlconnectp = NULL; struct hostent *hostp = NULL; struct in_addr *inaddrp = NULL; /* Converion to erl_interface format is in liberl_interface */ intx = erl_errno; ei_encode_term(charp, &index, voidp); ei_x_encode_term(&eix, voidp); ei_decode_term(charp, &index, voidp); erl_init(voidp, longx); erl_connect_init(intx, charp,shortx); erl_connect_xinit(charp,charp,charp,erl_ipaddr,charp,shortx); erl_connect(charp); erl_xconnect(erl_ipaddr,charp); erl_close_connection(intx); erl_receive(intx, ucharp, intx); erl_receive_msg(intx, ucharp, intx, erlmessagep); erl_xreceive_msg(intx, ucharpp, intp, erlmessagep); erl_send(intx, etermp, etermp); erl_reg_send(intx, charp, etermp); erl_rpc(intx,charp,charp,etermp); erl_rpc_to(intx,charp,charp,etermp); erl_rpc_from(intx,intx,erlmessagep); erl_publish(intx); erl_accept(intx,erlconnectp); erl_thiscookie(); erl_thisnodename(); erl_thishostname(); erl_thisalivename(); erl_thiscreation(); erl_unpublish(charp); erl_err_msg(charp); erl_err_quit(charp); erl_err_ret(charp); erl_err_sys(charp); erl_cons(etermp,etermp); erl_copy_term(etermp); erl_element(intx,etermp); erl_hd(etermp); erl_iolist_to_binary(etermp); erl_iolist_to_string(etermp); erl_iolist_length(etermp); erl_length(etermp); erl_mk_atom(charp); erl_mk_binary(charp,intx); erl_mk_empty_list(); erl_mk_estring(charp, intx); erl_mk_float(doublex); erl_mk_int(intx); erl_mk_list(etermpp,intx); erl_mk_pid(charp,uintx,uintx,uchar); erl_mk_port(charp,uintx,uchar); erl_mk_ref(charp,uintx,uchar); erl_mk_long_ref(charp,uintx,uintx,uintx,uchar); erl_mk_string(charp); erl_mk_tuple(etermpp,intx); erl_mk_uint(uintx); erl_mk_var(charp); erl_print_term(filep,etermp); /* erl_sprint_term(charp,etermp); */ erl_size(etermp); erl_tl(etermp); erl_var_content(etermp, charp); erl_format(charp); erl_match(etermp, etermp); erl_global_names(intx, intp); erl_global_register(intx, charp, etermp); erl_global_unregister(intx, charp); erl_global_whereis(intx, charp, charp); erl_init_malloc(erl_heapp,longx); erl_alloc_eterm(uchar); erl_eterm_release(); erl_eterm_statistics(ulongp,ulongp); erl_free_array(etermpp,intx); erl_free_term(etermp); erl_free_compound(etermp); erl_malloc(longx); erl_free(voidp); erl_compare_ext(ucharp, ucharp); erl_decode(ucharp); erl_decode_buf(ucharpp); erl_encode(etermp,ucharp); erl_encode_buf(etermp,ucharpp); erl_ext_size(ucharp); erl_ext_type(ucharp); erl_peek_ext(ucharp,intx); erl_term_len(etermp); erl_gethostbyname(charp); erl_gethostbyaddr(charp, intx, intx); erl_gethostbyname_r(charp, hostp, charp, intx, intp); erl_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp); erl_init_resolve(); erl_distversion(intx); erl_epmd_connect(inaddrp); erl_epmd_port(inaddrp, charp, intp); charp = ERL_ATOM_PTR(etermp); intx = ERL_ATOM_SIZE(etermp); ucharp = ERL_BIN_PTR(etermp); intx = ERL_BIN_SIZE(etermp); etermp = ERL_CONS_HEAD(etermp); etermp = ERL_CONS_TAIL(etermp); intx = ERL_COUNT(etermp); doublex= ERL_FLOAT_VALUE(etermp); uintx = ERL_INT_UVALUE(etermp); intx = ERL_INT_VALUE(etermp); intx = ERL_IS_ATOM(etermp); intx = ERL_IS_BINARY(etermp); intx = ERL_IS_CONS(etermp); intx = ERL_IS_EMPTY_LIST(etermp); intx = ERL_IS_FLOAT(etermp); intx = ERL_IS_INTEGER(etermp); intx = ERL_IS_LIST(etermp); intx = ERL_IS_PID(etermp); intx = ERL_IS_PORT(etermp); intx = ERL_IS_REF(etermp); intx = ERL_IS_TUPLE(etermp); intx = ERL_IS_UNSIGNED_INTEGER(etermp); uchar = ERL_PID_CREATION(etermp); charp = ERL_PID_NODE(etermp); uintx = ERL_PID_NUMBER(etermp); uintx = ERL_PID_SERIAL(etermp); uchar = ERL_PORT_CREATION(etermp); charp = ERL_PORT_NODE(etermp); uintx = ERL_PORT_NUMBER(etermp); uchar = ERL_REF_CREATION(etermp); intx = ERL_REF_LEN(etermp); charp = ERL_REF_NODE(etermp); uintx = ERL_REF_NUMBER(etermp); uintp = ERL_REF_NUMBERS(etermp); etermp = ERL_TUPLE_ELEMENT(etermp,intx); intx = ERL_TUPLE_SIZE(etermp); return BUFSIZ + EAGAIN + EHOSTUNREACH + EINVAL + EIO + EMSGSIZE + ENOMEM + ERL_ATOM + ERL_BINARY + ERL_ERROR + ERL_EXIT + ERL_FLOAT + ERL_INTEGER + ERL_LINK + ERL_LIST + ERL_MSG + ERL_NO_TIMEOUT + ERL_PID + ERL_PORT + ERL_REF + ERL_REG_SEND + ERL_SEND + ERL_SMALL_BIG + ERL_TICK + ERL_TIMEOUT + ERL_TUPLE + ERL_UNLINK + ERL_U_INTEGER + ERL_U_SMALL_BIG + ERL_VARIABLE + ETIMEDOUT + MAXNODELEN + MAXREGLEN; }
int main(int argc, char **argv) { /* int fd; /\* fd to Erlang node *\/ */ int loop = 1; /* Loop flag */ int got; /* Result of receive */ unsigned char buf[BUFSIZE]; /* Buffer for incoming message */ ErlMessage emsg; /* Incoming message */ ETERM *msg_type, *fromp, *refp, *tuplep, *fnp, *arg1p, *arg2p, *resp; char hostname[255]; char erlang_nodename[255] = "e1@"; erl_init(NULL, 0); if (erl_connect_init(1, "secretcookie", 0) == -1) erl_err_quit("erl_connect_init"); /* now we figure out where to connect to */ get_hostname(hostname); strcat(erlang_nodename, hostname); strstrip(erlang_nodename); if ((fd_erlang_node = erl_connect(erlang_nodename)) < 0) erl_err_quit("erl_connect"); fprintf(stderr, "Connected to %s\n\r",erlang_nodename); while (loop) { got = erl_receive_msg(fd_erlang_node, buf, BUFSIZE, &emsg); if (got == ERL_TICK) { /* ignore */ } else if (got == ERL_ERROR) { loop = 0; } else { if (emsg.type == ERL_REG_SEND) { msg_type = erl_element(1, emsg.msg); fromp = erl_element(2, emsg.msg); refp = erl_element(3, emsg.msg); tuplep = erl_element(4, emsg.msg); fnp = erl_element(1, tuplep); if (strncmp(ERL_ATOM_PTR(msg_type), "call", 4) == 0) { /* call expects a msg back */ /* always at least one argument so we get that out first*/ arg1p = erl_element(2, tuplep); if (strncmp(ERL_ATOM_PTR(fnp), "init", 4) == 0) { printf("init requested\n"); arg2p = erl_element(3, tuplep); resp = gpio_init(arg1p, arg2p); } else if (strncmp(ERL_ATOM_PTR(fnp), "write", 5) == 0) { arg2p = erl_element(3, tuplep); /* @todo implement the real impl here */ resp = gpio_write(arg1p, arg2p); } else if (strncmp(ERL_ATOM_PTR(fnp), "read", 4) == 0) { resp = gpio_read(arg1p); } else if (strncmp(ERL_ATOM_PTR(fnp), "set_int", 7) == 0) { arg2p = erl_element(3, tuplep); /* @todo implement the real impl here */ resp = gpio_set_int(arg1p, fromp, handle_gpio_interrupt, arg2p); } else if (strncmp(ERL_ATOM_PTR(fnp), "release", 7) == 0) { resp = gpio_release(arg1p); } printf("going to send resp: %s\n", ERL_ATOM_PTR(resp)); erl_send(fd_erlang_node, fromp, erl_format("{~w,~w}", refp, resp)); } else if (strncmp(ERL_ATOM_PTR(msg_type), "cast", 4) == 0) { /* cast does not expect a msg back */ } erl_free_term(emsg.from); erl_free_term(emsg.msg); erl_free_term(fromp); erl_free_term(refp); erl_free_term(tuplep); erl_free_term(fnp); erl_free_term(arg1p); erl_free_term(arg2p); erl_free_term(resp); } } } }
void watcher(void* data) { TRACE(("watcher thread started!")); info_t* threadinfo = (info_t*)data; int triggerfd, cnt, ret; char attrdata[1024]; struct pollfd ufd; if (!ERL_IS_PID(threadinfo->topid)) { fprintf(stderr, "PID is not a pid. wat."); pthread_exit(NULL); } TRACE(("watcher thread got fname(%d): %s", strlen(threadinfo->fname), threadinfo->fname)); //TRACE(("watcher got PID <.%d.%d> and fd %d", // ERL_PID_NUMBER(&threadinfo->topid), // ERL_PID_SERIAL(&threadinfo->topid), // threadinfo->erlvm_fd)); fprintf(stderr, "watcher got PID "); erl_print_term(stderr, threadinfo->topid); fprintf(stderr, "\n"); if ((ufd.fd = open(threadinfo->fname, O_RDONLY)) < 0) { TRACE(("unable to open file %s", threadinfo->fname)); perror("unable to open file"); goto end_watcher; } ufd.events = POLLPRI | POLLERR; // dummy read cnt = read(ufd.fd, attrdata, 1023); TRACE(("dummy read got value %d", cnt)); TRACE(("starting up main watcher loop")); while ((ret = poll(&ufd, 1, 10000)) >= 0) { TRACE(("began watcher loop")); if (ret == 0) { TRACE(("watcher thread poll() timed out, continuing.")); continue; } if (ufd.revents & (POLLPRI|POLLERR)) { TRACE(("watcher caught an event!")); close(ufd.fd); if ((ufd.fd = open(threadinfo->fname, O_RDONLY)) < 0) { TRACE(("unable to re-open file %s", threadinfo->fname)); perror("unable to re-open file"); break; } cnt = read(ufd.fd, attrdata, 1023); attrdata[cnt] = '\0'; TRACE(("watcher got %d bytes: %s", cnt, attrdata)); ETERM* notification = erl_format("{data, ~s}", attrdata); int sendret = erl_send(threadinfo->erlvm_fd, threadinfo->topid, notification); if (!sendret) { switch(erl_errno) { case(EINVAL): fprintf(stderr, "unable to send notification: bad PID\n"); break; case(ENOMEM): fprintf(stderr, "unable to send notification: no memory\n"); break; case(EIO): fprintf(stderr, "unable to send notification: I/O error\n"); break; default: fprintf(stderr, "unable to send notification: unspecified error\n"); break; } } else { TRACE(("sent notification")); } free(notification); } else { printf("watcher got something weird! revents = %d\n", ufd.revents); } ufd.revents = 0; TRACE(("finishing watcher loop")); } end_watcher: erl_free_compound(threadinfo->topid); free(threadinfo->fname); pthread_t* dying = threadinfo->self; free(threadinfo); free(dying); TRACE(("watcher thread exiting")); pthread_exit(NULL); }
void process_init_cmd(ETERM* init_cmd_pattern, int erl_fd, ETERM* msg_frompid) { fprintf(stderr, "process_init_cmd got PID "); erl_print_term(stderr, msg_frompid); fprintf(stderr, "\n"); ETERM* response; ETERM* msg_arg = erl_var_content(init_cmd_pattern, "Arg"); if (!ERL_IS_LIST(msg_arg)) { erl_err_msg("invalid argument to init command"); response = erl_format("{ecap_node, {error, {badarg, {init, ~w} } } }", msg_arg); erl_send(erl_fd, msg_frompid, response); goto invarg_cleanup; } char* fn_str = erl_iolist_to_string(msg_arg); if (fn_str == NULL) { erl_err_msg("could not unpack string"); response = erl_format("{ecap_node, {error, {badarg, {init, ~w}}}}", msg_arg); erl_send(erl_fd, msg_frompid, response); goto nostr_cleanup; } TRACE(("init command got argstring: %s", fn_str)); pthread_t* thread = (pthread_t*)malloc(sizeof(pthread_t)); info_t* threadinfo = (info_t*)malloc(sizeof(info_t)); // We copy all of this data because the transient pointers will be free()d // just before each function returns, destroying in the thread context. threadinfo->topid = msg_frompid; threadinfo->self = thread; threadinfo->fname = (char*)malloc(strlen(fn_str)+1); strncpy(threadinfo->fname, fn_str, strlen(fn_str)+1); threadinfo->erlvm_fd = erl_fd; int ret; if ((ret = pthread_create(thread, NULL, watcher, threadinfo)) != 0) { TRACE(("failed to create thread, with return code %d", ret)); erl_err_ret("failed to create watcher thread"); response = erl_format("{ecap_node, {error, {threadfail}}}"); erl_send(erl_fd, msg_frompid, response); TRACE(("freeing thread stuff")); free(thread); free(threadinfo->fname); free(threadinfo); goto nothread_cleanup; } response = erl_format("{ecap_node, ok}"); erl_send(erl_fd, msg_frompid, response); TRACE(("normal cleanup from init command call")); nothread_cleanup: nostr_cleanup: TRACE(("freeing fn_str")); erl_free(fn_str); invarg_cleanup: TRACE(("freeing terms")); erl_free_term(response); erl_free_term(msg_arg); TRACE(("done with init command processing")); }
int main(int argc, char **argv) { struct in_addr addr; /* 32-bit IP number of host */ int port; /* Listen port number */ int listen; /* Listen socket */ int fd; /* fd to Erlang node */ ErlConnect conn; /* Connection data */ int loop = 1; /* Lopp flag */ int got; /* Result of receive */ unsigned char buf[BUFSIZE]; /* Buffer for incoming message */ ErlMessage emsg; /* Incoming message */ ETERM *fromp, *tuplep, *fnp, *argp, *resp; int res; port = atoi(argv[1]); erl_init(NULL, 0); addr.s_addr = inet_addr("127.0.0.1"); if (erl_connect_xinit("alpha", "cnode", "*****@*****.**", &addr, "secretcookie", 0) == -1) erl_err_quit("erl_connect_xinit"); /* Make a listen socket */ if ((listen = my_listen(port)) <= 0) erl_err_quit("my_listen"); if (erl_publish(port) == -1) erl_err_quit("erl_publish"); if ((fd = erl_accept(listen, &conn)) == ERL_ERROR) erl_err_quit("erl_accept"); fprintf(stderr, "Connected to %s\n\r", conn.nodename); while (loop) { got = erl_receive_msg(fd, buf, BUFSIZE, &emsg); if (got == ERL_TICK) { /* ignore */ } else if (got == ERL_ERROR) { loop = 0; } else { if (emsg.type == ERL_REG_SEND) { fromp = erl_element(2, emsg.msg); tuplep = erl_element(3, emsg.msg); fnp = erl_element(1, tuplep); argp = erl_element(2, tuplep); if (strncmp(ERL_ATOM_PTR(fnp), "foo", 3) == 0) { res = foo(ERL_INT_VALUE(argp)); } else if (strncmp(ERL_ATOM_PTR(fnp), "bar", 3) == 0) { res = bar(ERL_INT_VALUE(argp)); } resp = erl_format("{cnode, ~i}", res); erl_send(fd, fromp, resp); erl_free_term(emsg.from); erl_free_term(emsg.msg); erl_free_term(fromp); erl_free_term(tuplep); erl_free_term(fnp); erl_free_term(argp); erl_free_term(resp); } } } /* while */ }
int main(int argc, char *argv[]) { int fd; /* fd to Erlang node */ unsigned char buf[BUFSIZE]; /* Buffer for incoming message */ ErlMessage emsg; /* Incoming message */ int c_node; /* C-Node number */ char cookie[EI_MAX_COOKIE_SIZE+1]; /* Shared cookie */ short creation; /* ?? */ char *erlang_node; /* Erlang node to connect to */ char *cookie_opt; /* Where to source our cookie */ char *cookie_data; /* Either the filename or literal cookie */ ETERM *fromp, *msgp, *fnp, *argp, *resp; int received, loop = 1; if (argc < 5) { quit_with_error("invalid_args"); } c_node = atoi(argv[1]); cookie_opt = argv[2]; cookie_data = argv[3]; creation = 0; erlang_node = argv[4]; erl_init(NULL, 0); get_cookie(cookie_opt, cookie_data, cookie); if (!erl_connect_init(c_node, cookie, creation)) { quit_with_error("erl_connect_init"); } if ((fd = erl_connect(erlang_node)) < 0) { quit_with_error("erl_connect"); } while (loop) { received = erl_receive_msg(fd, buf, BUFSIZE, &emsg); if (received == ERL_TICK) { /* ignore */ } else if (received == ERL_ERROR) { loop = 0; } else { if (emsg.type == ERL_REG_SEND) { fromp = erl_element(2, emsg.msg); msgp = erl_element(3, emsg.msg); fnp = erl_element(1, msgp); argp = erl_element(2, msgp); if (is_function(fnp, "stop")) { loop = 0; resp = erl_format("{c_node, ~i, ok}", c_node); } else if (is_function(fnp, "new_image_blank")) { resp = new_image_blank(argp, c_node); } else if (is_function(fnp, "write_to_png")) { resp = write_to_png(argp, c_node); } else if (is_function(fnp, "close_image")) { resp = close_image(argp, c_node); } else if (is_function(fnp, "save")) { resp = save(argp, c_node); } else if (is_function(fnp, "restore")) { resp = restore(argp, c_node); } else if (is_function(fnp, "set_line_width")) { resp = set_line_width(argp, c_node); } else if (is_function(fnp, "set_source_rgba")) { resp = set_source_rgba(argp, c_node); } else if (is_function(fnp, "set_operator")) { resp = set_operator(argp, c_node); } else if (is_function(fnp, "move_to")) { resp = move_to(argp, c_node); } else if (is_function(fnp, "line_to")) { resp = line_to(argp, c_node); } else if (is_function(fnp, "curve_to")) { resp = curve_to(argp, c_node); } else if (is_function(fnp, "rel_move_to")) { resp = rel_move_to(argp, c_node); } else if (is_function(fnp, "rel_line_to")) { resp = rel_line_to(argp, c_node); } else if (is_function(fnp, "rel_curve_to")) { resp = rel_curve_to(argp, c_node); } else if (is_function(fnp, "rectangle")) { resp = rectangle(argp, c_node); } else if (is_function(fnp, "arc")) { resp = arc(argp, c_node); } else if (is_function(fnp, "arc_negative")) { resp = arc_negative(argp, c_node); } else if (is_function(fnp, "close_path")) { resp = close_path(argp, c_node); } else if (is_function(fnp, "paint")) { resp = paint(argp, c_node); } else if (is_function(fnp, "fill")) { resp = fill(argp, c_node); } else if (is_function(fnp, "fill_preserve")) { resp = fill_preserve(argp, c_node); } else if (is_function(fnp, "stroke")) { resp = stroke(argp, c_node); } else if (is_function(fnp, "stroke_preserve")) { resp = stroke_preserve(argp, c_node); } else if (is_function(fnp, "translate")) { resp = translate(argp, c_node); } else if (is_function(fnp, "scale")) { resp = scale(argp, c_node); } else if (is_function(fnp, "rotate")) { resp = rotate(argp, c_node); } else if (is_function(fnp, "select_font")) { resp = select_font_face(argp, c_node); } else if (is_function(fnp, "set_font_size")) { resp = set_font_size(argp, c_node); } else if (is_function(fnp, "show_text")) { resp = show_text(argp, c_node); } else if (is_function(fnp, "text_extents")) { resp = text_extents(argp, c_node); } else if (is_function(fnp, "surface_create_from_png")) { resp = surface_create_from_png(argp, c_node); } else if (is_function(fnp, "surface_create_from_png_stream")) { resp = surface_create_from_png_stream(argp, c_node); } else if (is_function(fnp, "surface_get_width")) { resp = surface_get_width(argp, c_node); } else if (is_function(fnp, "surface_get_height")) { resp = surface_get_height(argp, c_node); } else if (is_function(fnp, "surface_destroy")) { resp = surface_destroy(argp, c_node); } else if (is_function(fnp, "set_source_surface")) { resp = set_source_surface(argp, c_node); } else if (is_function(fnp, "write_to_png_stream")) { resp = write_to_png_stream(argp, c_node); } else { resp = erl_format("{c_node, ~i, {error, '~s'}}", c_node, "unknown command"); } erl_send(fd, fromp, resp); erl_free_term(emsg.from); erl_free_term(emsg.msg); erl_free_term(fromp); erl_free_term(msgp); erl_free_term(fnp); erl_free_term(argp); erl_free_term(resp); } } } exit(EXIT_SUCCESS); }
PyObject *py_erlang_send_message(PyObject * self, PyObject * args) { ETERM *pymessage; ETERM *pid; int erfd; PyObject *ermessage, *erdest, *zero; int er_number, er_serial, er_creation; char *er_node; if (!PyArg_ParseTuple(args, "iOO|i:erlang_send_message", &erfd, &erdest, &ermessage)) { return NULL; } if (erfd < 0) { goto clear; } if (!PyString_Check(erdest) && !PyDict_Check(erdest)) { goto clear; } pymessage = py_to_eterm(ermessage); if (!pymessage) { goto clear; } if (PyString_Check(erdest)) { if (!erl_reg_send(erfd, PyString_AsString(erdest), pymessage)) { erl_err_msg("erl_reg_send()"); goto clear2; } } else if (PyDict_Check(erdest)) { zero = PyDict_GetItemString(erdest, "node"); if (!zero) { goto clear2; } if (!PyString_Check(zero)) { goto clear2; } er_node = PyString_AsString(zero); zero = PyDict_GetItemString(erdest, "number"); if (!zero) { goto clear2; } if (!PyInt_Check(zero)) { goto clear2; } er_number = PyInt_AsLong(zero); zero = PyDict_GetItemString(erdest, "serial"); if (!zero) { goto clear2; } if (!PyInt_Check(zero)) { goto clear2; } er_serial = PyInt_AsLong(zero); zero = PyDict_GetItemString(erdest, "creation"); if (!zero) { goto clear2; } if (!PyInt_Check(zero)) { goto clear2; } er_creation = PyInt_AsLong(zero); pid = erl_mk_pid((const char *) er_node, er_number, er_serial, er_creation); if (!pid) { goto clear2; } if (!erl_send(erfd, pid, pymessage)) { erl_err_msg("erl_send()"); erl_free_term(pid); goto clear2; } erl_free_term(pid); } else { goto clear; } erl_free_compound(pymessage); Py_INCREF(Py_True); return Py_True; clear2: erl_free_compound(pymessage); clear: PyErr_Print(); Py_INCREF(Py_None); return Py_None; }
void erlang_loop(struct wsgi_request *wsgi_req) { ErlConnect econn; ErlMessage em; ETERM *eresponse; PyObject *callable = PyDict_GetItemString(uwsgi.embedded_dict, "erlang_func"); if (!callable) { PyErr_Print(); fprintf(stderr, "- you have not defined a uwsgi.erlang_func callable, Erlang message manager will be disabled until you define it -\n"); } PyObject *pargs = PyTuple_New(1); if (!pargs) { PyErr_Print(); fprintf(stderr, "- error preparing arg tuple for uwsgi.erlang_func callable, Erlang message manager will be disabled -\n"); } while (uwsgi.workers[uwsgi.mywid].manage_next_request) { UWSGI_CLEAR_STATUS; wsgi_req->poll.fd = erl_accept(uwsgi.erlangfd, &econn); if (wsgi_req->poll.fd >= 0) { UWSGI_SET_ERLANGING; for (;;) { if (erl_receive_msg(wsgi_req->poll.fd, (unsigned char *) wsgi_req->buffer, uwsgi.buffer_size, &em) == ERL_MSG) { if (em.type == ERL_TICK) continue; if (!callable) { callable = PyDict_GetItemString(uwsgi.embedded_dict, "erlang_func"); } if (!callable) { fprintf(stderr, "- you still have not defined a uwsgi.erlang_func callable, Erlang message rejected -\n"); } PyObject *zero = eterm_to_py(em.msg); if (em.msg) { erl_free_compound(em.msg); } if (em.to) { erl_free_compound(em.to); } if (!zero) { PyErr_Print(); continue; } if (PyTuple_SetItem(pargs, 0, zero)) { PyErr_Print(); continue; } PyObject *erlang_result = PyEval_CallObject(callable, pargs); //Py_DECREF(zero); if (erlang_result) { eresponse = py_to_eterm(erlang_result); if (eresponse) { erl_send(wsgi_req->poll.fd, em.from, eresponse); erl_free_compound(eresponse); } Py_DECREF(erlang_result); } if (em.from) { erl_free_compound(em.from); } uwsgi.workers[0].requests++; uwsgi.workers[uwsgi.mywid].requests++; if (uwsgi.shared->options[UWSGI_OPTION_LOGGING]) erlang_log(); } else { break; } } erl_close_connection(wsgi_req->poll.fd); UWSGI_UNSET_ERLANGING; } } }