/* 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_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_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;
}
/* length (4), PASS_THOUGH (1), header, message */
int
ei_recv_internal (int fd,
char **mbufp, int *bufsz,
erlang_msg *msg, int *msglenp,
int staticbufp, unsigned ms)
{
char header[EIRECVBUF];
char *s=header;
char *mbuf=*mbufp;
int len = 0;
int msglen = 0;
int bytesread = 0;
int remain;
int arity;
int version;
int index = 0;
int i = 0;
int res;
int show_this_msg = 0;
/* get length field */
if ((res = ei_read_fill_t(fd, header, 4, ms)) != 4)
{
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
len = get32be(s);
/* got tick - respond and return */
if (!len) {
char tock[] = {0,0,0,0};
ei_write_fill_t(fd, tock, sizeof(tock), ms); /* Failure no problem */
*msglenp = 0;
return 0; /* maybe flag ERL_EAGAIN [sverkerw] */
}
/* turn off tracing on each receive. it will be turned back on if
* we receive a trace token.
*/
ei_trace(-1,NULL);
/* read enough to get at least entire header */
bytesread = (len > EIRECVBUF ? EIRECVBUF : len);
if ((i = ei_read_fill_t(fd,header,bytesread,ms)) != bytesread) {
erl_errno = (i == -2) ? ETIMEDOUT : EIO;
return -1;
}
/* now decode header */
/* pass-through, version, control tuple header, control message type */
s = header;
index = 1;
if ((get8(s) != ERL_PASS_THROUGH)
|| ei_decode_version(header,&index,&version)
|| (version != ERL_VERSION_MAGIC)
|| ei_decode_tuple_header(header,&index,&arity)
|| ei_decode_long(header,&index,&msg->msgtype))
{
erl_errno = EIO; /* Maybe another code for decoding errors */
return -1;
}
switch (msg->msgtype) {
case ERL_SEND: /* { SEND, Cookie, ToPid } */
if (ei_tracelevel >= 4) show_this_msg = 1;
if (ei_decode_atom(header,&index,msg->cookie)
|| ei_decode_pid(header,&index,&msg->to))
{
erl_errno = EIO;
return -1;
}
break;
case ERL_REG_SEND: /* { REG_SEND, From, Cookie, ToName } */
if (ei_tracelevel >= 4) show_this_msg = 1;
if (ei_decode_pid(header,&index,&msg->from)
|| ei_decode_atom(header,&index,msg->cookie)
|| ei_decode_atom(header,&index,msg->toname))
{
erl_errno = EIO;
return -1;
}
/* actual message is remaining part of headerbuf, plus any unread bytes */
break;
case ERL_LINK: /* { LINK, From, To } */
case ERL_UNLINK: /* { UNLINK, From, To } */
case ERL_GROUP_LEADER: /* { GROUP_LEADER, From, To } */
if (ei_tracelevel >= 4) show_this_msg = 1;
if (ei_decode_pid(header,&index,&msg->from)
|| ei_decode_pid(header,&index,&msg->to))
{
erl_errno = EIO;
return -1;
}
break;
case ERL_EXIT: /* { EXIT, From, To, Reason } */
case ERL_EXIT2: /* { EXIT2, From, To, Reason } */
if (ei_tracelevel >= 4) show_this_msg = 1;
if (ei_decode_pid(header,&index,&msg->from)
|| ei_decode_pid(header,&index,&msg->to))
{
erl_errno = EIO;
return -1;
}
break;
case ERL_SEND_TT: /* { SEND_TT, Cookie, ToPid, TraceToken } */
if (ei_tracelevel >= 4) show_this_msg = 1;
if (ei_decode_atom(header,&index,msg->cookie)
|| ei_decode_pid(header,&index,&msg->to)
|| ei_decode_trace(header,&index,&msg->token))
{
erl_errno = EIO;
return -1;
}
ei_trace(1,&msg->token); /* turn on tracing */
break;
case ERL_REG_SEND_TT: /* { REG_SEND_TT, From, Cookie, ToName, TraceToken } */
if (ei_tracelevel >= 4) show_this_msg = 1;
if (ei_decode_pid(header,&index,&msg->from)
|| ei_decode_atom(header,&index,msg->cookie)
|| ei_decode_atom(header,&index,msg->toname)
|| ei_decode_trace(header,&index,&msg->token))
{
erl_errno = EIO;
return -1;
}
ei_trace(1,&msg->token); /* turn on tracing */
break;
case ERL_EXIT_TT: /* { EXIT_TT, From, To, TraceToken, Reason } */
case ERL_EXIT2_TT: /* { EXIT2_TT, From, To, TraceToken, Reason } */
if (ei_tracelevel >= 4) show_this_msg = 1;
if (ei_decode_pid(header,&index,&msg->from)
|| ei_decode_pid(header,&index,&msg->to)
|| ei_decode_trace(header,&index,&msg->token))
{
erl_errno = EIO;
return -1;
}
ei_trace(1,&msg->token); /* turn on tracing */
break;
case ERL_NODE_LINK: /* { NODE_LINK } */
if (ei_tracelevel >= 4) show_this_msg = 1;
break;
default:
/* unknown type, just put any remaining bytes into buffer */
break;
}
/* actual message is remaining part of headerbuf, plus any unread bytes */
msglen = len - index; /* message size (payload) */
remain = len - bytesread; /* bytes left to read */
/* if callers buffer is too small, we flush in the rest of the
* message and discard it, unless we know that we can reallocate
* the buffer in which case we do that and read the message.
*/
if (msglen > *bufsz) {
if (staticbufp) {
int sz = EIRECVBUF;
/* flush in rest of packet */
while (remain > 0) {
if (remain < sz) sz = remain;
if ((i=ei_read_fill_t(fd,header,sz,ms)) <= 0) break;
remain -= i;
}
erl_errno = EMSGSIZE;
return -1;
}
else {
/* Dynamic buffer --- grow it. */
#ifdef DEBUG
fprintf(stderr, "Growing buffer from %d bytes to %d bytes\n",
*bufsz, msglen);
#endif
if ((mbuf = realloc(*mbufp, msglen)) == NULL)
{
erl_errno = ENOMEM;
return -1;
}
*mbufp = mbuf;
*bufsz = msglen;
}
}
/* move remaining bytes to callers buffer */
memmove(mbuf,header+index,bytesread-index);
/* let the caller know how big the message is in his buffer */
*msglenp = msglen;
/* read the rest of the message into callers buffer */
if (remain > 0) {
if ((i = ei_read_fill_t(fd,mbuf+bytesread-index,remain,ms)) != remain) {
*msglenp = bytesread-index+1; /* actual bytes in users buffer */
erl_errno = (i == -2) ? ETIMEDOUT : EIO;
return -1;
}
}
if (show_this_msg)
ei_show_recmsg(stderr,msg,mbuf);
/* the caller only sees "untraced" message types */
/* the trace token is buried in the message struct */
if (msg->msgtype > 10) msg->msgtype -= 10;
return msg->msgtype;
}