/*

** gateway implementation

*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <sys/wait.h>

#include <signal.h>

#include <pthread.h>

#define PORT "4000" // the port users will be connecting to

#define BACKLOG 10 // how many pending connections queue will hold

void sigchld_handler(int s)

{

while(waitpid(-1, NULL, WNOHANG) > 0);

}

// get sockaddr, IPv4 or IPv6:

void *get_in_addr(struct sockaddr *sa)

{

if (sa->sa_family == AF_INET) {

return &(((struct sockaddr_in*)sa)->sin_addr);

}

return &(((struct sockaddr_in6*)sa)->sin6_addr);

}

#define MAXSENDLENGTH 200

#define MAXRECVLENGTH 100

#define MAXRECVSTAGINGLENGTH 30

#define NOFSTAGINGNODES 5

int nofChunksToRecv=0;

//Some buffers necessary for communication

char send_buff[10*MAXSENDLENGTH];

char recv_buff[MAXRECVLENGTH];

char recv_buff_staging[MAXRECVSTAGINGLENGTH];

char temp_buffer[10];

int numbytes;

int sendTo(int socketFD, char* send_buf);

int recvFrom(int socketFD, int spec);

void *sendToStage();

void serverSocketStuff();

//

struct dsanode_id{

char ip[20];

char* port;

} dsanode_ids[NOFSTAGINGNODES];

void set_dsanode_ids(){

//Manual entry for convenience in the network building stage !!! Not beautiful hereeeee

strcpy(dsanode_ids[0].ip, "127.0.0.1");

dsanode_ids[0].port = "5000";

strcpy(dsanode_ids[1].ip, "127.0.0.1");

dsanode_ids[1].port = "5001";

strcpy(dsanode_ids[2].ip, "127.0.0.1");

dsanode_ids[2].port = "5002";

strcpy(dsanode_ids[3].ip, "127.0.0.1");

dsanode_ids[3].port = "5003";

strcpy(dsanode_ids[4].ip, "127.0.0.1");

dsanode_ids[4].port = "5004";

}

// For data staging

// char stageIPs[][]={{"10.0.0."}};

//To simulate in one host

int stagePorts[] = {5000, 5001, 5002, 5003, 5004};

int stageSockDFs[NOFSTAGINGNODES];

//

int sockfd, new_fd; // listen on sock_fd, new connection on new_fd

struct addrinfo hints, *servinfo, *p;

struct sockaddr_storage their_addr; // connector's address information

socklen_t sin_size;

struct sigaction sa;

int yes=1;

char s[INET6_ADDRSTRLEN];

int rv;

pid_t childPID; //control variable for multithreading

FILE *file;

pthread_t tt;

//

int main(int argc, char *argv[])

{

//For debugging

file = fopen("file_g_s.txt", "w");

fprintf(file,"%s","Top of the file");

//

//char send_buf[MAX_SEND_BUF_LENGTH];

set_dsanode_ids();

serverSocketStuff();

printf("gateway_s: waiting for connections...\n");

while(1) { // main accept() loop

sin_size = sizeof their_addr;

new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);

if (new_fd == -1) {

perror("accept");

continue;

}

inet_ntop(their_addr.ss_family,get_in_addr((struct sockaddr *)&their_addr),s, sizeof s);

printf("gateway_s: got connection from %s\n", s);

//fprintf(file,"%s","server: got connection from");

//fprintf(file,"%s\n",s);

//Threading

childPID=fork();

if(childPID>=0)

{

if(childPID == 0){ //Child process

close(sockfd); // child doesn't need the listener

//Wait for #ofChunks:X message from p

recvFrom(new_fd, 0);

char subbuff[10];

memcpy( subbuff, recv_buff, 10 );

subbuff[10] = '\0';

if(strcmp(subbuff, "#ofChunks:")==0){

sendTo(new_fd, "OK"); //the # of chunks that client desires to get

}

else{

printf("Recved irrelevant message:%s\n", recv_buff);

exit(1);

}

//send the bulk data to the client

strncpy(subbuff, recv_buff+strlen("#ofChunks:"), (strlen(recv_buff)-strlen("#ofChunks:")));

nofChunksToRecv=atoi(subbuff);

printf("nofChunksToRecv:%d\n", nofChunksToRecv);

while(1){

numbytes=recvFrom(new_fd, 0);

fprintf(file, "\nnumbytes recved: %d",numbytes);

//printf("GW RECEIVED: '%s'\n",recv_buff);

fprintf(file,"\n%s",recv_buff);

pthread_join(tt,NULL); //Wait for the previous thread to finish

strcat(send_buff, recv_buff);//buffer all the data to be sent to dsa stage

//Instead of writing the recved data to a file send the data to the staging nodes

int rc = pthread_create(&tt, NULL, sendToStage, NULL);

if (rc){

printf("ERROR; return code from pthread_create() is %d\n", rc);

exit(-1);

}

memset(recv_buff, 0, MAXRECVLENGTH);

}

}

else{//parent process

close(new_fd); // parent doesn't need this

//Listen the channel by inf while

}

}

else{

printf("\n Fork failed, exit !\n");

return 1;

}

}

fclose(file); /*done!*/

return 0;

}

/*Will create a socket connection to the dsanode with id: dsanode_ids[index]

**

*/

int connectToDsanode(int index){

int sockfd;

struct addrinfo hints, *servinfo, *p;

int rv;

char s[INET6_ADDRSTRLEN];

memset(&hints, 0, sizeof hints);

hints.ai_family = AF_UNSPEC;

hints.ai_socktype = SOCK_STREAM;

if ((rv = getaddrinfo(dsanode_ids[index].ip, dsanode_ids[index].port, &hints, &servinfo)) != 0) {

fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));

exit(1);

}

// loop through all the results and connect to the first we can

for(p = servinfo; p != NULL; p = p->ai_next) {

if ((sockfd = socket(p->ai_family, p->ai_socktype,p->ai_protocol)) == -1){

perror("gateway: socket");

continue;

}

if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {

close(sockfd);

perror("gateway: connect");

continue;

}

break;

}

if (p == NULL) {

fprintf(stderr, "gw: failed to connect\n");

exit(2);

}

inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),s, sizeof s);

printf("GW: connecting to %s\n", s);

freeaddrinfo(servinfo); // all done with this structure

return sockfd;

}

int sendTo(int socketFD, char* send_buf){

if (send(socketFD, send_buf, (int)strlen(send_buf), 0) != -1){

return 1; //sent successfully

}

else{

perror("send");

return -1; //could not be sent

}

}

//

int recvFrom(int socketFD, int spec){//spec: 0 -> recv from p | 1 -> recv from dsanode

int numbytes = (spec==0) ? recv(socketFD, recv_buff, MAXRECVLENGTH, 0) : recv(socketFD, recv_buff_staging, MAXRECVLENGTH, 0); //No flags are necessary

//printf("GW recved: %s\n", recv_buff);

if(numbytes>0){//Successful reception

return numbytes;

}

else if (numbytes == 0) {//socket is closed by the other side

if(spec == 0){//Normal process op

printf("GW_P socket is closed by P\n");

close(new_fd);

fclose(file);

pthread_join(tt,NULL);

exit(1);

}

else{ //Thread recving

printf("GW_DSANODE socket is closed by DSANODE\n");

//Nothing TODO ?

}

}

else{ //Unsuccessful reception

perror("recv");

exit(1);

}

}

void serverSocketStuff(){

memset(&hints, 0, sizeof hints);

hints.ai_family = AF_UNSPEC;

hints.ai_socktype = SOCK_STREAM;

hints.ai_flags = AI_PASSIVE; // use my IP

if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) {

fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));

exit(1);

}

// loop through all the results and bind to the first we can

for(p = servinfo; p != NULL; p = p->ai_next) {

if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {

perror("server: socket");

continue;

}

if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,

sizeof(int)) == -1) {

perror("setsockopt");

exit(1);

}

if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {

close(sockfd);

perror("server: bind");

continue;

}

break;

}

if (p == NULL) {

fprintf(stderr, "server: failed to bind\n");

exit(2);

}

freeaddrinfo(servinfo); // all done with this structure

if (listen(sockfd, BACKLOG) == -1) {

perror("listen");

exit(1);

}

sa.sa_handler = sigchld_handler; // reap all dead processes

sigemptyset(&sa.sa_mask);

sa.sa_flags = SA_RESTART;

if (sigaction(SIGCHLD, &sa, NULL) == -1) {

perror("sigaction");

exit(1);

}

}