/*
* Now returns non-negative number for success, negative for failure.
*/
int ei_rpc_to(ei_cnode *ec, int fd, char *mod, char *fun,
const char *buf, int len)
{
ei_x_buff x;
erlang_pid *self = ei_self(ec);
self->num = fd;
/* encode header */
ei_x_new_with_version(&x);
ei_x_encode_tuple_header(&x, 2); /* A */
self->num = fd;
ei_x_encode_pid(&x, self); /* A 1 */
ei_x_encode_tuple_header(&x, 5); /* B A 2 */
ei_x_encode_atom(&x, "call"); /* B 1 */
ei_x_encode_atom(&x, mod); /* B 2 */
ei_x_encode_atom(&x, fun); /* B 3 */
ei_x_append_buf(&x, buf, len); /* B 4 */
ei_x_encode_atom(&x, "user"); /* B 5 */
/* ei_x_encode_atom(&x,"user"); */
ei_send_reg_encoded(fd, self, "rex", x.buff, x.index);
ei_x_free(&x);
return 0;
} /* rpc_to */
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;
}
/* Client send message (Erlang distribution protocol) */
static int oe_send(CORBA_Environment *env)
{
if (strlen(env->_regname) == 0) {
if (ei_send_encoded(env->_fd, env->_to_pid, env->_outbuf,
env->_iout) < 0) {
/* XXX Cannot send to peer? */
CORBA_exc_set(env, CORBA_SYSTEM_EXCEPTION, NO_RESPONSE,
"Cannot connect to server");
return -1;
}
} else {
if (ei_send_reg_encoded(env->_fd, env->_from_pid,
env->_regname, env->_outbuf,
env->_iout) < 0) {
/* XXX Cannot send to peer? */
CORBA_exc_set(env, CORBA_SYSTEM_EXCEPTION, NO_RESPONSE,
"Cannot connect to server");
return -1;
}
}
return 0;
}
int erl_global_register(int fd, const char *name, ETERM *pid)
{
char buf[EISMALLBUF];
char *bufp=buf;
char tmpbuf[64];
int index = 0;
erlang_pid self;
erlang_msg msg;
int needlink, needatom, needmonitor;
int arity;
int version;
int msglen;
int i;
/* get that pid into a better format */
if (!erl_encode(pid,(unsigned char*)buf)) return -1;
if (ei_decode_version(buf,&index,&version)
|| ei_decode_pid(buf,&index,&self)) return -1;
/* set up rpc arguments */
/* { PidFrom, { call, Mod, Fun, Args, user }} */
index = 0;
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,"register_name_external"); /* Fun */
ei_encode_list_header(buf,&index,3); /* Args: [ name, self(), cnode ] */
ei_encode_atom(buf,&index,name);
ei_encode_pid(buf,&index,&self);
ei_encode_tuple_header(buf,&index,2);
ei_encode_atom(buf,&index,"global"); /* special "resolve" treatment */
ei_encode_atom(buf,&index,"cnode"); /* i.e. we get a SEND when conflict */
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 -1;
/* get the reply: expect link and an atom, or just an atom */
needlink = needatom = needmonitor = 1;
while (1) {
/* get message */
while (1) {
index = EISMALLBUF;
if (!(i = ei_recv_internal(fd,&bufp,&index,&msg,&msglen,1,0))) continue;
else break;
}
switch (i) {
case ERL_LINK:
/* got link */
if (!needlink) return -1;
needlink = 0;
break;
case ERL_MONITOR_P-10:
/* got monitor */
if (!needmonitor) { return -1;}
needmonitor = 0;
break;
case ERL_SEND:
/* got message - does it contain our atom? */
if (!needatom) return -1;
else {
/* expecting { rex, yes } */
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_atom(buf,&index,tmpbuf)
|| strcmp(tmpbuf,"yes"))
return -1; /* bad response from other side */
/* we're done */
return 0;
}
break;
default:
return -1; /* something else */
}
}
return 0;
}
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;
}
static int mn_start_restore(int fd, const erlang_pid *self, erlang_pid *mnesia, const char *mntab, long *count, long *maxkey,long *maxobj)
{
char buf[EISMALLBUF];
char *bufp=buf;
char tmpbuf[64];
int index = 0;
erlang_msg msg;
int arity;
int version;
int i;
int needlink;
int needmsg;
int msglen;
/* set up rpc arguments */
/* { PidFrom, { call, Mod, Fun, Args, user }} */
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,EI_MNESIA_MODULE); /* Mod */
ei_encode_atom(buf,&index,EI_MNESIA_RESTORE); /* Fun */
ei_encode_list_header(buf,&index,2); /* Args: [ table, self() ] */
ei_encode_atom(buf,&index,mntab);
ei_encode_pid(buf,&index,self);
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 -1;
/* get the reply: expect link and message (not sure which will come first though) */
needlink = needmsg = 1;
while (needlink || needmsg) {
/* get message */
index = EISMALLBUF;
while (!(i = ei_recv_internal(fd,&bufp,&index,&msg,&msglen,1,0))) index = EISMALLBUF;
switch (i) {
case ERL_LINK:
/* got link */
if (!needlink) return -1;
needlink = 0;
break;
case ERL_SEND:
/* got message - is it the right one? */
if (!needmsg) return -1;
else {
/* expecting { rex, { size, Pid, Count, MaxKey, MaxObj }} */
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_tuple_header(buf,&index,&arity)
|| (arity != 5)
|| ei_decode_atom(buf,&index,tmpbuf)
|| strcmp(tmpbuf,EI_MNESIA_SIZE)
|| ei_decode_pid(buf,&index,mnesia)
|| ei_decode_long(buf,&index,count)
|| ei_decode_long(buf,&index,maxkey)
|| ei_decode_long(buf,&index,maxobj))
return -1; /* bad response from other side */
/* got msg */
needmsg = 0;
}
break;
default:
return -1; /* wasn't link or pid */
}
}
return 0;
}
static int mn_start_dump(int fd, const erlang_pid *self,
erlang_pid *mnesia, const char *mntab)
{
char buf[EISMALLBUF];
char *bufp = buf;
char tmpbuf[64];
int index = 0;
erlang_msg msg;
int type;
int arity;
int version;
int msglen;
int i;
int needlink;
int needpid;
/* set up rpc arguments */
/* { PidFrom, { call, Mod, Fun, Args, user }} */
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,EI_MNESIA_MODULE); /* Mod */
ei_encode_atom(buf,&index,EI_MNESIA_DUMP); /* Fun */
ei_encode_list_header(buf,&index,2); /* Args: [ table, self() ] */
ei_encode_atom(buf,&index,mntab);
ei_encode_pid(buf,&index,self);
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 -1;
/* get the reply: expect link and pid (not sure which will come first though) */
needlink = needpid = 1;
while (needlink || needpid) {
/* get message */
while (1) {
index = EISMALLBUF;
if (!(i = ei_recv_internal(fd,&bufp,&index,&msg,&msglen,1,0))) continue;
else break;
}
switch (i) {
case ERL_LINK:
/* got link */
if (!needlink) return -1;
needlink = 0;
break;
case ERL_SEND:
/* got message - does it contain a pid? */
if (!needpid) return -1;
else {
/* 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_get_type_internal(buf,&index,&type,&arity)
|| (type != ERL_PID_EXT))
return -1; /* bad response from other side */
if (ei_decode_pid(buf,&index,mnesia)) return -1;
/* got pid */
needpid = 0;
}
break;
default:
return -1; /* wasn't link or pid */
}
}
return 0;
}
/* global:unregister_name(name) -> ok */
int erl_global_unregister(int fd, const char *name)
{
char buf[EISMALLBUF];
char *bufp=buf;
char tmpbuf[64];
int index = 0;
erlang_pid *self = erl_self();
erlang_msg msg;
int i;
int version,arity,msglen;
int needunlink, needatom, needdemonitor;
/* make a self pid */
self->num = fd;
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,"unregister_name_external"); /* 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 -1;
/* get the reply: expect unlink and an atom, or just an atom */
needunlink = needatom = needdemonitor = 1;
while (1) {
/* get message */
while (1) {
index = EISMALLBUF;
if (!(i = ei_recv_internal(fd,&bufp,&index,&msg,&msglen,1,0))) continue;
else break;
}
switch (i) {
case ERL_UNLINK:
/* got unlink */
if (!needunlink) return -1;
needunlink = 0;
break;
case ERL_DEMONITOR_P-10:
/* got demonitor */
if (!needdemonitor) return -1;
needdemonitor = 0;
break;
case ERL_SEND:
/* got message - does it contain our atom? */
if (!needatom) return -1;
else {
/* expecting { rex, ok } */
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_atom(buf,&index,tmpbuf)
|| strcmp(tmpbuf,"ok"))
return -1; /* bad response from other side */
/* we're done here */
return 0;
}
break;
default:
return -1;
}
}
return 0;
}
