ETERM*
get_term(void)
{
char* encoded;
ETERM* term;
int n;
encoded = read_packet(&n);
switch (encoded[0]) {
case 'e':
free(encoded);
return NULL;
case 't':
term = erl_decode(encoded+1);
free(encoded);
if (term == NULL) {
fail("Failed to decode term");
exit(0);
}
return term;
default:
fprintf(stderr, "Garbage received: ");
dump(encoded, n, 16);
putc('\n', stderr);
fail("C program received garbage");
free(encoded);
exit(1);
}
}
ETERM *
read_msg()
{
ETERM *msg;
unsigned char *buf;
msglen_t len;
if (restartable_read((unsigned char *)&len, sizeof(len)) == -1) {
if (errno == 0) {
logmsg("INFO: got end of file from Erlang process, shutting down.");
exit(0);
}
logmsg("ERROR: couldn't read %d byte message prefix: %s.",
sizeof(len), strerror(errno));
exit(2);
}
len = ntohl(len);
buf = (unsigned char *)safe_malloc(len);
if (restartable_read(buf, len) == -1) {
logmsg("ERROR: couldn't read %d byte message: %s.",
len, strerror(errno));
free(buf);
exit(2);
}
msg = erl_decode(buf);
free(buf);
return msg;
}
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);
}
}
static int
process_command(unsigned char *buf)
{
int retval = 0;
ETERM *pattern, *tuple, *cmd, *port, *data;
pattern = erl_format("{Cmd, Port, Data}");
tuple = erl_decode(buf);
if (erl_match(pattern, tuple)) {
cmd = erl_var_content(pattern, "Cmd");
port = erl_var_content(pattern, "Port");
data = erl_var_content(pattern, "Data");
switch (ERL_INT_VALUE(cmd)) {
case CMD_SALT:
retval = process_encode_salt(port, data);
break;
case CMD_HASHPW:
retval = process_hashpw(port, data);
break;
};
erl_free_term(cmd);
erl_free_term(port);
erl_free_term(data);
}
erl_free_term(pattern);
erl_free_term(tuple);
return retval;
}
static int process_command(byte *buf)
{
int retval = 0;
ETERM *pattern, *tuple, *cmd, *port, *data;
pattern = erl_format("{Cmd, Port, Data}");
tuple = erl_decode(buf);
if (erl_match(pattern, tuple))
{
cmd = erl_var_content(pattern, "Cmd");
port = erl_var_content(pattern, "Port");
data = erl_var_content(pattern, "Data");
switch (ERL_INT_VALUE(cmd))
{
case CMD_AUTH:
retval = process_auth(port, data);
break;
case CMD_ACCT:
retval = process_acct(port, data);
break;
};
erl_free_term(cmd);
erl_free_term(port);
erl_free_term(data);
}
erl_free_term(pattern);
erl_free_term(tuple);
return retval;
}
ETERM *erl_global_whereis(int fd, const char *name, char *node)
{
char buf[EISMALLBUF];
char *bufp=buf;
char tmpbuf[64];
int index = 0;
erlang_pid *self = erl_self();
erlang_pid epid;
ETERM *opid;
erlang_msg msg;
int i;
int version,arity,msglen;
self->num = fd; /* FIXME looks strange to change something?! */
ei_encode_version(buf,&index);
ei_encode_tuple_header(buf,&index,2);
ei_encode_pid(buf,&index,self); /* PidFrom */
ei_encode_tuple_header(buf,&index,5);
ei_encode_atom(buf,&index,"call"); /* call */
ei_encode_atom(buf,&index,"global"); /* Mod */
ei_encode_atom(buf,&index,"whereis_name"); /* Fun */
ei_encode_list_header(buf,&index,1); /* Args: [ name ] */
ei_encode_atom(buf,&index,name);
ei_encode_empty_list(buf,&index);
ei_encode_atom(buf,&index,"user"); /* user */
/* make the rpc call */
if (ei_send_reg_encoded(fd,self,"rex",buf,index)) return NULL;
while (1) {
index = EISMALLBUF;
if (!(i = ei_recv_internal(fd,&bufp,&index,&msg,&msglen,1,0))) continue;
else break;
}
if (i != ERL_SEND) return NULL;
/* expecting { rex, pid } */
index = 0;
if (ei_decode_version(buf,&index,&version)
|| ei_decode_tuple_header(buf,&index,&arity)
|| (arity != 2)
|| ei_decode_atom(buf,&index,tmpbuf)
|| strcmp(tmpbuf,"rex")
|| ei_decode_pid(buf,&index,&epid))
return NULL; /* bad response from other side */
/* put the pid into a format for the caller */
index = 0;
ei_encode_pid(buf,&index,&epid);
opid = erl_decode((unsigned char*)buf);
/* extract the nodename for the caller */
if (node) strcpy(node,epid.node);
return opid;
}
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 * 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);
}
ETERM *
read_msg()
{
ETERM *msg;
unsigned char *buf;
msglen_t len;
logmsg("DEBUG: reading message length.");
if (restartable_read((unsigned char *)&len, sizeof(len)) == -1) {
logmsg("ERROR: couldn't read %d byte message prefix: %s.",
sizeof(len), strerror(errno));
exit(2);
}
len = ntohl(len);
buf = (unsigned char *)malloc(len);
if (buf == NULL) {
logmsg("ERROR: Couldn't malloc %d bytes: %s.", len,
strerror(errno));
exit(2);
}
logmsg("DEBUG: reading message body (len: %d).", len);
if (restartable_read(buf, len) == -1) {
logmsg("ERROR: couldn't read %d byte message: %s.",
len, strerror(errno));
free(buf);
exit(2);
}
msg = erl_decode(buf);
free(buf);
return msg;
}
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);
}
}
/**
** rockse <path_to_tbl> <path_to_log>
**/
int main(int argc, char **argv) {
rockse * ptr;
ETERM *from_erl;
ETERM *cmd;
ETERM *key;
ETERM *value;
char *ret;
ETERM *to_send;
byte buf[1024];
int length;
log = fopen(argv[2], "a+");
erl_init(NULL, 0);
fprintf(log, "*** rockse opening table %s\n", argv[1]);
ptr = open(argv[1]);
while (read_cmd(buf) > 0) {
from_erl = erl_decode(buf);
fprintf(log, " rockse command type %d\n", ERL_TYPE(from_erl));
if (match_close(from_erl)) {
send_bok();
fprintf(log, " rockse command +close+ sent\n");
break;
}
if (ERL_IS_TUPLE(from_erl) && ERL_TUPLE_SIZE(from_erl) == 3) {
/* can only be a {put, key, val} */
cmd = ERL_TUPLE_ELEMENT(from_erl, 0);
if (match_put(cmd)) {
key = ERL_TUPLE_ELEMENT(from_erl, 1);
value = ERL_TUPLE_ELEMENT(from_erl, 2);
fprintf(log, " rockse command +put+ %s %s sent\n", erl_iolist_to_string(key), erl_iolist_to_string(value));
put(ptr, erl_iolist_to_string(key), erl_iolist_to_string(value));
send_put_ok();
}
erl_free_term(from_erl);
erl_free_term(cmd);
erl_free_term(key);
erl_free_term(value);
}
if (ERL_IS_TUPLE(from_erl) && ERL_TUPLE_SIZE(from_erl) == 2) {
/* can only be a {get, key} or {delete, key} */
cmd = ERL_TUPLE_ELEMENT(from_erl, 0);
if (match_get(cmd)) {
key = ERL_TUPLE_ELEMENT(from_erl, 1);
fprintf(log, " rockse command +get+ %s sent\n", erl_iolist_to_string(key));
ret = get(ptr, erl_iolist_to_string(key));
if (ret == NULL) {
send_nok();
}
else {
length = strlen(ret);
fprintf(log, " rockse command +get+ found %s of size %d\n", ret, length);
to_send = erl_format("{ok, get, ~s}", ret);
send_get_result(to_send);
free(ret);
}
}
else if (match_delete(cmd)) {
key = ERL_TUPLE_ELEMENT(from_erl, 1);
fprintf(log, " rockse command +delete+ %s sent\n", erl_iolist_to_string(key));
delete(ptr, erl_iolist_to_string(key));
send_delete_ok();
}
erl_free_term(from_erl);
erl_free_term(cmd);
erl_free_term(key);
}
fflush(log);
}
close_and_destroy(ptr);
fprintf(log, "*** rockse closing table %s\n", argv[1]);
erl_free_term(from_erl);
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 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;
}
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;
}
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;
}
/**
* Read an integer giving the maximum size of a fragment.
*/
int main( int argc, char *argv[] ) {
int fail = 0;
erl_init(NULL,0);
#ifdef _DEBUG
openlog( "erlang-port", 0, LOG_USER );
syslog( LOG_INFO, "%s is alive\n", argv[0] );
#endif
while( ! fail ) {
ETERM *fragsize_term = NULL;
byte buf[100 /*WIRE_SIZEOF_INT*/];
if( read_lpm( buf, sizeof(buf) ) <= 0 ) {
#ifdef _DEBUG
syslog( LOG_ERR, "failed reading fragment size:\n" );
#endif
break;
}
fragsize_term = erl_decode( buf );
if( fragsize_term ) {
ETERM **array;
unsigned int count;
unsigned int SIZEOF_FRAGMENT
= ERL_INT_UVALUE(fragsize_term);
erl_free_term( fragsize_term );
if( SIZEOF_FRAGMENT == 0 /* the explicit signal to shutdown */ )
break;
#ifdef _DEBUG
syslog( LOG_INFO, "received sizeof fragment: %d\n", SIZEOF_FRAGMENT );
#endif
count = min_packet_count( SIZEOF_IMAGE, SIZEOF_FRAGMENT );
array = calloc( count, sizeof(ETERM*) );
if( array ) {
ETERM *frags;
for(int i = 0; i < count; i++ ) {
const size_t S
= i+1 < count
? SIZEOF_FRAGMENT
: (SIZEOF_IMAGE % SIZEOF_FRAGMENT);
array[i] = erl_mk_binary(
TEST_IMAGE + i*SIZEOF_FRAGMENT, S );
if( array[i] == NULL ) {
count = i; // ...for erl_free_array below.
fail = 1;
break;
}
}
if( fail )
goto cleanup;
frags = erl_mk_list( array, count );
if( frags ) {
const int nbyte = erl_term_len( frags );
byte *buf = calloc( nbyte, sizeof(byte) );
if( buf ) {
if( erl_encode( frags, buf ) == nbyte ) {
if( write_lpm( buf, nbyte ) != nbyte )
fail = 1;
} else
fail = 1;
free( buf );
} else
fail = 1;
} else
fail = 1;
cleanup:
erl_free_array( array, count );
free( array );
}
} else
break;
}
#ifdef _DEBUG
closelog();
#endif
return 0;
}
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;
}
