void connectToServer(char * serveraddress, char * port, char* transType, char * infile){
// SSL init
SSL_library_init();
// ============== SSL init //
// establish connection
BIO* bio = establishSSLConnection(serveraddress, port);
// ================ STEP 1 FINISHED ESTABLISHED AN SSL CONNECTION
// Verify client
performRSAChallenge(serveraddress, port, bio);
// ================
int transaction = verifyTransaction(serveraddress, port, transType, bio);
if(transaction == 1) //send
{
sendFile(serveraddress, port, infile, bio);
}
if(transaction == 2) //recieve
{
recieveFile(serveraddress, port, infile, bio);
}
if(transaction < 0) //error
{
printf("Something went wrong with determining transaction type.");
}
if(transaction < 0) //error
{
printf("Something went wrong with determining transaction type.");
}
printf("SSL Connection closed.\n");
BIO_free(bio);
}
/**
*@description download single file from sock using http protocol
*@param filePath char pointer to a filepath
*@param sockFd int socket Id
*@param isAlive whether to create persistent connection
*@return if failed, return negative number, otherwise, nonnegative
*/
int downloadSingleFile(char* filePath, int sockFd, enum KeepAlive isAlive) {
char buffer[512];
int recvLen = 0;
//send request line
memset(buffer, '\0', sizeof(buffer));
snprintf(buffer, sizeof(buffer) - 1, "GET %s HTTP/1.0\r\n", filePath);
if (send(sockFd, buffer, strlen(buffer), 0) < 0) {
return -1;
}
//send connection type
memset(buffer, '\0', sizeof(buffer));
if (isAlive == persistent) {
snprintf(buffer, sizeof(buffer) - 1, "Connection: keep-alive\r\n");
} else {
snprintf(buffer, sizeof(buffer) - 1, "Connection: close\r\n");
}
if (send(sockFd, buffer, strlen(buffer), 0) < 0) {
return -1;
}
//send suffix
memset(buffer, '\0', sizeof(buffer));
snprintf(buffer, sizeof(buffer) - 1, "\r\n");
if (send(sockFd, buffer, strlen(buffer), 0) < 0) {
printf("%s %s send request for file %s failed\n", __FILE__, __func__, filePath);
return -1;
}
printf(" start to recv response for file %s\n", filePath);
//start to recieve response
int numHeaders = 0;
memset(buffer,'\0',sizeof(buffer));
Response * response = (Response*) malloc(sizeof(Response));
response->isAlive = no_persistent;
response->content_len = 0;
if (getLineFromSock(sockFd, buffer, sizeof(buffer)-1) > 0) {//read response line
//parse requestline successfully
if (parseHttpResponseLine(buffer, strlen(buffer), &(response->responseLine)) >= 0){
//printf("response code is %s\n", (response->responseLine).code);
//read each header per line, end by a blank line
numHeaders = 0;
memset(buffer,'\0',sizeof(buffer));
while (getLineFromSock(sockFd, buffer, sizeof(buffer)-1) > 0) {
response->headers[numHeaders] = (Header*) malloc(sizeof(Header));
if ( parseHeader(buffer, strlen(buffer), response->headers[numHeaders]) > 0) {
//printf("parsed header name %s value %s\n",response->headers[numHeaders]->name, response->headers[numHeaders]->value);
// get connect alive status
if (strcmp(response->headers[numHeaders]->name, "Connection") == 0) {
if (strcmp(response->headers[numHeaders]->value, "keep-alive") == 0) {
response->isAlive = persistent;
} else {
response->isAlive = no_persistent;
}
}
// get content length
if (strcmp(response->headers[numHeaders]->name, "Content-Length") == 0) {
response->content_len = atoi(response->headers[numHeaders]->value);
}
memset(buffer,'\0',sizeof(buffer));
numHeaders++;
} else {
free(response->headers[numHeaders]);
printf("pare header failed: \n%s\n", buffer);
break;
}
}
}
}
if (response->content_len > 0) {
recvLen = recieveFile(response->content_len, sockFd);
if (recvLen == response->content_len) {
printf("\nsuccessfully receive %d bytes for file %s\n", recvLen, filePath);
} else {
printf("\n%s %s failed to receive %d bytes for file %s, only recev %d bytes\n", __FILE__, __func__, response->content_len, filePath, recvLen);
}
} else {
return -1;
}
//free dynamically allocated memory
int i;
for (i = 0; i< numHeaders; i++) {
free(response->headers[i]);
}
free(response);
return recvLen;
}
void fileClient(int sockfd,struct sockaddr_in* servaddr, socklen_t servlen, client_args* c_arguments)
{
//printf("Filename : %s\n", c_arguments->file_name);
struct sockaddr_in newServAddr; //The address got when the child sends the port number
struct sockaddr_in changeServAddr; //New server address to which I'll do my calling
socklen_t newLen, socklen;
char buffer[BUFSIZE];
char recvBuffer[BUFSIZE];
char str[BUFSIZE];
int serverPort;
memset(str,0,BUFSIZE);
memset(recvBuffer, 0, BUFSIZE);
memset(buffer, 0, BUFSIZE);
bzero(&newServAddr, sizeof(newServAddr));
bzero(&changeServAddr, sizeof(changeServAddr));
fd_set rset;
int maxfdp1;
FD_ZERO(&rset);
int retransmitCounter =0;
inet_ntop(AF_INET,&servaddr->sin_addr, str, sizeof(str));
//printf("Server Address : %s\n", str);
//printf("Server Port : %u\n", servaddr->sin_port);
struct timeval time_count;
send_filename:
retransmitCounter++;
if(retransmitCounter > 3)
{
printf("Server never sent a Port number message\n");
printf("Now will terminate the client\n");
exit(1);
}
time_count.tv_sec = 3;
time_count.tv_usec = 0;
//printf("Length of filename = %d\n", strlen(c_arguments->file_name));
sprintf(buffer,"%s",c_arguments->file_name);
//printf("Filename : %s\n", buffer);
//if(sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr*) servaddr, sizeof(struct sockaddr)) < 0)
if(write(sockfd, buffer, strlen(buffer)) < 0)
{
perror("SendTo failed:");
exit(1);
}
FD_SET(sockfd, &rset);
maxfdp1=sockfd+1;
if(select(maxfdp1, &rset, NULL, NULL, &time_count) < 0)
{
if(errno == EINTR)
goto send_filename;
else
{
perror("Select Error :");
exit(1);
}
}
if(FD_ISSET(sockfd, &rset))
{
//printf("Hi I'm here");
newLen = sizeof(newServAddr);
if(recvfrom(sockfd, recvBuffer, BUFSIZE, 0, (struct sockaddr*)&newServAddr, &newLen) < 0)
{
perror("RecvFrom error :");
exit(1);
}
printf("Port received from server : %d\n", atoi(recvBuffer));
}
else
{
goto send_filename;
}
changeServAddr.sin_family = AF_INET;
changeServAddr.sin_addr = newServAddr.sin_addr;
changeServAddr.sin_port = htons(atoi(recvBuffer));
//Step - Forgotten
//Connect to new socket with the received port number
if(connect(sockfd,(struct sockaddr*)&changeServAddr,sizeof(struct sockaddr))< 0)
{
perror("Server Connection Failed:");
exit(1);
}
struct sockaddr_in newServSock;
socklen_t newSocklen;
bzero(&newServSock, sizeof(newServSock));
newSocklen = sizeof(newServSock);
if(getpeername(sockfd, (struct sockaddr*)&newServSock, &newSocklen) < 0)
{
perror("Getpeername failed :");
exit(1);
}
printf("New Server address %s:%u\n",inet_ntoa(newServSock.sin_addr), ntohs(newServSock.sin_port));
//Step - To send the ACK for the port number received (Send the message window)
FD_ZERO(&rset);
bzero(&newServAddr, sizeof(newServAddr));
retransmitCounter=0;
send_ACK_for_port:
retransmitCounter++;
if(retransmitCounter > 3)
{
printf("Server never sent a ACK for my message window\n");
printf("Now will terminate the client\n");
exit(1);
}
time_count.tv_sec = 3;
time_count.tv_usec = 0;
memset(buffer, 0, BUFSIZE);
sprintf(buffer,"%d",c_arguments->window_size);
//if(sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr*)&changeServAddr, sizeof(struct sockaddr)) < 0)
if(write(sockfd, buffer, strlen(buffer)) < 0)
{
perror("SendTo failed:");
exit(1);
}
FD_SET(sockfd, &rset);
maxfdp1=sockfd+1;
if(select(maxfdp1, &rset, NULL, NULL, &time_count) < 0)
{
if(errno == EINTR)
goto send_ACK_for_port;
else
{
perror("Select Error :");
exit(1);
}
}
if(FD_ISSET(sockfd, &rset))
{
//printf("Hi I'm here");
newLen = sizeof(newServAddr);
memset(recvBuffer, 0, BUFSIZE);
if(recvfrom(sockfd, recvBuffer, BUFSIZE, 0, (struct sockaddr*)&newServAddr, &newLen) < 0)
{
perror("RecvFrom error :");
if(errno == 111)
{
printf("Server never sent an ACK for my window buffer message\n");
printf("Now terminating the client\n");
}
exit(1);
}
//printf(" received this : %s\n", recvBuffer);
if(strcmp(recvBuffer, "ACK") == 0)
{
//printf("Yes\n");
goto send_ACK_for_port;
}
goto send_File;
}
else
{
goto send_ACK_for_port;
}
send_File:
recieveFile(sockfd, c_arguments->file_name, c_arguments->window_size, c_arguments->seed, c_arguments->probability, c_arguments->mean_time);
return;
}
