ETERM *space_delete(ETERM *fromp, ETERM *argp) {
// get the args
ETERM *space_refp = erl_element(1, argp);
erlmunk_space *s;
int space_id = ERL_REF_NUMBER(space_refp);
HASH_FIND_INT(erlmunk_spaces, &space_id, s);
// remove all subscribers
for(erlmunk_subscriber *subscriber = s->subscribers; subscriber != NULL;
subscriber = subscriber->hh.next) {
space_remove_subscriber(s, subscriber);
}
// remove all bodies
for(erlmunk_body *b = s->bodies; b != NULL;
b = b->hh.next) {
erlmunk_body_data *data = cpBodyGetUserData(b->body);
if (data->term != NULL)
erl_free_compound(data->term);
free(data);
cpSpaceRemoveBody(s->space, b->body);
cpBodyDestroy(b->body);
cpBodyFree(b->body);
space_remove_body_hash(s, b);
}
return NULL;
}
int main() {
ETERM *tuplep, *intp;
ETERM *fnp, *argp;
int res;
byte buf[100];
long allocated, freed;
erl_init(NULL, 0);
while (read_cmd(buf) > 0) {
tuplep = erl_decode(buf);
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", 17) == 0) {
res = bar(ERL_INT_VALUE(argp));
}
intp = erl_mk_int(res);
erl_encode(intp, buf);
write_cmd(buf, erl_term_len(intp));
erl_free_compound(tuplep);
erl_free_term(fnp);
erl_free_term(argp);
erl_free_term(intp);
}
}
ETERM *space_remove_body(ETERM *fromp, ETERM *argp) {
// get the args
ETERM *space_refp = erl_element(1, argp);
ETERM *idp = erl_element(2, argp);
erlmunk_space *s;
int space_id = ERL_REF_NUMBER(space_refp);
HASH_FIND_INT(erlmunk_spaces, &space_id, s);
int body_id = ERL_INT_VALUE(idp);
erlmunk_body *b = NULL;
HASH_FIND_INT(s->bodies, &body_id, b);
if (b == NULL)
return NULL;
// DEBUGF(("removing body #%d\n", body_id));
// remove the user data associated with the body
erlmunk_body_data *data = cpBodyGetUserData(b->body);
if (data->term != NULL)
erl_free_compound(data->term);
free(data);
cpBodyEachShape(b->body, shapeRemove, NULL);
cpSpaceRemoveBody(s->space, b->body);
space_remove_body_hash(s, b);
cpBodyDestroy(b->body);
cpBodyFree(b->body);
return NULL;
}
void send_result()
{
fprintf(log, "returning at len %d\n", erl_term_len(result));
respond(result);
erl_free_compound(result);
result = 0;
}
int main()
{
ETERM *tuplep;
ETERM *fnp;
ETERM *args;
byte buf[100];
const char* func_name;
#ifdef __WIN32__
/* Attention Windows programmers: you need [to pay Serge Aleynikov a
* beer because he's the one who figured out how to get this to work
* on windows :)] explicitly set mode of stdin/stdout to binary or
* else the port program won't work.
*/
_setmode(_fileno(stdout), _O_BINARY);
_setmode(_fileno(stdin), _O_BINARY);
#endif
eNotify_init();
erl_init(NULL, 0);
while (read_cmd(buf) > 0) {
tuplep = erl_decode(buf);
fnp = erl_element(1, tuplep);
func_name = (const char*)ERL_ATOM_PTR(fnp);
args = erl_element(2, tuplep);
// MATCH FIRST! -> REMEMBER THAT!
if (strncmp(func_name, "get_error_desc", 14) == 0)
{
local_get_error_desc(args);
}
else if (strncmp(func_name, "add_watch", 9) == 0)
{
local_add_watch(args);
}
else if (strncmp(func_name, "remove_watch", 12) == 0)
{
local_remove_watch(args);
}
else
{
byte buf[10];
ETERM *nok = erl_mk_atom("undef"); // alloc nok
erl_encode(nok, buf);
write_cmd(buf, erl_term_len(nok));
erl_free_term(nok); // free nok
}
erl_free_compound(tuplep);
erl_free_term(fnp);
}
return 0;
}
void send_error(char *err_msg)
{
ETERM *tup_list[2];
ETERM *to_send;
tup_list[0] = erl_mk_atom("sql_error");
tup_list[1] = erl_mk_string(err_msg);
to_send = erl_mk_tuple(tup_list, 2);
fprintf(log, "SQL Error: %s\n", err_msg);
respond(to_send);
erl_free_term(tup_list[0]);
erl_free_term(tup_list[1]);
erl_free_compound(to_send);
}
ETERM *body_update_user_data(ETERM *fromp, ETERM *argp) {
// DEBUGF(("body_update_user_data\n"));
// get the args
ETERM *space_refp = erl_element(1, argp);
ETERM *idp = erl_element(2, argp);
ETERM *keyp = erl_element(3, argp);
ETERM *valuep = erl_element(4, argp);
erlmunk_space *s;
int space_id = ERL_REF_NUMBER(space_refp);
HASH_FIND_INT(erlmunk_spaces, &space_id, s);
int body_id = ERL_INT_VALUE(idp);
erlmunk_body *b;
HASH_FIND_INT(s->bodies, &body_id, b);
if (b == NULL)
return NULL;
erlmunk_body_data *data = cpBodyGetUserData(b->body);
ETERM *new_data_term = erl_lists_keyreplace(data->term, keyp, valuep);
erl_free_compound(data->term);
data->term = new_data_term;
ETERM *new_valuep = erl_proplists_get_value(keyp, new_data_term);
// obtain updated key value and return that
ETERM *atom_ok = erl_mk_atom("ok");
ETERM **body_update_data_array = (ETERM **) malloc(sizeof(ETERM*) * 2);
body_update_data_array[0] = atom_ok;
body_update_data_array[1] = new_valuep;
ETERM *body_update_data_tuple = erl_mk_tuple(body_update_data_array, 2);
free(body_update_data_array);
ETERM *reply_tuple = erl_mk_reply(fromp, body_update_data_tuple);
ETERM *gen_cast_tuple = erl_mk_gen_cast(reply_tuple);
return gen_cast_tuple;
}
void * handle_command(void *buf){
ETERM *tuplep, *file;
ETERM *fnp;
tuplep = erl_decode(buf);
fnp = erl_element(1, tuplep);
char * path = "./priv/sample_images/ABST.00000000.tif";
IplImage *source = cvLoadImage( path, CV_LOAD_IMAGE_GRAYSCALE );
CvMat* pngImage = img(source);
//if (strncmp(ERL_ATOM_PTR(fnp), "img", 3) == 0) {
// no-op for now?
//}
file = erl_mk_binary((char *)pngImage->data.ptr, pngImage->cols);
erl_encode(file, buf);
write_cmd(buf, erl_term_len(file));
erl_free_compound(tuplep);
erl_free_term(fnp);
erl_free_term(file);
}
int main()
#endif
{
_setmode(0, _O_BINARY);
_setmode(1, _O_BINARY);
erl_init(NULL, 0);
for (;;) {
char buf[4*1024];
ETERM* term;
char* message;
int n;
if (readn(0, buf, 2) <= 0) {
/* fprintf(stderr, "error reading message header\n"); */
/* actually this is where we leave the infinite loop */
exit(1);
}
n = buf[0] * 256 + buf[1];
if (readn(0, buf, n) < 0) {
fprintf(stderr, "error reading message contents\n");
exit(1);
}
term = erl_decode(buf);
if (term == NULL) {
fprintf(stderr, "erl_decode() failed\n");
exit(1);
}
n = erl_print_term(stdout, term);
erl_free_compound(term);
fprintf(stdout,"\r%d\n", n);
fflush(stdout);
}
}
PyObject *py_erlang_rpc(PyObject * self, PyObject * args) {
int fd, timeout = uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT];
char *emod, *efun;
PyObject *eargs, *pyer = NULL;
ETERM *pyargs, *rex;
ErlMessage emsg;
int eret;
if (!PyArg_ParseTuple(args, "issO|i:erlang_rpc", &fd, &emod, &efun, &eargs, &timeout)) {
return NULL;
}
if (fd < 0) {
goto clear;
}
pyargs = py_to_eterm(eargs);
if (!pyargs) {
goto clear;
}
if (erl_rpc_to(fd, emod, efun, pyargs)) {
erl_err_msg("erl_rpc_to()");
goto clear2;
}
cycle:
memset(&emsg, 0, sizeof(ErlMessage));
UWSGI_SET_BLOCKING;
eret = erl_rpc_from(fd, timeout * 1000, &emsg);
if (eret == ERL_TICK) {
goto cycle;
}
else if (eret == ERL_MSG) {
if (emsg.msg) {
if (ERL_IS_TUPLE(emsg.msg)) {
rex = erl_element(1, emsg.msg);
if (!rex) {
goto clear2;
}
if (!strncmp("rex", ERL_ATOM_PTR(rex), ERL_ATOM_SIZE(rex))) {
erl_free_term(rex);
rex = erl_element(2, emsg.msg);
if (!rex) {
goto clear2;
}
pyer = eterm_to_py(rex);
erl_free_term(rex);
}
else {
erl_free_term(rex);
}
}
}
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 clear2;
}
erl_free_compound(pyargs);
UWSGI_UNSET_BLOCKING;
return pyer;
}
else {
erl_err_msg("erl_rpc_from()");
}
clear2:
UWSGI_UNSET_BLOCKING;
erl_free_compound(pyargs);
clear:
Py_INCREF(Py_None);
return Py_None;
}
int main(int argc, char **argv)
{
ETERM *tuplep;
ETERM *fnp, *argp;
byte buf[1024];
sqlite3 *db;
char *zErrMsg = 0;
int rc;
log = fopen("/tmp/sqlite_port.log", "a+");
fprintf(log, "******start log (%s)******\n", argv[1]);
fflush(log);
rc = sqlite3_open(argv[1], &db);
if (rc) {
sqlite3_close(db);
exit(1);
}
erl_init(NULL, 0);
while (read_cmd(buf) > 0) {
tuplep = erl_decode(buf);
fnp = erl_element(1, tuplep);
argp = erl_element(2, tuplep);
if (strncmp((const char *)ERL_ATOM_PTR(fnp), "close", 5) == 0) {
fprintf(log, "closing sqlite3_close\n");
fflush(log);
sqlite3_close(db);
break;
}
else if (strncmp((const char *)ERL_ATOM_PTR(fnp), "list_tables", 11) == 0) {
fprintf(log, "calling list_tables\n");
result = 0;
rc = sqlite3_exec(db, MASTER_QUERY, list_tables, 0, &zErrMsg);
if (rc != SQLITE_OK) {
send_error(zErrMsg);
sqlite3_free(zErrMsg);
}
else if (result != 0) {
send_result();
}
else {
// not an error and no results. still need to return something
send_ok();
}
fflush(log);
}
else if (strncmp((const char *)ERL_ATOM_PTR(fnp), "sql_exec", 8) == 0) {
fprintf(log, "calling sqlite3_exec %s\n", erl_iolist_to_string(argp));
result = 0;
rc = sqlite3_exec(db, erl_iolist_to_string(argp), callback, 0, &zErrMsg);
if (rc != SQLITE_OK) {
send_error(zErrMsg);
sqlite3_free(zErrMsg);
}
else if (result != 0) {
send_result();
}
else {
// not an error and no results. still need to return something
send_ok();
}
fflush(log);
}
erl_free_compound(tuplep);
erl_free_term(fnp);
erl_free_term(argp);
}
fprintf(log, "******end log******\n");
fclose(log);
return 0;
}
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_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;
}
int main(int argc, char* argv[]) {
ETERM *tuplep, *fnp, *pathp, *binp, *widthp, *heightp;
ETERM *res_tuplep;
ETERM *res_arrp[2];
ETERM *res_ok_atomp, *res_error_atomp, *res_error_cause_atomp;
int idx = 1;
byte *buf = malloc(INIT_BUF_SIZE);
int buf_len = INIT_BUF_SIZE;
int res_len;
erl_init(NULL, 0);
//Create common atoms(ok, error)
res_ok_atomp = erl_mk_atom("ok");
res_error_atomp = erl_mk_atom("error");
res_error_cause_atomp = erl_mk_atom("resize failed");
while (read_cmd(&buf, &buf_len) > 0) {
tuplep = erl_decode(buf);
fnp = erl_element(idx++, tuplep);
pathp = erl_element(idx++, tuplep);
binp = erl_element(idx++, tuplep);
widthp = erl_element(idx++, tuplep);
heightp = erl_element(idx++, tuplep);
if (strncmp(ERL_ATOM_PTR(fnp), "resize", 6) == 0) {
char* algop = ERL_ATOM_PTR(fnp) + 6;
resizerl_handler* rhp = (strncmp(algop, "_opencv", 7) == 0) ? resizerl_impls[0] : NULL;
if (rhp == NULL) {
exit(1);
}
// ERL_INT_VALUE, ERL_BIN_PTR, ERL_BIN_SIZE
void* dp = NULL;
rhp->exec(ERL_BIN_PTR(binp),
ERL_BIN_SIZE(binp),
ERL_BIN_PTR(pathp),
ERL_BIN_SIZE(pathp),
ERL_INT_VALUE(widthp),
ERL_INT_VALUE(heightp), &dp);
if (dp == NULL) {
exit(2);
}
unsigned char* dst;
int dst_size;
rhp->get_result(dp, &dst, &dst_size);
res_arrp[0] = res_ok_atomp;
res_arrp[1] = erl_mk_binary((const char*)dst, dst_size);
res_tuplep = erl_mk_tuple(res_arrp, 2);
res_len = erl_term_len(res_tuplep);
if (res_len > buf_len) {
byte* new_buf = (byte*)realloc((void*)buf, res_len);
if (new_buf == NULL) {
exit(3);
}
buf = new_buf;
buf_len = res_len;
}
erl_encode(res_tuplep, buf);
write_cmd(buf, erl_term_len(res_tuplep));
erl_free_term(res_arrp[1]);
erl_free_term(res_tuplep);
rhp->release(&dp);
} else {
res_arrp[0] = res_error_atomp;
res_arrp[1] = res_error_cause_atomp;
res_tuplep = erl_mk_tuple(res_arrp, 2);
if (res_len > buf_len) {
byte* new_buf = (byte*)realloc((void*)buf, res_len);
if (new_buf == NULL) {
exit(4);
}
buf = new_buf;
buf_len = res_len;
}
erl_encode(res_tuplep, buf);
write_cmd(buf, erl_term_len(res_tuplep));
erl_free_term(res_tuplep);
}
erl_free_compound(tuplep);
erl_free_term(fnp);
erl_free_term(pathp);
erl_free_term(binp);
erl_free_term(widthp);
erl_free_term(heightp);
idx = 1;
}
// normal
return 0;
}
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);
}
int main(int argc, char **argv) {
libusb_context *ctx = NULL;
dongleHandle dongle;
int option;
int address;
int bus;
ETERM *tuplep;
ETERM *functionp;
unsigned char buf[1024];
const char* func_name;
address = -1;
bus = -1;
while ((option = getopt(argc, argv, "p:b:")) != -1) {
switch (option) {
case 'p':
address = atoi(optarg);
break;
case 'b':
bus = atoi(optarg);
break;
default:
return 1;
}
}
if (bus == -1 || address == -1) {
return 1;
}
erl_init(NULL, 0);
initDongle(ctx);
dongle = getDongle(ctx, address, bus);
if (dongle == NULL) {
ERL_WRITE_ERROR("not_found");
exitDongle(ctx);
return 1;
}
while (read_cmd(buf) > 0) {
tuplep = erl_decode(buf);
functionp = erl_element(1, tuplep);
func_name = (const char*)ERL_ATOM_PTR(functionp);
if (strncmp(func_name, "derive", 6) == 0){
hsm_derive(dongle, tuplep);
} else if (strncmp(func_name, "import", 6) == 0){
hsm_import(dongle, tuplep);
} else if (strncmp(func_name, "pin", 3) == 0){
hsm_pin(dongle, tuplep);
} else if (strncmp(func_name, "pubkey", 6) == 0){
hsm_pubkey(dongle, tuplep);
} else if (strncmp(func_name, "random", 6) == 0){
hsm_random(dongle, tuplep);
} else if (strncmp(func_name, "sign", 4) == 0){
hsm_sign(dongle, tuplep);
} else if (strncmp(func_name, "verify", 6) == 0){
hsm_verify(dongle, tuplep);
} else if (strncmp(func_name, "close", 5) == 0){
break;
} else {
ERL_WRITE_ERROR("undef")
}
erl_free_compound(tuplep);
erl_free_term(functionp);
}
closeDongle(dongle);
exitDongle(ctx);
ETERM *atom;
atom = erl_mk_atom("closed");
unsigned char closed_buf[erl_term_len(atom)];
erl_encode(atom, closed_buf);
write_cmd(closed_buf, erl_term_len(atom));
erl_free_term(atom);
fprintf(stderr, "CLOSED");
return 0;
}
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;
}
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;
}
