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;
}
}
}
