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