static int
process_encode_salt(ETERM *pid, ETERM *data)
{
int retval = 0;
ETERM *pattern, *cslt, *lr;
byte *csalt = NULL;
long log_rounds = -1;
int csaltlen = -1;
char ret[64];
pattern = erl_format("{Csalt, LogRounds}");
if (erl_match(pattern, data)) {
cslt = erl_var_content(pattern, "Csalt");
csaltlen = ERL_BIN_SIZE(cslt);
csalt = ERL_BIN_PTR(cslt);
lr = erl_var_content(pattern, "LogRounds");
log_rounds = ERL_INT_UVALUE(lr);
if (16 != csaltlen) {
retval = process_reply(pid, CMD_SALT, "Invalid salt length");
} else if (log_rounds < 4 || log_rounds > 31) {
retval = process_reply(pid, CMD_SALT, "Invalid number of rounds");
} else {
encode_salt(ret, (u_int8_t*)csalt, csaltlen, log_rounds);
retval = process_reply(pid, CMD_SALT, ret);
}
erl_free_term(cslt);
erl_free_term(lr);
};
erl_free_term(pattern);
return retval;
}
ETERM *erl_mk_uint (unsigned int u)
{
ETERM *ep;
ep = erl_alloc_eterm(ERL_U_INTEGER);
ERL_COUNT(ep) = 1;
ERL_INT_UVALUE(ep) = u;
return ep;
}
void local_add_watch(ETERM* args)
{
ETERM *pathp = erl_element(1, args);
int pathLength = ERL_BIN_SIZE(pathp);
char *path = ERL_BIN_PTR(pathp);
ETERM *notifyFilterp = erl_element(2, args);
unsigned int notifyFilter_ui = ERL_INT_UVALUE(notifyFilterp);
long notifyFilter = (long)notifyFilter_ui;
ETERM *watchSubdirsp = erl_element(3, args);
int watchSubdirs = ERL_INT_VALUE(watchSubdirsp);
int watchID = eNotify_addWatch(path, pathLength, notifyFilter, watchSubdirs);
// Prepare response
ETERM *tuplep;
ETERM *tupleArray[2];
if (watchID < 0)
{
long errorCode = (long)(-watchID);
char errorDesc[1024];
eNotify_getErrorDesc(errorCode, errorDesc, 1024);
tupleArray[0] = erl_mk_atom("error");
tupleArray[1] = erl_mk_string(errorDesc);
}
else if (0 == watchID)
{
// this may happen if there's a problem converting
// a path from utf8 to UTF16
tupleArray[0] = erl_mk_atom("error");
tupleArray[1] = erl_mk_string("internal_error");
}
else
{
tupleArray[0] = erl_mk_atom("ok");
tupleArray[1] = erl_mk_int(watchID);
}
char buf[1024];
tuplep = erl_mk_tuple(tupleArray, 2);
erl_encode(tuplep, buf);
write_cmd(buf, erl_term_len(tuplep));
erl_free_array(tupleArray, 2); // free contents from tupleArray
}
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;
}
/*
* FIXME: Deep (the whole tree) or shallow (just the top term) copy?
* The documentation never says, but the code as written below will
* make a deep copy. This should be documented.
*/
ETERM *erl_copy_term(const ETERM *ep)
{
int i;
ETERM *cp;
if (!ep) return NULL;
/* ASSERT(ep != NULL); */
cp = erl_alloc_eterm(ERL_TYPE(ep));
ERL_COUNT(cp) = 1;
switch(ERL_TYPE(cp)) {
case ERL_INTEGER:
case ERL_SMALL_BIG:
ERL_INT_VALUE(cp) = ERL_INT_VALUE(ep);
break;
case ERL_U_INTEGER:
case ERL_U_SMALL_BIG:
ERL_INT_UVALUE(cp) = ERL_INT_UVALUE(ep);
break;
case ERL_LONGLONG:
ERL_LL_VALUE(cp) = ERL_LL_VALUE(ep);
break;
case ERL_U_LONGLONG:
ERL_LL_UVALUE(cp) = ERL_LL_UVALUE(ep);
break;
case ERL_FLOAT:
ERL_FLOAT_VALUE(cp) = ERL_FLOAT_VALUE(ep);
break;
case ERL_ATOM:
if (!erl_atom_copy(&cp->uval.aval.d, &ep->uval.aval.d))
{
erl_free_term(cp);
erl_errno = ENOMEM;
return NULL;
}
break;
case ERL_PID:
/* FIXME: First copy the bit pattern, then duplicate the node
name and plug in. Somewhat ugly (also done with port and
ref below). */
memcpy(&cp->uval.pidval, &ep->uval.pidval, sizeof(Erl_Pid));
erl_atom_copy(&cp->uval.pidval.node, &ep->uval.pidval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_PORT:
memcpy(&cp->uval.portval, &ep->uval.portval, sizeof(Erl_Port));
erl_atom_copy(&cp->uval.portval.node, &ep->uval.portval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_REF:
memcpy(&cp->uval.refval, &ep->uval.refval, sizeof(Erl_Ref));
erl_atom_copy(&cp->uval.refval.node, &ep->uval.refval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_LIST:
HEAD(cp) = erl_copy_term(HEAD(ep));
TAIL(cp) = erl_copy_term(TAIL(ep));
break;
case ERL_EMPTY_LIST:
break;
case ERL_TUPLE:
i = ERL_TUPLE_SIZE(cp) = ERL_TUPLE_SIZE(ep);
ERL_TUPLE_ELEMS(cp) = (ETERM**) erl_malloc(i * sizeof(ETERM*));
for(i=0; i < ERL_TUPLE_SIZE(ep); i++)
ERL_TUPLE_ELEMENT(cp,i) = erl_copy_term(ERL_TUPLE_ELEMENT(ep, i));
break;
case ERL_BINARY:
ERL_BIN_SIZE(cp) = ERL_BIN_SIZE(ep);
ERL_BIN_PTR(cp) = (unsigned char *) erl_malloc(ERL_BIN_SIZE(ep));
memcpy(ERL_BIN_PTR(cp), ERL_BIN_PTR(ep), ERL_BIN_SIZE(ep));
break;
case ERL_FUNCTION:
i = ERL_CLOSURE_SIZE(cp) = ERL_CLOSURE_SIZE(ep);
ERL_FUN_ARITY(cp) = ERL_FUN_ARITY(ep);
ERL_FUN_NEW_INDEX(cp) = ERL_FUN_NEW_INDEX(ep);
ERL_FUN_INDEX(cp) = erl_copy_term(ERL_FUN_INDEX(ep));
ERL_FUN_UNIQ(cp) = erl_copy_term(ERL_FUN_UNIQ(ep));
ERL_FUN_CREATOR(cp) = erl_copy_term(ERL_FUN_CREATOR(ep));
ERL_FUN_MODULE(cp) = erl_copy_term(ERL_FUN_MODULE(ep));
memcpy(ERL_FUN_MD5(cp), ERL_FUN_MD5(ep), sizeof(ERL_FUN_MD5(ep)));
ERL_CLOSURE(cp) = (ETERM**) erl_malloc(i * sizeof(ETERM*));
for(i=0; i < ERL_CLOSURE_SIZE(ep); i++)
ERL_CLOSURE_ELEMENT(cp,i) =
erl_copy_term(ERL_CLOSURE_ELEMENT(ep, i));
break;
default:
erl_err_msg("<ERROR> erl_copy_term: wrong type encountered !");
erl_free_term(cp);
return (ETERM *) NULL;
}
return cp;
}
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;
}
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;
}
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);
}
/*
* 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, ">");
}
/**
* 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;
}
