int main(int argc, char **argv) { int port; // Listen port number int fd; // Socket descriptor int listen; // Listen socket ErlConnect conn; // Connection data char *cookie; // Erlang magic cookie pid_t pid; int x; pthread_t thread; pthread_attr_t thread_attrs; thread_data_t *data; // Per thread data: thread ID, // connection node name static unsigned int tidx = 0; pid = fork(); if (pid < 0) exit(EXIT_FAILURE); if (pid > 0) exit(EXIT_SUCCESS); if (setsid() < 0) exit(EXIT_FAILURE); umask(0); chdir("/"); signal(SIGCHLD, SIG_DFL); signal(SIGHUP, SIG_DFL); if (argc == 3) { port = atoi(argv[1]); cookie = argv[2]; } else { fprintf(stderr, "Usage: %s <port number> <erlang secret cookie>\n\r",argv[0]); exit(EXIT_FAILURE); } for (x = sysconf(_SC_OPEN_MAX); x>0; x--) close (x); setlogmask (LOG_UPTO (LOG_NOTICE)); openlog("nfq_node", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL0); erl_init(NULL, 0); if (erl_connect_init(1, cookie, 0) == -1) erl_err_quit("erl_connect_init"); if ((listen = my_listen(port)) <= 0) erl_err_quit("my_listen"); if (erl_publish(port) == -1) erl_err_quit("erl_publish"); if (pthread_attr_init(&thread_attrs)) { syslog(LOG_ERR, "error while init pthread attr struct\n\r"); exit(EXIT_FAILURE); } if ((pthread_attr_setdetachstate(&thread_attrs, PTHREAD_CREATE_DETACHED))) { syslog(LOG_ERR, "error while set pthread attributes\n\r"); exit(EXIT_FAILURE); } syslog(LOG_NOTICE,"Waiting for connections...\n\r"); for(;;) { while((fd = erl_accept(listen, &conn)) == ERL_ERROR) syslog(LOG_ERR,"%s Connection error\n\r", argv[0]); if((data = (thread_data_t *)malloc(sizeof(thread_data_t))) == NULL) { syslog(LOG_ERR, "Memory allocation error\n\r"); exit(EXIT_FAILURE); } if((data->node = (char *)malloc(strlen(conn.nodename)+1)) == NULL) { syslog(LOG_ERR, "Memory allocation error\n\r"); exit(EXIT_FAILURE); } data->fd = fd; data->idx = tidx; strcpy(data->node, conn.nodename); if (pthread_create(&thread, &thread_attrs, erl_message_read_loop, data)) { syslog(LOG_ERR, "Thread create failure\n\r"); exit(EXIT_FAILURE); } tidx++; } closelog(); return 0; }
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) { 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 */ }
static void server_loop(int sd, int epmd_fd) { ErlConnect conn; erlang_msg msg; int status=1; CORBA_Environment *env; /* Create and init CORBA_Environment */ env = CORBA_Environment_alloc(INBUFSZ,OUTBUFSZ); while (status >= 0) { status = 1; if ((env->_fd = erl_accept(sd,&conn)) < 0) { /* error */ fprintf(stderr,"Accept failed: %s\n",strerror(errno)); } else { /* connection */ fprintf(stderr,"Accepted connection from %s\n",conn.nodename); while (status >= 0) { /* write message to buffer */ status = ei_receive_encoded(env->_fd, &env->_inbuf, &env->_inbufsz, &msg, &env->_iin); switch(status) { case ERL_SEND: case ERL_REG_SEND : /* do transaction with fd */ rmod_random__switch(NULL,env); switch(env->_major) { case CORBA_NO_EXCEPTION: /* Success */ break; case CORBA_SYSTEM_EXCEPTION: /* System exception */ printf("Request failure, reason : %s\n",(char *) CORBA_exception_value(env)); CORBA_exception_free(env); break; default: /* Should not come here */ CORBA_exception_free(env); break; } /* send outdata */ if (env->_iout > 0) ei_send_encoded(env->_fd,&env->_caller,env->_outbuf,env->_iout); break; case ERL_TICK : break; default : /* < 0 */ printf("Connection terminated\n"); break; } } } status=0; /* restart */ } /* close file descriptors */ terminate(&env->_fd, &sd, &epmd_fd); /* Free env & buffers */ CORBA_free(env->_inbuf); CORBA_free(env->_outbuf); CORBA_free(env); }
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; } } }