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; }