static void print_et(m_et* b) { fprintf(stdout, "\net struct --------\n"); erl_print_term(stdout, b->e); fprintf(stdout, "long: %ld\n", b->l); fprintf(stdout, "\n--------\n"); }
static void print_etseq(m_etseq *b) { int i; for (i = 0; i < b->_length; i++) { fprintf(stdout, "[%d]:\n", i); erl_print_term(stdout, b->_buffer[i]); } }
int main() #endif { _setmode(0, _O_BINARY); _setmode(1, _O_BINARY); erl_init(NULL, 0); for (;;) { char buf[4*1024]; ETERM* term; char* message; int n; if (readn(0, buf, 2) <= 0) { /* fprintf(stderr, "error reading message header\n"); */ /* actually this is where we leave the infinite loop */ exit(1); } n = buf[0] * 256 + buf[1]; if (readn(0, buf, n) < 0) { fprintf(stderr, "error reading message contents\n"); exit(1); } term = erl_decode(buf); if (term == NULL) { fprintf(stderr, "erl_decode() failed\n"); exit(1); } n = erl_print_term(stdout, term); erl_free_compound(term); fprintf(stdout,"\r%d\n", n); fflush(stdout); } }
int erl_print_term(FILE *fp, const ETERM *ep) { int j,i,doquote; int ch_written = 0; /* counter of written chars */ if ((!fp) || (!ep)) return 0; /* ASSERT(ep != NULL); */ j = i = doquote = 0; switch(ERL_TYPE(ep)) { case ERL_ATOM: { char* adata = ERL_ATOM_PTR(ep); /* FIXME: what if some weird locale is in use? */ if (!islower(adata[0])) doquote = 1; for (i = 0; !doquote && i < ERL_ATOM_SIZE(ep); i++) { doquote = !(isalnum(adata[i]) || (adata[i] == '_')); } if (doquote) { putc('\'', fp); ch_written++; } fputs(adata, fp); ch_written += ERL_ATOM_SIZE(ep); if (doquote) { putc('\'', fp); ch_written++; } break; } case ERL_VARIABLE: if (!isupper((int)ERL_VAR_NAME(ep)[0])) { doquote = 1; putc('\'', fp); ch_written++; } fputs(ERL_VAR_NAME(ep), fp); ch_written += ERL_VAR_LEN(ep); if (doquote) { putc('\'', fp); ch_written++; } break; case ERL_PID: ch_written += fprintf(fp, "<%s.%d.%d>", ERL_PID_NODE(ep), ERL_PID_NUMBER(ep), ERL_PID_SERIAL(ep)); break; case ERL_PORT: ch_written += fprintf(fp, "#Port"); break; case ERL_REF: ch_written += fprintf(fp, "#Ref"); break; case ERL_EMPTY_LIST: ch_written += fprintf(fp, "[]"); break; case ERL_LIST: if (is_printable_list(ep)) { ch_written += print_string(fp, ep); } else { putc('[', fp); ch_written++; while (ERL_IS_CONS(ep)) { ch_written += erl_print_term(fp, HEAD(ep)); ep = TAIL(ep); if (ERL_IS_CONS(ep)) { putc(',', fp); ch_written++; } } if (!ERL_IS_EMPTY_LIST(ep)) { putc('|', fp); ch_written++; ch_written += erl_print_term(fp, ep); } putc(']', fp); ch_written++; } break; case ERL_TUPLE: putc('{', fp); ch_written++; for (i=0; i < ERL_TUPLE_SIZE(ep); i++) { ch_written += erl_print_term(fp, ERL_TUPLE_ELEMENT(ep, j++) ); if (i != ERL_TUPLE_SIZE(ep)-1) { putc(',', fp); ch_written++; } } putc('}', fp); ch_written++; break; case ERL_BINARY: { int sz = (ERL_BIN_SIZE(ep) > 20) ? 20 : ERL_BIN_SIZE(ep); unsigned char *ptr = ERL_BIN_PTR(ep); ch_written += fprintf(fp, "#Bin<"); for (i = 0; i < sz; i++) { putc(ptr[i], fp); ch_written++; } if (sz == 20) ch_written += fprintf(fp, "(%d)....>", ERL_BIN_SIZE(ep)-20); else ch_written += fprintf(fp, ">"); break; } case ERL_INTEGER: case ERL_SMALL_BIG: ch_written += fprintf(fp, "%d", ERL_INT_VALUE(ep)); break; case ERL_U_INTEGER: case ERL_U_SMALL_BIG: ch_written += fprintf(fp, "%d", ERL_INT_UVALUE(ep)); break; case ERL_LONGLONG: case ERL_U_LONGLONG: ch_written += fprintf(fp, "%lld", ERL_LL_UVALUE(ep)); break; case ERL_FLOAT: ch_written += fprintf(fp, "%f", ERL_FLOAT_VALUE(ep)); break; case ERL_FUNCTION: ch_written += fprintf(fp, "#Fun<"); ch_written += erl_print_term(fp, ERL_FUN_MODULE(ep)); putc('.', fp); ch_written++; ch_written += erl_print_term(fp, ERL_FUN_INDEX(ep)); putc('.', fp); ch_written++; ch_written += erl_print_term(fp, ERL_FUN_UNIQ(ep)); putc('>', fp); ch_written++; break; default: ch_written = -10000; erl_err_msg("<ERROR> erl_print_term: Bad type of term !"); } return ch_written; }
static void print_term(ETERM *t) { fprintf(stdout, "\nETERM --------\n"); erl_print_term(stdout, t); fprintf(stdout, "\n--------\n"); }
int main(void) #endif { ei_x_buff eix; int index = 0; ETERM **etermpp = NULL, *etermp = NULL; char *charp = NULL; unsigned char uchar, **ucharpp = NULL, *ucharp = NULL; void *voidp = NULL; Erl_Heap *erl_heapp = NULL; int intx = 0; int *intp = NULL; unsigned int uintx, *uintp; unsigned long *ulongp = NULL; long longx = 0; double doublex = 0.0; short shortx = 42; FILE *filep = NULL; Erl_IpAddr erl_ipaddr = NULL; ErlMessage *erlmessagep = NULL; ErlConnect *erlconnectp = NULL; struct hostent *hostp = NULL; struct in_addr *inaddrp = NULL; /* Converion to erl_interface format is in liberl_interface */ intx = erl_errno; ei_encode_term(charp, &index, voidp); ei_x_encode_term(&eix, voidp); ei_decode_term(charp, &index, voidp); erl_init(voidp, longx); erl_connect_init(intx, charp,shortx); erl_connect_xinit(charp,charp,charp,erl_ipaddr,charp,shortx); erl_connect(charp); erl_xconnect(erl_ipaddr,charp); erl_close_connection(intx); erl_receive(intx, ucharp, intx); erl_receive_msg(intx, ucharp, intx, erlmessagep); erl_xreceive_msg(intx, ucharpp, intp, erlmessagep); erl_send(intx, etermp, etermp); erl_reg_send(intx, charp, etermp); erl_rpc(intx,charp,charp,etermp); erl_rpc_to(intx,charp,charp,etermp); erl_rpc_from(intx,intx,erlmessagep); erl_publish(intx); erl_accept(intx,erlconnectp); erl_thiscookie(); erl_thisnodename(); erl_thishostname(); erl_thisalivename(); erl_thiscreation(); erl_unpublish(charp); erl_err_msg(charp); erl_err_quit(charp); erl_err_ret(charp); erl_err_sys(charp); erl_cons(etermp,etermp); erl_copy_term(etermp); erl_element(intx,etermp); erl_hd(etermp); erl_iolist_to_binary(etermp); erl_iolist_to_string(etermp); erl_iolist_length(etermp); erl_length(etermp); erl_mk_atom(charp); erl_mk_binary(charp,intx); erl_mk_empty_list(); erl_mk_estring(charp, intx); erl_mk_float(doublex); erl_mk_int(intx); erl_mk_list(etermpp,intx); erl_mk_pid(charp,uintx,uintx,uchar); erl_mk_port(charp,uintx,uchar); erl_mk_ref(charp,uintx,uchar); erl_mk_long_ref(charp,uintx,uintx,uintx,uchar); erl_mk_string(charp); erl_mk_tuple(etermpp,intx); erl_mk_uint(uintx); erl_mk_var(charp); erl_print_term(filep,etermp); /* erl_sprint_term(charp,etermp); */ erl_size(etermp); erl_tl(etermp); erl_var_content(etermp, charp); erl_format(charp); erl_match(etermp, etermp); erl_global_names(intx, intp); erl_global_register(intx, charp, etermp); erl_global_unregister(intx, charp); erl_global_whereis(intx, charp, charp); erl_init_malloc(erl_heapp,longx); erl_alloc_eterm(uchar); erl_eterm_release(); erl_eterm_statistics(ulongp,ulongp); erl_free_array(etermpp,intx); erl_free_term(etermp); erl_free_compound(etermp); erl_malloc(longx); erl_free(voidp); erl_compare_ext(ucharp, ucharp); erl_decode(ucharp); erl_decode_buf(ucharpp); erl_encode(etermp,ucharp); erl_encode_buf(etermp,ucharpp); erl_ext_size(ucharp); erl_ext_type(ucharp); erl_peek_ext(ucharp,intx); erl_term_len(etermp); erl_gethostbyname(charp); erl_gethostbyaddr(charp, intx, intx); erl_gethostbyname_r(charp, hostp, charp, intx, intp); erl_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp); erl_init_resolve(); erl_distversion(intx); erl_epmd_connect(inaddrp); erl_epmd_port(inaddrp, charp, intp); charp = ERL_ATOM_PTR(etermp); intx = ERL_ATOM_SIZE(etermp); ucharp = ERL_BIN_PTR(etermp); intx = ERL_BIN_SIZE(etermp); etermp = ERL_CONS_HEAD(etermp); etermp = ERL_CONS_TAIL(etermp); intx = ERL_COUNT(etermp); doublex= ERL_FLOAT_VALUE(etermp); uintx = ERL_INT_UVALUE(etermp); intx = ERL_INT_VALUE(etermp); intx = ERL_IS_ATOM(etermp); intx = ERL_IS_BINARY(etermp); intx = ERL_IS_CONS(etermp); intx = ERL_IS_EMPTY_LIST(etermp); intx = ERL_IS_FLOAT(etermp); intx = ERL_IS_INTEGER(etermp); intx = ERL_IS_LIST(etermp); intx = ERL_IS_PID(etermp); intx = ERL_IS_PORT(etermp); intx = ERL_IS_REF(etermp); intx = ERL_IS_TUPLE(etermp); intx = ERL_IS_UNSIGNED_INTEGER(etermp); uchar = ERL_PID_CREATION(etermp); charp = ERL_PID_NODE(etermp); uintx = ERL_PID_NUMBER(etermp); uintx = ERL_PID_SERIAL(etermp); uchar = ERL_PORT_CREATION(etermp); charp = ERL_PORT_NODE(etermp); uintx = ERL_PORT_NUMBER(etermp); uchar = ERL_REF_CREATION(etermp); intx = ERL_REF_LEN(etermp); charp = ERL_REF_NODE(etermp); uintx = ERL_REF_NUMBER(etermp); uintp = ERL_REF_NUMBERS(etermp); etermp = ERL_TUPLE_ELEMENT(etermp,intx); intx = ERL_TUPLE_SIZE(etermp); return BUFSIZ + EAGAIN + EHOSTUNREACH + EINVAL + EIO + EMSGSIZE + ENOMEM + ERL_ATOM + ERL_BINARY + ERL_ERROR + ERL_EXIT + ERL_FLOAT + ERL_INTEGER + ERL_LINK + ERL_LIST + ERL_MSG + ERL_NO_TIMEOUT + ERL_PID + ERL_PORT + ERL_REF + ERL_REG_SEND + ERL_SEND + ERL_SMALL_BIG + ERL_TICK + ERL_TIMEOUT + ERL_TUPLE + ERL_UNLINK + ERL_U_INTEGER + ERL_U_SMALL_BIG + ERL_VARIABLE + ETIMEDOUT + MAXNODELEN + MAXREGLEN; }
void watcher(void* data) { TRACE(("watcher thread started!")); info_t* threadinfo = (info_t*)data; int triggerfd, cnt, ret; char attrdata[1024]; struct pollfd ufd; if (!ERL_IS_PID(threadinfo->topid)) { fprintf(stderr, "PID is not a pid. wat."); pthread_exit(NULL); } TRACE(("watcher thread got fname(%d): %s", strlen(threadinfo->fname), threadinfo->fname)); //TRACE(("watcher got PID <.%d.%d> and fd %d", // ERL_PID_NUMBER(&threadinfo->topid), // ERL_PID_SERIAL(&threadinfo->topid), // threadinfo->erlvm_fd)); fprintf(stderr, "watcher got PID "); erl_print_term(stderr, threadinfo->topid); fprintf(stderr, "\n"); if ((ufd.fd = open(threadinfo->fname, O_RDONLY)) < 0) { TRACE(("unable to open file %s", threadinfo->fname)); perror("unable to open file"); goto end_watcher; } ufd.events = POLLPRI | POLLERR; // dummy read cnt = read(ufd.fd, attrdata, 1023); TRACE(("dummy read got value %d", cnt)); TRACE(("starting up main watcher loop")); while ((ret = poll(&ufd, 1, 10000)) >= 0) { TRACE(("began watcher loop")); if (ret == 0) { TRACE(("watcher thread poll() timed out, continuing.")); continue; } if (ufd.revents & (POLLPRI|POLLERR)) { TRACE(("watcher caught an event!")); close(ufd.fd); if ((ufd.fd = open(threadinfo->fname, O_RDONLY)) < 0) { TRACE(("unable to re-open file %s", threadinfo->fname)); perror("unable to re-open file"); break; } cnt = read(ufd.fd, attrdata, 1023); attrdata[cnt] = '\0'; TRACE(("watcher got %d bytes: %s", cnt, attrdata)); ETERM* notification = erl_format("{data, ~s}", attrdata); int sendret = erl_send(threadinfo->erlvm_fd, threadinfo->topid, notification); if (!sendret) { switch(erl_errno) { case(EINVAL): fprintf(stderr, "unable to send notification: bad PID\n"); break; case(ENOMEM): fprintf(stderr, "unable to send notification: no memory\n"); break; case(EIO): fprintf(stderr, "unable to send notification: I/O error\n"); break; default: fprintf(stderr, "unable to send notification: unspecified error\n"); break; } } else { TRACE(("sent notification")); } free(notification); } else { printf("watcher got something weird! revents = %d\n", ufd.revents); } ufd.revents = 0; TRACE(("finishing watcher loop")); } end_watcher: erl_free_compound(threadinfo->topid); free(threadinfo->fname); pthread_t* dying = threadinfo->self; free(threadinfo); free(dying); TRACE(("watcher thread exiting")); pthread_exit(NULL); }
void process_init_cmd(ETERM* init_cmd_pattern, int erl_fd, ETERM* msg_frompid) { fprintf(stderr, "process_init_cmd got PID "); erl_print_term(stderr, msg_frompid); fprintf(stderr, "\n"); ETERM* response; ETERM* msg_arg = erl_var_content(init_cmd_pattern, "Arg"); if (!ERL_IS_LIST(msg_arg)) { erl_err_msg("invalid argument to init command"); response = erl_format("{ecap_node, {error, {badarg, {init, ~w} } } }", msg_arg); erl_send(erl_fd, msg_frompid, response); goto invarg_cleanup; } char* fn_str = erl_iolist_to_string(msg_arg); if (fn_str == NULL) { erl_err_msg("could not unpack string"); response = erl_format("{ecap_node, {error, {badarg, {init, ~w}}}}", msg_arg); erl_send(erl_fd, msg_frompid, response); goto nostr_cleanup; } TRACE(("init command got argstring: %s", fn_str)); pthread_t* thread = (pthread_t*)malloc(sizeof(pthread_t)); info_t* threadinfo = (info_t*)malloc(sizeof(info_t)); // We copy all of this data because the transient pointers will be free()d // just before each function returns, destroying in the thread context. threadinfo->topid = msg_frompid; threadinfo->self = thread; threadinfo->fname = (char*)malloc(strlen(fn_str)+1); strncpy(threadinfo->fname, fn_str, strlen(fn_str)+1); threadinfo->erlvm_fd = erl_fd; int ret; if ((ret = pthread_create(thread, NULL, watcher, threadinfo)) != 0) { TRACE(("failed to create thread, with return code %d", ret)); erl_err_ret("failed to create watcher thread"); response = erl_format("{ecap_node, {error, {threadfail}}}"); erl_send(erl_fd, msg_frompid, response); TRACE(("freeing thread stuff")); free(thread); free(threadinfo->fname); free(threadinfo); goto nothread_cleanup; } response = erl_format("{ecap_node, ok}"); erl_send(erl_fd, msg_frompid, response); TRACE(("normal cleanup from init command call")); nothread_cleanup: nostr_cleanup: TRACE(("freeing fn_str")); erl_free(fn_str); invarg_cleanup: TRACE(("freeing terms")); erl_free_term(response); erl_free_term(msg_arg); TRACE(("done with init command processing")); }