diff --git a/src/modules/erlang/cnode.c b/src/modules/erlang/cnode.c index 0df9544d77e..577bef7920f 100644 --- a/src/modules/erlang/cnode.c +++ b/src/modules/erlang/cnode.c @@ -24,10 +24,10 @@ #include "../../core/mem/mem.h" #define HANDLE_IO_INLINE #include "../../core/io_wait.h" -#include "../../core/pt.h" /* process_count */ +#include "../../core/pt.h" /* process_count */ #ifndef USE_TCP -#error "USE_TCP must be enabled for this module" +#error "USE_TCP must be enabled for this module" #endif #include "../../core/pass_fd.h" @@ -39,8 +39,8 @@ #include "worker.h" #include "handle_emsg.h" -#define IO_LISTEN_TIMEOUT 10 -#define CONNECT_TIMEOUT 500 /* ms */ +#define IO_LISTEN_TIMEOUT 10 +#define CONNECT_TIMEOUT 500 /* ms */ static io_wait_h erl_io_h; @@ -51,9 +51,10 @@ erlang_pid *cnode_reply_to_pid = NULL; /** * @brief Initialize Kamailio as C node by active connect as client. */ -int cnode_connect_to(cnode_handler_t *phandler, ei_cnode *ec, const str *nodename ) +int cnode_connect_to( + cnode_handler_t *phandler, ei_cnode *ec, const str *nodename) { - struct sockaddr addr = { 0 }; + struct sockaddr addr = {0}; socklen_t addrlen = sizeof(struct sockaddr); int port; @@ -68,24 +69,22 @@ int cnode_connect_to(cnode_handler_t *phandler, ei_cnode *ec, const str *nodenam LM_DBG("connecting to Erlang node %.*s ...\n", STR_FMT(nodename)); - if ((rfd = ei_connect_tmo(ec, nodename->s, CONNECT_TIMEOUT)) < 0) - { - switch (erl_errno) - { - case EHOSTUNREACH: - LM_ERR("remote node %.*s is unreachable.\n", STR_FMT(nodename)); - break; - case ENOMEM: - LM_ERR("%s.\n", strerror(erl_errno)); - break; - case EIO: - LM_ERR("%s. %s.\n", strerror(erl_errno), strerror(errno)); - break; - default: - LM_ERR("%s.\n",strerror(erl_errno)); - break; + if((rfd = ei_connect_tmo(ec, nodename->s, CONNECT_TIMEOUT)) < 0) { + switch(erl_errno) { + case EHOSTUNREACH: + LM_ERR("remote node %.*s is unreachable.\n", STR_FMT(nodename)); + break; + case ENOMEM: + LM_ERR("%s.\n", strerror(erl_errno)); + break; + case EIO: + LM_ERR("%s. %s.\n", strerror(erl_errno), strerror(errno)); + break; + default: + LM_ERR("%s.\n", strerror(erl_errno)); + break; } - LM_ERR("failed erl_errno=%d %s.\n",erl_errno,strerror(erl_errno)); + LM_ERR("failed erl_errno=%d %s.\n", erl_errno, strerror(erl_errno)); return -1; } @@ -99,16 +98,14 @@ int cnode_connect_to(cnode_handler_t *phandler, ei_cnode *ec, const str *nodenam phandler->sockfd = rfd; /* get addr on socket */ - if ((ai_error = getpeername(rfd, &addr, &addrlen))) - { - LM_ERR("%s\n",strerror(errno)); - } - else - { - sockaddr2ip_addr(&ip,&addr); + if((ai_error = getpeername(rfd, &addr, &addrlen))) { + LM_ERR("%s\n", strerror(errno)); + } else { + sockaddr2ip_addr(&ip, &addr); port = sockaddr_port(&addr); - LM_DBG("... connected to %.*s %s:%u\n", STR_FMT(nodename), ip_addr2strz(&ip), port); + LM_DBG("... connected to %.*s %s:%u\n", STR_FMT(nodename), + ip_addr2strz(&ip), port); } strncpy(phandler->conn.nodename, nodename->s, nodename->len); @@ -118,15 +115,13 @@ int cnode_connect_to(cnode_handler_t *phandler, ei_cnode *ec, const str *nodenam phandler->ec.self.num = phandler->sockfd; phandler->new = NULL; - if (ei_x_new(&phandler->request)) - { - LOG(L_ERR,"failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); + if(ei_x_new(&phandler->request)) { + LOG(L_ERR, "failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); return -1; } - if (ei_x_new_with_version(&phandler->response)) - { - LOG(L_ERR,"failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); + if(ei_x_new_with_version(&phandler->response)) { + LOG(L_ERR, "failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); return -1; } @@ -136,10 +131,12 @@ int cnode_connect_to(cnode_handler_t *phandler, ei_cnode *ec, const str *nodenam int destroy_cnode(handler_common_t *phandler_t) { - cnode_handler_t *phandler = (cnode_handler_t*)phandler_t; + cnode_handler_t *phandler = (cnode_handler_t *)phandler_t; - if(phandler->request.buff) ei_x_free(&phandler->request); - if(phandler->response.buff) ei_x_free(&phandler->response); + if(phandler->request.buff) + ei_x_free(&phandler->request); + if(phandler->response.buff) + ei_x_free(&phandler->response); erl_close_socket(phandler->sockfd); @@ -148,7 +145,7 @@ int destroy_cnode(handler_common_t *phandler_t) int init_cnode_sockets(int cnode_id) { - char buff[EI_MAXALIVELEN+1]; + char buff[EI_MAXALIVELEN + 1]; str alivename; ei_cnode ec; int poll_method; @@ -156,52 +153,55 @@ int init_cnode_sockets(int cnode_id) /* generate cnode name */ alivename.s = buff; - if (no_cnodes > 1) { - alivename.len = snprintf(buff,EI_MAXALIVELEN,"%.*s%d",STR_FMT(&cnode_alivename),cnode_id); + if(no_cnodes > 1) { + alivename.len = snprintf(buff, EI_MAXALIVELEN, "%.*s%d", + STR_FMT(&cnode_alivename), cnode_id); } else { alivename = cnode_alivename; } - if (alivename.len > EI_MAXALIVELEN) { - LM_ERR("alive name %.*s too long max allowed size is %d\n",STR_FMT(&cnode_alivename), EI_MAXALIVELEN); + if(alivename.len > EI_MAXALIVELEN) { + LM_ERR("alive name %.*s too long max allowed size is %d\n", + STR_FMT(&cnode_alivename), EI_MAXALIVELEN); return -1; } /* init Erlang connection */ - if (erl_init_ec(&ec,&alivename,&cnode_host,&cookie)) { + if(erl_init_ec(&ec, &alivename, &cnode_host, &cookie)) { LM_CRIT("failed to initialize ei_cnode\n"); return -1; } - poll_method=choose_poll_method(); + poll_method = choose_poll_method(); - LM_DBG("using %s as the I/O watch method (auto detected)\n", poll_method_name(poll_method)); + LM_DBG("using %s as the I/O watch method (auto detected)\n", + poll_method_name(poll_method)); - if (init_io_wait(&erl_io_h,get_max_open_fds(),poll_method)) - { + if(init_io_wait(&erl_io_h, get_max_open_fds(), poll_method)) { LM_CRIT("init_io_wait failed\n"); return -1; } - phandler = (handler_common_t*)pkg_malloc(sizeof(csockfd_handler_t)); - if (!phandler) { + phandler = (handler_common_t *)pkg_malloc(sizeof(csockfd_handler_t)); + if(!phandler) { LM_ERR("not enough memory\n"); return -1; } io_handler_ins(phandler); - if (csockfd_init((csockfd_handler_t*)phandler, &ec)) { + if(csockfd_init((csockfd_handler_t *)phandler, &ec)) { return -1; } - if (io_watch_add(&erl_io_h,phandler->sockfd,POLLIN,ERL_CSOCKFD_H,phandler)) { + if(io_watch_add( + &erl_io_h, phandler->sockfd, POLLIN, ERL_CSOCKFD_H, phandler)) { LM_CRIT("io_watch_add failed\n"); return -1; } - phandler = (handler_common_t*)pkg_malloc(sizeof(cnode_handler_t)); - if (!phandler) { + phandler = (handler_common_t *)pkg_malloc(sizeof(cnode_handler_t)); + if(!phandler) { LM_CRIT("not enough memory\n"); return -1; } @@ -209,17 +209,19 @@ int init_cnode_sockets(int cnode_id) io_handler_ins(phandler); /* connect to remote Erlang node */ - if (cnode_connect_to((cnode_handler_t*)phandler,&ec, erlang_nodename.s?&erlang_nodename:&erlang_node_sname)) { + if(cnode_connect_to((cnode_handler_t *)phandler, &ec, + erlang_nodename.s ? &erlang_nodename : &erlang_node_sname)) { /* continue even failed to connect, connection can be established * from Erlang side too */ io_handler_del(phandler); - } else if (io_watch_add(&erl_io_h,phandler->sockfd,POLLIN,ERL_CNODE_H,phandler)){ + } else if(io_watch_add(&erl_io_h, phandler->sockfd, POLLIN, ERL_CNODE_H, + phandler)) { LM_CRIT("io_watch_add failed\n"); return -1; } - phandler = (handler_common_t*)pkg_malloc(sizeof(epmd_handler_t)); - if (!phandler) { + phandler = (handler_common_t *)pkg_malloc(sizeof(epmd_handler_t)); + if(!phandler) { LM_CRIT("not enough memory\n"); return -1; } @@ -227,11 +229,12 @@ int init_cnode_sockets(int cnode_id) io_handler_ins(phandler); /* start epmd handler - publish Kamailio C node */ - if (epmd_init((epmd_handler_t*)phandler, &alivename) < 0 ) { + if(epmd_init((epmd_handler_t *)phandler, &alivename) < 0) { return -1; } - if (io_watch_add(&erl_io_h,phandler->sockfd,POLLIN,ERL_EPMD_H,phandler)){ + if(io_watch_add( + &erl_io_h, phandler->sockfd, POLLIN, ERL_EPMD_H, phandler)) { LM_CRIT("io_watch_add failed\n"); return -1; } @@ -245,97 +248,101 @@ void cnode_main_loop(int cnode_id) str *enode_name; int r; - if (snprintf(_cnode_name, MAXNODELEN, "%.*s%d@%.*s", STR_FMT(&cnode_alivename), cnode_id+1,STR_FMT(&cnode_host)) >= MAXNODELEN) - { - LM_CRIT("the node name <%.*s%d@%.*s> is too large max length allowed is %d\n", - STR_FMT(&cnode_alivename), cnode_id+1, STR_FMT(&cnode_host), MAXNODELEN-1); + if(snprintf(_cnode_name, MAXNODELEN, "%.*s%d@%.*s", + STR_FMT(&cnode_alivename), cnode_id + 1, STR_FMT(&cnode_host)) + >= MAXNODELEN) { + LM_CRIT("the node name <%.*s%d@%.*s> is too large max length allowed " + "is %d\n", + STR_FMT(&cnode_alivename), cnode_id + 1, STR_FMT(&cnode_host), + MAXNODELEN - 1); return; } erl_init_common(); - if (init_cnode_sockets(cnode_id)) { + if(init_cnode_sockets(cnode_id)) { io_handlers_delete(); erl_free_common(); return; } - enode_name = erlang_nodename.s?&erlang_nodename:&erlang_node_sname; + enode_name = erlang_nodename.s ? &erlang_nodename : &erlang_node_sname; /* main loop */ - switch(erl_io_h.poll_method){ + switch(erl_io_h.poll_method) { case POLL_POLL: - while(1){ + while(1) { r = io_wait_loop_poll(&erl_io_h, IO_LISTEN_TIMEOUT, 0); if(!r && enode_connect()) { - LM_ERR("failed reconnect to %.*s\n",STR_FMT(enode_name)); + LM_ERR("failed reconnect to %.*s\n", STR_FMT(enode_name)); } } break; #ifdef HAVE_SELECT case POLL_SELECT: - while(1){ + while(1) { r = io_wait_loop_select(&erl_io_h, IO_LISTEN_TIMEOUT, 0); if(!r && enode_connect()) { - LM_ERR("failed reconnect to %.*s\n",STR_FMT(enode_name)); + LM_ERR("failed reconnect to %.*s\n", STR_FMT(enode_name)); } } break; #endif #ifdef HAVE_SIGIO_RT case POLL_SIGIO_RT: - while(1){ + while(1) { r = io_wait_loop_sigio_rt(&erl_io_h, IO_LISTEN_TIMEOUT); if(!r && enode_connect()) { - LM_ERR("failed reconnect to %.*s\n",STR_FMT(enode_name)); + LM_ERR("failed reconnect to %.*s\n", STR_FMT(enode_name)); } } break; #endif #ifdef HAVE_EPOLL - case POLL_EPOLL_LT: - while(1){ - r = io_wait_loop_epoll(&erl_io_h, IO_LISTEN_TIMEOUT, 0); - if(!r && enode_connect()) { - LM_ERR("failed reconnect to %.*s\n",STR_FMT(enode_name)); - } + case POLL_EPOLL_LT: + while(1) { + r = io_wait_loop_epoll(&erl_io_h, IO_LISTEN_TIMEOUT, 0); + if(!r && enode_connect()) { + LM_ERR("failed reconnect to %.*s\n", STR_FMT(enode_name)); } - break; - case POLL_EPOLL_ET: - while(1){ - r = io_wait_loop_epoll(&erl_io_h, IO_LISTEN_TIMEOUT, 1); - if(!r && enode_connect()) { - LM_ERR("failed reconnect to %.*s\n",STR_FMT(enode_name)); - } + } + break; + case POLL_EPOLL_ET: + while(1) { + r = io_wait_loop_epoll(&erl_io_h, IO_LISTEN_TIMEOUT, 1); + if(!r && enode_connect()) { + LM_ERR("failed reconnect to %.*s\n", STR_FMT(enode_name)); } - break; + } + break; #endif #ifdef HAVE_KQUEUE - case POLL_KQUEUE: - while(1){ - r = io_wait_loop_kqueue(&erl_io_h, IO_LISTEN_TIMEOUT, 0); - if(!r && enode_connect()) { - LM_ERR("failed reconnect to %.*s\n",STR_FMT(enode_name)); - } + case POLL_KQUEUE: + while(1) { + r = io_wait_loop_kqueue(&erl_io_h, IO_LISTEN_TIMEOUT, 0); + if(!r && enode_connect()) { + LM_ERR("failed reconnect to %.*s\n", STR_FMT(enode_name)); } - break; + } + break; #endif #ifdef HAVE_DEVPOLL - case POLL_DEVPOLL: - while(1){ - r = io_wait_loop_devpoll(&erl_io_h, IO_LISTEN_TIMEOUT, 0); - if(!r && enode_connect()) { - LM_ERR("failed reconnect to %.*s\n",STR_FMT(enode_name)); - } - } - break; + case POLL_DEVPOLL: + while(1) { + r = io_wait_loop_devpoll(&erl_io_h, IO_LISTEN_TIMEOUT, 0); + if(!r && enode_connect()) { + LM_ERR("failed reconnect to %.*s\n", STR_FMT(enode_name)); + } + } + break; #endif - default: - LM_CRIT("BUG: io_listen_loop: no support for poll method " - " %s (%d)\n", poll_method_name(erl_io_h.poll_method), - erl_io_h.poll_method); - goto error; - } + default: + LM_CRIT("BUG: io_listen_loop: no support for poll method " + " %s (%d)\n", + poll_method_name(erl_io_h.poll_method), + erl_io_h.poll_method); + goto error; + } error: LOG(L_CRIT, "ERROR: cnode_main_loop exiting ...\n"); @@ -354,37 +361,39 @@ void cnode_main_loop(int cnode_id) * >0 on successfully read from the fd (when there might be more io * queued -- the receive buffer might still be non-empty) */ -int handle_io(struct fd_map* fm, short events, int idx) +int handle_io(struct fd_map *fm, short events, int idx) { int type; handler_common_t *phandler; - phandler = (handler_common_t*)fm->data; + phandler = (handler_common_t *)fm->data; - if (phandler->handle_f(phandler)) { - io_watch_del(&erl_io_h,fm->fd,idx,IO_FD_CLOSING); + if(phandler->handle_f(phandler)) { + io_watch_del(&erl_io_h, fm->fd, idx, IO_FD_CLOSING); io_handler_del(phandler); - if (fm->type == ERL_WORKER_H) { - LM_CRIT("error on unix socket, not recoverable error -- aborting\n"); + if(fm->type == ERL_WORKER_H) { + LM_CRIT("error on unix socket, not recoverable error -- " + "aborting\n"); abort(); } return -1; } - if (phandler->new) { - switch (fm->type) { - case ERL_CSOCKFD_H: - type = ERL_WORKER_H; - break; - case ERL_EPMD_H: - type = ERL_CNODE_H; - break; - default: - LM_ERR("should not be here!\n"); - return -1; + if(phandler->new) { + switch(fm->type) { + case ERL_CSOCKFD_H: + type = ERL_WORKER_H; + break; + case ERL_EPMD_H: + type = ERL_CNODE_H; + break; + default: + LM_ERR("should not be here!\n"); + return -1; } - LM_DBG("add new handler type=%d\n",type); - if (io_watch_add(&erl_io_h,phandler->new->sockfd,POLLIN,type,(void*)phandler->new)) { + LM_DBG("add new handler type=%d\n", type); + if(io_watch_add(&erl_io_h, phandler->new->sockfd, POLLIN, type, + (void *)phandler->new)) { LM_ERR("failed to add new handler\n"); return -1; } @@ -407,7 +416,7 @@ int handle_cnode(handler_common_t *phandler) ei_x_buff *response; int response_start_index; - listener = (cnode_handler_t*) phandler; + listener = (cnode_handler_t *)phandler; request = &listener->request; response = &listener->response; @@ -416,87 +425,96 @@ int handle_cnode(handler_common_t *phandler) listener->tick_tmo = 0; /* reset ERL_TICK timer for all events */ - memset((void*)&emsg,0,sizeof(erlang_msg)); + memset((void *)&emsg, 0, sizeof(erlang_msg)); - if ((got = ei_xreceive_msg_tmo(listener->sockfd, &emsg, request, - CONNECT_TIMEOUT)) == ERL_TICK) - { /* ignore */ - LM_DBG("%s received ERL_TICK from <%s>.\n", listener->ec.thisnodename, listener->conn.nodename); + if((got = ei_xreceive_msg_tmo( + listener->sockfd, &emsg, request, CONNECT_TIMEOUT)) + == ERL_TICK) { /* ignore */ + LM_DBG("%s received ERL_TICK from <%s>.\n", listener->ec.thisnodename, + listener->conn.nodename); return 0; - } - else if (got == ERL_ERROR) - { - switch (erl_errno) - { - case EAGAIN: - /* or */ - case ETIMEDOUT: - response->index = response_start_index; /* restore version point */ - return 0; - break; - case EIO: - LM_ERR("I/O error while receiving message from %s or connection closed.\n", listener->conn.nodename); - enode = NULL; - return -1; - break; - case ENOMEM: - LM_ERR("Failed to receive message from %s, not enough memory. Closing connection.\n", listener->conn.nodename); - enode = NULL; - return -1; - break; - default: - LM_ERR("Close connection to %s. %s.\n", listener->conn.nodename, strerror(erl_errno)); - enode = NULL; - return -1; + } else if(got == ERL_ERROR) { + switch(erl_errno) { + case EAGAIN: + /* or */ + case ETIMEDOUT: + response->index = + response_start_index; /* restore version point */ + return 0; + break; + case EIO: + LM_ERR("I/O error while receiving message from %s or " + "connection closed.\n", + listener->conn.nodename); + enode = NULL; + return -1; + break; + case ENOMEM: + LM_ERR("Failed to receive message from %s, not enough memory. " + "Closing connection.\n", + listener->conn.nodename); + enode = NULL; + return -1; + break; + default: + LM_ERR("Close connection to %s. %s.\n", listener->conn.nodename, + strerror(erl_errno)); + enode = NULL; + return -1; } - } - else if (got == ERL_MSG) - { + } else if(got == ERL_MSG) { response->index = response_start_index; /* restore version point */ - switch (emsg.msgtype) - { - case ERL_LINK: - LM_WARN("ERL_LINK from <%s> -- discarding.\n", listener->conn.nodename); - break; - case ERL_REG_SEND: - PRINT_DBG_REG_SEND(listener->conn.nodename,emsg.from, listener->ec.thisnodename, emsg.toname,request); - handle_erlang_msg(listener, &emsg); - break; - case ERL_SEND: - PRINT_DBG_SEND(listener->conn.nodename,emsg.to,request); - handle_erlang_msg(listener, &emsg); - break; - case ERL_EXIT: - LM_WARN("received ERL_EXIT from <%s> -- discarding.\n", listener->conn.nodename); - break; - case ERL_UNLINK: - LM_WARN("ERL_UNLINK from <%s> -- discarding.\n", listener->conn.nodename); - break; - case ERL_NODE_LINK: - LM_WARN("ERL_NODE_LINK from <%s> -- discarding.\n", listener->conn.nodename); - break; - case ERL_GROUP_LEADER: - LM_WARN("ERL_GROUP_LEADER from <%s> -- discarding.\n", listener->conn.nodename); - break; - case ERL_EXIT2: - LM_WARN("ERL_EXIT2 from <%s> -- discarding.\n", listener->conn.nodename); - break; - case ERL_PASS_THROUGH: - LM_WARN("ERL_PASS_THROUGH from <%s> -- discarding.\n", listener->conn.nodename); - break; - default: - LM_WARN("Received unknown msgtype <%ld> from <%s> -- discarding.\n", emsg.msgtype, listener->conn.nodename); - break; + switch(emsg.msgtype) { + case ERL_LINK: + LM_WARN("ERL_LINK from <%s> -- discarding.\n", + listener->conn.nodename); + break; + case ERL_REG_SEND: + PRINT_DBG_REG_SEND(listener->conn.nodename, emsg.from, + listener->ec.thisnodename, emsg.toname, request); + handle_erlang_msg(listener, &emsg); + break; + case ERL_SEND: + PRINT_DBG_SEND(listener->conn.nodename, emsg.to, request); + handle_erlang_msg(listener, &emsg); + break; + case ERL_EXIT: + LM_WARN("received ERL_EXIT from <%s> -- discarding.\n", + listener->conn.nodename); + break; + case ERL_UNLINK: + LM_WARN("ERL_UNLINK from <%s> -- discarding.\n", + listener->conn.nodename); + break; + case ERL_NODE_LINK: + LM_WARN("ERL_NODE_LINK from <%s> -- discarding.\n", + listener->conn.nodename); + break; + case ERL_GROUP_LEADER: + LM_WARN("ERL_GROUP_LEADER from <%s> -- discarding.\n", + listener->conn.nodename); + break; + case ERL_EXIT2: + LM_WARN("ERL_EXIT2 from <%s> -- discarding.\n", + listener->conn.nodename); + break; + case ERL_PASS_THROUGH: + LM_WARN("ERL_PASS_THROUGH from <%s> -- discarding.\n", + listener->conn.nodename); + break; + default: + LM_WARN("Received unknown msgtype <%ld> from <%s> -- " + "discarding.\n", + emsg.msgtype, listener->conn.nodename); + break; } - } - else - { + } else { LM_ERR("unknown return value from ei_xreceive_msg_tmo.\n"); } response->index = response_start_index; /* restore to version point */ - return 0; + return 0; } int wait_cnode_tmo(handler_common_t *phandler_t) @@ -526,14 +544,14 @@ int handle_csockfd(handler_common_t *phandler_t) int data[2]; int fd = -1; - phandler = (csockfd_handler_t*)phandler_t; + phandler = (csockfd_handler_t *)phandler_t; - if (receive_fd(phandler->sockfd,(void*)data,sizeof(data),&fd,0) == -1) { - LM_ERR("failed to receive socket: %s\n",strerror(errno)); + if(receive_fd(phandler->sockfd, (void *)data, sizeof(data), &fd, 0) == -1) { + LM_ERR("failed to receive socket: %s\n", strerror(errno)); return -1; } - phandler->new = (handler_common_t*)pkg_malloc(sizeof(worker_handler_t)); + phandler->new = (handler_common_t *)pkg_malloc(sizeof(worker_handler_t)); if(!phandler->new) { LM_ERR("not enough memory\n"); return -1; @@ -541,29 +559,30 @@ int handle_csockfd(handler_common_t *phandler_t) io_handler_ins(phandler->new); - return worker_init((worker_handler_t*)phandler->new,fd,&phandler_t->ec); + return worker_init((worker_handler_t *)phandler->new, fd, &phandler_t->ec); } /* * \brief Connect to Erlang node if not connected */ -int enode_connect() { +int enode_connect() +{ handler_common_t *phandler; - if (!csocket_handler) { + if(!csocket_handler) { return -1; } - if (enode) { + if(enode) { return 0; } LM_DBG("not connected, trying to connect...\n"); - phandler = (handler_common_t*)pkg_malloc(sizeof(cnode_handler_t)); + phandler = (handler_common_t *)pkg_malloc(sizeof(cnode_handler_t)); - if (!phandler) { + if(!phandler) { LM_CRIT("not enough memory\n"); return -1; } @@ -571,11 +590,13 @@ int enode_connect() { io_handler_ins(phandler); /* connect to remote Erlang node */ - if (cnode_connect_to((cnode_handler_t*)phandler,&csocket_handler->ec, erlang_nodename.s?&erlang_nodename:&erlang_node_sname)) { + if(cnode_connect_to((cnode_handler_t *)phandler, &csocket_handler->ec, + erlang_nodename.s ? &erlang_nodename : &erlang_node_sname)) { /* continue even failed to connect, connection can be established * from Erlang side too */ io_handler_del(phandler); - } else if (io_watch_add(&erl_io_h,phandler->sockfd,POLLIN,ERL_CNODE_H,phandler)){ + } else if(io_watch_add(&erl_io_h, phandler->sockfd, POLLIN, ERL_CNODE_H, + phandler)) { LM_CRIT("io_watch_add failed\n"); erl_close_socket(phandler->sockfd); io_handler_del(phandler); diff --git a/src/modules/erlang/cnode.h b/src/modules/erlang/cnode.h index 32d8333b71f..4509c0633f5 100644 --- a/src/modules/erlang/cnode.h +++ b/src/modules/erlang/cnode.h @@ -45,7 +45,7 @@ typedef struct cnode_handler_s int (*handle_f)(handler_common_t *phandler_t); int (*wait_tmo_f)(handler_common_t *phandler_t); int (*destroy_f)(handler_common_t *phandler_t); - int sockfd; /* connection socket to remote erlang node */ + int sockfd; /* connection socket to remote erlang node */ ei_cnode ec; /* erlang C node (actually it's kamailio node) */ /* @@ -83,7 +83,7 @@ typedef struct csockfd_handler_s int (*handle_f)(handler_common_t *phandler_t); int (*wait_tmo_f)(handler_common_t *phandler_t); int (*destroy_f)(handler_common_t *phandler_t); - int sockfd; /* its csockfd */ + int sockfd; /* its csockfd */ ei_cnode ec; /* erlang C node (actually it's kamailio node) */ } csockfd_handler_t; @@ -99,10 +99,12 @@ int handle_cnode(handler_common_t *phandler_t); int wait_cnode_tmo(handler_common_t *phandler_t); int destroy_cnode(handler_common_t *phandler_t); -int cnode_connect_to(cnode_handler_t *phandler, ei_cnode *ec, const str *nodename ); +int cnode_connect_to( + cnode_handler_t *phandler, ei_cnode *ec, const str *nodename); int enode_connect(); -enum erl_handle_type { +enum erl_handle_type +{ ERL_EPMD_H = 1, ERL_CNODE_H, ERL_WORKER_H, diff --git a/src/modules/erlang/epmd.c b/src/modules/erlang/epmd.c index dbadf9fc05d..42004fef2e5 100644 --- a/src/modules/erlang/epmd.c +++ b/src/modules/erlang/epmd.c @@ -44,8 +44,8 @@ int epmd_init(epmd_handler_t *epmd, str *alivename) epmd->sockfd = erl_init_node(&epmd->ec, alivename, &cnode_host, &cookie); epmd->handle_f = handle_epmd; epmd->wait_tmo_f = NULL; - epmd->destroy_f = NULL; - epmd->new = NULL; + epmd->destroy_f = NULL; + epmd->new = NULL; return epmd->sockfd; } @@ -56,7 +56,7 @@ int epmd_init(epmd_handler_t *epmd, str *alivename) int handle_epmd(handler_common_t *phandler) { struct ip_addr ip; - struct sockaddr addr = { 0 }; + struct sockaddr addr = {0}; struct sockaddr *paddr; socklen_t addrlen = sizeof(struct sockaddr); int port; @@ -69,56 +69,54 @@ int handle_epmd(handler_common_t *phandler) ErlConnect conn; paddr = &addr; - me = (epmd_handler_t*) phandler; + me = (epmd_handler_t *)phandler; - if ((sockfd = ei_accept_tmo(&me->ec, me->sockfd, &conn, CONNECT_TIMEOUT)) + if((sockfd = ei_accept_tmo(&me->ec, me->sockfd, &conn, CONNECT_TIMEOUT)) == ERL_ERROR) { LM_ERR("error on accept connection: %s.\n", strerror(erl_errno)); - if (erl_errno == ETIMEDOUT) { + if(erl_errno == ETIMEDOUT) { return 0; - } else if (errno) { + } else if(errno) { LM_ERR("socket error: %s\n", strerror(errno)); return -1; } else { /* if errno didn't get set, assume nothing *too much* horrible occurred */ - LM_NOTICE("ignored error in ei_accept, probably: bad client version, " + LM_NOTICE( + "ignored error in ei_accept, probably: bad client version, " "bad cookie or bad node name\n"); } return 0; } /* get remote address info of connected socket */ - if ((ai_error = getpeername(sockfd, paddr, &addrlen))) - { - LM_ERR("%s\n",strerror(errno)); - } - else - { - sockaddr2ip_addr(&ip,paddr); + if((ai_error = getpeername(sockfd, paddr, &addrlen))) { + LM_ERR("%s\n", strerror(errno)); + } else { + sockaddr2ip_addr(&ip, paddr); port = sockaddr_port(paddr); LM_DBG("connected from %s port %u\n", ip_addr2strz(&ip), port); } - remotenode = (cnode_handler_t*)pkg_malloc(sizeof(cnode_handler_t)); - if (!remotenode) { + remotenode = (cnode_handler_t *)pkg_malloc(sizeof(cnode_handler_t)); + if(!remotenode) { erl_close_socket(sockfd); return -1; } /* tos */ - on=IPTOS_LOWDELAY; - if (setsockopt(sockfd, IPPROTO_IP, IP_TOS, (void*)&on,sizeof(on)) ==-1) { - LM_WARN("setsockopt set tos failed: %s\n", strerror(errno)); - /* continue since this is not critical */ + on = IPTOS_LOWDELAY; + if(setsockopt(sockfd, IPPROTO_IP, IP_TOS, (void *)&on, sizeof(on)) == -1) { + LM_WARN("setsockopt set tos failed: %s\n", strerror(errno)); + /* continue since this is not critical */ } - if (erl_set_nonblock(sockfd)){ + if(erl_set_nonblock(sockfd)) { LM_ERR("set non blocking socket failed\n"); } - memset((void*)remotenode,0,sizeof(cnode_handler_t)); + memset((void *)remotenode, 0, sizeof(cnode_handler_t)); remotenode->handle_f = handle_cnode; remotenode->wait_tmo_f = wait_cnode_tmo; @@ -129,19 +127,17 @@ int handle_epmd(handler_common_t *phandler) /* for #Pid */ remotenode->ec.self.num = sockfd; - if (ei_x_new(&remotenode->request)) - { - LOG(L_ERR,"failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); + if(ei_x_new(&remotenode->request)) { + LOG(L_ERR, "failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); return -1; } - if (ei_x_new_with_version(&remotenode->response)) - { - LOG(L_ERR,"failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); + if(ei_x_new_with_version(&remotenode->response)) { + LOG(L_ERR, "failed to allocate ei_x_buff: %s.\n", strerror(erl_errno)); return -1; } - phandler->new = (handler_common_t*)remotenode; + phandler->new = (handler_common_t *)remotenode; /* activate node */ enode = remotenode; diff --git a/src/modules/erlang/epmd.h b/src/modules/erlang/epmd.h index 09b3eb59f0a..621d78b9cbb 100644 --- a/src/modules/erlang/epmd.h +++ b/src/modules/erlang/epmd.h @@ -50,7 +50,7 @@ typedef struct epmd_handler_s int (*handle_f)(handler_common_t *handler); int (*wait_tmo_f)(handler_common_t *handler); int (*destroy_f)(handler_common_t *handler); - int sockfd; /* socket to epmd */ + int sockfd; /* socket to epmd */ ei_cnode ec; /* erlang C node (actually it's me) */ } epmd_handler_t; diff --git a/src/modules/erlang/erl_api.c b/src/modules/erlang/erl_api.c index c7f074cd418..455e2875972 100644 --- a/src/modules/erlang/erl_api.c +++ b/src/modules/erlang/erl_api.c @@ -30,7 +30,8 @@ #include #include -int _impl_api_rpc_call(ei_x_buff* reply, const str *module,const str *function, const ei_x_buff *args); +int _impl_api_rpc_call(ei_x_buff *reply, const str *module, const str *function, + const ei_x_buff *args); int _impl_reg_send(const str *server, const ei_x_buff *msg); int _impl_send(const erlang_pid *pid, const ei_x_buff *msg); int _impl_reply(const ei_x_buff *msg); @@ -42,7 +43,7 @@ int xbuff2xavp(sr_xavp_t **xavp, ei_x_buff *xbuff); * \param erl_api Erlang API export binding * \return 1 */ -int load_erl( erl_api_t *erl_api ) +int load_erl(erl_api_t *erl_api) { erl_api->rpc = _impl_api_rpc_call; erl_api->reg_send = _impl_reg_send; @@ -59,64 +60,65 @@ int load_erl( erl_api_t *erl_api ) */ int xavp2xbuff(ei_x_buff *xbuff, sr_xavp_t *xavp) { - return xavp_encode(xbuff,xavp,0); + return xavp_encode(xbuff, xavp, 0); } int xbuff2xavp(sr_xavp_t **xavp, ei_x_buff *xbuff) { - int i=0, version=0; - if (ei_decode_version(xbuff->buff,&i,&version)) - { + int i = 0, version = 0; + if(ei_decode_version(xbuff->buff, &i, &version)) { LM_DBG("no version byte encoded in reply\n"); } - return xavp_decode(xbuff,&i,xavp,0); + return xavp_decode(xbuff, &i, xavp, 0); } -int _impl_api_rpc_call(ei_x_buff *reply, const str *module,const str *function, const ei_x_buff *args) +int _impl_api_rpc_call(ei_x_buff *reply, const str *module, const str *function, + const ei_x_buff *args) { struct msghdr msgh; struct iovec cnt[8]; int pid_no = my_pid(); eapi_t api = API_RPC_CALL; - int buffsz=0; + int buffsz = 0; int rc; - if (!csockfd) { + if(!csockfd) { - if (!enode) { + if(!enode) { LM_NOTICE("there is no connected Erlang node\n"); /* reply up with error */ ei_x_format(reply, "{error,cnode,~a}", "no_erlang_node"); return -1; } - if (rex_call_in_progress) { + if(rex_call_in_progress) { LM_ERR("RPC loop detected\n"); ei_x_format(reply, "{badrpc,cnode,~a}", "rpc_loop_detected"); return -1; } /* do RPC from event route */ - if (ei_rpc(&enode->ec,enode->sockfd,module->s,function->s,args->buff,args->index,reply) == ERL_ERROR) - { + if(ei_rpc(&enode->ec, enode->sockfd, module->s, function->s, args->buff, + args->index, reply) + == ERL_ERROR) { reply->index = 0; /* re-use reply buffer */ - if (erl_errno) - { + if(erl_errno) { ei_x_format(reply, "{error,cnode,~s}", strerror(erl_errno)); - LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno)); - } - else if (errno) - { + LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, + strerror(erl_errno)); + } else if(errno) { ei_x_format(reply, "{error,cnode,~s}", strerror(errno)); - LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno)); - } - else - { + LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(errno)); + } else { ei_x_format(reply, "{error,cnode,~s}", "Unknown error."); - LM_ERR("ei_rpc failed on node=<%s> socket=<%d>, Unknown error.\n",enode->ec.thisalivename,enode->sockfd); + LM_ERR("ei_rpc failed on node=<%s> socket=<%d>, Unknown " + "error.\n", + enode->ec.thisalivename, enode->sockfd); } return -1; } @@ -129,82 +131,82 @@ int _impl_api_rpc_call(ei_x_buff *reply, const str *module,const str *function, memset(&cnt, 0, sizeof(cnt)); /* Kamailio PID */ - cnt[0].iov_base = (void*)&pid_no; - cnt[0].iov_len = sizeof(pid_no); + cnt[0].iov_base = (void *)&pid_no; + cnt[0].iov_len = sizeof(pid_no); /* method */ - cnt[1].iov_base = (void*)&api; + cnt[1].iov_base = (void *)&api; cnt[1].iov_len = sizeof(api); /* put size of following data */ - cnt[2].iov_base = (void*)&module->len; - cnt[2].iov_len = sizeof(int); + cnt[2].iov_base = (void *)&module->len; + cnt[2].iov_len = sizeof(int); - cnt[3].iov_base = (void*)&function->len; - cnt[3].iov_len = sizeof(int); + cnt[3].iov_base = (void *)&function->len; + cnt[3].iov_len = sizeof(int); buffsz = args->index; /* occupied size */ - cnt[4].iov_base = (void*) &buffsz; + cnt[4].iov_base = (void *)&buffsz; cnt[4].iov_len = sizeof(buffsz); /* module name */ - cnt[5].iov_base = (void*)module->s; - cnt[5].iov_len = module->len; + cnt[5].iov_base = (void *)module->s; + cnt[5].iov_len = module->len; /* function name */ - cnt[6].iov_base = (void*)function->s; - cnt[6].iov_len = function->len; + cnt[6].iov_base = (void *)function->s; + cnt[6].iov_len = function->len; /* Erlang arguments content */ - cnt[7].iov_base = (void*)args->buff; + cnt[7].iov_base = (void *)args->buff; cnt[7].iov_len = buffsz; /* occupied size */ msgh.msg_iov = cnt; msgh.msg_iovlen = 8; - while ((rc = sendmsg(csockfd, &msgh, 0)) == -1 && errno == EAGAIN) + while((rc = sendmsg(csockfd, &msgh, 0)) == -1 && errno == EAGAIN) ; - if (rc == -1) { - LM_ERR("sendmsg failed: %s\n",strerror(errno)); + if(rc == -1) { + LM_ERR("sendmsg failed: %s\n", strerror(errno)); return -1; } /*receive into reply buffer */ cnt[1].iov_base = &buffsz; - cnt[1].iov_len = sizeof(buffsz); + cnt[1].iov_len = sizeof(buffsz); /* peek reply size safe */ msgh.msg_iovlen = 2; - while ((rc = recvmsg(csockfd, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) + while((rc = recvmsg(csockfd, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) ; - if (rc == -1) { - LM_ERR("recvmsg failed: %s\n",strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed: %s\n", strerror(errno)); return -1; } - if (reply->buffsz < buffsz) { + if(reply->buffsz < buffsz) { ei_x_free(reply); reply->buffsz = buffsz + 1; - reply->buff = (char*)malloc(reply->buffsz); + reply->buff = (char *)malloc(reply->buffsz); } - cnt[2].iov_base = (void*)reply->buff; - cnt[2].iov_len = buffsz; + cnt[2].iov_base = (void *)reply->buff; + cnt[2].iov_len = buffsz; msgh.msg_iovlen = 3; - while ((rc = recvmsg(csockfd, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) + while((rc = recvmsg(csockfd, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) ; - if (rc == -1) { - LM_ERR("recvmsg failed: %s\n",strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed: %s\n", strerror(errno)); return -1; } if(pid_no != my_pid()) { /* should never happened */ - LM_CRIT("BUG: got other process reply (pid_no=%d)\n",pid_no); + LM_CRIT("BUG: got other process reply (pid_no=%d)\n", pid_no); return -1; } @@ -219,42 +221,43 @@ int _impl_reg_send(const str *server, const ei_x_buff *msg) eapi_t api = API_REG_SEND; int buffsz; int rc; - int i=0,version; + int i = 0, version; memset(&msgh, 0, sizeof(msgh)); memset(&cnt, 0, sizeof(cnt)); - if (ei_decode_version(msg->buff,&i,&version)) { + if(ei_decode_version(msg->buff, &i, &version)) { LM_ERR("msg must be encoded with version\n"); return -1; } - if (!csockfd) { + if(!csockfd) { - if (!enode) { + if(!enode) { LM_NOTICE("there is no connected Erlang node\n"); return -1; } - if (rex_call_in_progress) { + if(rex_call_in_progress) { LM_ERR("RPC in progress detected\n"); return -1; } /* do ERL_REG_SEND in event route */ - if ((rc = ei_reg_send(&enode->ec,enode->sockfd,server->s,msg->buff,msg->buffsz)) == ERL_ERROR) - { - if (erl_errno) - { - LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno)); - } - else if (errno) - { - LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno)); - } - else - { - LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>, Unknown error.\n",enode->ec.thisalivename,enode->sockfd); + if((rc = ei_reg_send(&enode->ec, enode->sockfd, server->s, msg->buff, + msg->buffsz)) + == ERL_ERROR) { + if(erl_errno) { + LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, + strerror(erl_errno)); + } else if(errno) { + LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(errno)); + } else { + LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>, Unknown " + "error.\n", + enode->ec.thisalivename, enode->sockfd); } } /* reset response */ @@ -263,37 +266,37 @@ int _impl_reg_send(const str *server, const ei_x_buff *msg) } /* Kamailio PID */ - cnt[0].iov_base = (void*)&pid_no; - cnt[0].iov_len = sizeof(pid_no); + cnt[0].iov_base = (void *)&pid_no; + cnt[0].iov_len = sizeof(pid_no); /* method */ - cnt[1].iov_base = (void*)&api; + cnt[1].iov_base = (void *)&api; cnt[1].iov_len = sizeof(api); /* put size of following data */ - cnt[2].iov_base = (void*)&server->len; - cnt[2].iov_len = sizeof(int); + cnt[2].iov_base = (void *)&server->len; + cnt[2].iov_len = sizeof(int); buffsz = msg->index; /* occupied size */ - cnt[3].iov_base = (void*)&buffsz; + cnt[3].iov_base = (void *)&buffsz; cnt[3].iov_len = sizeof(buffsz); /* module name */ - cnt[4].iov_base = (void*)server->s; - cnt[4].iov_len = server->len; + cnt[4].iov_base = (void *)server->s; + cnt[4].iov_len = server->len; /* Erlang arguments content */ - cnt[5].iov_base = (void*)msg->buff; + cnt[5].iov_base = (void *)msg->buff; cnt[5].iov_len = buffsz; /* occupied size */ msgh.msg_iov = cnt; msgh.msg_iovlen = 6; - while ((rc = sendmsg(csockfd, &msgh, 0)) == -1 && errno == EAGAIN) + while((rc = sendmsg(csockfd, &msgh, 0)) == -1 && errno == EAGAIN) ; - if (rc == -1) { - LM_ERR("sendmsg failed: %s\n",strerror(errno)); + if(rc == -1) { + LM_ERR("sendmsg failed: %s\n", strerror(errno)); return -1; } @@ -304,40 +307,40 @@ int _impl_reg_send(const str *server, const ei_x_buff *msg) int _impl_reply(const ei_x_buff *msg) { - int i=0,version; + int i = 0, version; - if (ei_decode_version(msg->buff,&i,&version)) { + if(ei_decode_version(msg->buff, &i, &version)) { LM_ERR("msg must be encoded with version\n"); return -1; } /* must be in call back / event route */ - if (csockfd) { + if(csockfd) { LM_ERR("not in callback\n"); return -1; - } else if (!enode) { + } else if(!enode) { LM_ERR("not connected\n"); return -1; } - if (rex_call_in_progress) { + if(rex_call_in_progress) { LM_ERR("RPC in progress detected\n"); return -1; } /* copy into reply */ - if (enode->response.buffsz < msg->buffsz) { + if(enode->response.buffsz < msg->buffsz) { /* reallocate */ - enode->response.buff=realloc(enode->response.buff,msg->buffsz); - if (!enode->response.buff) { + enode->response.buff = realloc(enode->response.buff, msg->buffsz); + if(!enode->response.buff) { LM_ERR("realloc failed: not enough memory\n"); return -1; } enode->response.buffsz = msg->buffsz; } - memcpy((void*)enode->response.buff,(void*)msg->buff,msg->buffsz); + memcpy((void *)enode->response.buff, (void *)msg->buff, msg->buffsz); enode->response.index = msg->index; return 0; @@ -351,72 +354,72 @@ int _impl_send(const erlang_pid *pid, const ei_x_buff *msg) eapi_t api = API_SEND; int buffsz; int rc; - int i=0,version; + int i = 0, version; - if (ei_decode_version(msg->buff,&i,&version)) { + if(ei_decode_version(msg->buff, &i, &version)) { LM_ERR("msg must be encoded with version\n"); return -1; } - if (rex_call_in_progress) { + if(rex_call_in_progress) { LM_ERR("RPC in progress detected\n"); return -1; } - if (enode) { + if(enode) { /* copy into reply */ - if (enode->response.buffsz < msg->buffsz) { + if(enode->response.buffsz < msg->buffsz) { /* reallocate */ - enode->response.buff=realloc(enode->response.buff,msg->buffsz); - if (!enode->response.buff) { + enode->response.buff = realloc(enode->response.buff, msg->buffsz); + if(!enode->response.buff) { LM_ERR("realloc failed: not enough memory\n"); return -1; } enode->response.buffsz = msg->buffsz; } - memcpy((void*)enode->response.buff,(void*)msg->buff,msg->buffsz); + memcpy((void *)enode->response.buff, (void *)msg->buff, msg->buffsz); enode->response.index = msg->index; /* address process */ cnode_reply_to_pid = (erlang_pid *)pid; return 0; - } else if (csockfd) { + } else if(csockfd) { /* send via cnode */ memset(&msgh, 0, sizeof(msgh)); memset(&cnt, 0, sizeof(cnt)); /* Kamailio PID */ - cnt[0].iov_base = (void*)&pid_no; - cnt[0].iov_len = sizeof(pid_no); + cnt[0].iov_base = (void *)&pid_no; + cnt[0].iov_len = sizeof(pid_no); /* method */ - cnt[1].iov_base = (void*)&api; + cnt[1].iov_base = (void *)&api; cnt[1].iov_len = sizeof(api); /* put size of following data */ buffsz = msg->index; /* occupied size */ - cnt[2].iov_base = (void*)&buffsz; + cnt[2].iov_base = (void *)&buffsz; cnt[2].iov_len = sizeof(buffsz); /* module name */ - cnt[3].iov_base = (void*)pid; - cnt[3].iov_len = sizeof(erlang_pid); + cnt[3].iov_base = (void *)pid; + cnt[3].iov_len = sizeof(erlang_pid); /* Erlang arguments content */ - cnt[4].iov_base = (void*)msg->buff; + cnt[4].iov_base = (void *)msg->buff; cnt[4].iov_len = buffsz; /* occupied size */ msgh.msg_iov = cnt; msgh.msg_iovlen = 5; - while ((rc = sendmsg(csockfd, &msgh, 0)) == -1 && errno == EAGAIN) + while((rc = sendmsg(csockfd, &msgh, 0)) == -1 && errno == EAGAIN) ; - if (rc == -1) { - LM_ERR("sendmsg failed: %s\n",strerror(errno)); + if(rc == -1) { + LM_ERR("sendmsg failed: %s\n", strerror(errno)); return -1; } } else { diff --git a/src/modules/erlang/erl_api.h b/src/modules/erlang/erl_api.h index e66f086713f..faf8036c7d7 100644 --- a/src/modules/erlang/erl_api.h +++ b/src/modules/erlang/erl_api.h @@ -29,16 +29,18 @@ #include "../../core/xavp.h" #include -typedef int (*erl_rpc_f)(ei_x_buff* reply, const str *module,const str *function, const ei_x_buff *args); -typedef int (*erl_reg_send_f)(const str *server,const ei_x_buff *msg); +typedef int (*erl_rpc_f)(ei_x_buff *reply, const str *module, + const str *function, const ei_x_buff *args); +typedef int (*erl_reg_send_f)(const str *server, const ei_x_buff *msg); typedef int (*erl_reply_f)(const ei_x_buff *msg); -typedef int (*erl_send_f)(const erlang_pid *pid,const ei_x_buff *msg); +typedef int (*erl_send_f)(const erlang_pid *pid, const ei_x_buff *msg); /* data serialization */ typedef int (*xavp2xbuff_f)(ei_x_buff *xbuff, sr_xavp_t *xavp); typedef int (*xbuff2xavp_f)(sr_xavp_t **xavp, ei_x_buff *xbuff); -typedef struct erl_api_s { +typedef struct erl_api_s +{ erl_rpc_f rpc; erl_reg_send_f reg_send; erl_send_f send; @@ -47,48 +49,48 @@ typedef struct erl_api_s { xbuff2xavp_f xbuff2xavp; } erl_api_t; -typedef int (*load_erl_f)( erl_api_t* ); +typedef int (*load_erl_f)(erl_api_t *); /*! * \brief API bind function exported by the module - it will load the other functions * \param erl_api Erlang API export binding * \return 1 */ -int load_erl( erl_api_t *erl_api ); +int load_erl(erl_api_t *erl_api); /*! * \brief Function to be called directly from other modules to load the Erlang API * \param erl_api Erlang API export binding * \return 0 on success, -1 if the API loader could not imported */ -inline static int erl_load_api( erl_api_t *erl_api ) +inline static int erl_load_api(erl_api_t *erl_api) { - load_erl_f load_erl_v; + load_erl_f load_erl_v; - /* import the Erlang API auto-loading function */ - if ( !(load_erl_v=(load_erl_f)find_export("load_erl", 0, 0))) { - LM_ERR("failed to import load_erl\n"); - return -1; - } - /* let the auto-loading function load all Erlang stuff */ - load_erl_v( erl_api ); + /* import the Erlang API auto-loading function */ + if(!(load_erl_v = (load_erl_f)find_export("load_erl", 0, 0))) { + LM_ERR("failed to import load_erl\n"); + return -1; + } + /* let the auto-loading function load all Erlang stuff */ + load_erl_v(erl_api); - return 0; + return 0; } /** * debugging macro * uses LM_DBG to print ei_x_buff */ -#define EI_X_BUFF_PRINT(buf) \ -do{ \ - char *mbuf = NULL; \ - int i = 0, v=0; \ - ei_decode_version((buf)->buff,&i,&v);\ - i=v?i:0; \ - ei_s_print_term(&mbuf, (buf)->buff, &i); \ - LM_DBG(#buf": %s\n", mbuf); \ - free(mbuf); \ -} while(0) +#define EI_X_BUFF_PRINT(buf) \ + do { \ + char *mbuf = NULL; \ + int i = 0, v = 0; \ + ei_decode_version((buf)->buff, &i, &v); \ + i = v ? i : 0; \ + ei_s_print_term(&mbuf, (buf)->buff, &i); \ + LM_DBG(#buf ": %s\n", mbuf); \ + free(mbuf); \ + } while(0) #endif /* ERL_API_H_ */ diff --git a/src/modules/erlang/erl_helpers.c b/src/modules/erlang/erl_helpers.c index 8c7a3918304..32a0a0fa85d 100644 --- a/src/modules/erlang/erl_helpers.c +++ b/src/modules/erlang/erl_helpers.c @@ -40,10 +40,11 @@ int erl_set_nonblock(int sockfd) flags = fcntl(sockfd, F_GETFD); - if (flags == -1) { - LM_ERR("socket %d read settings error: %s\n",sockfd,strerror(errno)); - } else if (fcntl(sockfd, F_SETFD, flags|O_NONBLOCK) == -1) { - LM_ERR("socket %d set O_NONBLOCK failed: %s\n",sockfd,strerror(errno)); + if(flags == -1) { + LM_ERR("socket %d read settings error: %s\n", sockfd, strerror(errno)); + } else if(fcntl(sockfd, F_SETFD, flags | O_NONBLOCK) == -1) { + LM_ERR("socket %d set O_NONBLOCK failed: %s\n", sockfd, + strerror(errno)); } else { return 0; } @@ -53,7 +54,7 @@ int erl_set_nonblock(int sockfd) void erl_close_socket(int sockfd) { - if (sockfd > 0) { + if(sockfd > 0) { shutdown(sockfd, SHUT_RDWR); close(sockfd); } @@ -64,8 +65,7 @@ void erl_close_socket(int sockfd) * Allocate & bind a server socket using TCP. * */ -int erl_passive_socket(const char *hostname, int qlen, - struct addrinfo **ai_ret) +int erl_passive_socket(const char *hostname, int qlen, struct addrinfo **ai_ret) { int sockfd; /* socket descriptor and socket type */ int on = 1; @@ -84,48 +84,45 @@ int erl_passive_socket(const char *hostname, int qlen, hints.ai_flags = AI_V4MAPPED; hints.ai_protocol = IPPROTO_TCP; - if ((error_num = getaddrinfo(hostname, 0 /* unused */, &hints, &ai))) - { - LM_CRIT("failed to resolve %s: %s\n", hostname, gai_strerror(error_num)); + if((error_num = getaddrinfo(hostname, 0 /* unused */, &hints, &ai))) { + LM_CRIT("failed to resolve %s: %s\n", hostname, + gai_strerror(error_num)); return -1; } /* Allocate a socket */ sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); - if (sockfd < 0) - { + if(sockfd < 0) { LM_CRIT("failed to create socket. %s.\n", strerror(errno)); freeaddrinfo(ai); return -1; } /* initialize TCP */ -#if !defined(TCP_DONT_REUSEADDR) - if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int))) { +#if !defined(TCP_DONT_REUSEADDR) + if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int))) { LM_ERR("failed to enable SO_REUSEADDR: %s\n", strerror(errno)); } #endif /* tos */ - on=IPTOS_LOWDELAY; - if (setsockopt(sockfd, IPPROTO_IP, IP_TOS, (void*)&on,sizeof(on)) ==-1) { - LM_WARN("setsockopt tos: %s\n", strerror(errno)); - /* continue since this is not critical */ + on = IPTOS_LOWDELAY; + if(setsockopt(sockfd, IPPROTO_IP, IP_TOS, (void *)&on, sizeof(on)) == -1) { + LM_WARN("setsockopt tos: %s\n", strerror(errno)); + /* continue since this is not critical */ } /* Bind the socket */ - if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) - { - port=sockaddr_port(ai->ai_addr); - LM_CRIT("failed to bind socket on %s:%u. %s.\n", hostname, - port, strerror(errno)); + if(bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) { + port = sockaddr_port(ai->ai_addr); + LM_CRIT("failed to bind socket on %s:%u. %s.\n", hostname, port, + strerror(errno)); erl_close_socket(sockfd); freeaddrinfo(ai); return -1; } - if (ai->ai_socktype == SOCK_STREAM && listen(sockfd, qlen) < 0) - { + if(ai->ai_socktype == SOCK_STREAM && listen(sockfd, qlen) < 0) { LM_CRIT("failed to listen socket on %s: %s.\n", hostname, strerror(errno)); @@ -136,21 +133,16 @@ int erl_passive_socket(const char *hostname, int qlen, } /* get addr on socket */ - if (getsockname(sockfd, ai->ai_addr, &addrlen)){ - LM_ERR("getsockname failed: %s\n",strerror(errno)); + if(getsockname(sockfd, ai->ai_addr, &addrlen)) { + LM_ERR("getsockname failed: %s\n", strerror(errno)); } - if (ai_ret && *ai_ret == NULL) - { + if(ai_ret && *ai_ret == NULL) { *ai_ret = ai; - } - else if (ai_ret) - { + } else if(ai_ret) { freeaddrinfo(*ai_ret); *ai_ret = ai; - } - else - { + } else { freeaddrinfo(ai); } @@ -177,23 +169,18 @@ int erl_active_socket(const char *hostname, int qlen, struct addrinfo **ai_ret) hints.ai_flags = AI_V4MAPPED; hints.ai_protocol = IPPROTO_TCP; - if ((error_num = getaddrinfo(hostname, 0 /* unused */, &hints, &ai))) - { - LM_CRIT("failed to resolve %s: %s\n", hostname, gai_strerror(error_num)); + if((error_num = getaddrinfo(hostname, 0 /* unused */, &hints, &ai))) { + LM_CRIT("failed to resolve %s: %s\n", hostname, + gai_strerror(error_num)); return -1; } - if (ai_ret && *ai_ret == NULL) - { + if(ai_ret && *ai_ret == NULL) { *ai_ret = ai; - } - else if (ai_ret) - { + } else if(ai_ret) { freeaddrinfo(*ai_ret); *ai_ret = ai; - } - else - { + } else { freeaddrinfo(ai); } @@ -206,8 +193,7 @@ int erl_active_socket(const char *hostname, int qlen, struct addrinfo **ai_ret) void erl_init_common() { /* distribution trace level */ - if (trace_level) - { + if(trace_level) { ei_set_tracelevel(trace_level); } } @@ -222,7 +208,8 @@ void erl_free_common() /** * @brief Initialize Erlang connection */ -int erl_init_ec(ei_cnode *ec, const str *alivename, const str *hostname, const str *cookie) +int erl_init_ec(ei_cnode *ec, const str *alivename, const str *hostname, + const str *cookie) { /* identifies a specific instance of a C node. */ short creation = getpid(); @@ -235,25 +222,33 @@ int erl_init_ec(ei_cnode *ec, const str *alivename, const str *hostname, const s int result; /* copy the nodename into something we can modify */ - if (snprintf(nodename, MAXNODELEN, "%.*s@%.*s", STR_FMT(alivename), STR_FMT(hostname)) >= MAXNODELEN) { - LM_CRIT("the node name %.*s@%.*s is too large max length allowed is %d\n", STR_FMT(alivename), STR_FMT(hostname), MAXNODELEN-1); + if(snprintf(nodename, MAXNODELEN, "%.*s@%.*s", STR_FMT(alivename), + STR_FMT(hostname)) + >= MAXNODELEN) { + LM_CRIT("the node name %.*s@%.*s is too large max length allowed is " + "%d\n", + STR_FMT(alivename), STR_FMT(hostname), MAXNODELEN - 1); return -1; } - if (erl_active_socket(hostname->s, 128, &ai)) { + if(erl_active_socket(hostname->s, 128, &ai)) { return -1; } - addr = (struct sockaddr*) ai->ai_addr; - sockaddr2ip_addr(&ip,addr); + addr = (struct sockaddr *)ai->ai_addr; + sockaddr2ip_addr(&ip, addr); - if ((result = ei_connect_xinit(ec, hostname->s, alivename->s, nodename, (Erl_IpAddr) &(((struct sockaddr_in*)ai->ai_addr)->sin_addr), cookie->s, creation)) < 0) { + if((result = ei_connect_xinit(ec, hostname->s, alivename->s, nodename, + (Erl_IpAddr) & (((struct sockaddr_in *)ai->ai_addr)->sin_addr), + cookie->s, creation)) + < 0) { LM_CRIT("failed to initialize self as cnode name %s\n", nodename); return -1; } - LM_DBG("initialized ec for cnode '%s' on %.*s[%s] creation %d.\n", nodename, STR_FMT(hostname), ip_addr2strz(&ip), creation); + LM_DBG("initialized ec for cnode '%s' on %.*s[%s] creation %d.\n", nodename, + STR_FMT(hostname), ip_addr2strz(&ip), creation); freeaddrinfo(ai); return 0; @@ -261,7 +256,8 @@ int erl_init_ec(ei_cnode *ec, const str *alivename, const str *hostname, const s /** * \brief Initialize C node server and returns listen socket. */ -int erl_init_node(ei_cnode *ec, const str *alivename, const str *hostname, const str *cookie) +int erl_init_node(ei_cnode *ec, const str *alivename, const str *hostname, + const str *cookie) { /* identifies a specific instance of a C node. */ short creation = getpid(); @@ -279,19 +275,26 @@ int erl_init_node(ei_cnode *ec, const str *alivename, const str *hostname, const int epmdfd; /* copy the nodename into something we can modify */ - if (snprintf(nodename, MAXNODELEN, "%.*s@%.*s", STR_FMT(alivename), STR_FMT(hostname)) >= MAXNODELEN) { - LM_CRIT("the node name %.*s@%.*s is too large max length allowed is %d\n", STR_FMT(alivename), STR_FMT(hostname), MAXNODELEN-1); + if(snprintf(nodename, MAXNODELEN, "%.*s@%.*s", STR_FMT(alivename), + STR_FMT(hostname)) + >= MAXNODELEN) { + LM_CRIT("the node name %.*s@%.*s is too large max length allowed is " + "%d\n", + STR_FMT(alivename), STR_FMT(hostname), MAXNODELEN - 1); return -1; } - if ((listen_fd = erl_passive_socket(hostname->s, 128, &ai)) == -1) { + if((listen_fd = erl_passive_socket(hostname->s, 128, &ai)) == -1) { return -1; } /* use first ip address only, it's internal Erlang connection to empd */ - addr = (struct sockaddr*) ai->ai_addr; + addr = (struct sockaddr *)ai->ai_addr; - if ((result = ei_connect_xinit(ec, hostname->s, alivename->s, nodename, (Erl_IpAddr) &(((struct sockaddr_in*)ai->ai_addr)->sin_addr), cookie->s, creation)) < 0) { + if((result = ei_connect_xinit(ec, hostname->s, alivename->s, nodename, + (Erl_IpAddr) & (((struct sockaddr_in *)ai->ai_addr)->sin_addr), + cookie->s, creation)) + < 0) { LM_CRIT("failed to initialize self as node %s\n", nodename); erl_close_socket(listen_fd); @@ -302,23 +305,25 @@ int erl_init_node(ei_cnode *ec, const str *alivename, const str *hostname, const sockaddr2ip_addr(&ip, addr); /* publish */ - if ((epmdfd = ei_publish_tmo(ec, port, timeout_ms)) < 0) { + if((epmdfd = ei_publish_tmo(ec, port, timeout_ms)) < 0) { - LM_DBG("Failed publish %s:%u[%u] as %s: %s (%d)\n",ip_addr2strz(&ip),port,listen_fd,nodename, strerror(erl_errno), epmdfd); + LM_DBG("Failed publish %s:%u[%u] as %s: %s (%d)\n", ip_addr2strz(&ip), + port, listen_fd, nodename, strerror(erl_errno), epmdfd); erl_close_socket(listen_fd); return -1; } else { - LM_DBG("listen on %s:%u[%u]/[%d] as %s\n",ip_addr2strz(&ip),port,listen_fd,epmdfd,nodename); + LM_DBG("listen on %s:%u[%u]/[%d] as %s\n", ip_addr2strz(&ip), port, + listen_fd, epmdfd, nodename); } freeaddrinfo(ai); return listen_fd; } -void io_handler_ins(handler_common_t* phandler) +void io_handler_ins(handler_common_t *phandler) { - if (io_handlers) { + if(io_handlers) { io_handlers->prev = phandler; phandler->next = io_handlers; } else { @@ -329,29 +334,30 @@ void io_handler_ins(handler_common_t* phandler) io_handlers = phandler; } -void io_handler_del(handler_common_t* phandler) +void io_handler_del(handler_common_t *phandler) { - handler_common_t* p = phandler; + handler_common_t *p = phandler; - if (p == io_handlers) { + if(p == io_handlers) { io_handlers = phandler->next; } else { phandler->prev->next = phandler->next; } - if(phandler->destroy_f) phandler->destroy_f(phandler); + if(phandler->destroy_f) + phandler->destroy_f(phandler); - pkg_free((void*)phandler); + pkg_free((void *)phandler); } void io_handlers_delete() { - handler_common_t* p; + handler_common_t *p; - while(io_handlers){ + while(io_handlers) { p = io_handlers; io_handlers = io_handlers->next; - pkg_free((void*)p); + pkg_free((void *)p); } } @@ -366,29 +372,21 @@ int ei_decode_strorbin(char *buf, int *index, int maxlen, char *dst) ei_get_type(buf, index, &type, &size); - if (type == ERL_NIL_EXT || size == 0) - { + if(type == ERL_NIL_EXT || size == 0) { dst[0] = '\0'; return 0; } - if (type != ERL_STRING_EXT && type != ERL_BINARY_EXT) - { + if(type != ERL_STRING_EXT && type != ERL_BINARY_EXT) { return -1; - } - else if (size > maxlen) - { - LM_ERR("buffer size %d too small for %s with size %d\n", - maxlen, type == ERL_BINARY_EXT ? "binary" : "string", size); + } else if(size > maxlen) { + LM_ERR("buffer size %d too small for %s with size %d\n", maxlen, + type == ERL_BINARY_EXT ? "binary" : "string", size); return -1; - } - else if (type == ERL_BINARY_EXT) - { + } else if(type == ERL_BINARY_EXT) { res = ei_decode_binary(buf, index, dst, &len); dst[len] = '\0'; - } - else - { + } else { res = ei_decode_string(buf, index, dst); } diff --git a/src/modules/erlang/erl_helpers.h b/src/modules/erlang/erl_helpers.h index 913fa5d6f66..e69111ed726 100644 --- a/src/modules/erlang/erl_helpers.h +++ b/src/modules/erlang/erl_helpers.h @@ -39,10 +39,16 @@ #include "../../core/str.h" #include "../../core/dprint.h" -#define CONNECT_TIMEOUT 500 /* ms */ -#define sockaddr_port(addr) ((addr)->sa_family == AF_INET ? ntohs(((struct sockaddr_in *)(addr))->sin_port) : ntohs(((struct sockaddr_in6 *)(addr))->sin6_port)) +#define CONNECT_TIMEOUT 500 /* ms */ +#define sockaddr_port(addr) \ + ((addr)->sa_family == AF_INET \ + ? ntohs(((struct sockaddr_in *)(addr))->sin_port) \ + : ntohs(((struct sockaddr_in6 *)(addr))->sin6_port)) -#define EI_X_BUFF_NULL {0, 0, 0} +#define EI_X_BUFF_NULL \ + { \ + 0, 0, 0 \ + } extern char thishostname[512]; @@ -65,9 +71,10 @@ typedef struct handler_common_s } handler_common_t; -extern handler_common_t* io_handlers; +extern handler_common_t *io_handlers; -typedef struct erlang_ref_ex_s { +typedef struct erlang_ref_ex_s +{ erlang_ref ref; char nodename[MAXATOMLEN]; int with_node; @@ -79,74 +86,81 @@ void erl_free_common(); int erl_set_nonblock(int sockfd); void erl_close_socket(int sockfd); -int erl_passive_socket(const char *hostname, int qlen, struct addrinfo **ai_ret); +int erl_passive_socket( + const char *hostname, int qlen, struct addrinfo **ai_ret); int erl_active_socket(const char *hostname, int qlen, struct addrinfo **ai_ret); -int erl_init_ec(ei_cnode *ec, const str *alivename, const str *hostname, const str *cookie); -int erl_init_node(ei_cnode *ec, const str *alivename, const str *hostname, const str *cookie); +int erl_init_ec(ei_cnode *ec, const str *alivename, const str *hostname, + const str *cookie); +int erl_init_node(ei_cnode *ec, const str *alivename, const str *hostname, + const str *cookie); -void io_handler_ins(handler_common_t* phandler); -void io_handler_del(handler_common_t* phandler); +void io_handler_ins(handler_common_t *phandler); +void io_handler_del(handler_common_t *phandler); void io_handlers_delete(); -#define PRINT_DBG_REG_SEND(node,from,cnode,to,msg) \ - do { \ - char *mbuf = NULL; \ - char *pbuf = NULL; \ - ei_x_buff xpid = {0,0,0}; \ - int i=0,v=0; \ - ei_decode_version((msg)->buff,&i,&v);\ - i=v?i:0; \ - ei_s_print_term(&mbuf, (msg)->buff, &i); \ - ei_x_encode_pid(&xpid,&from); \ - i = 0; \ - ei_s_print_term(&pbuf,xpid.buff,&i); \ - LM_DBG("ERL_REG_SEND: {%s,'%s'} <- %s from {%s,'%s'}\n", to, cnode, mbuf, pbuf, node); \ - free(mbuf), free(pbuf), ei_x_free(&xpid); \ - } while(0) - -#define PRINT_DBG_SEND(node,to,msg) \ - do { \ - char *mbuf = NULL; \ - char *pbuf = NULL; \ - ei_x_buff xpid = {0,0,0}; \ - int i=0,v=0; \ - ei_decode_version((msg)->buff,&i,&v);\ - i=v?i:0; \ - ei_s_print_term(&mbuf, (msg)->buff, &i); \ - ei_x_encode_pid(&xpid,&to); \ - i = 0; \ - ei_s_print_term(&pbuf,xpid.buff,&i); \ - LM_DBG("ERL_SEND: %s <- %s from '%s'\n", pbuf, mbuf, node); \ - free(mbuf), free(pbuf), ei_x_free(&xpid); \ - } while(0) - -#define ei_x_print_reg_msg(buf, dest, send) \ -do{ \ - char *mbuf = NULL; \ - int i = 1; \ - ei_s_print_term(&mbuf, (buf)->buff, &i); \ - if (send) LM_DBG("sending %s to %s\n", mbuf, dest); \ - else LM_DBG("received %s from/for %s\n", mbuf, dest); \ - free(mbuf); \ -} while(0) - -#define ei_x_print_msg(buf, pid, send) \ -do { \ - char *pbuf = NULL; \ - int i = 0; \ - ei_x_buff pidbuf; \ - ei_x_new(&pidbuf); \ - ei_x_encode_pid(&pidbuf, pid); \ - ei_s_print_term(&pbuf, pidbuf.buff, &i); \ - ei_x_print_reg_msg(buf, pbuf, send); \ - free(pbuf); \ - ei_x_free(&pidbuf); \ -} while(0) +#define PRINT_DBG_REG_SEND(node, from, cnode, to, msg) \ + do { \ + char *mbuf = NULL; \ + char *pbuf = NULL; \ + ei_x_buff xpid = {0, 0, 0}; \ + int i = 0, v = 0; \ + ei_decode_version((msg)->buff, &i, &v); \ + i = v ? i : 0; \ + ei_s_print_term(&mbuf, (msg)->buff, &i); \ + ei_x_encode_pid(&xpid, &from); \ + i = 0; \ + ei_s_print_term(&pbuf, xpid.buff, &i); \ + LM_DBG("ERL_REG_SEND: {%s,'%s'} <- %s from {%s,'%s'}\n", to, cnode, \ + mbuf, pbuf, node); \ + free(mbuf), free(pbuf), ei_x_free(&xpid); \ + } while(0) + +#define PRINT_DBG_SEND(node, to, msg) \ + do { \ + char *mbuf = NULL; \ + char *pbuf = NULL; \ + ei_x_buff xpid = {0, 0, 0}; \ + int i = 0, v = 0; \ + ei_decode_version((msg)->buff, &i, &v); \ + i = v ? i : 0; \ + ei_s_print_term(&mbuf, (msg)->buff, &i); \ + ei_x_encode_pid(&xpid, &to); \ + i = 0; \ + ei_s_print_term(&pbuf, xpid.buff, &i); \ + LM_DBG("ERL_SEND: %s <- %s from '%s'\n", pbuf, mbuf, node); \ + free(mbuf), free(pbuf), ei_x_free(&xpid); \ + } while(0) + +#define ei_x_print_reg_msg(buf, dest, send) \ + do { \ + char *mbuf = NULL; \ + int i = 1; \ + ei_s_print_term(&mbuf, (buf)->buff, &i); \ + if(send) \ + LM_DBG("sending %s to %s\n", mbuf, dest); \ + else \ + LM_DBG("received %s from/for %s\n", mbuf, dest); \ + free(mbuf); \ + } while(0) + +#define ei_x_print_msg(buf, pid, send) \ + do { \ + char *pbuf = NULL; \ + int i = 0; \ + ei_x_buff pidbuf; \ + ei_x_new(&pidbuf); \ + ei_x_encode_pid(&pidbuf, pid); \ + ei_s_print_term(&pbuf, pidbuf.buff, &i); \ + ei_x_print_reg_msg(buf, pbuf, send); \ + free(pbuf); \ + ei_x_free(&pidbuf); \ + } while(0) int ei_decode_strorbin(char *buf, int *index, int maxlen, char *dst); -typedef enum { +typedef enum +{ API_RPC_CALL, API_REG_SEND, API_SEND diff --git a/src/modules/erlang/erlang_mod.c b/src/modules/erlang/erlang_mod.c index e4060698f96..3f1293650cf 100644 --- a/src/modules/erlang/erlang_mod.c +++ b/src/modules/erlang/erlang_mod.c @@ -35,7 +35,7 @@ #include "../../core/script_cb.h" #ifndef USE_TCP -#error "USE_TCP must be enabled for this module" +#error "USE_TCP must be enabled for this module" #endif #include "../../core/pass_fd.h" @@ -58,34 +58,36 @@ MODULE_VERSION static int child_init(int rank); static int mod_init(void); static void mod_destroy(void); -static int postprocess_request(struct sip_msg *msg, unsigned int flags, void *_param); +static int postprocess_request( + struct sip_msg *msg, unsigned int flags, void *_param); /* exported functions */ -static int erl_rpc(struct sip_msg *msg, char *module, char *function, char *args, char *reply); +static int erl_rpc(struct sip_msg *msg, char *module, char *function, + char *args, char *reply); static int erl_reg_send_k(struct sip_msg *msg, char *_server, char *_emsg); static int erl_send_k(struct sip_msg *msg, char *_server, char *_emsg); static int erl_reply_k(struct sip_msg *msg, char *_emsg); /* fix-ups */ -static int fixup_rpc(void** param, int param_no); -static int fixup_send(void** param, int param_no); -static int fixup_reg(void** param, int param_no); -static int fixup_reply(void** param, int param_no); +static int fixup_rpc(void **param, int param_no); +static int fixup_send(void **param, int param_no); +static int fixup_reg(void **param, int param_no); +static int fixup_reply(void **param, int param_no); -int fixup_free_rpc(void** param, int param_no); -int fixup_free_reg(void** param, int param_no); -int fixup_free_send(void** param, int param_no); -int fixup_free_reply(void** param, int param_no); +int fixup_free_rpc(void **param, int param_no); +int fixup_free_reg(void **param, int param_no); +int fixup_free_send(void **param, int param_no); +int fixup_free_reply(void **param, int param_no); /* initialize common vars */ str cookie = STR_NULL; int trace_level = 0; str cnode_alivename = STR_NULL; str cnode_host = STR_NULL; -int no_cnodes=1; +int no_cnodes = 1; int rpc_reply_with_struct = 0; -str erlang_nodename = STR_NULL; +str erlang_nodename = STR_NULL; str erlang_node_sname = STR_NULL; int rex_call_in_progress = 0; @@ -93,116 +95,67 @@ int rex_call_in_progress = 0; int *usocks[2]; int csockfd; -handler_common_t* io_handlers = NULL; +handler_common_t *io_handlers = NULL; erl_api_t erl_api; static pv_export_t pvs[] = { - { - { "erl_tuple", (sizeof("erl_tuple")-1) }, - PVT_OTHER, - pv_tuple_get, - pv_tuple_set, - pv_xbuff_parse_name, - 0, - 0, - 0 - }, - { - { "erl_atom", (sizeof("erl_atom")-1) }, - PVT_OTHER, - pv_atom_get, - pv_atom_set, - pv_atom_parse_name, - 0, - 0, - 0 - }, - { - { "erl_list", (sizeof("erl_list")-1) }, - PVT_OTHER, - pv_list_get, - pv_list_set, - pv_xbuff_parse_name, - 0, - 0, - 0 - }, - { - { "erl_xbuff", (sizeof("erl_xbuff")-1) }, - PVT_OTHER, - pv_xbuff_get, - pv_xbuff_set, - pv_xbuff_parse_name, - 0, - 0, - 0 - }, - { - { "erl_pid", (sizeof("erl_pid")-1) }, - PVT_OTHER, - pv_pid_get, - pv_pid_set, - pv_pid_parse_name, - 0, - 0, - 0 - }, - { - { "erl_ref", (sizeof("erl_ref")-1) }, - PVT_OTHER, - pv_ref_get, - pv_ref_set, - pv_ref_parse_name, - 0, - 0, - 0 - }, - {{0,0}, 0, 0, 0, 0, 0, 0, 0} -}; + {{"erl_tuple", (sizeof("erl_tuple") - 1)}, PVT_OTHER, pv_tuple_get, + pv_tuple_set, pv_xbuff_parse_name, 0, 0, 0}, + {{"erl_atom", (sizeof("erl_atom") - 1)}, PVT_OTHER, pv_atom_get, + pv_atom_set, pv_atom_parse_name, 0, 0, 0}, + {{"erl_list", (sizeof("erl_list") - 1)}, PVT_OTHER, pv_list_get, + pv_list_set, pv_xbuff_parse_name, 0, 0, 0}, + {{"erl_xbuff", (sizeof("erl_xbuff") - 1)}, PVT_OTHER, pv_xbuff_get, + pv_xbuff_set, pv_xbuff_parse_name, 0, 0, 0}, + {{"erl_pid", (sizeof("erl_pid") - 1)}, PVT_OTHER, pv_pid_get, + pv_pid_set, pv_pid_parse_name, 0, 0, 0}, + {{"erl_ref", (sizeof("erl_ref") - 1)}, PVT_OTHER, pv_ref_get, + pv_ref_set, pv_ref_parse_name, 0, 0, 0}, + {{0, 0}, 0, 0, 0, 0, 0, 0, 0}}; /* exported parameters */ -static param_export_t parameters[] = -{ +static param_export_t parameters[] = { /* Kamailio C node parameters */ - { "no_cnodes", PARAM_INT, &no_cnodes }, - { "cnode_alivename", PARAM_STR, &cnode_alivename }, - { "cnode_host", PARAM_STR, &cnode_host }, + {"no_cnodes", PARAM_INT, &no_cnodes}, + {"cnode_alivename", PARAM_STR, &cnode_alivename}, + {"cnode_host", PARAM_STR, &cnode_host}, /* Erlang node parameters */ - { "erlang_nodename", PARAM_STR, &erlang_nodename }, - { "erlang_node_sname", PARAM_STR, &erlang_node_sname }, + {"erlang_nodename", PARAM_STR, &erlang_nodename}, + {"erlang_node_sname", PARAM_STR, &erlang_node_sname}, - { "cookie", PARAM_STR, &cookie }, - { "trace_level", PARAM_INT, &trace_level }, /* tracing level on the distribution */ - { "rpc_reply_with_struct", PARAM_INT, &rpc_reply_with_struct}, - { 0, 0, 0 } -}; + {"cookie", PARAM_STR, &cookie}, + {"trace_level", PARAM_INT, + &trace_level}, /* tracing level on the distribution */ + {"rpc_reply_with_struct", PARAM_INT, &rpc_reply_with_struct}, + {0, 0, 0}}; /* exported commands */ -static cmd_export_t commands[] = -{ - {"erl_rpc", (cmd_function)erl_rpc, 4, fixup_rpc, fixup_free_rpc, ANY_ROUTE}, - {"erl_send", (cmd_function)erl_send_k, 2, fixup_send, fixup_free_send, ANY_ROUTE}, - {"erl_reg_send", (cmd_function)erl_reg_send_k, 2, fixup_reg, fixup_free_reg, ANY_ROUTE}, - {"erl_reply", (cmd_function)erl_reply_k, 1, fixup_reply, fixup_free_reply, EVENT_ROUTE}, - {"load_erl",(cmd_function)load_erl,0, 0, 0, 0}, /* API loader */ - { 0, 0, 0, 0, 0, 0 } -}; +static cmd_export_t commands[] = {{"erl_rpc", (cmd_function)erl_rpc, 4, + fixup_rpc, fixup_free_rpc, ANY_ROUTE}, + {"erl_send", (cmd_function)erl_send_k, 2, fixup_send, fixup_free_send, + ANY_ROUTE}, + {"erl_reg_send", (cmd_function)erl_reg_send_k, 2, fixup_reg, + fixup_free_reg, ANY_ROUTE}, + {"erl_reply", (cmd_function)erl_reply_k, 1, fixup_reply, + fixup_free_reply, EVENT_ROUTE}, + {"load_erl", (cmd_function)load_erl, 0, 0, 0, 0}, /* API loader */ + {0, 0, 0, 0, 0, 0}}; struct module_exports exports = { - "erlang", /* module name */ - DEFAULT_DLFLAGS, /* dlopen flags */ - commands, /* exported functions */ - parameters, /* exported parameters */ - 0, /* RPC method exports */ - pvs, /* exported pseudo-variables */ - 0, /* response handling function */ - mod_init, /* module initialization function */ - child_init, /* per-child init function */ - mod_destroy /* module destroy function */ + "erlang", /* module name */ + DEFAULT_DLFLAGS, /* dlopen flags */ + commands, /* exported functions */ + parameters, /* exported parameters */ + 0, /* RPC method exports */ + pvs, /* exported pseudo-variables */ + 0, /* response handling function */ + mod_init, /* module initialization function */ + child_init, /* per-child init function */ + mod_destroy /* module destroy function */ }; /** @@ -212,48 +165,46 @@ static int mod_init(void) { /* check required parameters */ - if (!cookie.s || cookie.len == 0) - { + if(!cookie.s || cookie.len == 0) { LM_CRIT("Erlang cookie parameter is required\n"); return -1; } - cookie.s[cookie.len]=0; + cookie.s[cookie.len] = 0; - if ((!erlang_nodename.s || erlang_nodename.len == 0) + if((!erlang_nodename.s || erlang_nodename.len == 0) && (!erlang_node_sname.s || erlang_node_sname.len == 0)) { LM_CRIT("Erlang node name is required\n"); return -1; } - if (erlang_nodename.s) { - erlang_nodename.s[erlang_nodename.len]=0; + if(erlang_nodename.s) { + erlang_nodename.s[erlang_nodename.len] = 0; } - if (erlang_node_sname.s) { - erlang_node_sname.s[erlang_node_sname.len]=0; + if(erlang_node_sname.s) { + erlang_node_sname.s[erlang_node_sname.len] = 0; } - if (!cnode_alivename.s || !cnode_alivename.len) { + if(!cnode_alivename.s || !cnode_alivename.len) { LM_CRIT("Kamailio C node alive name is required\n"); return -1; } - cnode_alivename.s[cnode_alivename.len]=0; + cnode_alivename.s[cnode_alivename.len] = 0; - if (!cnode_host.s || !cnode_host.len) { + if(!cnode_host.s || !cnode_host.len) { LM_WARN("Kamailio host name is not set, trying with gethostname...\n"); return -1; } - if (erl_load_api(&erl_api)) { + if(erl_load_api(&erl_api)) { LM_CRIT("failed to load erl API\n"); return -1; } - if (compile_xbuff_re()) { + if(compile_xbuff_re()) { return -1; } - if (register_script_cb(postprocess_request, POST_SCRIPT_CB | REQUEST_CB, 0) - != 0) - { + if(register_script_cb(postprocess_request, POST_SCRIPT_CB | REQUEST_CB, 0) + != 0) { LOG(L_CRIT, "could not register request post processing call back.\n"); return -1; } @@ -279,57 +230,63 @@ static int child_init(int rank) { char _cnode_desc[MAX_CNODE_DESC_LEN]; int pair[2], data[2]; - int i,j,pid; + int i, j, pid; - if (rank == PROC_INIT) { + if(rank == PROC_INIT) { - usocks[KSOCKET]=(int*)shm_malloc(sizeof(int)*no_cnodes); - if (!usocks[KSOCKET]) { + usocks[KSOCKET] = (int *)shm_malloc(sizeof(int) * no_cnodes); + if(!usocks[KSOCKET]) { LM_ERR("Not enough memory\n"); return -1; } - usocks[CSOCKET]=(int*)shm_malloc(sizeof(int)*no_cnodes); - if (!usocks[CSOCKET]) { + usocks[CSOCKET] = (int *)shm_malloc(sizeof(int) * no_cnodes); + if(!usocks[CSOCKET]) { LM_ERR("Not enough memory\n"); return -1; } - for(i=0;itype) { - case ERL_PARAM_FPARAM: - if(get_str_fparam(&module,msg,m->value.fp)) { - LM_ERR("can't get module name\n"); - } - break; - default: - LM_ERR("unexpected type for module name parameter\n"); - return -1; + switch(m->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&module, msg, m->value.fp)) { + LM_ERR("can't get module name\n"); + } + break; + default: + LM_ERR("unexpected type for module name parameter\n"); + return -1; } - switch (f->type) { - case ERL_PARAM_FPARAM: - if(get_str_fparam(&function,msg,f->value.fp)) { - LM_ERR("can't get function name\n"); - } - break; - default: - LM_ERR("unexpected type for function name parameter\n"); - return -1; + switch(f->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&function, msg, f->value.fp)) { + LM_ERR("can't get function name\n"); + } + break; + default: + LM_ERR("unexpected type for function name parameter\n"); + return -1; } - switch(a->type){ - case ERL_PARAM_FPARAM: - if(get_str_fparam(&vname,msg,a->value.fp)){ - LM_ERR("can't get name of arguments parameter\n"); - return -1; - } - xreq = pv_list_get_list(&vname); - if (!xreq){ - xreq = pv_xbuff_get_xbuff(&vname); - } - if (!xreq) { - LM_ERR("can't find variable $list(%.*s) nor $xbuff(%.*s)",STR_FMT(&vname),STR_FMT(&vname)); - return -1; - } - break; - case ERL_PARAM_XBUFF_SPEC: - nsp = NULL; - pvp = a->value.sp.pvp; /* work on copy */ + switch(a->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&vname, msg, a->value.fp)) { + LM_ERR("can't get name of arguments parameter\n"); + return -1; + } + xreq = pv_list_get_list(&vname); + if(!xreq) { + xreq = pv_xbuff_get_xbuff(&vname); + } + if(!xreq) { + LM_ERR("can't find variable $list(%.*s) nor $xbuff(%.*s)", + STR_FMT(&vname), STR_FMT(&vname)); + return -1; + } + break; + case ERL_PARAM_XBUFF_SPEC: + nsp = NULL; + pvp = a->value.sp.pvp; /* work on copy */ - if( pvp.pvn.type == PV_NAME_PVAR) { - nsp = pvp.pvn.u.dname; - } + if(pvp.pvn.type == PV_NAME_PVAR) { + nsp = pvp.pvn.u.dname; + } - if (nsp) { - pvi = &nsp->pvp.pvi; - pvn = &nsp->pvp.pvn; - sp = *nsp; - } else { - pvi = &pvp.pvi; - pvn = &pvp.pvn; - sp = a->value.sp; - } + if(nsp) { + pvi = &nsp->pvp.pvi; + pvn = &nsp->pvp.pvn; + sp = *nsp; + } else { + pvi = &pvp.pvi; + pvn = &pvp.pvn; + sp = a->value.sp; + } - if (sp.setf == pv_list_set ) { - xreq = pv_list_get_list(&pvn->u.isname.name.s); - } else if (sp.setf == pv_xbuff_set) { - xreq = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); - } else if (sp.setf == pv_tuple_set) { - xreq = pv_tuple_get_tuple(&pvn->u.isname.name.s); - } + if(sp.setf == pv_list_set) { + xreq = pv_list_get_list(&pvn->u.isname.name.s); + } else if(sp.setf == pv_xbuff_set) { + xreq = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); + } else if(sp.setf == pv_tuple_set) { + xreq = pv_tuple_get_tuple(&pvn->u.isname.name.s); + } - /* fix index */ - attr = xbuff_get_attr_flags(pvi->type); + /* fix index */ + attr = xbuff_get_attr_flags(pvi->type); - /* get the index */ - if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) - { - LM_ERR("invalid index\n"); - return -1; - } + /* get the index */ + if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) { + LM_ERR("invalid index\n"); + return -1; + } - if (xbuff_is_attr_set(attr)) { - LM_WARN("attribute is not expected here!\n"); - } + if(xbuff_is_attr_set(attr)) { + LM_WARN("attribute is not expected here!\n"); + } - if (!xreq) { - LM_ERR("undefined variable '%.*s'\n",STR_FMT(&pvn->u.isname.name.s)); - return -1; - } + if(!xreq) { + LM_ERR("undefined variable '%.*s'\n", + STR_FMT(&pvn->u.isname.name.s)); + return -1; + } - xreq = xreq->val.v.xavp; + xreq = xreq->val.v.xavp; - if ((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr) ) { - xreq = xavp_get_nth(&xreq->val.v.xavp,idx,NULL); - } + if((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr)) { + xreq = xavp_get_nth(&xreq->val.v.xavp, idx, NULL); + } - if (!xreq) { - LM_ERR("undefined value in '%.*s' at index %d\n",STR_FMT(&pvn->u.isname.name.s),idx); - return -1; - } + if(!xreq) { + LM_ERR("undefined value in '%.*s' at index %d\n", + STR_FMT(&pvn->u.isname.name.s), idx); + return -1; + } - if (xreq->val.type != SR_XTYPE_XAVP || xreq->name.s[0] != 'l') { - LM_ERR("given value in parameter args is not list\n"); + if(xreq->val.type != SR_XTYPE_XAVP || xreq->name.s[0] != 'l') { + LM_ERR("given value in parameter args is not list\n"); + return -1; + } + break; + default: + LM_ERR("unexpected type for arguments parameter\n"); return -1; - } - break; - default: - LM_ERR("unexpected type for arguments parameter\n"); - return -1; } - switch(r->type){ - case ERL_PARAM_FPARAM: - if(get_str_fparam(&vname,msg,r->value.fp)){ - LM_ERR("can't get name of arguments parameter\n"); - return -1; - } - xrepl = pv_xbuff_get_xbuff(&vname); - break; - case ERL_PARAM_XBUFF_SPEC: - nsp = NULL; - pvp = r->value.sp.pvp; /* work on copy */ - - if( pvp.pvn.type == PV_NAME_PVAR) { - nsp = pvp.pvn.u.dname; - } + switch(r->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&vname, msg, r->value.fp)) { + LM_ERR("can't get name of arguments parameter\n"); + return -1; + } + xrepl = pv_xbuff_get_xbuff(&vname); + break; + case ERL_PARAM_XBUFF_SPEC: + nsp = NULL; + pvp = r->value.sp.pvp; /* work on copy */ + + if(pvp.pvn.type == PV_NAME_PVAR) { + nsp = pvp.pvn.u.dname; + } - if (nsp) { - pvi = &nsp->pvp.pvi; - pvn = &nsp->pvp.pvn; - sp = *nsp; - } else { - pvi = &pvp.pvi; - pvn = &pvp.pvn; - sp = a->value.sp; - } + if(nsp) { + pvi = &nsp->pvp.pvi; + pvn = &nsp->pvp.pvn; + sp = *nsp; + } else { + pvi = &pvp.pvi; + pvn = &pvp.pvn; + sp = a->value.sp; + } - if (sp.setf == pv_xbuff_set ) { - xrepl = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); - } else { - LM_ERR("unsupported variable type, xbuff only\n"); - return -1; - } + if(sp.setf == pv_xbuff_set) { + xrepl = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); + } else { + LM_ERR("unsupported variable type, xbuff only\n"); + return -1; + } - /* fix index */ - attr = xbuff_get_attr_flags(pvi->type); + /* fix index */ + attr = xbuff_get_attr_flags(pvi->type); - /* get the index */ - if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) - { - LM_ERR("invalid index\n"); - return -1; - } + /* get the index */ + if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) { + LM_ERR("invalid index\n"); + return -1; + } - if (xbuff_is_attr_set(attr)) { - LM_WARN("attribute is not expected here!\n"); - } + if(xbuff_is_attr_set(attr)) { + LM_WARN("attribute is not expected here!\n"); + } - if ((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr) ) { - LM_ERR("index is not expected here!\n"); - return -1; - } + if((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr)) { + LM_ERR("index is not expected here!\n"); + return -1; + } - break; - default: - LM_ERR("unexpected type for arguments parameter\n"); - return -1; + break; + default: + LM_ERR("unexpected type for arguments parameter\n"); + return -1; } /* note: new without version byte */ ei_x_new(&ei_req); /* ei_x_buff <- XAVP */ - if (erl_api.xavp2xbuff(&ei_req,xreq)) { + if(erl_api.xavp2xbuff(&ei_req, xreq)) { LM_ERR("failed to encode\n"); ei_x_free(&ei_req); return -1; } - memset((void*)&ei_rep,0,sizeof(ei_x_buff)); + memset((void *)&ei_rep, 0, sizeof(ei_x_buff)); - erl_api.rpc(&ei_rep,&module,&function,&ei_req); + erl_api.rpc(&ei_rep, &module, &function, &ei_req); - if (xrepl) { + if(xrepl) { xavp_destroy_list(&xrepl->val.v.xavp); } else { xrepl = xbuff_new(&pvn->u.isname.name.s); @@ -615,7 +578,7 @@ static int erl_rpc(struct sip_msg *msg, char *_m, char *_f, char *_a, char *_r) xrepl->val.type = SR_XTYPE_XAVP; /* XAVP <- ei_x_buff */ - if (erl_api.xbuff2xavp(&xrepl->val.v.xavp,&ei_rep)){ + if(erl_api.xbuff2xavp(&xrepl->val.v.xavp, &ei_rep)) { LM_ERR("failed to decode\n"); ei_x_free(&ei_req); ei_x_free(&ei_rep); @@ -628,84 +591,90 @@ static int erl_rpc(struct sip_msg *msg, char *_m, char *_f, char *_a, char *_r) return 1; } -static int fixup_rpc(void** param, int param_no) +static int fixup_rpc(void **param, int param_no) { erl_param_t *erl_param; pv_spec_p psp; str s; - erl_param=(erl_param_t*)pkg_malloc(sizeof(erl_param_t)); + erl_param = (erl_param_t *)pkg_malloc(sizeof(erl_param_t)); if(!erl_param) { LM_ERR("no more memory\n"); return -1; } - memset(erl_param,0,sizeof(erl_param_t)); - - if(param_no==1 || param_no==2) { - if (fix_param_types(FPARAM_STR|FPARAM_STRING|FPARAM_AVP|FPARAM_PVS|FPARAM_PVE,param)){ - LM_ERR("wrong parameter #%d\n",param_no); - pkg_free((void*)erl_param); + memset(erl_param, 0, sizeof(erl_param_t)); + + if(param_no == 1 || param_no == 2) { + if(fix_param_types(FPARAM_STR | FPARAM_STRING | FPARAM_AVP | FPARAM_PVS + | FPARAM_PVE, + param)) { + LM_ERR("wrong parameter #%d\n", param_no); + pkg_free((void *)erl_param); return -1; } erl_param->type = ERL_PARAM_FPARAM; - erl_param->value.fp = (fparam_t*)*param; + erl_param->value.fp = (fparam_t *)*param; } - if (param_no==3 || param_no==4) { + if(param_no == 3 || param_no == 4) { - s.s = (char*)*param; s.len = strlen(s.s); + s.s = (char *)*param; + s.len = strlen(s.s); - if (pv_parse_avp_name(&erl_param->value.sp,&s)) { - LM_ERR("failed to parse parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(pv_parse_avp_name(&erl_param->value.sp, &s)) { + LM_ERR("failed to parse parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } - if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - if (fix_param_types(FPARAM_STR|FPARAM_STRING,param)) { - LM_ERR("wrong parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + if(fix_param_types(FPARAM_STR | FPARAM_STRING, param)) { + LM_ERR("wrong parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } erl_param->type = ERL_PARAM_FPARAM; - erl_param->value.fp = (fparam_t*)*param; + erl_param->value.fp = (fparam_t *)*param; } else { /* lets check what is acceptable */ psp = (pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname; - if (psp->setf != pv_list_set && psp->setf != pv_xbuff_set) { - LM_ERR("wrong parameter #%d: accepted types are list or xbuff\n",param_no); + if(psp->setf != pv_list_set && psp->setf != pv_xbuff_set) { + LM_ERR("wrong parameter #%d: accepted types are list or " + "xbuff\n", + param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } erl_param->type = ERL_PARAM_XBUFF_SPEC; - LM_ERR("erl_param->value.sp.type=%d\n",erl_param->value.sp.type); + LM_ERR("erl_param->value.sp.type=%d\n", erl_param->value.sp.type); } } - *param = (void*)erl_param; + *param = (void *)erl_param; return 0; } -int fixup_free_rpc(void** param, int param_no) { +int fixup_free_rpc(void **param, int param_no) +{ erl_param_t *erl_param; - erl_param = (erl_param_t*)*param; + erl_param = (erl_param_t *)*param; - if(param_no==1 || param_no==2) { - return fixup_free_fparam_2((void**)&erl_param->value.fp,param_no); + if(param_no == 1 || param_no == 2) { + return fixup_free_fparam_2((void **)&erl_param->value.fp, param_no); } - if (param_no==3 || param_no==4) { - LM_ERR("erl_param->value.sp.type=%d\n",erl_param->value.sp.type); - if (erl_param->value.sp.type == PVT_OTHER) { + if(param_no == 3 || param_no == 4) { + LM_ERR("erl_param->value.sp.type=%d\n", erl_param->value.sp.type); + if(erl_param->value.sp.type == PVT_OTHER) { pv_spec_free((pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname); - } else if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - return fixup_free_fparam_2((void**)&erl_param->value.fp,param_no); + } else if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + return fixup_free_fparam_2((void **)&erl_param->value.fp, param_no); } } @@ -714,15 +683,15 @@ int fixup_free_rpc(void** param, int param_no) { static int erl_reg_send_k(struct sip_msg *msg, char *_server, char *_emsg) { - erl_param_t *param_server=(erl_param_t*)_server; - erl_param_t *param_emsg=(erl_param_t*)_emsg; + erl_param_t *param_server = (erl_param_t *)_server; + erl_param_t *param_emsg = (erl_param_t *)_emsg; str server; str str_msg; - sr_xavp_t *xmsg=NULL; + sr_xavp_t *xmsg = NULL; pv_spec_t sp; pv_spec_t *nsp = NULL; - pv_param_t pvp; + pv_param_t pvp; pv_name_t *pvn; pv_index_t *pvi; int idx; @@ -730,97 +699,99 @@ static int erl_reg_send_k(struct sip_msg *msg, char *_server, char *_emsg) int attr; ei_x_buff ei_msg; - switch (param_server->type) { - case ERL_PARAM_FPARAM: - if(get_str_fparam(&server,msg,param_server->value.fp)) { - LM_ERR("can't get server process name\n"); - } - break; - default: - LM_ERR("unexpected type for server name parameter\n"); - return -1; + switch(param_server->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&server, msg, param_server->value.fp)) { + LM_ERR("can't get server process name\n"); + } + break; + default: + LM_ERR("unexpected type for server name parameter\n"); + return -1; } ei_x_new_with_version(&ei_msg); - switch(param_emsg->type){ - case ERL_PARAM_FPARAM: - if(get_str_fparam(&str_msg,msg,param_emsg->value.fp)){ - LM_ERR("can't get emsg parameter\n"); - goto err; - } + switch(param_emsg->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&str_msg, msg, param_emsg->value.fp)) { + LM_ERR("can't get emsg parameter\n"); + goto err; + } - ei_x_encode_string_len(&ei_msg,str_msg.s,str_msg.len); + ei_x_encode_string_len(&ei_msg, str_msg.s, str_msg.len); - break; - case ERL_PARAM_XBUFF_SPEC: - pvp = param_emsg->value.sp.pvp; /* work on copy */ + break; + case ERL_PARAM_XBUFF_SPEC: + pvp = param_emsg->value.sp.pvp; /* work on copy */ - if( pvp.pvn.type == PV_NAME_PVAR) { - nsp = pvp.pvn.u.dname; - } + if(pvp.pvn.type == PV_NAME_PVAR) { + nsp = pvp.pvn.u.dname; + } - if (nsp) { - pvi = &nsp->pvp.pvi; - pvn = &nsp->pvp.pvn; - sp = *nsp; - } else { - pvi = &pvp.pvi; - pvn = &pvp.pvn; - sp = param_emsg->value.sp; - } + if(nsp) { + pvi = &nsp->pvp.pvi; + pvn = &nsp->pvp.pvn; + sp = *nsp; + } else { + pvi = &pvp.pvi; + pvn = &pvp.pvn; + sp = param_emsg->value.sp; + } - if (sp.setf == pv_list_set ) { - xmsg = pv_list_get_list(&pvn->u.isname.name.s); - } else if (sp.setf == pv_xbuff_set) { - xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); - } else if (sp.setf == pv_tuple_set) { - xmsg = pv_tuple_get_tuple(&pvn->u.isname.name.s); - } + if(sp.setf == pv_list_set) { + xmsg = pv_list_get_list(&pvn->u.isname.name.s); + } else if(sp.setf == pv_xbuff_set) { + xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); + } else if(sp.setf == pv_tuple_set) { + xmsg = pv_tuple_get_tuple(&pvn->u.isname.name.s); + } - /* fix index */ - attr = xbuff_get_attr_flags(pvi->type); + /* fix index */ + attr = xbuff_get_attr_flags(pvi->type); - /* get the index */ - if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) - { - LM_ERR("invalid index\n"); - return -1; - } + /* get the index */ + if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) { + LM_ERR("invalid index\n"); + return -1; + } - if (xbuff_is_attr_set(attr)) { - LM_WARN("attribute is not expected here!\n"); - } + if(xbuff_is_attr_set(attr)) { + LM_WARN("attribute is not expected here!\n"); + } - if (!xmsg) { - LM_ERR("undefined variable '%.*s'\n",STR_FMT(&pvn->u.isname.name.s)); - return -1; - } + if(!xmsg) { + LM_ERR("undefined variable '%.*s'\n", + STR_FMT(&pvn->u.isname.name.s)); + return -1; + } - xmsg = xmsg->val.v.xavp; + xmsg = xmsg->val.v.xavp; - if ((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr) ) { - xmsg = xavp_get_nth(&xmsg->val.v.xavp,idx,NULL); - } + if((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr)) { + xmsg = xavp_get_nth(&xmsg->val.v.xavp, idx, NULL); + } - if (!xmsg) { - LM_ERR("undefined value in '%.*s' at index %d\n",STR_FMT(&pvn->u.isname.name.s),idx); - goto err; - } + if(!xmsg) { + LM_ERR("undefined value in '%.*s' at index %d\n", + STR_FMT(&pvn->u.isname.name.s), idx); + goto err; + } - /* ei_x_buff <- XAVP */ - if (erl_api.xavp2xbuff(&ei_msg,xmsg)) { - LM_ERR("failed to encode %.*s\n",STR_FMT(&pvn->u.isname.name.s)); - goto err; - } + /* ei_x_buff <- XAVP */ + if(erl_api.xavp2xbuff(&ei_msg, xmsg)) { + LM_ERR("failed to encode %.*s\n", + STR_FMT(&pvn->u.isname.name.s)); + goto err; + } - break; - default: - LM_ERR("unexpected type for emsg parameter\n"); - return -1; + break; + default: + LM_ERR("unexpected type for emsg parameter\n"); + return -1; } - if (erl_api.reg_send(&server,&ei_msg)) { + if(erl_api.reg_send(&server, &ei_msg)) { goto err; } @@ -834,95 +805,97 @@ static int erl_reg_send_k(struct sip_msg *msg, char *_server, char *_emsg) return -1; } -static int fixup_reg(void** param, int param_no) +static int fixup_reg(void **param, int param_no) { erl_param_t *erl_param; pv_spec_p psp; str s; - erl_param=(erl_param_t*)pkg_malloc(sizeof(erl_param_t)); + erl_param = (erl_param_t *)pkg_malloc(sizeof(erl_param_t)); if(!erl_param) { LM_ERR("no more memory\n"); return -1; } - memset(erl_param,0,sizeof(erl_param_t)); + memset(erl_param, 0, sizeof(erl_param_t)); - if(param_no==1) { - if (fix_param_types(FPARAM_STR|FPARAM_STRING|FPARAM_AVP|FPARAM_PVS|FPARAM_PVE|FPARAM_INT,param)){ - LM_ERR("wrong parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(param_no == 1) { + if(fix_param_types(FPARAM_STR | FPARAM_STRING | FPARAM_AVP | FPARAM_PVS + | FPARAM_PVE | FPARAM_INT, + param)) { + LM_ERR("wrong parameter #%d\n", param_no); + pkg_free((void *)erl_param); return -1; } erl_param->type = ERL_PARAM_FPARAM; - erl_param->value.fp = (fparam_t*)*param; + erl_param->value.fp = (fparam_t *)*param; } - if (param_no==2) { + if(param_no == 2) { - s.s = (char*)*param; s.len = strlen(s.s); + s.s = (char *)*param; + s.len = strlen(s.s); - if (pv_parse_avp_name(&erl_param->value.sp,&s)) { - LM_ERR("failed to parse parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(pv_parse_avp_name(&erl_param->value.sp, &s)) { + LM_ERR("failed to parse parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } - if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - if (fix_param_types(FPARAM_STR|FPARAM_STRING,param)) { - LM_ERR("wrong parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + if(fix_param_types(FPARAM_STR | FPARAM_STRING, param)) { + LM_ERR("wrong parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } erl_param->type = ERL_PARAM_FPARAM; - erl_param->value.fp = (fparam_t*)*param; + erl_param->value.fp = (fparam_t *)*param; } else { - if (erl_param->value.sp.type == PVT_XAVP) { - LM_ERR("XAVP not acceptable for parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(erl_param->value.sp.type == PVT_XAVP) { + LM_ERR("XAVP not acceptable for parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } psp = (pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname; - if (psp->setf == pv_list_set - || psp->setf == pv_xbuff_set - || psp->setf == pv_tuple_set - || psp->setf == pv_atom_set) { + if(psp->setf == pv_list_set || psp->setf == pv_xbuff_set + || psp->setf == pv_tuple_set || psp->setf == pv_atom_set) { erl_param->type = ERL_PARAM_XBUFF_SPEC; } else { - LM_ERR("wrong parameter #%d\n",param_no); + LM_ERR("wrong parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } } } - *param = (void*)erl_param; + *param = (void *)erl_param; return 0; } -int fixup_free_reg(void** param, int param_no) { +int fixup_free_reg(void **param, int param_no) +{ erl_param_t *erl_param; - erl_param = (erl_param_t*)*param; + erl_param = (erl_param_t *)*param; - if(param_no==1) { - return fixup_free_fparam_1((void**)&erl_param->value.fp,param_no); + if(param_no == 1) { + return fixup_free_fparam_1((void **)&erl_param->value.fp, param_no); } - if (param_no==2) { - LM_ERR("erl_param->value.sp.type=%d\n",erl_param->value.sp.type); - if (erl_param->value.sp.type == PVT_OTHER) { + if(param_no == 2) { + LM_ERR("erl_param->value.sp.type=%d\n", erl_param->value.sp.type); + if(erl_param->value.sp.type == PVT_OTHER) { pv_spec_free((pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname); - } else if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - return fixup_free_fparam_2((void**)&erl_param->value.fp,param_no); + } else if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + return fixup_free_fparam_2((void **)&erl_param->value.fp, param_no); } } @@ -931,13 +904,13 @@ int fixup_free_reg(void** param, int param_no) { static int erl_reply_k(struct sip_msg *msg, char *_emsg) { - erl_param_t *param_emsg=(erl_param_t*)_emsg; + erl_param_t *param_emsg = (erl_param_t *)_emsg; str str_msg; - sr_xavp_t *xmsg=NULL; + sr_xavp_t *xmsg = NULL; pv_spec_t sp; pv_spec_t *nsp = NULL; - pv_param_t pvp; + pv_param_t pvp; pv_name_t *pvn; pv_index_t *pvi; int idx; @@ -947,85 +920,87 @@ static int erl_reply_k(struct sip_msg *msg, char *_emsg) ei_x_new_with_version(&ei_msg); - switch(param_emsg->type){ - case ERL_PARAM_FPARAM: - if(get_str_fparam(&str_msg,msg,param_emsg->value.fp)){ - LM_ERR("can't get emsg parameter\n"); - goto err; - } + switch(param_emsg->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&str_msg, msg, param_emsg->value.fp)) { + LM_ERR("can't get emsg parameter\n"); + goto err; + } - ei_x_encode_string_len(&ei_msg,str_msg.s,str_msg.len); + ei_x_encode_string_len(&ei_msg, str_msg.s, str_msg.len); - break; - case ERL_PARAM_XBUFF_SPEC: - pvp = param_emsg->value.sp.pvp; /* work on copy */ + break; + case ERL_PARAM_XBUFF_SPEC: + pvp = param_emsg->value.sp.pvp; /* work on copy */ - if( pvp.pvn.type == PV_NAME_PVAR) { - nsp = pvp.pvn.u.dname; - } + if(pvp.pvn.type == PV_NAME_PVAR) { + nsp = pvp.pvn.u.dname; + } - if (nsp) { - pvi = &nsp->pvp.pvi; - pvn = &nsp->pvp.pvn; - sp = *nsp; - } else { - pvi = &pvp.pvi; - pvn = &pvp.pvn; - sp = param_emsg->value.sp; - } + if(nsp) { + pvi = &nsp->pvp.pvi; + pvn = &nsp->pvp.pvn; + sp = *nsp; + } else { + pvi = &pvp.pvi; + pvn = &pvp.pvn; + sp = param_emsg->value.sp; + } - if (sp.setf == pv_list_set ) { - xmsg = pv_list_get_list(&pvn->u.isname.name.s); - } else if (sp.setf == pv_xbuff_set) { - xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); - } else if (sp.setf == pv_tuple_set) { - xmsg = pv_tuple_get_tuple(&pvn->u.isname.name.s); - } + if(sp.setf == pv_list_set) { + xmsg = pv_list_get_list(&pvn->u.isname.name.s); + } else if(sp.setf == pv_xbuff_set) { + xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); + } else if(sp.setf == pv_tuple_set) { + xmsg = pv_tuple_get_tuple(&pvn->u.isname.name.s); + } - /* fix index */ - attr = xbuff_get_attr_flags(pvi->type); - pvi->type = xbuff_fix_index(pvi->type); + /* fix index */ + attr = xbuff_get_attr_flags(pvi->type); + pvi->type = xbuff_fix_index(pvi->type); - /* get the index */ - if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) - { - LM_ERR("invalid index\n"); - return -1; - } + /* get the index */ + if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) { + LM_ERR("invalid index\n"); + return -1; + } - if (xbuff_is_attr_set(attr)) { - LM_WARN("attribute is not expected here!\n"); - } + if(xbuff_is_attr_set(attr)) { + LM_WARN("attribute is not expected here!\n"); + } - if (!xmsg) { - LM_ERR("undefined variable '%.*s'\n",STR_FMT(&pvn->u.isname.name.s)); - return -1; - } + if(!xmsg) { + LM_ERR("undefined variable '%.*s'\n", + STR_FMT(&pvn->u.isname.name.s)); + return -1; + } - xmsg = xmsg->val.v.xavp; + xmsg = xmsg->val.v.xavp; - if ((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr) ) { - xmsg = xavp_get_nth(&xmsg->val.v.xavp,idx,NULL); - } + if((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr)) { + xmsg = xavp_get_nth(&xmsg->val.v.xavp, idx, NULL); + } - if (!xmsg) { - LM_ERR("undefined value in '%.*s' at index %d\n",STR_FMT(&pvn->u.isname.name.s),idx); - goto err; - } + if(!xmsg) { + LM_ERR("undefined value in '%.*s' at index %d\n", + STR_FMT(&pvn->u.isname.name.s), idx); + goto err; + } - /* ei_x_buff <- XAVP */ - if (erl_api.xavp2xbuff(&ei_msg,xmsg)) { - LM_ERR("failed to encode %.*s\n",STR_FMT(&pvn->u.isname.name.s)); - goto err; - } + /* ei_x_buff <- XAVP */ + if(erl_api.xavp2xbuff(&ei_msg, xmsg)) { + LM_ERR("failed to encode %.*s\n", + STR_FMT(&pvn->u.isname.name.s)); + goto err; + } - break; - default: - LM_ERR("unexpected type for emsg parameter\n"); - return -1; + break; + default: + LM_ERR("unexpected type for emsg parameter\n"); + return -1; } - if (erl_api.reply(&ei_msg)) { + if(erl_api.reply(&ei_msg)) { goto err; } @@ -1039,81 +1014,81 @@ static int erl_reply_k(struct sip_msg *msg, char *_emsg) return -1; } -static int fixup_reply(void** param, int param_no) +static int fixup_reply(void **param, int param_no) { erl_param_t *erl_param; pv_spec_p psp; str s; - erl_param=(erl_param_t*)pkg_malloc(sizeof(erl_param_t)); + erl_param = (erl_param_t *)pkg_malloc(sizeof(erl_param_t)); if(!erl_param) { LM_ERR("no more memory\n"); return -1; } - memset(erl_param,0,sizeof(erl_param_t)); + memset(erl_param, 0, sizeof(erl_param_t)); - if (param_no==1) { + if(param_no == 1) { - s.s = (char*)*param; s.len = strlen(s.s); + s.s = (char *)*param; + s.len = strlen(s.s); - if (pv_parse_avp_name(&erl_param->value.sp,&s)) { - LM_ERR("failed to parse parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(pv_parse_avp_name(&erl_param->value.sp, &s)) { + LM_ERR("failed to parse parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } - if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - if (fix_param_types(FPARAM_STR|FPARAM_STRING,param)) { - LM_ERR("wrong parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + if(fix_param_types(FPARAM_STR | FPARAM_STRING, param)) { + LM_ERR("wrong parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } erl_param->type = ERL_PARAM_FPARAM; - erl_param->value.fp = (fparam_t*)*param; + erl_param->value.fp = (fparam_t *)*param; } else { - if (erl_param->value.sp.type ==PVT_XAVP) { - LM_ERR("XAVP not acceptable for parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(erl_param->value.sp.type == PVT_XAVP) { + LM_ERR("XAVP not acceptable for parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } psp = (pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname; - if (psp->setf == pv_list_set - || psp->setf == pv_xbuff_set - || psp->setf == pv_tuple_set - || psp->setf == pv_atom_set) { + if(psp->setf == pv_list_set || psp->setf == pv_xbuff_set + || psp->setf == pv_tuple_set || psp->setf == pv_atom_set) { erl_param->type = ERL_PARAM_XBUFF_SPEC; } else { - LM_ERR("wrong parameter #%d\n",param_no); + LM_ERR("wrong parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } } } - *param = (void*)erl_param; + *param = (void *)erl_param; return 0; } -int fixup_free_reply(void** param, int param_no) { +int fixup_free_reply(void **param, int param_no) +{ erl_param_t *erl_param; - erl_param = (erl_param_t*)*param; + erl_param = (erl_param_t *)*param; - if (param_no==1) { - LM_ERR("erl_param->value.sp.type=%d\n",erl_param->value.sp.type); - if (erl_param->value.sp.type == PVT_OTHER) { + if(param_no == 1) { + LM_ERR("erl_param->value.sp.type=%d\n", erl_param->value.sp.type); + if(erl_param->value.sp.type == PVT_OTHER) { pv_spec_free((pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname); - } else if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - return fixup_free_fparam_2((void**)&erl_param->value.fp,param_no); + } else if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + return fixup_free_fparam_2((void **)&erl_param->value.fp, param_no); } } @@ -1122,14 +1097,14 @@ int fixup_free_reply(void** param, int param_no) { static int erl_send_k(struct sip_msg *msg, char *_pid, char *_emsg) { - erl_param_t *param_pid=(erl_param_t*)_pid; - erl_param_t *param_emsg=(erl_param_t*)_emsg; + erl_param_t *param_pid = (erl_param_t *)_pid; + erl_param_t *param_emsg = (erl_param_t *)_emsg; str str_msg; - sr_xavp_t *xmsg=NULL; + sr_xavp_t *xmsg = NULL; pv_spec_t sp; pv_spec_t *nsp; - pv_param_t pvp; + pv_param_t pvp; pv_name_t *pvn; pv_index_t *pvi; int idx; @@ -1138,162 +1113,166 @@ static int erl_send_k(struct sip_msg *msg, char *_pid, char *_emsg) ei_x_buff ei_msg; erlang_pid *pid; - switch (param_pid->type) { - case ERL_PARAM_XBUFF_SPEC: - nsp = NULL; - pvp = param_pid->value.sp.pvp; /* work on copy */ + switch(param_pid->type) { + case ERL_PARAM_XBUFF_SPEC: + nsp = NULL; + pvp = param_pid->value.sp.pvp; /* work on copy */ - if( pvp.pvn.type == PV_NAME_PVAR) { - nsp = pvp.pvn.u.dname; - } + if(pvp.pvn.type == PV_NAME_PVAR) { + nsp = pvp.pvn.u.dname; + } - if (nsp) { - pvi = &nsp->pvp.pvi; - pvn = &nsp->pvp.pvn; - sp = *nsp; - } else { - pvi = &pvp.pvi; - pvn = &pvp.pvn; - sp = param_pid->value.sp; - } + if(nsp) { + pvi = &nsp->pvp.pvi; + pvn = &nsp->pvp.pvn; + sp = *nsp; + } else { + pvi = &pvp.pvi; + pvn = &pvp.pvn; + sp = param_pid->value.sp; + } - if (sp.getf == pv_pid_get ) { - xmsg = pv_pid_get_pid(&pvn->u.isname.name.s); - } else if (sp.getf == pv_xbuff_get) { - xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); - } else { - LM_ERR("BUG: unexpected type for pid parameter\n"); - return -1; - } + if(sp.getf == pv_pid_get) { + xmsg = pv_pid_get_pid(&pvn->u.isname.name.s); + } else if(sp.getf == pv_xbuff_get) { + xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); + } else { + LM_ERR("BUG: unexpected type for pid parameter\n"); + return -1; + } - /* fix index */ - attr = xbuff_get_attr_flags(pvi->type); + /* fix index */ + attr = xbuff_get_attr_flags(pvi->type); - /* get the index */ - if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) - { - LM_ERR("invalid index\n"); - return -1; - } + /* get the index */ + if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) { + LM_ERR("invalid index\n"); + return -1; + } - if (xbuff_is_attr_set(attr)) { - LM_WARN("attribute is not expected here!\n"); - } + if(xbuff_is_attr_set(attr)) { + LM_WARN("attribute is not expected here!\n"); + } - if (!xmsg) { - LM_ERR("undefined variable '%.*s'\n",STR_FMT(&pvn->u.isname.name.s)); - return -1; - } + if(!xmsg) { + LM_ERR("undefined variable '%.*s'\n", + STR_FMT(&pvn->u.isname.name.s)); + return -1; + } - xmsg = xmsg->val.v.xavp; + xmsg = xmsg->val.v.xavp; - if ((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr) ) { - xmsg = xavp_get_nth(&xmsg->val.v.xavp,idx,NULL); - } + if((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr)) { + xmsg = xavp_get_nth(&xmsg->val.v.xavp, idx, NULL); + } - if (!xmsg) { - LM_ERR("undefined value in '%.*s' at index %d\n",STR_FMT(&pvn->u.isname.name.s),idx); - goto err; - } + if(!xmsg) { + LM_ERR("undefined value in '%.*s' at index %d\n", + STR_FMT(&pvn->u.isname.name.s), idx); + goto err; + } - /* erlang_pid <- XAVP */ - if (xmsg->name.s[0] == 'p' && xmsg->val.type == SR_XTYPE_DATA && xmsg->val.v.data) { - pid = xmsg->val.v.data->p; - } else { - LM_ERR("invalid value for pid parameter\n"); + /* erlang_pid <- XAVP */ + if(xmsg->name.s[0] == 'p' && xmsg->val.type == SR_XTYPE_DATA + && xmsg->val.v.data) { + pid = xmsg->val.v.data->p; + } else { + LM_ERR("invalid value for pid parameter\n"); + return -1; + } + break; + default: + LM_ERR("unexpected type for pid parameter\n"); return -1; - } - break; - default: - LM_ERR("unexpected type for pid parameter\n"); - return -1; } ei_x_new_with_version(&ei_msg); - switch(param_emsg->type){ - case ERL_PARAM_FPARAM: - if(get_str_fparam(&str_msg,msg,param_emsg->value.fp)){ - LM_ERR("can't get emsg parameter\n"); - goto err; - } + switch(param_emsg->type) { + case ERL_PARAM_FPARAM: + if(get_str_fparam(&str_msg, msg, param_emsg->value.fp)) { + LM_ERR("can't get emsg parameter\n"); + goto err; + } - ei_x_encode_string_len(&ei_msg,str_msg.s,str_msg.len); + ei_x_encode_string_len(&ei_msg, str_msg.s, str_msg.len); - break; - case ERL_PARAM_XBUFF_SPEC: - nsp = NULL; - pvp = param_emsg->value.sp.pvp; /* work on copy */ + break; + case ERL_PARAM_XBUFF_SPEC: + nsp = NULL; + pvp = param_emsg->value.sp.pvp; /* work on copy */ - if( pvp.pvn.type == PV_NAME_PVAR) { - nsp = pvp.pvn.u.dname; - } + if(pvp.pvn.type == PV_NAME_PVAR) { + nsp = pvp.pvn.u.dname; + } - if (nsp) { - pvi = &nsp->pvp.pvi; - pvn = &nsp->pvp.pvn; - sp = *nsp; - } else { - pvi = &pvp.pvi; - pvn = &pvp.pvn; - sp = param_emsg->value.sp; - } + if(nsp) { + pvi = &nsp->pvp.pvi; + pvn = &nsp->pvp.pvn; + sp = *nsp; + } else { + pvi = &pvp.pvi; + pvn = &pvp.pvn; + sp = param_emsg->value.sp; + } - if (sp.getf == pv_list_get ) { - xmsg = pv_list_get_list(&pvn->u.isname.name.s); - } else if (sp.getf == pv_xbuff_get) { - xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); - } else if (sp.getf == pv_tuple_get) { - xmsg = pv_tuple_get_tuple(&pvn->u.isname.name.s); - } else if (sp.getf == pv_atom_get) { - xmsg = pv_atom_get_atom(&pvn->u.isname.name.s); - } else if (sp.getf == pv_pid_get) { - xmsg = pv_pid_get_pid(&pvn->u.isname.name.s); - } + if(sp.getf == pv_list_get) { + xmsg = pv_list_get_list(&pvn->u.isname.name.s); + } else if(sp.getf == pv_xbuff_get) { + xmsg = pv_xbuff_get_xbuff(&pvn->u.isname.name.s); + } else if(sp.getf == pv_tuple_get) { + xmsg = pv_tuple_get_tuple(&pvn->u.isname.name.s); + } else if(sp.getf == pv_atom_get) { + xmsg = pv_atom_get_atom(&pvn->u.isname.name.s); + } else if(sp.getf == pv_pid_get) { + xmsg = pv_pid_get_pid(&pvn->u.isname.name.s); + } - /* fix index */ - attr = xbuff_get_attr_flags(pvi->type); + /* fix index */ + attr = xbuff_get_attr_flags(pvi->type); - /* get the index */ - if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) - { - LM_ERR("invalid index\n"); - return -1; - } + /* get the index */ + if(pv_get_spec_index(msg, &pvp, &idx, &idxf)) { + LM_ERR("invalid index\n"); + return -1; + } - if (xbuff_is_attr_set(attr)) { - LM_WARN("attribute is not expected here!\n"); - } + if(xbuff_is_attr_set(attr)) { + LM_WARN("attribute is not expected here!\n"); + } - if (!xmsg) { - LM_ERR("undefined variable '%.*s'\n",STR_FMT(&pvn->u.isname.name.s)); - return -1; - } + if(!xmsg) { + LM_ERR("undefined variable '%.*s'\n", + STR_FMT(&pvn->u.isname.name.s)); + return -1; + } - xmsg = xmsg->val.v.xavp; + xmsg = xmsg->val.v.xavp; - if ((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr) ) { - xmsg = xavp_get_nth(&xmsg->val.v.xavp,idx,NULL); - } + if((idxf != PV_IDX_ALL) && !xbuff_is_no_index(attr)) { + xmsg = xavp_get_nth(&xmsg->val.v.xavp, idx, NULL); + } - if (!xmsg) { - LM_ERR("undefined value in '%.*s' at index %d\n",STR_FMT(&pvn->u.isname.name.s),idx); - goto err; - } + if(!xmsg) { + LM_ERR("undefined value in '%.*s' at index %d\n", + STR_FMT(&pvn->u.isname.name.s), idx); + goto err; + } - /* ei_x_buff <- XAVP */ - if (erl_api.xavp2xbuff(&ei_msg,xmsg)) { - LM_ERR("failed to encode %.*s\n",STR_FMT(&pvn->u.isname.name.s)); - goto err; - } + /* ei_x_buff <- XAVP */ + if(erl_api.xavp2xbuff(&ei_msg, xmsg)) { + LM_ERR("failed to encode %.*s\n", + STR_FMT(&pvn->u.isname.name.s)); + goto err; + } - break; - default: - LM_ERR("unexpected type for emsg parameter\n"); - return -1; + break; + default: + LM_ERR("unexpected type for emsg parameter\n"); + return -1; } - if (erl_api.send(pid,&ei_msg)) { + if(erl_api.send(pid, &ei_msg)) { goto err; } @@ -1307,124 +1286,124 @@ static int erl_send_k(struct sip_msg *msg, char *_pid, char *_emsg) return -1; } -static int fixup_send(void** param, int param_no) +static int fixup_send(void **param, int param_no) { erl_param_t *erl_param; pv_spec_p psp; str s; - erl_param=(erl_param_t*)pkg_malloc(sizeof(erl_param_t)); + erl_param = (erl_param_t *)pkg_malloc(sizeof(erl_param_t)); if(!erl_param) { LM_ERR("no more memory\n"); return -1; } - memset(erl_param,0,sizeof(erl_param_t)); + memset(erl_param, 0, sizeof(erl_param_t)); - if (param_no==1) { + if(param_no == 1) { - s.s = (char*)*param; s.len = strlen(s.s); + s.s = (char *)*param; + s.len = strlen(s.s); - if (pv_parse_avp_name(&erl_param->value.sp,&s)) { - LM_ERR("failed to parse parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(pv_parse_avp_name(&erl_param->value.sp, &s)) { + LM_ERR("failed to parse parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } - if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - if (fix_param_types(FPARAM_STR|FPARAM_STRING,param)) { - LM_ERR("wrong parameter #%d\n",param_no); + if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + if(fix_param_types(FPARAM_STR | FPARAM_STRING, param)) { + LM_ERR("wrong parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } erl_param->type = ERL_PARAM_FPARAM; - erl_param->value.fp = (fparam_t*)*param; - } - else { - if (erl_param->value.sp.type == PVT_XAVP) { - LM_ERR("XAVP not acceptable for parameter #%d\n",param_no); + erl_param->value.fp = (fparam_t *)*param; + } else { + if(erl_param->value.sp.type == PVT_XAVP) { + LM_ERR("XAVP not acceptable for parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } psp = (pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname; - if (psp->getf == pv_pid_get || psp->getf == pv_xbuff_get) { + if(psp->getf == pv_pid_get || psp->getf == pv_xbuff_get) { erl_param->type = ERL_PARAM_XBUFF_SPEC; } else { - LM_ERR("wrong parameter #%d\n",param_no); + LM_ERR("wrong parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } } } - if (param_no==2) { + if(param_no == 2) { - s.s = (char*)*param; s.len = strlen(s.s); + s.s = (char *)*param; + s.len = strlen(s.s); - if (pv_parse_avp_name(&erl_param->value.sp,&s)) { - LM_ERR("failed to parse parameter #%d\n",param_no); - pkg_free((void*)erl_param); + if(pv_parse_avp_name(&erl_param->value.sp, &s)) { + LM_ERR("failed to parse parameter #%d\n", param_no); + pkg_free((void *)erl_param); return E_UNSPEC; } - if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - if (fix_param_types(FPARAM_STR|FPARAM_STRING,param)) { - LM_ERR("wrong parameter #%d\n",param_no); + if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + if(fix_param_types(FPARAM_STR | FPARAM_STRING, param)) { + LM_ERR("wrong parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } erl_param->type = ERL_PARAM_FPARAM; - erl_param->value.fp = (fparam_t*)*param; + erl_param->value.fp = (fparam_t *)*param; } else { - if (erl_param->value.sp.type ==PVT_XAVP) { - LM_ERR("XAVP not acceptable for parameter #%d\n",param_no); + if(erl_param->value.sp.type == PVT_XAVP) { + LM_ERR("XAVP not acceptable for parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } psp = (pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname; - if (psp->getf == pv_list_get - || psp->getf == pv_xbuff_get - || psp->getf == pv_tuple_get - || psp->getf == pv_atom_get + if(psp->getf == pv_list_get || psp->getf == pv_xbuff_get + || psp->getf == pv_tuple_get || psp->getf == pv_atom_get || psp->getf == pv_pid_get) { erl_param->type = ERL_PARAM_XBUFF_SPEC; } else { - LM_ERR("wrong parameter #%d\n",param_no); + LM_ERR("wrong parameter #%d\n", param_no); pv_spec_destroy(&erl_param->value.sp); - pkg_free((void*)erl_param); + pkg_free((void *)erl_param); return E_UNSPEC; } } } - *param = (void*)erl_param; + *param = (void *)erl_param; return 0; } -int fixup_free_send(void** param, int param_no) { +int fixup_free_send(void **param, int param_no) +{ erl_param_t *erl_param; - erl_param = (erl_param_t*)*param; + erl_param = (erl_param_t *)*param; - if (param_no==1 || param_no==2) { - if (erl_param->value.sp.type == PVT_OTHER) { + if(param_no == 1 || param_no == 2) { + if(erl_param->value.sp.type == PVT_OTHER) { pv_spec_free((pv_spec_p)erl_param->value.sp.pvp.pvn.u.dname); - } else if (erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { - return fixup_free_fparam_2((void**)&erl_param->value.fp,param_no); + } else if(erl_param->value.sp.pvp.pvn.type == PV_NAME_INTSTR) { + return fixup_free_fparam_2((void **)&erl_param->value.fp, param_no); } } diff --git a/src/modules/erlang/erlang_mod.h b/src/modules/erlang/erlang_mod.h index 37a26384576..c7403ca9031 100644 --- a/src/modules/erlang/erlang_mod.h +++ b/src/modules/erlang/erlang_mod.h @@ -29,7 +29,7 @@ #include "../../core/xavp.h" #include "erl_api.h" -extern str cookie; /* Erlang cookie */ +extern str cookie; /* Erlang cookie */ extern int trace_level; /* Tracing level on the distribution */ extern str cnode_alivename; extern str cnode_host; @@ -46,13 +46,14 @@ extern int *usocks[2]; extern int csockfd; /* socket to cnode process */ -#define KSOCKET 0 -#define CSOCKET 1 +#define KSOCKET 0 +#define CSOCKET 1 /** * types of command parameter */ -typedef enum { +typedef enum +{ ERL_PARAM_FPARAM, ERL_PARAM_XBUFF_SPEC } erl_param_type; @@ -62,9 +63,11 @@ typedef enum { * * combine str and PV */ -typedef struct erl_param_s { +typedef struct erl_param_s +{ erl_param_type type; - union { + union + { fparam_t *fp; pv_spec_t sp; } value; diff --git a/src/modules/erlang/handle_emsg.c b/src/modules/erlang/handle_emsg.c index 0f709e548ff..2cba25f71a8 100644 --- a/src/modules/erlang/handle_emsg.c +++ b/src/modules/erlang/handle_emsg.c @@ -39,14 +39,16 @@ #include "../../core/cfg/cfg_struct.h" #include "../../core/fmsg.h" -int handle_msg_req_tuple(cnode_handler_t *phandler, erlang_msg * msg); -int handle_req_ref_tuple(cnode_handler_t *phandler, erlang_msg * msg); -int handle_rpc_response(cnode_handler_t *phandler, erlang_msg * msg, int arity); -int handle_rex_call(cnode_handler_t *phandler,erlang_ref_ex_t *ref, erlang_pid *pid); -int handle_net_kernel(cnode_handler_t *phandler, erlang_msg * msg); -void encode_error_msg(ei_x_buff *response, erlang_ref_ex_t *ref, const char *type, const char *msg, ...); - -int handle_reg_send(cnode_handler_t *phandler, erlang_msg * msg) +int handle_msg_req_tuple(cnode_handler_t *phandler, erlang_msg *msg); +int handle_req_ref_tuple(cnode_handler_t *phandler, erlang_msg *msg); +int handle_rpc_response(cnode_handler_t *phandler, erlang_msg *msg, int arity); +int handle_rex_call( + cnode_handler_t *phandler, erlang_ref_ex_t *ref, erlang_pid *pid); +int handle_net_kernel(cnode_handler_t *phandler, erlang_msg *msg); +void encode_error_msg(ei_x_buff *response, erlang_ref_ex_t *ref, + const char *type, const char *msg, ...); + +int handle_reg_send(cnode_handler_t *phandler, erlang_msg *msg) { int rt, backup_rt; struct run_act_ctx ctx; @@ -62,20 +64,21 @@ int handle_reg_send(cnode_handler_t *phandler, erlang_msg * msg) sr_xval_t val; sr_data_t *data = NULL; - sz = sizeof("erlang")+strlen(msg->toname)+2; - route = (char*)pkg_malloc(sz); - if (!route) { + sz = sizeof("erlang") + strlen(msg->toname) + 2; + route = (char *)pkg_malloc(sz); + if(!route) { LM_ERR("not enough memory"); return -1; } - snprintf(route,sz,"erlang:%s",msg->toname); + snprintf(route, sz, "erlang:%s", msg->toname); rt = route_get(&event_rt, route); - if (rt < 0 || event_rt.rlist[rt] == NULL) { + if(rt < 0 || event_rt.rlist[rt] == NULL) { LM_WARN("ERL_REG_SEND message to unknown process %s\n", route); pkg_free(route); - PRINT_DBG_REG_SEND(phandler->conn.nodename, msg->from, phandler->ec.thisnodename, msg->toname,request); + PRINT_DBG_REG_SEND(phandler->conn.nodename, msg->from, + phandler->ec.thisnodename, msg->toname, request); return 0; } @@ -85,14 +88,14 @@ int handle_reg_send(cnode_handler_t *phandler, erlang_msg * msg) memcpy(&tmsg, fmsg, sizeof(sip_msg_t)); fmsg = &tmsg; - if ((xreq = pv_xbuff_get_xbuff(&msg_name))) { + if((xreq = pv_xbuff_get_xbuff(&msg_name))) { LM_DBG("free previous $xbuff(msg) value\n"); xavp_destroy_list(&xreq->val.v.xavp); } else { xreq = xbuff_new(&msg_name); } - if (!xreq) { + if(!xreq) { LM_ERR("failed to create $xbuff(msg) variable\n"); goto err; } @@ -101,42 +104,42 @@ int handle_reg_send(cnode_handler_t *phandler, erlang_msg * msg) xreq->val.type = SR_XTYPE_XAVP; /* XAVP <- ei_x_buff */ - if (erl_api.xbuff2xavp(&xreq->val.v.xavp,request)){ + if(erl_api.xbuff2xavp(&xreq->val.v.xavp, request)) { LM_ERR("failed to decode message\n"); goto err; } - if ((xpid = pv_xbuff_get_xbuff(&pid_name))) { + if((xpid = pv_xbuff_get_xbuff(&pid_name))) { LM_DBG("free previous $xbuff(pid) value\n"); xavp_destroy_list(&xpid->val.v.xavp); } else { xpid = xbuff_new(&pid_name); } - if (!xpid) { + if(!xpid) { LM_ERR("failed to create $xbuff(pid) variable\n"); goto err; } /* put erl_pid into $xbuff(pid) */ - data = (sr_data_t*)shm_malloc(sizeof(sr_data_t)+sizeof(erlang_pid)); - if (!data) { + data = (sr_data_t *)shm_malloc(sizeof(sr_data_t) + sizeof(erlang_pid)); + if(!data) { LM_ERR("not enough shared memory\n"); goto err; } - memset((void*)data,0,sizeof(sr_data_t)+sizeof(erlang_pid)); + memset((void *)data, 0, sizeof(sr_data_t) + sizeof(erlang_pid)); - data->p = (void*)data+sizeof(sr_data_t); + data->p = (void *)data + sizeof(sr_data_t); data->pfree = xbuff_data_free; - memcpy(data->p,(void*)&msg->from,sizeof(erlang_pid)); + memcpy(data->p, (void *)&msg->from, sizeof(erlang_pid)); val.type = SR_XTYPE_DATA; val.v.data = data; - xpid->val.v.xavp = xavp_new_value(&pid_name,&val); - if (!xpid->val.v.xavp) { + xpid->val.v.xavp = xavp_new_value(&pid_name, &val); + if(!xpid->val.v.xavp) { LM_ERR("failed to create xavp!\n"); goto err; } @@ -167,21 +170,23 @@ int handle_reg_send(cnode_handler_t *phandler, erlang_msg * msg) /* * handle ERL_SEND */ -int handle_send(cnode_handler_t *phandler, erlang_msg * msg) +int handle_send(cnode_handler_t *phandler, erlang_msg *msg) { int rt, backup_rt; struct run_act_ctx ctx; sip_msg_t *fmsg; sip_msg_t tmsg; - char route[]="erlang:self"; + char route[] = "erlang:self"; ei_x_buff *request = &phandler->request; sr_xavp_t *xreq = NULL; str msg_name = str_init("msg"); rt = route_get(&event_rt, route); - if (rt < 0 || event_rt.rlist[rt] == NULL) { - LM_WARN("ERL_SEND message not handled, missing event route %s\n", route); - PRINT_DBG_REG_SEND(phandler->conn.nodename, msg->from, phandler->ec.thisnodename, msg->toname,request); + if(rt < 0 || event_rt.rlist[rt] == NULL) { + LM_WARN("ERL_SEND message not handled, missing event route %s\n", + route); + PRINT_DBG_REG_SEND(phandler->conn.nodename, msg->from, + phandler->ec.thisnodename, msg->toname, request); return 0; } @@ -191,14 +196,14 @@ int handle_send(cnode_handler_t *phandler, erlang_msg * msg) memcpy(&tmsg, fmsg, sizeof(sip_msg_t)); fmsg = &tmsg; - if ((xreq = pv_xbuff_get_xbuff(&msg_name))) { + if((xreq = pv_xbuff_get_xbuff(&msg_name))) { LM_DBG("free previous value\n"); xavp_destroy_list(&xreq->val.v.xavp); } else { xreq = xbuff_new(&msg_name); } - if (!xreq) { + if(!xreq) { LM_ERR("failed to create $xbuff(msg) variable\n"); goto err; } @@ -207,7 +212,7 @@ int handle_send(cnode_handler_t *phandler, erlang_msg * msg) xreq->val.type = SR_XTYPE_XAVP; /* XAVP <- ei_x_buff */ - if (erl_api.xbuff2xavp(&xreq->val.v.xavp,request)){ + if(erl_api.xbuff2xavp(&xreq->val.v.xavp, request)) { LM_ERR("failed to decode message\n"); goto err; } @@ -228,7 +233,7 @@ int handle_send(cnode_handler_t *phandler, erlang_msg * msg) return -1; } -int handle_req_ref_tuple(cnode_handler_t *phandler, erlang_msg * msg) +int handle_req_ref_tuple(cnode_handler_t *phandler, erlang_msg *msg) { erlang_ref ref; erlang_pid pid; @@ -238,24 +243,19 @@ int handle_req_ref_tuple(cnode_handler_t *phandler, erlang_msg * msg) ei_decode_tuple_header(request->buff, &request->index, &arity); - if (ei_decode_ref(request->buff, &request->index, &ref)) - { + if(ei_decode_ref(request->buff, &request->index, &ref)) { LM_WARN("Invalid reference.\n"); return -1; } - if (ei_decode_pid(request->buff, &request->index, &pid)) - { + if(ei_decode_pid(request->buff, &request->index, &pid)) { LM_ERR("Invalid pid in a reference/pid tuple\n"); return -1; } - if (0) - { + if(0) { ei_x_encode_atom(response, "ok"); - } - else - { + } else { ei_x_encode_tuple_header(response, 2); ei_x_encode_atom(response, "error"); ei_x_encode_atom(response, "not_found"); @@ -267,28 +267,27 @@ int handle_req_ref_tuple(cnode_handler_t *phandler, erlang_msg * msg) /* catch the response to ei_rpc_to (which comes back as {rex, {Ref, Pid}} The {Ref,Pid} bit can be handled by handle_ref_tuple */ -int handle_rpc_response(cnode_handler_t *phandler, erlang_msg * msg, int arity) +int handle_rpc_response(cnode_handler_t *phandler, erlang_msg *msg, int arity) { int type, size, arity2, tmpindex; ei_x_buff *request = &phandler->request; ei_get_type(request->buff, &request->index, &type, &size); - switch (type) - { - case ERL_SMALL_TUPLE_EXT: - case ERL_LARGE_TUPLE_EXT: - tmpindex = request->index; - ei_decode_tuple_header(request->buff, &tmpindex, &arity2); - return handle_req_ref_tuple(phandler, msg); - default: - LM_ERR("Unknown RPC response.\n"); - break; + switch(type) { + case ERL_SMALL_TUPLE_EXT: + case ERL_LARGE_TUPLE_EXT: + tmpindex = request->index; + ei_decode_tuple_header(request->buff, &tmpindex, &arity2); + return handle_req_ref_tuple(phandler, msg); + default: + LM_ERR("Unknown RPC response.\n"); + break; } /* no reply */ return -1; } -int handle_msg_req_tuple(cnode_handler_t *phandler, erlang_msg * msg) +int handle_msg_req_tuple(cnode_handler_t *phandler, erlang_msg *msg) { char tupletag[MAXATOMLEN]; int arity; @@ -296,18 +295,12 @@ int handle_msg_req_tuple(cnode_handler_t *phandler, erlang_msg * msg) ei_x_buff *request = &phandler->request; ei_decode_tuple_header(request->buff, &request->index, &arity); - if (ei_decode_atom(request->buff, &request->index, tupletag)) - { + if(ei_decode_atom(request->buff, &request->index, tupletag)) { LM_ERR("error: badarg\n"); - } - else - { - if (!strncmp(tupletag, "rex", MAXATOMLEN)) - { + } else { + if(!strncmp(tupletag, "rex", MAXATOMLEN)) { ret = handle_rpc_response(phandler, msg, arity); - } - else - { + } else { LM_ERR("error: undef\n"); } } @@ -319,7 +312,7 @@ int handle_msg_req_tuple(cnode_handler_t *phandler, erlang_msg * msg) * * {'$gen_call', {, #Ref<194674.122.0>}, {is_auth, 'tbe1@tbe.lan'}} for net_kernel */ -int handle_net_kernel(cnode_handler_t *phandler, erlang_msg * msg) +int handle_net_kernel(cnode_handler_t *phandler, erlang_msg *msg) { int version, size, type, arity; char atom[MAXATOMLEN]; @@ -333,69 +326,60 @@ int handle_net_kernel(cnode_handler_t *phandler, erlang_msg * msg) ei_decode_version(request->buff, &request->index, &version); ei_get_type(request->buff, &request->index, &type, &size); - if (type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) - { + if(type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) { LM_ERR("not a tuple\n"); return -1; } ei_decode_tuple_header(request->buff, &request->index, &arity); - if (arity != 3) - { + if(arity != 3) { LM_ERR("wrong arity\n"); return -1; } - if (ei_decode_atom(request->buff, &request->index, atom) || strncmp(atom, - "$gen_call", MAXATOMLEN)) - { + if(ei_decode_atom(request->buff, &request->index, atom) + || strncmp(atom, "$gen_call", MAXATOMLEN)) { LM_ERR("not atom '$gen_call'\n"); return -1; } ei_get_type(request->buff, &request->index, &type, &size); - if (type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) - { + if(type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) { LM_ERR("not a tuple\n"); return -1; } ei_decode_tuple_header(request->buff, &request->index, &arity); - if (arity != 2) - { + if(arity != 2) { LM_ERR("wrong arity\n"); return -1; } - if (ei_decode_pid(request->buff, &request->index, &pid) - || ei_decode_ref(request->buff, &request->index, &ref)) - { + if(ei_decode_pid(request->buff, &request->index, &pid) + || ei_decode_ref(request->buff, &request->index, &ref)) { LM_ERR("decoding pid and ref error\n"); return -1; } ei_get_type(request->buff, &request->index, &type, &size); - if (type != ERL_SMALL_TUPLE_EXT) - { + if(type != ERL_SMALL_TUPLE_EXT) { LM_ERR("not a tuple\n"); return -1; } ei_decode_tuple_header(request->buff, &request->index, &arity); - if (arity != 2) - { + if(arity != 2) { LM_ERR("bad arity\n"); return -1; } - if (ei_decode_atom(request->buff, &request->index, atom) || strncmp(atom, - "is_auth", MAXATOMLEN)) - { + if(ei_decode_atom(request->buff, &request->index, atom) + || strncmp(atom, "is_auth", MAXATOMLEN)) { LM_ERR("not is_auth\n"); return -1; } @@ -407,63 +391,66 @@ int handle_net_kernel(cnode_handler_t *phandler, erlang_msg * msg) ei_x_print_msg(response, &pid, 1); - ei_send_tmo(phandler->sockfd, &pid, response->buff, response->index, CONNECT_TIMEOUT); + ei_send_tmo(phandler->sockfd, &pid, response->buff, response->index, + CONNECT_TIMEOUT); return -1; } -int erlang_whereis(cnode_handler_t *phandler,erlang_ref_ex_t *ref, erlang_pid *pid) +int erlang_whereis( + cnode_handler_t *phandler, erlang_ref_ex_t *ref, erlang_pid *pid) { ei_x_buff *response = &phandler->response; ei_x_buff *request = &phandler->request; - char route[sizeof("erlang:")+MAXATOMLEN] = "erlang:"; + char route[sizeof("erlang:") + MAXATOMLEN] = "erlang:"; int arity; int type; int rt; - ei_decode_list_header(request->buff,&request->index,&arity); + ei_decode_list_header(request->buff, &request->index, &arity); - if (arity != 1) { + if(arity != 1) { response->index = 1; - encode_error_msg(response, ref, "badarith", "undefined function erlang:whereis/%d",arity); + encode_error_msg(response, ref, "badarith", + "undefined function erlang:whereis/%d", arity); return 0; } - ei_get_type(request->buff,&request->index,&type,&arity); + ei_get_type(request->buff, &request->index, &type, &arity); - if (type != ERL_ATOM_EXT) { + if(type != ERL_ATOM_EXT) { response->index = 1; encode_error_msg(response, ref, "badarg", "bad argument"); return 0; } - if(ei_decode_atom(request->buff,&request->index,route+sizeof("erlang:")-1)) { + if(ei_decode_atom( + request->buff, &request->index, route + sizeof("erlang:") - 1)) { LM_ERR("error: badarg\n"); - ei_x_encode_atom(response,"badarg"); + ei_x_encode_atom(response, "badarg"); return 0; } rt = route_get(&event_rt, route); - if (rt < 0 || event_rt.rlist[rt] == NULL) { + if(rt < 0 || event_rt.rlist[rt] == NULL) { LM_WARN("can't find pseudo process %s\n", route); - ei_x_encode_atom(response,"undefined"); + ei_x_encode_atom(response, "undefined"); return 0; } - ei_x_encode_pid(response,&phandler->ec.self); + ei_x_encode_pid(response, &phandler->ec.self); return 0; } -static int handle_erlang_calls(cnode_handler_t *phandler,erlang_ref_ex_t *ref, erlang_pid *pid, const char *method) +static int handle_erlang_calls(cnode_handler_t *phandler, erlang_ref_ex_t *ref, + erlang_pid *pid, const char *method) { ei_x_buff *response = &phandler->response; - if (strcmp(method,"whereis")==0) - { - return erlang_whereis(phandler,ref,pid); - } - else { + if(strcmp(method, "whereis") == 0) { + return erlang_whereis(phandler, ref, pid); + } else { response->index = 1; encode_error_msg(response, ref, "badrpc", "Method Not Found"); } @@ -478,13 +465,14 @@ static int handle_erlang_calls(cnode_handler_t *phandler,erlang_ref_ex_t *ref, e * {call, tbe, dlg_bye, [123, 456], } * */ -int handle_rex_call(cnode_handler_t *phandler,erlang_ref_ex_t *ref, erlang_pid *pid) +int handle_rex_call( + cnode_handler_t *phandler, erlang_ref_ex_t *ref, erlang_pid *pid) { char module[MAXATOMLEN]; char method[MAXATOMLEN]; - char proc[2*MAXATOMLEN]; + char proc[2 * MAXATOMLEN]; erl_rpc_ctx_t ctx; - rpc_export_t* exp; + rpc_export_t *exp; int arity; ei_x_buff *request = &phandler->request; ei_x_buff *response = &phandler->response; @@ -495,97 +483,88 @@ int handle_rex_call(cnode_handler_t *phandler,erlang_ref_ex_t *ref, erlang_pid * * module,method...} */ - ei_get_type(request->buff,&request->index,&type,&size); + ei_get_type(request->buff, &request->index, &type, &size); #ifdef ERL_SMALL_ATOM_EXT - if (type == ERL_ATOM_EXT || type == ERL_SMALL_ATOM_EXT) - { + if(type == ERL_ATOM_EXT || type == ERL_SMALL_ATOM_EXT) { #else - if (type == ERL_ATOM_EXT) - { + if(type == ERL_ATOM_EXT) { #endif - if (ei_decode_atom(request->buff,&request->index,module)) - { - encode_error_msg(response, ref, "error", "Failed to decode module name"); + if(ei_decode_atom(request->buff, &request->index, module)) { + encode_error_msg( + response, ref, "error", "Failed to decode module name"); return 0; } - } - else if (ei_decode_strorbin(request->buff, &request->index, MAXATOMLEN, module)) - { - encode_error_msg(response, ref, "error", "Failed to decode module name"); + } else if(ei_decode_strorbin( + request->buff, &request->index, MAXATOMLEN, module)) { + encode_error_msg( + response, ref, "error", "Failed to decode module name"); return 0; } - ei_get_type(request->buff,&request->index,&type,&size); + ei_get_type(request->buff, &request->index, &type, &size); #ifdef ERL_SMALL_ATOM_EXT - if (type == ERL_ATOM_EXT || type == ERL_SMALL_ATOM_EXT) - { + if(type == ERL_ATOM_EXT || type == ERL_SMALL_ATOM_EXT) { #else - if (type == ERL_ATOM_EXT) - { + if(type == ERL_ATOM_EXT) { #endif - if (ei_decode_atom(request->buff,&request->index,method)) - { - encode_error_msg(response, ref, "error", "Failed to decode method name"); + if(ei_decode_atom(request->buff, &request->index, method)) { + encode_error_msg( + response, ref, "error", "Failed to decode method name"); return 0; } - } - else if (ei_decode_strorbin(request->buff, &request->index, MAXATOMLEN, method)) - { - encode_error_msg(response, ref, "error", "Failed to decode method name"); + } else if(ei_decode_strorbin( + request->buff, &request->index, MAXATOMLEN, method)) { + encode_error_msg( + response, ref, "error", "Failed to decode method name"); return 0; } - if (strcmp(module,"erlang") == 0) - { + if(strcmp(module, "erlang") == 0) { /* start encoding */ ei_x_encode_tuple_header(response, 2); - if (ref->with_node) - { - ei_x_encode_tuple_header(response,2); + if(ref->with_node) { + ei_x_encode_tuple_header(response, 2); ei_x_encode_ref(response, &ref->ref); - ei_x_encode_atom(response,ref->nodename); - } - else { + ei_x_encode_atom(response, ref->nodename); + } else { ei_x_encode_ref(response, &ref->ref); } - return handle_erlang_calls(phandler,ref,pid,method); + return handle_erlang_calls(phandler, ref, pid, method); } /* be up to date with cfg */ cfg_update(); - sprintf(proc,"%s.%s",module,method); + sprintf(proc, "%s.%s", module, method); - exp=find_rpc_export(proc,0); + exp = find_rpc_export(proc, 0); - if (!exp || !exp->function) - { + if(!exp || !exp->function) { encode_error_msg(response, ref, "badrpc", "Method Not Found"); return 0; } - ei_get_type(request->buff,&request->index,&type,&size); + ei_get_type(request->buff, &request->index, &type, &size); /* open list for decoding */ - if (ei_decode_list_header(request->buff,&request->index,&arity)) - { - LOG(L_ERR, "Expected list of parameters type=<%c> arity=<%d>\n", type, size); - encode_error_msg(response, ref, "badarith", "Expected list of parameters."); + if(ei_decode_list_header(request->buff, &request->index, &arity)) { + LOG(L_ERR, "Expected list of parameters type=<%c> arity=<%d>\n", type, + size); + encode_error_msg( + response, ref, "badarith", "Expected list of parameters."); return 0; } /* start encoding */ ei_x_encode_tuple_header(response, 2); - if (ref->with_node) - { - ei_x_encode_tuple_header(response,2); + if(ref->with_node) { + ei_x_encode_tuple_header(response, 2); ei_x_encode_ref(response, &ref->ref); - ei_x_encode_atom(response,ref->nodename); - } - else { + ei_x_encode_atom(response, ref->nodename); + } else { ei_x_encode_ref(response, &ref->ref); } @@ -608,23 +587,19 @@ int handle_rex_call(cnode_handler_t *phandler,erlang_ref_ex_t *ref, erlang_pid * /* call rpc */ rex_call_in_progress = 1; - exp->function(&erl_rpc_func_param,(void*)&ctx); + exp->function(&erl_rpc_func_param, (void *)&ctx); rex_call_in_progress = 0; - if (ctx.no_params) - { - ei_x_encode_list_header(response,ctx.no_params); + if(ctx.no_params) { + ei_x_encode_list_header(response, ctx.no_params); } - if (erl_rpc_send(&ctx, 0)) - { + if(erl_rpc_send(&ctx, 0)) { response->index = ctx.response_index; ei_x_encode_atom(response, "error"); - ei_x_encode_tuple_header(response,2); + ei_x_encode_tuple_header(response, 2); ei_x_encode_string(response, "Internal Error: Failed to encode reply"); - } - else - { + } else { ei_x_encode_empty_list(response); } @@ -635,7 +610,7 @@ int handle_rex_call(cnode_handler_t *phandler,erlang_ref_ex_t *ref, erlang_pid * } /* {'$gen_call', {, #Ref<62147.65.0>}, {call, tbe, dlg_bye, [123, 456], }} for rex */ -int handle_rex_msg(cnode_handler_t *phandler, erlang_msg * msg) +int handle_rex_msg(cnode_handler_t *phandler, erlang_msg *msg) { int version, size, type, arity; char atom[MAXATOMLEN]; @@ -644,52 +619,46 @@ int handle_rex_msg(cnode_handler_t *phandler, erlang_msg * msg) ei_x_buff *request = &phandler->request; ei_x_buff *response = &phandler->response; - memset((void*)&ref,0,sizeof(erlang_ref_ex_t)); + memset((void *)&ref, 0, sizeof(erlang_ref_ex_t)); /* start from first arg */ request->index = 0; ei_decode_version(request->buff, &request->index, &version); ei_get_type(request->buff, &request->index, &type, &size); - if (type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) - { + if(type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) { LM_ERR("not a tuple\n"); return -1; } ei_decode_tuple_header(request->buff, &request->index, &arity); - if (arity != 3) - { + if(arity != 3) { LM_ERR("wrong arity %d\n", arity); return -1; } - if (ei_decode_atom(request->buff, &request->index, atom) || strncmp(atom, - "$gen_call", MAXATOMLEN)) - { + if(ei_decode_atom(request->buff, &request->index, atom) + || strncmp(atom, "$gen_call", MAXATOMLEN)) { LM_ERR("not $gen_call\n"); return -1; } ei_get_type(request->buff, &request->index, &type, &size); - if (type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) - { + if(type != ERL_SMALL_TUPLE_EXT && type != ERL_SMALL_TUPLE_EXT) { LM_ERR("not a tuple\n"); goto err; } ei_decode_tuple_header(request->buff, &request->index, &arity); - if (arity != 2) - { + if(arity != 2) { LM_ERR("wrong arity\n"); goto err; } - if (ei_decode_pid(request->buff, &request->index, &pid) ) - { + if(ei_decode_pid(request->buff, &request->index, &pid)) { LM_ERR("decoding pid error\n"); goto err2; } @@ -697,31 +666,25 @@ int handle_rex_msg(cnode_handler_t *phandler, erlang_msg * msg) ref.with_node = 0; /* we can got with host accompanied {#Ref<18224.110.0>, 'reg-two@pbx.lan'} */ ei_get_type(request->buff, &request->index, &type, &size); - if (type == ERL_REFERENCE_EXT || type == ERL_NEW_REFERENCE_EXT) - { - if (ei_decode_ref(request->buff, &request->index, &ref.ref)) - { + if(type == ERL_REFERENCE_EXT || type == ERL_NEW_REFERENCE_EXT) { + if(ei_decode_ref(request->buff, &request->index, &ref.ref)) { LM_ERR("decoding ref error\n"); goto err2; } - } - else if (type != ERL_SMALL_TUPLE_EXT) - { + } else if(type != ERL_SMALL_TUPLE_EXT) { LM_ERR("not a tuple type {#Ref, 'node@host.tld'} %c\n", type); goto err; - } - else { - if (ei_decode_tuple_header(request->buff, &request->index, &arity) || arity !=2) + } else { + if(ei_decode_tuple_header(request->buff, &request->index, &arity) + || arity != 2) goto err2; - if (ei_decode_ref(request->buff, &request->index, &ref.ref)) - { + if(ei_decode_ref(request->buff, &request->index, &ref.ref)) { LM_ERR("decoding ref error\n"); goto err2; } - if (ei_decode_atom(request->buff, &request->index, ref.nodename)) - { + if(ei_decode_atom(request->buff, &request->index, ref.nodename)) { LM_ERR("decoding node in ref error\n"); goto err2; } @@ -730,23 +693,20 @@ int handle_rex_msg(cnode_handler_t *phandler, erlang_msg * msg) ei_get_type(request->buff, &request->index, &type, &size); - if (type != ERL_SMALL_TUPLE_EXT) - { + if(type != ERL_SMALL_TUPLE_EXT) { LM_ERR("not a tuple\n"); goto err; } ei_decode_tuple_header(request->buff, &request->index, &arity); - if (arity != 5) - { + if(arity != 5) { LM_ERR("bad arity %d\n", arity); goto err; } - if (ei_decode_atom(request->buff, &request->index, atom) == 0 && strncmp(atom, - "call", MAXATOMLEN) == 0) - { + if(ei_decode_atom(request->buff, &request->index, atom) == 0 + && strncmp(atom, "call", MAXATOMLEN) == 0) { return handle_rex_call(phandler, &ref, &pid); } @@ -754,51 +714,49 @@ int handle_rex_msg(cnode_handler_t *phandler, erlang_msg * msg) /* To ! {Tag, Reply} */ ei_x_encode_tuple_header(response, 2); - if (ref.with_node) - { - ei_x_encode_tuple_header(response,2); + if(ref.with_node) { + ei_x_encode_tuple_header(response, 2); ei_x_encode_ref(response, &ref.ref); - ei_x_encode_atom(response,ref.nodename); - } - else { + ei_x_encode_atom(response, ref.nodename); + } else { ei_x_encode_ref(response, &ref.ref); } - ei_x_encode_tuple_header(response,2); + ei_x_encode_tuple_header(response, 2); ei_x_encode_atom(response, "badrpc"); ei_x_encode_string(response, "Unsupported rex request."); ei_x_print_msg(response, &pid, 1); - ei_send_tmo(phandler->sockfd, &pid, response->buff, response->index, CONNECT_TIMEOUT); + ei_send_tmo(phandler->sockfd, &pid, response->buff, response->index, + CONNECT_TIMEOUT); err2: return -1; } -int handle_erlang_msg(cnode_handler_t *phandler, erlang_msg * msg) +int handle_erlang_msg(cnode_handler_t *phandler, erlang_msg *msg) { int type, type2, size, version, arity, tmpindex; int ret = 0; - ei_x_buff * request = &phandler->request; - ei_x_buff * response = &phandler->response; + ei_x_buff *request = &phandler->request; + ei_x_buff *response = &phandler->response; erlang_pid from; - if (msg->msgtype == ERL_REG_SEND ) - { + if(msg->msgtype == ERL_REG_SEND) { cnode_reply_to_pid = &msg->from; - if (!strncmp(msg->toname, "net_kernel",MAXATOMLEN)) { + if(!strncmp(msg->toname, "net_kernel", MAXATOMLEN)) { /* respond to ping stuff */ ret = handle_net_kernel(phandler, msg); - } else if (!strncmp(msg->toname, "rex",MAXATOMLEN)) { + } else if(!strncmp(msg->toname, "rex", MAXATOMLEN)) { /* respond to rex stuff */ ret = handle_rex_msg(phandler, msg); } else { /* try registered process */ - handle_reg_send(phandler,msg); + handle_reg_send(phandler, msg); } - } else if (msg->msgtype == ERL_SEND) { + } else if(msg->msgtype == ERL_SEND) { ret = handle_send(phandler, msg); } else { /* TODO: fix below after adding #Pid and #Ref in PVs */ @@ -806,58 +764,55 @@ int handle_erlang_msg(cnode_handler_t *phandler, erlang_msg * msg) ei_decode_version(request->buff, &request->index, &version); ei_get_type(request->buff, &request->index, &type, &size); - switch (type) - { - case ERL_SMALL_TUPLE_EXT: - case ERL_LARGE_TUPLE_EXT: - tmpindex = request->index; - ei_decode_tuple_header(request->buff, &tmpindex, &arity); - ei_get_type(request->buff, &tmpindex, &type2, &size); - - switch (type2) - { - case ERL_ATOM_EXT: - ret = handle_msg_req_tuple(phandler, msg); - break; - case ERL_REFERENCE_EXT: - case ERL_NEW_REFERENCE_EXT: - ret = handle_req_ref_tuple(phandler, msg); - break; - case ERL_PID_EXT: - if(ei_decode_pid(request->buff,&tmpindex,&from)) { - LM_ERR("failed to decode pid\n"); + switch(type) { + case ERL_SMALL_TUPLE_EXT: + case ERL_LARGE_TUPLE_EXT: + tmpindex = request->index; + ei_decode_tuple_header(request->buff, &tmpindex, &arity); + ei_get_type(request->buff, &tmpindex, &type2, &size); + + switch(type2) { + case ERL_ATOM_EXT: + ret = handle_msg_req_tuple(phandler, msg); + break; + case ERL_REFERENCE_EXT: + case ERL_NEW_REFERENCE_EXT: + ret = handle_req_ref_tuple(phandler, msg); + break; + case ERL_PID_EXT: + if(ei_decode_pid(request->buff, &tmpindex, &from)) { + LM_ERR("failed to decode pid\n"); + } + ret = handle_send(phandler, msg); + break; + default: + LM_ERR("nothing to do with term type=<%d> type2=<%d> " + "-- discarding\n", + type, type2); + break; } - ret = handle_send(phandler, msg); break; default: - LM_ERR("nothing to do with term type=<%d> type2=<%d> -- discarding\n", type, type2); + LM_ERR("not handled term type=<%d> size=<%d> -- discarding\n", + type, size); break; - } - break; - default: - LM_ERR("not handled term type=<%d> size=<%d> -- discarding\n", type, size); - break; } } - if (ret) - { + if(ret) { /* reset pid */ cnode_reply_to_pid = NULL; return ret; - } - else if (response->index > 1 && cnode_reply_to_pid) - { + } else if(response->index > 1 && cnode_reply_to_pid) { ei_x_print_msg(response, cnode_reply_to_pid, 1); - if (ei_send(phandler->sockfd, cnode_reply_to_pid, response->buff, response->index)) - { + if(ei_send(phandler->sockfd, cnode_reply_to_pid, response->buff, + response->index)) { LM_ERR("ei_send failed on node=<%s> socket=<%d>, %s\n", - phandler->ec.thisnodename,phandler->sockfd, strerror(erl_errno)); + phandler->ec.thisnodename, phandler->sockfd, + strerror(erl_errno)); } - } - else - { + } else { LM_DBG("** no reply **\n"); } @@ -866,29 +821,28 @@ int handle_erlang_msg(cnode_handler_t *phandler, erlang_msg * msg) return 0; } -void encode_error_msg(ei_x_buff *response, erlang_ref_ex_t *ref, const char *type, const char *msg, ... ) +void encode_error_msg(ei_x_buff *response, erlang_ref_ex_t *ref, + const char *type, const char *msg, ...) { char buffer[256]; va_list args; - va_start (args, msg); + va_start(args, msg); - vsnprintf (buffer, 255, msg, args); + vsnprintf(buffer, 255, msg, args); - va_end (args); + va_end(args); ei_x_encode_tuple_header(response, 2); - if (ref->with_node) - { - ei_x_encode_tuple_header(response,2); + if(ref->with_node) { + ei_x_encode_tuple_header(response, 2); ei_x_encode_ref(response, &ref->ref); - ei_x_encode_atom(response,ref->nodename); - } - else { + ei_x_encode_atom(response, ref->nodename); + } else { ei_x_encode_ref(response, &ref->ref); } - ei_x_encode_tuple_header(response,2); + ei_x_encode_tuple_header(response, 2); ei_x_encode_atom(response, type); ei_x_encode_string(response, buffer); } diff --git a/src/modules/erlang/handle_emsg.h b/src/modules/erlang/handle_emsg.h index 01dae2d05a8..9b48cdc9484 100644 --- a/src/modules/erlang/handle_emsg.h +++ b/src/modules/erlang/handle_emsg.h @@ -29,6 +29,6 @@ extern int rex_in_progress; -int handle_erlang_msg(cnode_handler_t *handler, erlang_msg * msg); +int handle_erlang_msg(cnode_handler_t *handler, erlang_msg *msg); #endif /* HANDLE_EMSG_H_ */ diff --git a/src/modules/erlang/handle_rpc.c b/src/modules/erlang/handle_rpc.c index 5cf5f109f84..53044c98111 100644 --- a/src/modules/erlang/handle_rpc.c +++ b/src/modules/erlang/handle_rpc.c @@ -33,11 +33,14 @@ /* create empty recycle bin */ static struct erl_rpc_garbage *recycle_bin = 0; -static int get_int(int *int_ptr,erl_rpc_ctx_t *ctx, int reads, int autoconvert); -static int get_double(double *double_prt,erl_rpc_ctx_t *ctx, int reads, int autoconvert); -static int get_str(str *str_ptr, erl_rpc_ctx_t *ctx, int reads, int autoconvert); -static int find_member(erl_rpc_ctx_t *ctx, int arity, const char* member_name); -static int add_to_recycle_bin(int type, void* ptr, erl_rpc_ctx_t *ctx); +static int get_int( + int *int_ptr, erl_rpc_ctx_t *ctx, int reads, int autoconvert); +static int get_double( + double *double_prt, erl_rpc_ctx_t *ctx, int reads, int autoconvert); +static int get_str( + str *str_ptr, erl_rpc_ctx_t *ctx, int reads, int autoconvert); +static int find_member(erl_rpc_ctx_t *ctx, int arity, const char *member_name); +static int add_to_recycle_bin(int type, void *ptr, erl_rpc_ctx_t *ctx); erl_rpc_param_t *erl_new_param(erl_rpc_ctx_t *ctx); void erl_rpc_append_param(erl_rpc_ctx_t *ctx, erl_rpc_param_t *param); @@ -52,80 +55,108 @@ rpc_t erl_rpc_func_param; */ int erl_rpc_send(erl_rpc_ctx_t *ctx, int depth) { - if (ctx->response_sent) return 0; + if(ctx->response_sent) + return 0; ctx->response_sent = 1; erl_rpc_ctx_t *handler; erl_rpc_param_t *fault = *(ctx->fault_p); - if (fault) - { - LM_ERR("fault: %d %.*s\n",fault->type, STR_FMT(&fault->value.S)); + if(fault) { + LM_ERR("fault: %d %.*s\n", fault->type, STR_FMT(&fault->value.S)); /* restore clear point */ ctx->response->index = ctx->response_index; /* {error,{struct,[ {"code", 400}, {"error","Error message"}]}}*/ - if (ei_x_encode_tuple_header(ctx->response,1)) goto error; /* {error,{_,_}} */ - if (rpc_reply_with_struct && ei_x_encode_atom(ctx->response,"struct")) goto error; /* {error,{struct,_}} */ - if (ei_x_encode_list_header(ctx->response,2)) goto error; /* {error,{struct,[_,_]}} */ - if (ei_x_encode_tuple_header(ctx->response,2)) goto error; /* {error,{struct,[{_,_},_]}} */ - if (ei_x_encode_atom(ctx->response,"code")) goto error; /* {error,{struct,[{code,_},_]}} */ - if (ei_x_encode_long(ctx->response,fault->type)) goto error;/* {error,{struct,[{code,400},_]}} */ - if (ei_x_encode_tuple_header(ctx->response,2)) goto error; /* {error,{struct,[{code,400},{_,_}]}} */ - if (ei_x_encode_binary(ctx->response,"error",sizeof("error")-1)) goto error; /* {error,{struct,[{code,400},{<<"error">>,_}]}} */ - if (ei_x_encode_binary(ctx->response,(void*)fault->value.S.s,fault->value.S.len)) /* {error,{struct,[{code,400},{<<"error">>,<>}]}} */ + if(ei_x_encode_tuple_header(ctx->response, 1)) + goto error; /* {error,{_,_}} */ + if(rpc_reply_with_struct && ei_x_encode_atom(ctx->response, "struct")) + goto error; /* {error,{struct,_}} */ + if(ei_x_encode_list_header(ctx->response, 2)) + goto error; /* {error,{struct,[_,_]}} */ + if(ei_x_encode_tuple_header(ctx->response, 2)) + goto error; /* {error,{struct,[{_,_},_]}} */ + if(ei_x_encode_atom(ctx->response, "code")) + goto error; /* {error,{struct,[{code,_},_]}} */ + if(ei_x_encode_long(ctx->response, fault->type)) + goto error; /* {error,{struct,[{code,400},_]}} */ + if(ei_x_encode_tuple_header(ctx->response, 2)) + goto error; /* {error,{struct,[{code,400},{_,_}]}} */ + if(ei_x_encode_binary(ctx->response, "error", sizeof("error") - 1)) + goto error; /* {error,{struct,[{code,400},{<<"error">>,_}]}} */ + if(ei_x_encode_binary(ctx->response, (void *)fault->value.S.s, + fault->value.S + .len)) /* {error,{struct,[{code,400},{<<"error">>,<>}]}} */ goto error; - if (ei_x_encode_empty_list(ctx->response)) goto error; - } - else if (ctx->reply_params) - { - while(ctx->reply_params) - { - if (ctx->reply_params->member_name) - { + if(ei_x_encode_empty_list(ctx->response)) + goto error; + } else if(ctx->reply_params) { + while(ctx->reply_params) { + if(ctx->reply_params->member_name) { /* {"member_name", _} */ - if (ei_x_encode_tuple_header(ctx->response,2)) goto error; - if (ei_x_encode_binary(ctx->response,ctx->reply_params->member_name, strlen(ctx->reply_params->member_name))) + if(ei_x_encode_tuple_header(ctx->response, 2)) + goto error; + if(ei_x_encode_binary(ctx->response, + ctx->reply_params->member_name, + strlen(ctx->reply_params->member_name))) goto error; } /* {"member_name", MemberValue} */ - switch (ctx->reply_params->type) { + switch(ctx->reply_params->type) { case ERL_INTEGER_EXT: - if(ei_x_encode_long(ctx->response,ctx->reply_params->value.n)) goto error; + if(ei_x_encode_long( + ctx->response, ctx->reply_params->value.n)) + goto error; break; case ERL_FLOAT_EXT: - if(ei_x_encode_double(ctx->response,ctx->reply_params->value.d)) goto error; + if(ei_x_encode_double( + ctx->response, ctx->reply_params->value.d)) + goto error; break; case ERL_STRING_EXT: - if(ei_x_encode_binary(ctx->response,ctx->reply_params->value.S.s,ctx->reply_params->value.S.len)) goto error; + if(ei_x_encode_binary(ctx->response, + ctx->reply_params->value.S.s, + ctx->reply_params->value.S.len)) + goto error; break; case ERL_SMALL_TUPLE_EXT: /* add as {struct,list(no_params)} */ - handler = (erl_rpc_ctx_t*)ctx->reply_params->value.handler; - if (ei_x_encode_tuple_header(ctx->response,1)) goto error; - if (rpc_reply_with_struct && ei_x_encode_atom(ctx->response,"struct")) goto error; - if (ei_x_encode_list_header(ctx->response,handler->no_params)) goto error; - if (erl_rpc_send(handler, depth++)) goto error; - if (ei_x_encode_empty_list(ctx->response)) goto error; + handler = (erl_rpc_ctx_t *)ctx->reply_params->value.handler; + if(ei_x_encode_tuple_header(ctx->response, 1)) + goto error; + if(rpc_reply_with_struct + && ei_x_encode_atom(ctx->response, "struct")) + goto error; + if(ei_x_encode_list_header( + ctx->response, handler->no_params)) + goto error; + if(erl_rpc_send(handler, depth++)) + goto error; + if(ei_x_encode_empty_list(ctx->response)) + goto error; break; case ERL_LIST_EXT: /* add as [list(no_params)] */ - handler = (erl_rpc_ctx_t*)ctx->reply_params->value.handler; - if (ei_x_encode_list_header(ctx->response,handler->no_params)) goto error; - if (erl_rpc_send(handler, depth++)) goto error; - if (handler->no_params) - if (ei_x_encode_empty_list(ctx->response)) goto error; + handler = (erl_rpc_ctx_t *)ctx->reply_params->value.handler; + if(ei_x_encode_list_header( + ctx->response, handler->no_params)) + goto error; + if(erl_rpc_send(handler, depth++)) + goto error; + if(handler->no_params) + if(ei_x_encode_empty_list(ctx->response)) + goto error; break; default: - LM_ERR("Unknown type '%c' for encoding RPC reply\n",ctx->reply_params->type); + LM_ERR("Unknown type '%c' for encoding RPC reply\n", + ctx->reply_params->type); break; } - ctx->reply_params=ctx->reply_params->next; + ctx->reply_params = ctx->reply_params->next; } - } - else if (!depth) - { + } else if(!depth) { /* restore start point */ LM_WARN("encode empty response -> ok"); ctx->response->index = ctx->response_index; - if (ei_x_encode_atom(ctx->response,"ok")) goto error; + if(ei_x_encode_atom(ctx->response, "ok")) + goto error; } return 0; @@ -135,7 +166,7 @@ int erl_rpc_send(erl_rpc_ctx_t *ctx, int depth) return -1; } -void erl_rpc_fault(erl_rpc_ctx_t* ctx, int code, char* fmt, ...) +void erl_rpc_fault(erl_rpc_ctx_t *ctx, int code, char *fmt, ...) { static char buf[FAULT_BUF_LEN]; erl_rpc_param_t *fault = *(ctx->fault_p); @@ -143,22 +174,21 @@ void erl_rpc_fault(erl_rpc_ctx_t* ctx, int code, char* fmt, ...) va_list ap; - if (fault) return; + if(fault) + return; va_start(ap, fmt); len = vsnprintf(buf, FAULT_BUF_LEN, fmt, ap); va_end(ap); - fault=(erl_rpc_param_t*)pkg_malloc(sizeof(erl_rpc_param_t)); + fault = (erl_rpc_param_t *)pkg_malloc(sizeof(erl_rpc_param_t)); - if (fault == 0) - { + if(fault == 0) { LM_ERR("Not enough memory\n"); return; } - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)fault,ctx)) - { + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)fault, ctx)) { pkg_free(fault); return; } @@ -169,7 +199,7 @@ void erl_rpc_fault(erl_rpc_ctx_t* ctx, int code, char* fmt, ...) ctx->fault = fault; } -int erl_rpc_add(erl_rpc_ctx_t* ctx, char* fmt, ...) +int erl_rpc_add(erl_rpc_ctx_t *ctx, char *fmt, ...) { void **void_ptr; int int_ptr; @@ -179,132 +209,123 @@ int erl_rpc_add(erl_rpc_ctx_t* ctx, char* fmt, ...) erl_rpc_ctx_t *handler; erl_rpc_param_t *param; - int reads=0; + int reads = 0; va_list ap; - va_start(ap,fmt); + va_start(ap, fmt); - while(*fmt) - { - if ((param = erl_new_param(ctx))==0) - { + while(*fmt) { + if((param = erl_new_param(ctx)) == 0) { goto error; } - switch(*fmt) - { - case 'b': /* Bool */ - case 't': /* Date and time */ - case 'd': /* Integer */ - int_ptr = va_arg(ap, int); - param->type = ERL_INTEGER_EXT; - param->value.n = int_ptr; - break; + switch(*fmt) { + case 'b': /* Bool */ + case 't': /* Date and time */ + case 'd': /* Integer */ + int_ptr = va_arg(ap, int); + param->type = ERL_INTEGER_EXT; + param->value.n = int_ptr; + break; - case 'f': /* double */ - double_ptr = va_arg(ap, double); - param->type = ERL_FLOAT_EXT; - param->value.d = double_ptr; - break; + case 'f': /* double */ + double_ptr = va_arg(ap, double); + param->type = ERL_FLOAT_EXT; + param->value.d = double_ptr; + break; - case 'S': /* str structure */ - str_ptr = va_arg(ap, str*); + case 'S': /* str structure */ + str_ptr = va_arg(ap, str *); - param->type = ERL_STRING_EXT; - param->value.S = *str_ptr; + param->type = ERL_STRING_EXT; + param->value.S = *str_ptr; - break; + break; - case 's':/* zero terminated string */ + case 's': /* zero terminated string */ - char_ptr = va_arg(ap, char *); + char_ptr = va_arg(ap, char *); - param->type = ERL_STRING_EXT; - param->value.S.len = strlen(char_ptr); + param->type = ERL_STRING_EXT; + param->value.S.len = strlen(char_ptr); - param->value.S.s = (char*)pkg_malloc(param->value.S.len+1); + param->value.S.s = (char *)pkg_malloc(param->value.S.len + 1); - if (!param->value.S.s) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!param->value.S.s) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR, param->value.S.s, ctx)) - { - pkg_free(param->value.S.s); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, param->value.S.s, ctx)) { + pkg_free(param->value.S.s); + goto error; + } - memcpy(param->value.S.s,char_ptr,param->value.S.len); + memcpy(param->value.S.s, char_ptr, param->value.S.len); - break; - case '{': - void_ptr = va_arg(ap,void**); + break; + case '{': + void_ptr = va_arg(ap, void **); - handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t)); + handler = (erl_rpc_ctx_t *)pkg_malloc(sizeof(erl_rpc_ctx_t)); - if (!handler) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!handler) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)handler,ctx)) - { - pkg_free(handler); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)handler, ctx)) { + pkg_free(handler); + goto error; + } - *handler = *ctx; - handler->no_params = 0; - handler->reply_params=0; - handler->tail = 0; + *handler = *ctx; + handler->no_params = 0; + handler->reply_params = 0; + handler->tail = 0; - /* go where we stopped */ - *(erl_rpc_ctx_t**)void_ptr = handler; + /* go where we stopped */ + *(erl_rpc_ctx_t **)void_ptr = handler; - param->type = ERL_SMALL_TUPLE_EXT; - param->value.handler = (void*)handler; + param->type = ERL_SMALL_TUPLE_EXT; + param->value.handler = (void *)handler; - break; + break; - case '[': - void_ptr = va_arg(ap,void**); + case '[': + void_ptr = va_arg(ap, void **); - handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t)); + handler = (erl_rpc_ctx_t *)pkg_malloc(sizeof(erl_rpc_ctx_t)); - if (!handler) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!handler) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)handler,ctx)) - { - pkg_free(handler); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)handler, ctx)) { + pkg_free(handler); + goto error; + } - *handler = *ctx; - handler->no_params = 0; - handler->reply_params=0; - handler->tail = 0; + *handler = *ctx; + handler->no_params = 0; + handler->reply_params = 0; + handler->tail = 0; - /* go where we stopped */ - *(erl_rpc_ctx_t**)void_ptr = handler; + /* go where we stopped */ + *(erl_rpc_ctx_t **)void_ptr = handler; - param->type = ERL_LIST_EXT; - param->value.handler = (void*)handler; + param->type = ERL_LIST_EXT; + param->value.handler = (void *)handler; - break; - default: - LM_ERR("Invalid type '%c' in formatting string\n", *fmt); - goto error; + break; + default: + LM_ERR("Invalid type '%c' in formatting string\n", *fmt); + goto error; } - erl_rpc_append_param(ctx,param); + erl_rpc_append_param(ctx, param); reads++; fmt++; @@ -313,145 +334,138 @@ int erl_rpc_add(erl_rpc_ctx_t* ctx, char* fmt, ...) return reads; error: - LM_ERR("Failed to encode parameter #%d into response.\n",reads); + LM_ERR("Failed to encode parameter #%d into response.\n", reads); va_end(ap); return -reads; } -int erl_rpc_scan(erl_rpc_ctx_t* ctx, char* fmt, ...) +int erl_rpc_scan(erl_rpc_ctx_t *ctx, char *fmt, ...) { - int* int_ptr; - char** char_ptr; - str* str_ptr; - double* double_ptr; - void** void_ptr; + int *int_ptr; + char **char_ptr; + str *str_ptr; + double *double_ptr; + void **void_ptr; str s; /* helper str */ int reads = 0; int modifiers = 0; int autoconv = 0; - int type,size; + int type, size; erl_rpc_ctx_t *handler; va_list ap; - va_start(ap,fmt); + va_start(ap, fmt); - while(*fmt && ctx->size) - { + while(*fmt && ctx->size) { /* optional and we at the end of decoding params */ - if (ctx->optional && !ctx->size) - { + if(ctx->optional && !ctx->size) { break; } - if (ei_get_type(ctx->request->buff,&ctx->request_index,&type,&size)) - { - erl_rpc_fault(ctx,400,"Can't determine data type, for parameter #%d",reads); - LM_ERR("Can't determine data type, for parameter #%d",reads); + if(ei_get_type(ctx->request->buff, &ctx->request_index, &type, &size)) { + erl_rpc_fault(ctx, 400, + "Can't determine data type, for parameter #%d", reads); + LM_ERR("Can't determine data type, for parameter #%d", reads); goto error; } - switch(*fmt) - { - case '*': /* start of optional parameters */ - modifiers++; - ctx->optional = 1; - reads++; - fmt++; - continue; - case '.': /* autoconvert */ - modifiers++; - autoconv = 1; - reads++; - fmt++; - continue; - case 'b': /* Bool */ - case 't': /* Date and time */ - case 'd': /* Integer */ - int_ptr = va_arg(ap, int*); - - if (get_int(int_ptr,ctx,reads,autoconv)) - { - goto error; - } + switch(*fmt) { + case '*': /* start of optional parameters */ + modifiers++; + ctx->optional = 1; + reads++; + fmt++; + continue; + case '.': /* autoconvert */ + modifiers++; + autoconv = 1; + reads++; + fmt++; + continue; + case 'b': /* Bool */ + case 't': /* Date and time */ + case 'd': /* Integer */ + int_ptr = va_arg(ap, int *); + + if(get_int(int_ptr, ctx, reads, autoconv)) { + goto error; + } - break; - case 'f': /* double */ - double_ptr = va_arg(ap, double*); + break; + case 'f': /* double */ + double_ptr = va_arg(ap, double *); - if (get_double(double_ptr,ctx,reads,autoconv)) - { - goto error; - } + if(get_double(double_ptr, ctx, reads, autoconv)) { + goto error; + } - break; - case 'S': /* str structure */ + break; + case 'S': /* str structure */ - str_ptr = va_arg(ap, str*); + str_ptr = va_arg(ap, str *); - if (get_str(str_ptr,ctx,reads,autoconv)) - { - goto error; - } + if(get_str(str_ptr, ctx, reads, autoconv)) { + goto error; + } - break; - case 's':/* zero terminated string */ + break; + case 's': /* zero terminated string */ - char_ptr = va_arg(ap, char **); - if (get_str(&s,ctx,reads,autoconv)) - { - goto error; - } + char_ptr = va_arg(ap, char **); + if(get_str(&s, ctx, reads, autoconv)) { + goto error; + } - *char_ptr = s.s; + *char_ptr = s.s; - break; - case '{': - void_ptr = va_arg(ap,void**); + break; + case '{': + void_ptr = va_arg(ap, void **); - if (type!=ERL_SMALL_TUPLE_EXT && type!=ERL_LARGE_TUPLE_EXT) - { - erl_rpc_fault(ctx,400,"Bad type of parameter #%d (t=%c).",reads,type); - goto error; - } + if(type != ERL_SMALL_TUPLE_EXT && type != ERL_LARGE_TUPLE_EXT) { + erl_rpc_fault(ctx, 400, "Bad type of parameter #%d (t=%c).", + reads, type); + goto error; + } - handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t)); + handler = (erl_rpc_ctx_t *)pkg_malloc(sizeof(erl_rpc_ctx_t)); - if (!handler) - { - erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)"); - LM_ERR("Not enough memory\n"); - goto error; - } + if(!handler) { + erl_rpc_fault( + ctx, 500, "Internal Server Error (No memory left)"); + LM_ERR("Not enough memory\n"); + goto error; + } - *handler = *ctx; /* copy state */ - handler->optional = 0; - handler->no_params = 0; - handler->size = size; /* size of tuple */ + *handler = *ctx; /* copy state */ + handler->optional = 0; + handler->no_params = 0; + handler->size = size; /* size of tuple */ - if (add_to_recycle_bin(JUNK_PKGCHAR,handler,ctx)) - { - pkg_free(handler); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, handler, ctx)) { + pkg_free(handler); + goto error; + } - /* skip element */ - if (ei_skip_term(ctx->request->buff,&ctx->request_index)) - { - goto error; - } + /* skip element */ + if(ei_skip_term(ctx->request->buff, &ctx->request_index)) { + goto error; + } - /* go where we stopped */ - *(erl_rpc_ctx_t**)void_ptr = handler; + /* go where we stopped */ + *(erl_rpc_ctx_t **)void_ptr = handler; - break; - default: - LM_ERR("Invalid parameter type in formatting string: %c\n", *fmt); - erl_rpc_fault(ctx, 500, "Server Internal Error (Invalid Formatting String)"); - goto error; + break; + default: + LM_ERR("Invalid parameter type in formatting string: %c\n", + *fmt); + erl_rpc_fault(ctx, 500, + "Server Internal Error (Invalid Formatting String)"); + goto error; } autoconv = 0; /* reset autovoncersion for next parameter */ @@ -459,22 +473,21 @@ int erl_rpc_scan(erl_rpc_ctx_t* ctx, char* fmt, ...) fmt++; ctx->size--; } - va_end(ap); - return reads-modifiers; + va_end(ap); + return reads - modifiers; error: - va_end(ap); - return -(reads-modifiers); - + va_end(ap); + return -(reads - modifiers); } -int erl_rpc_struct_scan(erl_rpc_ctx_t* ctx, char* fmt, ...) +int erl_rpc_struct_scan(erl_rpc_ctx_t *ctx, char *fmt, ...) { - int* int_ptr; - char** char_ptr; - str* str_ptr; - double* double_ptr; - char* member_name; + int *int_ptr; + char **char_ptr; + str *str_ptr; + double *double_ptr; + char *member_name; str s; /* helper str */ int reads = 0; @@ -489,84 +502,78 @@ int erl_rpc_struct_scan(erl_rpc_ctx_t* ctx, char* fmt, ...) /* preserve index */ index = ctx->request_index; - if(ei_decode_tuple_header(ctx->request->buff,&index, &arity)) - { - erl_rpc_fault(ctx,400,"Bad tuple"); + if(ei_decode_tuple_header(ctx->request->buff, &index, &arity)) { + erl_rpc_fault(ctx, 400, "Bad tuple"); return -1; } - va_start(ap,fmt); + va_start(ap, fmt); - while(*fmt) - { - member_name = va_arg(ap, char*); + while(*fmt) { + member_name = va_arg(ap, char *); - if (find_member(ctx,arity,member_name)) - { + if(find_member(ctx, arity, member_name)) { goto error; } - switch(*fmt) - { - case 'b': /* Bool */ - case 't': /* Date and time */ - case 'd': /* Integer */ - int_ptr = va_arg(ap, int*); + switch(*fmt) { + case 'b': /* Bool */ + case 't': /* Date and time */ + case 'd': /* Integer */ + int_ptr = va_arg(ap, int *); - if (get_int(int_ptr,ctx,reads,autoconv)) - { - goto error; - } + if(get_int(int_ptr, ctx, reads, autoconv)) { + goto error; + } - break; - case 'f': /* double */ - double_ptr = va_arg(ap, double*); + break; + case 'f': /* double */ + double_ptr = va_arg(ap, double *); - if (get_double(double_ptr,ctx,reads,autoconv)) - { - goto error; - } + if(get_double(double_ptr, ctx, reads, autoconv)) { + goto error; + } - break; - case 'S': /* str structure */ + break; + case 'S': /* str structure */ - str_ptr = va_arg(ap, str*); + str_ptr = va_arg(ap, str *); - if (get_str(str_ptr,ctx,reads,autoconv)) - { - goto error; - } + if(get_str(str_ptr, ctx, reads, autoconv)) { + goto error; + } - break; - case 's':/* zero terminated string */ + break; + case 's': /* zero terminated string */ - char_ptr = va_arg(ap,char**); + char_ptr = va_arg(ap, char **); - if (get_str(&s,ctx,reads,autoconv)) - { - goto error; - } + if(get_str(&s, ctx, reads, autoconv)) { + goto error; + } - *char_ptr = s.s; + *char_ptr = s.s; - break; + break; - default: - LM_ERR("Invalid parameter type in formatting string: %c\n", *fmt); - erl_rpc_fault(ctx, 500, "Server Internal Error (Invalid Formatting String)"); - goto error; + default: + LM_ERR("Invalid parameter type in formatting string: %c\n", + *fmt); + erl_rpc_fault(ctx, 500, + "Server Internal Error (Invalid Formatting String)"); + goto error; } reads++; fmt++; } - va_end(ap); - return reads-modifiers; + va_end(ap); + return reads - modifiers; error: - va_end(ap); - return -(reads-modifiers); + va_end(ap); + return -(reads - modifiers); } #define RPC_BUF_SIZE 1024 @@ -574,44 +581,37 @@ int erl_rpc_struct_scan(erl_rpc_ctx_t* ctx, char* fmt, ...) /* * adds formatted string into RPC response buffer as Erlang string/list */ -int erl_rpc_printf(erl_rpc_ctx_t* ctx, char* fmt, ...) +int erl_rpc_printf(erl_rpc_ctx_t *ctx, char *fmt, ...) { int n, buff_size; char *buff = 0; va_list ap; erl_rpc_param_t *param; - buff = (char*)pkg_malloc(RPC_BUF_SIZE); - if (!buff) { - erl_rpc_fault(ctx, 500, "Internal Server Error (No memory left)"); - ERR("No memory left\n"); - return -1; + buff = (char *)pkg_malloc(RPC_BUF_SIZE); + if(!buff) { + erl_rpc_fault(ctx, 500, "Internal Server Error (No memory left)"); + ERR("No memory left\n"); + return -1; } buff_size = RPC_BUF_SIZE; - while(1) - { + while(1) { /* Try to print in the allocated space. */ va_start(ap, fmt); n = vsnprintf(buff, buff_size, fmt, ap); va_end(ap); - /* If that worked, return the string. */ - if (n > -1 && n < buff_size) - { - if(add_to_recycle_bin(JUNK_PKGCHAR,(void*)buff,ctx)) - { + /* If that worked, return the string. */ + if(n > -1 && n < buff_size) { + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)buff, ctx)) { goto error; - } - else if ((param = erl_new_param(ctx))) - { + } else if((param = erl_new_param(ctx))) { param->type = ERL_STRING_EXT; param->value.S.s = buff; param->value.S.len = n; - erl_rpc_append_param(ctx,param); - } - else - { + erl_rpc_append_param(ctx, param); + } else { goto error; } @@ -619,16 +619,12 @@ int erl_rpc_printf(erl_rpc_ctx_t* ctx, char* fmt, ...) } /* Else try again with more space. */ - if (n > -1) - { /* glibc 2.1 */ + if(n > -1) { /* glibc 2.1 */ buff_size = n + 1; /* precisely what is needed */ + } else { /* glibc 2.0 */ + buff_size *= 2; /* twice the old size */ } - else - { /* glibc 2.0 */ - buff_size *= 2; /* twice the old size */ - } - if ((buff = pkg_realloc(buff, buff_size)) == 0) - { + if((buff = pkg_realloc(buff, buff_size)) == 0) { erl_rpc_fault(ctx, 500, "Internal Server Error (No memory left)"); ERR("No memory left\n"); goto error; @@ -638,11 +634,12 @@ int erl_rpc_printf(erl_rpc_ctx_t* ctx, char* fmt, ...) return 0; error: - if(buff) pkg_free(buff); + if(buff) + pkg_free(buff); return -1; } -int erl_rpc_struct_add(erl_rpc_ctx_t* ctx, char* fmt, ...) +int erl_rpc_struct_add(erl_rpc_ctx_t *ctx, char *fmt, ...) { void **void_ptr; char *char_ptr; @@ -650,133 +647,125 @@ int erl_rpc_struct_add(erl_rpc_ctx_t* ctx, char* fmt, ...) erl_rpc_ctx_t *handler; erl_rpc_param_t *param; - int reads=0; + int reads = 0; va_list ap; - va_start(ap,fmt); + va_start(ap, fmt); - while(*fmt) - { - if ((param = erl_new_param(ctx))==0) - { + while(*fmt) { + if((param = erl_new_param(ctx)) == 0) { goto error; } - param->member_name = va_arg(ap, char*); + param->member_name = va_arg(ap, char *); - switch(*fmt) - { - case 'b': /* Bool */ - case 't': /* Date and time */ - case 'd': /* Integer */ - param->type = ERL_INTEGER_EXT; - param->value.n = va_arg(ap, int);; - break; + switch(*fmt) { + case 'b': /* Bool */ + case 't': /* Date and time */ + case 'd': /* Integer */ + param->type = ERL_INTEGER_EXT; + param->value.n = va_arg(ap, int); + ; + break; - case 'f': /* double */ - param->type = ERL_FLOAT_EXT; - param->value.d = va_arg(ap, double); - break; + case 'f': /* double */ + param->type = ERL_FLOAT_EXT; + param->value.d = va_arg(ap, double); + break; - case 'S': /* str structure */ - str_ptr = va_arg(ap, str*); + case 'S': /* str structure */ + str_ptr = va_arg(ap, str *); - param->type = ERL_STRING_EXT; - param->value.S = *str_ptr; - break; + param->type = ERL_STRING_EXT; + param->value.S = *str_ptr; + break; - case 's':/* zero terminated string */ + case 's': /* zero terminated string */ - char_ptr = va_arg(ap, char *); + char_ptr = va_arg(ap, char *); - param->type = ERL_STRING_EXT; - param->value.S.len = strlen(char_ptr); + param->type = ERL_STRING_EXT; + param->value.S.len = strlen(char_ptr); - param->value.S.s = (char*)pkg_malloc(param->value.S.len+1); + param->value.S.s = (char *)pkg_malloc(param->value.S.len + 1); - if (!param->value.S.s) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!param->value.S.s) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR, param->value.S.s, ctx)) - { - pkg_free(param->value.S.s); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, param->value.S.s, ctx)) { + pkg_free(param->value.S.s); + goto error; + } - memcpy(param->value.S.s,char_ptr,param->value.S.len); + memcpy(param->value.S.s, char_ptr, param->value.S.len); - break; + break; - case '{': - void_ptr = va_arg(ap,void**); + case '{': + void_ptr = va_arg(ap, void **); - handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t)); + handler = (erl_rpc_ctx_t *)pkg_malloc(sizeof(erl_rpc_ctx_t)); - if (!handler) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!handler) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)handler,ctx)) - { - pkg_free(handler); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)handler, ctx)) { + pkg_free(handler); + goto error; + } - *handler = *ctx; - handler->no_params = 0; - handler->reply_params=0; - handler->tail = 0; + *handler = *ctx; + handler->no_params = 0; + handler->reply_params = 0; + handler->tail = 0; - /* go where we stopped */ - *(erl_rpc_ctx_t**)void_ptr = handler; + /* go where we stopped */ + *(erl_rpc_ctx_t **)void_ptr = handler; - param->type = ERL_SMALL_TUPLE_EXT; - param->value.handler = (void*)handler; + param->type = ERL_SMALL_TUPLE_EXT; + param->value.handler = (void *)handler; - break; + break; - case '[': - void_ptr = va_arg(ap,void**); + case '[': + void_ptr = va_arg(ap, void **); - handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t)); + handler = (erl_rpc_ctx_t *)pkg_malloc(sizeof(erl_rpc_ctx_t)); - if (!handler) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!handler) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)handler,ctx)) - { - pkg_free(handler); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)handler, ctx)) { + pkg_free(handler); + goto error; + } - *handler = *ctx; - handler->no_params = 0; - handler->reply_params=0; - handler->tail = 0; + *handler = *ctx; + handler->no_params = 0; + handler->reply_params = 0; + handler->tail = 0; - /* go where we stopped */ - *(erl_rpc_ctx_t**)void_ptr = handler; + /* go where we stopped */ + *(erl_rpc_ctx_t **)void_ptr = handler; - param->type = ERL_LIST_EXT; - param->value.handler = (void*)handler; + param->type = ERL_LIST_EXT; + param->value.handler = (void *)handler; - break; + break; - default: - LM_ERR("Invalid type '%c' in formatting string\n", *fmt); - goto error; + default: + LM_ERR("Invalid type '%c' in formatting string\n", *fmt); + goto error; } - erl_rpc_append_param(ctx,param); + erl_rpc_append_param(ctx, param); reads++; fmt++; @@ -786,12 +775,12 @@ int erl_rpc_struct_add(erl_rpc_ctx_t* ctx, char* fmt, ...) error: - LM_ERR("Failed to encode parameter #%d into response.\n",reads); + LM_ERR("Failed to encode parameter #%d into response.\n", reads); va_end(ap); return -reads; } -int erl_rpc_array_add(erl_rpc_ctx_t* ctx, char* fmt, ...) +int erl_rpc_array_add(erl_rpc_ctx_t *ctx, char *fmt, ...) { void **void_ptr; char *char_ptr; @@ -799,135 +788,127 @@ int erl_rpc_array_add(erl_rpc_ctx_t* ctx, char* fmt, ...) erl_rpc_ctx_t *handler; erl_rpc_param_t *param; - int reads=0; + int reads = 0; va_list ap; - va_start(ap,fmt); + va_start(ap, fmt); - LM_DBG("ctx=%p add fmt=<%s>\n",(void*)ctx,fmt); + LM_DBG("ctx=%p add fmt=<%s>\n", (void *)ctx, fmt); - while(*fmt) - { - if ((param = erl_new_param(ctx))==0) - { + while(*fmt) { + if((param = erl_new_param(ctx)) == 0) { goto error; } param->member_name = NULL; - switch(*fmt) - { - case 'b': /* Bool */ - case 't': /* Date and time */ - case 'd': /* Integer */ - param->type = ERL_INTEGER_EXT; - param->value.n = va_arg(ap, int);; - break; + switch(*fmt) { + case 'b': /* Bool */ + case 't': /* Date and time */ + case 'd': /* Integer */ + param->type = ERL_INTEGER_EXT; + param->value.n = va_arg(ap, int); + ; + break; - case 'f': /* double */ - param->type = ERL_FLOAT_EXT; - param->value.d = va_arg(ap, double); - break; + case 'f': /* double */ + param->type = ERL_FLOAT_EXT; + param->value.d = va_arg(ap, double); + break; - case 'S': /* str structure */ - str_ptr = va_arg(ap, str*); + case 'S': /* str structure */ + str_ptr = va_arg(ap, str *); - param->type = ERL_STRING_EXT; - param->value.S = *str_ptr; - break; + param->type = ERL_STRING_EXT; + param->value.S = *str_ptr; + break; - case 's':/* zero terminated string */ + case 's': /* zero terminated string */ - char_ptr = va_arg(ap, char *); + char_ptr = va_arg(ap, char *); - param->type = ERL_STRING_EXT; - param->value.S.len = strlen(char_ptr); + param->type = ERL_STRING_EXT; + param->value.S.len = strlen(char_ptr); - param->value.S.s = (char*)pkg_malloc(param->value.S.len+1); + param->value.S.s = (char *)pkg_malloc(param->value.S.len + 1); - if (!param->value.S.s) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!param->value.S.s) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR, param->value.S.s, ctx)) - { - pkg_free(param->value.S.s); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, param->value.S.s, ctx)) { + pkg_free(param->value.S.s); + goto error; + } - memcpy(param->value.S.s,char_ptr,param->value.S.len); + memcpy(param->value.S.s, char_ptr, param->value.S.len); - break; + break; - case '{': - void_ptr = va_arg(ap,void**); + case '{': + void_ptr = va_arg(ap, void **); - handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t)); + handler = (erl_rpc_ctx_t *)pkg_malloc(sizeof(erl_rpc_ctx_t)); - if (!handler) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!handler) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)handler,ctx)) - { - pkg_free(handler); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)handler, ctx)) { + pkg_free(handler); + goto error; + } - *handler = *ctx; - handler->no_params = 0; - handler->reply_params=0; - handler->tail = 0; + *handler = *ctx; + handler->no_params = 0; + handler->reply_params = 0; + handler->tail = 0; - /* go where we stopped */ - *(erl_rpc_ctx_t**)void_ptr = handler; + /* go where we stopped */ + *(erl_rpc_ctx_t **)void_ptr = handler; - param->type = ERL_SMALL_TUPLE_EXT; - param->value.handler = (void*)handler; + param->type = ERL_SMALL_TUPLE_EXT; + param->value.handler = (void *)handler; - break; + break; - case '[': - void_ptr = va_arg(ap,void**); + case '[': + void_ptr = va_arg(ap, void **); - handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t)); + handler = (erl_rpc_ctx_t *)pkg_malloc(sizeof(erl_rpc_ctx_t)); - if (!handler) - { - LM_ERR("Not enough memory\n"); - goto error; - } + if(!handler) { + LM_ERR("Not enough memory\n"); + goto error; + } - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)handler,ctx)) - { - pkg_free(handler); - goto error; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)handler, ctx)) { + pkg_free(handler); + goto error; + } - *handler = *ctx; - handler->no_params = 0; - handler->reply_params=0; - handler->tail = 0; + *handler = *ctx; + handler->no_params = 0; + handler->reply_params = 0; + handler->tail = 0; - /* go where we stopped */ - *(erl_rpc_ctx_t**)void_ptr = handler; + /* go where we stopped */ + *(erl_rpc_ctx_t **)void_ptr = handler; - param->type = ERL_LIST_EXT; - param->value.handler = (void*)handler; + param->type = ERL_LIST_EXT; + param->value.handler = (void *)handler; - break; + break; - default: - LM_ERR("Invalid type '%c' in formatting string\n", *fmt); - goto error; + default: + LM_ERR("Invalid type '%c' in formatting string\n", *fmt); + goto error; } - erl_rpc_append_param(ctx,param); + erl_rpc_append_param(ctx, param); reads++; fmt++; @@ -937,52 +918,45 @@ int erl_rpc_array_add(erl_rpc_ctx_t* ctx, char* fmt, ...) error: - LM_ERR("Failed to encode parameter #%d into response.\n",reads); + LM_ERR("Failed to encode parameter #%d into response.\n", reads); va_end(ap); return -reads; } -int erl_rpc_struct_printf(erl_rpc_ctx_t* ctx, char* name, char* fmt, ...) +int erl_rpc_struct_printf(erl_rpc_ctx_t *ctx, char *name, char *fmt, ...) { int n, buff_size; char *buff; va_list ap; erl_rpc_param_t *param; - LM_ERR("parsing name:%s fmt: %s\n",name, fmt); + LM_ERR("parsing name:%s fmt: %s\n", name, fmt); - buff = (char*)pkg_malloc(RPC_BUF_SIZE); - if (!buff) { - ERR("No memory left\n"); - return -1; + buff = (char *)pkg_malloc(RPC_BUF_SIZE); + if(!buff) { + ERR("No memory left\n"); + return -1; } buff_size = RPC_BUF_SIZE; - while(1) - { + while(1) { /* Try to print in the allocated space. */ va_start(ap, fmt); n = vsnprintf(buff, buff_size, fmt, ap); va_end(ap); - /* If that worked, return the string. */ - if (n > -1 && n < buff_size) - { + /* If that worked, return the string. */ + if(n > -1 && n < buff_size) { - if(add_to_recycle_bin(JUNK_PKGCHAR,(void*)buff,ctx)) - { + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)buff, ctx)) { goto error; - } - else if ((param = erl_new_param(ctx))) - { + } else if((param = erl_new_param(ctx))) { param->type = ERL_STRING_EXT; param->value.S.s = buff; param->value.S.len = n; param->member_name = name; - erl_rpc_append_param(ctx,param); - } - else - { + erl_rpc_append_param(ctx, param); + } else { goto error; } @@ -990,16 +964,12 @@ int erl_rpc_struct_printf(erl_rpc_ctx_t* ctx, char* name, char* fmt, ...) } /* Else try again with more space. */ - if (n > -1) - { /* glibc 2.1 */ + if(n > -1) { /* glibc 2.1 */ buff_size = n + 1; /* precisely what is needed */ + } else { /* glibc 2.0 */ + buff_size *= 2; /* twice the old size */ } - else - { /* glibc 2.0 */ - buff_size *= 2; /* twice the old size */ - } - if ((buff = pkg_realloc(buff, buff_size)) == 0) - { + if((buff = pkg_realloc(buff, buff_size)) == 0) { ERR("No memory left\n"); goto error; } @@ -1008,11 +978,12 @@ int erl_rpc_struct_printf(erl_rpc_ctx_t* ctx, char* name, char* fmt, ...) return 0; error: - if(buff) pkg_free(buff); + if(buff) + pkg_free(buff); return -1; } -int erl_rpc_capabilities(erl_rpc_ctx_t* ctx) +int erl_rpc_capabilities(erl_rpc_ctx_t *ctx) { return 0; /* no RPC_DELAYED_REPLY */ } @@ -1030,12 +1001,11 @@ static int add_to_recycle_bin(int type, void *ptr, erl_rpc_ctx_t *ctx) { struct erl_rpc_garbage *p; - p = (struct erl_rpc_garbage*)pkg_malloc(sizeof(struct erl_rpc_garbage)); + p = (struct erl_rpc_garbage *)pkg_malloc(sizeof(struct erl_rpc_garbage)); - if (!p) - { - LM_ERR("Not enough memory\n"); - return -1; + if(!p) { + LM_ERR("Not enough memory\n"); + return -1; } p->type = type; @@ -1050,45 +1020,41 @@ static int add_to_recycle_bin(int type, void *ptr, erl_rpc_ctx_t *ctx) */ void empty_recycle_bin(void) { - struct erl_rpc_garbage* p; - /* Collect garbage */ - while(recycle_bin) - { - p = recycle_bin; - recycle_bin = recycle_bin->next; - switch(p->type) - { - case JUNK_EI_X_BUFF: - - if (p->ptr) - { - ei_x_free((ei_x_buff*)p->ptr); - pkg_free(p->ptr); - } + struct erl_rpc_garbage *p; + /* Collect garbage */ + while(recycle_bin) { + p = recycle_bin; + recycle_bin = recycle_bin->next; + switch(p->type) { + case JUNK_EI_X_BUFF: - break; + if(p->ptr) { + ei_x_free((ei_x_buff *)p->ptr); + pkg_free(p->ptr); + } - case JUNK_PKGCHAR: + break; - if (p->ptr) - { - pkg_free(p->ptr); - } + case JUNK_PKGCHAR: - break; + if(p->ptr) { + pkg_free(p->ptr); + } + + break; - default: - ERR("BUG: Unsupported junk type\n"); - } + default: + ERR("BUG: Unsupported junk type\n"); + } - pkg_free(p); - } + pkg_free(p); + } } /* * Get int parameter */ -static int get_int(int *int_ptr,erl_rpc_ctx_t *ctx, int reads, int autoconvert) +static int get_int(int *int_ptr, erl_rpc_ctx_t *ctx, int reads, int autoconvert) { int type, size; char *p; @@ -1096,166 +1062,170 @@ static int get_int(int *int_ptr,erl_rpc_ctx_t *ctx, int reads, int autoconvert) double d; long l; - if (ei_get_type(ctx->request->buff,&ctx->request_index,&type,&size)) - { - if(ctx->optional) return 0; + if(ei_get_type(ctx->request->buff, &ctx->request_index, &type, &size)) { + if(ctx->optional) + return 0; - erl_rpc_fault(ctx,400,"Can't determine data type of parameter #%d",reads); + erl_rpc_fault( + ctx, 400, "Can't determine data type of parameter #%d", reads); return -1; } - switch(type) - { - case ERL_SMALL_INTEGER_EXT: - case ERL_INTEGER_EXT: - if(ei_decode_long(ctx->request->buff, &ctx->request_index, &l)) - { - erl_rpc_fault(ctx,400,"Bad value of parameter #%d.",reads); - return -1; - } - *int_ptr = (int)l; + switch(type) { + case ERL_SMALL_INTEGER_EXT: + case ERL_INTEGER_EXT: + if(ei_decode_long(ctx->request->buff, &ctx->request_index, &l)) { + erl_rpc_fault(ctx, 400, "Bad value of parameter #%d.", reads); + return -1; + } + *int_ptr = (int)l; - break; - case ERL_STRING_EXT: - case ERL_LIST_EXT: + break; + case ERL_STRING_EXT: + case ERL_LIST_EXT: - if (autoconvert == 0) - { - erl_rpc_fault(ctx,400,"Bad type of parameter #%d",reads); - return -1; - } + if(autoconvert == 0) { + erl_rpc_fault(ctx, 400, "Bad type of parameter #%d", reads); + return -1; + } - /* allocate buffer */ - p = (char*)pkg_malloc(size+1); + /* allocate buffer */ + p = (char *)pkg_malloc(size + 1); - if (!p) - { - erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)"); - LM_ERR("Not enough memory\n"); - return -1; - } + if(!p) { + erl_rpc_fault( + ctx, 500, "Internal Server Error (No memory left)"); + LM_ERR("Not enough memory\n"); + return -1; + } - ei_decode_string(ctx->request->buff, &ctx->request_index, p); + ei_decode_string(ctx->request->buff, &ctx->request_index, p); - *int_ptr = strtol(p,&endptr,10); - if (p == endptr) - { - erl_rpc_fault(ctx,400,"Unable to convert %s into integer for parameter at position %d",p,reads); - pkg_free(p); - return -1; - } + *int_ptr = strtol(p, &endptr, 10); + if(p == endptr) { + erl_rpc_fault(ctx, 400, + "Unable to convert %s into integer for parameter at " + "position %d", + p, reads); + pkg_free(p); + return -1; + } - pkg_free(p); - break; + pkg_free(p); + break; - case ERL_FLOAT_EXT: + case ERL_FLOAT_EXT: - if (autoconvert == 0) - { - erl_rpc_fault(ctx,400,"Bad type of parameter #%d",reads); - return -1; - } + if(autoconvert == 0) { + erl_rpc_fault(ctx, 400, "Bad type of parameter #%d", reads); + return -1; + } - if (ei_decode_double(ctx->request->buff,&ctx->request_index,&d)) - { - erl_rpc_fault(ctx,400, "Can't read parameter #%d",reads); - return -1; - } + if(ei_decode_double(ctx->request->buff, &ctx->request_index, &d)) { + erl_rpc_fault(ctx, 400, "Can't read parameter #%d", reads); + return -1; + } - *int_ptr=(int)d; - break; + *int_ptr = (int)d; + break; - default: - LM_ERR("Unsupported type ('%c') for conversion into integer parameter #%d.\n",type,reads); - erl_rpc_fault(ctx,400,"Unsupported type ('%c') for conversion into integer parameter #%d.",type,reads); - return -1; + default: + LM_ERR("Unsupported type ('%c') for conversion into integer " + "parameter #%d.\n", + type, reads); + erl_rpc_fault(ctx, 400, + "Unsupported type ('%c') for conversion into integer " + "parameter #%d.", + type, reads); + return -1; } return 0; } -static int get_double(double *double_prt,erl_rpc_ctx_t *ctx, int reads, int autoconvert) +static int get_double( + double *double_prt, erl_rpc_ctx_t *ctx, int reads, int autoconvert) { int type, size; char *p; char *endptr; long n; - if (ei_get_type(ctx->request->buff,&ctx->request_index,&type,&size)){ - erl_rpc_fault(ctx,400,"Can't determine data type of parameter #%d",reads); + if(ei_get_type(ctx->request->buff, &ctx->request_index, &type, &size)) { + erl_rpc_fault( + ctx, 400, "Can't determine data type of parameter #%d", reads); return -1; } - switch(type) - { - case ERL_FLOAT_EXT: + switch(type) { + case ERL_FLOAT_EXT: - if (ei_decode_double(ctx->request->buff,&ctx->request_index,double_prt)) - { - erl_rpc_fault(ctx,400, "Bad value of parameter #%d.",reads); - return -1; - } + if(ei_decode_double( + ctx->request->buff, &ctx->request_index, double_prt)) { + erl_rpc_fault(ctx, 400, "Bad value of parameter #%d.", reads); + return -1; + } - break; - case ERL_STRING_EXT: - case ERL_LIST_EXT: + break; + case ERL_STRING_EXT: + case ERL_LIST_EXT: - if (autoconvert == 0) - { - erl_rpc_fault(ctx,400,"Bad type of parameter #%d",reads); - return -1; - } + if(autoconvert == 0) { + erl_rpc_fault(ctx, 400, "Bad type of parameter #%d", reads); + return -1; + } - /* allocate buffer */ - p = (char*)pkg_malloc(size+1); + /* allocate buffer */ + p = (char *)pkg_malloc(size + 1); - if (!p) - { - erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)"); - LM_ERR("Not enough memory\n"); - return -1; - } + if(!p) { + erl_rpc_fault( + ctx, 500, "Internal Server Error (No memory left)"); + LM_ERR("Not enough memory\n"); + return -1; + } - ei_decode_string(ctx->request->buff, &ctx->request_index, p); + ei_decode_string(ctx->request->buff, &ctx->request_index, p); - *double_prt = strtod(p,&endptr); - if (p == endptr) - { - erl_rpc_fault(ctx,400,"Unable to convert %s into double, parameter at position #%d",p,reads); - pkg_free(p); - return -1; - } + *double_prt = strtod(p, &endptr); + if(p == endptr) { + erl_rpc_fault(ctx, 400, + "Unable to convert %s into double, parameter at " + "position #%d", + p, reads); + pkg_free(p); + return -1; + } - pkg_free(p); - break; + pkg_free(p); + break; - case ERL_SMALL_INTEGER_EXT: - case ERL_INTEGER_EXT: + case ERL_SMALL_INTEGER_EXT: + case ERL_INTEGER_EXT: - if (autoconvert == 0) - { - erl_rpc_fault(ctx,400,"Bad type of parameter #%d",reads); - return -1; - } + if(autoconvert == 0) { + erl_rpc_fault(ctx, 400, "Bad type of parameter #%d", reads); + return -1; + } - if(ei_decode_long(ctx->request->buff, &ctx->request_index, &n)) - { - erl_rpc_fault(ctx,400,"Can't read parameter #%d",reads); - return -1; - } + if(ei_decode_long(ctx->request->buff, &ctx->request_index, &n)) { + erl_rpc_fault(ctx, 400, "Can't read parameter #%d", reads); + return -1; + } - *double_prt=n; + *double_prt = n; - break; - default: - erl_rpc_fault(ctx,400,"Can't convert to double parameter #%d.",reads); - return -1; + break; + default: + erl_rpc_fault( + ctx, 400, "Can't convert to double parameter #%d.", reads); + return -1; } return 0; } -#define MAX_DIGITS 20 +#define MAX_DIGITS 20 static int get_str(str *str_ptr, erl_rpc_ctx_t *ctx, int reads, int autoconvert) { @@ -1264,119 +1234,112 @@ static int get_str(str *str_ptr, erl_rpc_ctx_t *ctx, int reads, int autoconvert) double d; long n; - if (ei_get_type(ctx->request->buff,&ctx->request_index,&type,&size)) - { - erl_rpc_fault(ctx,400,"Can't determine data type of parameter #%d",reads); + if(ei_get_type(ctx->request->buff, &ctx->request_index, &type, &size)) { + erl_rpc_fault( + ctx, 400, "Can't determine data type of parameter #%d", reads); return -1; } - switch(type) - { - case ERL_FLOAT_EXT: + switch(type) { + case ERL_FLOAT_EXT: - if (autoconvert == 0) - { - erl_rpc_fault(ctx,400,"Bad type of parameter #%d",reads); - return -1; - } + if(autoconvert == 0) { + erl_rpc_fault(ctx, 400, "Bad type of parameter #%d", reads); + return -1; + } - if (ei_decode_double(ctx->request->buff,&ctx->request_index,&d)) - { - erl_rpc_fault(ctx,400, "Bad value of parameter #%d.",reads); - return -1; - } + if(ei_decode_double(ctx->request->buff, &ctx->request_index, &d)) { + erl_rpc_fault(ctx, 400, "Bad value of parameter #%d.", reads); + return -1; + } - p=(char*)pkg_malloc(MAX_DIGITS); + p = (char *)pkg_malloc(MAX_DIGITS); - if (!p) - { - erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)"); - LM_ERR("Not enough memory\n"); - return -1; - } + if(!p) { + erl_rpc_fault( + ctx, 500, "Internal Server Error (No memory left)"); + LM_ERR("Not enough memory\n"); + return -1; + } - if (add_to_recycle_bin(JUNK_PKGCHAR, p, ctx)) - { - pkg_free(p); - return -1; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, p, ctx)) { + pkg_free(p); + return -1; + } - str_ptr->len=snprintf(p, MAX_DIGITS, "%f", d); - str_ptr->s = p; + str_ptr->len = snprintf(p, MAX_DIGITS, "%f", d); + str_ptr->s = p; - break; + break; - case ERL_STRING_EXT: - case ERL_LIST_EXT: - case ERL_BINARY_EXT: + case ERL_STRING_EXT: + case ERL_LIST_EXT: + case ERL_BINARY_EXT: - /* allocate buffer */ - p = (char*)pkg_malloc(size+1); + /* allocate buffer */ + p = (char *)pkg_malloc(size + 1); - if (!p) - { - erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)"); - LM_ERR("Not enough memory\n"); - return -1; - } + if(!p) { + erl_rpc_fault( + ctx, 500, "Internal Server Error (No memory left)"); + LM_ERR("Not enough memory\n"); + return -1; + } - if (add_to_recycle_bin(JUNK_PKGCHAR, p, ctx)) - { - pkg_free(p); - return -1; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, p, ctx)) { + pkg_free(p); + return -1; + } - if(ei_decode_strorbin(ctx->request->buff,&ctx->request_index,size+1,p)) - { - erl_rpc_fault(ctx,400, "Can't read parameter #%d",reads); - return -1; - } + if(ei_decode_strorbin( + ctx->request->buff, &ctx->request_index, size + 1, p)) { + erl_rpc_fault(ctx, 400, "Can't read parameter #%d", reads); + return -1; + } - str_ptr->s=p; - str_ptr->len=size; + str_ptr->s = p; + str_ptr->len = size; - break; + break; - case ERL_SMALL_INTEGER_EXT: - case ERL_INTEGER_EXT: + case ERL_SMALL_INTEGER_EXT: + case ERL_INTEGER_EXT: - if (autoconvert == 0) - { - erl_rpc_fault(ctx,400,"Bad type of parameter #%d",reads); - return -1; - } + if(autoconvert == 0) { + erl_rpc_fault(ctx, 400, "Bad type of parameter #%d", reads); + return -1; + } - if (ei_decode_long(ctx->request->buff,&ctx->request_index,&n)) - { - erl_rpc_fault(ctx,400, "Bad value of parameter #%d.",reads); - return -1; - } + if(ei_decode_long(ctx->request->buff, &ctx->request_index, &n)) { + erl_rpc_fault(ctx, 400, "Bad value of parameter #%d.", reads); + return -1; + } - p=(char*)pkg_malloc(MAX_DIGITS); + p = (char *)pkg_malloc(MAX_DIGITS); - if (!p) - { - erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)"); - LM_ERR("Not enough memory\n"); - return -1; - } + if(!p) { + erl_rpc_fault( + ctx, 500, "Internal Server Error (No memory left)"); + LM_ERR("Not enough memory\n"); + return -1; + } - if (add_to_recycle_bin(JUNK_PKGCHAR, p, ctx)) - { - pkg_free(p); - return -1; - } + if(add_to_recycle_bin(JUNK_PKGCHAR, p, ctx)) { + pkg_free(p); + return -1; + } - str_ptr->len=snprintf(p, MAX_DIGITS, "%ld", n); - str_ptr->s = p; + str_ptr->len = snprintf(p, MAX_DIGITS, "%ld", n); + str_ptr->s = p; - break; - default: - erl_rpc_fault(ctx,400,"Can't convert to string parameter #%d.",reads); - return -1; + break; + default: + erl_rpc_fault( + ctx, 400, "Can't convert to string parameter #%d.", reads); + return -1; } - LM_ERR("parameter #%d:<%.*s>\n",reads,STR_FMT(str_ptr)); + LM_ERR("parameter #%d:<%.*s>\n", reads, STR_FMT(str_ptr)); return 0; } @@ -1384,47 +1347,40 @@ static int get_str(str *str_ptr, erl_rpc_ctx_t *ctx, int reads, int autoconvert) /* * Find member in tuple (aka RPC struct) */ -static int find_member(erl_rpc_ctx_t *ctx, int arity, const char* member_name) +static int find_member(erl_rpc_ctx_t *ctx, int arity, const char *member_name) { - int index,i=0; - int type,size; + int index, i = 0; + int type, size; char key_name[MAXATOMLEN]; /* save position */ index = ctx->request_index; /* { name, Value, name, Value...} */ - while (i < arity) - { - if (ei_get_type(ctx->request->buff,&ctx->request_index,&type,&size)) - { - erl_rpc_fault(ctx,400,"Bad struct member type"); + while(i < arity) { + if(ei_get_type(ctx->request->buff, &ctx->request_index, &type, &size)) { + erl_rpc_fault(ctx, 400, "Bad struct member type"); goto error; } - if(ei_decode_atom(ctx->request->buff,&ctx->request_index, key_name)) - { - erl_rpc_fault(ctx,400,"Bad member name"); + if(ei_decode_atom(ctx->request->buff, &ctx->request_index, key_name)) { + erl_rpc_fault(ctx, 400, "Bad member name"); goto error; } - if (strcasecmp(member_name,key_name)) - { - if(ei_skip_term(ctx->request->buff,&ctx->request_index)) - { - erl_rpc_fault(ctx,400,"Unexpected end of struct tuple"); + if(strcasecmp(member_name, key_name)) { + if(ei_skip_term(ctx->request->buff, &ctx->request_index)) { + erl_rpc_fault(ctx, 400, "Unexpected end of struct tuple"); goto error; } i++; - } - else - { + } else { /* return at current position */ return 0; } } - erl_rpc_fault(ctx,400, "Member %s not found",member_name); + erl_rpc_fault(ctx, 400, "Member %s not found", member_name); error: ctx->request_index = index; @@ -1441,7 +1397,8 @@ void init_rpc_handlers() erl_rpc_func_param.struct_add = (rpc_struct_add_f)erl_rpc_struct_add; erl_rpc_func_param.array_add = (rpc_array_add_f)erl_rpc_array_add; erl_rpc_func_param.struct_scan = (rpc_struct_scan_f)erl_rpc_struct_scan; - erl_rpc_func_param.struct_printf = (rpc_struct_printf_f)erl_rpc_struct_printf; + erl_rpc_func_param.struct_printf = + (rpc_struct_printf_f)erl_rpc_struct_printf; erl_rpc_func_param.capabilities = (rpc_capabilities_f)erl_rpc_capabilities; erl_rpc_func_param.delayed_ctx_new = 0; erl_rpc_func_param.delayed_ctx_close = 0; @@ -1451,9 +1408,8 @@ erl_rpc_param_t *erl_new_param(erl_rpc_ctx_t *ctx) { erl_rpc_param_t *p = (erl_rpc_param_t *)pkg_malloc(sizeof(erl_rpc_param_t)); - if (add_to_recycle_bin(JUNK_PKGCHAR,(void*)p,ctx)) - { - erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)"); + if(add_to_recycle_bin(JUNK_PKGCHAR, (void *)p, ctx)) { + erl_rpc_fault(ctx, 500, "Internal Server Error (No memory left)"); LM_ERR("Not enough memory\n"); pkg_free(p); @@ -1468,13 +1424,10 @@ erl_rpc_param_t *erl_new_param(erl_rpc_ctx_t *ctx) void erl_rpc_append_param(erl_rpc_ctx_t *ctx, erl_rpc_param_t *param) { - if (ctx->tail) - { + if(ctx->tail) { ctx->tail->next = param; ctx->tail = param; - } - else - { + } else { ctx->reply_params = ctx->tail = param; } diff --git a/src/modules/erlang/handle_rpc.h b/src/modules/erlang/handle_rpc.h index 24edabf21d6..32137d8d7e5 100644 --- a/src/modules/erlang/handle_rpc.h +++ b/src/modules/erlang/handle_rpc.h @@ -33,19 +33,22 @@ /* * RPC structure to store reply before marshaling. */ -typedef struct erl_rpc_param_s { +typedef struct erl_rpc_param_s +{ int type; - union { + union + { int n; double d; str S; - void* handler; + void *handler; } value; char *member_name; struct erl_rpc_param_s *next; } erl_rpc_param_t; -typedef struct erl_rpc_ctx { +typedef struct erl_rpc_ctx +{ cnode_handler_t *phandler; erlang_ref_ex_t *ref; erlang_pid *pid; @@ -54,26 +57,36 @@ typedef struct erl_rpc_ctx { ei_x_buff *response; int response_sent; int response_index; - erl_rpc_param_t *reply_params; /* encoded into reply as {ok,[]} */ + erl_rpc_param_t + *reply_params; /* encoded into reply as {ok,[]} */ erl_rpc_param_t *tail; erl_rpc_param_t *fault; /* is set has precedence on reply_params encoded as {error, {code, }} */ erl_rpc_param_t **fault_p; int no_params; /* number of encoding params */ - int optional; /* are params optional */ - int size; /* size of decoding structure or main list */ + int optional; /* are params optional */ + int size; /* size of decoding structure or main list */ } erl_rpc_ctx_t; -int erl_rpc_send(erl_rpc_ctx_t* ctx, int depth); /* Send the reply to the Erlang Node */ -void erl_rpc_fault(erl_rpc_ctx_t* ctx, int code, char* fmt, ...); /* Signal a failure to the client */ -int erl_rpc_add(erl_rpc_ctx_t* ctx, char* fmt, ...); /* Add a new piece of data to the result */ -int erl_rpc_scan(erl_rpc_ctx_t* ctx, char* fmt, ...); /* Retrieve request parameters */ -int erl_rpc_printf(erl_rpc_ctx_t* ctx, char* fmt, ...); /* Add printf-like formatted data to the result set */ -int erl_rpc_struct_add(erl_rpc_ctx_t* ctx, char* fmt, ...); /* Add a new structure into structure */ -int erl_rpc_array_add(erl_rpc_ctx_t* ctx, char* fmt, ...); /* Add a new structure into array */ -int erl_rpc_struct_scan(erl_rpc_ctx_t* ctx, char* fmt, ...); /* Scan attributes of a structure */ -int erl_rpc_struct_printf(erl_rpc_ctx_t* ctx, char* name, char* fmt, ...); /* Struct version of rpc_printf */ -int erl_rpc_capabilities(erl_rpc_ctx_t* ctx); /* capabilities */ +int erl_rpc_send( + erl_rpc_ctx_t *ctx, int depth); /* Send the reply to the Erlang Node */ +void erl_rpc_fault(erl_rpc_ctx_t *ctx, int code, char *fmt, + ...); /* Signal a failure to the client */ +int erl_rpc_add(erl_rpc_ctx_t *ctx, char *fmt, + ...); /* Add a new piece of data to the result */ +int erl_rpc_scan( + erl_rpc_ctx_t *ctx, char *fmt, ...); /* Retrieve request parameters */ +int erl_rpc_printf(erl_rpc_ctx_t *ctx, char *fmt, + ...); /* Add printf-like formatted data to the result set */ +int erl_rpc_struct_add(erl_rpc_ctx_t *ctx, char *fmt, + ...); /* Add a new structure into structure */ +int erl_rpc_array_add(erl_rpc_ctx_t *ctx, char *fmt, + ...); /* Add a new structure into array */ +int erl_rpc_struct_scan(erl_rpc_ctx_t *ctx, char *fmt, + ...); /* Scan attributes of a structure */ +int erl_rpc_struct_printf(erl_rpc_ctx_t *ctx, char *name, char *fmt, + ...); /* Struct version of rpc_printf */ +int erl_rpc_capabilities(erl_rpc_ctx_t *ctx); /* capabilities */ void init_rpc_handlers(); void empty_recycle_bin(void); @@ -81,16 +94,19 @@ void empty_recycle_bin(void); /** * Garbage collection data structure. */ -struct erl_rpc_garbage { - enum { - JUNK_EI_X_BUFF, /**< This type indicates that the memory block was +struct erl_rpc_garbage +{ + enum + { + JUNK_EI_X_BUFF, /**< This type indicates that the memory block was * allocated for the erlang EI interface, this * type needs to be freed differently */ - JUNK_PKGCHAR /** This type indicates a pkg_malloc'ed string */ - } type; /**< Type of the memory block */ - void* ptr; /**< Pointer to the memory block obtained from pkg_malloc */ - struct erl_rpc_garbage* next; /**< The linked list of all allocated memory blocks */ + JUNK_PKGCHAR /** This type indicates a pkg_malloc'ed string */ + } type; /**< Type of the memory block */ + void *ptr; /**< Pointer to the memory block obtained from pkg_malloc */ + struct erl_rpc_garbage + *next; /**< The linked list of all allocated memory blocks */ }; diff --git a/src/modules/erlang/pv_atom.c b/src/modules/erlang/pv_atom.c index 9b7f0555cfb..fa6bd50b8a8 100644 --- a/src/modules/erlang/pv_atom.c +++ b/src/modules/erlang/pv_atom.c @@ -32,7 +32,7 @@ #include -static str atom_list=str_init("[atoms]"); +static str atom_list = str_init("[atoms]"); static char *atom_fmt_buff = NULL; static int counter; @@ -44,7 +44,7 @@ int pv_atom_parse_name(pv_spec_t *sp, str *in) str attr; int l; - if (in->s == NULL || in->len <= 0) + if(in->s == NULL || in->len <= 0) return -1; p = in->s; @@ -54,12 +54,13 @@ int pv_atom_parse_name(pv_spec_t *sp, str *in) /*pvi.type now defaults to 4, breaking the erlang module's type management*/ sp->pvp.pvi.type = 0; - while (is_in_str(p, in)) { - if (*p == '[' || *p== '=') + while(is_in_str(p, in)) { + if(*p == '[' || *p == '=') break; - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in var name %.*s at %d\n",STR_FMT(in),l); + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in var name %.*s at %d\n", STR_FMT(in), + l); goto error; } p++; @@ -68,20 +69,19 @@ int pv_atom_parse_name(pv_spec_t *sp, str *in) /* from in->s to p */ name.len = p - in->s; - if (pv_parse_avp_name(sp,&name)) + if(pv_parse_avp_name(sp, &name)) goto error; - if (is_in_str(p,in) && *p =='[') - { - idx.s=++p; + if(is_in_str(p, in) && *p == '[') { + idx.s = ++p; - while (is_in_str(p,in)) { - if (*p == ']' || *p == '=') + while(is_in_str(p, in)) { + if(*p == ']' || *p == '=') break; p++; } - if (is_in_str(p,in) && *p==']') { + if(is_in_str(p, in) && *p == ']') { idx.len = p - idx.s; LM_ERR("index isn't allowed for this variable\n"); @@ -89,25 +89,28 @@ int pv_atom_parse_name(pv_spec_t *sp, str *in) } p++; } else { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_NO_IDX); + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_NO_IDX); } - if (is_in_str(p,in) && *p =='=') - { + if(is_in_str(p, in) && *p == '=') { p++; - if (!is_in_str(p,in) || *p!='>') { - l = p-in->s; - LM_ERR("invalid operator (expected =>) for accessing attribute in token %.*s at position %d\n",STR_FMT(in),l); + if(!is_in_str(p, in) || *p != '>') { + l = p - in->s; + LM_ERR("invalid operator (expected =>) for accessing attribute in " + "token %.*s at position %d\n", + STR_FMT(in), l); goto error; } attr.s = ++p; - while (is_in_str(p,in)) { - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in attribute name in token %.*s at %d\n",STR_FMT(in),l); + while(is_in_str(p, in)) { + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in attribute name in token %.*s at " + "%d\n", + STR_FMT(in), l); goto error; } p++; @@ -115,25 +118,25 @@ int pv_atom_parse_name(pv_spec_t *sp, str *in) attr.len = p - attr.s; - if (attr.len > 0 ) { + if(attr.len > 0) { - if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_TYPE))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_TYPE); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_FORMAT))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_FORMAT); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_LENGTH))) { + if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_TYPE))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_TYPE); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_FORMAT))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_FORMAT); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_LENGTH))) { LM_ERR("attribute isn't supported for this variable\n"); goto error; } else { - LM_ERR("unknown attribute %.*s\n",STR_FMT(&attr)); + LM_ERR("unknown attribute %.*s\n", STR_FMT(&attr)); goto error; } } } - if (p < in->s + in->len) { - l = p-in->s; - LM_ERR("unexpected token in %.*s at %d\n",STR_FMT(in),l); + if(p < in->s + in->len) { + l = p - in->s; + LM_ERR("unexpected token in %.*s at %d\n", STR_FMT(in), l); goto error; } @@ -147,9 +150,10 @@ int pv_atom_parse_name(pv_spec_t *sp, str *in) sr_xavp_t *xavp_get_atoms() { sr_xavp_t *list; - list = xavp_get(&atom_list,NULL); + list = xavp_get(&atom_list, NULL); - if(!list) counter = 0; + if(!list) + counter = 0; return list; } @@ -159,21 +163,22 @@ sr_xavp_t *pv_atom_get_atom(str *name) return xavp_get_child(&atom_list, name); } -int pv_atom_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) +int pv_atom_set(struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) { str name; sr_xavp_t *atoms_root; sr_xavp_t *atom; - sr_xavp_t *new,*old=NULL; + sr_xavp_t *new, *old = NULL; sr_xavp_t *atom_xavp; sr_xval_t atom_val; - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) { + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) { LM_ERR("invalid variable name type\n"); return -1; } - if(pv_xbuff_new_xavp(&atom_xavp,val,&counter,'a')) { + if(pv_xbuff_new_xavp(&atom_xavp, val, &counter, 'a')) { LM_ERR("failed to create new value\n"); return -1; } @@ -181,7 +186,7 @@ int pv_atom_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val /* atom name */ name = param->pvn.u.isname.name.s; - memset((void*)&atom_val,0,sizeof(sr_xval_t)); + memset((void *)&atom_val, 0, sizeof(sr_xval_t)); atoms_root = xavp_get_atoms(); @@ -189,9 +194,10 @@ int pv_atom_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val atom_val.type = SR_XTYPE_XAVP; atom_val.v.xavp = atom_xavp; - atom = xavp_add_xavp_value(&atom_list,&name,&atom_val,xavp_get_crt_list()); + atom = xavp_add_xavp_value( + &atom_list, &name, &atom_val, xavp_get_crt_list()); - if (!atom) + if(!atom) goto err; return 0; @@ -199,14 +205,14 @@ int pv_atom_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val atom = xavp_get_child(&atom_list, &name); - if (!atom) { + if(!atom) { atom_val.type = SR_XTYPE_XAVP; atom_val.v.xavp = atom_xavp; - new = xavp_add_value(&name,&atom_val,&atoms_root->val.v.xavp); + new = xavp_add_value(&name, &atom_val, &atoms_root->val.v.xavp); - if (!new) + if(!new) goto err; return 0; @@ -215,7 +221,7 @@ int pv_atom_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val old = atom->val.v.xavp; new = atom_xavp; - if (old) { + if(old) { xavp_destroy_list(&old); } @@ -230,42 +236,43 @@ int pv_atom_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val return -1; } -int pv_atom_get_value(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp) +int pv_atom_get_value( + struct sip_msg *msg, pv_param_t *param, pv_value_t *res, sr_xavp_t *avp) { static char _pv_xavp_buf[128]; str s; - if (!avp) return pv_get_null(msg,param,res); + if(!avp) + return pv_get_null(msg, param, res); switch(avp->val.type) { - case SR_XTYPE_NULL: - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_STR: - if(snprintf(_pv_xavp_buf, 128, "<>", avp)<0) + case SR_XTYPE_NULL: return pv_get_null(msg, param, res); - break; - case SR_XTYPE_XAVP: - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) + break; + case SR_XTYPE_STR: + if(snprintf(_pv_xavp_buf, 128, "<>", avp) < 0) + return pv_get_null(msg, param, res); + break; + case SR_XTYPE_XAVP: + if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp) < 0) + return pv_get_null(msg, param, res); + break; + case SR_XTYPE_DATA: + case SR_XTYPE_TIME: + case SR_XTYPE_LONG: + case SR_XTYPE_LLONG: + LM_ERR("BUG: unexpected atom value\n"); + return pv_get_null(msg, param, res); + break; + default: return pv_get_null(msg, param, res); - break; - case SR_XTYPE_DATA: - case SR_XTYPE_TIME: - case SR_XTYPE_LONG: - case SR_XTYPE_LLONG: - LM_ERR("BUG: unexpected atom value\n"); - return pv_get_null(msg, param, res); - break; - default: - return pv_get_null(msg, param, res); } s.s = _pv_xavp_buf; s.len = strlen(_pv_xavp_buf); return pv_get_strval(msg, param, res, &s); } -int pv_atom_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) +int pv_atom_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { str name; sr_xavp_t *atoms_root; @@ -276,14 +283,14 @@ int pv_atom_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) ei_x_buff xbuff; - if(param==NULL) - { + if(param == NULL) { LM_ERR("bad parameters\n"); return -1; } - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) - return -1; + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) + return -1; /* tuple name */ name = param->pvn.u.isname.name.s; @@ -292,58 +299,60 @@ int pv_atom_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) atoms_root = xavp_get_atoms(); if(!atoms_root) { - return pv_get_null(msg,param,res); + return pv_get_null(msg, param, res); } - atom = xavp_get(&name,atoms_root->val.v.xavp); - if (!atom) { - return pv_get_null(msg,param,res); + atom = xavp_get(&name, atoms_root->val.v.xavp); + if(!atom) { + return pv_get_null(msg, param, res); } xavp = atom->val.v.xavp; - switch (xbuff_is_attr_set(attr)) { - case XBUFF_ATTR_TYPE: - return pv_get_strval(msg,param,res,&xbuff_types[XBUFF_TYPE_ATOM]); - break; - case XBUFF_ATTR_LENGTH: /* always 1 */ - return pv_get_uintval(msg,param,res,1); - break; - case XBUFF_ATTR_FORMAT: - /* + switch(xbuff_is_attr_set(attr)) { + case XBUFF_ATTR_TYPE: + return pv_get_strval( + msg, param, res, &xbuff_types[XBUFF_TYPE_ATOM]); + break; + case XBUFF_ATTR_LENGTH: /* always 1 */ + return pv_get_uintval(msg, param, res, 1); + break; + case XBUFF_ATTR_FORMAT: + /* * Prints a term, in clear text, to the PV value pointed to by res. * It tries to resemble the term printing in the erlang shell. */ - ei_x_new_with_version(&xbuff); - if (xavp && xavp_encode(&xbuff,xavp,1)) { - ei_x_free(&xbuff); - return -1; - } else { - ei_x_encode_atom(&xbuff,"undefined"); - } - i = 1; - if (ei_s_print_term(&atom_fmt_buff,xbuff.buff,&i)<0) { - LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_new_with_version(&xbuff); + if(xavp && xavp_encode(&xbuff, xavp, 1)) { + ei_x_free(&xbuff); + return -1; + } else { + ei_x_encode_atom(&xbuff, "undefined"); + } + i = 1; + if(ei_s_print_term(&atom_fmt_buff, xbuff.buff, &i) < 0) { + LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_free(&xbuff); + return -1; + } + i = pv_get_strzval(msg, param, res, atom_fmt_buff); ei_x_free(&xbuff); - return -1; - } - i = pv_get_strzval(msg,param,res,atom_fmt_buff); - ei_x_free(&xbuff); - return i; + return i; } - if (!xavp) { - return pv_get_null(msg,param,res); + if(!xavp) { + return pv_get_null(msg, param, res); } - return pv_atom_get_value(msg,param,res,xavp); + return pv_atom_get_value(msg, param, res, xavp); } /* * free format buffer for tuple */ -void free_atom_fmt_buff() { - if (atom_fmt_buff) { +void free_atom_fmt_buff() +{ + if(atom_fmt_buff) { free(atom_fmt_buff); } atom_fmt_buff = 0; diff --git a/src/modules/erlang/pv_atom.h b/src/modules/erlang/pv_atom.h index 17912021bef..f3e57d9afb7 100644 --- a/src/modules/erlang/pv_atom.h +++ b/src/modules/erlang/pv_atom.h @@ -27,8 +27,8 @@ #include "../../core/pvar.h" int pv_atom_parse_name(pv_spec_t *sp, str *in); -int pv_atom_set(struct sip_msg*, pv_param_t*, int, pv_value_t*); -int pv_atom_get(struct sip_msg*, pv_param_t*, pv_value_t*); +int pv_atom_set(struct sip_msg *, pv_param_t *, int, pv_value_t *); +int pv_atom_get(struct sip_msg *, pv_param_t *, pv_value_t *); void free_atom_fmt_buff(); diff --git a/src/modules/erlang/pv_list.c b/src/modules/erlang/pv_list.c index cc533f597f5..ae76f6ba2a3 100644 --- a/src/modules/erlang/pv_list.c +++ b/src/modules/erlang/pv_list.c @@ -28,7 +28,7 @@ #include "pv_list.h" #include "pv_xbuff.h" -static str list_list=str_init("[lists]"); +static str list_list = str_init("[lists]"); static int counter; static char *list_fmt_buff = NULL; @@ -36,9 +36,10 @@ static char *list_fmt_buff = NULL; sr_xavp_t *xavp_get_lists() { sr_xavp_t *list; - list = xavp_get(&list_list,NULL); + list = xavp_get(&list_list, NULL); - if(!list) counter = 0; + if(!list) + counter = 0; return list; } @@ -48,12 +49,12 @@ sr_xavp_t *pv_list_get_list(str *name) return xavp_get_child(&list_list, name); } -int pv_list_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) +int pv_list_set(struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) { str name; sr_xavp_t *lists_root; sr_xavp_t *list; - sr_xavp_t *lh,*new,*old,*prv=NULL; + sr_xavp_t *lh, *new, *old, *prv = NULL; sr_xavp_t *list_xavp; sr_xavp_t *item_xavp; sr_xval_t list_val; @@ -63,12 +64,13 @@ int pv_list_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val int idxf = 0; int attr = 0; - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) { + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) { LM_ERR("invalid variable name type\n"); return -1; } - memset((void*)&empty,0,sizeof(pv_value_t)); + memset((void *)&empty, 0, sizeof(pv_value_t)); empty.flags = PV_VAL_NULL; /* list name */ @@ -78,24 +80,25 @@ int pv_list_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val if(!lists_root) { - if(pv_xbuff_new_xavp(&list_xavp,&empty,&counter,'l')) { + if(pv_xbuff_new_xavp(&list_xavp, &empty, &counter, 'l')) { LM_ERR("failed to create new value\n"); return -1; } list_val.type = SR_XTYPE_XAVP; list_val.v.xavp = list_xavp; - list = xavp_add_xavp_value(&list_list,&name,&list_val,xavp_get_crt_list()); + list = xavp_add_xavp_value( + &list_list, &name, &list_val, xavp_get_crt_list()); - if (!list) + if(!list) goto err; } - list=xavp_get_child(&list_list, &name); + list = xavp_get_child(&list_list, &name); - if (!list) { + if(!list) { - if(pv_xbuff_new_xavp(&list_xavp,&empty,&counter,'l')) { + if(pv_xbuff_new_xavp(&list_xavp, &empty, &counter, 'l')) { LM_ERR("failed to create new value\n"); return -1; } @@ -103,15 +106,15 @@ int pv_list_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val list_val.type = SR_XTYPE_XAVP; list_val.v.xavp = list_xavp; - list=xavp_add_value(&name,&list_val,&lists_root->val.v.xavp); + list = xavp_add_value(&name, &list_val, &lists_root->val.v.xavp); - if (!list) + if(!list) goto err; } lh = list->val.v.xavp; - if(pv_xbuff_new_xavp(&item_xavp,val,&counter,0)) { + if(pv_xbuff_new_xavp(&item_xavp, val, &counter, 0)) { LM_ERR("failed to create new value\n"); return -1; } @@ -124,49 +127,48 @@ int pv_list_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val p.pvi.type = xbuff_fix_index(p.pvi.type); /* get the index */ - if(pv_get_spec_index(msg, &p, &idx, &idxf)) - { + if(pv_get_spec_index(msg, &p, &idx, &idxf)) { LM_ERR("invalid index\n"); return -1; } - if (xbuff_is_attr_set(attr)) { - LM_ERR("read only attribute %.*s\n",STR_FMT(&xbuff_attr_name(attr))); + if(xbuff_is_attr_set(attr)) { + LM_ERR("read only attribute %.*s\n", STR_FMT(&xbuff_attr_name(attr))); return -1; } /* prepend on list when no index */ - if (xbuff_is_no_index(attr)) { - if (lh->val.type == SR_XTYPE_NULL) { + if(xbuff_is_no_index(attr)) { + if(lh->val.type == SR_XTYPE_NULL) { lh->val.type = SR_XTYPE_XAVP; lh->val.v.xavp = item_xavp; return 0; } else { - return xavp_add(item_xavp,&lh->val.v.xavp); + return xavp_add(item_xavp, &lh->val.v.xavp); } } - if (idxf == PV_IDX_ALL) { + if(idxf == PV_IDX_ALL) { xavp_destroy_list(&lh->val.v.xavp); - if (item_xavp->val.type == SR_XTYPE_NULL) { + if(item_xavp->val.type == SR_XTYPE_NULL) { /* create empty list */ xavp_destroy_list(&item_xavp); - memset((void*)&lh->val,0,sizeof(sr_xval_t)); + memset((void *)&lh->val, 0, sizeof(sr_xval_t)); lh->val.type = SR_XTYPE_NULL; return 0; } else { - return xavp_add(item_xavp,&lh->val.v.xavp); + return xavp_add(item_xavp, &lh->val.v.xavp); } } /* set by index */ - old = xavp_get_nth(&lh->val.v.xavp,idx,&prv); + old = xavp_get_nth(&lh->val.v.xavp, idx, &prv); new = item_xavp; - if (old) { + if(old) { new->next = old->next; - if (prv) { + if(prv) { prv->next = new; } else { new->next = old->next; @@ -175,7 +177,7 @@ int pv_list_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val old->next = NULL; xavp_destroy_list(&old); } else { - if (prv) { + if(prv) { prv->next = new; } else { lh->val.v.xavp = new; @@ -192,67 +194,78 @@ int pv_list_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val return -1; } -int pv_list_get_value(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp) +int pv_list_get_value( + struct sip_msg *msg, pv_param_t *param, pv_value_t *res, sr_xavp_t *avp) { static char _pv_xavp_buf[128]; str s; - if (!avp) return pv_get_null(msg,param,res); + if(!avp) + return pv_get_null(msg, param, res); switch(avp->val.type) { - case SR_XTYPE_NULL: - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_LONG: - return pv_get_sintval(msg, param, res, avp->val.v.l); - break; - case SR_XTYPE_STR: - switch (avp->name.s[0]) { - case 'a': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) - return pv_get_null(msg, param, res); - break; - default: - return pv_get_strval(msg, param, res, &avp->val.v.s); - } - break; - case SR_XTYPE_TIME: - if(snprintf(_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t)<0) + case SR_XTYPE_NULL: return pv_get_null(msg, param, res); - break; - case SR_XTYPE_LLONG: - if(snprintf(_pv_xavp_buf, 128, "%lld", avp->val.v.ll)<0) - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_XAVP: - switch(avp->name.s[0]) { - case 't': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) + break; + case SR_XTYPE_LONG: + return pv_get_sintval(msg, param, res, avp->val.v.l); + break; + case SR_XTYPE_STR: + switch(avp->name.s[0]) { + case 'a': + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + break; + default: + return pv_get_strval(msg, param, res, &avp->val.v.s); + } + break; + case SR_XTYPE_TIME: + if(snprintf(_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t) + < 0) return pv_get_null(msg, param, res); break; - case 'l': - default: - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) + case SR_XTYPE_LLONG: + if(snprintf(_pv_xavp_buf, 128, "%lld", avp->val.v.ll) < 0) return pv_get_null(msg, param, res); - } - break; - case SR_XTYPE_DATA: - if (avp->name.s[0] == 'p') { - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) + break; + case SR_XTYPE_XAVP: + switch(avp->name.s[0]) { + case 't': + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + break; + case 'l': + default: + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + } + break; + case SR_XTYPE_DATA: + if(avp->name.s[0] == 'p') { + if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data) + < 0) + return pv_get_null(msg, param, res); + } else if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.data) + < 0) return pv_get_null(msg, param, res); - } else if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) + break; + default: return pv_get_null(msg, param, res); - break; - default: - return pv_get_null(msg, param, res); } s.s = _pv_xavp_buf; s.len = strlen(_pv_xavp_buf); return pv_get_strval(msg, param, res, &s); } -int pv_list_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) +int pv_list_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { str name; pv_spec_t *nsp = NULL; @@ -263,30 +276,30 @@ int pv_list_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) sr_xavp_t *lh; sr_xavp_t *xavp; pv_param_t p; - int idx=0; - int idxf=0; + int idx = 0; + int idxf = 0; int attr; - int i,count; + int i, count; ei_x_buff xbuff; - if(param==NULL) - { + if(param == NULL) { LM_ERR("bad parameters\n"); return -1; } - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) - return -1; + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) + return -1; - if( param->pvn.type == PV_NAME_PVAR) { - nsp = param->pvn.u.dname; + if(param->pvn.type == PV_NAME_PVAR) { + nsp = param->pvn.u.dname; } /* work on copy of index! */ p = *param; - if (nsp) { + if(nsp) { pvi = &nsp->pvp.pvi; pvn = &nsp->pvp.pvn; } else { @@ -302,89 +315,94 @@ int pv_list_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) pvi->type = xbuff_fix_index(pvi->type); /* get the index */ - if(pv_get_spec_index(msg, &p, &idx, &idxf)) - { + if(pv_get_spec_index(msg, &p, &idx, &idxf)) { LM_ERR("invalid index\n"); return -1; } lists_root = xavp_get_lists(); if(!lists_root) { - return pv_get_null(msg,param,res); + return pv_get_null(msg, param, res); } - list = xavp_get(&name,lists_root->val.v.xavp); - if (!list) { - return pv_get_null(msg,param,res); + list = xavp_get(&name, lists_root->val.v.xavp); + if(!list) { + return pv_get_null(msg, param, res); } lh = list->val.v.xavp; - switch (xbuff_is_attr_set(attr)) { - case XBUFF_ATTR_TYPE: - if (xbuff_is_no_index(attr)) { - return pv_get_strval(msg,param,res,&xbuff_types[XBUFF_TYPE_LIST]); - } else { - xavp = xavp_get_nth(&lh->val.v.xavp,idx,NULL); - return pv_xbuff_get_type(msg,param,res,xavp); - } - break; - case XBUFF_ATTR_LENGTH: - xavp = xbuff_is_no_index(attr) ? lh : xavp_get_nth(&lh->val.v.xavp,idx,NULL); - - if (xavp) { - count = xavp_get_count(xavp->val.v.xavp); - return pv_get_uintval(msg,param,res,(unsigned int)count); - } else { - return pv_get_null(msg,param,res); - } - break; - case XBUFF_ATTR_FORMAT: - /* + switch(xbuff_is_attr_set(attr)) { + case XBUFF_ATTR_TYPE: + if(xbuff_is_no_index(attr)) { + return pv_get_strval( + msg, param, res, &xbuff_types[XBUFF_TYPE_LIST]); + } else { + xavp = xavp_get_nth(&lh->val.v.xavp, idx, NULL); + return pv_xbuff_get_type(msg, param, res, xavp); + } + break; + case XBUFF_ATTR_LENGTH: + xavp = xbuff_is_no_index(attr) + ? lh + : xavp_get_nth(&lh->val.v.xavp, idx, NULL); + + if(xavp) { + count = xavp_get_count(xavp->val.v.xavp); + return pv_get_uintval(msg, param, res, (unsigned int)count); + } else { + return pv_get_null(msg, param, res); + } + break; + case XBUFF_ATTR_FORMAT: + /* * Prints a term, in clear text, to the PV value pointed to by res. * It tries to resemble the term printing in the erlang shell. */ - ei_x_new_with_version(&xbuff); + ei_x_new_with_version(&xbuff); - xavp = xbuff_is_no_index(attr) ? lh : xavp_get_nth(&lh->val.v.xavp,idx,NULL); - if (!xavp || xavp_encode(&xbuff,xavp,1)) { - ei_x_free(&xbuff); - return -1; - } - i = 1; - if (ei_s_print_term(&list_fmt_buff,xbuff.buff,&i)<0) { - LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + xavp = xbuff_is_no_index(attr) + ? lh + : xavp_get_nth(&lh->val.v.xavp, idx, NULL); + if(!xavp || xavp_encode(&xbuff, xavp, 1)) { + ei_x_free(&xbuff); + return -1; + } + i = 1; + if(ei_s_print_term(&list_fmt_buff, xbuff.buff, &i) < 0) { + LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_free(&xbuff); + return -1; + } + i = pv_get_strzval(msg, param, res, list_fmt_buff); ei_x_free(&xbuff); - return -1; - } - i = pv_get_strzval(msg,param,res,list_fmt_buff); - ei_x_free(&xbuff); - return i; + return i; } /* get whole list */ - if ((idxf == PV_IDX_ALL) || xbuff_is_no_index(attr)) { - return pv_list_get_value(msg,param,res,list); + if((idxf == PV_IDX_ALL) || xbuff_is_no_index(attr)) { + return pv_list_get_value(msg, param, res, list); } - if (lh->val.type == SR_XTYPE_NULL) { - return pv_get_null(msg,param,res); + if(lh->val.type == SR_XTYPE_NULL) { + return pv_get_null(msg, param, res); } /* get by idx */ - xavp = xavp_get_nth(&lh->val.v.xavp,idx,NULL); - if (!xavp) { - return pv_get_null(msg,param,res); + xavp = xavp_get_nth(&lh->val.v.xavp, idx, NULL); + if(!xavp) { + return pv_get_null(msg, param, res); } - return pv_list_get_value(msg,param,res,xavp); + return pv_list_get_value(msg, param, res, xavp); } /* * free format buffer for list */ -void free_list_fmt_buff() { - if (list_fmt_buff) { +void free_list_fmt_buff() +{ + if(list_fmt_buff) { free(list_fmt_buff); } list_fmt_buff = 0; diff --git a/src/modules/erlang/pv_list.h b/src/modules/erlang/pv_list.h index 49aab121a9a..091735d3afb 100644 --- a/src/modules/erlang/pv_list.h +++ b/src/modules/erlang/pv_list.h @@ -26,8 +26,8 @@ #include "../../core/pvar.h" #include "../../core/xavp.h" -int pv_list_set(struct sip_msg*, pv_param_t*, int, pv_value_t*); -int pv_list_get(struct sip_msg*, pv_param_t*, pv_value_t*); +int pv_list_set(struct sip_msg *, pv_param_t *, int, pv_value_t *); +int pv_list_get(struct sip_msg *, pv_param_t *, pv_value_t *); sr_xavp_t *pv_list_get_list(str *name); diff --git a/src/modules/erlang/pv_pid.c b/src/modules/erlang/pv_pid.c index 34551f8ede1..0fc0f310a78 100644 --- a/src/modules/erlang/pv_pid.c +++ b/src/modules/erlang/pv_pid.c @@ -30,13 +30,13 @@ #include "pv_pid.h" #include "pv_xbuff.h" -static str pid_list=str_init("[pids]"); +static str pid_list = str_init("[pids]"); static char *pid_fmt_buff = NULL; static int counter; sr_xavp_t *pv_pid_get_pid(str *name) { - return xavp_get_child(&pid_list,name); + return xavp_get_child(&pid_list, name); } int pv_pid_parse_name(pv_spec_t *sp, str *in) @@ -47,7 +47,7 @@ int pv_pid_parse_name(pv_spec_t *sp, str *in) str attr; int l; - if (in->s == NULL || in->len <= 0) + if(in->s == NULL || in->len <= 0) return -1; p = in->s; @@ -57,12 +57,13 @@ int pv_pid_parse_name(pv_spec_t *sp, str *in) /*pvi.type now defaults to 4, breaking the erlang module's type management*/ sp->pvp.pvi.type = 0; - while (is_in_str(p, in)) { - if (*p == '[' || *p== '=') + while(is_in_str(p, in)) { + if(*p == '[' || *p == '=') break; - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in var name %.*s at %d\n",STR_FMT(in),l); + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in var name %.*s at %d\n", STR_FMT(in), + l); goto error; } p++; @@ -71,20 +72,19 @@ int pv_pid_parse_name(pv_spec_t *sp, str *in) /* from in->s to p */ name.len = p - in->s; - if (pv_parse_avp_name(sp,&name)) + if(pv_parse_avp_name(sp, &name)) goto error; - if (is_in_str(p,in) && *p =='[') - { - idx.s=++p; + if(is_in_str(p, in) && *p == '[') { + idx.s = ++p; - while (is_in_str(p,in)) { - if (*p == ']' || *p == '=') + while(is_in_str(p, in)) { + if(*p == ']' || *p == '=') break; p++; } - if (is_in_str(p,in) && *p==']') { + if(is_in_str(p, in) && *p == ']') { idx.len = p - idx.s; LM_ERR("index isn't allowed for this variable\n"); @@ -92,25 +92,28 @@ int pv_pid_parse_name(pv_spec_t *sp, str *in) } p++; } else { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_NO_IDX); + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_NO_IDX); } - if (is_in_str(p,in) && *p =='=') - { + if(is_in_str(p, in) && *p == '=') { p++; - if (!is_in_str(p,in) || *p!='>') { - l = p-in->s; - LM_ERR("invalid operator (expected =>) for accessing attribute in token %.*s at position %d\n",STR_FMT(in),l); + if(!is_in_str(p, in) || *p != '>') { + l = p - in->s; + LM_ERR("invalid operator (expected =>) for accessing attribute in " + "token %.*s at position %d\n", + STR_FMT(in), l); goto error; } attr.s = ++p; - while (is_in_str(p,in)) { - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in attribute name in token %.*s at %d\n",STR_FMT(in),l); + while(is_in_str(p, in)) { + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in attribute name in token %.*s at " + "%d\n", + STR_FMT(in), l); goto error; } p++; @@ -118,25 +121,25 @@ int pv_pid_parse_name(pv_spec_t *sp, str *in) attr.len = p - attr.s; - if (attr.len > 0 ) { + if(attr.len > 0) { - if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_TYPE))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_TYPE); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_FORMAT))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_FORMAT); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_LENGTH))) { + if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_TYPE))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_TYPE); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_FORMAT))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_FORMAT); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_LENGTH))) { LM_ERR("attribute isn't supported for this variable\n"); goto error; } else { - LM_ERR("unknown attribute %.*s\n",STR_FMT(&attr)); + LM_ERR("unknown attribute %.*s\n", STR_FMT(&attr)); goto error; } } } - if (p < in->s + in->len) { - l = p-in->s; - LM_ERR("unexpected token in %.*s at %d\n",STR_FMT(in),l); + if(p < in->s + in->len) { + l = p - in->s; + LM_ERR("unexpected token in %.*s at %d\n", STR_FMT(in), l); goto error; } @@ -150,28 +153,30 @@ int pv_pid_parse_name(pv_spec_t *sp, str *in) sr_xavp_t *xavp_get_pids() { sr_xavp_t *list; - list = xavp_get(&pid_list,NULL); + list = xavp_get(&pid_list, NULL); - if(!list) counter = 0; + if(!list) + counter = 0; return list; } -int pv_pid_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) +int pv_pid_set(struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) { str name; sr_xavp_t *pid_root; sr_xavp_t *pid; - sr_xavp_t *new,*old=NULL; + sr_xavp_t *new, *old = NULL; sr_xavp_t *pid_xavp; sr_xval_t pid_val; - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) { + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) { LM_ERR("invalid variable name type\n"); return -1; } - if(pv_xbuff_new_xavp(&pid_xavp,val,&counter,'p')) { + if(pv_xbuff_new_xavp(&pid_xavp, val, &counter, 'p')) { LM_ERR("failed to create new value\n"); return -1; } @@ -179,7 +184,7 @@ int pv_pid_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) /* pid var name */ name = param->pvn.u.isname.name.s; - memset((void*)&pid_val,0,sizeof(sr_xval_t)); + memset((void *)&pid_val, 0, sizeof(sr_xval_t)); pid_root = xavp_get_pids(); @@ -187,9 +192,10 @@ int pv_pid_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) pid_val.type = SR_XTYPE_XAVP; pid_val.v.xavp = pid_xavp; - pid = xavp_add_xavp_value(&pid_list,&name,&pid_val,xavp_get_crt_list()); + pid = xavp_add_xavp_value( + &pid_list, &name, &pid_val, xavp_get_crt_list()); - if (!pid) + if(!pid) goto err; return 0; @@ -197,14 +203,14 @@ int pv_pid_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) pid = xavp_get_child(&pid_list, &name); - if (!pid) { + if(!pid) { pid_val.type = SR_XTYPE_XAVP; pid_val.v.xavp = pid_xavp; - new = xavp_add_value(&name,&pid_val,&pid_root->val.v.xavp); + new = xavp_add_value(&name, &pid_val, &pid_root->val.v.xavp); - if (!new) + if(!new) goto err; return 0; @@ -213,7 +219,7 @@ int pv_pid_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) old = pid->val.v.xavp; new = pid_xavp; - if (old) { + if(old) { xavp_destroy_list(&old); } @@ -228,39 +234,40 @@ int pv_pid_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) return -1; } -int pv_pid_get_value(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp) +int pv_pid_get_value( + struct sip_msg *msg, pv_param_t *param, pv_value_t *res, sr_xavp_t *avp) { static char _pv_xavp_buf[128]; str s; - if (!avp) return pv_get_null(msg,param,res); + if(!avp) + return pv_get_null(msg, param, res); switch(avp->val.type) { - case SR_XTYPE_NULL: - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_DATA: - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) + case SR_XTYPE_NULL: + return pv_get_null(msg, param, res); + break; + case SR_XTYPE_DATA: + if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data) < 0) + return pv_get_null(msg, param, res); + break; + case SR_XTYPE_XAVP: + case SR_XTYPE_STR: + case SR_XTYPE_TIME: + case SR_XTYPE_LONG: + case SR_XTYPE_LLONG: + LM_ERR("BUG: unexpected pid value\n"); + return pv_get_null(msg, param, res); + break; + default: return pv_get_null(msg, param, res); - break; - case SR_XTYPE_XAVP: - case SR_XTYPE_STR: - case SR_XTYPE_TIME: - case SR_XTYPE_LONG: - case SR_XTYPE_LLONG: - LM_ERR("BUG: unexpected pid value\n"); - return pv_get_null(msg, param, res); - break; - default: - return pv_get_null(msg, param, res); } s.s = _pv_xavp_buf; s.len = strlen(_pv_xavp_buf); return pv_get_strval(msg, param, res, &s); } -int pv_pid_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) +int pv_pid_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { str name; sr_xavp_t *pids_root; @@ -271,14 +278,14 @@ int pv_pid_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) ei_x_buff xbuff; - if(param==NULL) - { + if(param == NULL) { LM_ERR("bad parameters\n"); return -1; } - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) - return -1; + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) + return -1; /* pid name */ name = param->pvn.u.isname.name.s; @@ -287,58 +294,59 @@ int pv_pid_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) pids_root = xavp_get_pids(); if(!pids_root) { - return pv_get_null(msg,param,res); + return pv_get_null(msg, param, res); } - pid = xavp_get(&name,pids_root->val.v.xavp); - if (!pid) { - return pv_get_null(msg,param,res); + pid = xavp_get(&name, pids_root->val.v.xavp); + if(!pid) { + return pv_get_null(msg, param, res); } xavp = pid->val.v.xavp; - switch (xbuff_is_attr_set(attr)) { - case XBUFF_ATTR_TYPE: - return pv_get_strval(msg,param,res,&xbuff_types[XBUFF_TYPE_PID]); - break; - case XBUFF_ATTR_LENGTH: /* always 1 */ - return pv_get_uintval(msg,param,res,1); - break; - case XBUFF_ATTR_FORMAT: - /* + switch(xbuff_is_attr_set(attr)) { + case XBUFF_ATTR_TYPE: + return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_PID]); + break; + case XBUFF_ATTR_LENGTH: /* always 1 */ + return pv_get_uintval(msg, param, res, 1); + break; + case XBUFF_ATTR_FORMAT: + /* * Prints a term, in clear text, to the PV value pointed to by res. * It tries to resemble the term printing in the erlang shell. */ - ei_x_new_with_version(&xbuff); - if (xavp && xavp_encode(&xbuff,xavp,1)) { - ei_x_free(&xbuff); - return -1; - } else { - ei_x_encode_atom(&xbuff,"undefined"); - } - i = 1; - if (ei_s_print_term(&pid_fmt_buff,xbuff.buff,&i)<0) { - LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_new_with_version(&xbuff); + if(xavp && xavp_encode(&xbuff, xavp, 1)) { + ei_x_free(&xbuff); + return -1; + } else { + ei_x_encode_atom(&xbuff, "undefined"); + } + i = 1; + if(ei_s_print_term(&pid_fmt_buff, xbuff.buff, &i) < 0) { + LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_free(&xbuff); + return -1; + } + i = pv_get_strzval(msg, param, res, pid_fmt_buff); ei_x_free(&xbuff); - return -1; - } - i = pv_get_strzval(msg,param,res,pid_fmt_buff); - ei_x_free(&xbuff); - return i; + return i; } - if (!xavp) { - return pv_get_null(msg,param,res); + if(!xavp) { + return pv_get_null(msg, param, res); } - return pv_pid_get_value(msg,param,res,xavp); + return pv_pid_get_value(msg, param, res, xavp); } /* * free format buffer for tuple */ -void free_pid_fmt_buff() { - if (pid_fmt_buff) { +void free_pid_fmt_buff() +{ + if(pid_fmt_buff) { free(pid_fmt_buff); } pid_fmt_buff = 0; diff --git a/src/modules/erlang/pv_pid.h b/src/modules/erlang/pv_pid.h index bfeee69b652..301b5ae75b8 100644 --- a/src/modules/erlang/pv_pid.h +++ b/src/modules/erlang/pv_pid.h @@ -27,8 +27,8 @@ #include "../../core/pvar.h" int pv_pid_parse_name(pv_spec_t *sp, str *in); -int pv_pid_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val); -int pv_pid_get(struct sip_msg*, pv_param_t*, pv_value_t*); +int pv_pid_set(struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val); +int pv_pid_get(struct sip_msg *, pv_param_t *, pv_value_t *); sr_xavp_t *pv_pid_get_pid(str *name); diff --git a/src/modules/erlang/pv_ref.c b/src/modules/erlang/pv_ref.c index 5abff809c74..aaed747a809 100644 --- a/src/modules/erlang/pv_ref.c +++ b/src/modules/erlang/pv_ref.c @@ -30,13 +30,13 @@ #include "pv_ref.h" #include "pv_xbuff.h" -static str ref_list=str_init("[refs]"); +static str ref_list = str_init("[refs]"); static char *ref_fmt_buff = NULL; static int counter; sr_xavp_t *pv_ref_get_ref(str *name) { - return xavp_get_child(&ref_list,name); + return xavp_get_child(&ref_list, name); } int pv_ref_parse_name(pv_spec_t *sp, str *in) @@ -47,7 +47,7 @@ int pv_ref_parse_name(pv_spec_t *sp, str *in) str attr; int l; - if (in->s == NULL || in->len <= 0) + if(in->s == NULL || in->len <= 0) return -1; p = in->s; @@ -57,12 +57,13 @@ int pv_ref_parse_name(pv_spec_t *sp, str *in) /*pvi.type now defaults to 4, breaking the erlang module's type management*/ sp->pvp.pvi.type = 0; - while (is_in_str(p, in)) { - if (*p == '[' || *p== '=') + while(is_in_str(p, in)) { + if(*p == '[' || *p == '=') break; - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in var name %.*s at %d\n",STR_FMT(in),l); + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in var name %.*s at %d\n", STR_FMT(in), + l); goto error; } p++; @@ -71,20 +72,19 @@ int pv_ref_parse_name(pv_spec_t *sp, str *in) /* from in->s to p */ name.len = p - in->s; - if (pv_parse_avp_name(sp,&name)) + if(pv_parse_avp_name(sp, &name)) goto error; - if (is_in_str(p,in) && *p =='[') - { - idx.s=++p; + if(is_in_str(p, in) && *p == '[') { + idx.s = ++p; - while (is_in_str(p,in)) { - if (*p == ']' || *p == '=') + while(is_in_str(p, in)) { + if(*p == ']' || *p == '=') break; p++; } - if (is_in_str(p,in) && *p==']') { + if(is_in_str(p, in) && *p == ']') { idx.len = p - idx.s; LM_ERR("index isn't allowed for this variable\n"); @@ -92,25 +92,28 @@ int pv_ref_parse_name(pv_spec_t *sp, str *in) } p++; } else { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_NO_IDX); + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_NO_IDX); } - if (is_in_str(p,in) && *p =='=') - { + if(is_in_str(p, in) && *p == '=') { p++; - if (!is_in_str(p,in) || *p!='>') { - l = p-in->s; - LM_ERR("invalid operator (expected =>) for accessing attribute in token %.*s at position %d\n",STR_FMT(in),l); + if(!is_in_str(p, in) || *p != '>') { + l = p - in->s; + LM_ERR("invalid operator (expected =>) for accessing attribute in " + "token %.*s at position %d\n", + STR_FMT(in), l); goto error; } attr.s = ++p; - while (is_in_str(p,in)) { - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in attribute name in token %.*s at %d\n",STR_FMT(in),l); + while(is_in_str(p, in)) { + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in attribute name in token %.*s at " + "%d\n", + STR_FMT(in), l); goto error; } p++; @@ -118,25 +121,25 @@ int pv_ref_parse_name(pv_spec_t *sp, str *in) attr.len = p - attr.s; - if (attr.len > 0 ) { + if(attr.len > 0) { - if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_TYPE))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_TYPE); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_FORMAT))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_FORMAT); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_LENGTH))) { + if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_TYPE))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_TYPE); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_FORMAT))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_FORMAT); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_LENGTH))) { LM_ERR("attribute isn't supported for this variable\n"); goto error; } else { - LM_ERR("unknown attribute %.*s\n",STR_FMT(&attr)); + LM_ERR("unknown attribute %.*s\n", STR_FMT(&attr)); goto error; } } } - if (p < in->s + in->len) { - l = p-in->s; - LM_ERR("unexpected token in %.*s at %d\n",STR_FMT(in),l); + if(p < in->s + in->len) { + l = p - in->s; + LM_ERR("unexpected token in %.*s at %d\n", STR_FMT(in), l); goto error; } @@ -150,28 +153,30 @@ int pv_ref_parse_name(pv_spec_t *sp, str *in) sr_xavp_t *xavp_get_refs() { sr_xavp_t *list; - list = xavp_get(&ref_list,NULL); + list = xavp_get(&ref_list, NULL); - if(!list) counter = 0; + if(!list) + counter = 0; return list; } -int pv_ref_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) +int pv_ref_set(struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) { str name; sr_xavp_t *ref_root; sr_xavp_t *ref; - sr_xavp_t *new,*old=NULL; + sr_xavp_t *new, *old = NULL; sr_xavp_t *ref_xavp; sr_xval_t ref_val; - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) { + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) { LM_ERR("invalid variable name type\n"); return -1; } - if(pv_xbuff_new_xavp(&ref_xavp,val,&counter,'r')) { + if(pv_xbuff_new_xavp(&ref_xavp, val, &counter, 'r')) { LM_ERR("failed to create new value\n"); return -1; } @@ -179,7 +184,7 @@ int pv_ref_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) /* ref var name */ name = param->pvn.u.isname.name.s; - memset((void*)&ref_val,0,sizeof(sr_xval_t)); + memset((void *)&ref_val, 0, sizeof(sr_xval_t)); ref_root = xavp_get_refs(); @@ -187,9 +192,10 @@ int pv_ref_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) ref_val.type = SR_XTYPE_XAVP; ref_val.v.xavp = ref_xavp; - ref = xavp_add_xavp_value(&ref_list,&name,&ref_val,xavp_get_crt_list()); + ref = xavp_add_xavp_value( + &ref_list, &name, &ref_val, xavp_get_crt_list()); - if (!ref) + if(!ref) goto err; return 0; @@ -197,14 +203,14 @@ int pv_ref_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) ref = xavp_get_child(&ref_list, &name); - if (!ref) { + if(!ref) { ref_val.type = SR_XTYPE_XAVP; ref_val.v.xavp = ref_xavp; - new = xavp_add_value(&name,&ref_val,&ref_root->val.v.xavp); + new = xavp_add_value(&name, &ref_val, &ref_root->val.v.xavp); - if (!new) + if(!new) goto err; return 0; @@ -213,7 +219,7 @@ int pv_ref_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) old = ref->val.v.xavp; new = ref_xavp; - if (old) { + if(old) { xavp_destroy_list(&old); } @@ -228,39 +234,40 @@ int pv_ref_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) return -1; } -int pv_ref_get_value(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp) +int pv_ref_get_value( + struct sip_msg *msg, pv_param_t *param, pv_value_t *res, sr_xavp_t *avp) { static char _pv_xavp_buf[128]; str s; - if (!avp) return pv_get_null(msg,param,res); + if(!avp) + return pv_get_null(msg, param, res); switch(avp->val.type) { - case SR_XTYPE_NULL: - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_DATA: - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) + case SR_XTYPE_NULL: + return pv_get_null(msg, param, res); + break; + case SR_XTYPE_DATA: + if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data) < 0) + return pv_get_null(msg, param, res); + break; + case SR_XTYPE_XAVP: + case SR_XTYPE_STR: + case SR_XTYPE_TIME: + case SR_XTYPE_LONG: + case SR_XTYPE_LLONG: + LM_ERR("BUG: unexpected ref value\n"); + return pv_get_null(msg, param, res); + break; + default: return pv_get_null(msg, param, res); - break; - case SR_XTYPE_XAVP: - case SR_XTYPE_STR: - case SR_XTYPE_TIME: - case SR_XTYPE_LONG: - case SR_XTYPE_LLONG: - LM_ERR("BUG: unexpected ref value\n"); - return pv_get_null(msg, param, res); - break; - default: - return pv_get_null(msg, param, res); } s.s = _pv_xavp_buf; s.len = strlen(_pv_xavp_buf); return pv_get_strval(msg, param, res, &s); } -int pv_ref_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) +int pv_ref_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { str name; sr_xavp_t *refs_root; @@ -271,14 +278,14 @@ int pv_ref_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) ei_x_buff xbuff; - if(param==NULL) - { + if(param == NULL) { LM_ERR("bad parameters\n"); return -1; } - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) - return -1; + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) + return -1; /* ref name */ name = param->pvn.u.isname.name.s; @@ -287,58 +294,59 @@ int pv_ref_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) refs_root = xavp_get_refs(); if(!refs_root) { - return pv_get_null(msg,param,res); + return pv_get_null(msg, param, res); } - ref = xavp_get(&name,refs_root->val.v.xavp); - if (!ref) { - return pv_get_null(msg,param,res); + ref = xavp_get(&name, refs_root->val.v.xavp); + if(!ref) { + return pv_get_null(msg, param, res); } xavp = ref->val.v.xavp; - switch (xbuff_is_attr_set(attr)) { - case XBUFF_ATTR_TYPE: - return pv_get_strval(msg,param,res,&xbuff_types[XBUFF_TYPE_REF]); - break; - case XBUFF_ATTR_LENGTH: /* always 1 */ - return pv_get_uintval(msg,param,res,1); - break; - case XBUFF_ATTR_FORMAT: - /* + switch(xbuff_is_attr_set(attr)) { + case XBUFF_ATTR_TYPE: + return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_REF]); + break; + case XBUFF_ATTR_LENGTH: /* always 1 */ + return pv_get_uintval(msg, param, res, 1); + break; + case XBUFF_ATTR_FORMAT: + /* * Prints a term, in clear text, to the PV value pointed to by res. * It tries to resemble the term printing in the erlang shell. */ - ei_x_new_with_version(&xbuff); - if (xavp && xavp_encode(&xbuff,xavp,1)) { - ei_x_free(&xbuff); - return -1; - } else { - ei_x_encode_atom(&xbuff,"undefined"); - } - i = 1; - if (ei_s_print_term(&ref_fmt_buff,xbuff.buff,&i)<0) { - LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_new_with_version(&xbuff); + if(xavp && xavp_encode(&xbuff, xavp, 1)) { + ei_x_free(&xbuff); + return -1; + } else { + ei_x_encode_atom(&xbuff, "undefined"); + } + i = 1; + if(ei_s_print_term(&ref_fmt_buff, xbuff.buff, &i) < 0) { + LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_free(&xbuff); + return -1; + } + i = pv_get_strzval(msg, param, res, ref_fmt_buff); ei_x_free(&xbuff); - return -1; - } - i = pv_get_strzval(msg,param,res,ref_fmt_buff); - ei_x_free(&xbuff); - return i; + return i; } - if (!xavp) { - return pv_get_null(msg,param,res); + if(!xavp) { + return pv_get_null(msg, param, res); } - return pv_ref_get_value(msg,param,res,xavp); + return pv_ref_get_value(msg, param, res, xavp); } /* * free format buffer for tuple */ -void free_ref_fmt_buff() { - if (ref_fmt_buff) { +void free_ref_fmt_buff() +{ + if(ref_fmt_buff) { free(ref_fmt_buff); } ref_fmt_buff = 0; diff --git a/src/modules/erlang/pv_ref.h b/src/modules/erlang/pv_ref.h index 263ae863ca7..8e52e3d5792 100644 --- a/src/modules/erlang/pv_ref.h +++ b/src/modules/erlang/pv_ref.h @@ -27,8 +27,8 @@ #include "../../core/pvar.h" int pv_ref_parse_name(pv_spec_t *sp, str *in); -int pv_ref_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val); -int pv_ref_get(struct sip_msg*, pv_param_t*, pv_value_t*); +int pv_ref_set(struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val); +int pv_ref_get(struct sip_msg *, pv_param_t *, pv_value_t *); sr_xavp_t *pv_ref_get_ref(str *name); diff --git a/src/modules/erlang/pv_tuple.c b/src/modules/erlang/pv_tuple.c index 83fd01e902d..d25b98caea9 100644 --- a/src/modules/erlang/pv_tuple.c +++ b/src/modules/erlang/pv_tuple.c @@ -28,7 +28,7 @@ #include "pv_tuple.h" #include "pv_xbuff.h" -static str tuple_list=str_init("[tuples]"); +static str tuple_list = str_init("[tuples]"); static int counter; static char *tuple_fmt_buff = NULL; @@ -36,24 +36,26 @@ static char *tuple_fmt_buff = NULL; sr_xavp_t *xavp_get_tuples() { sr_xavp_t *list; - list = xavp_get(&tuple_list,NULL); + list = xavp_get(&tuple_list, NULL); - if(!list) counter = 0; + if(!list) + counter = 0; return list; } sr_xavp_t *pv_tuple_get_tuple(str *name) { - return xavp_get_child(&tuple_list,name); + return xavp_get_child(&tuple_list, name); } -int pv_tuple_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) +int pv_tuple_set( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) { str name; sr_xavp_t *tuples_root; sr_xavp_t *tuple; - sr_xavp_t *th,*new,*old,*prv=NULL; + sr_xavp_t *th, *new, *old, *prv = NULL; sr_xavp_t *tuple_xavp; sr_xavp_t *elem_xavp; sr_xval_t tuple_val; @@ -63,15 +65,16 @@ int pv_tuple_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va int idxf = 0; int attr = 0; - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) { + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) { LM_ERR("invalid variable name type\n"); return -1; } - memset((void*)&empty,0,sizeof(pv_value_t)); + memset((void *)&empty, 0, sizeof(pv_value_t)); empty.flags = PV_VAL_NULL; - memset((void*)&tuple_val,0,sizeof(sr_xval_t)); + memset((void *)&tuple_val, 0, sizeof(sr_xval_t)); /* list name */ name = param->pvn.u.isname.name.s; @@ -80,24 +83,25 @@ int pv_tuple_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va if(!tuples_root) { - if(pv_xbuff_new_xavp(&tuple_xavp,&empty,&counter,'t')) { + if(pv_xbuff_new_xavp(&tuple_xavp, &empty, &counter, 't')) { LM_ERR("failed to create new value\n"); return -1; } tuple_val.type = SR_XTYPE_XAVP; tuple_val.v.xavp = tuple_xavp; - tuple = xavp_add_xavp_value(&tuple_list,&name,&tuple_val,xavp_get_crt_list()); + tuple = xavp_add_xavp_value( + &tuple_list, &name, &tuple_val, xavp_get_crt_list()); - if (!tuple) + if(!tuple) goto err; } - tuple=xavp_get_child(&tuple_list, &name); + tuple = xavp_get_child(&tuple_list, &name); - if (!tuple) { + if(!tuple) { - if(pv_xbuff_new_xavp(&tuple_xavp,&empty,&counter,'t')) { + if(pv_xbuff_new_xavp(&tuple_xavp, &empty, &counter, 't')) { LM_ERR("failed to create new value\n"); return -1; } @@ -105,15 +109,15 @@ int pv_tuple_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va tuple_val.type = SR_XTYPE_XAVP; tuple_val.v.xavp = tuple_xavp; - tuple=xavp_add_value(&name,&tuple_val,&tuples_root->val.v.xavp); + tuple = xavp_add_value(&name, &tuple_val, &tuples_root->val.v.xavp); - if (!tuple) + if(!tuple) goto err; } th = tuple->val.v.xavp; - if(pv_xbuff_new_xavp(&elem_xavp,val,&counter,0)) { + if(pv_xbuff_new_xavp(&elem_xavp, val, &counter, 0)) { LM_ERR("failed to create new value\n"); return -1; } @@ -126,49 +130,48 @@ int pv_tuple_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va p.pvi.type = xbuff_fix_index(p.pvi.type); /* get the index */ - if(pv_get_spec_index(msg, &p, &idx, &idxf)) - { + if(pv_get_spec_index(msg, &p, &idx, &idxf)) { LM_ERR("invalid index\n"); return -1; } - if (xbuff_is_attr_set(attr)) { - LM_ERR("read only attribute %.*s\n",STR_FMT(&xbuff_attr_name(attr))); + if(xbuff_is_attr_set(attr)) { + LM_ERR("read only attribute %.*s\n", STR_FMT(&xbuff_attr_name(attr))); return -1; } /* prepend on list when no index */ - if (xbuff_is_no_index(attr)) { - if (th->val.type == SR_XTYPE_NULL) { + if(xbuff_is_no_index(attr)) { + if(th->val.type == SR_XTYPE_NULL) { th->val.type = SR_XTYPE_XAVP; th->val.v.xavp = elem_xavp; return 0; } else { - return xavp_add(elem_xavp,&th->val.v.xavp); + return xavp_add(elem_xavp, &th->val.v.xavp); } } - if (idxf == PV_IDX_ALL) { + if(idxf == PV_IDX_ALL) { xavp_destroy_list(&th->val.v.xavp); - if (elem_xavp->val.type == SR_XTYPE_NULL) { + if(elem_xavp->val.type == SR_XTYPE_NULL) { /* create empty list */ xavp_destroy_list(&elem_xavp); - memset((void*)&th->val,0,sizeof(sr_xval_t)); + memset((void *)&th->val, 0, sizeof(sr_xval_t)); th->val.type = SR_XTYPE_NULL; return 0; } else { - return xavp_add(elem_xavp,&th->val.v.xavp); + return xavp_add(elem_xavp, &th->val.v.xavp); } } /* set by index */ - old = xavp_get_nth(&th->val.v.xavp,idx,&prv); + old = xavp_get_nth(&th->val.v.xavp, idx, &prv); new = elem_xavp; - if (old) { + if(old) { new->next = old->next; - if (prv) { + if(prv) { prv->next = new; } else { new->next = old->next; @@ -177,7 +180,7 @@ int pv_tuple_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va old->next = NULL; xavp_destroy_list(&old); } else { - if (prv) { + if(prv) { prv->next = new; } else { th->val.v.xavp = new; @@ -194,67 +197,78 @@ int pv_tuple_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va return -1; } -int pv_tuple_get_value(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp) +int pv_tuple_get_value( + struct sip_msg *msg, pv_param_t *param, pv_value_t *res, sr_xavp_t *avp) { static char _pv_xavp_buf[128]; str s; - if (!avp) return pv_get_null(msg,param,res); + if(!avp) + return pv_get_null(msg, param, res); switch(avp->val.type) { - case SR_XTYPE_NULL: - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_LONG: - return pv_get_sintval(msg, param, res, avp->val.v.l); - break; - case SR_XTYPE_STR: - switch (avp->name.s[0]) { - case 'a': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) + case SR_XTYPE_NULL: + return pv_get_null(msg, param, res); + break; + case SR_XTYPE_LONG: + return pv_get_sintval(msg, param, res, avp->val.v.l); + break; + case SR_XTYPE_STR: + switch(avp->name.s[0]) { + case 'a': + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + break; + default: + return pv_get_strval(msg, param, res, &avp->val.v.s); + } + break; + case SR_XTYPE_TIME: + if(snprintf(_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t) + < 0) return pv_get_null(msg, param, res); break; - default: - return pv_get_strval(msg, param, res, &avp->val.v.s); - } - break; - case SR_XTYPE_TIME: - if(snprintf(_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t)<0) - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_LLONG: - if(snprintf(_pv_xavp_buf, 128, "%lld", avp->val.v.ll)<0) - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_XAVP: - switch(avp->name.s[0]) { - case 'l': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) + case SR_XTYPE_LLONG: + if(snprintf(_pv_xavp_buf, 128, "%lld", avp->val.v.ll) < 0) return pv_get_null(msg, param, res); break; - case 't': - default: - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) + case SR_XTYPE_XAVP: + switch(avp->name.s[0]) { + case 'l': + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + break; + case 't': + default: + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + } + break; + case SR_XTYPE_DATA: + if(avp->name.s[0] == 'p') { + if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data) + < 0) return pv_get_null(msg, param, res); - } - break; - case SR_XTYPE_DATA: - if (avp->name.s[0] == 'p') { - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) + } else if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.data) + < 0) return pv_get_null(msg, param, res); - } else if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) + break; + default: return pv_get_null(msg, param, res); - break; - default: - return pv_get_null(msg, param, res); } s.s = _pv_xavp_buf; s.len = strlen(_pv_xavp_buf); return pv_get_strval(msg, param, res, &s); } -int pv_tuple_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) +int pv_tuple_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { str name; pv_spec_t *nsp = NULL; @@ -265,30 +279,30 @@ int pv_tuple_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) sr_xavp_t *th; sr_xavp_t *xavp; pv_param_t p; - int idx=0; - int idxf=0; + int idx = 0; + int idxf = 0; int attr; - int i,count; + int i, count; ei_x_buff xbuff; - if(param==NULL) - { + if(param == NULL) { LM_ERR("bad parameters\n"); return -1; } - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) - return -1; + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) + return -1; - if( param->pvn.type == PV_NAME_PVAR) { - nsp = param->pvn.u.dname; + if(param->pvn.type == PV_NAME_PVAR) { + nsp = param->pvn.u.dname; } /* work on copy of index! */ p = *param; - if (nsp) { + if(nsp) { pvi = &nsp->pvp.pvi; pvn = &nsp->pvp.pvn; } else { @@ -304,87 +318,92 @@ int pv_tuple_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) pvi->type = xbuff_fix_index(pvi->type); /* get the index */ - if(pv_get_spec_index(msg, &p, &idx, &idxf)) - { + if(pv_get_spec_index(msg, &p, &idx, &idxf)) { LM_ERR("invalid index\n"); return -1; } tuples_root = xavp_get_tuples(); if(!tuples_root) { - return pv_get_null(msg,param,res); + return pv_get_null(msg, param, res); } - tuple = xavp_get(&name,tuples_root->val.v.xavp); - if (!tuple) { - return pv_get_null(msg,param,res); + tuple = xavp_get(&name, tuples_root->val.v.xavp); + if(!tuple) { + return pv_get_null(msg, param, res); } th = tuple->val.v.xavp; - switch (xbuff_is_attr_set(attr)) { - case XBUFF_ATTR_TYPE: - if (xbuff_is_no_index(attr)) { - return pv_get_strval(msg,param,res,&xbuff_types[XBUFF_TYPE_TUPLE]); - } else { - xavp = xavp_get_nth(&th->val.v.xavp,idx,NULL); - return pv_xbuff_get_type(msg,param,res,xavp); - } - break; - case XBUFF_ATTR_LENGTH: - xavp = xbuff_is_no_index(attr) ? th : xavp_get_nth(&th->val.v.xavp,idx,NULL); - if (xavp) { - count = xavp_get_count(xavp->val.v.xavp); - return pv_get_uintval(msg,param,res,(unsigned int)count); - } else { - return pv_get_null(msg,param,res); - } - break; - case XBUFF_ATTR_FORMAT: - /* + switch(xbuff_is_attr_set(attr)) { + case XBUFF_ATTR_TYPE: + if(xbuff_is_no_index(attr)) { + return pv_get_strval( + msg, param, res, &xbuff_types[XBUFF_TYPE_TUPLE]); + } else { + xavp = xavp_get_nth(&th->val.v.xavp, idx, NULL); + return pv_xbuff_get_type(msg, param, res, xavp); + } + break; + case XBUFF_ATTR_LENGTH: + xavp = xbuff_is_no_index(attr) + ? th + : xavp_get_nth(&th->val.v.xavp, idx, NULL); + if(xavp) { + count = xavp_get_count(xavp->val.v.xavp); + return pv_get_uintval(msg, param, res, (unsigned int)count); + } else { + return pv_get_null(msg, param, res); + } + break; + case XBUFF_ATTR_FORMAT: + /* * Prints a term, in clear text, to the PV value pointed to by res. * It tries to resemble the term printing in the erlang shell. */ - ei_x_new_with_version(&xbuff); - xavp = xbuff_is_no_index(attr) ? th : xavp_get_nth(&th->val.v.xavp,idx,NULL); - if (!xavp || xavp_encode(&xbuff,xavp,1)) { - ei_x_free(&xbuff); - return -1; - } - i = 1; - if (ei_s_print_term(&tuple_fmt_buff,xbuff.buff,&i)<0) { - LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_new_with_version(&xbuff); + xavp = xbuff_is_no_index(attr) + ? th + : xavp_get_nth(&th->val.v.xavp, idx, NULL); + if(!xavp || xavp_encode(&xbuff, xavp, 1)) { + ei_x_free(&xbuff); + return -1; + } + i = 1; + if(ei_s_print_term(&tuple_fmt_buff, xbuff.buff, &i) < 0) { + LM_ERR("BUG: xbuff[index] doesn't contain a valid term!\n"); + ei_x_free(&xbuff); + return -1; + } + i = pv_get_strzval(msg, param, res, tuple_fmt_buff); ei_x_free(&xbuff); - return -1; - } - i = pv_get_strzval(msg,param,res,tuple_fmt_buff); - ei_x_free(&xbuff); - return i; + return i; } /* get whole list */ - if ((idxf == PV_IDX_ALL) || xbuff_is_no_index(attr)) { - return pv_tuple_get_value(msg,param,res,tuple); + if((idxf == PV_IDX_ALL) || xbuff_is_no_index(attr)) { + return pv_tuple_get_value(msg, param, res, tuple); } - if (th->val.type == SR_XTYPE_NULL) { - return pv_get_null(msg,param,res); + if(th->val.type == SR_XTYPE_NULL) { + return pv_get_null(msg, param, res); } /* get by idx */ - xavp = xavp_get_nth(&th->val.v.xavp,idx,NULL); - if (!xavp) { - return pv_get_null(msg,param,res); + xavp = xavp_get_nth(&th->val.v.xavp, idx, NULL); + if(!xavp) { + return pv_get_null(msg, param, res); } - return pv_tuple_get_value(msg,param,res,xavp); + return pv_tuple_get_value(msg, param, res, xavp); } /* * free format buffer for tuple */ -void free_tuple_fmt_buff() { - if (tuple_fmt_buff) { +void free_tuple_fmt_buff() +{ + if(tuple_fmt_buff) { free(tuple_fmt_buff); } tuple_fmt_buff = 0; diff --git a/src/modules/erlang/pv_tuple.h b/src/modules/erlang/pv_tuple.h index 986e0a0ec51..939d3a7df0f 100644 --- a/src/modules/erlang/pv_tuple.h +++ b/src/modules/erlang/pv_tuple.h @@ -27,8 +27,8 @@ #include "../../core/pvar.h" #include "../../core/xavp.h" -int pv_tuple_set(struct sip_msg*, pv_param_t*, int, pv_value_t*); -int pv_tuple_get(struct sip_msg*, pv_param_t*, pv_value_t*); +int pv_tuple_set(struct sip_msg *, pv_param_t *, int, pv_value_t *); +int pv_tuple_get(struct sip_msg *, pv_param_t *, pv_value_t *); sr_xavp_t *pv_tuple_get_tuple(str *name); diff --git a/src/modules/erlang/pv_xbuff.c b/src/modules/erlang/pv_xbuff.c index 1ea5c8331c1..2abb2eab43b 100644 --- a/src/modules/erlang/pv_xbuff.c +++ b/src/modules/erlang/pv_xbuff.c @@ -28,30 +28,20 @@ #include "pv_xbuff.h" -str xbuff_attributes[] = { - STR_STATIC_INIT("type"), - STR_STATIC_INIT("format"), - STR_STATIC_INIT("length"), - STR_NULL -}; - -str xbuff_types[] = { - STR_STATIC_INIT("atom"), - STR_STATIC_INIT("integer"), - STR_STATIC_INIT("string"), - STR_STATIC_INIT("tuple"), - STR_STATIC_INIT("list"), - STR_STATIC_INIT("pid"), - STR_STATIC_INIT("ref"), - STR_NULL -}; +str xbuff_attributes[] = {STR_STATIC_INIT("type"), STR_STATIC_INIT("format"), + STR_STATIC_INIT("length"), STR_NULL}; + +str xbuff_types[] = {STR_STATIC_INIT("atom"), STR_STATIC_INIT("integer"), + STR_STATIC_INIT("string"), STR_STATIC_INIT("tuple"), + STR_STATIC_INIT("list"), STR_STATIC_INIT("pid"), STR_STATIC_INIT("ref"), + STR_NULL}; /** * atom,tuple,xbuff & list regex */ regex_t xbuff_type_re = {0}; -static str xbuff_list=str_init("[xbuffs]"); +static str xbuff_list = str_init("[xbuffs]"); static int counter; static char *xbuff_fmt_buff = NULL; @@ -61,16 +51,17 @@ void xbuff_data_free(void *p, sr_xavp_sfree_f sfree); sr_xavp_t *xavp_get_xbuffs() { sr_xavp_t *list; - list = xavp_get(&xbuff_list,NULL); + list = xavp_get(&xbuff_list, NULL); - if(!list) counter = 0; + if(!list) + counter = 0; return list; } sr_xavp_t *pv_xbuff_get_xbuff(str *name) { - return xavp_get_child(&xbuff_list,name); + return xavp_get_child(&xbuff_list, name); } sr_xavp_t *xbuff_new(str *name) @@ -79,28 +70,28 @@ sr_xavp_t *xbuff_new(str *name) sr_xavp_t *xbuff; sr_xval_t xbuff_val; - memset((void*)&xbuff_val,0,sizeof(sr_xval_t)); + memset((void *)&xbuff_val, 0, sizeof(sr_xval_t)); xbuff_val.type = SR_XTYPE_NULL; xbuffs_root = xavp_get_xbuffs(); - if(!xbuffs_root) - { - xbuffs_root = xavp_add_xavp_value(&xbuff_list,name,&xbuff_val,xavp_get_crt_list()); - if (!xbuffs_root){ - LM_ERR("cannot create xbuffs_root \n"); - return NULL; - } + if(!xbuffs_root) { + xbuffs_root = xavp_add_xavp_value( + &xbuff_list, name, &xbuff_val, xavp_get_crt_list()); + if(!xbuffs_root) { + LM_ERR("cannot create xbuffs_root \n"); + return NULL; + } } xbuff = xavp_get_child(&xbuff_list, name); - if (!xbuff) { + if(!xbuff) { xbuff_val.type = SR_XTYPE_NULL; xbuff_val.v.xavp = NULL; - xbuff=xavp_add_value(name,&xbuff_val,&xbuffs_root->val.v.xavp); + xbuff = xavp_add_value(name, &xbuff_val, &xbuffs_root->val.v.xavp); } return xbuff; @@ -111,14 +102,15 @@ sr_xavp_t *xbuff_new(str *name) */ int compile_xbuff_re() { - char *pattern = "^<<\\(tuple\\|list\\|atom\\|pid\\|ref\\):\\(0x[[:xdigit:]]\\+\\)>>$"; + char *pattern = "^<<\\(tuple\\|list\\|atom\\|pid\\|ref\\):\\(0x[[:xdigit:]]" + "\\+\\)>>$"; size_t bfsz = 128; char errbuff[128]; int e; - if((e=regcomp(&xbuff_type_re,pattern,0))) { - regerror(e,&xbuff_type_re,errbuff,bfsz); - LM_ERR("failed to compile pattern '%s' error: %s\n",pattern,errbuff); + if((e = regcomp(&xbuff_type_re, pattern, 0))) { + regerror(e, &xbuff_type_re, errbuff, bfsz); + LM_ERR("failed to compile pattern '%s' error: %s\n", pattern, errbuff); return -1; } @@ -139,41 +131,42 @@ int xbuff_match_type_re(str *s, xbuff_type_t *type, sr_xavp_t **addr) matches[0].rm_so = 0; matches[0].rm_eo = s->len; - e = regexec(&xbuff_type_re,s->s,nmatch,matches,REG_STARTEND); + e = regexec(&xbuff_type_re, s->s, nmatch, matches, REG_STARTEND); - if (e == 0) { + if(e == 0) { - tname.s = s->s + matches[1].rm_so; + tname.s = s->s + matches[1].rm_so; tname.len = matches[1].rm_eo - matches[1].rm_so; - a.s = s->s + matches[2].rm_so; + a.s = s->s + matches[2].rm_so; a.len = matches[2].rm_eo - matches[1].rm_so; - if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_ATOM])) { + if(STR_EQ(tname, xbuff_types[XBUFF_TYPE_ATOM])) { t = XBUFF_TYPE_ATOM; - } else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_LIST])) { + } else if(STR_EQ(tname, xbuff_types[XBUFF_TYPE_LIST])) { t = XBUFF_TYPE_LIST; - } else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_TUPLE])) { + } else if(STR_EQ(tname, xbuff_types[XBUFF_TYPE_TUPLE])) { t = XBUFF_TYPE_TUPLE; - } else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_PID])) { + } else if(STR_EQ(tname, xbuff_types[XBUFF_TYPE_PID])) { t = XBUFF_TYPE_PID; - } else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_REF])) { + } else if(STR_EQ(tname, xbuff_types[XBUFF_TYPE_REF])) { t = XBUFF_TYPE_REF; } else { LM_ERR("BUG: unknown xbuff type"); return -1; } - if(type) *type = t; + if(type) + *type = t; - if (addr) - sscanf(a.s,"%lx>>",(long unsigned int *)addr); + if(addr) + sscanf(a.s, "%lx>>", (long unsigned int *)addr); return 0; - } else if (e != REG_NOMATCH) { - regerror(e,&xbuff_type_re,errbuff,bfsz); - LM_ERR("regexec error: %s\n",errbuff); + } else if(e != REG_NOMATCH) { + regerror(e, &xbuff_type_re, errbuff, bfsz); + LM_ERR("regexec error: %s\n", errbuff); } return -1; @@ -181,8 +174,8 @@ int xbuff_match_type_re(str *s, xbuff_type_t *type, sr_xavp_t **addr) int is_pv_xbuff_valid_char(char c) { - if((c>='0' && c<='9') || (c>='a' && c<='z') || (c>='A' && c<='Z') - || (c=='_')) + if((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') + || (c >= 'A' && c <= 'Z') || (c == '_')) return 1; return 0; } @@ -195,7 +188,7 @@ int pv_xbuff_parse_name(pv_spec_t *sp, str *in) str attr; int l; - if (in->s == NULL || in->len <= 0) + if(in->s == NULL || in->len <= 0) return -1; p = in->s; @@ -205,12 +198,13 @@ int pv_xbuff_parse_name(pv_spec_t *sp, str *in) /*pvi.type now defaults to 4, breaking the erlang module's type management*/ sp->pvp.pvi.type = 0; - while (is_in_str(p, in)) { - if (*p == '[' || *p== '=') + while(is_in_str(p, in)) { + if(*p == '[' || *p == '=') break; - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in var name %.*s at %d\n",STR_FMT(in),l); + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in var name %.*s at %d\n", STR_FMT(in), + l); goto error; } p++; @@ -219,46 +213,48 @@ int pv_xbuff_parse_name(pv_spec_t *sp, str *in) /* from in->s to p */ name.len = p - in->s; - if (pv_parse_avp_name(sp,&name)) + if(pv_parse_avp_name(sp, &name)) goto error; - if (is_in_str(p,in) && *p =='[') - { - idx.s=++p; + if(is_in_str(p, in) && *p == '[') { + idx.s = ++p; - while (is_in_str(p,in)) { - if (*p == ']' || *p == '=') + while(is_in_str(p, in)) { + if(*p == ']' || *p == '=') break; p++; } - if (is_in_str(p,in) && *p==']') { + if(is_in_str(p, in) && *p == ']') { idx.len = p - idx.s; - if (pv_parse_index(sp,&idx)) + if(pv_parse_index(sp, &idx)) goto error; } p++; } else { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_NO_IDX); + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_NO_IDX); } - if (is_in_str(p,in) && *p =='=') - { + if(is_in_str(p, in) && *p == '=') { p++; - if (!is_in_str(p,in) || *p!='>') { - l = p-in->s; - LM_ERR("invalid operator (expected =>) for accessing attribute in token %.*s at position %d\n",STR_FMT(in),l); + if(!is_in_str(p, in) || *p != '>') { + l = p - in->s; + LM_ERR("invalid operator (expected =>) for accessing attribute in " + "token %.*s at position %d\n", + STR_FMT(in), l); goto error; } attr.s = ++p; - while (is_in_str(p,in)) { - if (!is_pv_xbuff_valid_char(*p)) { - l = p-in->s; - LM_ERR("invalid character in attribute name in token %.*s at %d\n",STR_FMT(in),l); + while(is_in_str(p, in)) { + if(!is_pv_xbuff_valid_char(*p)) { + l = p - in->s; + LM_ERR("invalid character in attribute name in token %.*s at " + "%d\n", + STR_FMT(in), l); goto error; } p++; @@ -266,29 +262,30 @@ int pv_xbuff_parse_name(pv_spec_t *sp, str *in) attr.len = p - attr.s; - if (attr.len > 0 ) { + if(attr.len > 0) { - if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_TYPE))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_TYPE); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_FORMAT))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_FORMAT); - } else if (STR_EQ(attr,xbuff_attr_name(XBUFF_ATTR_LENGTH))) { - xbuff_set_attr_flag(sp->pvp.pvi.type,XBUFF_ATTR_LENGTH); + if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_TYPE))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_TYPE); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_FORMAT))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_FORMAT); + } else if(STR_EQ(attr, xbuff_attr_name(XBUFF_ATTR_LENGTH))) { + xbuff_set_attr_flag(sp->pvp.pvi.type, XBUFF_ATTR_LENGTH); } else { - LM_ERR("unknown attribute %.*s\n",STR_FMT(&attr)); + LM_ERR("unknown attribute %.*s\n", STR_FMT(&attr)); goto error; } - if (sp->pvp.pvi.type & PV_IDX_ALL) { - LM_ERR("index [*] (all) isn't compatible with attribute %.*s\n",STR_FMT(&attr)); + if(sp->pvp.pvi.type & PV_IDX_ALL) { + LM_ERR("index [*] (all) isn't compatible with attribute %.*s\n", + STR_FMT(&attr)); goto error; } } } - if (p < in->s + in->len) { - l = p-in->s; - LM_ERR("unexpected token in %.*s at %d\n",STR_FMT(in),l); + if(p < in->s + in->len) { + l = p - in->s; + LM_ERR("unexpected token in %.*s at %d\n", STR_FMT(in), l); goto error; } @@ -300,7 +297,8 @@ int pv_xbuff_parse_name(pv_spec_t *sp, str *in) } -int pv_xbuff_new_xavp(sr_xavp_t **new, pv_value_t *pval, int *counter, char prefix) +int pv_xbuff_new_xavp( + sr_xavp_t **new, pv_value_t *pval, int *counter, char prefix) { char s[101]; str name; @@ -309,96 +307,101 @@ int pv_xbuff_new_xavp(sr_xavp_t **new, pv_value_t *pval, int *counter, char pref sr_xval_t nval; xbuff_type_t type; - if (!new) return -1; + if(!new) + return -1; - memset((void*)&nval,0,sizeof(sr_xval_t)); + memset((void *)&nval, 0, sizeof(sr_xval_t)); - if (pval->flags&PV_VAL_NULL) { + if(pval->flags & PV_VAL_NULL) { nval.type = SR_XTYPE_NULL; s[0] = prefix ? prefix : 'n'; - } else if (pval->flags&PV_VAL_INT) { + } else if(pval->flags & PV_VAL_INT) { nval.type = SR_XTYPE_LONG; nval.v.l = pval->ri; s[0] = prefix ? prefix : 'i'; - } else if (pval->flags&PV_VAL_STR) { + } else if(pval->flags & PV_VAL_STR) { /* check what it is */ - if (xbuff_match_type_re(&pval->rs,&type,&xavp)) { + if(xbuff_match_type_re(&pval->rs, &type, &xavp)) { nval.type = SR_XTYPE_STR; nval.v.s = pval->rs; s[0] = prefix ? prefix : 's'; } else { - switch (type) { - case XBUFF_TYPE_ATOM: - s[0] = 'a'; - nval = xavp->val; - break; - case XBUFF_TYPE_LIST: - s[0] = 'l'; - /* copy tree */ - cxavp = xbuff_copy_xavp(xavp); - - if (!cxavp) + switch(type) { + case XBUFF_TYPE_ATOM: + s[0] = 'a'; + nval = xavp->val; + break; + case XBUFF_TYPE_LIST: + s[0] = 'l'; + /* copy tree */ + cxavp = xbuff_copy_xavp(xavp); + + if(!cxavp) + return -1; + + nval = cxavp->val; + + /* free overhead */ + cxavp->next = NULL; + cxavp->val.v.xavp = NULL; + xavp_destroy_list(&cxavp); + + break; + case XBUFF_TYPE_TUPLE: + s[0] = 't'; + + /* copy tree */ + cxavp = xbuff_copy_xavp(xavp); + + if(!cxavp) + return -1; + + nval = cxavp->val; + + /* free overhead */ + cxavp->next = NULL; + cxavp->val.v.xavp = NULL; + xavp_destroy_list(&cxavp); + break; + case XBUFF_TYPE_PID: + s[0] = 'p'; + nval.type = SR_XTYPE_DATA; + nval.v.data = (sr_data_t *)shm_malloc( + sizeof(sr_data_t) + sizeof(erlang_pid)); + if(!nval.v.data) { + LM_ERR("not enough shared memory\n"); + return -1; + } + memcpy((void *)nval.v.data, (void *)xavp, + sizeof(sr_data_t) + sizeof(erlang_pid)); + break; + case XBUFF_TYPE_REF: + s[0] = 'r'; + nval.type = SR_XTYPE_DATA; + nval.v.data = (sr_data_t *)shm_malloc( + sizeof(sr_data_t) + sizeof(erlang_ref)); + if(!nval.v.data) { + LM_ERR("not enough shared memory\n"); + return -1; + } + memcpy((void *)nval.v.data, (void *)xavp, + sizeof(sr_data_t) + sizeof(erlang_ref)); + break; + case XBUFF_TYPE_INT: + case XBUFF_TYPE_STR: + default: + LM_ERR("BUG: unexpected XBUFF type!\n"); return -1; - - nval = cxavp->val; - - /* free overhead */ - cxavp->next = NULL; - cxavp->val.v.xavp = NULL; - xavp_destroy_list(&cxavp); - - break; - case XBUFF_TYPE_TUPLE: - s[0] = 't'; - - /* copy tree */ - cxavp = xbuff_copy_xavp(xavp); - - if (!cxavp) - return -1; - - nval = cxavp->val; - - /* free overhead */ - cxavp->next = NULL; - cxavp->val.v.xavp = NULL; - xavp_destroy_list(&cxavp); - break; - case XBUFF_TYPE_PID: - s[0] = 'p'; - nval.type = SR_XTYPE_DATA; - nval.v.data = (sr_data_t*)shm_malloc(sizeof(sr_data_t)+sizeof(erlang_pid)); - if (!nval.v.data) { - LM_ERR("not enough shared memory\n"); - return -1; - } - memcpy((void*)nval.v.data,(void*)xavp,sizeof(sr_data_t)+sizeof(erlang_pid)); - break; - case XBUFF_TYPE_REF: - s[0] = 'r'; - nval.type = SR_XTYPE_DATA; - nval.v.data = (sr_data_t*)shm_malloc(sizeof(sr_data_t)+sizeof(erlang_ref)); - if (!nval.v.data) { - LM_ERR("not enough shared memory\n"); - return -1; - } - memcpy((void*)nval.v.data,(void*)xavp,sizeof(sr_data_t)+sizeof(erlang_ref)); - break; - case XBUFF_TYPE_INT: - case XBUFF_TYPE_STR: - default: - LM_ERR("BUG: unexpected XBUFF type!\n"); - return -1; } } } name.s = s; - name.len = snprintf(s+1,99,"%d",(*counter)++) + 1; + name.len = snprintf(s + 1, 99, "%d", (*counter)++) + 1; - cxavp = xavp_new_value(&name,&nval); + cxavp = xavp_new_value(&name, &nval); - if (!cxavp) { + if(!cxavp) { return -1; } @@ -407,47 +410,52 @@ int pv_xbuff_new_xavp(sr_xavp_t **new, pv_value_t *pval, int *counter, char pref return 0; } -int pv_xbuff_get_type(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp) +int pv_xbuff_get_type( + struct sip_msg *msg, pv_param_t *param, pv_value_t *res, sr_xavp_t *avp) { - if (!avp) return pv_get_null(msg,param,res); - - switch(avp->name.s[0]){ - case 'n': - return pv_get_null(msg,param,res); - break; - case 'i': - return pv_get_strval(msg,param,res,&xbuff_types[XBUFF_TYPE_INT]); - break; - case 'l': - return pv_get_strval(msg,param,res,&xbuff_types[XBUFF_TYPE_LIST]); - break; - case 'a': - return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_ATOM]); - break; - case 's': - return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_STR]); - break; - case 't': - return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_TUPLE]); - break; - case 'p': - return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_PID]); - break; - case 'r': - return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_REF]); - break; + if(!avp) + return pv_get_null(msg, param, res); + + switch(avp->name.s[0]) { + case 'n': + return pv_get_null(msg, param, res); + break; + case 'i': + return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_INT]); + break; + case 'l': + return pv_get_strval( + msg, param, res, &xbuff_types[XBUFF_TYPE_LIST]); + break; + case 'a': + return pv_get_strval( + msg, param, res, &xbuff_types[XBUFF_TYPE_ATOM]); + break; + case 's': + return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_STR]); + break; + case 't': + return pv_get_strval( + msg, param, res, &xbuff_types[XBUFF_TYPE_TUPLE]); + break; + case 'p': + return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_PID]); + break; + case 'r': + return pv_get_strval(msg, param, res, &xbuff_types[XBUFF_TYPE_REF]); + break; } return pv_get_null(msg, param, res); } -int pv_xbuff_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* val) +int pv_xbuff_set( + struct sip_msg *msg, pv_param_t *param, int op, pv_value_t *val) { str name; sr_xavp_t *xbuffs_root; sr_xavp_t *xbuff; - sr_xavp_t *new,*old,*prv=NULL; + sr_xavp_t *new, *old, *prv = NULL; sr_xavp_t *xbuff_xavp; sr_xval_t xbuff_val; pv_param_t p; @@ -455,7 +463,8 @@ int pv_xbuff_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va int idxf = 0; int attr = 0; - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) { + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) { LM_ERR("invalid variable name type\n"); return -1; } @@ -467,31 +476,32 @@ int pv_xbuff_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va if(!xbuffs_root) { - memset((void*)&xbuff_val,0,sizeof(sr_xval_t)); + memset((void *)&xbuff_val, 0, sizeof(sr_xval_t)); xbuff_val.type = SR_XTYPE_NULL; - xbuff = xavp_add_xavp_value(&xbuff_list,&name,&xbuff_val,xavp_get_crt_list()); + xbuff = xavp_add_xavp_value( + &xbuff_list, &name, &xbuff_val, xavp_get_crt_list()); - if (!xbuff) + if(!xbuff) goto err; } - if(pv_xbuff_new_xavp(&xbuff_xavp,val,&counter,0)) { + if(pv_xbuff_new_xavp(&xbuff_xavp, val, &counter, 0)) { LM_ERR("failed to create new value\n"); return -1; } - xbuff=xavp_get_child(&xbuff_list, &name); + xbuff = xavp_get_child(&xbuff_list, &name); - if (!xbuff) { + if(!xbuff) { xbuff_val.type = SR_XTYPE_NULL; xbuff_val.v.xavp = NULL; - xbuff=xavp_add_value(&name,&xbuff_val,&xbuffs_root->val.v.xavp); + xbuff = xavp_add_value(&name, &xbuff_val, &xbuffs_root->val.v.xavp); - if (!xbuff) + if(!xbuff) goto err; } @@ -503,76 +513,75 @@ int pv_xbuff_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va p.pvi.type = xbuff_fix_index(p.pvi.type); /* get the index */ - if(pv_get_spec_index(msg, &p, &idx, &idxf)) - { + if(pv_get_spec_index(msg, &p, &idx, &idxf)) { LM_ERR("invalid index\n"); return -1; } - if (xbuff_is_attr_set(attr)) { - LM_ERR("read only attribute %.*s\n",STR_FMT(&xbuff_attr_name(attr))); + if(xbuff_is_attr_set(attr)) { + LM_ERR("read only attribute %.*s\n", STR_FMT(&xbuff_attr_name(attr))); return -1; } /* check container type */ - if (xbuff->val.v.xavp == NULL) { + if(xbuff->val.v.xavp == NULL) { xbuff->val.type = SR_XTYPE_XAVP; xbuff->val.v.xavp = xbuff_xavp; return 0; } - switch (xbuff->val.v.xavp->name.s[0]) { - case 'l': /* list */ - case 't': /* tuple */ + switch(xbuff->val.v.xavp->name.s[0]) { + case 'l': /* list */ + case 't': /* tuple */ - /* prepend on list when no index */ - if (xbuff_is_no_index(attr)) { - return xavp_add(xbuff_xavp,&xbuff->val.v.xavp); - } + /* prepend on list when no index */ + if(xbuff_is_no_index(attr)) { + return xavp_add(xbuff_xavp, &xbuff->val.v.xavp); + } - /* reset list given value */ - if (idxf == PV_IDX_ALL) { - xavp_destroy_list(&xbuff->val.v.xavp); - if (xbuff_xavp->val.type == SR_XTYPE_NULL) { - /* create empty list/tuple */ - xavp_destroy_list(&xbuff_xavp); - return 0; - } else { - return xavp_add(xbuff_xavp,&xbuff->val.v.xavp); + /* reset list given value */ + if(idxf == PV_IDX_ALL) { + xavp_destroy_list(&xbuff->val.v.xavp); + if(xbuff_xavp->val.type == SR_XTYPE_NULL) { + /* create empty list/tuple */ + xavp_destroy_list(&xbuff_xavp); + return 0; + } else { + return xavp_add(xbuff_xavp, &xbuff->val.v.xavp); + } } - } - /* set by index */ - old = xavp_get_nth(&xbuff->val.v.xavp,idx,&prv); - new = xbuff_xavp; + /* set by index */ + old = xavp_get_nth(&xbuff->val.v.xavp, idx, &prv); + new = xbuff_xavp; - if (old) { - new->next = old->next; - if (prv) { - prv->next = new; - } else { + if(old) { new->next = old->next; - xbuff->val.v.xavp = new; - } - old->next = NULL; - xavp_destroy_list(&old); - } else { - if (prv) { - prv->next = new; + if(prv) { + prv->next = new; + } else { + new->next = old->next; + xbuff->val.v.xavp = new; + } + old->next = NULL; + xavp_destroy_list(&old); } else { - xbuff->val.v.xavp = new; + if(prv) { + prv->next = new; + } else { + xbuff->val.v.xavp = new; + } } - } - break; - case 'n': /* null (empty) */ - case 's': /* string */ - case 'a': /* atom */ - case 'i': /* integer */ - default: /* default */ - xavp_destroy_list(&xbuff->val.v.xavp); - xbuff->val.v.xavp = xbuff_xavp; - break; + break; + case 'n': /* null (empty) */ + case 's': /* string */ + case 'a': /* atom */ + case 'i': /* integer */ + default: /* default */ + xavp_destroy_list(&xbuff->val.v.xavp); + xbuff->val.v.xavp = xbuff_xavp; + break; } return 0; @@ -584,79 +593,93 @@ int pv_xbuff_set(struct sip_msg* msg, pv_param_t* param, int op, pv_value_t* va return -1; } -int pv_xbuff_get_value(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp) +int pv_xbuff_get_value( + struct sip_msg *msg, pv_param_t *param, pv_value_t *res, sr_xavp_t *avp) { static char _pv_xavp_buf[128]; str s; - if (!avp) return pv_get_null(msg,param,res); + if(!avp) + return pv_get_null(msg, param, res); switch(avp->val.type) { - case SR_XTYPE_NULL: - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_LONG: - return pv_get_sintval(msg, param, res, avp->val.v.l); - break; - case SR_XTYPE_STR: - switch (avp->name.s[0]) { - case 'a': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) - return pv_get_null(msg, param, res); - break; - default: - return pv_get_strval(msg, param, res, &avp->val.v.s); - } - break; - case SR_XTYPE_TIME: - if(snprintf(_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t)<0) - return pv_get_null(msg, param, res); - break; - case SR_XTYPE_LLONG: - if(snprintf(_pv_xavp_buf, 128, "%lld", avp->val.v.ll)<0) + case SR_XTYPE_NULL: return pv_get_null(msg, param, res); - break; - case SR_XTYPE_DATA: - switch (avp->name.s[0]) { - case 'p': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) - return pv_get_null(msg, param, res); break; - case 'r': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) - return pv_get_null(msg, param, res); + case SR_XTYPE_LONG: + return pv_get_sintval(msg, param, res, avp->val.v.l); break; - default: - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.data)<0) + case SR_XTYPE_STR: + switch(avp->name.s[0]) { + case 'a': + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + break; + default: + return pv_get_strval(msg, param, res, &avp->val.v.s); + } + break; + case SR_XTYPE_TIME: + if(snprintf(_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t) + < 0) return pv_get_null(msg, param, res); - } - break; - case SR_XTYPE_XAVP: - switch(avp->name.s[0]) { - case 't': - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) + break; + case SR_XTYPE_LLONG: + if(snprintf(_pv_xavp_buf, 128, "%lld", avp->val.v.ll) < 0) return pv_get_null(msg, param, res); break; - case 'l': + case SR_XTYPE_DATA: + switch(avp->name.s[0]) { + case 'p': + if(snprintf( + _pv_xavp_buf, 128, "<>", avp->val.v.data) + < 0) + return pv_get_null(msg, param, res); + break; + case 'r': + if(snprintf( + _pv_xavp_buf, 128, "<>", avp->val.v.data) + < 0) + return pv_get_null(msg, param, res); + break; + default: + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.data) + < 0) + return pv_get_null(msg, param, res); + } + break; + case SR_XTYPE_XAVP: + switch(avp->name.s[0]) { + case 't': + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + break; + case 'l': + default: + if(snprintf(_pv_xavp_buf, 128, "<>", + avp->val.v.xavp) + < 0) + return pv_get_null(msg, param, res); + // break; + // default: + // LM_ERR("unexpected type!\n"); + // return pv_get_null(msg, param, res); + } + break; default: - if(snprintf(_pv_xavp_buf, 128, "<>", avp->val.v.xavp)<0) - return pv_get_null(msg, param, res); -// break; -// default: -// LM_ERR("unexpected type!\n"); -// return pv_get_null(msg, param, res); - } - break; - default: - return pv_get_null(msg, param, res); + return pv_get_null(msg, param, res); } s.s = _pv_xavp_buf; s.len = strlen(_pv_xavp_buf); return pv_get_strval(msg, param, res, &s); } -int pv_xbuff_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) +int pv_xbuff_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { str name; pv_spec_t *nsp = NULL; @@ -666,30 +689,30 @@ int pv_xbuff_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) sr_xavp_t *xbuff; sr_xavp_t *xavp; pv_param_t p; - int idx=0; - int idxf=0; + int idx = 0; + int idxf = 0; int attr; - int i,count; + int i, count; ei_x_buff x_buff; - if(param==NULL) - { + if(param == NULL) { LM_ERR("bad parameters\n"); return -1; } - if (param->pvn.type != PV_NAME_INTSTR || !(param->pvn.u.isname.type & AVP_NAME_STR)) - return -1; + if(param->pvn.type != PV_NAME_INTSTR + || !(param->pvn.u.isname.type & AVP_NAME_STR)) + return -1; - if( param->pvn.type == PV_NAME_PVAR) { - nsp = param->pvn.u.dname; + if(param->pvn.type == PV_NAME_PVAR) { + nsp = param->pvn.u.dname; } /* work on copy of index! */ p = *param; - if (nsp) { + if(nsp) { pvi = &nsp->pvp.pvi; pvn = &nsp->pvp.pvn; } else { @@ -705,99 +728,98 @@ int pv_xbuff_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) pvi->type = xbuff_fix_index(pvi->type); /* get the index */ - if(pv_get_spec_index(msg, &p, &idx, &idxf)) - { + if(pv_get_spec_index(msg, &p, &idx, &idxf)) { LM_ERR("invalid index\n"); return -1; } xbuffs_root = xavp_get_xbuffs(); if(!xbuffs_root) { - return pv_get_null(msg,param,res); + return pv_get_null(msg, param, res); } - xbuff = xavp_get(&name,xbuffs_root->val.v.xavp); - if (!xbuff) { - return pv_get_null(msg,param,res); + xbuff = xavp_get(&name, xbuffs_root->val.v.xavp); + if(!xbuff) { + return pv_get_null(msg, param, res); } xavp = xbuff->val.v.xavp; - switch (xbuff_is_attr_set(attr)) { - case XBUFF_ATTR_TYPE: - if (xbuff_is_no_index(attr)) { - return pv_xbuff_get_type(msg,param,res,xavp); - } else { - if(xavp && (xavp->name.s[0]=='l'||xavp->name.s[0]=='t')) { - xavp=xavp->val.v.xavp; + switch(xbuff_is_attr_set(attr)) { + case XBUFF_ATTR_TYPE: + if(xbuff_is_no_index(attr)) { + return pv_xbuff_get_type(msg, param, res, xavp); + } else { + if(xavp && (xavp->name.s[0] == 'l' || xavp->name.s[0] == 't')) { + xavp = xavp->val.v.xavp; + } + xavp = xavp_get_nth(&xavp, idx, NULL); + return pv_xbuff_get_type(msg, param, res, xavp); } - xavp = xavp_get_nth(&xavp,idx,NULL); - return pv_xbuff_get_type(msg,param,res,xavp); - } - break; - case XBUFF_ATTR_LENGTH: - if (xbuff_is_no_index(attr)) { - xavp = xbuff->val.v.xavp; - } else { - if(xavp && (xavp->name.s[0]=='l'||xavp->name.s[0]=='t')) { - xavp=xavp->val.v.xavp; + break; + case XBUFF_ATTR_LENGTH: + if(xbuff_is_no_index(attr)) { + xavp = xbuff->val.v.xavp; + } else { + if(xavp && (xavp->name.s[0] == 'l' || xavp->name.s[0] == 't')) { + xavp = xavp->val.v.xavp; + } + xavp = xavp_get_nth(&xavp, idx, NULL); } - xavp = xavp_get_nth(&xavp,idx,NULL); - } - count = xavp ? xavp_get_count(xavp->val.v.xavp) : 0; - return pv_get_uintval(msg,param,res,(unsigned int)count); - break; - case XBUFF_ATTR_FORMAT: - if (xbuff_is_no_index(attr)) { - xavp = xbuff->val.v.xavp; - } else { - if(xavp && (xavp->name.s[0]=='l'||xavp->name.s[0]=='t')) { - xavp=xavp->val.v.xavp; + count = xavp ? xavp_get_count(xavp->val.v.xavp) : 0; + return pv_get_uintval(msg, param, res, (unsigned int)count); + break; + case XBUFF_ATTR_FORMAT: + if(xbuff_is_no_index(attr)) { + xavp = xbuff->val.v.xavp; + } else { + if(xavp && (xavp->name.s[0] == 'l' || xavp->name.s[0] == 't')) { + xavp = xavp->val.v.xavp; + } + xavp = xavp_get_nth(&xavp, idx, NULL); } - xavp = xavp_get_nth(&xavp,idx,NULL); - } - /* + /* * Prints a term, in clear text, to the PV value pointed to by res. * It tries to resemble the term printing in the erlang shell. */ - ei_x_new_with_version(&x_buff); - if (!xavp || xavp_encode(&x_buff,xavp,1)) { - ei_x_free(&x_buff); - return pv_get_null(msg,param,res); - } + ei_x_new_with_version(&x_buff); + if(!xavp || xavp_encode(&x_buff, xavp, 1)) { + ei_x_free(&x_buff); + return pv_get_null(msg, param, res); + } - i = 1; - if (ei_s_print_term(&xbuff_fmt_buff,x_buff.buff,&i)<0) { - LM_ERR("BUG: xbuff doesn't contain a valid term!\n"); + i = 1; + if(ei_s_print_term(&xbuff_fmt_buff, x_buff.buff, &i) < 0) { + LM_ERR("BUG: xbuff doesn't contain a valid term!\n"); + ei_x_free(&x_buff); + return -1; + } + i = pv_get_strzval(msg, param, res, xbuff_fmt_buff); ei_x_free(&x_buff); - return -1; - } - i = pv_get_strzval(msg,param,res,xbuff_fmt_buff); - ei_x_free(&x_buff); - return i; + return i; } - if (!xavp) { - return pv_get_null(msg,param,res); + if(!xavp) { + return pv_get_null(msg, param, res); } /* get whole xbuff */ - if (idxf == PV_IDX_ALL) { - return pv_xbuff_get_value(msg,param,res,xavp); + if(idxf == PV_IDX_ALL) { + return pv_xbuff_get_value(msg, param, res, xavp); } /* get by idx */ - if (xavp->name.s[0]=='l'||xavp->name.s[0]=='t') { + if(xavp->name.s[0] == 'l' || xavp->name.s[0] == 't') { xavp = xavp->val.v.xavp; } - xavp = xavp_get_nth(&xavp,idx,NULL); - if (!xavp) { - return pv_get_null(msg,param,res); + xavp = xavp_get_nth(&xavp, idx, NULL); + if(!xavp) { + return pv_get_null(msg, param, res); } - return pv_xbuff_get_value(msg,param,res,xavp); + return pv_xbuff_get_value(msg, param, res, xavp); } /** @@ -806,26 +828,28 @@ int pv_xbuff_get(struct sip_msg* msg, pv_param_t* param, pv_value_t* res) sr_xavp_t *xbuff_copy_xavp(sr_xavp_t *xavp) { sr_xavp_t *new = NULL; - sr_xavp_t *cp = NULL; + sr_xavp_t *cp = NULL; - if (!xavp) return NULL; + if(!xavp) + return NULL; - while (xavp) { - if (new) { - new->next = xavp_new_value(&xavp->name,&xavp->val); + while(xavp) { + if(new) { + new->next = xavp_new_value(&xavp->name, &xavp->val); new = new->next; } else { - new = xavp_new_value(&xavp->name,&xavp->val); + new = xavp_new_value(&xavp->name, &xavp->val); } - if (!new) { + if(!new) { LM_ERR("not enough memory\n"); return cp; } - if (!cp) cp = new; + if(!cp) + cp = new; - if (xavp->val.type == SR_XTYPE_XAVP) + if(xavp->val.type == SR_XTYPE_XAVP) new->val.v.xavp = xbuff_copy_xavp(xavp->val.v.xavp); xavp = xavp->next; @@ -845,25 +869,24 @@ sr_xavp_t *xavp_new_value(str *name, sr_xval_t *val) int size; unsigned int id; - if(name==NULL || name->s==NULL || val==NULL) + if(name == NULL || name->s == NULL || val == NULL) return NULL; id = get_hash1_raw(name->s, name->len); size = sizeof(sr_xavp_t) + name->len + 1; if(val->type == SR_XTYPE_STR) size += val->v.s.len + 1; - avp = (sr_xavp_t*)shm_malloc(size); - if(avp==NULL) + avp = (sr_xavp_t *)shm_malloc(size); + if(avp == NULL) return NULL; memset(avp, 0, size); avp->id = id; - avp->name.s = (char*)avp + sizeof(sr_xavp_t); + avp->name.s = (char *)avp + sizeof(sr_xavp_t); memcpy(avp->name.s, name->s, name->len); avp->name.s[name->len] = '\0'; avp->name.len = name->len; memcpy(&avp->val, val, sizeof(sr_xval_t)); - if(val->type == SR_XTYPE_STR) - { + if(val->type == SR_XTYPE_STR) { avp->val.v.s.s = avp->name.s + avp->name.len + 1; memcpy(avp->val.v.s.s, val->v.s.s, val->v.s.len); avp->val.v.s.s[val->v.s.len] = '\0'; @@ -878,18 +901,18 @@ sr_xavp_t *xavp_get_nth(sr_xavp_t **list, int idx, sr_xavp_t **prv) sr_xavp_t *avp; int n = 0; - if (list && *list) + if(list && *list) avp = *list; else return NULL; - while (avp) { + while(avp) { - if (idx == n) + if(idx == n) return avp; n++; - if (prv) + if(prv) *prv = avp; avp = avp->next; @@ -901,44 +924,47 @@ sr_xavp_t *xavp_get_nth(sr_xavp_t **list, int idx, sr_xavp_t **prv) /** * Encode XAVPs into ei_x_buff */ -int xavp_encode(ei_x_buff *xbuff, sr_xavp_t *xavp,int level) +int xavp_encode(ei_x_buff *xbuff, sr_xavp_t *xavp, int level) { int n; while(xavp) { - switch (xavp->name.s[0]) { - case 'a': - ei_x_encode_atom_len(xbuff,xavp->val.v.s.s,xavp->val.v.s.len); - break; - case 's': - ei_x_encode_string_len(xbuff,xavp->val.v.s.s,xavp->val.v.s.len); - break; - case 'i': - ei_x_encode_long(xbuff,xavp->val.v.l); - break; - case 't': - n = xavp_get_count(xavp->val.v.xavp); - ei_x_encode_tuple_header(xbuff,n); - if (xavp_encode(xbuff,xavp->val.v.xavp,level+1)) return -1; - break; - case 'l': - n = xavp_get_count(xavp->val.v.xavp); - ei_x_encode_list_header(xbuff, n); - if (xavp_encode(xbuff, xavp->val.v.xavp, level + 1)) return -1; - ei_x_encode_empty_list(xbuff); - break; - case 'p': - ei_x_encode_pid(xbuff,xavp->val.v.data->p); - break; - case 'r': - ei_x_encode_ref(xbuff,xavp->val.v.data->p); - break; - case 'n': - ei_x_encode_atom(xbuff,"undefined"); - break; - default: - LM_ERR("BUG: unknown type for %.*s\n",STR_FMT(&xavp->name)); - return -1; + switch(xavp->name.s[0]) { + case 'a': + ei_x_encode_atom_len(xbuff, xavp->val.v.s.s, xavp->val.v.s.len); + break; + case 's': + ei_x_encode_string_len( + xbuff, xavp->val.v.s.s, xavp->val.v.s.len); + break; + case 'i': + ei_x_encode_long(xbuff, xavp->val.v.l); + break; + case 't': + n = xavp_get_count(xavp->val.v.xavp); + ei_x_encode_tuple_header(xbuff, n); + if(xavp_encode(xbuff, xavp->val.v.xavp, level + 1)) + return -1; + break; + case 'l': + n = xavp_get_count(xavp->val.v.xavp); + ei_x_encode_list_header(xbuff, n); + if(xavp_encode(xbuff, xavp->val.v.xavp, level + 1)) + return -1; + ei_x_encode_empty_list(xbuff); + break; + case 'p': + ei_x_encode_pid(xbuff, xavp->val.v.data->p); + break; + case 'r': + ei_x_encode_ref(xbuff, xavp->val.v.data->p); + break; + case 'n': + ei_x_encode_atom(xbuff, "undefined"); + break; + default: + LM_ERR("BUG: unknown type for %.*s\n", STR_FMT(&xavp->name)); + return -1; } xavp = xavp->next; } @@ -949,9 +975,9 @@ int xavp_encode(ei_x_buff *xbuff, sr_xavp_t *xavp,int level) /** * Decode XAVP from ei_x_buff */ -int xavp_decode(ei_x_buff *xbuff, int *index, sr_xavp_t **xavp,int level) +int xavp_decode(ei_x_buff *xbuff, int *index, sr_xavp_t **xavp, int level) { - int i=0; + int i = 0; int type, size, arity; int l; char _s[128]; @@ -960,7 +986,7 @@ int xavp_decode(ei_x_buff *xbuff, int *index, sr_xavp_t **xavp,int level) sr_xval_t val; sr_xavp_t **tail; sr_xavp_t *new; - char *pbuf=0; + char *pbuf = 0; erlang_pid *pid; erlang_ref *ref; erlang_fun fun; @@ -970,244 +996,248 @@ int xavp_decode(ei_x_buff *xbuff, int *index, sr_xavp_t **xavp,int level) name.s = _s; - if (!xavp || !xbuff) return -1; + if(!xavp || !xbuff) + return -1; - if (ei_get_type(xbuff->buff,index,&type,&size)) { + if(ei_get_type(xbuff->buff, index, &type, &size)) { LM_ERR("failed to get type\n"); return -1; } - switch (type) { - case ERL_ATOM_EXT: + switch(type) { + case ERL_ATOM_EXT: #ifdef ERL_SMALL_ATOM_EXT - case ERL_SMALL_ATOM_EXT: + case ERL_SMALL_ATOM_EXT: #endif - name.len = snprintf(_s,sizeof(_s),"a%d",counter++); - pbuf = (char*)pkg_realloc(pbuf,size+1); - - if (!pbuf) { - LM_ERR("not enough memory!\n"); - return -1; - } - - if (ei_decode_atom(xbuff->buff,index,pbuf)) { - LM_ERR("failed to decode atom\n"); - goto err; - } + name.len = snprintf(_s, sizeof(_s), "a%d", counter++); + pbuf = (char *)pkg_realloc(pbuf, size + 1); - val.type = SR_XTYPE_STR; - val.v.s.s = pbuf; - val.v.s.len = size; - - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - goto err; - } - - break; - case ERL_LIST_EXT: - case ERL_SMALL_TUPLE_EXT: - case ERL_LARGE_TUPLE_EXT: - - name.len = snprintf(_s,sizeof(_s),"%c%d", type == ERL_LIST_EXT ? 'l' : 't', counter++); + if(!pbuf) { + LM_ERR("not enough memory!\n"); + return -1; + } - val.v.xavp = NULL; + if(ei_decode_atom(xbuff->buff, index, pbuf)) { + LM_ERR("failed to decode atom\n"); + goto err; + } - if (type == ERL_LIST_EXT) { - ei_decode_list_header(xbuff->buff,index,&arity); - } else { - ei_decode_tuple_header(xbuff->buff,index,&arity); - } + val.type = SR_XTYPE_STR; + val.v.s.s = pbuf; + val.v.s.len = size; - if (arity == 0) { - val.type = SR_XTYPE_NULL; - } else { - val.type = SR_XTYPE_XAVP; - } + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + goto err; + } - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - goto err; - } + break; + case ERL_LIST_EXT: + case ERL_SMALL_TUPLE_EXT: + case ERL_LARGE_TUPLE_EXT: - tail = &(*xavp)->val.v.xavp; + name.len = snprintf(_s, sizeof(_s), "%c%d", + type == ERL_LIST_EXT ? 'l' : 't', counter++); - for(l=0;lbuff, index, &arity); + } else { + ei_decode_tuple_header(xbuff->buff, index, &arity); + } - if (xavp_decode(xbuff,index,&new,level+1)) { - LM_ERR("failed to decode %.*s\n",STR_FMT(&name)); - return -1; + if(arity == 0) { + val.type = SR_XTYPE_NULL; + } else { + val.type = SR_XTYPE_XAVP; } - if (!new) { + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { LM_ERR("failed to create new xavp!\n"); goto err; } - *tail = new; - tail = &new->next; - } + tail = &(*xavp)->val.v.xavp; - break; - case ERL_STRING_EXT: - name.len = snprintf(_s,sizeof(_s),"s%d",counter++); + for(l = 0; l < arity; l++) { - pbuf = (char*)pkg_realloc(pbuf,size+1); + new = NULL; - if (!pbuf) { - LM_ERR("not enough memory!\n"); - return -1; - } + if(xavp_decode(xbuff, index, &new, level + 1)) { + LM_ERR("failed to decode %.*s\n", STR_FMT(&name)); + return -1; + } - ei_decode_string(xbuff->buff,index,pbuf); + if(!new) { + LM_ERR("failed to create new xavp!\n"); + goto err; + } - val.type = SR_XTYPE_STR; - val.v.s.s = pbuf; - val.v.s.len = size; + *tail = new; + tail = &new->next; + } - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - goto err; - } - break; - case ERL_SMALL_INTEGER_EXT: - name.len = snprintf(_s,sizeof(_s),"i%d",counter++); + break; + case ERL_STRING_EXT: + name.len = snprintf(_s, sizeof(_s), "s%d", counter++); - ei_decode_long(xbuff->buff,index,&val.v.l); - val.type = SR_XTYPE_LONG; + pbuf = (char *)pkg_realloc(pbuf, size + 1); - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - goto err; - } - break; - case ERL_SMALL_BIG_EXT: - case ERL_INTEGER_EXT: - name.len = snprintf(_s,sizeof(_s),"i%d",counter++); - - if (size > sizeof(long)) { - ei_decode_longlong(xbuff->buff,index,&val.v.ll); - val.type = SR_XTYPE_LLONG; - } else { - ei_decode_long(xbuff->buff,index,&val.v.l); + if(!pbuf) { + LM_ERR("not enough memory!\n"); + return -1; + } + + ei_decode_string(xbuff->buff, index, pbuf); + + val.type = SR_XTYPE_STR; + val.v.s.s = pbuf; + val.v.s.len = size; + + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + goto err; + } + break; + case ERL_SMALL_INTEGER_EXT: + name.len = snprintf(_s, sizeof(_s), "i%d", counter++); + + ei_decode_long(xbuff->buff, index, &val.v.l); val.type = SR_XTYPE_LONG; - } - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - goto err; - } - break; - case ERL_FLOAT_EXT: - case NEW_FLOAT_EXT: - name.len = snprintf(_s,sizeof(_s),"s%d",counter++); + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + goto err; + } + break; + case ERL_SMALL_BIG_EXT: + case ERL_INTEGER_EXT: + name.len = snprintf(_s, sizeof(_s), "i%d", counter++); - ei_decode_double(xbuff->buff,index,&d); - val.v.s.s = _fmt; - val.v.s.len = snprintf(_fmt,sizeof(_fmt),"%g",d); + if(size > sizeof(long)) { + ei_decode_longlong(xbuff->buff, index, &val.v.ll); + val.type = SR_XTYPE_LLONG; + } else { + ei_decode_long(xbuff->buff, index, &val.v.l); + val.type = SR_XTYPE_LONG; + } - val.type = SR_XTYPE_STR; + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + goto err; + } + break; + case ERL_FLOAT_EXT: + case NEW_FLOAT_EXT: + name.len = snprintf(_s, sizeof(_s), "s%d", counter++); - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - goto err; - } - break; + ei_decode_double(xbuff->buff, index, &d); + val.v.s.s = _fmt; + val.v.s.len = snprintf(_fmt, sizeof(_fmt), "%g", d); - case ERL_PID_EXT: - name.len = snprintf(_s,sizeof(_s),"p%d",counter++); + val.type = SR_XTYPE_STR; - data = (sr_data_t*)shm_malloc(sizeof(sr_data_t)+sizeof(erlang_pid)); - if (!data) { - LM_ERR("not enough shared memory\n"); - goto err; - } + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + goto err; + } + break; - memset((void*)data,0,sizeof(sr_data_t)+sizeof(erlang_pid)); + case ERL_PID_EXT: + name.len = snprintf(_s, sizeof(_s), "p%d", counter++); - data->p = pid = (void*)data+sizeof(sr_data_t); - data->pfree = xbuff_data_free; + data = (sr_data_t *)shm_malloc( + sizeof(sr_data_t) + sizeof(erlang_pid)); + if(!data) { + LM_ERR("not enough shared memory\n"); + goto err; + } - if (ei_decode_pid(xbuff->buff,index,pid)<0) { - LM_ERR("failed to decode pid\n"); - shm_free(data); - goto err; - } + memset((void *)data, 0, sizeof(sr_data_t) + sizeof(erlang_pid)); - val.type = SR_XTYPE_DATA; - val.v.data = data; + data->p = pid = (void *)data + sizeof(sr_data_t); + data->pfree = xbuff_data_free; - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - shm_free(data); - goto err; - } + if(ei_decode_pid(xbuff->buff, index, pid) < 0) { + LM_ERR("failed to decode pid\n"); + shm_free(data); + goto err; + } - break; - case ERL_REFERENCE_EXT: - case ERL_NEW_REFERENCE_EXT: - name.len = snprintf(_s,sizeof(_s),"r%d",counter++); + val.type = SR_XTYPE_DATA; + val.v.data = data; - data = (sr_data_t*)shm_malloc(sizeof(sr_data_t)+sizeof(erlang_ref)); - if (!data) { - LM_ERR("not enough shared memory\n"); - goto err; - } + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + shm_free(data); + goto err; + } - memset((void*)data,0,sizeof(sr_data_t)+sizeof(erlang_ref)); + break; + case ERL_REFERENCE_EXT: + case ERL_NEW_REFERENCE_EXT: + name.len = snprintf(_s, sizeof(_s), "r%d", counter++); + + data = (sr_data_t *)shm_malloc( + sizeof(sr_data_t) + sizeof(erlang_ref)); + if(!data) { + LM_ERR("not enough shared memory\n"); + goto err; + } - data->p = ref = (void*)data+sizeof(sr_data_t); - data->pfree = xbuff_data_free; + memset((void *)data, 0, sizeof(sr_data_t) + sizeof(erlang_ref)); - if (ei_decode_ref(xbuff->buff,index,ref)<0) { - LM_ERR("failed to decode pid\n"); - shm_free(data); - goto err; - } + data->p = ref = (void *)data + sizeof(sr_data_t); + data->pfree = xbuff_data_free; - val.type = SR_XTYPE_DATA; - val.v.data = data; + if(ei_decode_ref(xbuff->buff, index, ref) < 0) { + LM_ERR("failed to decode pid\n"); + shm_free(data); + goto err; + } - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - shm_free(data); - goto err; - } + val.type = SR_XTYPE_DATA; + val.v.data = data; - break; - case ERL_FUN_EXT: - name.len = snprintf(_s,sizeof(_s),"s%d",counter++); - i = *index; + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + shm_free(data); + goto err; + } - ei_decode_fun(xbuff->buff,index,&fun); + break; + case ERL_FUN_EXT: + name.len = snprintf(_s, sizeof(_s), "s%d", counter++); + i = *index; - if (ei_s_print_term(&p,xbuff->buff,&i)<0) { - LM_ERR("failed to decode fun\n"); - goto err; - } - val.type = SR_XTYPE_STR; - val.v.s.s = p; - val.v.s.len = strlen(p); + ei_decode_fun(xbuff->buff, index, &fun); - *xavp = xavp_new_value(&name,&val); - if (!*xavp) { - LM_ERR("failed to create new xavp!\n"); - goto err; - } - break; - default: - LM_ERR("unknown type %c(%d)\n",(char)type,type); + if(ei_s_print_term(&p, xbuff->buff, &i) < 0) { + LM_ERR("failed to decode fun\n"); + goto err; + } + val.type = SR_XTYPE_STR; + val.v.s.s = p; + val.v.s.len = strlen(p); + + *xavp = xavp_new_value(&name, &val); + if(!*xavp) { + LM_ERR("failed to create new xavp!\n"); + goto err; + } + break; + default: + LM_ERR("unknown type %c(%d)\n", (char)type, type); } pkg_free(pbuf); @@ -1234,8 +1264,9 @@ int xavp_get_count(sr_xavp_t *list) /* * free format buffer for list */ -void free_xbuff_fmt_buff() { - if (xbuff_fmt_buff) { +void free_xbuff_fmt_buff() +{ + if(xbuff_fmt_buff) { free(xbuff_fmt_buff); } xbuff_fmt_buff = 0; @@ -1245,9 +1276,11 @@ void xbuff_destroy_all() { sr_xavp_t *list; list = xavp_get_xbuffs(); - if (list) xavp_destroy_list(&list); + if(list) + xavp_destroy_list(&list); } /* does nothing but must be executed in xavp_free[_unsafe] */ -void xbuff_data_free(void *p, sr_xavp_sfree_f sfree) { +void xbuff_data_free(void *p, sr_xavp_sfree_f sfree) +{ } diff --git a/src/modules/erlang/pv_xbuff.h b/src/modules/erlang/pv_xbuff.h index 9f5961470cb..1a956aed210 100644 --- a/src/modules/erlang/pv_xbuff.h +++ b/src/modules/erlang/pv_xbuff.h @@ -30,14 +30,16 @@ #include #include -typedef enum { - XBUFF_ATTR_TYPE = (1<<2), - XBUFF_ATTR_FORMAT = (1<<3), - XBUFF_ATTR_LENGTH = (1<<4), - XBUFF_NO_IDX = (1<<5) +typedef enum +{ + XBUFF_ATTR_TYPE = (1 << 2), + XBUFF_ATTR_FORMAT = (1 << 3), + XBUFF_ATTR_LENGTH = (1 << 4), + XBUFF_NO_IDX = (1 << 5) } xbuff_attr_t; -typedef enum { +typedef enum +{ XBUFF_TYPE_ATOM, XBUFF_TYPE_INT, XBUFF_TYPE_STR, @@ -48,25 +50,26 @@ typedef enum { XBUFF_TYPE_COUNT } xbuff_type_t; -#define XBUFF_IDX_MASK 3 +#define XBUFF_IDX_MASK 3 int pv_xbuff_parse_name(pv_spec_t *sp, str *in); -int pv_xbuff_new_xavp(sr_xavp_t **new, pv_value_t *pval, int *counter, char prefix); -int pv_xbuff_get_type(struct sip_msg *msg, pv_param_t *param, - pv_value_t *res, sr_xavp_t *avp); +int pv_xbuff_new_xavp( + sr_xavp_t **new, pv_value_t *pval, int *counter, char prefix); +int pv_xbuff_get_type(struct sip_msg *msg, pv_param_t *param, pv_value_t *res, + sr_xavp_t *avp); sr_xavp_t *pv_xbuff_get_xbuff(str *name); -int xavp_decode(ei_x_buff *xbuff, int *index, sr_xavp_t **xavp,int level); +int xavp_decode(ei_x_buff *xbuff, int *index, sr_xavp_t **xavp, int level); sr_xavp_t *xbuff_new(str *name); extern str xbuff_attributes[]; extern str xbuff_types[]; -#define xbuff_attr_name(flag) (xbuff_attributes[(flag)>>XBUFF_IDX_MASK]) -#define xbuff_set_attr_flag(type,flag) type |= flag -#define xbuff_get_attr_flags(type) ((type)&~XBUFF_IDX_MASK) -#define xbuff_is_attr_set(flags) ((attr)&~XBUFF_NO_IDX) +#define xbuff_attr_name(flag) (xbuff_attributes[(flag) >> XBUFF_IDX_MASK]) +#define xbuff_set_attr_flag(type, flag) type |= flag +#define xbuff_get_attr_flags(type) ((type) & ~XBUFF_IDX_MASK) +#define xbuff_is_attr_set(flags) ((attr) & ~XBUFF_NO_IDX) #define xbuff_is_no_index(attr) ((attr)&XBUFF_NO_IDX) #define xbuff_fix_index(type) ((type)&XBUFF_IDX_MASK) @@ -77,8 +80,8 @@ int is_pv_xbuff_valid_char(char c); sr_xavp_t *xbuff_copy_xavp(sr_xavp_t *xavp); -int pv_xbuff_set(struct sip_msg*, pv_param_t*, int, pv_value_t*); -int pv_xbuff_get(struct sip_msg*, pv_param_t*, pv_value_t*); +int pv_xbuff_set(struct sip_msg *, pv_param_t *, int, pv_value_t *); +int pv_xbuff_get(struct sip_msg *, pv_param_t *, pv_value_t *); void free_xbuff_fmt_buff(); /* destroy all xbuffs */ @@ -96,7 +99,7 @@ extern regex_t xbuff_type_re; sr_xavp_t *xavp_new_value(str *name, sr_xval_t *val); sr_xavp_t *xavp_get_nth(sr_xavp_t **list, int idx, sr_xavp_t **prv); int xavp_get_count(sr_xavp_t *list); -int xavp_encode(ei_x_buff *xbuff, sr_xavp_t *xavp,int level); +int xavp_encode(ei_x_buff *xbuff, sr_xavp_t *xavp, int level); void xbuff_data_free(void *p, sr_xavp_sfree_f sfree); diff --git a/src/modules/erlang/worker.c b/src/modules/erlang/worker.c index fea6c9d8d9b..4a63c65c068 100644 --- a/src/modules/erlang/worker.c +++ b/src/modules/erlang/worker.c @@ -34,7 +34,7 @@ int worker_send_impl(ei_cnode *ec, int s, int wpid); int worker_init(worker_handler_t *phandler, int fd, const ei_cnode *ec) { - if (erl_set_nonblock(fd)){ + if(erl_set_nonblock(fd)) { LM_ERR("set non blocking failed\n"); } @@ -51,7 +51,7 @@ int worker_init(worker_handler_t *phandler, int fd, const ei_cnode *ec) int handle_worker(handler_common_t *phandler) { - worker_handler_t* w = (worker_handler_t*)phandler; + worker_handler_t *w = (worker_handler_t *)phandler; struct msghdr msg; struct iovec cnt[2]; int wpid = 0; @@ -59,54 +59,55 @@ int handle_worker(handler_common_t *phandler) int rc; /* ensure be connected */ - if (enode_connect()){ + if(enode_connect()) { LM_ERR("failed to connect!\n"); return -1; } - memset((void*)&msg,0,sizeof(msg)); + memset((void *)&msg, 0, sizeof(msg)); /* Kamailio worker PID */ cnt[0].iov_base = &wpid; - cnt[0].iov_len = sizeof(wpid); + cnt[0].iov_len = sizeof(wpid); /* method */ cnt[1].iov_base = &api; - cnt[1].iov_len = sizeof(api); + cnt[1].iov_len = sizeof(api); msg.msg_iov = cnt; msg.msg_iovlen = 2; - while ((rc = recvmsg(w->sockfd, &msg, MSG_WAITALL)) == -1 && errno == EAGAIN) + while((rc = recvmsg(w->sockfd, &msg, MSG_WAITALL)) == -1 && errno == EAGAIN) ; - if (rc < 0){ - LM_ERR("recvmsg failed (socket=%d): %s\n",w->sockfd,strerror(errno)); + if(rc < 0) { + LM_ERR("recvmsg failed (socket=%d): %s\n", w->sockfd, strerror(errno)); return -1; } switch(api) { - case API_RPC_CALL: - if (worker_rpc_impl(&w->ec,w->sockfd,wpid)) - return -1; - break; - case API_REG_SEND: - if (worker_reg_send_impl(&w->ec,w->sockfd,wpid)) - return -1; - break; - case API_SEND: - if (worker_send_impl(&w->ec,w->sockfd,wpid)) - return -1; - break; - default: - LM_ERR("BUG: bad method or not implemented!\n"); - return 1; + case API_RPC_CALL: + if(worker_rpc_impl(&w->ec, w->sockfd, wpid)) + return -1; + break; + case API_REG_SEND: + if(worker_reg_send_impl(&w->ec, w->sockfd, wpid)) + return -1; + break; + case API_SEND: + if(worker_send_impl(&w->ec, w->sockfd, wpid)) + return -1; + break; + default: + LM_ERR("BUG: bad method or not implemented!\n"); + return 1; } return 0; } -int wait_tmo_worker(handler_common_t* phandler){ +int wait_tmo_worker(handler_common_t *phandler) +{ return 0; } @@ -114,7 +115,7 @@ int wait_tmo_worker(handler_common_t* phandler){ /** * internal implementation */ -int worker_rpc_impl(ei_cnode *ec, int s,int wpid) +int worker_rpc_impl(ei_cnode *ec, int s, int wpid) { str module = STR_NULL; str function = STR_NULL; @@ -124,69 +125,69 @@ int worker_rpc_impl(ei_cnode *ec, int s,int wpid) struct iovec cnt[6]; int rc; - memset((void*)&args,0,sizeof(args)); - memset((void*)&reply,0,sizeof(reply)); - memset((void*)&msgh,0,sizeof(msgh)); + memset((void *)&args, 0, sizeof(args)); + memset((void *)&reply, 0, sizeof(reply)); + memset((void *)&msgh, 0, sizeof(msgh)); /* module name length */ cnt[0].iov_base = &module.len; - cnt[0].iov_len = sizeof(int); + cnt[0].iov_len = sizeof(int); /* function name length */ cnt[1].iov_base = &function.len; - cnt[1].iov_len = sizeof(int); + cnt[1].iov_len = sizeof(int); /* Erlang args size */ cnt[2].iov_base = &args.buffsz; - cnt[2].iov_len = sizeof(int); + cnt[2].iov_len = sizeof(int); /* get data size */ - msgh.msg_iov = cnt; + msgh.msg_iov = cnt; msgh.msg_iovlen = 3; - while ((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) + while((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) ; - if (rc == -1){ - LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed (socket=%d): %s\n", s, strerror(errno)); goto err; } /* allocate space */ - module.s = (char*)pkg_malloc(module.len+1); - if (!module.s) { + module.s = (char *)pkg_malloc(module.len + 1); + if(!module.s) { LM_ERR("not enough memory\n"); goto err; } - function.s = (char*)pkg_malloc(function.len+1); - if (!function.s) { + function.s = (char *)pkg_malloc(function.len + 1); + if(!function.s) { LM_ERR("not enough memory\n"); goto err; } - args.buff = (char*)malloc(args.buffsz); - if (!args.buff) { + args.buff = (char *)malloc(args.buffsz); + if(!args.buff) { LM_ERR("malloc: not enough memory\n"); goto err; } /* buffers */ cnt[3].iov_base = module.s; - cnt[3].iov_len = module.len; + cnt[3].iov_len = module.len; cnt[4].iov_base = function.s; - cnt[4].iov_len = function.len; + cnt[4].iov_len = function.len; cnt[5].iov_base = args.buff; - cnt[5].iov_len = args.buffsz; + cnt[5].iov_len = args.buffsz; /* get whole data */ msgh.msg_iovlen = 6; - while ((rc = recvmsg(s, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) + while((rc = recvmsg(s, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) ; - if (rc == -1){ - LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed (socket=%d): %s\n", s, strerror(errno)); goto err; } @@ -194,7 +195,7 @@ int worker_rpc_impl(ei_cnode *ec, int s,int wpid) module.s[module.len] = 0; function.s[function.len] = 0; - LM_DBG("rpc: %.*s:%.*s(args)\n",STR_FMT(&module),STR_FMT(&function)); + LM_DBG("rpc: %.*s:%.*s(args)\n", STR_FMT(&module), STR_FMT(&function)); EI_X_BUFF_PRINT(&args); @@ -206,46 +207,46 @@ int worker_rpc_impl(ei_cnode *ec, int s,int wpid) } /* do RPC */ - if ((rc = ei_rpc(ec,enode->sockfd,module.s,function.s,args.buff,args.buffsz,&reply)) == ERL_ERROR) - { + if((rc = ei_rpc(ec, enode->sockfd, module.s, function.s, args.buff, + args.buffsz, &reply)) + == ERL_ERROR) { reply.index = 0; /* re-use reply buffer */ - if (erl_errno) - { + if(erl_errno) { ei_x_format(&reply, "{error,cnode,~s}", strerror(erl_errno)); - LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno)); - } - else if (errno) - { + LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(erl_errno)); + } else if(errno) { ei_x_format(&reply, "{error,cnode,~s}", strerror(errno)); - LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno)); - } - else - { + LM_ERR("ei_rpc failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(errno)); + } else { ei_x_format(&reply, "{error,cnode,~s}", "Unknown error."); - LM_ERR("ei_rpc failed on node=<%s> socket=<%d>, Unknown error.\n",ec->thisalivename,enode->sockfd); + LM_ERR("ei_rpc failed on node=<%s> socket=<%d>, Unknown error.\n", + ec->thisalivename, enode->sockfd); } } reply: EI_X_BUFF_PRINT(&reply); - cnt[0].iov_base = (void*)&wpid; - cnt[0].iov_len = sizeof(int); + cnt[0].iov_base = (void *)&wpid; + cnt[0].iov_len = sizeof(int); /* send reply to Kamailio worker */ - cnt[1].iov_base = (void*)&reply.buffsz; - cnt[1].iov_len = sizeof(int); + cnt[1].iov_base = (void *)&reply.buffsz; + cnt[1].iov_len = sizeof(int); - cnt[2].iov_base = (void*)reply.buff; - cnt[2].iov_len = reply.buffsz; + cnt[2].iov_base = (void *)reply.buff; + cnt[2].iov_len = reply.buffsz; msgh.msg_iovlen = 3; - while ((rc = sendmsg(s, &msgh, 0)) == -1 && errno == EAGAIN) + while((rc = sendmsg(s, &msgh, 0)) == -1 && errno == EAGAIN) ; - if (rc == -1) { - LM_ERR("sendmsg failed on socket=%d rpid_no=%d; %s\n",s, wpid, strerror(errno)); + if(rc == -1) { + LM_ERR("sendmsg failed on socket=%d rpid_no=%d; %s\n", s, wpid, + strerror(errno)); goto err; }; @@ -264,7 +265,7 @@ int worker_rpc_impl(ei_cnode *ec, int s,int wpid) return -1; } -int worker_reg_send_impl(ei_cnode *ec, int s,int wpid) +int worker_reg_send_impl(ei_cnode *ec, int s, int wpid) { str server = STR_NULL; ei_x_buff emsg; @@ -272,57 +273,57 @@ int worker_reg_send_impl(ei_cnode *ec, int s,int wpid) struct iovec cnt[6]; int rc; - memset((void*)&emsg,0,sizeof(emsg)); + memset((void *)&emsg, 0, sizeof(emsg)); - memset((void*)&msgh,0,sizeof(msgh)); + memset((void *)&msgh, 0, sizeof(msgh)); /* server name length */ cnt[0].iov_base = &server.len; - cnt[0].iov_len = sizeof(int); + cnt[0].iov_len = sizeof(int); /* Erlang args size */ cnt[1].iov_base = &emsg.buffsz; - cnt[1].iov_len = sizeof(int); + cnt[1].iov_len = sizeof(int); /* get data size */ - msgh.msg_iov = cnt; + msgh.msg_iov = cnt; msgh.msg_iovlen = 2; - while ((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) + while((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) ; - if (rc == -1){ - LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed (socket=%d): %s\n", s, strerror(errno)); return -1; } /* allocate space */ - server.s = (char*)pkg_malloc(server.len+1); - if (!server.s) { + server.s = (char *)pkg_malloc(server.len + 1); + if(!server.s) { LM_ERR("not enough memory\n"); goto err; } - emsg.buff = (char*)malloc(emsg.buffsz); - if (!emsg.buff) { + emsg.buff = (char *)malloc(emsg.buffsz); + if(!emsg.buff) { LM_ERR("malloc: not enough memory\n"); goto err; } /* buffers */ cnt[2].iov_base = server.s; - cnt[2].iov_len = server.len; + cnt[2].iov_len = server.len; cnt[3].iov_base = emsg.buff; - cnt[3].iov_len = emsg.buffsz; + cnt[3].iov_len = emsg.buffsz; /* get whole data */ msgh.msg_iovlen = 4; - while ((rc = recvmsg(s, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) + while((rc = recvmsg(s, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) ; - if (rc == -1){ - LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed (socket=%d): %s\n", s, strerror(errno)); goto err; } @@ -334,24 +335,23 @@ int worker_reg_send_impl(ei_cnode *ec, int s,int wpid) goto err; } - LM_DBG(">> {%.*s,'%s'} ! emsg\n",STR_FMT(&server),enode->conn.nodename); + LM_DBG(">> {%.*s,'%s'} ! emsg\n", STR_FMT(&server), enode->conn.nodename); EI_X_BUFF_PRINT(&emsg); /* do ERL_REG_SEND */ - if ((rc = ei_reg_send(ec,enode->sockfd,server.s,emsg.buff,emsg.buffsz)) == ERL_ERROR) - { - if (erl_errno) - { - LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno)); - } - else if (errno) - { - LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno)); - } - else - { - LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>, Unknown error.\n",ec->thisalivename,enode->sockfd); + if((rc = ei_reg_send(ec, enode->sockfd, server.s, emsg.buff, emsg.buffsz)) + == ERL_ERROR) { + if(erl_errno) { + LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(erl_errno)); + } else if(errno) { + LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(errno)); + } else { + LM_ERR("ei_reg_send failed on node=<%s> socket=<%d>, Unknown " + "error.\n", + ec->thisalivename, enode->sockfd); } } @@ -367,7 +367,7 @@ int worker_reg_send_impl(ei_cnode *ec, int s,int wpid) return -1; } -int worker_send_impl(ei_cnode *ec, int s,int wpid) +int worker_send_impl(ei_cnode *ec, int s, int wpid) { erlang_pid pid; ei_x_buff emsg; @@ -375,46 +375,46 @@ int worker_send_impl(ei_cnode *ec, int s,int wpid) struct iovec cnt[6]; int rc; - memset((void*)&emsg,0,sizeof(emsg)); + memset((void *)&emsg, 0, sizeof(emsg)); - memset((void*)&msgh,0,sizeof(msgh)); + memset((void *)&msgh, 0, sizeof(msgh)); /* Erlang args size */ cnt[0].iov_base = &emsg.buffsz; - cnt[0].iov_len = sizeof(int); + cnt[0].iov_len = sizeof(int); /* get data size */ - msgh.msg_iov = cnt; + msgh.msg_iov = cnt; msgh.msg_iovlen = 1; - while ((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) + while((rc = recvmsg(s, &msgh, MSG_PEEK)) == -1 && errno == EAGAIN) ; - if (rc == -1){ - LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed (socket=%d): %s\n", s, strerror(errno)); return -1; } - emsg.buff = (char*)malloc(emsg.buffsz); - if (!emsg.buff) { + emsg.buff = (char *)malloc(emsg.buffsz); + if(!emsg.buff) { LM_ERR("malloc: not enough memory\n"); goto err; } /* buffers */ cnt[1].iov_base = &pid; - cnt[1].iov_len = sizeof(erlang_pid); + cnt[1].iov_len = sizeof(erlang_pid); cnt[2].iov_base = emsg.buff; - cnt[2].iov_len = emsg.buffsz; + cnt[2].iov_len = emsg.buffsz; /* get whole data */ msgh.msg_iovlen = 3; - while ((rc = recvmsg(s, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) + while((rc = recvmsg(s, &msgh, MSG_WAITALL)) == -1 && errno == EAGAIN) ; - if (rc == -1){ - LM_ERR("recvmsg failed (socket=%d): %s\n",s,strerror(errno)); + if(rc == -1) { + LM_ERR("recvmsg failed (socket=%d): %s\n", s, strerror(errno)); goto err; } @@ -423,24 +423,22 @@ int worker_send_impl(ei_cnode *ec, int s,int wpid) goto err; } - LM_DBG(">> <%s.%d.%d> ! emsg\n",pid.node,pid.num,pid.serial); + LM_DBG(">> <%s.%d.%d> ! emsg\n", pid.node, pid.num, pid.serial); EI_X_BUFF_PRINT(&emsg); /* do ERL_SEND */ - if ((rc = ei_send(enode->sockfd,&pid,emsg.buff,emsg.buffsz)) == ERL_ERROR) - { - if (erl_errno) - { - LM_ERR("ei_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(erl_errno)); - } - else if (errno) - { - LM_ERR("ei_send failed on node=<%s> socket=<%d>: %s\n",enode->conn.nodename,enode->sockfd,strerror(errno)); - } - else - { - LM_ERR("ei_send failed on node=<%s> socket=<%d>, Unknown error.\n",ec->thisalivename,enode->sockfd); + if((rc = ei_send(enode->sockfd, &pid, emsg.buff, emsg.buffsz)) + == ERL_ERROR) { + if(erl_errno) { + LM_ERR("ei_send failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(erl_errno)); + } else if(errno) { + LM_ERR("ei_send failed on node=<%s> socket=<%d>: %s\n", + enode->conn.nodename, enode->sockfd, strerror(errno)); + } else { + LM_ERR("ei_send failed on node=<%s> socket=<%d>, Unknown error.\n", + ec->thisalivename, enode->sockfd); } } diff --git a/src/modules/erlang/worker.h b/src/modules/erlang/worker.h index 4c291351667..b200907e5ad 100644 --- a/src/modules/erlang/worker.h +++ b/src/modules/erlang/worker.h @@ -47,7 +47,7 @@ typedef struct worker_handler_s int (*handle_f)(handler_common_t *phandler_t); int (*wait_tmo_f)(handler_common_t *phandler_t); int (*destroy_f)(handler_common_t *handler); - int sockfd; /* kamailio to cnode socket r/w */ + int sockfd; /* kamailio to cnode socket r/w */ ei_cnode ec; /* erlang C node (actually it's me) */ } worker_handler_t;