int ei_x_encode_ulong(ei_x_buff* x, unsigned long n)
{
int i = x->index;
ei_encode_ulong(NULL, &i, n);
if (!x_fix_buff(x, i))
return -1;
return ei_encode_ulong(x->buff, &x->index, n);
}
static void enumerate_ports()
{
struct serial_info *port_list = find_serialports();
int port_list_len = 0;
for (struct serial_info *port = port_list;
port != NULL;
port = port->next)
port_list_len++;
debug("Found %d ports", port_list_len);
char resp[4096];
int resp_index = sizeof(uint16_t); // Space for payload size
resp[resp_index++] = response_id;
ei_encode_version(resp, &resp_index);
ei_encode_map_header(resp, &resp_index, port_list_len);
for (struct serial_info *port = port_list;
port != NULL;
port = port->next) {
ei_encode_binary(resp, &resp_index, port->name, strlen(port->name));
int info_count = (port->description ? 1 : 0) +
(port->manufacturer ? 1 : 0) +
(port->serial_number ? 1 : 0) +
(port->vid > 0 ? 1 : 0) +
(port->pid > 0 ? 1 : 0);
ei_encode_map_header(resp, &resp_index, info_count);
if (port->description) {
ei_encode_atom(resp, &resp_index, "description");
ei_encode_binary(resp, &resp_index, port->description, strlen(port->description));
}
if (port->manufacturer) {
ei_encode_atom(resp, &resp_index, "manufacturer");
ei_encode_binary(resp, &resp_index, port->manufacturer, strlen(port->manufacturer));
}
if (port->serial_number) {
ei_encode_atom(resp, &resp_index, "serial_number");
ei_encode_binary(resp, &resp_index, port->serial_number, strlen(port->serial_number));
}
if (port->vid > 0) {
ei_encode_atom(resp, &resp_index, "vendor_id");
ei_encode_ulong(resp, &resp_index, port->vid);
}
if (port->pid > 0) {
ei_encode_atom(resp, &resp_index, "product_id");
ei_encode_ulong(resp, &resp_index, port->pid);
}
}
erlcmd_send(resp, resp_index);
serial_info_free_list(port_list);
}
int oe_ei_encode_ulong(CORBA_Environment *ev, unsigned long p) {
int size = ev->_iout + __OE_ULONGSZ__;
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_ulong(ev->_outbuf, &ev->_iout, p);
}
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;
}
int32_t spawn(char protocol, uint32_t * ports, uint32_t ports_len,
char * filename, uint32_t /*filename_len*/,
char * argv, uint32_t argv_len,
char * env, uint32_t env_len)
{
int type;
if (protocol == 't') // tcp
{
type = SOCK_STREAM;
}
else if (protocol == 'u') // udp
{
type = SOCK_DGRAM;
}
else
{
return spawn_status::invalid_input;
}
int fds_stdout[2] = {-1, -1};
int fds_stderr[2] = {-1, -1};
if (::pipe(fds_stdout) == -1)
return spawn_status::errno_pipe();
if (::pipe(fds_stderr) == -1)
return spawn_status::errno_pipe();
pid_t const pid = fork();
if (pid == -1)
{
return spawn_status::errno_fork();
}
else if (pid == 0)
{
for (size_t i = 0; i < GEPD::nfds; ++i)
{
if (::close(GEPD::fds[i].fd) == -1)
::_exit(spawn_status::errno_close());
}
if (::dup2(fds_stdout[1], 1) == -1)
::_exit(spawn_status::errno_dup());
if (::close(fds_stdout[0]) == -1 || close(fds_stdout[1]) == -1)
::_exit(spawn_status::errno_close());
if (::dup2(fds_stderr[1], 2) == -1)
::_exit(spawn_status::errno_dup());
if (::close(fds_stderr[0]) == -1 || close(fds_stderr[1]) == -1)
::_exit(spawn_status::errno_close());
char pid_message[1024];
int pid_message_index = 0;
unsigned long const pid_child = ::getpid();
if (ei_encode_version(pid_message, &pid_message_index))
::_exit(GEPD::ExitStatus::ei_encode_error);
if (ei_encode_tuple_header(pid_message, &pid_message_index, 2))
::_exit(GEPD::ExitStatus::ei_encode_error);
if (ei_encode_atom(pid_message, &pid_message_index, "pid"))
::_exit(GEPD::ExitStatus::ei_encode_error);
if (ei_encode_ulong(pid_message, &pid_message_index, pid_child))
::_exit(GEPD::ExitStatus::ei_encode_error);
for (size_t i = 0; i < ports_len; ++i)
{
int sockfd = ::socket(AF_INET, type, 0);
if (sockfd == -1)
::_exit(spawn_status::errno_socket());
if (type == SOCK_STREAM)
{
int tcp_nodelay_flag = 1;
// set TCP_NODELAY to turn off Nagle's algorithm
if (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY,
(char *) &tcp_nodelay_flag, sizeof(int)) == -1)
::_exit(spawn_status::socket_unknown);
}
if (static_cast<size_t>(sockfd) != i + 3)
{
if (::dup2(sockfd, i + 3) == -1)
::_exit(spawn_status::errno_dup());
sockfd = i + 3;
}
struct sockaddr_in localhost;
localhost.sin_family = AF_INET;
localhost.sin_port = htons(ports[i]);
localhost.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
if (::connect(sockfd,
reinterpret_cast<struct sockaddr *>(&localhost),
sizeof(localhost)) == -1)
::_exit(spawn_status::errno_connect());
if (i == 0)
{
// let the first connection get a pid message for attempting
// to kill the OS process when the Erlang process terminates
if (::write(sockfd, pid_message, pid_message_index) == -1)
::_exit(spawn_status::errno_write());
}
}
int argv_count = 2;
{
assert(argv[argv_len - 1] == '\0');
for (size_t i = 1; i < argv_len; ++i)
{
if (argv[i] == '\0')
++argv_count;
}
}
char * execve_argv[argv_count];
{
int index = 0;
execve_argv[index++] = filename;
if (argv_count == 2)
{
execve_argv[index++] = 0;
}
else
{
execve_argv[index++] = argv;
for (size_t i = 0; i < argv_len - 1; ++i)
{
if (argv[i] == '\0')
execve_argv[index++] = &(argv[i + 1]);
}
execve_argv[index++] = 0;
assert(index == argv_count);
}
}
int env_count = 1;
{
assert(env[env_len - 1] == '\0');
for (size_t i = 1; i < env_len; ++i)
{
if (env[i] == '\0')
++env_count;
}
}
char * execve_env[env_count];
{
if (env_count == 1)
{
execve_env[0] = 0;
}
else
{
int index = 0;
execve_env[index++] = env;
for (size_t i = 0; i < env_len - 1; ++i)
{
if (env[i] == '\0')
execve_env[index++] = &(env[i + 1]);
}
execve_env[index++] = 0;
assert(index == env_count);
}
}
::execve(filename, execve_argv, execve_env);
::_exit(spawn_status::errno_exec());
}
else
{
if (::close(fds_stdout[1]) == -1)
return spawn_status::errno_close();
if (::close(fds_stderr[1]) == -1)
return spawn_status::errno_close();
if (GEPD::fds.reserve(GEPD::nfds + 2) == false)
::exit(spawn_status::out_of_memory);
size_t const index_stdout = GEPD::nfds;
size_t const index_stderr = GEPD::nfds + 1;
GEPD::fds[index_stdout].fd = fds_stdout[0];
GEPD::fds[index_stdout].events = POLLIN | POLLPRI;
GEPD::fds[index_stdout].revents = 0;
GEPD::fds[index_stderr].fd = fds_stderr[0];
GEPD::fds[index_stderr].events = POLLIN | POLLPRI;
GEPD::fds[index_stderr].revents = 0;
GEPD::nfds += 2;
copy_ptr<process_data> P(new process_data(pid,
index_stdout,
index_stderr));
processes.push_back(P);
}
return pid;
}
