int main(void) {
receiver r;
receiver_init(&r);
unpack(&r);
return 0;
}
int allocation_create(struct allocator *allocator, unsigned ix, int proto,
const struct sa *srv,
const char *username, const char *password,
struct tls *tls, bool turn_ind,
allocation_h *alloch, void *arg)
{
struct allocation *alloc;
struct sa laddr;
int err;
if (!allocator || !proto || !srv)
return EINVAL;
sa_init(&laddr, sa_af(srv));
alloc = mem_zalloc(sizeof(*alloc), destructor);
if (!alloc)
return ENOMEM;
list_append(&allocator->allocl, &alloc->le, alloc);
(void)gettimeofday(&alloc->sent, NULL);
alloc->atime = -1;
alloc->ix = ix;
alloc->allocator = allocator;
alloc->proto = proto;
alloc->secure = tls != NULL;
alloc->srv = *srv;
alloc->user = username;
alloc->pass = password;
alloc->turn_ind = turn_ind;
alloc->alloch = alloch;
alloc->arg = arg;
alloc->tls = mem_ref(tls);
receiver_init(&alloc->recv, allocator->session_cookie, alloc->ix);
err = udp_listen(&alloc->us_tx, &laddr, NULL, NULL);
if (err) {
re_fprintf(stderr, "allocation: failed to create UDP tx socket"
" (%m)\n", err);
goto out;
}
udp_local_get(alloc->us_tx, &alloc->laddr_tx);
err = start(alloc);
if (err)
goto out;
out:
if (err)
mem_deref(alloc);
return err;
}
/*
* Start the receive thread and wait for it
*/
int
_server_start_receive (int sock)
{
pthread_t receiver_thread;
receiver_init (sock, &receiver_thread);
pthread_join (receiver_thread, NULL);
return EXIT_SUCCESS;
}
static int __init graybox_init(void)
{
int i, error;
log_debug("%s", banner);
log_debug("Inserting the module...");
/* Init Packet sender's submodules. */
error = config_init();
if (error)
goto config_failure;
error = dev_init();
if (error)
goto device_failure;
error = receiver_init();
if (error)
goto receiver_failure;
error = skbops_init();
if (error)
goto skbops_failure;
/* Hook Jool to Netfilter. */
for (i = 0; i < ARRAY_SIZE(nfho); i++) {
nfho[i].owner = NULL;
nfho[i].priority = NF_IP_PRI_FIRST + 25;
}
error = nf_register_hooks(nfho, ARRAY_SIZE(nfho));
if (error)
goto nf_register_hooks_failure;
/* Yay */
log_info(MODULE_NAME " module inserted.\n");
return error;
nf_register_hooks_failure:
skbops_destroy();
skbops_failure:
receiver_destroy();
receiver_failure:
dev_destroy();
device_failure:
config_destroy();
config_failure:
return error;
}
receiver_t receiver_create(FILE* log, int frame_size, int data_size)
{
receiver_t self = (receiver_t)malloc(sizeof(receiver_base_t));
if(!self) return NULL;
self->log = log;
self->data_size = data_size;
self->frame_size = frame_size;
self->data = (int*)malloc(sizeof(int) * data_size);
receiver_init(self);
return self;
}
/**
* Accepts an incoming connection by forking a receiver process.
* @param server_sock - socket that this connection came in to
* @param new_sock - socket to be update with the value of the accepter socket
* @returns 1 on success, 0 on error
*/
inline static int accept_connection(int server_sock,int *new_sock)
{
unsigned int length;
struct sockaddr_in remote;
int pid;
/* do accept */
length = sizeof( struct sockaddr_in);
*new_sock = accept( server_sock, (struct sockaddr*)&remote, &length);
if (*new_sock==-1) {
LOG(L_ERR,"ERROR:accept_connection(): accept failed!\n");
goto error;
} else {
LOG(L_INFO,"INFO:accept_connection(): new tcp connection accepted!\n");
}
/* initialise stuff for the new socket, to handle later. */
receiver_init(*new_sock,0);
#ifdef CDP_FOR_SER
pid = fork_process(server_sock,"receiver R",0);
#else
pid = fork();
#endif
if (pid<0){
LOG(L_ERR,"ERROR:accept_connection(): fork() failed > %s\n",strerror(errno));
goto error;
}
if (pid==0){
/* child */
if (listening_socks) {
pkg_free(listening_socks);
listening_socks=0;
}
dp_add_pid(pid);
/* jump to this method in recieve.c */
receiver_process(*new_sock);
LOG(L_CRIT,"ERROR:accept_connection(): receiver_process finished without exit!\n");
exit(-1);
}else{
/* parent */
LOG(L_INFO,"INFO:accept_connection(): Receiver process forked [%d]\n",pid);
}
return 1;
error:
return 0;
}
int main(void){
LCD_init();
LCD_clr();
receiver_init();
while(1){
print_at(0, 0,0);
print_at(5, 0,1);
print_at(10,0,2);
print_at(0, 1,3);
print_at(10,1,4);
_delay_ms(100);
}
return 0;
}
static void test_socket_transport(void)
{
struct async_transport *st
= socket_transport_create(socket_factory(), "127.0.0.1");
struct receiver receiver;
struct sender senders[MESSAGES];
size_t i;
receiver_init(&receiver, st);
for (i = 0; i < MESSAGES; i++)
sender_init(&senders[i], st, receiver_address(&receiver));
application_run();
for (i = 0; i < MESSAGES; i++)
sender_fini(&senders[i]);
receiver_fini(&receiver);
async_transport_destroy(st);
}
/**
* Start the CDiameterPeer operations.
* It forks all the processes required.
* @param blocking - if this is set, use the calling processes for the timer and never
* return; else fork a new one for the timer and return
* @returns 1 on success, 0 on error, never if blocking
*/
int diameter_peer_start(int blocking)
{
int pid;
int k=0;
peer *p;
/* fork workers */
for(k=0;k<config->workers;k++){
pid = fork_process(1001+k,"cdp_worker",1);
if (pid==-1){
LM_CRIT("init_diameter_peer(): Error on fork() for worker!\n");
return 0;
}
if (pid==0) {
srandom(time(0)*k);
snprintf(pt[process_no].desc, MAX_PT_DESC,"cdp worker child=%d", k );
if (cfg_child_init()) return 0;
worker_process(k);
LM_CRIT("init_diameter_peer(): worker_process finished without exit!\n");
exit(-1);
}else{
dp_add_pid(pid);
}
}
/* init the fd_exchange pipes */
receiver_init(NULL);
for(p = peer_list->head,k=0;p;p=p->next,k++)
receiver_init(p);
/* fork receiver for unknown peers */
pid = fork_process(1001+k,"cdp_receiver_peer_unkown",1);
if (pid==-1){
LM_CRIT("init_diameter_peer(): Error on fork() for unknown peer receiver!\n");
return 0;
}
if (pid==0) {
srandom(time(0)*k);
snprintf(pt[process_no].desc, MAX_PT_DESC,
"cdp receiver peer unknown");
if (cfg_child_init()) return 0;
receiver_process(NULL);
LM_CRIT("init_diameter_peer(): receiver_process finished without exit!\n");
exit(-1);
}else{
dp_add_pid(pid);
}
/* fork receivers for each pre-configured peers */
lock_get(peer_list_lock);
for(p = peer_list->head,k=-1;p;p = p->next,k--){
pid = fork_process(1001+k,"cdp_receiver_peer",1);
if (pid==-1){
LM_CRIT("init_diameter_peer(): Error on fork() for peer receiver!\n");
return 0;
}
if (pid==0) {
srandom(time(0)*k);
snprintf(pt[process_no].desc, MAX_PT_DESC,
"cdp_receiver_peer=%.*s", p->fqdn.len,p->fqdn.s );
if (cfg_child_init()) return 0;
receiver_process(p);
LM_CRIT("init_diameter_peer(): receiver_process finished without exit!\n");
exit(-1);
}else{
dp_add_pid(pid);
}
}
lock_release(peer_list_lock);
/* Fork the acceptor process (after receivers, so it inherits all the right sockets) */
pid = fork_process(1000,"cdp_acceptor",1);
if (pid==-1){
LM_CRIT("init_diameter_peer(): Error on fork() for acceptor!\n");
return 0;
}
if (pid==0) {
if (cfg_child_init()) return 0;
acceptor_process(config);
LM_CRIT("init_diameter_peer(): acceptor_process finished without exit!\n");
exit(-1);
}else{
dp_add_pid(pid);
}
/* fork/become timer */
if (blocking) {
dp_add_pid(getpid());
if (cfg_child_init()) return 0;
timer_process(1);
}
else{
pid = fork_process(1001,"cdp_timer",1);
if (pid==-1){
LM_CRIT("init_diameter_peer(): Error on fork() for timer!\n");
return 0;
}
if (pid==0) {
if (cfg_child_init()) return 0;
timer_process(0);
LM_CRIT("init_diameter_peer(): timer_process finished without exit!\n");
exit(-1);
}else{
dp_add_pid(pid);
}
}
return 1;
}
/**
* Initiate a connection to a peer.
* @param p - peer to connect to
* @returns socket if OK, -1 on error
*/
int peer_connect(peer *p)
{
int sock;
int pid;
unsigned char servip[4];
struct sockaddr_in servaddr;
unsigned int option = 1;
struct hostent *host=0;
host = gethostbyname(p->fqdn.s);
if (!host){
LOG(L_WARN,"WARNING:peer_connect(): Error opening connection to %.*s:%d >%s\n",
p->fqdn.len,p->fqdn.s,p->port,strerror(h_errno));
goto error;
}
sock = socket(AF_INET, SOCK_STREAM, 0);
if ( sock==-1) {
LOG(L_ERR,"ERROR:peer_connect(): cannot connect, failed to create "
"new socket\n");
goto error;
}
memset( &servip, 0, sizeof(servip) );
memcpy( &servip, host->h_addr_list[0], 4);
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(p->port);
servaddr.sin_addr.s_addr = *(unsigned int*)servip;
if (connect(sock,(struct sockaddr*)&servaddr, sizeof(struct sockaddr_in))!=0) {
LOG(L_WARN,"WARNING:peer_connect(): Error opening connection to %.*s:%d >%s\n",
p->fqdn.len,p->fqdn.s,p->port,strerror(errno));
goto error;
}
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&option,sizeof(option));
LOG(L_INFO,"INFO:peer_connect(): Peer %.*s:%d connected\n",p->fqdn.len,p->fqdn.s,p->port);
receiver_init(sock,p);
#ifdef CDP_FOR_SER
pid = fork_process(p->port,"receiver I",0);
#else
pid = fork();
#endif
if (pid<0){
LOG(L_ERR,"ERROR:peer_connect(): fork() failed > %s\n",strerror(errno));
goto error;
}
if (pid==0){
/* child */
receiver_process(sock);
LOG(L_CRIT,"ERROR:peer_connect(): receiver_process finished without exit!\n");
exit(-1);
}else{
/* parent */
LOG(L_INFO,"INFO:peer_connect(): Receiver process forked [%d]\n",pid);
dp_add_pid(pid);
}
return sock;
error:
return -1;
}
void OIUC::prepare() {
/*---------------- ICS -----------------*/
ics_pool_init(&app_data.ics);
ics_pjsua_init(&app_data.ics);
ics_init(&app_data.ics);
//qDebug() << "INIT DONE";
#if 1
SET_LOG_LEVEL(4);
pj_log_set_level(3);
ics_set_default_callback(&on_reg_start_default);
ics_set_reg_start_callback(&on_reg_start_impl);
ics_set_reg_state_callback(&on_reg_state_impl);
ics_set_incoming_call_callback(&on_incoming_call_impl);
ics_set_call_state_callback(&on_call_state_impl);
ics_set_call_transfer_callback(&on_call_transfer_impl);
ics_set_call_media_state_callback(&on_call_media_state_impl);
ics_start(&app_data.ics);
config->getPortAsterisk(); // Don't need anymore, now set default bind to any port
ics_connect(&app_data.ics, config->getPortAsterisk());
qDebug() << "ICS STARTED";
#endif
/*---------------- PTTC -----------------*/
#if 0
pttc_init(&app_data.serial, &app_data.pttc, on_pttc_ptt, app_data.ics.pool);
pttc_start(&app_data.serial, config->getSerialFile().toLocal8Bit().data());
#endif
/*---------------- NODE -----------------*/
#if 1
memset(&app_data.node, 0, sizeof(app_data.node));
gm_cs = "udp:" + config->getArbiterIP() + ":" + QString::number(config->getPortSendToArbiter());
gmc_cs = "udp:" + config->getOIUCIP() + ":" + QString::number(config->getPortOIUCListen());
adv_cs = "udp:0.0.0.0:2015";
init_adv_server(&app_data, adv_cs.toLocal8Bit().data(), &app_data.node, app_data.ics.pool);
app_data.node.on_leaving_server_f = &on_leaving_server;
node_init(&app_data.node,
config->getOIUCName().toLocal8Bit().data(),
config->getLocation().toLocal8Bit().data(),
config->getOIUCDescription().toLocal8Bit().data(),
-1,
gm_cs.toLocal8Bit().data(),
gmc_cs.toLocal8Bit().data(),
app_data.ics.pool);
node_add_adv_server(&app_data.node, &app_data.adv_server);
qDebug() << "NODE INIT DONE";
#endif
/*---------------- GB -----------------*/
#if 1
memset(&app_data.gr, 0, sizeof(app_data.gr));
app_data.gr.on_online_report_f = &on_online_report;
app_data.gr.on_tx_report_f = &on_tx_report;
app_data.gr.on_rx_report_f = &on_rx_report;
app_data.gr.on_sq_report_f = &on_sq_report;
gb_receiver_init(&app_data.gr, (char *)GB_CS, app_data.ics.pool);
qDebug() << "GB DONE";
#endif
/*---------------- STREAM -----------------*/
#if 1
node_media_config(&app_data.node, &app_data.streamer, &app_data.receiver);
app_data.node.streamer->pool = app_data.node.receiver->pool = app_data.ics.pool;
app_data.node.streamer->ep = app_data.node.receiver->ep = pjsua_get_pjmedia_endpt();
pjmedia_codec_g711_init(app_data.node.streamer->ep);
pjmedia_codec_g711_init(app_data.node.receiver->ep);
streamer_init(app_data.node.streamer, app_data.node.streamer->ep, app_data.node.streamer->pool);
receiver_init(app_data.node.receiver, app_data.node.receiver->ep, app_data.node.receiver->pool, config->getNumberChannels());
streamer_config_dev_source(app_data.node.streamer, config->getSoundStreamerIdx());
receiver_config_dev_sink(app_data.node.receiver, config->getSoundReceiverIdx());
//streamer_config_dev_source(app_data.node.streamer, 2);
//receiver_config_dev_sink(app_data.node.receiver, 2);
//qDebug() << "STREAM INIT...DONE\n";
#endif
}
/**
* Initiate a connection to a peer.
* @param p - peer to connect to
* @returns socket if OK, -1 on error
*/
int peer_connect(peer *p)
{
int sock;
int pid;
unsigned int option = 1;
struct addrinfo *ainfo=0,*res=0,hints;
char buf[256],host[256],serv[256];
int error;
memset (&hints, 0, sizeof(hints));
//hints.ai_protocol = IPPROTO_SCTP;
//hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_ADDRCONFIG;
hints.ai_socktype = SOCK_STREAM;
sprintf(buf,"%d",p->port);
error = getaddrinfo(p->fqdn.s, buf, &hints, &res);
if (error!=0){
LOG(L_WARN,"WARNING:peer_connect(): Error opening connection to %.*s:%d >%s\n",
p->fqdn.len,p->fqdn.s,p->port,gai_strerror(error));
goto error;
}
for(ainfo = res;ainfo;ainfo = ainfo->ai_next)
{
if (getnameinfo(ainfo->ai_addr,ainfo->ai_addrlen,
host,256,serv,256,NI_NUMERICHOST|NI_NUMERICSERV)==0){
LOG(L_WARN,"INFO:peer_connect(): Trying to connect to %s port %s\n",
host,serv);
}
if ((sock = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol)) == -1) {
LOG(L_ERR,"ERROR:create_socket(): error creating client socket to %s port %s >"
" %s\n",host,serv,strerror(errno));
continue;
}
if (connect(sock,ainfo->ai_addr,ainfo->ai_addrlen)!=0) {
LOG(L_WARN,"WARNING:peer_connect(): Error opening connection to to %s port %s >%s\n",
host,serv,strerror(errno));
close(sock);
continue;
}
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&option,sizeof(option));
LOG(L_INFO,"INFO:peer_connect(): Peer %.*s:%d connected\n",p->fqdn.len,p->fqdn.s,p->port);
receiver_init(sock,p);
#ifdef CDP_FOR_SER
pid = fork_process(p->port,"receiver I",0);
#else
pid = fork();
#endif
if (pid<0){
LOG(L_ERR,"ERROR:peer_connect(): fork() failed > %s\n",strerror(errno));
goto error;
}
if (pid==0){
/* child */
receiver_process(sock);
LOG(L_CRIT,"ERROR:peer_connect(): receiver_process finished without exit!\n");
exit(-1);
}else{
/* parent */
LOG(L_INFO,"INFO:peer_connect(): Receiver process forked [%d]\n",pid);
dp_add_pid(pid);
}
if (res) freeaddrinfo(res);
return sock;
}
error:
if (res) freeaddrinfo(res);
return -1;
}
int main(int argc, char *argv[]) {
if (argc < 3) {
usage(argv[0]);
}
/*------------ CONFIG VARIABLES ------------*/
sqlite3 *db;
char *sql, sql_cmd[100];
sqlite3_stmt *stmt;
char id[10], location[30], desc[50];
char gm_cs[50], gmc_cs[50], adv_cs[50], gb_cs[50];
char gm_cs_tmp[50], gmc_cs_tmp[50], adv_cs_tmp[50];
int snd_dev_r0, snd_dev_r1, snd_dev_r2, snd_dev_r3;
int adv_port = ADV_PORT;
int gb_port = GB_PORT;
/*------------ INIT & STREAM VARIABLES ------------*/
pj_caching_pool cp;
pj_pool_t *pool;
pjmedia_endpt *ep;
endpoint_t streamers[MAX_NODE];
endpoint_t receivers[MAX_NODE];
adv_server_t adv_server;
/*------------ OTHER VARIABLES ------------*/
pthread_t thread;
char *dummy, option[10];
int i, n, input, f_quit = 0;
int snd_dev[4];
/*-----------------------------------------*/
SET_LOG_LEVEL(4);
/*------------ START ------------*/
#if 1
SHOW_LOG(3, "Press '1': Set sound devices configure\nPress 's': Show databases\nPress 'Space': Load databases\nPress 'q': Quit\n");
CALL_SQLITE (open (argv[2], &db));
while(!f_quit) {
dummy = fgets(option, sizeof(option), stdin);
switch(option[0]) {
case '1':
SHOW_LOG(3, "Set device index for each radio...\n");
for (i = 0; i < MAX_NODE; i++){
SHOW_LOG(3, "Radio %d: ", i);
dummy = fgets(option, sizeof(option), stdin);
input = atoi(&option[0]);
n = sprintf(sql_cmd, "UPDATE riuc_config SET snd_dev_r%d =(?)", i);
sql_cmd[n] = '\0';
CALL_SQLITE (prepare_v2 (db, sql_cmd, strlen (sql_cmd) + 1, & stmt, NULL));
CALL_SQLITE (bind_int (stmt, 1, input));
CALL_SQLITE_EXPECT (step (stmt), DONE);
}
SHOW_LOG(3, "Config completed\n");
f_quit = 1;
break;
case 's':
sql = "SELECT *FROM riuc_config";
CALL_SQLITE (prepare_v2 (db, sql, strlen (sql) + 1, &stmt, NULL));
while (sqlite3_step(stmt) == SQLITE_ROW) {
printf("ID: %s\n", sqlite3_column_text(stmt, 0));
printf("Location: %s\n", sqlite3_column_text(stmt, 1));
printf("Desc: %s\n", sqlite3_column_text(stmt, 2));
printf("GM_CS: %s\n", sqlite3_column_text(stmt, 3));
printf("GMC_CS: %s\n", sqlite3_column_text(stmt, 4));
printf("snd_dev_r0: %u\n", sqlite3_column_int(stmt, 5));
printf("snd_dev_r1: %u\n", sqlite3_column_int(stmt, 6));
printf("snd_dev_r2: %u\n", sqlite3_column_int(stmt, 7));
printf("snd_dev_r3: %u\n", sqlite3_column_int(stmt, 8));
}
break;
case ' ':
f_quit = 1;
break;
case 'q':
return 0;
default:
SHOW_LOG(3, "Unknown option\n");
}
}
f_quit = 0;
#endif
/*------------ LOAD CONFIG ------------*/
//CALL_SQLITE (open ("databases/riuc.db", &db));
sql = "SELECT * FROM riuc_config";
CALL_SQLITE (prepare_v2 (db, sql, strlen (sql) + 1, &stmt, NULL));
//WARNING: MAX NUMBER OF SOUND DEV = 4
while (sqlite3_step(stmt) == SQLITE_ROW) {
strcpy(id, sqlite3_column_text(stmt, 0));
strcpy(location, sqlite3_column_text(stmt, 1));
strcpy(desc, sqlite3_column_text(stmt, 2));
strcpy(gm_cs, sqlite3_column_text(stmt, 3));
strcpy(gmc_cs, sqlite3_column_text(stmt, 4));
snd_dev_r0 = sqlite3_column_int(stmt, 5);
snd_dev_r1 = sqlite3_column_int(stmt, 6);
snd_dev_r2 = sqlite3_column_int(stmt, 7);
snd_dev_r3 = sqlite3_column_int(stmt, 8);
auto_invite = sqlite3_column_int(stmt, 9);
}
snd_dev[0] = snd_dev_r0;
snd_dev[1] = snd_dev_r1;
snd_dev[2] = snd_dev_r2;
snd_dev[3] = snd_dev_r3;
n = sprintf(adv_cs, "udp:0.0.0.0:%d", adv_port);
adv_cs[n] = '\0';
n = sprintf(gb_cs, "udp:%s:%d",GB_MIP, gb_port);
gb_cs[n] = '\0';
SHOW_LOG(3, "========= LOADED CONFIG ========\n");
SHOW_LOG(3, "ID: %s\nDesc: %s\nGM_CS: %s\nGMC_CS: %s\nADV_CS: %s\nGB_CS: %s\nsnd_r0: %d\nsnd_r1: %d\nsnd_r2: %d\nsnd_r3: %dAuto invite: %d\n", id, desc, gm_cs, gmc_cs, adv_cs, gm_cs, snd_dev_r0, snd_dev_r1, snd_dev_r2, snd_dev_r3, auto_invite);
SHOW_LOG(3, "================================\n");
/*------------ INIT ------------*/
pj_init();
pj_caching_pool_init(&cp, NULL, 10000);
pool = pj_pool_create(&cp.factory, "pool1", 1024, 1024, NULL);
SHOW_LOG(2, "INIT CP AND POOL...DONE\n");
/*------------ NODE ------------*/
#if 1
init_adv_server(&adv_server, adv_cs, pool);
for (i = 0;i < MAX_NODE; i++) {
memset(gm_cs_tmp, 0, sizeof(gm_cs_tmp));
memset(gmc_cs_tmp, 0, sizeof(gmc_cs_tmp));
memset(adv_cs_tmp, 0, sizeof(adv_cs_tmp));
ansi_copy_str(gm_cs_tmp, gm_cs);
ansi_copy_str(adv_cs_tmp, adv_cs);
ansi_copy_str(gmc_cs_tmp, gmc_cs);
n = strlen(gmc_cs);
gmc_cs_tmp[n-1] = i + 1+ '0';
memset(&riuc_data.node[i], 0, sizeof(riuc_data.node[i]));
riuc_data.node[i].on_leaving_server_f = &on_leaving_server;
node_init(&riuc_data.node[i], id, location, desc, i, gm_cs_tmp, gmc_cs_tmp, pool);
node_add_adv_server(&riuc_data.node[i], &adv_server);
}
SHOW_LOG(2, "INIT NODE...DONE\n");
#endif
/*----------- GB --------------*/
#if 1
memset(&riuc_data.gb_sender, 0, sizeof(riuc_data.gb_sender));
n = sprintf(gb_cs, "udp:%s:%d", GB_MIP, GB_PORT);
gb_cs[n] = '\0';
gb_sender_create(&riuc_data.gb_sender, gb_cs);
SHOW_LOG(2, "INIT GB SENDER...DONE\n");
#endif
/*----------- RIUC4 --------------*/
#if 1
memset(riuc_data.serial_file, 0, sizeof(riuc_data.serial_file));
strncpy(riuc_data.serial_file, argv[1], strlen(argv[1]));
riuc4_init(&riuc_data.serial, &riuc_data.riuc4, &on_riuc4_status, pool);
riuc4_start(&riuc_data.serial, riuc_data.serial_file);
SHOW_LOG(2, "INIT RIUC4...DONE\n");
#if 1
for (i = 0; i < MAX_NODE; i++) {
riuc4_enable_rx(&riuc_data.riuc4, i);
usleep(250*1000);
riuc4_enable_tx(&riuc_data.riuc4, i);
usleep(250*1000);
}
#endif
SHOW_LOG(2, "ENABLE TX & RX...DONE\n");
#endif
/*----------- STREAM --------------*/
#if 1
SHOW_LOG(3, "INIT STREAM...START\n");
pjmedia_endpt_create(&cp.factory, NULL, 1, &ep);
#if 1
SHOW_LOG(3, "CODEC INIT\n");
pjmedia_codec_g711_init(ep);
for (i = 0; i < MAX_NODE; i++) {
SHOW_LOG(3, "NODE MEDIA CONFIG\n");
node_media_config(&riuc_data.node[i], &streamers[i], &receivers[i]);
SHOW_LOG(3, "SET POOL\n");
riuc_data.node[i].streamer->pool = pool;
riuc_data.node[i].receiver->pool = pool;
SHOW_LOG(3, "SET ENDPOINT\n");
riuc_data.node[i].receiver->ep = ep;
riuc_data.node[i].streamer->ep = ep;
SHOW_LOG(3, "INIT STREAMER & RECEIVER FOR NODE %d\n", i);
streamer_init(riuc_data.node[i].streamer, riuc_data.node[i].streamer->ep, riuc_data.node[i].receiver->pool);
receiver_init(riuc_data.node[i].receiver, riuc_data.node[i].receiver->ep, riuc_data.node[i].receiver->pool, 2);
}
SHOW_LOG(3, "CONFIG SOUND DEVICE\n");
for (i = 0; i < MAX_NODE; i++) {
streamer_config_dev_source(riuc_data.node[i].streamer, snd_dev[i]);
receiver_config_dev_sink(riuc_data.node[i].receiver, snd_dev[i]);
}
SHOW_LOG(2, "INIT STREAM...DONE\n");
/*---------------------------------*/
pthread_create(&thread, NULL, auto_register, &riuc_data);
#endif
#endif
while(!f_quit) {
dummy = fgets(option, sizeof(option), stdin);
switch(option[0]) {
case 'c':
for (i = 0; i < MAX_NODE; i++){
SHOW_LOG(3, "Set device index for each radio...\nRadio %d: ", i);
dummy = fgets(option, sizeof(option), stdin);
input = atoi(&option[0]);
n = sprintf(sql_cmd, "UPDATE riuc_config SET snd_dev_r%d =(?)", i);
sql_cmd[n] = '\0';
CALL_SQLITE (prepare_v2 (db, sql_cmd, strlen (sql_cmd) + 1, & stmt, NULL));
CALL_SQLITE (bind_int (stmt, 1, input));
CALL_SQLITE_EXPECT (step (stmt), DONE);
streamer_config_dev_source(riuc_data.node[i].streamer, input);
receiver_config_dev_sink(riuc_data.node[i].receiver, input);
}
SHOW_LOG(3, "Config completed\n");
break;
case 's':
sql = "SELECT *FROM riuc_config";
CALL_SQLITE (prepare_v2 (db, sql, strlen (sql) + 1, &stmt, NULL));
while (sqlite3_step(stmt) == SQLITE_ROW) {
printf("ID: %s\n", sqlite3_column_text(stmt, 0));
printf("Location: %s\n", sqlite3_column_text(stmt, 1));
printf("Desc: %s\n", sqlite3_column_text(stmt, 2));
printf("GM_CS: %s\n", sqlite3_column_text(stmt, 3));
printf("GMC_CS: %s\n", sqlite3_column_text(stmt, 4));
printf("snd_dev_r0: %u\n", sqlite3_column_int(stmt, 5));
printf("snd_dev_r1: %u\n", sqlite3_column_int(stmt, 6));
printf("snd_dev_r2: %u\n", sqlite3_column_int(stmt, 7));
printf("snd_dev_r3: %u\n", sqlite3_column_int(stmt, 8));
}
break;
case 't':
node_start_session(&riuc_data.node[0]);
break;
case 'y':
node_stop_session(&riuc_data.node[0]);
break;
case 'j':
node_invite(&riuc_data.node[0], "FTW");
break;
case 'l':
node_repulse(&riuc_data.node[0], "FTW");
break;
case 'q':
f_quit = 1;
break;
default:
SHOW_LOG(3, "Unknown option\n");
break;
}
}
SHOW_LOG(3, "Quiting...\n");
//pthread_join(thread, NULL);
sqlite3_finalize(stmt);
sqlite3_close(db);
return 0;
}
