int main(int argc, char *argv[])
{
int opt;
bool dump_flag = false;
buffer = (char *)malloc(BUFFER_SIZE);
while ((opt = getopt(argc, argv, "d")) != -1) {
switch (opt) {
case 'd':
dump_flag = true;
break;
default:
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
}
if (argc - optind < 2 || argc - optind > 4) {
fprintf(stderr, "wrong argument count\n");
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
if (strcmp(argv[optind], "listen") == 0) {
optind++;
_server_socket = open_server_socket(atoi(argv[optind]));
server_with_select(NULL, dump_flag);
} else if (strcmp(argv[optind], "send") == 0) {
UDPClient *client;
struct sockaddr_in from_address, to_address;
size_t len;
ssize_t read;
optind++;
to_address = socket_address(argv[optind], atoi(argv[optind + 1]));
from_address = socket_address(NULL, atoi(argv[optind + 1]));
read = getline(&buffer, &len, stdin);
if (read > 0) {
client = new UDPClient(from_address, to_address, -1, dump_flag);
client->send_to_server(buffer, read);
}
} else if (strcmp(argv[optind], "relay") == 0) {
struct sockaddr_in to_address;
optind++;
_server_socket = open_server_socket(atoi(argv[optind]));
to_address = socket_address(argv[optind + 1], atoi(argv[optind + 2]));
server_with_select(&to_address, dump_flag);
}
return 0;
}
static void
test_connect_first (void)
{
int s = open_server_socket ();
struct sockaddr_in ia;
socklen_t addrlen;
int c1, c2;
if (poll1_nowait (s, POLLIN | POLLRDNORM | POLLRDBAND) != 0)
failed ("can read, socket not connected");
c1 = connect_to_socket (false);
if (poll1_wait (s, POLLIN | POLLRDNORM | POLLRDBAND) != (POLLIN | POLLRDNORM))
failed ("expecting POLLIN | POLLRDNORM on passive socket");
if (poll1_nowait (s, POLLIN | POLLRDBAND) != POLLIN)
failed ("expecting POLLIN on passive socket");
if (poll1_nowait (s, POLLRDNORM | POLLRDBAND) != POLLRDNORM)
failed ("expecting POLLRDNORM on passive socket");
addrlen = sizeof (ia);
c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
close (s);
close (c1);
close (c2);
}
/*
* main() - parse command line, create a socket, handle requests
*/
int main(int argc, char **argv) {
/* for getopt */
long opt;
int lru_size = 10;
int port = 9000;
check_team(argv[0]);
/* parse the command-line options. They are 'p' for port number, */
/* and 'l' for lru cache size. 'h' is also supported. */
while ((opt = getopt(argc, argv, "hl:p:")) != -1) {
switch(opt) {
case 'h':
help(argv[0]);
break;
case 'l':
lru_size = atoi(argv[0]);
break;
case 'p':
port = atoi(optarg);
break;
}
}
/* open a socket, and start handling requests */
int fd = open_server_socket(port);
handle_requests(fd, file_server, lru_size);
exit(0);
}
static void
test_connect_first (void)
{
int s = open_server_socket ();
struct sockaddr_in ia;
socklen_t addrlen;
int c1, c2;
if (do_select_nowait (s, SEL_IN | SEL_EXC) != 0)
failed ("can read, socket not connected");
c1 = connect_to_socket (false);
if (do_select_wait (s, SEL_IN | SEL_EXC) != SEL_IN)
failed ("expecting readability on passive socket");
if (do_select_nowait (s, SEL_IN | SEL_EXC) != SEL_IN)
failed ("expecting readability on passive socket");
addrlen = sizeof (ia);
c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
close (s);
close (c1);
close (c2);
}
void * socket_uart_send_manager(void * arg)
{
int listen_fd = open_server_socket(UNIX_SOCKET_UART_SEND);
int com_fd;
socklen_t len;
struct sockaddr_un clt_addr;
pthread_t real_send;
pthread_create(&real_send,
NULL,
uart_send_worker,
NULL);
while(1)
{
len = sizeof(clt_addr);
com_fd = accept(listen_fd,(struct sockaddr*)&clt_addr,&len);
if(com_fd < 0)
{
perror("cannot accept client connect request");
close(listen_fd);
unlink(UNIX_SOCKET_UART_SEND);
exit(-1);
}
int n = 0;
uint8_t recv_buf[MAX_BUFSIZ];
if( (n = read(com_fd,recv_buf,sizeof(recv_buf))) < 0)
{
LOG_ERROR("[%s] Read Error\n",__func__);
exit(-1);
}
LOG_DEBUG("I read a request message, the request is: %s",recv_buf);
if(is_invalid_message((char *)recv_buf, n))
{
LOG_ERROR("InvalidMessage");
process_message_invalid_message(com_fd);
close(com_fd);
}
else
{
message_t * message = deserialized_message(recv_buf,n);
uart_dev_t * dev = get_dev_by_name(message->name);
if(dev == NULL)
{
LOG_ERROR("InvalidName");
process_message_invalid_name(com_fd, message->name);
close(com_fd);
}
else
{
LOG_DEBUG("ValidMessage");
message->dev = dev;
queue_enqueue(context->send_queue, message);
process_message_succeed(com_fd);
close(com_fd);
}
}
}
return NULL;
}
int main()
{
int sockid = open_server_socket("localhost", 5555);
int newsockid = accept(sockid,0,0);
handle_connection(newsockid);
}
int main(int argc, char **argv)
{
int serfd;
if (argc != 4)
{
fprintf(stderr,
"Usage: %s <port> <device> <rate> - act as a serial forwarder on <port>\n"
"(listens to serial port <device> at baud rate <rate>)\n" ,
argv[0]);
exit(2);
}
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
fprintf(stderr, "Warning: failed to ignore SIGPIPE.\n");
open_serial(argv[2], platform_baud_rate(argv[3]));
serfd = serial_source_fd(src);
open_server_socket(atoi(argv[1]));
for (;;)
{
fd_set rfds;
int maxfd = -1;
struct timeval zero;
int serial_empty;
int ret;
zero.tv_sec = zero.tv_usec = 0;
FD_ZERO(&rfds);
fd_wait(&rfds, &maxfd, serfd);
fd_wait(&rfds, &maxfd, server_socket);
wait_clients(&rfds, &maxfd);
serial_empty = serial_source_empty(src);
if (serial_empty)
ret = select(maxfd + 1, &rfds, NULL, NULL, NULL);
else
{
ret = select(maxfd + 1, &rfds, NULL, NULL, &zero);
check_serial();
}
if (ret >= 0)
{
if (FD_ISSET(serfd, &rfds))
check_serial();
if (FD_ISSET(server_socket, &rfds))
check_new_client();
check_clients(&rfds);
}
}
}
int main(int argc, char *argv[])
{
int socket_fd = 0, conn_fd = 0;
int n, last;
char send_buffer[1025];
char receive_buffer[1025];
memset(receive_buffer, 0, sizeof(receive_buffer));
memset(send_buffer, 0, sizeof(send_buffer));
socket_fd = open_server_socket(5000);
printf("socket opened\n");
listen(socket_fd, 10);
printf("listening\n");
int f = open("destfile.txt", O_CREAT | O_WRONLY, (S_IWUSR | S_IRUSR | S_IWOTH | S_IROTH));
fchmod(f, (S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH));
while(1)
{
printf("accepting connection\n");
conn_fd = accept(socket_fd, (struct sockaddr*)NULL, NULL);
printf("writing\n");
snprintf(send_buffer, sizeof(send_buffer), "server says hello world!\n");
write(conn_fd, send_buffer, strlen(send_buffer));
printf("reading\n");
n = read(conn_fd, receive_buffer, sizeof(receive_buffer));
if (n >= 0){
if (n){
write(1, receive_buffer, n);//stdout
write(f, receive_buffer, n);
last = n-1;
}
}else{
printf("socket error\n");
}
printf("closing connection\n");
close(conn_fd);
sleep(1);
}
}
static void
test_socket_pair (void)
{
struct sockaddr_in ia;
socklen_t addrlen = sizeof (ia);
int s = open_server_socket ();
int c1 = connect_to_socket (false);
int c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
close (s);
test_pair (c1, c2);
close (c1);
write (c2, "foo", 3);
close (c2);
}
static void
test_accept_first (void)
{
#ifndef WINDOWS_NATIVE
int s = open_server_socket ();
struct sockaddr_in ia;
socklen_t addrlen;
char buf[3];
int c, pid;
pid = fork ();
if (pid < 0)
return;
if (pid == 0)
{
addrlen = sizeof (ia);
c = accept (s, (struct sockaddr *) &ia, &addrlen);
ASSERT (c >= 0);
close (s);
ASSERT (write (c, "foo", 3) == 3);
ASSERT (read (c, buf, 3) == 3);
shutdown (c, SHUT_RD);
close (c);
exit (0);
}
else
{
close (s);
c = connect_to_socket (true);
ASSERT (c >= 0);
if (poll1_nowait (c, POLLOUT | POLLWRNORM | POLLRDBAND)
!= (POLLOUT | POLLWRNORM))
failed ("cannot write after blocking connect");
ASSERT (write (c, "foo", 3) == 3);
wait (&pid);
if (poll1_wait (c, POLLIN) != POLLIN)
failed ("cannot read data left in the socket by closed process");
ASSERT (read (c, buf, 3) == 3);
ASSERT (write (c, "foo", 3) == 3);
if ((poll1_wait (c, POLLIN | POLLOUT) & (POLLHUP | POLLERR)) == 0)
failed ("expecting POLLHUP after shutdown");
close (c);
}
#endif
}
int main()
{
int sockid = open_server_socket("localhost", 5555);
while(true){
int newsockid = accept(sockid,0,0);
int pid = fork();
if (pid == -1){
throw std::runtime_error("Forking error");
}
if (pid == 0){
handle_connection(newsockid);
return 0;
}
}
}
static void
test_accept_first (void)
{
#ifndef WIN32_NATIVE
int s = open_server_socket ();
struct sockaddr_in ia;
socklen_t addrlen;
char buf[3];
int c, pid;
pid = fork ();
if (pid < 0)
return;
if (pid == 0)
{
addrlen = sizeof (ia);
c = accept (s, (struct sockaddr *) &ia, &addrlen);
close (s);
write (c, "foo", 3);
read (c, buf, 3);
shutdown (c, SHUT_RD);
close (c);
exit (0);
}
else
{
close (s);
c = connect_to_socket (true);
if (do_select_nowait (c, SEL_OUT) != SEL_OUT)
failed ("cannot write after blocking connect");
write (c, "foo", 3);
wait (&pid);
if (do_select_wait (c, SEL_IN) != SEL_IN)
failed ("cannot read data left in the socket by closed process");
read (c, buf, 3);
write (c, "foo", 3);
close (c);
}
#endif
}
static void
test_socket_pair (void)
{
struct sockaddr_in ia;
socklen_t addrlen = sizeof (ia);
int s = open_server_socket ();
int c1 = connect_to_socket (false);
int c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
ASSERT (s >= 0);
ASSERT (c1 >= 0);
ASSERT (c2 >= 0);
close (s);
test_pair (c1, c2);
close (c1);
ASSERT (write (c2, "foo", 3) == 3);
if ((poll1_nowait (c2, POLLIN | POLLOUT) & (POLLHUP | POLLERR)) == 0)
failed ("expecting POLLHUP after shutdown");
close (c2);
}
void * socket_uart_recv_manager(void * arg)
{
int listen_fd = open_server_socket(UNIX_SOCKET_UART_RECV);
pthread_t real_recv;
int result = pthread_create(&real_recv,
NULL,
uart_recv_worker,
NULL);
assert(result == 0);
socklen_t len = -1;
struct sockaddr_un clt_addr;
int com_fd = -1;
while(1)
{
len = sizeof(clt_addr);
com_fd = accept(listen_fd,(struct sockaddr*)&clt_addr,&len);
if(com_fd < 0)
{
perror("cannot accept client connect request");
close(listen_fd);
unlink(UNIX_SOCKET_UART_SEND);
exit(-1);
}
int n = 0;
uint8_t recv_buf[MAX_BUFSIZ];
if( (n = read(com_fd,recv_buf,sizeof(recv_buf))) < 0)
{
LOG_ERROR("[%s] Read Error\n",__func__);
}
if(is_invalid_message((char *)recv_buf, n))
{
process_message_invalid_message(com_fd);
close(com_fd);
}
else
{
message_t * message = deserialized_message(recv_buf,n);
#if 0
LOG_DEBUG("XXXXXXXXXXXXXXXXXXXXXXXXXXXX");
view_message(message);
LOG_DEBUG("____________________________");
#endif
uart_dev_t * dev = get_dev_by_name(message->name);
if(dev == NULL)
{
process_message_invalid_name(com_fd, message->name);
close(com_fd);
}
else
{
struct timeval now;
gettimeofday(&now,NULL);
message_t * fit = NULL;
socket_recv_handler * process_socket_recv = get_socket_recv_handler_by_protocol(dev->protocol);
process_socket_recv->func(dev, message, &fit);
if((fit == NULL))
{
process_message_not_fit(com_fd);
}
else if((now.tv_sec - fit->stamp.tv_sec) > 10)
{
free_message(fit);
process_message_not_fit(com_fd);
}
else
{
process_message_fitted(com_fd, fit);
}
free_message(message);
close(com_fd);
}
}
}
return NULL;
}
/*-----------------------------------------------------------------------------
* LL node
------------------------------------------------------------------------------*/
int tgc_ll(TGC *tgc)
{
fd_set rfds, reads;
struct sockaddr_in addr;
socklen_t in_addrlen = sizeof(addr);
int rc=0, sdi, sdx, sd;
socket_pair_list *conn, *prev_conn;
char cmd;
struct in_addr cc_addr = { 0 } ;
char ip[16];
int close_control = 0;
struct timeval tv;
if (!tgc)
return E_TGC_IE;
if ( (tgc->sdx_accept=open_server_socket(tgc->node.ll.port)) < 0 ) {
PRINT_LOG(1, "Can't bind to port %d", tgc->node.ll.port);
return E_TGC_NOCANDO;
}
if ( (tgc->sdi_accept=open_server_socket(tgc->node.ll.ll_port)) < 0 ) {
PRINT_LOG(1, "Can't bind to port %d", tgc->node.ll.ll_port);
return E_TGC_NOCANDO;
}
PRINT_LOG(3, "waiting for client on port %d ...", tgc->node.ll.port);
PRINT_LOG(3, "waiting for CC on %d!", tgc->node.ll.ll_port);
FD_ZERO(&rfds);
FD_SET(tgc->sdi_accept, &rfds);
FD_SET(tgc->sdx_accept, &rfds);
tgc->node.ll.control_sd = -1;
while(1) {
tv.tv_sec = tgc->node.ll.timeout;
tv.tv_usec = 0;
reads = rfds;
if ( (rc = select(FD_SETSIZE, &reads, NULL, NULL, &tv)) < 0 )
continue;
if (rc == 0 && tgc->node.ll.control_sd >= 0) {
PRINT_LOG(1, "time out, closing control connection");
FD_CLR(tgc->node.ll.control_sd, &rfds);
close_connection(&(tgc->node.ll.control_sd));
close_control = 0;
continue;
}
if (FD_ISSET(tgc->sdx_accept, &reads)) { // incoming client connection
sdx = accept_connection(tgc->sdx_accept, (struct sockaddr_in *)&addr,
(socklen_t *)&in_addrlen);
if (sdx==-1) {
if (errno==EINTR)
continue;
PRINT_LOG(1, "Error accepting new client connection");
continue; //break; // exit
}
if (tgc->node.ll.control_sd<0) {
//client came in while there is no control connection, so we close it
PRINT_LOG(3, "rejecting client connection before control connection received ");
close_connection(&sdx);
continue;
}
strncpy(ip, inet_ntoa(addr.sin_addr), 16);
PRINT_LOG(3, "client (%s) connected on %d!", ip, tgc->node.ll.ll_port);
// run the filter
if (!tgc_check_filter(tgc, ip)) {
close_connection(&sdx);
continue;
}
PRINT_LOG(3, "Ask CC for a connection for the new client");
if (tgc_send(tgc->node.ll.control_sd, TGC_COMM_CCC)>=0) {
if (tgc_add_queue( &(tgc->node.ll.socketq), sdx)<0) {
PRINT_LOG(1, "Error adding socket to queue!");
close_connection(&sdx);
return E_TGC_NOCANDO;
}
PRINT_LOG(5, "client connection added to the queue");
} else
close_connection(&sdx); // couldn't ask CC for a new connection, close the client
}
if (FD_ISSET(tgc->sdi_accept, &reads)) { // from CC
sdi = accept_connection(tgc->sdi_accept, (struct sockaddr_in *)&addr,
(socklen_t *)&in_addrlen);
if (sdi==-1) {
if (errno==EINTR)
continue;
PRINT_LOG(1, "Error accepting new CC connection");
break; // exit
}
strncpy(ip, inet_ntoa(addr.sin_addr), 16);
PRINT_LOG(3, "CC connected from %s", ip);
// run the filter
if (!tgc_check_filter(tgc, ip)) {
close_connection(&sdi);
continue;
}
if (tgc->node.ll.control_sd<0) {
// it's the control connection
tgc->node.ll.control_sd = sdi;
cc_addr.s_addr = addr.sin_addr.s_addr;
FD_SET(sdi, &rfds);
PRINT_LOG(4, "Control connection established");
} else { // it's a normal CC connection
if (addr.sin_addr.s_addr!=cc_addr.s_addr || !tgc->node.ll.socketq) {
// if this CC's address is different from control_sd's OR
// if there are no client connections waiting in the queue
// we reject the CC
close_connection(&sdi);
PRINT_LOG(1, "Suspicious CC rejected");
} else { //everything seems good, lets do our thing!
sdx = tgc_remove_queue(&(tgc->node.ll.socketq));
if (sdx>=0) {
if (tgc->method==TGC_METHOD_SELECT) {
if (!tgc_add_list( &(tgc->pairs), sdi, sdx)) {
FD_SET(sdi, &rfds);
FD_SET(sdx, &rfds);
}
} else {
#ifdef HAVE_FORK
// FORK
if (fork()==0) { // child
close_connection(&(tgc->sdi_accept));
close_connection(&(tgc->sdx_accept));
close_connection(&(tgc->node.ll.control_sd));
tgc_pump(sdi, sdx, tgc->buf, tgc->key);
break; //exit(0);
} else { // parent
close_connection(&sdi);
close_connection(&sdx);
}
#endif
}
}
}
}
}
if (tgc->node.ll.control_sd>=0 && FD_ISSET(tgc->node.ll.control_sd, &reads)) {
close_control = 0;
if (tgc_read(tgc->node.ll.control_sd, &cmd) == E_TGC_OK) {
switch (cmd) {
case TGC_COMM_PING:
PRINT_LOG(2, "Received a ping from CC");
if (tgc_send(tgc->node.ll.control_sd, TGC_COMM_PING)<0) {
PRINT_LOG(1, "Internal Error: can't write to control connection");
FD_CLR(tgc->node.ll.control_sd, &rfds);
close_connection(&(tgc->node.ll.control_sd));
tgc->node.ll.control_sd = -1;
continue;
}
break;
case TGC_COMM_CLOSE:
PRINT_LOG(3, "CC wants us to close the lingering client connection!");
if ((sd=tgc_remove_queue(&(tgc->node.ll.socketq)))>=0)
close_connection(&sd);
break;
default:
PRINT_LOG(1, "Internal Error: Uknown code (0x%x) recieved from CC!", cmd);
close_control = 1;
}
} else {
close_control = 1;
}
if (close_control) {
PRINT_LOG(1, "closing control connection");
FD_CLR(tgc->node.ll.control_sd, &rfds);
close_connection(&(tgc->node.ll.control_sd));
tgc->node.ll.control_sd = -1;
close_control = 0;
continue;
}
}
// pump the data for each and every connection pairs
if (tgc->method==TGC_METHOD_SELECT) {
conn = tgc->pairs;
while (conn) {
if (FD_ISSET(conn->sdi , &reads)) { // from CC?
if ( (rc=tgc_rxtx(conn->sdi, conn->sdx, tgc->buf, tgc->key)) < 0 ) {
FD_CLR(conn->sdi, &rfds);
FD_CLR(conn->sdx, &rfds);
close_connection(&(conn->sdi));
close_connection(&(conn->sdx));
prev_conn = conn;
conn = conn->next;
tgc_remove_list( &(tgc->pairs), prev_conn);
continue;
}
}
if (FD_ISSET(conn->sdx, &reads)) { // from client?
if ( (rc=tgc_rxtx(conn->sdx, conn->sdi, tgc->buf, tgc->key)) < 0 ) {
FD_CLR(conn->sdi, &rfds);
FD_CLR(conn->sdx, &rfds);
close_connection(&(conn->sdi));
close_connection(&(conn->sdx));
prev_conn = conn;
conn = conn->next;
tgc_remove_list( &(tgc->pairs), prev_conn);
continue;
}
}
conn=conn->next;
}
}
}
return 0;
}
int main (int argc, char** argv)
{
StackDescription_t stkd ;
Analysis_t analysis ;
Output_t output ;
ThermalData_t tdata ;
Error_t error ;
struct timespec t1,t2;
struct timespec res;
res.tv_sec=0;
res.tv_nsec=0;
Quantity_t server_port ;
Socket_t server_socket, client_socket ;
NetworkMessage_t request, reply , tmapReply;
bool headers = false ;
/* Checks if all arguments are there **************************************/
if (argc != 3)
{
fprintf (stderr, "Usage: \"%s file.stk server_port\n", argv[0]) ;
return EXIT_FAILURE ;
}
server_port = atoi (argv[2]) ;
/* Parses stack file (fills stack descrition and analysis) ****************/
fprintf (stdout, "Preparing stk data ... ") ; fflush (stdout) ;
stack_description_init (&stkd) ;
analysis_init (&analysis) ;
output_init (&output) ;
error = parse_stack_description_file (argv[1], &stkd, &analysis, &output) ;
/* Initialise the compression related data ********************************/
Quantity_t nflpel_ = get_total_number_of_floorplan_elements (&stkd) ;
float hist_table_d[nflpel_][HIST_TABLE_SIZE];
int tail_d[nflpel_];
for (unsigned int i = 0; i < nflpel_; i++)
{
tail_d[i] = 0;
for (int j = 0; j < HIST_TABLE_SIZE; j++)
hist_table_d[i][j] = -1.0;
}
for(int i=0;i<MAXRES;i++)
for(int j=0;j<MAXROWS;j++)
for(int k=0;k<MAXCOLS;k++)
for(int l=0;l<HIST_TABLE_SIZE;l++)
histTableMap[i][j][k][l] = -1.0;
int compressionUsed;
if (error != TDICE_SUCCESS) return EXIT_FAILURE ;
if (analysis.AnalysisType != TDICE_ANALYSIS_TYPE_TRANSIENT)
{
fprintf (stderr, "only transient analysis!\n") ;
goto wrong_analysis_error ;
}
fprintf (stdout, "done !\n") ;
/* Prepares thermal data **************************************************/
fprintf (stdout, "Preparing thermal data ... ") ; fflush (stdout) ;
thermal_data_init (&tdata) ;
error = thermal_data_build
(&tdata, &stkd.StackElements, stkd.Dimensions, &analysis) ;
if (error != TDICE_SUCCESS) goto ftd_error ;
fprintf (stdout, "done !\n") ;
/* Creates socket *********************************************************/
fprintf (stdout, "Creating socket ... ") ; fflush (stdout) ;
socket_init (&server_socket) ;
error = open_server_socket (&server_socket, server_port) ;
if (error != TDICE_SUCCESS) goto socket_error ;
fprintf (stdout, "done !\n") ;
/* Waits for a client to connect ******************************************/
fprintf (stdout, "Waiting for client ... ") ; fflush (stdout) ;
socket_init (&client_socket) ;
error = wait_for_client (&server_socket, &client_socket) ;
if (error != TDICE_SUCCESS) goto wait_error ;
fprintf (stdout, "done !\n") ;
//float timeForTmap = 0.0;
/* Runs the simlation *****************************************************/
do
{
network_message_init (&request) ;
receive_message_from_socket (&client_socket, &request) ;
switch (*request.Type)
{
/**********************************************************************/
case TDICE_COMPRESSION_USED :
{
extract_message_word (&request, &compressionUsed,0);
break;
}
case TDICE_EXIT_SIMULATION :
{
network_message_destroy (&request) ;
goto quit ;
}
/**********************************************************************/
case TDICE_RESET_THERMAL_STATE :
{
reset_thermal_state (&tdata, &analysis) ;
break ;
}
/**********************************************************************/
case TDICE_TOTAL_NUMBER_OF_FLOORPLAN_ELEMENTS :
{
network_message_init (&reply) ;
build_message_head (&reply, TDICE_TOTAL_NUMBER_OF_FLOORPLAN_ELEMENTS) ;
Quantity_t nflpel = get_total_number_of_floorplan_elements (&stkd) ;
insert_message_word (&reply, &nflpel) ;
send_message_to_socket (&client_socket, &reply) ;
network_message_destroy (&reply) ;
break ;
}
/**********************************************************************/
case TDICE_INSERT_POWERS_AND_SIMULATE_SLOT :
{
Quantity_t nflpel, index ;
PowersQueue_t queue ;
powers_queue_init (&queue) ;
extract_message_word (&request, &nflpel, 0) ;
powers_queue_build (&queue, nflpel) ;
if(compressionUsed)
{
unsigned int tmp[3];
int ret=-1;
unsigned int compressedWord;
float power=0.0;
int readIndex=1;
index=1;
initTmp(tmp);
extract_message_word (&request, &compressedWord,readIndex);
while(index<=nflpel)
{
ret=getNextDecompressedWord(compressedWord,tmp,0);
switch(ret)
{
case WI_DC:
case WC_DC:
switch(tmp[0])
{
case 0:
power=(int)hist_table_d[index-1][tmp[1]]+(hist_table_d[index-1][tmp[2]]-(int)hist_table_d[index-1][tmp[2]]);
break;
case 1:
power=tmp[1]+(hist_table_d[index-1][tmp[2]]-(int)hist_table_d[index-1][tmp[2]]);
hist_table_d[index-1][tail_d[index-1]]=power;
tail_d[index-1]=(tail_d[index-1]+1)%HIST_TABLE_SIZE;
break;
case 2:
power=(int)hist_table_d[index-1][tmp[1]]+((float)tmp[2])/(pow(10,DECIMAL_DIGITS));
hist_table_d[index-1][tail_d[index-1]]=power;
tail_d[index-1]=(tail_d[index-1]+1)%HIST_TABLE_SIZE;
break;
case 3:
power=tmp[1]+((float)tmp[2])/(pow(10,DECIMAL_DIGITS));
hist_table_d[index-1][tail_d[index-1]]=power;
tail_d[index-1]=(tail_d[index-1]+1)%HIST_TABLE_SIZE;
break;
}
put_into_powers_queue(&queue,power);
index++;
initTmp(tmp);
if(ret==WC_DC)
{
readIndex++;
extract_message_word (&request, &compressedWord,readIndex);
}
break;
case WC_DI:
readIndex++;
extract_message_word (&request, &compressedWord,readIndex);
break;
default:
break;
}
}
ret=getNextDecompressedWord(compressedWord,tmp,1);
}
/* NO COMPRESSION *************************************/
else
{
for (index = 1, nflpel++ ; index != nflpel ; index++)
{
float power_value ;
extract_message_word (&request, &power_value, index) ;
put_into_powers_queue (&queue, power_value) ;
}
}
error = insert_power_values (&tdata.PowerGrid, &queue) ;
if (error != TDICE_SUCCESS)
{
fprintf (stderr, "error: insert power values\n") ;
powers_queue_destroy (&queue) ;
goto sim_error ;
}
powers_queue_destroy (&queue) ;
network_message_init (&reply) ;
build_message_head (&reply, TDICE_INSERT_POWERS_AND_SIMULATE_SLOT) ;
SimResult_t result = emulate_slot
(&tdata, stkd.Dimensions, &analysis) ;
insert_message_word (&reply, &result) ;
send_message_to_socket (&client_socket, &reply) ;
network_message_destroy (&reply) ;
if (result != TDICE_SLOT_DONE)
{
fprintf (stderr, "error %d: emulate slot\n", result) ;
goto sim_error ;
}
break ;
}
/**********************************************************************/
case TDICE_SEND_OUTPUT :
{
OutputInstant_t instant ;
OutputType_t type ;
OutputQuantity_t quantity ;
//clock_t Time;
extract_message_word (&request, &instant, 0) ;
extract_message_word (&request, &type, 1) ;
extract_message_word (&request, &quantity, 2) ;
network_message_init (&reply) ;
build_message_head (&reply, TDICE_SEND_OUTPUT) ;
float time = get_simulated_time (&analysis) ;
Quantity_t n = get_number_of_inspection_points (&output, instant, type, quantity) ;
insert_message_word (&reply, &time) ;
insert_message_word (&reply, &n) ;
if (n > 0)
{
error = fill_output_message
(&output, stkd.Dimensions,
tdata.Temperatures, tdata.PowerGrid.Sources,
instant, type, quantity, &reply) ;
if (error != TDICE_SUCCESS)
{
fprintf (stderr, "error: generate message content\n") ;
network_message_destroy (&reply) ;
goto sim_error ;
}
}
if(type == TDICE_OUTPUT_TYPE_TMAP && compressionUsed)
{
//init histTableMap tailMap for compression
//New packet tmapReply is being initialised /
//clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t1);
network_message_init (&tmapReply);
build_message_head (&tmapReply, TDICE_SEND_OUTPUT);
insert_message_word (&tmapReply, &time);
insert_message_word (&tmapReply, &n);
CellIndex_t nrows, ncols;
int readIndex = 4;
//get the no of rows and cols from reply packet
extract_message_word (&reply, &nrows, 2);
extract_message_word (&reply, &ncols, 3);
//insert nrows and ncols into my packet
insert_message_word (&tmapReply, &nrows);
insert_message_word (&tmapReply, &ncols);
int ret=-1, f1, f2;
unsigned int compressedWord, i, j, k, l;
unsigned int flag=0, intPart, decPart;
unsigned int tmp[3];
float temper;
for(i=0; i<n; i++)
for(j=0; j<nrows; j++)
for(k=0; k<ncols; k++)
{
f1 = -1;f2 = -1;
extract_message_word (&reply, &temper, readIndex);
readIndex++;
unsigned int intPartTemper, decPartTemper;
getParts (temper, &intPartTemper, &decPartTemper);
for (l=0;l<HIST_TABLE_SIZE;l++)
{
if(histTableMap[i][j][k][l] != -1.0)
{
getParts (histTableMap[i][j][k][l], &intPart, &decPart);
if(intPart == intPartTemper)f1 = l;
float val=((float)decPart-decPartTemper);
val=val/(float)pow(10,DECIMAL_DIGITS);
val=abs (val);
if(val <= TOLERANCE)
f2=l;
}
}
flag = getFlag (f1,f2);
switch (flag)
{
case 1:
histTableMap[i][j][k][tailMap[i][j][k]] = intPartTemper +
(histTableMap[i][j][k][f2] - (int)histTableMap[i][j][k][f2]);
tailMap[i][j][k] = (tailMap[i][j][k] + 1)%HIST_TABLE_SIZE;
break;
case 2:
histTableMap[i][j][k][tailMap[i][j][k]] = (int)histTableMap[i][j][k][f1] +
((float)decPartTemper)/(pow(10,DECIMAL_DIGITS));
tailMap[i][j][k] = (tailMap[i][j][k] + 1)%HIST_TABLE_SIZE;
break;
case 3:
histTableMap[i][j][k][tailMap[i][j][k]] = intPartTemper +
((float)decPartTemper)/(pow(10,DECIMAL_DIGITS));
tailMap[i][j][k] = (tailMap[i][j][k] + 1)%HIST_TABLE_SIZE;
break;
default:
break;
}
getArgsInArray (f1, f2, flag, intPartTemper, decPartTemper, tmp);
ret = getNextCompressedWord (tmp[1], tmp[2], flag, &compressedWord, !WRAP_UP);
if(ret != WORD_INCOMPLETE)
insert_message_word (&tmapReply, &compressedWord);
}
switch(ret)
{
case WORD_INCOMPLETE:
case WORD_IN_TEMP:
getNextCompressedWord (tmp[1], tmp[2], flag, &compressedWord, WRAP_UP);
insert_message_word (&tmapReply, &compressedWord);
break;
default:
break;
}
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t1);
send_message_to_socket (&client_socket, &tmapReply);
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t2);
diff(t1,t2,&res);
network_message_destroy (&reply);
network_message_destroy (&tmapReply);
}
else
{
if(type == TDICE_OUTPUT_TYPE_TMAP)
{
//Time = clock();
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t1);
send_message_to_socket (&client_socket, &reply);
//timeForTmap += ((double)clock() - Time) / CLOCKS_PER_SEC ;
clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &t2);
diff(t1,t2,&res);
}
else
send_message_to_socket (&client_socket, &reply) ;
network_message_destroy (&reply) ;
}
break ;
}
/**********************************************************************/
case TDICE_PRINT_OUTPUT :
{
OutputInstant_t instant ;
extract_message_word (&request, &instant, 0) ;
if (headers == false)
{
Error_t error = generate_output_headers
(&output, stkd.Dimensions, (String_t)"% ") ;
if (error != TDICE_SUCCESS)
{
fprintf (stderr, "error in initializing output files \n ");
goto sim_error ;
}
headers = true ;
}
generate_output
(&output, stkd.Dimensions,
tdata.Temperatures, tdata.PowerGrid.Sources,
get_simulated_time (&analysis), instant) ;
break ;
}
/**********************************************************************/
case TDICE_SIMULATE_SLOT :
{
network_message_init (&reply) ;
build_message_head (&reply, TDICE_SIMULATE_SLOT) ;
SimResult_t result = emulate_slot (&tdata, stkd.Dimensions, &analysis) ;
insert_message_word (&reply, &result) ;
send_message_to_socket (&client_socket, &reply) ;
network_message_destroy (&reply) ;
if (result == TDICE_END_OF_SIMULATION)
{
network_message_destroy (&request) ;
goto quit ;
}
else if (result != TDICE_SLOT_DONE)
{
fprintf (stderr, "error %d: emulate slot\n", result) ;
goto sim_error ;
}
break ;
}
/**********************************************************************/
case TDICE_SIMULATE_STEP :
{
network_message_init (&reply) ;
build_message_head (&reply, TDICE_SIMULATE_STEP) ;
SimResult_t result = emulate_step (&tdata, stkd.Dimensions, &analysis) ;
insert_message_word (&reply, &result) ;
send_message_to_socket (&client_socket, &reply) ;
network_message_destroy (&reply) ;
if (result == TDICE_END_OF_SIMULATION)
{
network_message_destroy (&request) ;
goto quit ;
}
else if (result != TDICE_STEP_DONE && result != TDICE_SLOT_DONE)
{
fprintf (stderr, "error %d: emulate step\n", result) ;
goto sim_error ;
}
break ;
}
/**********************************************************************/
default :
fprintf (stderr, "ERROR :: received unknown message type") ;
}
network_message_destroy (&request) ;
} while (1) ;
/**************************************************************************/
quit :
socket_close (&client_socket) ;
socket_close (&server_socket) ;
thermal_data_destroy (&tdata) ;
stack_description_destroy (&stkd) ;
output_destroy (&output) ;
printf("Time taken %d sec %d nsec \n",(int)res.tv_sec,(int)res.tv_nsec);
return EXIT_SUCCESS ;
sim_error :
network_message_destroy (&request) ;
socket_close (&client_socket) ;
wait_error :
socket_close (&server_socket) ;
socket_error :
thermal_data_destroy (&tdata) ;
ftd_error :
wrong_analysis_error :
stack_description_destroy (&stkd) ;
output_destroy (&output) ;
return EXIT_FAILURE ;
}
/*-----------------------------------------------------------------------------
Become a port forwarder
------------------------------------------------------------------------------*/
int tgc_pf(TGC *tgc)
{
struct sockaddr_in addr;
socklen_t in_addrlen = sizeof(addr);
fd_set rfds, reads;
int sdi, sdx, rc=0;
socket_pair_list *conn, *prev_conn;
char ip[16];
signal(SIGCLD, SIG_DFL); // to avoid zombie process
if ( (tgc->sdi_accept=open_server_socket(tgc->node.pf.port)) < 0 ) {
PRINT_LOG(1, "Can't bind to port %d", tgc->node.pf.port);
return E_TGC_NOCANDO;
}
PRINT_LOG(3, "waiting for incomming connections on port %d ...", tgc->node.pf.port);
FD_ZERO(&rfds);
FD_SET(tgc->sdi_accept, &rfds);
while (1) {
reads = rfds;
if ( select(FD_SETSIZE, &reads, NULL, NULL, NULL) < 0 )
continue;
if (FD_ISSET(tgc->sdi_accept, &reads)) {
sdi = accept_connection(tgc->sdi_accept, (struct sockaddr_in *) &addr,
(socklen_t *)&in_addrlen);
if (sdi==-1) {
if (errno==EINTR)
continue;
PRINT_LOG(0, "Error accepting new connection!");
close_connection(&(tgc->sdi_accept));
break; //exit
}
// run the filter
strncpy(ip, inet_ntoa(addr.sin_addr), 16);
PRINT_LOG(3, "Received a client from %s", ip);
if (!tgc_check_filter(tgc, ip)) {
close_connection(&sdi);
sdi = -1;
continue;
}
if ( (sdx=connect_server(tgc->node.pf.dst_host, tgc->node.pf.dst_port))<0 ) {
PRINT_LOG(1, "failed connecting to %s:%d", tgc->node.pf.dst_host, tgc->node.pf.dst_port);
close_connection(&sdi);
sdi = -1;
continue;
}
PRINT_LOG(3, "connected to the server");
if (tgc->method == TGC_METHOD_SELECT) {
if (!tgc_add_list( &(tgc->pairs), sdi, sdx)) {
FD_SET(sdi, &rfds);
FD_SET(sdx, &rfds);
PRINT_LOG(3, "Added socket pairs to the list");
continue;
}
} else { //fork method
#ifdef HAVE_FORK
if (fork()==0) { //child
close_connection(&(tgc->sdi_accept));
tgc_pump(sdi, sdx, tgc->buf, tgc->key);
break;
} else {// parent
close_connection(&sdi);
close_connection(&sdx);
PRINT_LOG(3, "waiting for incomming connections on port %d again...", tgc->node.pf.port);
}
#endif
}
}
// pump the data for each and every connection pairs
if (tgc->method==TGC_METHOD_SELECT) {
conn = tgc->pairs;
while (conn) {
if (FD_ISSET(conn->sdi , &reads)) { // from client
if ( (rc=tgc_rxtx(conn->sdi, conn->sdx, tgc->buf, tgc->key)) < 0 ) {
PRINT_LOG(3, "Error reading socket, closing pair");
FD_CLR(conn->sdi, &rfds);
FD_CLR(conn->sdx, &rfds);
close_connection(&(conn->sdi));
close_connection(&(conn->sdx));
prev_conn = conn;
conn = conn->next;
tgc_remove_list( &(tgc->pairs), prev_conn);
continue;
}
}
if (FD_ISSET(conn->sdx, &reads)) { // from server
if ( (rc=tgc_rxtx(conn->sdx, conn->sdi, tgc->buf, tgc->key)) < 0 ) {
PRINT_LOG(3, "Error reading socket, closing pair.");
FD_CLR(conn->sdi, &rfds);
FD_CLR(conn->sdx, &rfds);
close_connection(&(conn->sdi));
close_connection(&(conn->sdx));
prev_conn = conn;
conn=conn->next;
tgc_remove_list( &(tgc->pairs), prev_conn);
continue;
}
}
conn=conn->next;
}
}
}
return E_TGC_NOCANDO;
}
