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);
}
}
}
/*
* And here is the rpc receiving part. A negative
* timeout means 'infinity'. Returns either of: ERL_MSG,
* ERL_TICK, ERL_ERROR or ERL_TIMEOUT.
*/
int erl_rpc_from(int fd, int timeout, ErlMessage *emsg)
{
fd_set readmask;
struct timeval tv;
struct timeval *t = NULL;
unsigned char rbuf[MAX_RECEIVE_BUF];
if (timeout >= 0) {
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
t = &tv;
}
FD_ZERO(&readmask);
FD_SET(fd,&readmask);
switch (select(fd+1, &readmask, NULL, NULL, t)) {
case -1:
erl_errno = EIO;
return ERL_ERROR;
case 0:
erl_errno = ETIMEDOUT;
return ERL_TIMEOUT;
default:
if (FD_ISSET(fd, &readmask))
return erl_receive_msg(fd, rbuf, MAX_RECEIVE_BUF, emsg);
else {
erl_errno = EIO;
return ERL_ERROR;
}
}
} /* rpc_from */
int main(int argc, char** argv)
{
int erl_fd; // FD to the ERL VM
char* bufp; // storage for incoming messages
int bufsz = 1024;
// the following are basically magic values.
erl_fd = setup_connection(1, "secretcookie", 0, "e1@am335x-evm");
ErlMessage* emsg;
emsg = (ErlMessage*)malloc(sizeof(ErlMessage));
bufp = (char*)malloc(bufsz * sizeof(char));
while (1) // main loop - we don't ever expect to leave.
{
TRACE(("starting main loop"));
TRACE(("waiting for a message..."));
int msg_status = erl_receive_msg(erl_fd, bufp, bufsz, emsg);
TRACE(("got a message"));
switch (msg_status)
{
case (ERL_MSG):
TRACE(("message status is ERL_MSG"));
process_msg(emsg, erl_fd);
break;
case (ERL_TICK):
TRACE(("message status is ERL_TICK"));
break;
case (ERL_ERROR):
default:
TRACE(("message status is ERL_ERROR"));
process_error();
break;
}
TRACE(("cleaning up at end of main loop"));
erl_free_term(emsg->msg);
erl_free_term(emsg->from);
erl_free_term(emsg->to);
} // end while loop
if (erl_close_connection(erl_fd) < 0)
{
perror("failed to close connection. plowing onward.");
}
free(emsg);
free(bufp);
}
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);
}
}
}
}
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);
}
}
}
}
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 */
}
void *cnode_run()
{
int fd; /* fd to Erlang node */
int got; /* Result of receive */
unsigned char buf[BUFSIZE]; /* Buffer for incoming message */
ErlMessage emsg; /* Incoming message */
ETERM *uid, *msg;
erl_init(NULL, 0);
if (erl_connect_init(1, "secretcookie", 0) == -1)
erl_err_quit("erl_connect_init");
if ((fd = erl_connect("httpdmaster@localhost")) < 0)
erl_err_quit("erl_connect");
fprintf(stderr, "Connected to httpdmaster@localhost\n\r");
struct evbuffer *evbuf;
while (1) {
got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
if (got == ERL_TICK) {
continue;
} else if (got == ERL_ERROR) {
fprintf(stderr, "ERL_ERROR from erl_receive_msg.\n");
break;
} else {
if (emsg.type == ERL_REG_SEND) {
fprintf(stderr, "type of emsg is ERL_REG_SEND\n");
// get uid and body data from eg: {123, <<"Hello">>}
uid = erl_element(1, emsg.msg);
msg = erl_element(2, emsg.msg);
char *token = (char *) ERL_BIN_PTR(uid);
char *body = (char *) ERL_BIN_PTR(msg);
int body_len = ERL_BIN_SIZE(msg);
char *cached = fetch_memcached(token);
int userid = atoi(cached);
fprintf(stderr, "memc: %d\n\r", userid);
if(clients[userid]){
fprintf(stderr, "Sending %d bytes to token %s\n", body_len, token);
evbuf = evbuffer_new();
evbuffer_add(evbuf, (const void*)body, (size_t) body_len);
evhttp_send_reply_chunk(clients[userid], evbuf);
evhttp_send_reply_end(clients[userid]);
evbuffer_free(evbuf);
}else{
fprintf(stderr, "Discarding %d bytes to uid %d - user not connected\n",
body_len, userid);
}
free(cached);
erl_free_term(emsg.msg);
erl_free_term(uid);
erl_free_term(msg);
}
}
fprintf(stderr, ".");
}
pthread_exit(0);
}
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);
}
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;
}
}
}
PyObject *py_erlang_recv_message(PyObject * self, PyObject * args) {
int erfd;
struct pollfd erpoll;
ErlMessage emsg;
PyObject *pyer = NULL;
unsigned char erlang_buffer[8192];
int eret;
int timeout = uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT];
if (!PyArg_ParseTuple(args, "i|i:erlang_recv_message", &erfd, &timeout)) {
return NULL;
}
if (erfd < 0) {
goto clear;
}
erpoll.fd = erfd;
erpoll.events = POLLIN;
cycle:
memset(&emsg, 0, sizeof(ErlMessage));
UWSGI_SET_BLOCKING;
if (timeout > 0) {
eret = poll(&erpoll, 1, timeout * 1000);
if (eret < 0) {
uwsgi_error("poll()");
goto clear;
}
else if (eret == 0) {
goto clear;
}
}
if (erl_receive_msg(erfd, erlang_buffer, 8192, &emsg) == ERL_MSG) {
if (emsg.type == ERL_TICK) {
goto cycle;
}
if (emsg.msg) {
pyer = eterm_to_py(emsg.msg);
}
if (emsg.msg) {
erl_free_compound(emsg.msg);
}
if (emsg.to) {
erl_free_compound(emsg.to);
}
if (emsg.from) {
erl_free_compound(emsg.from);
}
if (!pyer) {
goto clear;
}
UWSGI_UNSET_BLOCKING;
return pyer;
}
clear:
UWSGI_UNSET_BLOCKING;
Py_INCREF(Py_None);
return Py_None;
}
