ETERM * text_extents(ETERM* arg, int c_node) {
ETERM *text;
cairo_text_extents_t extents;
cairo_context *ctx = get_cairo_context(arg);
if (ctx) {
text = erl_element(2, arg);
cairo_text_extents (ctx->cr, (char *)ERL_ATOM_PTR(text), &extents);
erl_free_term(text);
return erl_format("{c_node, ~i, {~f, ~f}}", c_node, extents.width, extents.height);
} else {
return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
}
}
ETERM * write_to_png(ETERM* arg, int c_node) {
int status;
ETERM *file;
cairo_context *ctx = get_cairo_context(arg);
if (ctx) {
file = erl_element(2, arg);
status = cairo_surface_write_to_png(ctx->sf, (char *)ERL_ATOM_PTR(file));
erl_free_term(file);
return erl_format("{c_node, ~i, ok}", c_node);
} else {
return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
}
}
/**
* @brief Port interface for gpio_init
*/
int
port_gpio_init (ETERM *pin_t, ETERM *direction_t)
{
int pin, dir;
/* convert erlang terms to usable values */
pin = ERL_INT_VALUE(pin_t);
syslog(LOG_NOTICE, "init with direction %s", ERL_ATOM_PTR(direction_t));
if (strncmp(ERL_ATOM_PTR(direction_t), "input", 5) == 0)
{
dir = 1;
} else if (strncmp(ERL_ATOM_PTR(direction_t), "output", 6) == 0)
{
dir = 0;
} else
{
return -1;
}
syslog(LOG_NOTICE, "init with dir %d", dir);
my_pin = pin;
return gpio_init(pin, dir);
}
ETERM * select_font_face(ETERM* arg, int c_node) {
ETERM *family, *slant, *weight;
cairo_context *ctx = get_cairo_context(arg);
if (ctx) {
family = erl_element(2, arg);
slant = erl_element(3, arg);
weight = erl_element(4, arg);
cairo_select_font_face(ctx->cr, (char *)ERL_ATOM_PTR(family), ERL_INT_VALUE(slant), val(weight));
erl_free_term(family);
erl_free_term(slant);
erl_free_term(weight);
return erl_format("{c_node, ~i, ok}", c_node);
} else {
return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
}
}
void
dispatch_db_cmd(ETERM *msg)
{
ETERM *tag;
char *tag_name;
tag = erl_element(1, msg);
tag_name = (char *)ERL_ATOM_PTR(tag);
if (strncmp(tag_name, CONNECT_MSG, strlen(CONNECT_MSG)) == 0)
handle_connect(msg);
else if (strncmp(tag_name, QUERY_MSG, strlen(QUERY_MSG)) == 0)
handle_query(msg);
else if (strncmp(tag_name, PARAM_QUERY_MSG, strlen(PARAM_QUERY_MSG)) == 0)
handle_param_query(msg);
else if (strncmp(tag_name, SELECT_COUNT_MSG, strlen(SELECT_COUNT_MSG)) == 0)
handle_select_count(msg);
else if (strncmp(tag_name, SELECT_MSG, strlen(SELECT_MSG)) == 0)
handle_select(msg);
else if (strncmp(tag_name, FIRST_MSG, strlen(FIRST_MSG)) == 0)
handle_first(msg);
else if (strncmp(tag_name, LAST_MSG, strlen(LAST_MSG)) == 0)
handle_last(msg);
else if (strncmp(tag_name, NEXT_MSG, strlen(NEXT_MSG)) == 0)
handle_next(msg);
else if (strncmp(tag_name, PREV_MSG, strlen(PREV_MSG)) == 0)
handle_prev(msg);
else {
ETERM *resp;
resp = erl_format("{error, {uknown_message, ~s}}", tag);
write_msg(resp);
erl_free_term(resp);
}
erl_free_term(tag);
}
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[]) {
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;
}
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 */
}
PyObject *eterm_to_py(ETERM * obj) {
int i;
int count;
ETERM *obj2;
PyObject *eobj = NULL;
if (obj == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
switch (ERL_TYPE(obj)) {
case ERL_CONS:
case ERL_NIL:
count = erl_length(obj);
eobj = PyList_New(0);
for (i = 0; i < count; i++) {
obj2 = erl_hd(obj);
PyList_Append(eobj, eterm_to_py(obj2));
obj = erl_tl(obj);
}
break;
case ERL_TUPLE:
eobj = PyTuple_New(erl_size(obj));
for (i = 1; i <= erl_size(obj); i++) {
obj2 = erl_element(i, obj);
PyTuple_SetItem(eobj, i - 1, eterm_to_py(obj2));
}
break;
case ERL_ATOM:
eobj = PyString_FromStringAndSize(ERL_ATOM_PTR(obj), ERL_ATOM_SIZE(obj));
break;
case ERL_INTEGER:
eobj = PyInt_FromLong(ERL_INT_VALUE(obj));
break;
case ERL_BINARY:
fprintf(stderr, "FOUND A BINARY %.*s\n", ERL_BIN_SIZE(obj), ERL_BIN_PTR(obj));
break;
case ERL_PID:
eobj = PyDict_New();
if (PyDict_SetItemString(eobj, "node", PyString_FromString(ERL_PID_NODE(obj)))) {
PyErr_Print();
break;
}
if (PyDict_SetItemString(eobj, "number", PyInt_FromLong(ERL_PID_NUMBER(obj)))) {
PyErr_Print();
break;
}
if (PyDict_SetItemString(eobj, "serial", PyInt_FromLong(ERL_PID_SERIAL(obj)))) {
PyErr_Print();
break;
}
if (PyDict_SetItemString(eobj, "creation", PyInt_FromLong(ERL_PID_CREATION(obj)))) {
PyErr_Print();
break;
}
default:
fprintf(stderr, "UNMANAGED ETERM TYPE: %d\n", ERL_TYPE(obj));
break;
}
if (eobj == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return eobj;
}
int erl_sprint_term(char *buf, const ETERM *ep)
{
int j,i,doquote;
int ch_written = 0; /* counter of written chars */
if ((!buf) || (!ep)) return 0;
/* ASSERT(ep != NULL); */
j = i = doquote = 0;
switch(ERL_TYPE(ep))
{
case ERL_ATOM:
/* FIXME: what if some weird locale is in use? */
if (!islower((int)ERL_ATOM_PTR(ep)[0]))
doquote = 1;
for (i = 0; !doquote && i < ERL_ATOM_SIZE(ep); i++)
{
doquote = !(isalnum((int)ERL_ATOM_PTR(ep)[i])
|| (ERL_ATOM_PTR(ep)[i] == '_'));
}
if (doquote) {
*buf++ = '\'';
ch_written++;
}
{
int len = ERL_ATOM_SIZE(ep);
strncpy(buf, ERL_ATOM_PTR(ep), len);
buf += len;
ch_written += len;
}
if (doquote) {
*buf++ = '\'';
ch_written++;
}
break;
case ERL_VARIABLE:
if (!isupper((int)ERL_VAR_NAME(ep)[0])) {
doquote = 1;
*buf++ = '\'';
ch_written++;
}
len = ERL_VAR_LEN(ep);
strncpy(buf, ERL_VAR_NAME(ep), len);
buf += len;
ch_written += len;
if (doquote) {
*buf++ = '\'';
ch_written++;
}
break;
case ERL_PID:
len = sprintf(buf, "<%s.%d.%d>",
ERL_PID_NODE(ep),
ERL_PID_NUMBER(ep), ERL_PID_SERIAL(ep));
buf += len;
ch_written += len;
break;
case ERL_PORT:
len = sprintf(buf , "#Port");
buf += len;
ch_written += len;
break;
case ERL_REF:
len = sprintf(buf , "#Ref");
buf += len;
ch_written += len;
break;
case ERL_EMPTY_LIST:
len = sprintf(buf , "[]");
buf += len;
ch_written += len;
break;
case ERL_LIST:
if (is_printable_list(ep)) {
ch_written += print_string(fp, ep);
} else {
putc('[', fp);
ch_written++;
while (ERL_IS_CONS(ep)) {
ch_written += erl_sprint_term(fp, HEAD(ep));
ep = TAIL(ep);
if (ERL_IS_CONS(ep)) {
putc(',', fp);
ch_written++;
}
}
if (!ERL_IS_EMPTY_LIST(ep)) {
putc('|', fp);
ch_written++;
ch_written += erl_sprint_term(fp, ep);
}
putc(']', fp);
ch_written++;
}
break;
case ERL_TUPLE:
putc('{', fp);
ch_written++;
for (i=0; i < ERL_TUPLE_SIZE(ep); i++) {
ch_written += erl_sprint_term(fp, ERL_TUPLE_ELEMENT(ep, j++) );
if (i != ERL_TUPLE_SIZE(ep)-1) {
putc(',', fp);
ch_written++;
}
}
putc('}', fp);
ch_written++;
break;
case ERL_BINARY:
len = sprintf(buf , "#Bin");
buf += len;
ch_written += len;
break;
case ERL_INTEGER:
case ERL_SMALL_BIG:
len = sprintf(buf , "%d", ERL_INT_VALUE(ep));
buf += len;
ch_written += len;
break;
case ERL_U_INTEGER:
case ERL_U_SMALL_BIG:
len = sprintf(buf , "%d", ERL_INT_UVALUE(ep));
buf += len;
ch_written += len;
break;
case ERL_FLOAT:
len = sprintf(buf , "%f", ERL_FLOAT_VALUE(ep));
buf += len;
ch_written += len;
break;
case ERL_FUNCTION:
len = sprintf(buf , "#Fun<");
buf += len;
ch_written += len;
ch_written += erl_sprint_term(fp, ERL_FUN_MODULE(ep));
putc('.', fp);
ch_written++;
ch_written += erl_sprint_term(fp, ERL_FUN_INDEX(ep));
putc('.', fp);
ch_written++;
ch_written += erl_sprint_term(fp, ERL_FUN_UNIQ(ep));
putc('>', fp);
ch_written++;
break;
default:
ch_written = -10000;
erl_err_msg("<ERROR> erl_sprint_term: Bad type of term !");
}
return ch_written;
}
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);
}
/*
* http://dev.mysql.com/doc/refman/5.1/en/mysql-stmt-execute.html
*
* 6 > odbc:param_query(Ref,
* "INSERT INTO EMPLOYEE (NR, FIRSTNAME, "
* "LASTNAME, GENDER) VALUES(?, ?, ?, ?)",
* [{sql_integer,[2,3,4,5,6,7,8]},
* {{sql_varchar, 20},
* ["John", "Monica", "Ross", "Rachel",
* "Piper", "Prue", "Louise"]},
* {{sql_varchar, 20},
* ["Doe","Geller","Geller", "Green",
* "Halliwell", "Halliwell", "Lane"]},
* {{sql_char, 1}, ["M","F","M","F","T","F","F"]}]).
* {updated, 7}
*/
void
handle_param_query(ETERM *msg)
{
ETERM *query, *params, *p, *tmp, *resp;
MYSQL_STMT *handle;
MYSQL_BIND *bind;
char *q;
int param_count, i;
query = erl_element(2, msg);
q = erl_iolist_to_string(query);
erl_free_term(query);
logmsg("INFO: got param query: %s", q);
params = erl_element(3, msg);
erl_free_term(params);
handle = mysql_stmt_init(&dbh);
if (mysql_stmt_prepare(handle, q, strlen(q))) {
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
} else {
param_count = mysql_stmt_param_count(handle);
if (param_count != erl_length(params)) {
resp = erl_format("{error, {mysql_error, -1, [expected_params, %d, got_params, %d]}}", param_count, erl_length(params));
} else {
bind = safe_malloc(param_count * sizeof(MYSQL_BIND));
memset(bind, 0, param_count * sizeof(MYSQL_BIND));
for (i = 0, tmp = params;
i < param_count && (p = erl_hd(tmp)) != NULL;
i++, tmp = erl_tl(tmp)) {
ETERM *type, *value;
type = erl_element(1, p);
value = erl_element(2, p);
if (ERL_IS_TUPLE(type)) {
// Parameter Type + Size: {Type, Size}
ETERM *t_type, *t_size;
char *t;
unsigned long size;
t_size = erl_element(2, type);
size = ERL_INT_VALUE(t_size);
bind[i].buffer_length = size;
erl_free_term(t_size);
t_type = erl_element(1, type);
t = (char *)ERL_ATOM_PTR(t_type);
bind[i].length = safe_malloc(sizeof(unsigned long));
if (strncmp(t, NUMERIC_SQL, strlen(NUMERIC_SQL)) == 0) {
int val;
bind[i].buffer_type = MYSQL_TYPE_LONG;
*bind[i].length = sizeof(int);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = ERL_INT_VALUE(value);
memcpy(bind[i].buffer, &val, *bind[i].length);
} else if (strncmp(t, DECIMAL_SQL, strlen(DECIMAL_SQL)) == 0) {
char *val;
bind[i].buffer_type = MYSQL_TYPE_STRING;
*bind[i].length = bind[i].buffer_length * sizeof(char);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = erl_iolist_to_string(value);
if (val) {
memcpy(bind[i].buffer, val, *bind[i].length);
free(val);
}
} else if (strncmp(t, FLOAT_SQL, strlen(FLOAT_SQL)) == 0) {
float val;
bind[i].buffer_type = MYSQL_TYPE_FLOAT;
*bind[i].length = sizeof(float);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = ERL_FLOAT_VALUE(value);
memcpy(bind[i].buffer, &val, *bind[i].length);
} else if (strncmp(t, CHAR_SQL, strlen(CHAR_SQL)) == 0) {
char *val;
bind[i].buffer_type = MYSQL_TYPE_STRING;
*bind[i].length = bind[i].buffer_length * sizeof(char);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = erl_iolist_to_string(value);
if (val) {
memcpy(bind[i].buffer, val, *bind[i].length);
free(val);
}
} else if (strncmp(t, VARCHAR_SQL, strlen(VARCHAR_SQL)) == 0) {
(void)bind_string(&bind[i], value, size);
} else {
ETERM *resp;
resp = erl_format("{error, {unknown_sized_type, ~s, ~i}}",
t, bind[i].buffer_length);
write_msg(resp);
erl_free_term(resp);
}
erl_free_term(t_type);
} else {
char *t;
t = (char *)ERL_ATOM_PTR(type);
if (strncmp(t, TIMESTAMP_SQL, strlen(TIMESTAMP_SQL)) == 0) {
bind[i].buffer_type = MYSQL_TYPE_TIMESTAMP;
*bind[i].length = sizeof(MYSQL_TIME);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
memcpy(bind[i].buffer, value, *bind[i].length);
} else if (strncmp(t, INTEGER_SQL, strlen(INTEGER_SQL)) == 0) {
int val;
bind[i].buffer_type = MYSQL_TYPE_LONG;
*bind[i].length = sizeof(int);
bind[i].buffer = safe_malloc(*bind[i].length);
memset(bind[i].buffer, 0, *bind[i].length);
val = ERL_INT_VALUE(value);
memcpy(bind[i].buffer, &val, *bind[i].length);
} else {
ETERM *resp;
resp = erl_format("{error, {unknown_type, ~s}}", t);
write_msg(resp);
erl_free_term(resp);
}
}
if (ERL_IS_ATOM(value)
&& strncmp((char *)ERL_ATOM_PTR(value),
NULL_SQL, strlen(NULL_SQL)) == 0)
bind[i].is_null = &TRUTHY;
else
bind[i].is_null = &FALSY;
erl_free_term(value);
erl_free_term(type);
}
erl_free_term(params);
if (mysql_stmt_bind_param(handle, bind)) {
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
} else {
if (mysql_stmt_execute(handle)) {
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
} else {
set_mysql_results(handle);
if (results) {
resp = handle_mysql_result();
} else {
if (mysql_stmt_field_count(handle) == 0)
resp = erl_format("{updated, ~i}", numrows);
else
resp = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(handle), mysql_stmt_error(handle));
}
}
}
for (i = 0; i < param_count; i++) {
free(bind[i].length);
free(bind[i].buffer);
}
free(bind);
}
}
erl_free(q);
mysql_stmt_close(handle);
write_msg(resp);
erl_free_term(resp);
}
/*
* Dump (print for debugging) a term. Useful if/when things go wrong.
*/
void
dump_term (FILE *fp, ETERM *t)
{
if (fp == NULL) return;
fprintf(fp, "#<%p ", t);
if(t != NULL)
{
fprintf(fp, "count:%d, type:%d", ERL_COUNT(t), ERL_TYPE(t));
switch(ERL_TYPE(t))
{
case ERL_UNDEF:
fprintf(fp, "==undef");
break;
case ERL_INTEGER:
fprintf(fp, "==int, val:%d", ERL_INT_VALUE(t));
break;
case ERL_U_INTEGER:
fprintf(fp, "==uint, val:%u", ERL_INT_UVALUE(t));
break;
case ERL_FLOAT:
fprintf(fp, "==float, val:%g", ERL_FLOAT_VALUE(t));
break;
case ERL_ATOM:
fprintf(fp, "==atom, name:%p \"%s\"",
ERL_ATOM_PTR(t), ERL_ATOM_PTR(t));
break;
case ERL_BINARY:
fprintf(fp, "==binary, data:%p,%u",
ERL_BIN_PTR(t), ERL_BIN_SIZE(t));
break;
case ERL_PID:
fprintf(fp, "==pid, node:%p \"%s\"",
ERL_PID_NODE(t), ERL_PID_NODE(t));
break;
case ERL_PORT:
fprintf(fp, "==port, node:%p \"%s\"",
ERL_PORT_NODE(t), ERL_PORT_NODE(t));
break;
case ERL_REF:
fprintf(fp, "==ref, node:%p \"%s\"",
ERL_REF_NODE(t), ERL_REF_NODE(t));
break;
case ERL_CONS:
fprintf(fp, "==cons");
fprintf(fp, ", car:");
dump_term(fp, ERL_CONS_HEAD(t));
fprintf(fp, ", cdr:");
dump_term(fp, ERL_CONS_TAIL(t));
break;
case ERL_NIL:
fprintf(fp, "==nil");
break;
case ERL_TUPLE:
fprintf(fp, "==tuple, elems:%p,%u",
ERL_TUPLE_ELEMS(t), ERL_TUPLE_SIZE(t));
{
size_t i;
for(i = 0; i < ERL_TUPLE_SIZE(t); i++)
{
fprintf(fp, "elem[%u]:", i);
dump_term(fp, ERL_TUPLE_ELEMENT(t, i));
}
}
break;
case ERL_VARIABLE:
fprintf(fp, "==variable, name:%p \"%s\"",
ERL_VAR_NAME(t), ERL_VAR_NAME(t));
fprintf(fp, ", value:");
dump_term(fp, ERL_VAR_VALUE(t));
break;
default:
break;
}
}
fprintf(fp, ">");
}
ETERM * surface_create_from_png(ETERM* arg, int c_node) {
ETERM *file = erl_element(1, arg);
cairo_surface_t *surface = cairo_image_surface_create_from_png((char *)ERL_ATOM_PTR(file));
erl_free_term(file);
return erl_format("{c_node, ~i, {ok, ~i}}", c_node, surface);
}
int is_function(ETERM *fn, char *fn_name) {
return (strcmp((char *)ERL_ATOM_PTR(fn), fn_name) == 0);
}
int main(void)
#endif
{
ei_x_buff eix;
int index = 0;
ETERM **etermpp = NULL, *etermp = NULL;
char *charp = NULL;
unsigned char uchar, **ucharpp = NULL, *ucharp = NULL;
void *voidp = NULL;
Erl_Heap *erl_heapp = NULL;
int intx = 0;
int *intp = NULL;
unsigned int uintx, *uintp;
unsigned long *ulongp = NULL;
long longx = 0;
double doublex = 0.0;
short shortx = 42;
FILE *filep = NULL;
Erl_IpAddr erl_ipaddr = NULL;
ErlMessage *erlmessagep = NULL;
ErlConnect *erlconnectp = NULL;
struct hostent *hostp = NULL;
struct in_addr *inaddrp = NULL;
/* Converion to erl_interface format is in liberl_interface */
intx = erl_errno;
ei_encode_term(charp, &index, voidp);
ei_x_encode_term(&eix, voidp);
ei_decode_term(charp, &index, voidp);
erl_init(voidp, longx);
erl_connect_init(intx, charp,shortx);
erl_connect_xinit(charp,charp,charp,erl_ipaddr,charp,shortx);
erl_connect(charp);
erl_xconnect(erl_ipaddr,charp);
erl_close_connection(intx);
erl_receive(intx, ucharp, intx);
erl_receive_msg(intx, ucharp, intx, erlmessagep);
erl_xreceive_msg(intx, ucharpp, intp, erlmessagep);
erl_send(intx, etermp, etermp);
erl_reg_send(intx, charp, etermp);
erl_rpc(intx,charp,charp,etermp);
erl_rpc_to(intx,charp,charp,etermp);
erl_rpc_from(intx,intx,erlmessagep);
erl_publish(intx);
erl_accept(intx,erlconnectp);
erl_thiscookie();
erl_thisnodename();
erl_thishostname();
erl_thisalivename();
erl_thiscreation();
erl_unpublish(charp);
erl_err_msg(charp);
erl_err_quit(charp);
erl_err_ret(charp);
erl_err_sys(charp);
erl_cons(etermp,etermp);
erl_copy_term(etermp);
erl_element(intx,etermp);
erl_hd(etermp);
erl_iolist_to_binary(etermp);
erl_iolist_to_string(etermp);
erl_iolist_length(etermp);
erl_length(etermp);
erl_mk_atom(charp);
erl_mk_binary(charp,intx);
erl_mk_empty_list();
erl_mk_estring(charp, intx);
erl_mk_float(doublex);
erl_mk_int(intx);
erl_mk_list(etermpp,intx);
erl_mk_pid(charp,uintx,uintx,uchar);
erl_mk_port(charp,uintx,uchar);
erl_mk_ref(charp,uintx,uchar);
erl_mk_long_ref(charp,uintx,uintx,uintx,uchar);
erl_mk_string(charp);
erl_mk_tuple(etermpp,intx);
erl_mk_uint(uintx);
erl_mk_var(charp);
erl_print_term(filep,etermp);
/* erl_sprint_term(charp,etermp); */
erl_size(etermp);
erl_tl(etermp);
erl_var_content(etermp, charp);
erl_format(charp);
erl_match(etermp, etermp);
erl_global_names(intx, intp);
erl_global_register(intx, charp, etermp);
erl_global_unregister(intx, charp);
erl_global_whereis(intx, charp, charp);
erl_init_malloc(erl_heapp,longx);
erl_alloc_eterm(uchar);
erl_eterm_release();
erl_eterm_statistics(ulongp,ulongp);
erl_free_array(etermpp,intx);
erl_free_term(etermp);
erl_free_compound(etermp);
erl_malloc(longx);
erl_free(voidp);
erl_compare_ext(ucharp, ucharp);
erl_decode(ucharp);
erl_decode_buf(ucharpp);
erl_encode(etermp,ucharp);
erl_encode_buf(etermp,ucharpp);
erl_ext_size(ucharp);
erl_ext_type(ucharp);
erl_peek_ext(ucharp,intx);
erl_term_len(etermp);
erl_gethostbyname(charp);
erl_gethostbyaddr(charp, intx, intx);
erl_gethostbyname_r(charp, hostp, charp, intx, intp);
erl_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
erl_init_resolve();
erl_distversion(intx);
erl_epmd_connect(inaddrp);
erl_epmd_port(inaddrp, charp, intp);
charp = ERL_ATOM_PTR(etermp);
intx = ERL_ATOM_SIZE(etermp);
ucharp = ERL_BIN_PTR(etermp);
intx = ERL_BIN_SIZE(etermp);
etermp = ERL_CONS_HEAD(etermp);
etermp = ERL_CONS_TAIL(etermp);
intx = ERL_COUNT(etermp);
doublex= ERL_FLOAT_VALUE(etermp);
uintx = ERL_INT_UVALUE(etermp);
intx = ERL_INT_VALUE(etermp);
intx = ERL_IS_ATOM(etermp);
intx = ERL_IS_BINARY(etermp);
intx = ERL_IS_CONS(etermp);
intx = ERL_IS_EMPTY_LIST(etermp);
intx = ERL_IS_FLOAT(etermp);
intx = ERL_IS_INTEGER(etermp);
intx = ERL_IS_LIST(etermp);
intx = ERL_IS_PID(etermp);
intx = ERL_IS_PORT(etermp);
intx = ERL_IS_REF(etermp);
intx = ERL_IS_TUPLE(etermp);
intx = ERL_IS_UNSIGNED_INTEGER(etermp);
uchar = ERL_PID_CREATION(etermp);
charp = ERL_PID_NODE(etermp);
uintx = ERL_PID_NUMBER(etermp);
uintx = ERL_PID_SERIAL(etermp);
uchar = ERL_PORT_CREATION(etermp);
charp = ERL_PORT_NODE(etermp);
uintx = ERL_PORT_NUMBER(etermp);
uchar = ERL_REF_CREATION(etermp);
intx = ERL_REF_LEN(etermp);
charp = ERL_REF_NODE(etermp);
uintx = ERL_REF_NUMBER(etermp);
uintp = ERL_REF_NUMBERS(etermp);
etermp = ERL_TUPLE_ELEMENT(etermp,intx);
intx = ERL_TUPLE_SIZE(etermp);
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EINVAL +
EIO +
EMSGSIZE +
ENOMEM +
ERL_ATOM +
ERL_BINARY +
ERL_ERROR +
ERL_EXIT +
ERL_FLOAT +
ERL_INTEGER +
ERL_LINK +
ERL_LIST +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_PID +
ERL_PORT +
ERL_REF +
ERL_REG_SEND +
ERL_SEND +
ERL_SMALL_BIG +
ERL_TICK +
ERL_TIMEOUT +
ERL_TUPLE +
ERL_UNLINK +
ERL_U_INTEGER +
ERL_U_SMALL_BIG +
ERL_VARIABLE +
ETIMEDOUT +
MAXNODELEN +
MAXREGLEN;
}
int main(int argc, char **argv) {
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;
}
void
handle_select(ETERM *msg)
{
ETERM *epos, *ecount, *ecols, *erows, *resp;
my_ulonglong pos, count;
epos = erl_element(2, msg);
ecount = erl_element(3, msg);
pos = ERL_INT_UVALUE(epos);
count = ERL_INT_UVALUE(ecount);
erl_free_term(epos);
erl_free_term(ecount);
if (results == NULL) {
resp = erl_format("{error, result_set_does_not_exist}");
write_msg(resp);
erl_free_term(resp);
return;
}
if (ERL_IS_TUPLE(epos)) {
char *pos_type;
unsigned int pos_count;
pos_type = ERL_ATOM_PTR(erl_element(1, epos));
pos_count = ERL_INT_UVALUE(erl_element(2, epos));
if (strncmp(pos_type, SELECT_ABSOLUTE, strlen(SELECT_ABSOLUTE)) == 0) {
resultoffset = pos_count - 1;
} else if (strncmp(pos_type, SELECT_RELATIVE, strlen(SELECT_RELATIVE)) == 0) {
resultoffset += pos_count - 1;
} else {
resp = erl_format("{error, unknown_position, ~w}", epos);
write_msg(resp);
erl_free_term(resp);
return;
}
} else {
if (strncmp((char *)ERL_ATOM_PTR(epos), SELECT_NEXT, strlen(SELECT_NEXT)) == 0) {
handle_next(NULL);
return;
} else {
resp = erl_format("{error, unknown_position, ~w}", epos);
write_msg(resp);
erl_free_term(resp);
return;
}
}
mysql_stmt_data_seek(sth, resultoffset);
ecols = make_cols();
erows = make_rows(count);
resultoffset += count;
resp = erl_format("{selected, ~w, ~w}", ecols, erows);
erl_free_term(erows);
erl_free_term(ecols);
write_msg(resp);
erl_free_term(resp);
}
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;
}
/**
* @brief The main function.
* It waits for data in the buffer and calls the driver.
*/
int main() {
unsigned char buf[BUF_SIZE];
/* char command[MAXATOMLEN]; */
/* int index, version, arity; */
ETERM *emsg, *msg_type, *refp, *tuplep, *fnp, *arg1p, *arg2p, *resp;
int res;
/* ei_x_buff result; */
memset(buf, 0, BUF_SIZE);
erl_init(NULL, 0);
/* setlogmask( LOG_UPTO (LOG_NOTICE));
*/
openlog("gpio_port", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);
syslog(LOG_NOTICE, "openlog done");
while ((res = read_cmd(buf)) > 0)
{
syslog(LOG_NOTICE, "read_cmd done");
if ((emsg = erl_decode(buf)) != NULL)
{
syslog(LOG_NOTICE, "erl_decode done");
}
else
{
syslog(LOG_ERR, "erl_decode FAILED");
break;
}
if ((msg_type = erl_element(1, emsg)) != NULL)
{
syslog(LOG_NOTICE, "erl_element succeeded!");
syslog(LOG_NOTICE, "msg_type: %s", ERL_ATOM_PTR(msg_type));
if (strncmp(ERL_ATOM_PTR(msg_type), "init", 4) == 0)
{
arg1p = erl_element(2, emsg);
arg2p = erl_element(3, emsg);
if (arg1p != NULL && arg2p != NULL)
{
if (port_gpio_init(arg1p, arg2p))
{
resp = erl_format("ok");
}
else
{
resp = erl_format("{error, gpio_init_fail}");
}
}
else
{
syslog(LOG_ERR,"init arguments incorrect");
resp = erl_format("{error, gpio_init_wrong_arguments}");
}
if (write_cmd_eterm(resp))
syslog(LOG_NOTICE, "write_cmd_eterm done for init ");
else
syslog(LOG_NOTICE, "write_cmd_eterm FAILED for init");
}
else if (strncmp(ERL_ATOM_PTR(msg_type), "cast", 4) == 0)
{
if ((arg1p = erl_element(2, emsg))!= NULL)
{
if (strncmp(ERL_ATOM_PTR(arg1p), "release", 7) == 0)
{
if (port_gpio_release(my_pin))
{
syslog(LOG_NOTICE, "gpio_relase went well for pin %d",
my_pin);
}
else
{
syslog(LOG_ERR, "gpio_release failed for pin %d", my_pin);
}
}
}
else
{
syslog(LOG_ERR, "release arguments incorrect");
}
}
else if (strncmp(ERL_ATOM_PTR(msg_type), "call", 4) == 0)
{
refp = erl_element(2, emsg);
tuplep = erl_element(3, emsg);
if (refp != NULL && tuplep != NULL)
{
if ((fnp = erl_element(1, tuplep)) != NULL)
{
if (strncmp(ERL_ATOM_PTR(fnp), "write", 5) == 0)
{
if((arg1p = erl_element(2, tuplep)) != NULL)
{
if(port_gpio_write(my_pin, arg1p))
{
resp = erl_format("ok");
}
else
{
syslog(LOG_ERR, "port write failed");
resp = erl_format("{error, gpio_write_failed}");
}
}
else
{
syslog(LOG_ERR, "call with wrong tuple");
resp = erl_format("{error, call_expected_tuple}");
}
}
else if (strncmp(ERL_ATOM_PTR(fnp), "read", 4) == 0)
{
if((res =port_gpio_read(my_pin)) !=-1)
{
resp = erl_format("~i",res);
}
else
{
syslog(LOG_ERR, "port read failed");
resp = erl_format("{error, gpio_read_failed}");
}
}
else if (strncmp(ERL_ATOM_PTR(fnp), "set_int", 7) == 0)
{
if((arg1p = erl_element(2, tuplep)) != NULL)
{
if(port_gpio_set_int(my_pin, arg1p))
{
resp = erl_format("ok");
}
else
{
syslog(LOG_ERR, "port set_int failed");
resp = erl_format("{error, gpio_set_int_failed}");
}
} else
{
syslog(LOG_ERR, "call with wrong tuple");
resp = erl_format("{error, call_expected_tuple}");
}
}
}
else
{
syslog(LOG_ERR,"call arguments incorrect");
resp = erl_format("{error, gpio_cal_wrong_arguments}");
}
}
/* Now we can send the response to the caller */
if (write_cmd_eterm(erl_format("{port_reply,~w,~w}", refp, resp)))
{
syslog(LOG_NOTICE, "successful reply to call");
}
else
{
syslog(LOG_ERR, "error write_cmd_eterm");
}
}
}
else
{
syslog(LOG_NOTICE, "erl_element FAILED!!!!");
break;
}
}
syslog(LOG_NOTICE, "leaving gpio_port %d", res);
closelog();
erl_free_term(emsg); erl_free_term(msg_type);
/* 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);
return 0;
/* /\* Reset the index, so that ei functions can decode terms from the */
/* * beginning of the buffer *\/ */
/* index = 0; */
/* /\* Ensure that we are receiving the binary term by reading and */
/* * stripping the version byte *\/ */
/* if (ei_decode_version(buf, &index, &version)) return 1; */
/* /\* Our marshalling spec is that we are expecting a tuple {Command, Arg1, Arg2, ...} *\/ */
/* if (ei_decode_tuple_header(buf, &index, &arity)) return 2; */
/* //if (arity != 3) return 3; */
/* if (ei_decode_atom(buf, &index, command)) return 4; */
/* /\* Prepare the output buffer that will hold {ok, Result} or {error, Reason} *\/ */
/* if (ei_x_new_with_version(&result) || ei_x_encode_tuple_header(&result, 2)) return 5; */
/* /\* This is where we handle incoming commands *\/ */
/* if ( !strcmp("gpio_init", command) ) */
/* { */
/* if (ei_decode_int(buf, &index, &arg1)) return 6; */
/* if (ei_decode_int(buf, &index, &arg2)) return 7; */
/* res = port_gpio_init(arg1, arg2); */
/* if ( res ) */
/* { */
/* if (ei_x_encode_atom(&result, "ok") || ei_x_encode_int(&result, res)) return 8; */
/* } */
/* else */
/* { */
/* if (ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "fail.")) return 99; */
/* } */
/* } */
/* else if( !strcmp("gpio_release", command) ) */
/* { */
/* if (ei_decode_int(buf, &index, &arg1)) return 6; */
/* res = port_gpio_release(arg1); */
/* if ( res ) */
/* { */
/* if (ei_x_encode_atom(&result, "ok") || ei_x_encode_int(&result, res)) return 8; */
/* } */
/* else */
/* { */
/* if (ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "fail.")) return 99; */
/* } */
/* } */
/* else if( !strcmp("gpio_write", command) ) */
/* { */
/* if (ei_decode_int(buf, &index, &arg1)) return 6; */
/* if (ei_decode_int(buf, &index, &arg2)) return 7; */
/* res = port_gpio_write(arg1, arg2); */
/* if ( res ) */
/* { */
/* if (ei_x_encode_atom(&result, "ok") || ei_x_encode_int(&result, res)) return 8; */
/* } */
/* else */
/* { */
/* if (ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "fail.")) return 99; */
/* } */
/* } */
/* else if( !strcmp("gpio_read", command) ) */
/* { */
/* if (ei_decode_int(buf, &index, &arg1)) return 6; */
/* res = port_gpio_read(arg1); */
/* if ( res ) */
/* { */
/* if (ei_x_encode_atom(&result, "ok") || ei_x_encode_int(&result, res)) return 8; */
/* } */
/* else */
/* { */
/* if (ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "fail.")) return 99; */
/* } */
/* } */
/* else if( !strcmp("gpio_set_int", command) ) */
/* { */
/* if (ei_decode_int(buf, &index, &arg1)) return 6; */
/* if (ei_decode_int(buf, &index, &arg2)) return 7; */
/* res = port_gpio_set_int(arg1, arg2); */
/* if ( res ) */
/* { */
/* if (ei_x_encode_atom(&result, "ok") || ei_x_encode_int(&result, res)) return 8; */
/* } */
/* else */
/* { */
/* if (ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "fail.")) return 99; */
/* } */
/* } */
/* else { */
/* if (ei_x_encode_atom(&result, "error") || ei_x_encode_atom(&result, "unsupported_command")) */
/* return 99; */
/* } */
/* write_cmd(&result); */
/* ei_x_free(&result); */
/* } */
}
int erl_print_term(FILE *fp, const ETERM *ep)
{
int j,i,doquote;
int ch_written = 0; /* counter of written chars */
if ((!fp) || (!ep)) return 0;
/* ASSERT(ep != NULL); */
j = i = doquote = 0;
switch(ERL_TYPE(ep))
{
case ERL_ATOM: {
char* adata = ERL_ATOM_PTR(ep);
/* FIXME: what if some weird locale is in use? */
if (!islower(adata[0]))
doquote = 1;
for (i = 0; !doquote && i < ERL_ATOM_SIZE(ep); i++)
{
doquote = !(isalnum(adata[i]) || (adata[i] == '_'));
}
if (doquote) {
putc('\'', fp);
ch_written++;
}
fputs(adata, fp);
ch_written += ERL_ATOM_SIZE(ep);
if (doquote) {
putc('\'', fp);
ch_written++;
}
break;
}
case ERL_VARIABLE:
if (!isupper((int)ERL_VAR_NAME(ep)[0])) {
doquote = 1;
putc('\'', fp);
ch_written++;
}
fputs(ERL_VAR_NAME(ep), fp);
ch_written += ERL_VAR_LEN(ep);
if (doquote) {
putc('\'', fp);
ch_written++;
}
break;
case ERL_PID:
ch_written += fprintf(fp, "<%s.%d.%d>",
ERL_PID_NODE(ep),
ERL_PID_NUMBER(ep), ERL_PID_SERIAL(ep));
break;
case ERL_PORT:
ch_written += fprintf(fp, "#Port");
break;
case ERL_REF:
ch_written += fprintf(fp, "#Ref");
break;
case ERL_EMPTY_LIST:
ch_written += fprintf(fp, "[]");
break;
case ERL_LIST:
if (is_printable_list(ep)) {
ch_written += print_string(fp, ep);
} else {
putc('[', fp);
ch_written++;
while (ERL_IS_CONS(ep)) {
ch_written += erl_print_term(fp, HEAD(ep));
ep = TAIL(ep);
if (ERL_IS_CONS(ep)) {
putc(',', fp);
ch_written++;
}
}
if (!ERL_IS_EMPTY_LIST(ep)) {
putc('|', fp);
ch_written++;
ch_written += erl_print_term(fp, ep);
}
putc(']', fp);
ch_written++;
}
break;
case ERL_TUPLE:
putc('{', fp);
ch_written++;
for (i=0; i < ERL_TUPLE_SIZE(ep); i++) {
ch_written += erl_print_term(fp, ERL_TUPLE_ELEMENT(ep, j++) );
if (i != ERL_TUPLE_SIZE(ep)-1) {
putc(',', fp);
ch_written++;
}
}
putc('}', fp);
ch_written++;
break;
case ERL_BINARY: {
int sz = (ERL_BIN_SIZE(ep) > 20) ? 20 : ERL_BIN_SIZE(ep);
unsigned char *ptr = ERL_BIN_PTR(ep);
ch_written += fprintf(fp, "#Bin<");
for (i = 0; i < sz; i++) {
putc(ptr[i], fp); ch_written++;
}
if (sz == 20) ch_written += fprintf(fp, "(%d)....>", ERL_BIN_SIZE(ep)-20);
else ch_written += fprintf(fp, ">");
break;
}
case ERL_INTEGER:
case ERL_SMALL_BIG:
ch_written += fprintf(fp, "%d", ERL_INT_VALUE(ep));
break;
case ERL_U_INTEGER:
case ERL_U_SMALL_BIG:
ch_written += fprintf(fp, "%d", ERL_INT_UVALUE(ep));
break;
case ERL_LONGLONG:
case ERL_U_LONGLONG:
ch_written += fprintf(fp, "%lld", ERL_LL_UVALUE(ep));
break;
case ERL_FLOAT:
ch_written += fprintf(fp, "%f", ERL_FLOAT_VALUE(ep));
break;
case ERL_FUNCTION:
ch_written += fprintf(fp, "#Fun<");
ch_written += erl_print_term(fp, ERL_FUN_MODULE(ep));
putc('.', fp);
ch_written++;
ch_written += erl_print_term(fp, ERL_FUN_INDEX(ep));
putc('.', fp);
ch_written++;
ch_written += erl_print_term(fp, ERL_FUN_UNIQ(ep));
putc('>', fp);
ch_written++;
break;
default:
ch_written = -10000;
erl_err_msg("<ERROR> erl_print_term: Bad type of term !");
}
return ch_written;
}
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;
}
