/* length (4), PASS_THROUGH (1), header, message */
int ei_ei_send_reg_encoded(ei_cnode* ec, int fd, const erlang_pid *from,
const char *to, const char *msg, int msglen)
{
char *s, header[1400]; /* see size calculation below */
erlang_trace *token = NULL;
int index = 5; /* reserve 5 bytes for control message */
#ifdef HAVE_WRITEV
struct iovec v[2];
#endif
/* are we tracing? */
/* check that he can receive trace tokens first */
if (ei_distversion(fd) > 0)
token = ei_trace(0,(erlang_trace *)NULL);
/* header = REG_SEND, from, cookie, toname max sizes: */
ei_encode_version(header,&index); /* 1 */
if (token) {
ei_encode_tuple_header(header,&index,5); /* 2 */
ei_encode_long(header,&index,ERL_REG_SEND_TT); /* 2 */
} else {
ei_encode_tuple_header(header,&index,4);
ei_encode_long(header,&index,ERL_REG_SEND);
}
ei_encode_pid(header,&index,from); /* 268 */
ei_encode_atom(header,&index,"" /*ei_getfdcookie(ec, fd)*/ ); /* 258 */
ei_encode_atom(header,&index,to); /* 268 */
if (token) ei_encode_trace(header,&index,token); /* 534 */
/* control message (precedes header actually) */
/* length = 1 ('p') + header len + message len */
s = header;
put32be(s, index + msglen - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/*** sum: 1336 */
#ifdef DEBUG_DIST
if (ei_trace_distribution > 0) ei_show_sendmsg(stderr,header,msg);
#endif
#ifdef HAVE_WRITEV
v[0].iov_base = (char *)header;
v[0].iov_len = index;
v[1].iov_base = (char *)msg;
v[1].iov_len = msglen;
if (writev(fd,v,2) != index+msglen) return -1;
#else
/* no writev() */
if (writesocket(fd,header,index) != index) return -1;
if (writesocket(fd,msg,msglen) != msglen) return -1;
#endif
return 0;
}
int ei_x_encode_long(ei_x_buff* x, long n)
{
int i = x->index;
ei_encode_long(NULL, &i, n);
if (!x_fix_buff(x, i))
return -1;
return ei_encode_long(x->buff, &x->index, n);
}
int ei_encode_fun(char *buf, int *index, const erlang_fun *p)
{
int ix = *index;
if (p->arity == -1) {
/* ERL_FUN_EXT */
if (buf != NULL) {
char* s = buf + ix;
put8(s, ERL_FUN_EXT);
put32be(s, p->n_free_vars);
}
ix += sizeof(char) + 4;
if (ei_encode_pid(buf, &ix, &p->pid) < 0)
return -1;
if (ei_encode_atom_as(buf, &ix, p->module, ERLANG_UTF8, p->module_org_enc) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->index) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->uniq) < 0)
return -1;
if (buf != NULL)
memcpy(buf + ix, p->free_vars, p->free_var_len);
ix += p->free_var_len;
} else {
char *size_p;
/* ERL_NEW_FUN_EXT */
if (buf != NULL) {
char* s = buf + ix;
put8(s, ERL_NEW_FUN_EXT);
size_p = s;
s += 4;
put8(s, p->arity);
memcpy(s, p->md5, sizeof(p->md5));
s += sizeof(p->md5);
put32be(s, p->index);
put32be(s, p->n_free_vars);
} else
size_p = NULL;
ix += 1 + 4 + 1 + sizeof(p->md5) + 4 + 4;
if (ei_encode_atom_as(buf, &ix, p->module, ERLANG_UTF8, p->module_org_enc) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->old_index) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->uniq) < 0)
return -1;
if (ei_encode_pid(buf, &ix, &p->pid) < 0)
return -1;
if (buf != NULL)
memcpy(buf + ix, p->free_vars, p->free_var_len);
ix += p->free_var_len;
if (size_p != NULL) {
int sz = buf + ix - size_p;
put32be(size_p, sz);
}
}
*index = ix;
return 0;
}
int ei_send_exit_tmo(int fd, const erlang_pid *from, const erlang_pid *to,
const char *reason, unsigned ms)
{
char sbuf[EISMALLBUF];
erlang_trace *token = NULL;
char *dbuf = NULL;
char *msgbuf;
char *s;
int index = 0;
int len = strlen(reason) + 1080; /* see below */
if (len > EISMALLBUF)
if (!(dbuf = malloc(len)))
return -1;
msgbuf = (dbuf ? dbuf : sbuf);
/* are we tracing? */
/* check that he can receive trace tokens first */
if (ei_distversion(fd) > 0) token = ei_trace(0,NULL);
index = 5; /* max sizes: */
ei_encode_version(msgbuf,&index); /* 1 */
if (token) {
ei_encode_tuple_header(msgbuf,&index,5); /* 2 */
ei_encode_long(msgbuf,&index,ERL_EXIT_TT); /* 2 */
}
else {
ei_encode_tuple_header(msgbuf,&index,4);
ei_encode_long(msgbuf,&index,ERL_EXIT);
}
ei_encode_pid(msgbuf,&index,from); /* 268 */
ei_encode_pid(msgbuf,&index,to); /* 268 */
if (token) ei_encode_trace(msgbuf,&index,token); /* 534 */
/* Reason */
ei_encode_string(msgbuf,&index,reason); /* len */
/* 5 byte header missing */
s = msgbuf;
put32be(s, index - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/*** sum: len + 1080 */
/* FIXME incorrect level */
if (ei_tracelevel > 1)
ei_show_sendmsg(stderr,msgbuf,NULL);
ei_write_fill_t(fd,msgbuf,index,ms);
/* FIXME ignore timeout etc? erl_errno?! */
if (dbuf) free(dbuf);
return 0;
}
int ei_encode_trace(char *buf, int *index, const erlang_trace *p)
{
/* { Flags, Label, Serial, FromPid, Prev } */
ei_encode_tuple_header(buf,index,5);
ei_encode_long(buf,index,p->flags);
ei_encode_long(buf,index,p->label);
ei_encode_long(buf,index,p->serial);
ei_encode_pid(buf,index,&p->from);
ei_encode_long(buf,index,p->prev);
/* index is updated by the functions we called */
return 0;
}
/* this sends either link or unlink ('which' decides) */
static int link_unlink(int fd, const erlang_pid *from, const erlang_pid *to,
int which, unsigned ms)
{
char msgbuf[EISMALLBUF];
char *s;
int index = 0;
int n;
index = 5; /* max sizes: */
ei_encode_version(msgbuf,&index); /* 1 */
ei_encode_tuple_header(msgbuf,&index,3);
ei_encode_long(msgbuf,&index,which);
ei_encode_pid(msgbuf,&index,from); /* 268 */
ei_encode_pid(msgbuf,&index,to); /* 268 */
/* 5 byte header missing */
s = msgbuf;
put32be(s, index - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/* sum: 542 */
#ifdef DEBUG_DIST
if (ei_trace_distribution > 1) ei_show_sendmsg(stderr,msgbuf,NULL);
#endif
n = ei_write_fill_t(fd,msgbuf,index,ms);
return (n==index ? 0 : -1);
}
void ei_link(listener_t *listener, erlang_pid * from, erlang_pid * to)
{
char msgbuf[2048];
char *s;
int index = 0;
index = 5; /* max sizes: */
ei_encode_version(msgbuf, &index); /* 1 */
ei_encode_tuple_header(msgbuf, &index, 3);
ei_encode_long(msgbuf, &index, ERL_LINK);
ei_encode_pid(msgbuf, &index, from); /* 268 */
ei_encode_pid(msgbuf, &index, to); /* 268 */
/* 5 byte header missing */
s = msgbuf;
put32be(s, index - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/* sum: 542 */
switch_mutex_lock(listener->sock_mutex);
#ifdef WIN32
send(listener->sockfd, msgbuf, index, 0);
#else
if (write(listener->sockfd, msgbuf, index) == -1) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to link to process on %s\n", listener->peer_nodename);
}
#endif
switch_mutex_unlock(listener->sock_mutex);
}
void ei_link(listener_t *listener, erlang_pid * from, erlang_pid * to)
{
char msgbuf[2048];
char *s;
int index = 0;
switch_socket_t *sock = NULL;
switch_os_sock_put(&sock, &listener->sockdes, listener->pool);
index = 5; /* max sizes: */
ei_encode_version(msgbuf, &index); /* 1 */
ei_encode_tuple_header(msgbuf, &index, 3);
ei_encode_long(msgbuf, &index, ERL_LINK);
ei_encode_pid(msgbuf, &index, from); /* 268 */
ei_encode_pid(msgbuf, &index, to); /* 268 */
/* 5 byte header missing */
s = msgbuf;
put32be(s, index - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/* sum: 542 */
switch_mutex_lock(listener->sock_mutex);
if (switch_socket_send(sock, msgbuf, (switch_size_t *) &index)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to link to process on %s\n", listener->peer_nodename);
}
switch_mutex_unlock(listener->sock_mutex);
}
void ei_link(listener_t *listener, erlang_pid * from, erlang_pid * to)
{
char msgbuf[2048];
char *s;
int index = 0;
int ret;
index = 5; /* max sizes: */
ei_encode_version(msgbuf, &index); /* 1 */
ei_encode_tuple_header(msgbuf, &index, 3);
ei_encode_long(msgbuf, &index, ERL_LINK);
ei_encode_pid(msgbuf, &index, from); /* 268 */
ei_encode_pid(msgbuf, &index, to); /* 268 */
/* 5 byte header missing */
s = msgbuf;
put32be(s, index - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/* sum: 542 */
switch_mutex_lock(listener->sock_mutex);
#ifdef WIN32
ret = send(listener->sockfd, msgbuf, index, 0);
#else
ret = write(listener->sockfd, msgbuf, index);
#endif
switch_mutex_unlock(listener->sock_mutex);
}
static void handle_configuration(const char *req, int *req_index)
{
char resp[256];
int resp_index = sizeof(uint16_t); // Space for payload size
resp[resp_index++] = response_id;
ei_encode_version(resp, &resp_index);
ei_encode_list_header(resp, &resp_index, 5);
ei_encode_tuple_header(resp, &resp_index, 2);
ei_encode_atom(resp, &resp_index, "speed");
ei_encode_long(resp, &resp_index, current_config.speed);
ei_encode_tuple_header(resp, &resp_index, 2);
ei_encode_atom(resp, &resp_index, "data_bits");
ei_encode_long(resp, &resp_index, current_config.data_bits);
ei_encode_tuple_header(resp, &resp_index, 2);
ei_encode_atom(resp, &resp_index, "stop_bits");
ei_encode_long(resp, &resp_index, current_config.stop_bits);
ei_encode_tuple_header(resp, &resp_index, 2);
ei_encode_atom(resp, &resp_index, "parity");
switch (current_config.parity) {
default:
case UART_PARITY_NONE: ei_encode_atom(resp, &resp_index, "none"); break;
case UART_PARITY_EVEN: ei_encode_atom(resp, &resp_index, "even"); break;
case UART_PARITY_ODD: ei_encode_atom(resp, &resp_index, "odd"); break;
case UART_PARITY_SPACE: ei_encode_atom(resp, &resp_index, "space"); break;
case UART_PARITY_MARK: ei_encode_atom(resp, &resp_index, "mark"); break;
case UART_PARITY_IGNORE: ei_encode_atom(resp, &resp_index, "ignore"); break;
}
ei_encode_tuple_header(resp, &resp_index, 2);
ei_encode_atom(resp, &resp_index, "flow_control");
switch (current_config.parity) {
default:
case UART_FLOWCONTROL_NONE: ei_encode_atom(resp, &resp_index, "none"); break;
case UART_FLOWCONTROL_HARDWARE: ei_encode_atom(resp, &resp_index, "hardware"); break;
case UART_FLOWCONTROL_SOFTWARE: ei_encode_atom(resp, &resp_index, "software"); break;
}
ei_encode_empty_list(resp, &resp_index);
erlcmd_send(resp, resp_index);
}
/*!
* Return statistics (amount of calls) for the driver and the currently active
* thread. This function does not send any arguments to the driver.
*
* \param[in] req Request
* \param[in,out] res Result
* \param[in,out] drv_state Driver state
* \param[in,out] trd_state Thread state
*/
static void
handle_stats(gd_req_t *req, gd_res_t *res, gdt_drv_t *drv, gdt_trd_t *trd) {
/* Encode return tuple header */
ei_encode_tuple_header(res->buf, &res->index, 2);
ei_encode_atom(res->buf, &res->index, "ok");
/* Encode proplist header */
ei_encode_list_header(res->buf, &res->index, 2);
/* Encode driver calls */
ei_encode_tuple_header(res->buf, &res->index, 2);
ei_encode_atom(res->buf, &res->index, "driver");
ei_encode_long(res->buf, &res->index, drv->count++);
/* Encode thread calls */
ei_encode_tuple_header(res->buf, &res->index, 2);
ei_encode_atom(res->buf, &res->index, "thread");
ei_encode_long(res->buf, &res->index, trd->count++);
/* Encode empty list at the end */
ei_encode_empty_list(res->buf, &res->index);
}
int push(int index, const QVariant & v)
{
switch (v.type())
{
case QMetaType::Int:
ei_encode_long(_buf, &index, v.toInt());
break;
case QMetaType::Double:
ei_encode_double(_buf, &index, v.toDouble());
break;
case QMetaType::QString:
ei_encode_string(_buf, &index, qPrintable(v.toString()));
break;
default:
qWarning("can't cast QVariant to term");
}
return index;
}
static int mn_send_write(int fd, erlang_pid *mnesia, const char *key, ei_reg_obj *obj)
{
char sbuf[EISMALLBUF];
char *dbuf = NULL;
char *msgbuf;
int index = 0;
int keylen = strlen(key) + 1;
int len = 32 + keylen + obj->size;
if (len > EISMALLBUF)
if (!(dbuf = malloc(len)))
return -1;
msgbuf = (dbuf ? dbuf : sbuf);
ei_encode_version(msgbuf,&index);
ei_encode_tuple_header(msgbuf,&index,6);
ei_encode_atom(msgbuf,&index,EI_MNESIA_WRITE);
ei_encode_string(msgbuf,&index,key);
ei_encode_long(msgbuf,&index,keylen);
ei_encode_long(msgbuf,&index,obj->attr);
ei_encode_long(msgbuf,&index,obj->size);
switch (ei_reg_typeof(obj)) {
case EI_INT:
ei_encode_long(msgbuf,&index,obj->val.i);
break;
case EI_FLT:
ei_encode_double(msgbuf,&index,obj->val.f);
break;
case EI_STR:
if (obj->size > 0) ei_encode_string(msgbuf,&index,obj->val.s);
else ei_encode_long(msgbuf,&index, (long)NULL); /* just the NULL pointer */
break;
case EI_BIN:
if (obj->size > 0) ei_encode_binary(msgbuf,&index,obj->val.p,obj->size);
else ei_encode_long(msgbuf,&index,(long)(obj->val.p)); /* just the pointer */
break;
default:
if (dbuf) free(dbuf);
return -1;
}
/* send it */
if (ei_send_encoded(fd,mnesia,msgbuf,index)) {
if (dbuf) free(dbuf);
return -1;
}
if (dbuf) free(dbuf);
return 0;
}
int oe_ei_encode_long(CORBA_Environment *ev, long p) {
int size = ev->_iout + __OE_LONGSZ__;
if (size >= ev->_outbufsz) {
char *buf = ev->_outbuf;
int bufsz = ev->_outbufsz + ev->_memchunk;
if ((buf = realloc(buf,bufsz)) != NULL) {
ev->_outbuf = buf;
ev->_outbufsz += ev->_memchunk;
}
else {
CORBA_exc_set(ev, CORBA_SYSTEM_EXCEPTION, NO_MEMORY, "End of heap memory while encoding");
return -1; /* OUT OF MEMORY */
}
}
return ei_encode_long(ev->_outbuf, &ev->_iout, p);
}
void ei_link(ei_node_t *ei_node, erlang_pid * from, erlang_pid * to) {
char msgbuf[2048];
char *s;
int index = 0;
index = 5; /* max sizes: */
ei_encode_version(msgbuf, &index); /* 1 */
ei_encode_tuple_header(msgbuf, &index, 3);
ei_encode_long(msgbuf, &index, ERL_LINK);
ei_encode_pid(msgbuf, &index, from); /* 268 */
ei_encode_pid(msgbuf, &index, to); /* 268 */
/* 5 byte header missing */
s = msgbuf;
put32be(s, index - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/* sum: 542 */
if (write(ei_node->nodefd, msgbuf, index) == -1) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to link to process on %s\n", ei_node->peer_nodename);
}
}
int main(void)
#endif
{
ErlConnect conp;
Erl_IpAddr thisipaddr = (Erl_IpAddr)0;
FILE *fp = (FILE *)0;
char* charp = "foo";
double *doublep = NULL;
double doublex = 0.0;
ei_cnode xec;
ei_reg *ei_regp = NULL;
ei_term eterm;
ei_x_buff eix;
erlang_big *bigp = NULL;
erlang_fun efun;
erlang_msg *msgp = NULL;
erlang_msg emsg;
erlang_pid *pidp = NULL;
erlang_pid epid;
erlang_port eport;
erlang_ref eref;
erlang_trace etrace;
int *intp = NULL;
int intx = 0;
long *longp = NULL;
long longx = 0;
short creation = 0;
struct ei_reg_stat *ei_reg_statp = NULL;
struct ei_reg_tabstat *ei_reg_tabstatp = NULL;
struct hostent *hostp = NULL;
unsigned char * ucharp = (unsigned char *)"foo";
unsigned long *ulongp = NULL;
unsigned long ulongx = 0;
void *voidp = NULL;
#ifndef VXWORKS
EI_LONGLONG *longlongp = (EI_LONGLONG*)NULL;
EI_LONGLONG longlongx = 0;
EI_ULONGLONG *ulonglongp = (EI_ULONGLONG*)NULL;
EI_ULONGLONG ulonglongx = 0;
#endif
enum erlang_char_encoding enc;
intx = erl_errno;
ei_connect_init(&xec, charp, charp, creation);
ei_connect_xinit (&xec, charp, charp, charp, thisipaddr, charp, creation);
ei_connect(&xec, charp);
ei_xconnect (&xec, thisipaddr, charp);
ei_receive(intx, ucharp, intx);
ei_receive_msg(intx, &emsg, &eix);
ei_xreceive_msg(intx, &emsg, &eix);
ei_send(intx, &epid, charp, intx);
ei_reg_send(&xec, intx, charp, charp, intx);
ei_rpc(&xec, intx, charp, charp, charp, intx, &eix);
ei_rpc_to(&xec, intx, charp, charp, charp, intx);
ei_rpc_from(&xec, intx, intx, &emsg, &eix);
ei_publish(&xec, intx);
ei_accept(&xec, intx, &conp);
ei_unpublish(&xec);
ei_thisnodename(&xec);
ei_thishostname(&xec);
ei_thisalivename(&xec);
ei_self(&xec);
ei_gethostbyname(charp);
ei_gethostbyaddr(charp, intx, intx);
ei_gethostbyname_r(charp, hostp, charp, intx, intp);
ei_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
ei_encode_version(charp, intp);
ei_x_encode_version(&eix);
ei_encode_long(charp, intp, longx);
ei_x_encode_long(&eix, longx);
ei_encode_ulong(charp, intp, ulongx);
ei_x_encode_ulong(&eix, ulongx);
ei_encode_double(charp, intp, doublex);
ei_x_encode_double(&eix, doublex);
ei_encode_boolean(charp, intp, intx);
ei_x_encode_boolean(&eix, intx);
ei_encode_char(charp, intp, 'a');
ei_x_encode_char(&eix, 'a');
ei_encode_string(charp, intp, charp);
ei_encode_string_len(charp, intp, charp, intx);
ei_x_encode_string(&eix, charp);
ei_x_encode_string_len(&eix, charp, intx);
ei_encode_atom(charp, intp, charp);
ei_encode_atom_as(charp, intp, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_atom_len(charp, intp, charp, intx);
ei_encode_atom_len_as(charp, intp, charp, intx, ERLANG_ASCII, ERLANG_LATIN1);
ei_x_encode_atom(&eix, charp);
ei_x_encode_atom_as(&eix, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_x_encode_atom_len(&eix, charp, intx);
ei_x_encode_atom_len_as(&eix, charp, intx, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_binary(charp, intp, (void *)0, longx);
ei_x_encode_binary(&eix, (void*)0, intx);
ei_encode_pid(charp, intp, &epid);
ei_x_encode_pid(&eix, &epid);
ei_encode_fun(charp, intp, &efun);
ei_x_encode_fun(&eix, &efun);
ei_encode_port(charp, intp, &eport);
ei_x_encode_port(&eix, &eport);
ei_encode_ref(charp, intp, &eref);
ei_x_encode_ref(&eix, &eref);
ei_encode_trace(charp, intp, &etrace);
ei_x_encode_trace(&eix, &etrace);
ei_encode_tuple_header(charp, intp, intx);
ei_x_encode_tuple_header(&eix, longx);
ei_encode_list_header(charp, intp, intx);
ei_x_encode_list_header(&eix, longx);
/* #define ei_encode_empty_list(buf,i) ei_encode_list_header(buf,i,0) */
ei_x_encode_empty_list(&eix);
ei_get_type(charp, intp, intp, intp);
ei_get_type_internal(charp, intp, intp, intp);
ei_decode_version(charp, intp, intp);
ei_decode_long(charp, intp, longp);
ei_decode_ulong(charp, intp, ulongp);
ei_decode_double(charp, intp, doublep);
ei_decode_boolean(charp, intp, intp);
ei_decode_char(charp, intp, charp);
ei_decode_string(charp, intp, charp);
ei_decode_atom(charp, intp, charp);
ei_decode_atom_as(charp, intp, charp, MAXATOMLEN_UTF8, ERLANG_WHATEVER, &enc, &enc);
ei_decode_binary(charp, intp, (void *)0, longp);
ei_decode_fun(charp, intp, &efun);
free_fun(&efun);
ei_decode_pid(charp, intp, &epid);
ei_decode_port(charp, intp, &eport);
ei_decode_ref(charp, intp, &eref);
ei_decode_trace(charp, intp, &etrace);
ei_decode_tuple_header(charp, intp, intp);
ei_decode_list_header(charp, intp, intp);
ei_decode_ei_term(charp, intp, &eterm);
ei_print_term(fp, charp, intp);
ei_s_print_term(&charp, charp, intp);
ei_x_format(&eix, charp);
ei_x_format_wo_ver(&eix, charp);
ei_x_new(&eix);
ei_x_new_with_version(&eix);
ei_x_free(&eix);
ei_x_append(&eix, &eix);
ei_x_append_buf(&eix, charp, intx);
ei_skip_term(charp, intp);
ei_reg_open(intx);
ei_reg_resize(ei_regp, intx);
ei_reg_close(ei_regp);
ei_reg_setival(ei_regp, charp, longx);
ei_reg_setfval(ei_regp, charp, doublex);
ei_reg_setsval(ei_regp, charp, charp);
ei_reg_setpval(ei_regp, charp, voidp, intx);
ei_reg_setval(ei_regp, charp, intx);
ei_reg_getival(ei_regp, charp);
ei_reg_getfval(ei_regp, charp);
ei_reg_getsval(ei_regp, charp);
ei_reg_getpval(ei_regp, charp, intp);
ei_reg_getval(ei_regp, charp, intx);
ei_reg_markdirty(ei_regp, charp);
ei_reg_delete(ei_regp, charp);
ei_reg_stat(ei_regp, charp, ei_reg_statp);
ei_reg_tabstat(ei_regp, ei_reg_tabstatp);
ei_reg_dump(intx, ei_regp, charp, intx);
ei_reg_restore(intx, ei_regp, charp);
ei_reg_purge(ei_regp);
#if defined(HAVE_GMP_H) && defined(HAVE_LIBGMP)
{
mpz_t obj;
ei_decode_bignum(charp, intp, obj);
ei_encode_bignum(charp, intp, obj);
ei_x_encode_bignum(&eix, obj);
}
#endif /* HAVE_GMP_H && HAVE_LIBGMP */
#ifndef VXWORKS
ei_decode_longlong(charp, intp, longlongp);
ei_decode_ulonglong(charp, intp, ulonglongp);
ei_encode_longlong(charp, intp, longlongx);
ei_encode_ulonglong(charp, intp, ulonglongx);
ei_x_encode_longlong(&eix, longlongx);
ei_x_encode_ulonglong(&eix, ulonglongx);
#endif
#ifdef USE_EI_UNDOCUMENTED
ei_decode_intlist(charp, intp, longp, intp);
ei_receive_encoded(intx, &charp, intp, msgp, intp);
ei_send_encoded(intx, pidp, charp, intx);
ei_send_reg_encoded(intx, pidp, charp, charp, intx);
ei_decode_big(charp, intp, bigp);
ei_big_comp(bigp, bigp);
ei_big_to_double(bigp, doublep);
ei_small_to_big(intx, bigp);
ei_alloc_big(intx);
ei_free_big(bigp);
#endif /* USE_EI_UNDOCUMENTED */
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EIO +
EI_BIN +
EI_DELET +
EI_DIRTY +
EI_FLT +
EI_FORCE +
EI_INT +
EI_NOPURGE +
EI_STR +
EMSGSIZE +
ENOMEM +
ERL_ERROR +
ERL_EXIT +
ERL_LINK +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_REG_SEND +
ERL_SEND +
ERL_TICK +
ERL_TIMEOUT +
ERL_UNLINK +
ETIMEDOUT +
MAXATOMLEN;
}
int ei_send_encoded_tmo(int fd, const erlang_pid *to,
char *msg, int msglen, unsigned ms)
{
char *s, header[1200]; /* see size calculation below */
erlang_trace *token = NULL;
int index = 5; /* reserve 5 bytes for control message */
int res;
#ifdef HAVE_WRITEV
struct iovec v[2];
#endif
/* are we tracing? */
/* check that he can receive trace tokens first */
if (ei_distversion(fd) > 0) token = ei_trace(0,NULL);
/* header = SEND, cookie, to max sizes: */
ei_encode_version(header,&index); /* 1 */
if (token) {
ei_encode_tuple_header(header,&index,4); /* 2 */
ei_encode_long(header,&index,ERL_SEND_TT); /* 2 */
} else {
ei_encode_tuple_header(header,&index,3);
ei_encode_long(header,&index,ERL_SEND);
}
ei_encode_atom(header,&index,ei_getfdcookie(fd)); /* 258 */
ei_encode_pid(header,&index,to); /* 268 */
if (token) ei_encode_trace(header,&index,token); /* 534 */
/* control message (precedes header actually) */
/* length = 1 ('p') + header len + message len */
s = header;
put32be(s, index + msglen - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/*** sum: 1070 */
if (ei_tracelevel >= 4)
ei_show_sendmsg(stderr,header,msg);
#ifdef HAVE_WRITEV
v[0].iov_base = (char *)header;
v[0].iov_len = index;
v[1].iov_base = (char *)msg;
v[1].iov_len = msglen;
if ((res = ei_writev_fill_t(fd,v,2,ms)) != index+msglen) {
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
#else /* !HAVE_WRITEV */
if ((res = ei_write_fill_t(fd,header,index,ms)) != index) {
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
if ((res = ei_write_fill_t(fd,msg,msglen,ms)) != msglen) {
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
#endif /* !HAVE_WRITEV */
return 0;
}
int ei_send_reg_encoded_tmo(int fd, const erlang_pid *from,
const char *to, char *msg, int msglen,
unsigned ms)
{
char *s, header[1400]; /* see size calculation below */
erlang_trace *token = NULL;
int index = 5; /* reserve 5 bytes for control message */
int err;
ei_socket_callbacks *cbs;
void *ctx;
ssize_t len, tot_len;
unsigned tmo = ms == 0 ? EI_SCLBK_INF_TMO : ms;
err = EI_GET_CBS_CTX__(&cbs, &ctx, fd);
if (err) {
EI_CONN_SAVE_ERRNO__(err);
return ERL_ERROR;
}
/* are we tracing? */
/* check that he can receive trace tokens first */
if (ei_distversion(fd) > 0)
token = ei_trace(0,NULL);
/* header = REG_SEND, from, cookie, toname max sizes: */
ei_encode_version(header,&index); /* 1 */
if (token) {
ei_encode_tuple_header(header,&index,5); /* 2 */
ei_encode_long(header,&index,ERL_REG_SEND_TT); /* 2 */
} else {
ei_encode_tuple_header(header,&index,4);
ei_encode_long(header,&index,ERL_REG_SEND);
}
ei_encode_pid(header, &index, from); /* 268 */
ei_encode_atom(header, &index, ei_getfdcookie(fd)); /* 258 */
ei_encode_atom(header, &index, to); /* 268 */
if (token) ei_encode_trace(header,&index,token); /* 534 */
/* control message (precedes header actually) */
/* length = 1 ('p') + header len + message len */
s = header;
put32be(s, index + msglen - 4); /* 4 */
put8(s, ERL_PASS_THROUGH); /* 1 */
/*** sum: 1336 */
if (ei_tracelevel >= 4)
ei_show_sendmsg(stderr,header,msg);
#ifdef EI_HAVE_STRUCT_IOVEC__
if (ei_socket_callbacks_have_writev__(cbs)) {
struct iovec v[2];
v[0].iov_base = (char *)header;
v[0].iov_len = index;
v[1].iov_base = (char *)msg;
v[1].iov_len = msglen;
len = tot_len = (ssize_t) index+msglen;
err = ei_writev_fill_ctx_t__(cbs, ctx, v, 2, &len, tmo);
if (!err && len != tot_len)
err = EIO;
if (err) {
EI_CONN_SAVE_ERRNO__(err);
return -1;
}
return 0;
}
#endif /* EI_HAVE_STRUCT_IOVEC__ */
/* no writev() */
len = tot_len = (ssize_t) index;
err = ei_write_fill_ctx_t__(cbs, ctx, header, &len, tmo);
if (!err && len != tot_len)
err = EIO;
if (err) {
EI_CONN_SAVE_ERRNO__(err);
return -1;
}
len = tot_len = (ssize_t) msglen;
err = ei_write_fill_ctx_t__(cbs, ctx, msg, &len, tmo);
if (!err && len != tot_len)
err = EIO;
if (err) {
EI_CONN_SAVE_ERRNO__(err);
return -1;
}
return 0;
}
int ei_encode_fun(char *buf, int *index, const erlang_fun *p)
{
int ix = *index;
switch (p->type) {
case EI_FUN_CLOSURE:
if (p->arity == -1) {
/* ERL_FUN_EXT */
if (buf != NULL) {
char* s = buf + ix;
put8(s, ERL_FUN_EXT);
put32be(s, p->u.closure.n_free_vars);
}
ix += sizeof(char) + 4;
if (ei_encode_pid(buf, &ix, &p->u.closure.pid) < 0)
return -1;
if (ei_encode_atom_as(buf, &ix, p->module, ERLANG_UTF8, ERLANG_UTF8) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->u.closure.index) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->u.closure.uniq) < 0)
return -1;
if (buf != NULL)
memcpy(buf + ix, p->u.closure.free_vars, p->u.closure.free_var_len);
ix += p->u.closure.free_var_len;
} else {
char *size_p;
if (buf != NULL) {
char* s = buf + ix;
put8(s, ERL_NEW_FUN_EXT);
size_p = s;
s += 4;
put8(s, p->arity);
memcpy(s, p->u.closure.md5, sizeof(p->u.closure.md5));
s += sizeof(p->u.closure.md5);
put32be(s, p->u.closure.index);
put32be(s, p->u.closure.n_free_vars);
} else
size_p = NULL;
ix += 1 + 4 + 1 + sizeof(p->u.closure.md5) + 4 + 4;
if (ei_encode_atom_as(buf, &ix, p->module, ERLANG_UTF8, ERLANG_UTF8) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->u.closure.old_index) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->u.closure.uniq) < 0)
return -1;
if (ei_encode_pid(buf, &ix, &p->u.closure.pid) < 0)
return -1;
if (buf != NULL)
memcpy(buf + ix, p->u.closure.free_vars, p->u.closure.free_var_len);
ix += p->u.closure.free_var_len;
if (size_p != NULL) {
int sz = buf + ix - size_p;
put32be(size_p, sz);
}
}
break;
case EI_FUN_EXPORT:
if (buf != NULL) {
char* s = buf + ix;
put8(s, ERL_EXPORT_EXT);
}
ix++;
if (ei_encode_atom_as(buf, &ix, p->module, ERLANG_UTF8, ERLANG_UTF8) < 0)
return -1;
if (ei_encode_atom_as(buf, &ix, p->u.exprt.func, ERLANG_UTF8, ERLANG_UTF8) < 0)
return -1;
if (ei_encode_long(buf, &ix, p->arity) < 0)
return -1;
break;
}
*index = ix;
return 0;
}
static ErlDrvSSizeT call(ErlDrvData edd, unsigned int cmd, char *buf,
ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen,
unsigned int *flags) {
dnssd_drv_t* dd = (dnssd_drv_t*) edd;
int version, out_len, index, rindex, local_only;
DNSServiceErrorType err;
char* out_atom_text;
ei_term arg, name, type, domain, txt, host, hostport;
char *name_tmp, *type_tmp, *domain_tmp, *txt_tmp, *host_tmp;
/* don't allow reuse */
if (dd->sd_ref) return -1;
index = 0;
dd->sd_ref = NULL;
ei_decode_version(buf, &index, &version);
ei_decode_ei_term(buf, &index, &arg);
if (cmd == DNSSD_CMD_ENUM) {
if (arg.ei_type == ERL_ATOM_EXT) {
if (strncmp(arg.value.atom_name, "browse", 6) == 0) {
// init for enum browse
err = DNSServiceEnumerateDomains(&dd->sd_ref,
kDNSServiceFlagsBrowseDomains,
kDNSServiceInterfaceIndexAny,
(DNSServiceDomainEnumReply) EnumReply,
dd);
} else if (strncmp(arg.value.atom_name,"reg", 3) == 0) {
// init for enum reg
err = DNSServiceEnumerateDomains(&dd->sd_ref,
kDNSServiceFlagsRegistrationDomains,
kDNSServiceInterfaceIndexAny,
(DNSServiceDomainEnumReply) EnumReply,
dd);
} else {
goto badarg;
}
} else {
goto badarg;
}
} else if (cmd == DNSSD_CMD_BROWSE) {
if (!arg.ei_type == ERL_TUPLE || arg.arity != 2) goto badarg;
/* decode type */
ei_decode_ei_term(buf, &index, &type);
if (type.ei_type != ERL_BINARY_EXT) goto badarg;
index += 5; // skip tag + 4 byte size
type_tmp = (char*)driver_alloc(type.size + 1);
memset(type_tmp, 0, type.size + 1);
memcpy(type_tmp, buf + index, type.size);
index += type.size;
/* decode domain */
ei_decode_ei_term(buf, &index, &domain);
if (domain.ei_type != ERL_BINARY_EXT) {
driver_free(type_tmp);
goto badarg;
}
index += 5; // skip tag + 4 byte size
domain_tmp = (char *) driver_alloc(domain.size + 1);
memset(domain_tmp, 0, domain.size + 1);
memcpy(domain_tmp, buf + index, domain.size);
err = DNSServiceBrowse(&dd->sd_ref,
0, // Flags
kDNSServiceInterfaceIndexAny,
type_tmp,
domain_tmp,
(DNSServiceBrowseReply) BrowseReply,
dd);
driver_free(type_tmp);
driver_free(domain_tmp);
} else if (cmd == DNSSD_CMD_RESOLVE) {
if (!arg.ei_type == ERL_TUPLE || arg.arity != 3) goto badarg;
/* decode name */
ei_decode_ei_term(buf, &index, &name);
if (name.ei_type != ERL_BINARY_EXT) goto badarg;
index += 5; // skip tag + 4 byte size
name_tmp = (char *) driver_alloc(name.size + 1);
memset(name_tmp, 0, name.size + 1);
memcpy(name_tmp, buf + index, name.size);
index += name.size;
/* decode type */
ei_decode_ei_term(buf, &index, &type);
if (type.ei_type != ERL_BINARY_EXT) {
driver_free(name_tmp);
goto badarg;
}
index += 5; // skip tag + 4 byte size
type_tmp = (char *) driver_alloc(type.size + 1);
memset(type_tmp, 0, type.size + 1);
memcpy(type_tmp, buf + index, type.size);
index += type.size;
/* decode domain */
ei_decode_ei_term(buf, &index, &domain);
if (domain.ei_type != ERL_BINARY_EXT) {
driver_free(name_tmp);
driver_free(type_tmp);
goto badarg;
}
index += 5; // skip tag + 4 byte size
domain_tmp = (char *) driver_alloc(domain.size + 1);
memset(domain_tmp, 0, domain.size + 1);
memcpy(domain_tmp, buf + index, domain.size);
/* start op */
err = DNSServiceResolve(&dd->sd_ref,
0, // Flags
kDNSServiceInterfaceIndexAny,
name_tmp,
type_tmp,
domain_tmp,
(DNSServiceResolveReply) ResolveReply,
dd);
driver_free(name_tmp);
driver_free(type_tmp);
driver_free(domain_tmp);
} else if (cmd == DNSSD_CMD_REGISTER) {
if (!arg.ei_type == ERL_TUPLE || arg.arity != 6) goto badarg;
/* decode name */
ei_decode_ei_term(buf, &index, &name);
if (name.ei_type != ERL_BINARY_EXT) goto badarg;
index += 5; // skip tag + 4 byte size
name_tmp = (char *) driver_alloc(name.size + 1);
memset(name_tmp, 0, name.size + 1);
memcpy(name_tmp, buf + index, name.size);
index += name.size;
/* decode type */
ei_decode_ei_term(buf, &index, &type);
if (type.ei_type != ERL_BINARY_EXT) {
driver_free(name_tmp);
goto badarg;
}
index += 5; // skip tag + 4 byte size
type_tmp = (char *) driver_alloc(type.size + 1);
memset(type_tmp, 0, type.size + 1);
memcpy(type_tmp, buf + index, type.size);
index += type.size;
/* decode domain */
ei_decode_ei_term(buf, &index, &domain);
if (domain.ei_type != ERL_BINARY_EXT) {
driver_free(name_tmp);
driver_free(type_tmp);
goto badarg;
}
index += 5; // skip tag + 4 byte size
domain_tmp = (char *) driver_alloc(domain.size + 1);
memset(domain_tmp, 0, domain.size + 1);
memcpy(domain_tmp, buf + index, domain.size);
index += domain.size;
/* decode host */
ei_decode_ei_term(buf, &index, &host);
if (host.ei_type != ERL_BINARY_EXT) {
driver_free(name_tmp);
driver_free(type_tmp);
driver_free(domain_tmp);
goto badarg;
}
index += 5; // skip tag + 4 byte size
host_tmp = (char *) driver_alloc(host.size + 1);
memset(host_tmp, 0, host.size + 1);
memcpy(host_tmp, buf + index, host.size);
index += host.size;
/* decode port */
ei_decode_ei_term(buf, &index, &hostport);
if (hostport.ei_type != ERL_INTEGER_EXT &&
hostport.ei_type != ERL_SMALL_INTEGER_EXT) {
driver_free(name_tmp);
driver_free(type_tmp);
driver_free(domain_tmp);
driver_free(host_tmp);
goto badarg;
}
/* decode txt */
ei_decode_ei_term(buf, &index, &txt);
if (txt.ei_type != ERL_BINARY_EXT) {
driver_free(name_tmp);
driver_free(type_tmp);
driver_free(domain_tmp);
driver_free(host_tmp);
goto badarg;
}
index += 5; // skip tag + 4 byte size
txt_tmp = (char *) driver_alloc(txt.size + 1);
memset(txt_tmp, 0, txt.size + 1);
memcpy(txt_tmp, buf + index, txt.size);
local_only = (0 == strcmp("localhost", host_tmp));
err = DNSServiceRegister(&dd->sd_ref,
0, // Flags
local_only ? -1 : 0, // Interface: local / any
name_tmp,
type_tmp,
local_only ? "local" : domain_tmp,
host_tmp,
htons(hostport.value.i_val),
txt.size,
txt_tmp,
(DNSServiceRegisterReply) RegisterReply,
dd);
driver_free(name_tmp);
driver_free(type_tmp);
driver_free(domain_tmp);
driver_free(host_tmp);
driver_free(txt_tmp);
} else {
goto badarg;
}
rindex = 0;
out_len = 0;
ei_encode_version(NULL, &out_len);
if (err == kDNSServiceErr_NoError) {
#ifdef __WIN32__
dd->event = WSACreateEvent();
WSAEventSelect(DNSServiceRefSockFD(dd->sd_ref), dd->event, FD_READ);
driver_select(dd->erl_port, dd->event, ERL_DRV_READ, 1);
#else
driver_select(dd->erl_port,
(ErlDrvEvent)(size_t) DNSServiceRefSockFD(dd->sd_ref),
ERL_DRV_READ,
1);
#endif
out_atom_text = "ok";
ei_encode_atom(NULL, &out_len, out_atom_text);
if(rlen < out_len) {
*rbuf = driver_alloc(out_len);
rlen = out_len;
}
ei_encode_version(*rbuf, &rindex);
ei_encode_atom(*rbuf, &rindex, out_atom_text);
return out_len;
} else {
out_atom_text = "error";
ei_encode_tuple_header(NULL, &out_len, 2);
ei_encode_atom(NULL, &out_len, out_atom_text);
ei_encode_long(NULL, &out_len, 1337);
if(rlen < out_len) {
*rbuf = driver_alloc(out_len);
rlen = out_len;
}
ei_encode_version(*rbuf, &rindex);
ei_encode_tuple_header(*rbuf, &rindex, 2);
ei_encode_atom(*rbuf, &rindex, out_atom_text);
ei_encode_long(*rbuf, &rindex, (long) err);
return out_len;
}
badarg:
return -1;
}
