static void response_client_open_int(response_client_t *uclient, char *conn_str) {
char *first, *second, *third;
int len, port;
memset(uclient->connect_str, 0, sizeof(uclient->connect_str));
strncpy(uclient->connect_str, conn_str, strlen(conn_str));
len = strlen(uclient->connect_str);
uclient->connect_str[len] = '\0';
first = conn_str;
second = strchr(first, ':');
EXIT_IF_TRUE(second == NULL, "Invalid connection string\n");
*second = '\0';
second++;
if( 0 == strcmp(first, "udp") ) {
third = strchr(second, ':');
EXIT_IF_TRUE(third == NULL, "Invalid connection string for udp socket\n");
*third = '\0';
third++;
port = atoi(third);
open_udp_socket(uclient, second, port);
}
else if( 0 == strcmp(first, "tty") ) {
open_tty(uclient, second);
}
}
void asterisk_acc_unpack_socket(char *buff, perm_node_t **key_list, asterisk_acc_table_t *asterisk_acc_table, opool_t *opool) {
int i;
json_object *new_obj, *jvalue;
opool_item_t *item, *item2;
perm_node_t *key_element, *value_element, *data_list;
perm_node_t *temp, *entry;
perm_node_t *temp2, *entry2;
perm_node_t *data_list2;
char id[10], pwd[10];
new_obj = json_tokener_parse(buff);
//printf("new_obj.to_string()=%s\n", json_object_to_json_string(new_obj));
for(i = 0; i < json_object_array_length(new_obj); i++)
{
item = opool_get(opool);
EXIT_IF_TRUE(item == NULL, "Cannot get from object pool\n");
key_element = (perm_node_t *)item->data;
item2 = opool_get(opool);
EXIT_IF_TRUE(item == NULL, "Cannot get from object pool\n");
value_element = (perm_node_t *)item2->data;
json_object *obj = json_object_array_get_idx(new_obj, i);
json_object_object_get_ex(obj, "account", &jvalue);
strcpy(id, json_object_get_string(jvalue));
json_object_object_get_ex(obj, "password", &jvalue);
strcpy(pwd, json_object_get_string(jvalue));
ansi_copy_str(key_element->value, id);
ansi_copy_str(value_element->value, pwd);
data_list = (perm_node_t *)ht_get_item(asterisk_acc_table, (void *)id);
if (data_list == NULL) {
DL_APPEND(*key_list, key_element);
DL_APPEND(data_list, value_element);
ht_add_item(asterisk_acc_table, id, data_list);
}
else {
DL_APPEND(data_list, value_element);
}
}
}
static void open_tty($UPROTO$_server_t *userver, char *path) {
(void)userver;
(void)path;
#if 0
struct termios options;
userver->fd = open(path, O_RDWR | O_NOCTTY);
EXIT_IF_TRUE(userver->fd < 0, "Cannot open port");
fcntl(userver->fd, F_SETFL, 0);
tcgetattr(userver->fd, &options);
cfsetispeed(&options, B9600);
cfsetospeed(&options, B9600);
options.c_cflag |= (CREAD |CLOCAL);
options.c_cflag &= ~CSIZE; /* Mask the character size bits */
options.c_cflag |= CS8; /* Select 8 data bits */
options.c_cflag &= ~CRTSCTS;
options.c_iflag &= ~(IXON | IXOFF | IXANY);
//options->c_lflag |= (ICANON | ECHO | ECHOE); // Canonical mode
options.c_lflag &= ~(ICANON | ECHO); // RAW mode
options.c_cc[VMIN] = 0;
options.c_cc[VTIME] = 2; // measured in 0.1 second
tcsetattr(userver->fd, TCSANOW, &options);
#endif
}
void on_riuc4_status(int port, riuc4_signal_t signal, uart4_status_t *ustatus) {
SHOW_LOG(4, "on_riuc4_status port:%d, signal:%s\n", port, RIUC4_SIGNAL_NAME[signal]);
static pj_thread_desc s_desc;
static pj_thread_t *s_thread;
ANSI_CHECK(__FILE__, pj_thread_register("adv_server", s_desc, &s_thread));
switch(signal) {
case RIUC_SIGNAL_SQ:
SHOW_LOG(3, "Received SQ signal\n");
gb_sender_report_sq(&riuc_data.gb_sender, riuc_data.node[port].id, port, ustatus->sq);
if (ustatus->sq == 1) {
node_start_session(&riuc_data.node[port]);
gb_sender_report_rx(&riuc_data.gb_sender, riuc_data.node[port].id, port, 1);
}
else {
node_stop_session(&riuc_data.node[port]);
gb_sender_report_rx(&riuc_data.gb_sender, riuc_data.node[port].id, port, 0);
}
break;
case RIUC_SIGNAL_PTT:
SHOW_LOG(3, "Received PTT signal - node[%d]\n", port);
gb_sender_report_tx(&riuc_data.gb_sender, riuc_data.node[port].id, port, ustatus->ptt);
break;
case RIUC_SIGNAL_RX:
SHOW_LOG(3, "Received RX signal\n");
break;
case RIUC_SIGNAL_TX:
SHOW_LOG(3, "Received TX signal\n");
break;
default:
EXIT_IF_TRUE(1, "Unknow signal\n");
}
}
void lvc_pack(lvc_t *lvc, int len, char *val) {
EXIT_IF_TRUE((lvc->pack_ptr + len) > lvc->len, "lvc buffer is overflown\n");
SHOW_LOG(1, "len:%d\n", len);
memcpy((lvc->data + lvc->pack_ptr), &len, sizeof(int));
lvc->pack_ptr += sizeof(int);
memcpy(lvc->data + lvc->pack_ptr, val, len);
lvc->pack_ptr += len;
}
/*
void on_request_adv_server(adv_server_t *adv_server, adv_request_t *request) {
//TODO
SHOW_LOG(4, fprintf(stdout,"Received: ID = %s\nSDP addr %s:%d\n", request->adv_info.info_id, request->adv_info.sdp_mip, request->adv_info.sdp_port));
}
*/
void on_request_gmc_server(gmc_server_t *gmc_server, gmc_request_t *request) {
node_t *node = gmc_server->user_data;
SHOW_LOG(5, fprintf(stdout, "Receive something\n"));
switch(request->msg_id) {
case GMC_GROUP:
SHOW_LOG(4, fprintf(stdout, "Received request:\nAction: %d - Adv_ip: %s\n",
request->gmc_group.join, request->gmc_group.adv_ip));
if (request->gmc_group.join == 1) {
SHOW_LOG(4, fprintf(stdout, "Join %s\n", request->gmc_group.adv_ip));
adv_server_join(&node->adv_server, request->gmc_group.adv_ip);
}
else if (request->gmc_group.join == 0) {
SHOW_LOG(4, fprintf(stdout, "Leave %s\n", request->gmc_group.adv_ip));
adv_server_leave(&node->adv_server, request->gmc_group.adv_ip);
}
else {
EXIT_IF_TRUE(1, "Unknow action\n");
}
break;
default:
EXIT_IF_TRUE(1, "Unknow request\n");
}
}
void do_disable_rx(int port_idx, int fd) {
char data[] = "disrxX\r";
data[5] = port_idx + '1';
EXIT_IF_TRUE(7 != write(fd, data, 7), "Write error\n");
}
void do_enable_rx(int port_idx, int fd) {
char data[] = "enrxX\r";
data[4] = port_idx + '1';
EXIT_IF_TRUE(6 != write(fd, data, 6), "Write error\n");
}
void do_check_rx(int port_idx, int fd) {
char data[] = "rxX\r";
data[2] = port_idx + '1';
EXIT_IF_TRUE(4 != write(fd, data, 4), "Write error\n");
}
void do_check_ptt(int port_idx, int fd) {
char data[] = "pttX\r";
data[3] = port_idx + '1';
EXIT_IF_TRUE(5 != write(fd, data, 5), "Write error\n");
}
int $UPROTO$_server_proc(void *param) {
int ret;
unsigned int len;
int port;
char *first, *second, *third;
char cnt_str[30];
pj_sockaddr_in caddr;
char *caddr_str;
pj_time_val timeout;
pj_fd_set_t read_fds;
char buffer[USERVER_BUFSIZE];
$UPROTO$_request_t request;
$UPROTO$_server_t *userver = ($UPROTO$_server_t *)param;
ansi_copy_str(cnt_str, userver->connect_str);
first = cnt_str;
second = strchr(first, ':');
EXIT_IF_TRUE(second == NULL, "Wrong connection string format\n");
*second = '\0';
second++;
if(0 == strcmp(first, "udp")) {
third = strchr(second, ':');
EXIT_IF_TRUE(third == NULL, "Wrong connection string format\n");
*third = '\0';
third++;
port = atoi(third);
open_udp_socket(userver, second, port);
if (userver->on_open_socket_f != NULL)
userver->on_open_socket_f(userver);
userver->recv_f = &udp_recvfrom;
userver->send_f = &udp_sendto;
}
else if( 0 == strcmp(first, "tty") ) {
open_tty(userver, second);
userver->recv_f = &tty_recvfrom;
userver->send_f = &tty_sendto;
}
else {
EXIT_IF_TRUE(1, "Unsuported protocol\n");
}
// thread loop
timeout.sec = 0;
timeout.msec = 100;
userver->is_end = 0;
while( !userver->is_end ) {
while (!userver->is_online) {
SHOW_LOG(3, "Server is currently offline...\n");
//usleep(8*1000*1000);
pj_thread_sleep(1000);
}
PJ_FD_ZERO(&read_fds);
PJ_FD_SET(userver->fd, &read_fds);
pj_mutex_lock(userver->mutex);
ret = pj_sock_select(userver->fd + 1, &read_fds, NULL, NULL, &timeout);
pj_mutex_unlock(userver->mutex);
EXIT_IF_TRUE(ret < 0, "Error on server socket\n");
if( PJ_FD_ISSET(userver->fd, &read_fds) ) {
len = sizeof(caddr);
pj_bzero(&caddr, len);
pj_mutex_lock(userver->mutex);
ret = userver->recv_f(userver->fd, buffer, USERVER_BUFSIZE, (void *)&caddr, &len);
pj_mutex_unlock(userver->mutex);
caddr_str = pj_inet_ntoa(caddr.sin_addr);
if( ret > 0 ) {
buffer[ret] = '\0';
SHOW_LOG(5, "Received from client: %s\n", buffer);
$UPROTO$_parse_request(buffer, ret, &request);
userver->on_request_f(userver, &request, caddr_str);
}
}
//usleep(100*1000);
pj_thread_sleep(100);
// if userver->fd is ready to write. When write finish, call userver->on_sent();
// else --> time out
}
return 0;
}
void ht_create(hash_table_t *table_data, unsigned size) {
table_data->hash_table = pj_hash_create(table_data->pool, size);
EXIT_IF_TRUE(table_data->hash_table == NULL, "Error: pj_hash_create()\n");
}
void ht_init(hash_table_t *table_data, pj_pool_t *pool) {
EXIT_IF_TRUE(pool == NULL, "Error: NULL pool\n");
table_data->pool = pool;
}
int $UPROTO$_secure_server_proc(void *param) {
int ret;
unsigned int len;
int port;
char *first, *second, *third;
char cnt_str[30];
pj_sockaddr_in caddr;
char *caddr_str;
pj_time_val timeout;
pj_fd_set_t read_fds;
char buffer[USERVER_BUFSIZE];
$UPROTO$_request_t request;
// For lvc parsing
lvc_t lvc;
int len1;
char *val;
uint32_t *ts;
char sts[32];
char plain[USERVER_BUFSIZE];
char *pph;
char otp[32];
pj_str_t pjstr;
// End for lvc parsing
$UPROTO$_server_t *userver = ($UPROTO$_server_t *)param;
ansi_copy_str(cnt_str, userver->connect_str);
first = cnt_str;
second = strchr(first, ':');
EXIT_IF_TRUE(second == NULL, "Wrong connection string format\n");
*second = '\0';
second++;
if(0 == strcmp(first, "udp")) {
third = strchr(second, ':');
EXIT_IF_TRUE(third == NULL, "Wrong connection string format\n");
*third = '\0';
third++;
port = atoi(third);
open_udp_socket(userver, second, port);
if (userver->on_open_socket_f != NULL)
userver->on_open_socket_f(userver);
userver->recv_f = &udp_recvfrom;
userver->send_f = &udp_sendto;
}
else if( 0 == strcmp(first, "tty") ) {
open_tty(userver, second);
userver->recv_f = &tty_recvfrom;
userver->send_f = &tty_sendto;
}
else {
EXIT_IF_TRUE(1, "Unsuported protocol\n");
}
// thread loop
timeout.sec = 0;
timeout.msec = 100;
userver->is_end = 0;
while( !userver->is_end ) {
while (!userver->is_online) {
SHOW_LOG(3, "Server is currently offline...\n");
pj_thread_sleep(1000);
}
PJ_FD_ZERO(&read_fds);
PJ_FD_SET(userver->fd, &read_fds);
pj_mutex_lock(userver->mutex);
ret = pj_sock_select(userver->fd + 1, &read_fds, NULL, NULL, &timeout);
pj_mutex_unlock(userver->mutex);
EXIT_IF_TRUE(ret < 0, "Error on server socket\n");
if( PJ_FD_ISSET(userver->fd, &read_fds) ) {
len = sizeof(caddr);
pj_bzero(&caddr, len);
pj_mutex_lock(userver->mutex);
ret = userver->recv_f(userver->fd, buffer, USERVER_BUFSIZE, (void *)&caddr, &len);
pj_mutex_unlock(userver->mutex);
caddr_str = pj_inet_ntoa(caddr.sin_addr);
if( ret > 0 ) {
buffer[ret] = '\0';
lvc_init(&lvc, buffer, ret);
lvc_unpack(&lvc, &len, &val);
pj_strset(&pjstr, val, len);
pph = userver->get_pph_f(&pjstr);
if( pph != NULL ) {
lvc_unpack(&lvc, &len, &val);
ts = (uint32_t *)val;
ts2str(*ts, sts);
lvc_unpack(&lvc, &len, &val);
generate_otp(otp, pph, sts);
do_decrypt(val, len, plain, &len1, otp);
if( pj_ansi_strncmp(sts, plain, len1) == 0 ) {
lvc_unpack(&lvc, &len, &val);
do_decrypt(val, len, plain, &len1, otp);
plain[len1] = '\0';
$UPROTO$_parse_request(plain, len1, &request);
userver->on_request_f(userver, &request, caddr_str);
}
}
//else {
//}
}
}
pj_thread_sleep(100);
}
return 0;
}
void do_on_ptt(int port_idx, int fd) {
char data[] = "onpttX\r";
data[5] = port_idx + '1';
EXIT_IF_TRUE(7 != write(fd, data, 7), "Write error\n");
}
void do_off_ptt(int port_idx, int fd) {
char data[] = "offpttX\r";
data[6] = port_idx + '1';
EXIT_IF_TRUE(8 != write(fd, data, 8), "Write error\n");
}
int main(int argc, char* argv[])
{
int lsocket = -1; //侦听套接字
int dsocket = -1; //连接套接字
ushort mix_socket[2];
memset(mix_socket, 0, sizeof(mix_socket));
P_EPOLL_STRUCT p_epoll = NULL;
char buf[4096];
int cnt = 0;
int ready = 0;
// STAGE1, build local listen
EXIT_IF_TRUE ( (lsocket = st_buildsocket(10, SERV_PORT)) == -1);
st_make_nonblock(lsocket);
EXIT_IF_TRUE( (p_epoll = st_make_events(lsocket, 64)) == NULL);
st_print("SERVER prepared OK!\n");
int e_i = 0;
while (TRUE)
{
ready = epoll_wait(p_epoll->event_fd, p_epoll->p_events, 64, 5000 /*5s*/);
if (ready == -1)
{
SYS_ABORT("EPOLL_WAIT ERROR!\n");
}
if( ready == 0)
{
st_print("PROCESS ALIVE!\n");
continue;
}
for (e_i = 0; e_i < ready; ++e_i)
{
if( (p_epoll->p_events[e_i].events & EPOLLERR) )
{
st_d_error("Epoll Error!\n");
close(p_epoll->p_events[e_i].data.fd);
continue;
}
if ( ( p_epoll->p_events[e_i].events & EPOLLHUP ) ||
( p_epoll->p_events[e_i].events & EPOLLRDHUP) )
{
st_d_error("Remote Disconnected!\n");
close(p_epoll->p_events[e_i].data.fd);
continue;
}
if (p_epoll->p_events[e_i].data.fd == lsocket)
{
struct sockaddr in_addr;
socklen_t in_len;
dsocket = accept(lsocket,
(struct sockaddr *) &in_addr, &in_len);
if (dsocket == -1)
{
st_d_error("accept lsocket error!\n");
continue;
}
st_make_nonblock(dsocket);
if (st_add_new_event(dsocket, p_epoll))
{
st_d_error("Add socket:%d to event error！\n", dsocket);
close(dsocket);
dsocket = -1; //INVALID
break;
}
st_print("Server accept new socket:%d\n", dsocket);
if(mix_socket[0] == 0)
mix_socket[0] = dsocket;
else
mix_socket[1] = dsocket;
}
else //数据转发部分
{
if(p_epoll->p_events[e_i].data.fd == mix_socket[0])
{
memset(buf, 0, sizeof(buf));
cnt = recv(mix_socket[0], buf, sizeof(buf), 0);
if (cnt > 0)
{
//write(1, buf, cnt);
send(mix_socket[1], buf, cnt, 0);
}
continue;
}
else if(p_epoll->p_events[e_i].data.fd == mix_socket[1])
{
memset(buf, 0, sizeof(buf));
cnt = recv(mix_socket[1], buf, sizeof(buf), 0);
if (cnt > 0)
{
//write(1, buf, cnt);
send(mix_socket[0], buf, cnt, 0);
}
continue;
}
}
}
}
st_print("PROCESS TERMINATED!\n");
return 0;
}
