//HsBool
HsInt vaskerl_init_connect (char *name, char *ip, char *host,
char *dest, char *cookie)
{
if (fd > -1)
return fd;
struct in_addr addr;
addr.s_addr = inet_addr(ip);
// struct hostent *he = erl_gethostbyname("127.0.0.1");
// printf("... %s\n", he->h_name);
char fullname[256];
sprintf(fullname, "%s@%s", name, host);
erl_init(NULL, 0);
if (erl_connect_xinit(host, name, fullname, &addr, cookie, 0) < 0)
//if (erl_connect_xinit("McHoovy.rd.shawcable.net", "vaskerl",
// "*****@*****.**", &addr,
// cookie, 0) < 0)
erl_err_quit("erl_connect_xinit failed");
printf("node=%s, host=%s, alive=%s, creation=%d\n",
erl_thisnodename(), erl_thishostname(),
erl_thisalivename(), erl_thiscreation());
if ((fd = erl_xconnect(&addr, dest)) < 0)
erl_err_quit("erl_xconnect failed");
return fd;
//return HS_BOOL_TRUE;
}
static int init(int *sd, int *portnr, int *epmd_fd)
{
char host[HOSTNAMESZ];
char servernode[NODENAMESZ];
struct hostent *h;
int error = 0;
#ifdef __WIN32__
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(1, 1);
if ((error = WSAStartup(wVersionRequested, &wsaData))) {
fprintf(stderr,"Can't initialize windows sockets: %d",error);
}
#endif
/* get the host name */
error = gethostname(host,HOSTNAMESZ);
if (error) {
#ifdef __WIN32__
fprintf(stderr,"can't find own hostname (error = %ld) !\n",WSAGetLastError());
#else /* not __WIN32__ */
fprintf(stderr,"can't find own hostname !\n");
#endif
}
else {
/* identify host */
if (!(h = erl_gethostbyname(host)))
fprintf(stdout,"can't find own ip address\n");
else {
/* get a listen port. 0 means let system choose port number */
*sd = getlisten(0);
/* what port did we get? */
/* this call not necessary if we specified port in call to getlisten() */
*portnr = getport(*sd);
/* make the nodename server@host */
sprintf(servernode,"%s@%s",SERVER,host);
/* initiate */
erl_init(NULL,0);
/* host, alive, alive@host, addr, cookie, creation */
erl_connect_xinit(host,SERVER,servernode,(Erl_IpAddr)(h->h_addr_list[0]),COOKIE,0);
/* let epmd know we are here */
*epmd_fd = erl_publish(*portnr);
return 0;
}
}
return -1;
}
VALUE erlix_node_init(int argc,VALUE *argv,VALUE self){
VALUE sname,str_name;
VALUE nhost,str_host;
VALUE cookie,str_cookie;
int creation;
struct in_addr self_addr;
char host[64];
int nn_len;
char *nname;
if(erlix_node!=NULL){
rb_raise(rb_eException,"Erlix::Node has been inited already!");
return Qnil;
}
rb_scan_args(argc,argv,"12",&sname,&nhost,&cookie);
str_name=StringValue(sname);
if (NIL_P(nhost)) {
memset(host,0,64);
if(gethostname(host,64)!=0){
rb_raise(rb_eException,"gethostname error!");
return Qnil;
}
} else {
str_host=StringValue(nhost);
snprintf(host,64,"%s",RSTRING_PTR(str_host));
}
nn_len=strlen(host)+RSTRING_LEN(str_name)+2;
nname=(char*)malloc(nn_len);
memset(nname,0,nn_len);
sprintf(nname,"%s@%s",RSTRING_PTR(str_name),host);
creation=rand()%100;
self_addr.s_addr=htonl(INADDR_ANY);
if(!erl_connect_xinit(host,
RSTRING_PTR(str_name),
nname,
&self_addr,
NIL_P(cookie)?NULL:RSTRING_PTR(cookie),
creation)){
free(nname);
rb_raise(rb_eException,"erl_connect_xinit error!");
return Qnil;
}
free(nname);
erlix_node=(ErlixNode*)malloc(sizeof(ErlixNode));
return self;
}
int main(int argc, char **argv)
#endif
{
struct hostent *hp;
MyTimeval start, stop;
int i, fd, ires, tries;
CORBA_Environment *env;
char *this_node_name = NULL;
char *peer_node = NULL;
char *cookie = NULL;
char host[HOSTNAMESZ + 1];
char this_node[NODENAMESZ + 1];
erlang_msg msg;
int status, loop;
#ifdef __WIN32__
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 0);
if (WSAStartup(wVersionRequested, &wsaData) != 0) {
fprintf(stderr, "Could not load winsock2 v2.0 compatible DLL");
exit(1);
}
#endif
progname = argv[0];
host[HOSTNAMESZ] = '\0';
if (gethostname(host, HOSTNAMESZ) < 0) {
fprintf(stderr, "Can't find own hostname\n");
done(1);
}
if ((hp = gethostbyname(host)) == 0) {
fprintf(stderr, "Can't get ip address for host %s\n", host);
done(1);
}
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-help") == 0) {
usage();
done(0);
} else if (strcmp(argv[i], "-this-node-name") == 0) {
i++;
this_node_name = argv[i];
} else if (strcmp(argv[i], "-peer-node") == 0) {
i++;
peer_node = argv[i];
} else if (strcmp(argv[i], "-cookie") == 0) {
i++;
cookie = argv[i];
} else {
fprintf(stderr, "Error : invalid argument \"%s\"\n", argv[i]);
usage();
done(1);
}
}
if (this_node_name == NULL || peer_node == NULL || cookie == NULL) {
fprintf(stderr, "Error: missing option\n");
usage();
done(1);
}
/* Behead hostname at first dot */
for (i=0; host[i] != '\0'; i++) {
if (host[i] == '.') { host[i] = '\0'; break; }
}
sprintf(this_node, "%s@%s", this_node_name, host);
fprintf(stderr, "c_server: this node: \"%s\"\n", this_node);
fprintf(stderr, "c_server: peer node: \"%s\"\n", peer_node);
/* initialize erl_interface */
erl_init(NULL, 0);
for (tries = 0; tries < MAXTRIES; tries++) {
/* connect to peer node */
ires = erl_connect_xinit(host, this_node_name, this_node,
(struct in_addr *)*hp->h_addr_list,
cookie, 0);
fprintf(stderr, "c_server: erl_connect_xinit(): %d\n", ires);
fd = erl_connect(peer_node);
fprintf(stderr, "c_server: erl_connect(): %d\n", fd);
if (fd >= 0)
break;
fprintf(stderr, "c_server: cannot connect, retrying\n");
}
if (fd < 0) {
fprintf(stderr, "c_server: cannot connect, exiting\n");
done(1);
}
env = CORBA_Environment_alloc(INBUFSZ, OUTBUFSZ);
env->_fd = fd;
status = 1;
loop = 1;
my_gettimeofday(&start);
while (status >= 0 && loop > 0) {
status = ei_receive_encoded(env->_fd, &env->_inbuf, &env->_inbufsz,
&msg, &env->_iin);
switch(status) {
case ERL_SEND:
case ERL_REG_SEND:
/* get result */
m_i__switch(NULL, env);
switch(env->_major) {
case CORBA_NO_EXCEPTION:
break;
case CORBA_SYSTEM_EXCEPTION:
fprintf(stderr, "Request failure, reason : %s\n",
(char *) CORBA_exception_value(env));
CORBA_exception_free(env);
break;
default: /* Should not happen */
CORBA_exception_free(env);
break;
}
/* send back result data */
if (env->_iout > 0)
ei_send_encoded(env->_fd, &env->_caller, env->_outbuf,
env->_iout);
loop = 0;
break;
case ERL_TICK:
break;
default:
if (status < 0) {
fprintf(stderr, "Status negative: %d\n", status);
loop = 0;
}
break;
}
}
my_gettimeofday(&stop);
showtime(&start, &stop);
erl_close_connection(fd);
CORBA_free(env->_inbuf);
CORBA_free(env->_outbuf);
CORBA_free(env);
if (status < 0)
done(-status);
else
done(0);
}
int main(int argc, char **argv)
#endif
{
struct hostent *hp;
erlang_pid pid;
MyTimeval start, stop;
int i, fd, ires, tres;
IC_Env *env;
int tries = 0;
char *this_node_name = NULL;
char *peer_node = NULL;
char *peer_process_name = NULL;
char *cookie = NULL;
char host[HOSTNAMESZ + 1];
TestFunc test_func = NULL;
TestCase *test_case;
char *test_case_name = NULL;
#ifdef __WIN32__
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 0);
if (WSAStartup(wVersionRequested, &wsaData) != 0) {
fprintf(stderr, "Could not load winsock2 v2.0 compatible DLL");
exit(1);
}
#endif
progname = argv[0];
host[HOSTNAMESZ] = '\0';
if (gethostname(host, HOSTNAMESZ) < 0) {
fprintf(stderr, "Can't find own hostname\n");
done(1);
}
if ((hp = gethostbyname(host)) == 0) {
fprintf(stderr, "Can't get ip address for host %s\n", host);
done(1);
}
for (i = 1; i < argc; i++) {
if (cmp_str(argv[i], "-help")) {
usage();
done(0);
} else if (cmp_str(argv[i], "-this-node-name")) {
i++;
this_node_name = argv[i];
} else if (cmp_str(argv[i], "-peer-node")) {
i++;
peer_node = argv[i];
} else if (cmp_str(argv[i], "-peer-process-name")) {
i++;
peer_process_name = argv[i];
} else if (cmp_str(argv[i], "-cookie")) {
i++;
cookie = argv[i];
} else if (cmp_str(argv[i], "-test-case")) {
i++;
test_case_name = argv[i];
} else {
fprintf(stderr, "Error : invalid argument \"%s\"\n", argv[i]);
usage();
done(1);
}
}
if (this_node_name == NULL || peer_node == NULL || test_case_name == NULL
|| peer_process_name == NULL || cookie == NULL) {
fprintf(stderr, "Error: missing option\n");
usage();
done(1);
}
test_case = test_cases;
while (test_case->func) {
if (cmp_str(test_case->name, test_case_name)) {
test_func = test_case->func;
break;
}
test_case++;
}
if (test_func == NULL) {
fprintf(stderr, "Error: illegal test case: \"%s\"\n", test_case_name);
done(1);
}
/* Behead hostname at first dot */
for (i=0; host[i] != '\0'; i++) {
if (host[i] == '.') { host[i] = '\0'; break; }
}
sprintf(this_node, "%s@%s", this_node_name, host);
fprintf(stderr, "c_client: this node: \"%s\"\n", this_node);
fprintf(stderr, "c_client: peer node: \"%s\"\n", peer_node);
fprintf(stderr, "c_client: test case: \"%s\"\n", test_case_name);
fprintf(stderr, "c_client: starting\n");
/* initialize erl_interface */
erl_init(NULL, 0);
for (tries = 0; tries < MAXTRIES; tries++) {
/* connect to erlang node */
ires = erl_connect_xinit(host, this_node_name, this_node,
(struct in_addr *)*hp->h_addr_list,
cookie, 0);
fprintf(stderr, "c_client: erl_connect_xinit(): %d\n", ires);
fd = erl_connect(peer_node);
fprintf(stderr, "c_client: erl_connect(): %d\n", fd);
if (fd >= 0)
break;
fprintf(stderr, "c_client: cannot connect, retrying\n");
}
if (fd < 0) {
fprintf(stderr, "c_client: cannot connect, exiting\n");
done(1);
}
env = CORBA_Environment_alloc(INBUFSZ, OUTBUFSZ);
env->_fd = fd;
strcpy(env->_regname, peer_process_name);
env->_to_pid = NULL;
env->_from_pid = &pid;
strcpy(pid.node, this_node);
pid.num = fd;
pid.serial = 0;
pid.creation = 0;
my_gettimeofday(&start);
tres = test_func(env); /* Call test case */
my_gettimeofday(&stop);
showtime(&start, &stop);
erl_close_connection(fd);
printf("c_client: env->_inbuf before : %d\n", INBUFSZ);
printf("c_client: env->_outbuf before : %d\n", OUTBUFSZ);
printf("c_client: env->_inbuf after : %d\n", env->_inbufsz);
printf("c_client: env->_outbuf after : %d\n", env->_outbufsz);
CORBA_free(env->_inbuf);
CORBA_free(env->_outbuf);
CORBA_free(env);
done(tres);
}
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 */
}
int init_erlang(char *nodename, char *cookie) {
struct sockaddr_in e_addr;
char *ip;
char *node;
int efd;
int rlen;
char *cookiefile;
char *cookiehome;
char cookievalue[128];
int cookiefd;
PyMethodDef *uwsgi_function;
ip = strchr(nodename, '@');
if (ip == NULL) {
fprintf(stderr, "*** invalid erlang node name ***\n");
return -1;
}
if (cookie == NULL) {
// get the cookie from the home
cookiehome = getenv("HOME");
if (!cookiehome) {
fprintf(stderr, "unable to get erlang cookie from your home.\n");
return -1;
}
cookiefile = malloc(strlen(cookiehome) + 1 + strlen(".erlang.cookie") + 1);
if (!cookiefile) {
uwsgi_error("malloc()");
}
cookiefile[0] = 0;
strcat(cookiefile, cookiehome);
strcat(cookiefile, "/.erlang.cookie");
cookiefd = open(cookiefile, O_RDONLY);
if (cookiefd < 0) {
uwsgi_error("open()");
free(cookiefile);
return -1;
}
memset(cookievalue, 0, 128);
if (read(cookiefd, cookievalue, 127) < 1) {
fprintf(stderr, "invalid cookie found in %s\n", cookiefile);
close(cookiefd);
free(cookiefile);
return -1;
}
cookie = cookievalue;
close(cookiefd);
free(cookiefile);
}
node = malloc((ip - nodename) + 1);
if (node == NULL) {
uwsgi_error("malloc()");
return -1;
}
memset(node, 0, (ip - nodename) + 1);
memcpy(node, nodename, ip - nodename);
erl_init(NULL, 0);
if (erl_connect_xinit(ip + 1, node, nodename, NULL, cookie, 0) == -1) {
fprintf(stderr, "*** unable to initialize erlang c-node ***\n");
return -1;
}
efd = socket(AF_INET, SOCK_STREAM, 0);
if (efd < 0) {
uwsgi_error("socket()");
return -1;
}
memset(&e_addr, 0, sizeof(struct sockaddr_in));
e_addr.sin_family = AF_INET;
e_addr.sin_addr.s_addr = inet_addr(ip + 1);
rlen = 1;
if (setsockopt(efd, SOL_SOCKET, SO_REUSEADDR, &rlen, sizeof(rlen))) {
uwsgi_error("setsockopt()");
close(efd);
return -1;
}
if (bind(efd, (struct sockaddr *) &e_addr, sizeof(struct sockaddr_in)) < 0) {
uwsgi_error("bind()");
close(efd);
return -1;
}
rlen = sizeof(struct sockaddr_in);
if (getsockname(efd, (struct sockaddr *) &e_addr, (socklen_t *) & rlen)) {
uwsgi_error("getsockname()");
close(efd);
return -1;
}
if (listen(efd, uwsgi.listen_queue)) {
uwsgi_error("listen()");
close(efd);
return -1;
}
if (erl_publish(ntohs(e_addr.sin_port)) < 0) {
fprintf(stderr, "*** unable to subscribe with EPMD ***\n");
close(efd);
return -1;
}
fprintf(stderr, "Erlang C-Node initialized on port %d you can access it with name %s\n", ntohs(e_addr.sin_port), nodename);
for (uwsgi_function = uwsgi_erlang_methods; uwsgi_function->ml_name != NULL; uwsgi_function++) {
PyObject *func = PyCFunction_New(uwsgi_function, NULL);
PyDict_SetItemString(uwsgi.embedded_dict, uwsgi_function->ml_name, func);
Py_DECREF(func);
}
return efd;
}