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