Question

*****Can someone please HELP me with this assignment please, I am struggling with this assignment and would appreciate some help, needs to be done in c/c++ *******

1. (100 marks) In this problem, you will write a file transfer program for transferring files between two computers connected by a network. The protocol that you will implement is called the Simple File Transfer Protocol (SFTP). The complete description for SFTP is given below.

PART 1

SFTP is a simple protocol for transferring small files from the file system on one computer to the file system on another. The computers are connected by a network. Within the context of SFTP, a small file is defined as one containing up to ten lines of text-based data consisting of uppercase and lowercase letters, the digits 0 through 9, and typical punctuation.

Any transfer begins with a request from a client to read (write) a file from (to) the file system on the server.

In a read request, the server acknowledges the request by sending the requested file to be written on the client’s file system. Upon completion of the transfer, the server sends an end-of-file message to the client, causing the client to terminate the connection.

In a write request, the server acknowledges the request by sending an acknowledgement. The client responds by sending the file to be written on the server’s file system. Upon completion of the transfer, the client sends an end-of-file message to the server and then terminates the connection.

PART 2

A transfer is initiated by a client sending a read request (rrq) or write request (wrq) message to the server.

Read request: Upon receiving an rrq message, the server will determine whether the file is empty. If the file is empty, the server will respond by sending an end-of-file (eof) message to the client. Upon receipt of the eofmessage, the client will respond by terminating the connection with the server. If the file is not empty, the server will respond by sending to the client a data (data) message containing the first line of the requested file. Upon receipt of the data message, the client will respond by sending an acknowledgement (ack) message to the server. Upon receipt of the ack message, the server will respond by sending the next line of the requested file. data and ackmessages will be exchanged in this way until all data in the file has been transferred. When there is no more data to transfer, the server will respond by sending an eof message to the client. Upon receipt of the eof message, the client will respond by terminating the connection with the server. If the server discovers that the number of lines in the file being read exceeds ten, the server will respond by sending a file size exceeded (fse) message to the client. Upon receipt of the fse message, the client will respond by sending either a continue (cont) message or an abort (abort) message to the server. Upon receipt of a cont message, the server will continue to transfer data to completion in the normal way. Upon receipt of an abort message, the server will send an ack message to the client. Upon receipt of the ack message, the client will respond by deleting all data received from the server and terminating the connection with the server.

Write request: Upon receiving a wrq message, the server will respond by sending to the client an acknowledgement(ack) message. Upon receipt of the ack message, the client will determine whether the file is empty. If the file is empty, the client will respond by sending an end-of-file (eof) message to the server. Upon receipt of the eofmessage, the server will respond by sending an ack message to the client. Upon receipt of the ack message, the client will respond by terminating the connection with the server. If the file is not empty, the client will respond by sending a data (data) message containing the first line of the file. Upon receipt of the data message, the server will respond by sending an ack message to the client. Upon receipt of the ack message, the client will respond by sending the next line of the file. data and ack messages will be exchanged in this way until all data in the file has been transferred. When there is no more data to transfer, the client will respond by sending an eof message to the server. Upon receipt of the eof message, the server will respond by sending an ack message to the client. Upon receipt of the ack message, the client will respond by terminating the connection with the server. If the server discovers that the number of lines in the file being written exceeds ten, the server will respond by sending a file size exceeded (fse) message to the client. Upon receipt of the fse message, the client will respond by sending an abort (abort) message to the server. Upon receipt of the abort message, the server will respond by sending an ackmessage to the client and deleting all data received from the client. Upon receipt of the ack message, the client will respond by terminating the connection with the server.

PART 3

Implement client and server programs for the SFTP protocol described above. The client and server programs should communicate via TCP using Berkeley sockets. The client and server programs must be based upon the source code provided in socketClient.c, socketServer.c, socketFunctions.h, and socketInclude.h. These files can be found in the directory /home/venus/hilder/cs330/assignment5/datafiles. Instructions for compiling and running these programs can be found at the end of the Programming Sockets section of the Course Notes.

Feel free to change the source code in any way you want, but you might want to consider first studying the source code, compiling it, running it, and stepping through the code with the debugger to get a better understanding as to how it works (particularly the sending and receiving of messages).

Note: When testing your client and server, run them from different machines and different directories. Also, be sure to kill all server processes you have running before you log off.

Answer 1

SERVER PROGRAM:

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#define IP_PROTOCOL 0
#define PORT_NO 15050
#define NET_BUF_SIZE 10
#define cipherKey 'S'
#define sendrecvflag 0
#define nofile "File Not Found!"

// function to clear buffer
void clearBuf(char* b)
{
   int i;
   for (i = 0; i < NET_BUF_SIZE; i++)
       b[i] = '\0';
}

// function to encrypt
char Cipher(char ch)
{
   return ch ^ cipherKey;
}

// function sending file
int sendFile(FILE* fp, char* buf, int s)
{
   int i, len;
   if (fp == NULL) {
       strcpy(buf, nofile);
       len = strlen(nofile);
       buf[len] = EOF;
       for (i = 0; i <= len; i++)
           buf[i] = Cipher(buf[i]);
       return 1;
   }

   char ch, ch2;
   for (i = 0; i < s; i++) {
       ch = fgetc(fp);
       ch2 = Cipher(ch);
       buf[i] = ch2;
       if (ch == EOF)
           return 1;
   }
   return 0;
}

// driver code
int main()
{
   int sockfd, nBytes;
   struct sockaddr_in addr_con;
   int addrlen = sizeof(addr_con);
   addr_con.sin_family = AF_INET;
   addr_con.sin_port = htons(PORT_NO);
   addr_con.sin_addr.s_addr = INADDR_ANY;
   char net_buf[NET_BUF_SIZE];
   FILE* fp;

   // socket()
   sockfd = socket(AF_INET, SOCK_DGRAM, IP_PROTOCOL);

   if (sockfd < 0)
       printf("\nfile descriptor not received!!\n");
   else
       printf("\nfile descriptor %d received\n", sockfd);

   // bind()
   if (bind(sockfd, (struct sockaddr*)&addr_con, sizeof(addr_con)) == 0)
       printf("\nSuccessfully binded!\n");
   else
       printf("\nBinding Failed!\n");

   while (1) {
       printf("\nWaiting for file name...\n");

       // receive file name
       clearBuf(net_buf);

       nBytes = recvfrom(sockfd, net_buf,
                       NET_BUF_SIZE, sendrecvflag,
                       (struct sockaddr*)&addr_con, &addrlen);

       fp = fopen(net_buf, "r");
       printf("\nFile Name Received: %s\n", net_buf);
       if (fp == NULL)
           printf("\nFile open failed!\n");
       else
           printf("\nFile Successfully opened!\n");

       while (1) {

           // process
           if (sendFile(fp, net_buf, NET_BUF_SIZE)) {
               sendto(sockfd, net_buf, NET_BUF_SIZE,
                   sendrecvflag,
                   (struct sockaddr*)&addr_con, addrlen);
               break;
           }

           // send
           sendto(sockfd, net_buf, NET_BUF_SIZE,
               sendrecvflag,
               (struct sockaddr*)&addr_con, addrlen);
           clearBuf(net_buf);
       }
       if (fp != NULL)
           fclose(fp);
   }
   return 0;
}

CLIENT PROGRAM:

// client code for UDP socket programming
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#define IP_PROTOCOL 0
#define IP_ADDRESS "127.0.0.1" // localhost
#define PORT_NO 15050
#define NET_BUF_SIZE 32
#define cipherKey 'S'
#define sendrecvflag 0

// function to clear buffer
void clearBuf(char* b)
{
   int i;
   for (i = 0; i < NET_BUF_SIZE; i++)
       b[i] = '\0';
}

// function for decryption
char Cipher(char ch)
{
   return ch ^ cipherKey;
}

// function to receive file
int recvFile(char* buf, int s)
{
   int i;
   char ch;
   for (i = 0; i < s; i++) {
       ch = buf[i];
       ch = Cipher(ch);
       if (ch == EOF)
           return 1;
       else
           printf("%c", ch);
   }
   return 0;
}

// driver code
int main()
{
   int sockfd, nBytes;
   struct sockaddr_in addr_con;
   int addrlen = sizeof(addr_con);
   addr_con.sin_family = AF_INET;
   addr_con.sin_port = htons(PORT_NO);
   addr_con.sin_addr.s_addr = inet_addr(IP_ADDRESS);
   char net_buf[NET_BUF_SIZE];
   FILE* fp;

   // socket()
   sockfd = socket(AF_INET, SOCK_DGRAM,
                   IP_PROTOCOL);

   if (sockfd < 0)
       printf("\nfile descriptor not received!!\n");
   else
       printf("\nfile descriptor %d received\n", sockfd);

   while (1) {
       printf("\nPlease enter file name to receive:\n");
       scanf("%s", net_buf);
       sendto(sockfd, net_buf, NET_BUF_SIZE,
           sendrecvflag, (struct sockaddr*)&addr_con,
           addrlen);

       printf("\n---------Data Received---------\n");

       while (1) {
           // receive
           clearBuf(net_buf);
           nBytes = recvfrom(sockfd, net_buf, NET_BUF_SIZE,
                           sendrecvflag, (struct sockaddr*)&addr_con,
                           &addrlen);

           // process
           if (recvFile(net_buf, NET_BUF_SIZE)) {
               break;
           }
       }
       printf("\n-------------------------------\n");
   }
   return 0;
}