void run_as_client() {
fflush(stdout_file_descriptor);
fflush(stderr_file_descriptor);
int pid = fork();
int status;
int sin_size = sizeof(struct sockaddr_in);
socklen_t *temp_sock_len = (socklen_t *) &sin_size;
if (pid == 0) {
waitpid(pid, &status, 0);
} else {
int sock;
struct hostent *host;
struct sockaddr_in server_addr;
char command[1000];
char buffer[1024000];
host = gethostbyname(server_hostname);
if(!host) {
logger_error_client("INVALID HOST ADDRESS");
exit(EXIT_FAILURE);
}
logger_info_client("FOUND HOST");
if (strcmp(connection_type, "tcp") == 0) {
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == -1) {
logger_error_client("UNABLE TO RETRIEVE SOCKET");
exit(EXIT_FAILURE);
}
} else {
if (strcmp(connection_type, "udp") == 0) {
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == -1) {
logger_error_client("UNABLE TO RETRIEVE SOCKET");
exit(EXIT_FAILURE);
}
}
}
logger_info_client("SOCKET RETRIEVED");
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(client_port);
server_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(server_addr.sin_zero),8);
if (strcmp(connection_type, "tcp") == 0) {
if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) {
logger_error_client("UNABLE TO CONNECT TO SOCKET");
exit(EXIT_FAILURE);
}
}
logger_info_client("CONNECTED TO SOCKET");
client_send_buffer = (char *) calloc(sizeof(char) * 1024, 0);
client_receive_buffer = (char *) calloc(sizeof(char) * 1024, 0);
while (1)
{
printf(">> ");
readLine(command);
while (command[0] == '\0')
{
printf(">> ");
readLine(command);
}
if (strncmp (command, "quit", 4) == 0)
break;
if (strncmp (command, "exit", 4) == 0)
break;
if (strncmp (command, "easter-egg", 10) == 0) {
fprintf(stdout_file_descriptor,
"\n"
" ##\n"
" ###\n"
" ####\n"
" #####\n"
" #######\n"
" #######\n"
" ########\n"
" ########\n"
" #########\n"
" ##########\n"
" ############\n"
" ##############\n"
" ################\n"
" ################ #\n"
" ############## ###\n"
" ############## ####\n"
" ############## #####\n"
" ############## #######\n"
" ############## ###########\n"
" ############### #############\n"
" ################ ##############\n"
" ################# # ################\n"
" ################## ## # #################\n"
" #################### ### ## #################\n"
" ################ ######## #################\n"
" ################ ####### ###################\n"
" ####################### #####################\n"
" ##################### ###################\n"
" ############################################\n"
" ###########################################\n"
" ##########################################\n"
" ########################################\n"
" ########################################\n"
" ######################################\n"
" ######################################\n"
" ########################## #####\n"
" ### ################### ##\n"
" ## ############### #\n"
" # ## ##########\n"
" ## ###\n"
" ###\n"
" ##\n"
" #\n"
"\n"
" LONG LIVE THE BAT.\n"
"\n");
continue;
}
memset(client_receive_buffer, 0, sizeof(char) * 1024);
memset(client_send_buffer, 0, sizeof(char) * 1024);
strcpy(client_send_buffer, command);
if(strcmp(connection_type, "tcp") == 0) {
send(sock, client_send_buffer, strlen(client_send_buffer), 0);
} else {
if (strcmp(connection_type, "udp") == 0) {
sendto(sock, client_send_buffer, strlen(client_send_buffer), 0,(struct sockaddr *)&server_addr, sizeof(struct sockaddr));
}
}
if(strcmp(connection_type, "tcp") == 0) {
recv_wrapper(sock, client_receive_buffer, sizeof(char) * 1024, 0);
} else {
if (strcmp(connection_type, "udp") == 0) {
recvfrom(sock, client_receive_buffer, sizeof(char) * 1024, 0,(struct sockaddr *)&server_addr, temp_sock_len);
}
}
strcpy(buffer, client_receive_buffer);
while (!strstr(client_receive_buffer, "MAGIC-STRING-SPRINKLEBERRY-MUFFIN")) {
if(strcmp(connection_type, "tcp") == 0) {
recv_wrapper(sock, client_receive_buffer, sizeof(char) * 1024, 0);
} else {
if (strcmp(connection_type, "udp") == 0) {
recvfrom(sock, client_receive_buffer, sizeof(char) * 1024, 0,(struct sockaddr *)&server_addr, temp_sock_len);
}
}
strcat (buffer, client_receive_buffer);
}
char * zero_out = strstr(buffer, "MAGIC-STRING-SPRINKLEBERRY-MUFFIN");
*zero_out = '\0';
fprintf(stdout_file_descriptor, "%s\n", buffer);
}
close(sock);
}
}
int main(int argc, char**argv)
{
int sfd,ssfd;
char num[10];
char clientID[22];
char filename[100];
int result;
int taskSize;
int exitCode;
int numBytes;
char *msg;
char *taskID;
char ACK[]="OK\n";
char lifetime[]="10\n";
Task *task;
char *back;
if (argc!=5)
{
fprintf(stdout,"usage: client <IP> <port> <port> <debug>");
exit(1);
}
if (strcmp(argv[4],"-debug")==0)
flag=1;
recover:
if(flag == 1)
fprintf(stdout,"con_server() to %s on port %s\n", argv[1], argv[2]);
sfd=con_server(atoi(argv[2]), argv[1]);
set_sockopt(sfd);
if(flag == 1)
fprintf(stdout,"con_server() to %s on port %s\n", argv[1], argv[3]);
ssfd=con_server(atoi(argv[3]), argv[1]);
if (flag==1)
fprintf(stdout,"connection established!\n");
/*numBytes=send(sfd, lifetime, sizeof(lifetime), 0);
if (numBytes<0)
{
fprintf(stdout, "main: send lifetime error\n");
fprintf(stdout,"main: error description: EOF\n");
recovery(sfd, ssfd);
goto recover;
}*/
while (1)
{
task = (Task *)malloc(sizeof(Task));
if (task==NULL)
printf("failed to allocate memory in main loop\n");
memset(filename,'\0',sizeof(filename));
memset(clientID,'\0',sizeof(clientID));
memset(num, '\0', sizeof(num));
/*receive clientID*/
recv_wrapper(sfd, ssfd, clientID, 22);
if (flag==1)
{
fprintf(stdout,"main: clientID: %s\n", clientID);
}
/*receive size of task*/
recv_wrapper(sfd, ssfd, num, 10);
if (flag==1)
{
fprintf(stdout,"main: size_of_task: %s\n", num);
}
/*allocate memory for task description*/
taskSize=atoi(num);
msg=malloc(sizeof(char)*(taskSize+1));
if (msg==NULL)
{
fprintf(stdout,"main: allocate memory failed\n");
exit (1);
}
memset(msg,'\0',taskSize+1);
/*receive task description*/
recv_wrapper(sfd, ssfd, msg, taskSize);
if (flag==1)
{
fprintf(stdout,"main:received: %s\n", msg);
}
/*send acknoledgement for the received task*/
numBytes=send(sfd, ACK,strlen(ACK),0);
if (numBytes < 0)
{
fprintf(stdout,"main: Sent ACK %s failed\n", ACK);
fprintf(stdout,"main: error description: EOF\n");
recovery(sfd, ssfd);
goto recover;
}
else
{
if (flag == 1)
fprintf(stdout,"main: Sent ACK %s successful (%d)\n", ACK, numBytes);
}
parseExec(msg, task);
exitCode = run_task(task);
/*send results back to Falkon service*/
numBytes = sendResults(task, ssfd, sfd);
if (numBytes < 0)
{
fprintf(stdout,"main: Send results failed\n");
recovery(sfd, ssfd);
goto recover;
}
//free(task->taskID);
//free(task->command);
//free(task->directory);
free(task);
free(msg);
//exit(1);
}
}
void run_as_server() {
fflush(stdout_file_descriptor);
fflush(stderr_file_descriptor);
int pid = fork();
int status;
if (pid == 0) {
if (is_client == true) {
// Do nothing
} else {
waitpid(pid, &status, 0);
}
} else {
int sock, connection;
struct sockaddr_in server_addr, client_addr;
ssize_t bytes_recv;
int sin_size;
char print_buffer[4096];
if(strcmp(connection_type, "tcp") == 0) {
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == -1){
logger_error_server("UNABLE TO RETRIEVE SOCKET");
exit(EXIT_FAILURE);
}
} else {
if(strcmp(connection_type, "udp") == 0) {
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == -1) {
logger_error_server("UNABLE TO RETRIEVE SOCKET");
exit(EXIT_FAILURE);
}
}
}
logger_info_server("SOCKET RETRIEVED");
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(server_port);
server_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(server_addr.sin_zero), 8);
if(bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) {
logger_error_server("UNABLE TO BIND SOCKET");
exit(EXIT_FAILURE);
}
logger_info_server("SOCKET BOUND");
if (strcmp(connection_type, "tcp") == 0) {
if (listen(sock, 10) == -1) {
logger_error_server("UNABLE TO LISTEN ON SOCKET");
exit(EXIT_FAILURE);
}
}
server_send_buffer = (char *) calloc(sizeof(char), 1024);
server_receive_buffer = (char *) calloc(sizeof(char), 1024);
logger_info_server("LISTENING ON SOCKET");
while(1) {
sin_size = sizeof(struct sockaddr_in);
socklen_t *temp_sock_len = (socklen_t *) &sin_size;
if (strcmp(connection_type, "tcp") == 0) {
connection = accept(sock, (struct sockaddr *)&client_addr, temp_sock_len);
logger_info_server("CONNECTION ESTABLISHED");
}
while(1) {
memset(server_send_buffer, 0, 1024*sizeof(char));
memset(server_receive_buffer, 0, 1024*sizeof(char));
if(strcmp(connection_type, "tcp") == 0) {
bytes_recv = recv_wrapper(connection, server_receive_buffer, 1024, 0);
} else {
if(strcmp(connection_type, "udp") == 0) {
bytes_recv = recvfrom(sock, server_receive_buffer, 1024, 0, (struct sockaddr *)&client_addr, temp_sock_len);
}
}
server_receive_buffer[bytes_recv] = '\0';
strcpy(print_buffer, "\nRECEIVED REQUEST:\n-----------------\n");
strcat(print_buffer, server_receive_buffer);
logger_info_server(print_buffer);
if( bytes_recv == 0 || strcmp(server_receive_buffer,"exit") == 0) {
logger_info_server("CONNECTION CLOSED");
close(connection);
break;
}
server_query_handler(sock, connection, server_addr, client_addr);
}
}
close(sock);
}
}
