response_t read_pkt_start(int q_num, q_data_t **q_data, thread_data_t *data) { int cq_idx; response_t r; pthread_attr_t thread_attrs; if((cq_idx = get_queue_idx(q_num, q_data)) >= 0) { if(q_data[cq_idx]->pid <= 0) { pthread_attr_init(&thread_attrs); pthread_attr_setdetachstate(&thread_attrs, PTHREAD_CREATE_DETACHED); if (pthread_create(&(q_data[cq_idx]->thread), &thread_attrs, read_queue_loop, q_data[cq_idx])) { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("failure to create thread", strlen("failure to create thread")); } else { r.cs = erl_mk_atom("ok"); r.rsp = erl_mk_atom("ok"); } pthread_attr_destroy(&thread_attrs); } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("thread already started", strlen("thread already started")); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such queue", strlen("no such queue")); } return r; }
response_t read_pkt_stop(int q_num, q_data_t **q_data, thread_data_t *data) { int cq_idx; response_t r; if((cq_idx = get_queue_idx(q_num, q_data)) >= 0) { if(q_data[cq_idx]->pid > 0) { if(!pthread_cancel(q_data[cq_idx]->thread)) { q_data[cq_idx]->pid = 0; r.cs = erl_mk_atom("ok"); r.rsp = erl_mk_atom("ok"); } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("failed to stop thread", strlen("failed to stop thread")); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such thread", strlen("no such thread")); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such queue", strlen("no such queue")); } return r; }
// NF_QUEUE operations response_t create_queue(int q_num, q_data_t **q_data, thread_data_t *data) { response_t r; int cq_idx; if(get_queue_idx(q_num, q_data) == -1 && (cq_idx = get_free_idx(q_data)) >=0 ) { q_data[cq_idx]->h = nfq_open(); if (!q_data[cq_idx]->h) syslog(LOG_ERR, "[%d] error during nfq_open()\n\r", data->idx); if (nfq_bind_pf(q_data[cq_idx]->h, AF_INET) < 0) syslog(LOG_ERR, "[%d] error during nfq_bind_pf()\n\r", data->idx); q_data[cq_idx]->qh = nfq_create_queue(q_data[cq_idx]->h, q_num, &cb, NULL); syslog(LOG_NOTICE,"[%d] q_num: %d\n\r", data->idx, q_num); if (!q_data[cq_idx]->qh) { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("failed to create queue", strlen("failed to create queue")); } else { q_data[cq_idx]->q_num = q_num; r.cs = erl_mk_atom("ok"); r.rsp = erl_mk_atom("ok"); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("queue in use", strlen("queue in use")); } return r; }
response_t set_queue_len(int len, ETERM *tuplep, q_data_t **q_data, thread_data_t *data) { int q_num, cq_idx; ETERM *arg; response_t r; if(erl_size(tuplep) > 2) { arg = erl_element(3, tuplep); q_num = ERL_INT_VALUE(arg); erl_free_term(arg); syslog(LOG_NOTICE,"[%d] q_num: %d, len: %d\n\r", data->idx, q_num, len); if((cq_idx = get_queue_idx(q_num, q_data)) >= 0) { if(nfq_set_queue_maxlen(q_data[cq_idx]->qh, len) >= 0) { r.cs = erl_mk_atom("ok"); r.rsp = erl_mk_atom("ok"); } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("failed to set queue max length", strlen("failed to set queue max length")); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such queue", strlen("no such queue")); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("argument missing", strlen("argument missing")); } return r; }
static response_t set_mode(int t_mode, ETERM *tuplep, q_data_t **q_data, thread_data_t *data) { int cq_idx, q_num; ETERM *arg; u_int8_t mode = NFQNL_COPY_NONE; response_t r; if(erl_size(tuplep) > 2) { arg = erl_element(3, tuplep); q_num = ERL_INT_VALUE(arg); erl_free_term(arg); syslog(LOG_NOTICE,"[%d] q_num: %d, mode: %d\n\r", data->idx, q_num, t_mode); if((cq_idx = get_queue_idx(q_num, q_data)) >= 0) { switch(t_mode) { case 0: mode = NFQNL_COPY_NONE; break; case 1: mode = NFQNL_COPY_META; break; case 2: mode = NFQNL_COPY_PACKET; break; default: mode = NFQNL_COPY_NONE; break; } if (nfq_set_mode(q_data[cq_idx]->qh, mode, 0xffff) < 0) { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("failed to set mode", strlen("failed to set mode")); } else { r.cs = erl_mk_atom("ok"); r.rsp = erl_mk_atom("ok"); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such queue", strlen("no such queue")); } } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("argument missing", strlen("argument missing")); } return r; }
/* * Given a string as input, creates a list. */ ETERM *erl_mk_string(const char *s) { /* ASSERT(s != NULL); */ if (!s) return NULL; return erl_mk_estring(s, strlen(s)); }
response_t destroy_queue(int q_num, q_data_t **q_data, thread_data_t *data) { int cq_idx; response_t r; syslog(LOG_NOTICE,"[%d] q_num: %d\n\r", data->idx, q_num); if((cq_idx = get_queue_idx(q_num, q_data)) >= 0) { if(q_data[cq_idx]->pid > 0) pthread_cancel(q_data[cq_idx]->thread); nfq_destroy_queue(q_data[cq_idx]->qh); nfq_unbind_pf(q_data[cq_idx]->h, AF_INET); nfq_close(q_data[cq_idx]->h); q_data[cq_idx]->pid = 0; q_data[cq_idx]->q_num = -1; q_data[cq_idx]->qh = NULL; q_data[cq_idx]->h = NULL; r.cs = erl_mk_atom("ok"); r.rsp = erl_mk_atom("ok"); } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such queue", strlen("no such queue")); } return r; }
ETERM * make_row() { ETERM **rowtup, *rc; unsigned int i; rowtup = (ETERM **)safe_malloc(numfields * sizeof(ETERM *)); for (i = 0; i < numfields; i++) { if (*r_bind[i].is_null) rowtup[i] = erl_mk_atom("null"); else rowtup[i] = erl_mk_estring(r_bind[i].buffer, *r_bind[i].length); } rc = erl_mk_tuple(rowtup, numfields); if (rc == NULL) { ETERM *resp; resp = erl_format("{error, {erl_mk_tuple, ~i}}", numfields); write_msg(resp); erl_free_term(resp); exit(3); } for (i = 0; i < numfields; i++) erl_free_term(rowtup[i]); free(rowtup); return rc; }
static VALUE erlix_list_init(VALUE self,VALUE ary){ ErlixTerm *list; ETERM **les; VALUE e; ErlixTerm *ep; int i; Data_Get_Struct(self,ErlixTerm,list); if(NIL_P(ary)){ //empty list list->term=erl_mk_empty_list(); return self; } if(TYPE(ary)==T_ARRAY){ if(RARRAY_LEN(ary)==0){ //empty list list->term=erl_mk_empty_list(); }else{ //check: all elements' must be ErlixTerm or auto-convertable Type for(i=0;i<RARRAY_LEN(ary);i++){ e=RARRAY_PTR(ary)[i]; if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){ rb_raise(rb_eTypeError,"all list's elements must be ErlixTerm or Auto-Convertable-Type!"); } } les=(ETERM**)malloc(sizeof(ETERM*)*(RARRAY_LEN(ary))); for(i=0;i<RARRAY_LEN(ary);i++){ e=RARRAY_PTR(ary)[i]; if(IS_ETERM(e)){ Data_Get_Struct(e,ErlixTerm,ep); *(les+i)=erl_copy_term(ep->term); }else{ *(les+i)=erlix_auto_conv(e); } } list->term=erl_mk_list(les,RARRAY_LEN(ary)); //for(i=0;i<RARRAY(ary)->len;i++){ // erl_free_term(*(les+i)); //} free(les); } }else if(TYPE(ary)==T_STRING){ list->term=erl_mk_estring(RSTRING_PTR(ary), RSTRING_LEN(ary)); } return self; }
void *erl_message_read_loop(void *arg_data) { thread_data_t *data = (thread_data_t *)arg_data; ErlMessage emsg; // Incoming message unsigned char buf[BUFSIZE]; // Buffer for incoming message int got; // Result of receive ETERM *fromp, *tuplep, *fun, *arg, *resp; // Erlang terms int loop = 1; // Loop flag char *f_name_atom; int q_num; int i = 0, temp; q_data_t *q_data[MAX_Q_NUMS]; // Per queue data response_t r; /* Exepected Erlang term: {from_pid(), {fun_name_atom, argument}}} or {from_pid(), {fun_name_atom, argument1, argument2}}} and returned term: {call_state, response} */ syslog(LOG_NOTICE,"[%d] Connection with node: %s\n\r",data->idx, data->node); for(i = 0; i < MAX_Q_NUMS; i++) { q_data[i] = malloc(sizeof(q_data_t)); q_data[i]->q_num = -1; q_data[i]->h = NULL; q_data[i]->qh = NULL; q_data[i]->pid = 0; } pthread_setname_np(pthread_self(), "msg_read_loop"); while (loop) { got = erl_receive_msg(data->fd, buf, BUFSIZE, &emsg); switch (got) { case ERL_TICK: syslog(LOG_NOTICE,"[%d] %s tick\n\r",data->idx, data->node); break; case ERL_ERROR: syslog(LOG_NOTICE,"[%d] %s erl_receive_msg error or node down\n\r",data->idx, data->node); loop = 0; break; case ERL_MSG: if (emsg.type == ERL_REG_SEND || emsg.type == ERL_SEND) { fromp = erl_element(1, emsg.msg); tuplep = erl_element(2, emsg.msg); fun = erl_element(1, tuplep); arg = erl_element(2, tuplep); f_name_atom = ERL_ATOM_PTR(fun); syslog(LOG_NOTICE,"[%d] %s %s()\n\r", data->idx, data->node, f_name_atom); if(strcmp(f_name_atom, "create_queue") == 0) { q_num = ERL_INT_VALUE(arg); r = create_queue(q_num, q_data, data); } else if(strcmp(f_name_atom, "destroy_queue") == 0) { q_num = ERL_INT_VALUE(arg); r = destroy_queue(q_num, q_data, data); } else if(strcmp(f_name_atom, "queue_list") == 0) { r = queue_list(q_data); } else if(strcmp(f_name_atom, "set_mode") == 0) { temp = ERL_INT_VALUE(arg); r = set_mode(temp, tuplep, q_data, data); } else if(strcmp(f_name_atom, "set_queue_len") == 0) { temp = ERL_INT_VALUE(arg); r = set_queue_len(temp, tuplep, q_data, data); } else if(strcmp(f_name_atom, "read_pkt_start") == 0) { q_num = ERL_INT_VALUE(arg); r = read_pkt_start(q_num, q_data, data); } else if(strcmp(f_name_atom, "read_pkt_stop") == 0) { q_num = ERL_INT_VALUE(arg); r = read_pkt_stop(q_num, q_data, data); } else { r.cs = erl_mk_atom("error"); r.rsp = erl_mk_estring("no such function", strlen("no such function")); } if ((resp = erl_format("{cnode, {reply, {~w, ~w}}}", r.cs, r.rsp)) != NULL) { if(!erl_send(data->fd, fromp, resp)) { syslog(LOG_ERR,"[%d] %s send reply error, exit loop\n\r", data->idx, data->node); loop = 0; } } else { syslog(LOG_ERR,"[%d] %s term format error\n\r", data->idx, data->node); loop = 0; } erl_free_term(emsg.from); erl_free_term(emsg.msg); erl_free_term(fromp); erl_free_term(tuplep); erl_free_term(fun); erl_free_term(arg); erl_free_term(resp); erl_free_term(r.rsp); erl_free_term(r.cs); } break; default: syslog(LOG_ERR,"[%d] %s something wrong! :(\n\r", data->idx, data->node); loop = 0; break; } } /* while */ for(i = 0; i < MAX_Q_NUMS; i++) { if(q_data[i]->pid > 0) pthread_cancel(q_data[i]->thread); if (q_data[i]->q_num >= 0) { nfq_destroy_queue(q_data[i]->qh); nfq_close(q_data[i]->h); } free(q_data[i]); } syslog(LOG_ERR,"[%d] %s thread stop\n\r", data->idx, data->node); free(data->node); free(data); pthread_exit(NULL); }
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; }