elem* heap_insert(heap** H, int key, void* value){
node* newNode = node_init(key, value);
return heap_add(H, newNode);
}
int main(void) {
struct control_params_t control_params;
struct motor_params_t motor_params;
float temp;
uint8_t node_id;
hal_reset();
hal_set_low_frequency_callback(systick_cb);
/* Read parameters from flash */
Configuration configuration;
configuration.read_motor_params(motor_params);
configuration.read_control_params(control_params);
/* Set phase reverse if required */
if (configuration.get_param_value_by_index(PARAM_CONTROL_DIRECTION) == 1.0f) {
hal_set_pwm_reverse(true);
}
/* Estimate motor parameters */
hal_set_pwm_state(HAL_PWM_STATE_RUNNING);
g_controller_state.mode = CONTROLLER_IDENTIFYING;
g_parameter_estimator.start_estimation(hal_control_t_s);
hal_set_high_frequency_callback(identification_cb);
while (g_controller_state.mode == CONTROLLER_IDENTIFYING);
hal_set_high_frequency_callback(NULL);
/* Copy measured Rs and Ls */
if (!g_controller_state.fault) {
motor_params.rs_r = g_measured_rs_r;
motor_params.ls_h = g_measured_ls_h;
/*
This is not strictly necessary as the values are never written to
flash, but it does enable the measurements to be read via the
parameter interfaces.
*/
configuration.set_param_value_by_index(PARAM_MOTOR_RS,
motor_params.rs_r);
configuration.set_param_value_by_index(PARAM_MOTOR_LS,
motor_params.ls_h);
/* R/L * t must be < 1.0; R must be < 1.0 */
if (motor_params.rs_r / motor_params.ls_h * hal_control_t_s >= 1.0f ||
motor_params.rs_r > 1.0f) {
g_controller_state.fault = true;
}
}
/* Initialize the system with the motor parameters */
((volatile StateEstimator*)&g_estimator)->set_control_params(
control_params.bandwidth_hz, hal_control_t_s);
((volatile StateEstimator*)&g_estimator)->set_motor_params(
motor_params.rs_r, motor_params.ls_h, motor_params.phi_v_s_per_rad,
hal_control_t_s);
((volatile StateEstimator*)&g_estimator)->reset_state();
((volatile DQCurrentController*)&g_current_controller)->set_params(
motor_params, control_params, hal_control_t_s);
/* Set up the control parameters */
*((volatile float*)&g_controller_constants.idle_speed_rad_per_s) =
motor_params.idle_speed_rad_per_s;
*((volatile float*)&g_controller_constants.spinup_rate_rad_per_s2) =
motor_params.spinup_rate_rad_per_s2;
*((volatile float*)&g_controller_constants.accel_current_a) =
motor_params.accel_voltage_v / motor_params.rs_r;
*((volatile float*)&g_controller_constants.max_current_a) =
motor_params.max_current_a;
*((volatile float*)&g_controller_constants.braking_current_a) =
motor_params.max_current_a * control_params.braking_frac;
*((volatile float*)&g_controller_constants.effective_inv_r) =
control_params.gain / motor_params.rs_r;
temp = 1.0f / (float(2.0 * M_PI) * control_params.bandwidth_hz);
*((volatile float*)&g_controller_constants.control_lpf_coeff) =
hal_control_t_s / (hal_control_t_s + temp);
/* Clear audio state */
g_audio_state.off_time = 0;
g_audio_state.phase_rad = 0.0f;
g_audio_state.angular_velocity_rad_per_u = 0.0f;
g_audio_state.volume_v = 0.0f;
/*
After starting the ISR tasks we are no longer able to access g_estimator,
g_current_controller and g_speed_controller, since they're updated from
the ISRs and not declared volatile.
*/
hal_set_high_frequency_callback(control_cb);
node_id = hal_get_can_node_id();
node_init(node_id, configuration);
node_run(node_id, configuration, motor_params, control_params);
}
void enqueue(b_queue b, char c) {
struct queue_t *q = b;
struct node_t *node = node_init(c);
node->next = q->front;
q->front = node;
}
// this function is called when we have received a new socket. We need to
// create a new node, and add it to our node list. We need to pass to the node
// any pointers to other sub-systems that it will need to have, and then we
// insert the node into the 'node-circle' somewhere. Finally, we need to add
// the new node to the event base.
static void server_event_handler(int hid, short flags, void *data)
{
server_t *server;
socklen_t addrlen;
struct sockaddr_storage addr;
int sfd;
node_t *node = NULL;
assert(hid >= 0);
assert(data != NULL);
server = (server_t *) data;
assert(server->handle == hid);
addrlen = sizeof(addr);
if ((sfd = accept(hid, (struct sockaddr *)&addr, &addrlen)) == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
/* these are transient, so don't log anything */
} else if (errno == EMFILE) {
if (server->verbose > 0)
fprintf(stderr, "Too many open connections\n");
// accept_new_conns(false);
} else {
perror("accept()");
}
}
// mark socket as non-blocking
if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 || fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
perror("setting O_NONBLOCK");
close(sfd);
}
printf("New Connection [%d]\n", sfd);
assert(node == NULL);
if (server->nodes[sfd] == NULL) {
printf("Creating a new node\n");
node = (node_t *) malloc(sizeof(node_t));
node_init(node);
server->nodes[sfd] = node;
node->handle = sfd;
node->verbose = server->verbose;
assert(node->active == false);
node->active = true;
assert(server->stats != NULL);
node->stats = server->stats;
assert(server->risp != NULL);
node->risp = server->risp;
assert(server->storepath != NULL);
node->storepath = server->storepath;
}
else {
node = server->nodes[sfd];
assert(node->storepath != NULL);
if (node->active == false) {
printf("Re-using an existing node\n");
node->handle = sfd;
node->active = true;
// clear our base out... just to be sure.
cmdClear(node);
}
else {
assert(node->handle != sfd);
assert(0);
// need to code for an instance where we use some other slot.
}
}
assert(server->event.ev_base != NULL);
// setup the event handling...
event_set(&node->event, sfd, EV_READ | EV_PERSIST, node_event_handler, (void *)node);
event_base_set(server->event.ev_base, &node->event);
event_add(&node->event, 0);
}
void run(EpmdVars *g)
{
struct EPMD_SOCKADDR_IN iserv_addr[MAX_LISTEN_SOCKETS];
int listensock[MAX_LISTEN_SOCKETS];
int num_sockets;
int i;
int opt;
unsigned short sport = g->port;
node_init(g);
g->conn = conn_init(g);
#ifdef HAVE_SYSTEMD_DAEMON
if (g->is_systemd)
{
int n;
dbg_printf(g,2,"try to obtain sockets from systemd");
n = sd_listen_fds(0);
if (n < 0)
{
dbg_perror(g,"cannot obtain sockets from systemd");
epmd_cleanup_exit(g,1);
}
else if (n == 0)
{
dbg_tty_printf(g,0,"systemd provides no sockets");
epmd_cleanup_exit(g,1);
}
else if (n > MAX_LISTEN_SOCKETS)
{
dbg_tty_printf(g,0,"cannot listen on more than %d IP addresses", MAX_LISTEN_SOCKETS);
epmd_cleanup_exit(g,1);
}
num_sockets = n;
for (i = 0; i < num_sockets; i++)
{
g->listenfd[i] = listensock[i] = SD_LISTEN_FDS_START + i;
}
}
else
{
#endif /* HAVE_SYSTEMD_DAEMON */
dbg_printf(g,2,"try to initiate listening port %d", g->port);
if (g->addresses != NULL && /* String contains non-separator characters if: */
g->addresses[strspn(g->addresses," ,")] != '\000')
{
char *tmp;
char *token;
int loopback_ok = 0;
if ((tmp = (char *)malloc(strlen(g->addresses) + 1)) == NULL)
{
dbg_perror(g,"cannot allocate memory");
epmd_cleanup_exit(g,1);
}
strcpy(tmp,g->addresses);
for(token = strtok(tmp,", "), num_sockets = 0;
token != NULL;
token = strtok(NULL,", "), num_sockets++)
{
struct EPMD_IN_ADDR addr;
#ifdef HAVE_INET_PTON
int ret;
if ((ret = inet_pton(FAMILY,token,&addr)) == -1)
{
dbg_perror(g,"cannot convert IP address to network format");
epmd_cleanup_exit(g,1);
}
else if (ret == 0)
#elif !defined(EPMD6)
if ((addr.EPMD_S_ADDR = inet_addr(token)) == INADDR_NONE)
#endif
{
dbg_tty_printf(g,0,"cannot parse IP address \"%s\"",token);
epmd_cleanup_exit(g,1);
}
if (IS_ADDR_LOOPBACK(addr))
loopback_ok = 1;
if (num_sockets - loopback_ok == MAX_LISTEN_SOCKETS - 1)
{
dbg_tty_printf(g,0,"cannot listen on more than %d IP addresses",
MAX_LISTEN_SOCKETS);
epmd_cleanup_exit(g,1);
}
SET_ADDR(iserv_addr[num_sockets],addr.EPMD_S_ADDR,sport);
}
free(tmp);
if (!loopback_ok)
{
SET_ADDR(iserv_addr[num_sockets],EPMD_ADDR_LOOPBACK,sport);
num_sockets++;
}
}
else
{
SET_ADDR(iserv_addr[0],EPMD_ADDR_ANY,sport);
num_sockets = 1;
}
#ifdef HAVE_SYSTEMD_DAEMON
}
#endif /* HAVE_SYSTEMD_DAEMON */
#if !defined(__WIN32__)
/* We ignore the SIGPIPE signal that is raised when we call write
twice on a socket closed by the other end. */
signal(SIGPIPE, SIG_IGN);
#endif
/*
* Initialize number of active file descriptors.
* Stdin, stdout, and stderr are still open.
*/
g->active_conn = 3 + num_sockets;
g->max_conn -= num_sockets;
FD_ZERO(&g->orig_read_mask);
g->select_fd_top = 0;
#ifdef HAVE_SYSTEMD_DAEMON
if (g->is_systemd)
for (i = 0; i < num_sockets; i++)
select_fd_set(g, listensock[i]);
else
{
#endif /* HAVE_SYSTEMD_DAEMON */
for (i = 0; i < num_sockets; i++)
{
if ((listensock[i] = socket(FAMILY,SOCK_STREAM,0)) < 0)
{
dbg_perror(g,"error opening stream socket");
epmd_cleanup_exit(g,1);
}
g->listenfd[i] = listensock[i];
/*
* Note that we must not enable the SO_REUSEADDR on Windows,
* because addresses will be reused even if they are still in use.
*/
#if !defined(__WIN32__)
opt = 1;
if (setsockopt(listensock[i],SOL_SOCKET,SO_REUSEADDR,(char* ) &opt,
sizeof(opt)) <0)
{
dbg_perror(g,"can't set sockopt");
epmd_cleanup_exit(g,1);
}
#endif
/* In rare cases select returns because there is someone
to accept but the request is withdrawn before the
accept function is called. We set the listen socket
to be non blocking to prevent us from being hanging
in accept() waiting for the next request. */
#if (defined(__WIN32__) || defined(NO_FCNTL))
opt = 1;
/* Gives warning in VxWorks */
if (ioctl(listensock[i], FIONBIO, &opt) != 0)
#else
opt = fcntl(listensock[i], F_GETFL, 0);
if (fcntl(listensock[i], F_SETFL, opt | O_NONBLOCK) == -1)
#endif /* __WIN32__ || VXWORKS */
dbg_perror(g,"failed to set non-blocking mode of listening socket %d",
listensock[i]);
if (bind(listensock[i], (struct sockaddr*) &iserv_addr[i],
sizeof(iserv_addr[i])) < 0)
{
if (errno == EADDRINUSE)
{
dbg_tty_printf(g,1,"there is already a epmd running at port %d",
g->port);
epmd_cleanup_exit(g,0);
}
else
{
dbg_perror(g,"failed to bind socket");
epmd_cleanup_exit(g,1);
}
}
if(listen(listensock[i], SOMAXCONN) < 0) {
dbg_perror(g,"failed to listen on socket");
epmd_cleanup_exit(g,1);
}
select_fd_set(g, listensock[i]);
}
#ifdef HAVE_SYSTEMD_DAEMON
}
sd_notifyf(0, "READY=1\n"
"STATUS=Processing port mapping requests...\n"
"MAINPID=%lu", (unsigned long) getpid());
#endif /* HAVE_SYSTEMD_DAEMON */
dbg_tty_printf(g,2,"entering the main select() loop");
select_again:
while(1)
{
fd_set read_mask = g->orig_read_mask;
struct timeval timeout;
int ret;
/* If we are idle we time out now and then to enable the code
below to close connections that are old and probably
hanging. Make sure that select will return often enough. */
timeout.tv_sec = (g->packet_timeout < IDLE_TIMEOUT) ? 1 : IDLE_TIMEOUT;
timeout.tv_usec = 0;
if ((ret = select(g->select_fd_top,
&read_mask, (fd_set *)0,(fd_set *)0,&timeout)) < 0) {
dbg_perror(g,"error in select ");
switch (errno) {
case EAGAIN:
case EINTR:
break;
default:
epmd_cleanup_exit(g,1);
}
}
else {
time_t now;
if (ret == 0) {
FD_ZERO(&read_mask);
}
if (g->delay_accept) { /* Test of busy server */
sleep(g->delay_accept);
}
for (i = 0; i < num_sockets; i++)
if (FD_ISSET(listensock[i],&read_mask)) {
if (do_accept(g, listensock[i]) && g->active_conn < g->max_conn) {
/*
* The accept() succeeded, and we have at least one file
* descriptor still free, which means that another accept()
* could succeed. Go do do another select(), in case there
* are more incoming connections waiting to be accepted.
*/
goto select_again;
}
}
/* Check all open streams marked by select for data or a
close. We also close all open sockets except ALIVE
with no activity for a long period */
now = current_time(g);
for (i = 0; i < g->max_conn; i++) {
if (g->conn[i].open == EPMD_TRUE) {
if (FD_ISSET(g->conn[i].fd,&read_mask))
do_read(g,&g->conn[i]);
else if ((g->conn[i].keep == EPMD_FALSE) &&
((g->conn[i].mod_time + g->packet_timeout) < now)) {
dbg_tty_printf(g,1,"closing because timed out on receive");
epmd_conn_close(g,&g->conn[i]);
}
}
}
}
}
}
void stack_push(b_stack b, char c) {
struct stack_t *stack = b;
struct node_t *node = node_init(c);
node->next = stack->top;
stack->top = node;
}
struct variable *sys_connect(struct context *context)
{
struct variable *arguments = (struct variable*)stack_pop(context->operand_stack);
const char *serveraddr = param_str(arguments, 1);
const int32_t serverport = param_int(arguments, 2);
struct variable *listener = ((struct variable*)array_get(arguments->list, 2));
int sockfd;
struct sockaddr_in servaddr;
CYASSL_CTX* ctx;
CYASSL* ssl;
node_init();
// Create and initialize CYASSL_CTX structure
if ( (ctx = CyaSSL_CTX_new(CyaTLSv1_client_method())) == NULL)
{
context->vm_exception = variable_new_str(context, byte_array_from_string("SSL_CTX_new error"));
CyaSSL_Cleanup();
return NULL;
}
// Load CA certificates into CYASSL_CTX
if (CyaSSL_CTX_load_verify_locations(ctx, "./conf/ca-cert.pem", 0) != SSL_SUCCESS)
{
context->vm_exception = variable_new_str(context, byte_array_from_string("Error loading ca-cert.pem, please check the file.\n"));
CyaSSL_CTX_free(ctx);
CyaSSL_Cleanup();
return NULL;
}
// Create Socket file descriptor
sockfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(serverport);
inet_pton(AF_INET, serveraddr, &servaddr.sin_addr);
// Blocking Connect to socket file descriptor
connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
// Create CYASSL object
if ((ssl = CyaSSL_new(ctx)) == NULL)
{
context->vm_exception = variable_new_str(context, byte_array_from_string("CyaSSL_new error"));
CyaSSL_CTX_free(ctx);
CyaSSL_Cleanup();
return NULL;
}
CyaSSL_set_fd(ssl, sockfd);
fprintf(stderr, "Connected on %d -- %p\n", sockfd, ssl);
struct thread_argument *ta = (struct thread_argument *)malloc(sizeof(struct thread_argument));
ta->find = context->find;
ta->listener = listener;
ta->ssl = ssl;
ta->fd = sockfd;
ta->cya = ctx;
if (socket_listeners == NULL)
socket_listeners = map_new_ex(NULL, &int_compare, &int_hash, &int_copy, &int_del);
map_insert(socket_listeners, (void*)(VOID_INT)sockfd, (void*)(VOID_INT)ta);
return variable_new_int(context, sockfd);
}
int main()
{
node* n = node_init('a');
printf("key: %d, value: %c, is_red: %d\n", n->key, n->value, n->color);
return 0;
}
void run(EpmdVars *g)
{
int listensock;
int i;
int opt;
struct EPMD_SOCKADDR_IN iserv_addr;
node_init(g);
g->conn = conn_init(g);
dbg_printf(g,2,"try to initiate listening port %d", g->port);
if ((listensock = socket(FAMILY,SOCK_STREAM,0)) < 0) {
dbg_perror(g,"error opening stream socket");
epmd_cleanup_exit(g,1);
}
g->listenfd = listensock;
/*
* Initialize number of active file descriptors.
* Stdin, stdout, and stderr are still open.
* One for the listen socket.
*/
g->active_conn = 3+1;
/*
* Note that we must not enable the SO_REUSEADDR on Windows,
* because addresses will be reused even if they are still in use.
*/
#if !defined(__WIN32__)
/* We ignore the SIGPIPE signal that is raised when we call write
twice on a socket closed by the other end. */
signal(SIGPIPE, SIG_IGN);
opt = 1; /* Set this option */
if (setsockopt(listensock,SOL_SOCKET,SO_REUSEADDR,(char* ) &opt,
sizeof(opt)) <0) {
dbg_perror(g,"can't set sockopt");
epmd_cleanup_exit(g,1);
}
#endif
/* In rare cases select returns because there is someone
to accept but the request is withdrawn before the
accept function is called. We set the listen socket
to be non blocking to prevent us from being hanging
in accept() waiting for the next request. */
#if (defined(__WIN32__) || defined(NO_FCNTL))
opt = 1;
if (ioctl(listensock, FIONBIO, &opt) != 0) /* Gives warning in VxWorks */
#else
opt = fcntl(listensock, F_GETFL, 0);
if (fcntl(listensock, F_SETFL, opt | O_NONBLOCK) == -1)
#endif /* __WIN32__ || VXWORKS */
dbg_perror(g,"failed to set non-blocking mode of listening socket %d",
listensock);
{ /* store port number in unsigned short */
unsigned short sport = g->port;
SET_ADDR_ANY(iserv_addr, FAMILY, sport);
}
if(bind(listensock,(struct sockaddr*) &iserv_addr, sizeof(iserv_addr)) < 0 )
{
if (errno == EADDRINUSE)
{
dbg_tty_printf(g,1,"there is already a epmd running at port %d",
g->port);
epmd_cleanup_exit(g,0);
}
else
{
dbg_perror(g,"failed to bind socket");
epmd_cleanup_exit(g,1);
}
}
dbg_printf(g,2,"starting");
if(listen(listensock, SOMAXCONN) < 0) {
dbg_perror(g,"failed to listen on socket");
epmd_cleanup_exit(g,1);
}
FD_ZERO(&g->orig_read_mask);
FD_SET(listensock,&g->orig_read_mask);
dbg_tty_printf(g,2,"entering the main select() loop");
select_again:
while(1)
{
fd_set read_mask = g->orig_read_mask;
struct timeval timeout;
int ret;
/* If we are idle we time out now and then to enable the code
below to close connections that are old and probably
hanging. Make sure that select will return often enough. */
timeout.tv_sec = (g->packet_timeout < IDLE_TIMEOUT) ? 1 : IDLE_TIMEOUT;
timeout.tv_usec = 0;
if ((ret = select(g->max_conn,&read_mask,(fd_set *)0,(fd_set *)0,&timeout)) < 0) {
dbg_perror(g,"error in select ");
switch (errno) {
case EAGAIN:
case EINTR:
break;
default:
epmd_cleanup_exit(g,1);
}
}
else {
time_t now;
if (ret == 0) {
FD_ZERO(&read_mask);
}
if (g->delay_accept) { /* Test of busy server */
sleep(g->delay_accept);
}
if (FD_ISSET(listensock,&read_mask)) {
if (do_accept(g, listensock) && g->active_conn < g->max_conn) {
/*
* The accept() succeeded, and we have at least one file
* descriptor still free, which means that another accept()
* could succeed. Go do do another select(), in case there
* are more incoming connections waiting to be accepted.
*/
goto select_again;
}
}
/* Check all open streams marked by select for data or a
close. We also close all open sockets except ALIVE
with no activity for a long period */
now = current_time(g);
for (i = 0; i < g->max_conn; i++) {
if (g->conn[i].open == EPMD_TRUE) {
if (FD_ISSET(g->conn[i].fd,&read_mask))
do_read(g,&g->conn[i]);
else if ((g->conn[i].keep == EPMD_FALSE) &&
((g->conn[i].mod_time + g->packet_timeout) < now)) {
dbg_tty_printf(g,1,"closing because timed out on receive");
epmd_conn_close(g,&g->conn[i]);
}
}
}
}
}
}
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;
}
/*
* ======== api_init ========
* Purpose:
* Module initialization used by Bridge API.
*/
bool api_init(void)
{
bool ret = true;
bool fdrv, fdev, fcod, fchnl, fmsg, fio;
bool fmgr, fproc, fnode, fdisp, fstrm, frmm;
if (api_c_refs == 0) {
/* initialize driver and other modules */
fdrv = drv_init();
fmgr = mgr_init();
fproc = proc_init();
fnode = node_init();
fdisp = disp_init();
fstrm = strm_init();
frmm = rmm_init();
fchnl = chnl_init();
fmsg = msg_mod_init();
fio = io_init();
fdev = dev_init();
fcod = cod_init();
ret = fdrv && fdev && fchnl && fcod && fmsg && fio;
ret = ret && fmgr && fproc && frmm;
if (!ret) {
if (fdrv)
drv_exit();
if (fmgr)
mgr_exit();
if (fstrm)
strm_exit();
if (fproc)
proc_exit();
if (fnode)
node_exit();
if (fdisp)
disp_exit();
if (fchnl)
chnl_exit();
if (fmsg)
msg_exit();
if (fio)
io_exit();
if (fdev)
dev_exit();
if (fcod)
cod_exit();
if (frmm)
rmm_exit();
}
}
if (ret)
api_c_refs++;
return ret;
}
static rstatus_t
gossip_pool_each_init(void *elem, void *data)
{
rstatus_t status;
struct server_pool *sp = elem;
gn_pool.ctx = sp->ctx;
gn_pool.name = &sp->name;
gn_pool.idx = sp->idx;
gn_pool.g_interval = sp->g_interval;
//dictDisableResize();
gn_pool.dict_dc = dictCreate(&string_table_dict_type, NULL);
gossip_set_seeds_provider(&sp->seed_provider);
uint32_t n_dc = array_n(&sp->datacenters);
if (n_dc == 0)
return DN_OK;
if (n_dc > 0) {
status = array_init(&gn_pool.datacenters, n_dc, sizeof(struct gossip_dc));
if (status != DN_OK) {
return status;
}
}
//add racks and datacenters
uint32_t dc_cnt = array_n(&sp->datacenters);
uint32_t dc_index;
for(dc_index = 0; dc_index < dc_cnt; dc_index++) {
struct datacenter *dc = array_get(&sp->datacenters, dc_index);
uint32_t rack_cnt = array_n(&dc->racks);
uint32_t rack_index;
for(rack_index = 0; rack_index < rack_cnt; rack_index++) {
struct rack *rack = array_get(&dc->racks, rack_index);
if (dictFind(gn_pool.dict_dc, rack->dc) == NULL) {
struct gossip_dc *g_dc = array_push(&gn_pool.datacenters);
gossip_dc_init(g_dc, rack->dc);
dictAdd(gn_pool.dict_dc, &g_dc->name, g_dc);
}
struct gossip_dc *g_dc = dictFetchValue(gn_pool.dict_dc, rack->dc);
if (dictFind(g_dc->dict_rack, rack->name) == NULL) {
log_debug(LOG_VERB, "What?? No rack in Dict for rack : '%.*s'", g_dc->name);
struct gossip_rack *g_rack = array_push(&g_dc->racks);
gossip_rack_init(g_rack, rack->dc, rack->name);
dictAdd(g_dc->dict_rack, &g_rack->name, g_rack);
}
}
}
uint32_t i, nelem;
for (i = 0, nelem = array_n(&sp->peers); i < nelem; i++) {
struct server *peer = array_get(&sp->peers, i);
struct gossip_dc *g_dc = dictFetchValue(gn_pool.dict_dc, &peer->dc);
struct gossip_rack *g_rack = dictFetchValue(g_dc->dict_rack, &peer->rack);
struct node *gnode = array_push(&g_rack->nodes);
node_init(gnode);
string_copy(&gnode->dc, peer->dc.data, peer->dc.len);
string_copy(&gnode->rack, g_rack->name.data, g_rack->name.len);
string_copy(&gnode->name, peer->name.data, peer->name.len);
string_copy(&gnode->pname, peer->pname.data, peer->pname.len); //ignore the port for now
gnode->port = peer->port;
gnode->is_local = peer->is_local;
if (i == 0) { //Don't override its own state
gnode->state = sp->ctx->dyn_state; //likely it is JOINING state
gnode->ts = (uint64_t)time(NULL);
current_node = gnode;
char *b_address = get_broadcast_address(sp);
string_deinit(&gnode->name);
string_copy(&gnode->name, b_address, dn_strlen(b_address));
} else {
gnode->state = DOWN;
gnode->ts = 1010101; //make this to be a very aged ts
}
struct dyn_token *ptoken = array_get(&peer->tokens, 0);
copy_dyn_token(ptoken, &gnode->token);
//copy socket stuffs
g_rack->nnodes++;
//add into dicts
dictAdd(g_rack->dict_name_nodes, &gnode->name, gnode);
dictAdd(g_rack->dict_token_nodes, token_to_string(&gnode->token), gnode);
node_count++;
}
//gossip_debug();
status = gossip_start(sp);
if (status != DN_OK) {
goto error;
}
return DN_OK;
error:
gossip_destroy(sp);
return DN_OK;
}
void list_add(list_t inst, void* val) {
node_t n;
//printf("Add %p\n", val);
n = node_init(val);
list_add_node(inst, n);
}
static void
negamax(struct node *node)
{
assert(node->alpha < node->beta);
node_init(node);
if (check_trivial_draw(node) == is_trivial_draw)
return;
ht_prefetch(node->tt, node->pos->zhash[0]);
if (adjust_depth(node) == too_deep)
return;
if (handle_mate_search(node) == mate_search_handled)
return;
if (setup_bounds(node) == stand_pat_cutoff)
return;
if (setup_moves(node) == no_legal_moves)
return;
if (node->forced_pv == 0) {
if (fetch_hash_value(node) == hash_cutoff)
return;
}
else {
int r = move_order_add_hint(node->mo, node->forced_pv, 0);
(void) r;
assert(r == 0);
}
if (try_null_move_prune(node) == prune_successfull)
return;
if (recheck_bounds(node) == alpha_beta_range_too_small)
return;
assert(node->beta > -max_value + 2);
assert(node->alpha < max_value - 2);
do {
move_order_pick_next(node->mo);
if (can_prune_moves(node))
break;
move m = mo_current_move(node->mo);
int LMR_factor;
setup_child_node(node, m, &LMR_factor);
int value = negamax_child(node);
if (LMR_factor != 0) {
if (value > node->alpha) {
reset_child_after_lmr(node);
value = negamax_child(node);
}
else {
debug_trace_tree_pop_move(node);
continue;
}
}
value = handle_beta_extension(node, m, value);
if (value > node->value) {
node->value = value;
if (value > node->alpha) {
node->alpha = value;
new_best_move(node, m);
if (node->alpha >= node->beta)
fail_high(node);
else
node->expected_type = PV_node;
}
}
debug_trace_tree_pop_move(node);
} while (search_more_moves(node));
ht_entry entry = hash_current_node_value(node);
setup_best_move(node);
assert(node->repetition_affected_any == 0 || !node->is_GHI_barrier);
assert(node->repetition_affected_best == 0 || !node->is_GHI_barrier);
if (node->depth > 0) {
if (node->best_move != 0)
entry = ht_set_move(entry, node->best_move);
if (node->null_move_search_failed)
entry = ht_set_no_null(entry);
if (ht_value_type(entry) != 0 || node->best_move != 0)
ht_pos_insert(node->tt, node->pos, entry);
}
if (node->value < node->lower_bound)
node->value = node->lower_bound;
node->forced_pv = 0;
}
// listens for incoming connections
void *sys_listen2(void *arg)
{
struct listen_arguments *la = (struct listen_arguments*)arg;
struct variable *listener = la->listener;
int serverport = la->serverport;
if (server_listeners == NULL)
server_listeners = map_new_ex(NULL, &int_compare, &int_hash, &int_copy, &int_del);
map_insert(server_listeners, (void*)(VOID_INT)serverport, listener);
node_init();
// Create and initialize CYASSL_CTX structure
CYASSL_CTX* ctx;
if ( (ctx = CyaSSL_CTX_new(CyaTLSv1_server_method())) == NULL)
{
fprintf(stderr, "CyaSSL_CTX_new error.\n");
return NULL;
}
// Load CA certificates into CYASSL_CTX
if (CyaSSL_CTX_load_verify_locations(ctx, "./conf/ca-cert.pem", 0) != SSL_SUCCESS)
{
fprintf(stderr, "Error loading ca-cert.pem, please check the file.\n");
return NULL;
}
// Load server certificate into CYASSL_CTX
if (CyaSSL_CTX_use_certificate_file(ctx, "conf/server-cert.pem", SSL_FILETYPE_PEM) != SSL_SUCCESS)
{
fprintf(stderr, "Error loading server-cert.pem, please check the file.\n");
return NULL;
}
// Load server key into CYASSL_CTX
if (CyaSSL_CTX_use_PrivateKey_file(ctx, "conf/server-key.pem", SSL_FILETYPE_PEM) != SSL_SUCCESS)
{
fprintf(stderr, "Error loading server-key.pem, please check the file.\n");
return NULL;
}
// open the server socket over specified port 8080 to accept client connections
int listenfd = socket(AF_INET, SOCK_STREAM, 0);
// setsockopt: Eliminates "ERROR on binding: Address already in use" error.
int optval = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval, sizeof(int));
struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(serverport);
bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
listen(listenfd, 5);
// create thread for processing each client request
struct sockaddr_in client_addr;
socklen_t sin_size = sizeof (struct sockaddr_in);
for(;;)
{
int connfd = accept(listenfd, (struct sockaddr *) &client_addr, &sin_size );
DEBUGPRINT("\n Got a connection from (%s , %d)\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
// Create CYASSL Object
CYASSL* ssl;
if ((ssl = CyaSSL_new(ctx)) == NULL) {
fprintf(stderr, "CyaSSL_new error");
return NULL;
}
CyaSSL_set_fd(ssl, connfd);
struct thread_argument *ta = (struct thread_argument *)malloc(sizeof(struct thread_argument));
ta->find = la->find;
ta->listener = listener;
ta->ssl = ssl;
ta->fd = connfd;
ta->cya = ctx;
DEBUGPRINT("listenting on %d - %p\n", connfd, ta->ssl);
pthread_t child;
pthread_create(&child, NULL, incoming_connection, &ta);
}
return NULL;
}
node_t node_blank() {
node_t node;
alloc_struct(sizeof(struct Node),(void **) &node);
return node_init(node);
}
node_t *graph_add_sam(graph_t *g, bam1_t *b, ref_t *ref, int32_t use_threads)
{
bam_aln_t *aln = NULL;
int32_t aln_start, aln_index, ref_index, aln_ref_index;
int32_t i;
node_t *prev_node=NULL, *cur_node=NULL, *ret_node=NULL;
uint8_t type, strand;
aln_start = b->core.pos+1;
aln_ref_index = b->core.tid;
aln = bam_aln_init(b, ref);
strand = bam1_strand(b);
// --- SYNC ON ---
if(1 == use_threads) pthread_mutex_lock(&graph_mutex); // synchronize start
if(aln_start < g->position_start) {
int32_t diff = g->position_start - aln_start;
graph_nodes_realloc(g, g->position_end - aln_start + 1); // alloc more memory if needed
// shift up
for(i=g->position_end-g->position_start;0<=i;i--) {
// swap
node_list_t *list = g->nodes[i+diff];
g->nodes[i+diff] = g->nodes[i];
g->nodes[i] = list;
}
g->position_start = aln_start;
}
if(1 == g->is_empty) {
for(i=0;i<g->position_end - g->position_start + 1;i++) {
node_list_clear(g->nodes[i]);
assert(0 == g->nodes[i]->length); // DEBUG
}
g->position_start = aln_start;
if(ALN_GAP == aln->ref[0]) {
g->position_start--;
}
g->position_end = g->position_start;
g->contig = aln_ref_index + 1;
g->is_empty = 0;
}
if(1 == use_threads) pthread_mutex_unlock(&graph_mutex); // synchronize end
// --- SYNC OFF ---
for(aln_index=0,ref_index=-1;aln_index<aln->length;aln_index++,prev_node=cur_node) {
// Skip over a deletion
while(ALN_GAP == aln->read[aln_index]) {
aln_index++;
ref_index++;
}
if(aln->read[aln_index] == aln->ref[aln_index]) { // match
type = NODE_MATCH;
}
else if(aln->ref[aln_index] == ALN_GAP) { // insertion
type = NODE_INSERTION;
}
else { // mismatch
type = NODE_MISMATCH;
}
if(NULL == prev_node || NODE_INSERTION != __node_type(prev_node)) { // previous was an insertion, already on the position
ref_index++;
}
cur_node = graph_add_node(g,
node_init(aln->read[aln_index], type, g->contig, aln_start + ref_index, prev_node),
prev_node,
use_threads);
if(NULL == prev_node && 0 == strand) { // first node and forward strand
ret_node = cur_node;
}
}
if(1 == strand) {
ret_node = cur_node;
}
bam_aln_free(aln);
return ret_node;
}
struct node *node_new() {
struct node *this = malloc(sizeof(struct node));
node_init(this);
return this;
}
void *dop2p(void* peer) {
FILE *fp;
Peer* p = (Peer*)peer;
uint32_t filelen;
int n, sockfd = p->port;
char rq[MAXLINE], *buffer, *f;
if ((recv(sockfd, &n, sizeof(int), 0)) < 0) { syserr("can't receive port number from client"); exit(0); }
p->port = ntohl(n);
// receive the size of the file
if (recv(sockfd, &filelen, sizeof(int), 0) < 0) syserr("can't receive from server");
filelen = ntohl(filelen);
// receive the file
f = (char*)malloc(filelen*sizeof(char));
if (recvall(sockfd, f, &filelen) < 0) syserr("can't receive from server");
char *s = f, *e = f;
while (e < f + filelen && *e != '\0') {
if (*e == '\n') {
*e = '\0';
int found = 0;
pthread_mutex_lock(&peer_mutex);
Node* node;
node = (Node*)malloc(sizeof(Node));
node_init(node, s, inet_ntoa(p->peer_addr.sin_addr), p->port);
list_add(list, node);
pthread_mutex_unlock(&peer_mutex);
s = e+1;
}
e++;
}
free(f);
buffer = (char*)malloc(MAXLINE*sizeof(char));
while (1) {
memset(rq,0, MAXLINE*sizeof(char));
if ((recv(sockfd, rq, MAXLINE, 0)) < 0) { syserr("can't receive from client"); exit(0); }
if (!strcmp(rq, LIST)) {
// execute ls on command line and write outcome into a file
pthread_mutex_lock(&peer_mutex);
fp = fopen("list.txt", "wb");
Node* cur = list->head;
n = 0;
while (cur) {
memset(buffer, 0, sizeof(buffer));
sprintf(buffer, "[%d] %s, %s:%d\n", n++, cur->filename, cur->ip, cur->port);
cur = cur->next;
int k = 0;
while (*(buffer+k++) != '\n');
fwrite(buffer, 1, k, fp);
}
fclose(fp);
fp = fopen("list.txt", "rb"); fseek(fp, 0, SEEK_END);
filelen = ftell(fp); rewind(fp);
filelen++;
filelen = htonl(filelen);
//notify client the size of the file
if (send(sockfd, &filelen, sizeof(int), 0) < 0) syserr("can't send to client");
//send file to the client
filelen = ntohl(filelen);
buffer = (char *)realloc(buffer, (filelen) * sizeof(char));
memset(buffer, 0, filelen);
fread(buffer, filelen-1, 1, fp);
fclose(fp);
pthread_mutex_unlock(&peer_mutex);
buffer[filelen-1] = '\0';
if (sendall(sockfd, buffer, &filelen) < 0) syserr("can't send to client");
}
else if (!strcmp(rq, EXIT)) {
pthread_mutex_lock(&peer_mutex);
if (list->head) {
Node* cur = list->head;
while (cur->next) {
if (!strcmp(cur->next->ip, inet_ntoa(p->peer_addr.sin_addr)) && cur->next->port == p->port) {
Node* tmp = cur->next;
cur->next = cur->next->next;
node_free(tmp);
list->size--;
} else
cur = cur->next;
}
if (!strcmp(list->head->ip, inet_ntoa(p->peer_addr.sin_addr)) && list->head->port == p->port) {
Node* tmp = list->head;
list->head = list->head->next;
node_free(tmp);
list->size--;
}
}
pthread_mutex_unlock(&peer_mutex);
printf("Peer %s:%d has left.\n", inet_ntoa(p->peer_addr.sin_addr), p->port);
break;
} else if (!strcmp(rq, UPDATE)) {
if ((recv(sockfd, rq, MAXLINE, 0)) < 0) { syserr("can't receive from client"); exit(0); }
char* s = (char*)malloc(MAXLINE*sizeof(char));
strcpy(s, rq);
s[strlen(s)] = '\0';
pthread_mutex_lock(&peer_mutex);
Node* node;
node = (Node*)malloc(sizeof(Node));
node_init(node, s, inet_ntoa(p->peer_addr.sin_addr), p->port);
list_add(list, node);
pthread_mutex_unlock(&peer_mutex);
}
else {
pthread_mutex_lock(&peer_mutex);
if (list->head) {
Node* cur = list->head;
while (cur->next) {
if (!strcmp(cur->next->ip, inet_ntoa(p->peer_addr.sin_addr)) && cur->next->port == p->port) {
Node* tmp = cur->next;
cur->next = cur->next->next;
node_free(tmp);
list->size--;
} else
cur = cur->next;
}
if (!strcmp(list->head->ip, inet_ntoa(p->peer_addr.sin_addr)) && list->head->port == p->port) {
Node* tmp = list->head;
list->head = list->head->next;
node_free(tmp);
list->size--;
}
}
pthread_mutex_unlock(&peer_mutex);
printf("Peer %s:%d has left.\n", inet_ntoa(p->peer_addr.sin_addr), p->port);
break;
}
}
free(buffer);
pthread_exit(NULL);
}
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
}
int lexical(struct lex_state_t* plex_state,
vector<token_pair_t>* ptoken_pairs) {
int ch;
int action = ACT_IDLE;
token_pair_t token_pair;
while (1) {
ch = get_next_char(plex_state);
if (DEBUG)
printf("get char:%c(0x%02X) @(%3d, %3d)\n", ch, ch,
plex_state->lineno, plex_state->rowno);
switch (plex_state->cur_state) {
case STA_START:
action = _handler_start(ch, plex_state, &token_pair);
break;
case STA_ASSIGN:
action = _handler_assign(ch, plex_state, &token_pair);
break;
case STA_COMMENT:
action = _handler_comment(ch, plex_state, &token_pair);
break;
case STA_DONE:
action = _handler_done(ch, plex_state, &token_pair);
break;
case STA_GREATER:
action = _handler_greater(ch, plex_state, &token_pair);
break;
case STA_LESS:
action = _handler_less(ch, plex_state, &token_pair);
break;
case STA_ID:
action = _handler_id(ch, plex_state, &token_pair);
break;
case STA_NUMBER:
action = _handler_number(ch, plex_state, &token_pair);
break;
case STA_NUMBER_TMP:
action = _handler_number_tmp(ch, plex_state, &token_pair);
break;
case STA_OCTNUMBER:
action = _handler_number_oct(ch, plex_state, &token_pair);
break;
case STA_HEXNUMBER_TMP:
action = _handler_number_hex_tmp(ch, plex_state, &token_pair);
break;
case STA_HEXNUMBER:
action = _handler_number_hex(ch, plex_state, &token_pair);
break;
case STA_STRING:
action = _handler_string(ch, plex_state, &token_pair);
break;
case STA_ERROR:
action = _handler_error(ch, plex_state, &token_pair);
break;
default:
fprintf(stderr, "State:%d had not been handled!\n",
plex_state->cur_state);
action = ACT_REPORT_ERROR;
}
switch (action) {
case ACT_PUSH_NODE:
if (DEBUG)
printf("Node: (%d,%s)\n", token_pair.kind,
token_pair.value.c_str());
ptoken_pairs->push_back(token_pair);
node_init(&token_pair);
break;
case ACT_COMMENT:
if (DEBUG) printf("Comment: %s\n", token_pair.value.c_str());
node_init(&token_pair);
break;
case ACT_REPORT_ERROR:
action_report_error(plex_state);
token_pair.value.clear();
if (IGNORE_ERROR) {
plex_state->cur_state = STA_START;
plex_state->err_type = 0;
break;
} else {
return 1;
}
case ACT_EXIT:
token_pair.kind = TK_ENDFILE;
ptoken_pairs->push_back(token_pair);
if (DEBUG)
printf("Node: (%d,%s)\n", token_pair.kind,
token_pair.value.c_str());
return 0;
}
}
return 0;
}
void linkedlist_init(linkedlist_t *ll) {
//init struct vars
node_init(&ll->sentinel, NULL);
ll->sentinel.nextptr = ll->sentinel.prevptr = &ll->sentinel;
ll->size = 0;
}
const struct sensors_input_cache_entry_t *sensors_input_cache_get(
const char *name)
{
int rc;
int fd;
DIR *dir;
struct dirent * item;
struct list_node *member;
struct input_dev_list *temp;
pthread_t id[MAX_EVENT_DRIVERS];
unsigned int i = 0;
unsigned int threads = 0;
const struct sensors_input_cache_entry_t *found = NULL;
pthread_mutex_lock(&util_mutex);
if (!list_initialized) {
node_init(&head);
list_initialized = 1;
}
temp = lookup(name, NULL);
if (temp) {
found = &temp->entry;
goto exit;
}
dir = opendir(INPUT_EVENT_DIR);
if (!dir) {
ALOGE("%s: error opening '%s'\n", __func__,
INPUT_EVENT_DIR);
goto exit;
}
while ((item = readdir(dir)) != NULL) {
if (strncmp(item->d_name, INPUT_EVENT_BASENAME,
sizeof(INPUT_EVENT_BASENAME) - 1) != 0) {
continue;
}
temp = (temp ? temp : malloc(sizeof(*temp)));
if (temp == NULL) {
ALOGE("%s: malloc error!\n", __func__);
break;
}
/* skip already cached entries */
snprintf(temp->entry.event_path, sizeof(temp->entry.event_path),
"%s%s", INPUT_EVENT_DIR, item->d_name);
if (lookup(NULL, temp->entry.event_path))
continue;
/* make sure we have access */
fd = open(temp->entry.event_path, O_RDONLY);
if (fd < 0) {
ALOGE("%s: cant open %s", __func__,
item->d_name);
continue;
}
rc = ioctl(fd, EVIOCGNAME(sizeof(temp->entry.dev_name)),
temp->entry.dev_name);
/* close in parallell to optimize boot time */
pthread_create(&id[threads++], NULL,
close_input_dev_fd, (void*) fd);
if (rc < 0) {
ALOGE("%s: cant get name from %s", __func__,
item->d_name);
continue;
}
temp->entry.nr = atoi(item->d_name +
sizeof(INPUT_EVENT_BASENAME) - 1);
node_add(&head, &temp->node);
if (!found && !strncmp(temp->entry.dev_name, name,
sizeof(temp->entry.dev_name) - 1))
found = &temp->entry;
temp = NULL;
}
closedir(dir);
for(i = 0; i < threads; ++i)
pthread_join(id[i], NULL);
exit:
pthread_mutex_unlock(&util_mutex);
return found;
}
