#include

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

<sys/stat.h>
<arpa/inet.h>
<sys/wait.h>
<sys/socket.h>
<stdio.h>
<time.h>
<dirent.h>
<sys/types.h>
<netinet/in.h>
<arpa/inet.h>
<fcntl.h>
<unistd.h>
<signal.h>
<errno.h>
<stdlib.h>
<netdb.h>

#define ShareDir "./shared"

void error(const char *msg)
{
perror(msg);
exit(0);
}
int fd[2];
int choice;
struct filestat
{
struct stat *buffarray;
char* name[200];
int len;
};
typedef struct file
{
char name[1024];
char time[1024];
int size;
char type[200];
}file;
// getting time from string
time_t gettime(char *intime)
{
char *a = strtok(intime, "_");
int time1[6];
int i = 0;
struct tm t1={0};
while(a != NULL)
{
time1[i++] = atoi(a);
a = (char*)strtok(NULL, "_");
}
while(i < 6)
time1[i++] = 0;

if(time1[2] == 0)
time1[2] = 1;
t1.tm_year = time1[0] - 1900;
t1.tm_mon = time1[1] - 1;
t1.tm_mday = time1[2];
t1.tm_hour = time1[3];
t1.tm_min = time1[4];
t1.tm_sec = time1[5];
}

return mktime(&t1);

int getlistlong(const char *path,struct dirent* listfiles)

{
struct dirent *entry;
DIR *dp;
dp = opendir(path);
if (dp == NULL) {
perror("opendir");
return -1;
}
int i;
for(i=0;i<200 && (entry = readdir(dp));i++)
{
listfiles[i] = (*entry);
}

closedir(dp);
return i;

struct filestat* shortlist(time_t fromTime,time_t toTime)

{
int i,j;
struct dirent* querylist = (struct
dirent*)malloc(200*sizeof(struct dirent));
i = getlistlong("./shared", querylist);
int k = 0;
struct stat *buff;
struct filestat *templist = (struct filestat*)malloc(sizeof(struct
filestat));
templist->buffarray = (struct stat*)malloc(200*sizeof(struct
stat));
for(j=0;j<i;j++)
{
char a[NAME_MAX] = "./shared/";
strcat(a,querylist[j].d_name);
stat(a,buff);
if((difftime(buff->st_mtime,fromTime)*difftime(buff>st_mtime,toTime)) < 0 )
{
(templist->buffarray)[k] = *buff;
(templist->name)[k] = (char*)malloc(sizeof(char)*1024);
strcpy((templist->name)[k],querylist[j].d_name);
k++;
}

}
templist->len = k;
return templist;

void cIndexget(char buff[],int *sock)

{
int n;
char read_buff[1024];
bzero(read_buff, 1024);
while((n=read(*sock,read_buff,1024))>0)
{
read_buff[n]='\0';
if(strcmp(read_buff,"END")==0)
break;
printf("%s",read_buff);
}
printf("\n");
}
int serPort,clPort;
char clIp[100];
char recv_command[1000][1000];
char send_command[1000][1000];
pid_t pid;
void sIndexget(char read_buffer[],int *sock)
{
char str1[1024],str2[1024];
char l[8]="LongList";
char r[5]="RegEx";
char s[9]="ShortList";
char write_buff[1024];
int f=0,i=0;
if(strstr(read_buffer,l)!=NULL)
f=0;
if(strstr(read_buffer,r)!=NULL)
f=1;
if(strstr(read_buffer,s)!=NULL)
f=2;
FILE *fs;
int flag = 0;
bzero(write_buff,1024);
if(f==0)
{
struct dirent *get_list = (struct
dirent*)malloc(200*sizeof(struct dirent));
int len = getlistlong("./shared",get_list);
int i;
int fi=0,flag=0;
bzero(write_buff, 1024);
for(i=0;i<len;i++)
{
printf("%s\n",write_buff);
strcpy(write_buff,get_list[i].d_name);
if(write(*sock, write_buff, 1024) < 0)
error("\nERROR: Writing to socket");

bzero(write_buff, 1024);
flag=1;
}
}
if(f==1)
{
bzero(str1,1024);
bzero(str2,1024);
int k=0;
i=19;
while(i<38)
str1[k++]=read_buffer[i++];
str1[k]='\0';
i++;
k=0;
while(i<58)
str2[k++]=read_buffer[i++];
str2[k]='\0';
}
if(f==2)
{
bzero(str1,1024);
bzero(str2,1024);
int k=0;
i=19;
while(i<38)
str1[k++]=read_buffer[i++];
str1[k]='\0';
i++;
k=0;
while(i<58)
str2[k++]=read_buffer[i++];
str2[k]='\0';
struct filestat *getlist;
getlist = shortlist(gettime(str1),gettime(str2));
bzero(write_buff, 1024);
char a[1024];
for(i=0;i<getlist->len;i++)
{
//
printf("%s\n",write_buff);
strcpy(a,(getlist->name)[i]);
strcat(a,"
");
strcat(a,ctime((getlist->buffarray)[i].st_mtime));
strcpy(write_buff,a);
if(write(*sock, write_buff, 1024) < 0)
error("\nERROR: Writing to socket");
bzero(write_buff, 1024);
flag=1;
}

}
bzero(write_buff, 1024);
strcpy(write_buff,"END");
if(write(*sock, write_buff, 1024) < 0)
error("\nERROR: Writing to socket");

void Filehash(char read_buffer[] , int *newsock_fd)

{
int f=0;
if(strstr(read_buffer,"Verify") != NULL )
f = 1;
else if(strstr(read_buffer,"CheckAll") != NULL )
f = 2;
if(f==1)
{
int i=0,k;
int len=strlen(read_buffer);
char file[1024];
for(k=0,i=16;i!=len;i++,k++)
file[k]=read_buffer[i];
file[k]='\0';
char md5sum[1024],query[1024],write_buffer[1024];
bzero(write_buffer,1024);
strcpy(md5sum,"md5sum ");
strcat(md5sum,file);
system("touch tmp1");
system("touch tmp1");
strcat(md5sum," > tmp1");
system(md5sum);
strcpy(query,"stat ");
strcat(query,file);
strcat(query," | grep Modify | awk '{print $3}' > tmp2");
system(query);
FILE *f1=fopen("tmp1","r");
FILE *f2=fopen("tmp2","r");
char t1[1024],t2[1024];
fread(t1,sizeof(char),1024,f1);
fread(t2,sizeof(char),1024,f2);
i = 0;
while( t1[i++] != ' ' );
t1[i] = '\0';
strcpy(write_buffer,file);
strcat(write_buffer,"\t");
strcat(write_buffer,t1);
strcat(write_buffer,"\t");
strcat(write_buffer,t2);
system("rm tmp1 tmp2");
if(write(*newsock_fd, write_buffer, 1024) < 0)
error("\nERROR: Writing to socket");
bzero(write_buffer,1024);
strcpy(write_buffer,"END");
if(write(*newsock_fd, write_buffer, 1024) < 0)
error("\nERROR: Writing to socket");
}
if(f==2)
{
DIR *dp;
struct dirent *ep;
char tmp[1024];
dp=opendir(".");
if(dp!=NULL)
{
while ( (ep = readdir (dp)) != NULL)
{

if( ep->d_type == 8 )
{
strcpy(tmp,ep->d_name);
char md5sum[1024],query[1024],write_buffer[1024];
bzero(write_buffer,1024);
strcpy(md5sum,"md5sum ");
strcat(md5sum,tmp);
strcat(md5sum," > tmp1");
system(md5sum);
strcpy(query,"stat ");
strcat(query,tmp);
strcat(query," | grep Modify | awk '{print $3}' >
tmp2");

system(query);
system("touch tmp1");
system("touch tmp1");
FILE *f1=fopen("tmp1","r");
FILE *f2=fopen("tmp2","r");
char t1[1024],t2[1024];
fread(t1,sizeof(char),1024,f1);
fread(t2,sizeof(char),1024,f2);
int i = 0;
while( t1[i++] != ' ' );
t1[i] = '\0';
strcpy(write_buffer,tmp);
strcat(write_buffer,"\t");
strcat(write_buffer,t1);
strcat(write_buffer,"\t");
strcat(write_buffer,t2);
system("rm tmp1 tmp2");
if(write(*newsock_fd, write_buffer, 1024) < 0)
error("\nERROR: Writing to socket");
bzero(write_buffer,1024);
strcpy(write_buffer,"END");
if(write(*newsock_fd, write_buffer, 1024) < 0)
error("\nERROR: Writing to socket");
}
}
(void )closedir(dp);

}
else

error ("Couldn't open the directory");

void Filedownload(char read_buffer[] , int *newsock_fd)

{
char write_buffer[1024];
int i,n;
char file[1024];
for(i=13;read_buffer[i]!='\0';i++)
file[i-13]=read_buffer[i];
file[i-13]='\0';
FILE *fp;
if(fp==NULL)
{

if( write(*newsock_fd,"file doesn't exist",1024)<0)

error("\nERROR: Writing to socket");
return;

}
fp=fopen(file,"rb");
bzero(write_buffer,1024);
while((n=fread(write_buffer,1,1024,fp))>0)
{
if( write(*newsock_fd,write_buffer,1024)<0)
error("\nERROR: Writing to socket");
bzero(write_buffer,1024);
}
strcpy(write_buffer,"END");
if( write(*newsock_fd,write_buffer,1024)<0)
error("\nERROR: Writing to socket");
fclose(fp);

}
void cFiledownload(char write_buffer[],int *sockfd)
{
int n,i;
char read_buff[1024];
char file[1024];
for(i=13;write_buffer[i]!='\0';i++)
file[i-13]=write_buffer[i];
file[i-13]='\0';
FILE *fp=fopen(file,"w");
printf("Downloading\n");
fflush(stdout);
bzero(read_buff, 1024);
while((n=read(*sockfd,read_buff,1024))>0)
{
read_buff[n]='\0';
if(strcmp(read_buff,"END")==0)
break;
fprintf(fp,"%s",read_buff);
printf(".");
fflush(stdout);
bzero(read_buff, 1024);
}
printf("\nDownload Complete\n");
fflush(stdout);
fclose(fp);
}
void FileUpload(char read_buffer[],int *newsockfd)
{
char write_buffer[1024];
int i,n;
char file[1024];
for(i=11;read_buffer[i]!='\0';i++)
file[i-11]=read_buffer[i];
file[i-11]='\0';
printf("Received Upload request for %s\n",file);
printf("Allow/Deny the client to upload:\n");
char inp[100];
fflush(stdout);
kill (pid,SIGSTOP);
scanf("%s",inp);
if(strlen(inp)>0 && inp[strlen(inp)]=='\n')

inp[strlen(inp)]='\0';
kill (pid,SIGCONT);
//char inp[1024];
//if((n=read(fd[0],&inp,1024))<=0)
// error("Pipe Error\n");
if(n=write(*newsockfd,inp,1024)<0)
error("Error writing to socket\n");
if(strcmp(inp,"FileUploadAllow")==0)
{
bzero(write_buffer, 1024);
FILE * fp=fopen(file,"wb");
if(fp==NULL)
error("File Cannot be opened file on peer.\n");
printf("Downloading\n");
fflush(stdout);
bzero(write_buffer, 1024);
while(1)
{
if((n=read(*newsockfd,write_buffer,1024))<=0)
error("\nERROR: Writing to socket");
if(strcmp(write_buffer,"END")==0)
break;
fprintf(fp,"%s",write_buffer);
bzero(write_buffer, 1024);
printf(".");
fflush(stdout);
}
printf("\nDownload Complete\n");
fflush(stdout);
fclose(fp);
}

}
void cFileUpload(char write_buffer[],int *sockfd)
{
int n,i;
char read_buffer[1024];
char file[1024];
for(i=11;write_buffer[i]!='\0';i++)
file[i-11]=write_buffer[i];
file[i-11]='\0';
bzero(read_buffer,1024);
if(n=read(*sockfd,read_buffer,1024)<0)
error("Error in reading from socket");
if(strcmp(read_buffer,"FileUploadAllow")==0)
{
printf("Uploading\n");
fflush(stdout);
bzero(read_buffer,1024);
FILE *fp=fopen(file,"rb");
if(fp==NULL)
error("ERROR: File not found on server.\n");
while((n=fread(read_buffer,sizeof(char),1024,fp))>0)
{
if(write(*sockfd,read_buffer,1024)<=0)
error("Error in writing in socket");
bzero(read_buffer,1024);
printf(".");
fflush(stdout);

}
fclose(fp);
if(write(*sockfd,"END",1024)<=0)
error("Error in writing in socket");
printf("\nUpload Complete\n");
fflush(stdout);
}
}
void server()
{
int sockfd, newsockfd;
socklen_t cli_len;
char read_buffer[1024];
struct sockaddr_in servi_addr, cli_addr;
int n,i;
if(choice==0)
{
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("Socket");
exit(1);
}
}
else
{
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("Socket");
exit(1);
}
}
bzero((char *) &servi_addr, sizeof(servi_addr));
servi_addr.sin_family = AF_INET;
servi_addr.sin_addr.s_addr = INADDR_ANY;
servi_addr.sin_port = htons(serPort);
if (bind(sockfd, (struct sockaddr *)&servi_addr, sizeof(servi_addr))
<0) {
error("Unable to bind");
}
else
printf("[Server] Socket Binded to the Server Address\n");
if(choice==0)
{
if (listen(sockfd, 5) == -1) {
perror("Listen");
exit(1);
}
printf("\nTCPServer Waiting for client on port %d",serPort);
fflush(stdout);
}
else
{
printf("\nUDPServer Waiting for client on port %d",serPort);
fflush(stdout);
}
// while(1)
// {

cli_len = sizeof(cli_addr);
if(choice==0)
{
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr,
&cli_len);
if (newsockfd < 0)
{
perror("ERROR on accept");
exit(1);
}
printf("\nServer:I got a connection from (%s ,
%d)\n",inet_ntoa(cli_addr.sin_addr),ntohs(cli_addr.sin_port));
fflush(stdout);
}
while (1)
{
bzero(read_buffer,1024);
n= read(newsockfd, read_buffer , 1024);
if (n < 0)
error("ERROR writing to socket");
//
read_buffer[n]='\0';
int n;
int i;
int c=0;
int j=0;
for(i=0;i<strlen(read_buffer);i++)
{
if(read_buffer[i] == ' ')
{
recv_command[c][j]='\0';
j=0;
c++;
}
else
recv_command[c][j++]=read_buffer[i];
}
recv_command[c][j]='\0';
if(strcmp(read_buffer, "q")==0 || strcmp(read_buffer, "Q")==0)
{
printf("\nRecieved Data: %s\n",read_buffer);
kill(pid,SIGTERM);
break;
}
else if(strncmp(read_buffer , "IndexGet",8)==0){
printf("\nRecieved Data: %s\n",read_buffer);
sIndexget(read_buffer,&newsockfd);
}
else if(strncmp(read_buffer,"FileHash",8)==0)
{
printf("\nRecieved Data: %s\n",read_buffer);
Filehash(read_buffer,&newsockfd);
}
else if(strncmp(read_buffer,"FileDownload",12)==0)
{
printf("\nRecieved Data: %s\n",read_buffer);
Filedownload(read_buffer,&newsockfd);
}

else if(strncmp(read_buffer,"FileUpload",10)==0)
{
printf("\nRecieved Data: %s\n",read_buffer);
FileUpload(read_buffer,&newsockfd);
}
else
{
printf("\nRecieved Data : %s\n" , read_buffer);
}
fflush(stdout);
//
while(waitpid(-1, NULL, WNOHANG) > 0);

}
close(newsockfd);
printf("\nConnection closed by peer\n");
fflush(stdout);
// }
close(sockfd);
exit(1);
}

void client()
{
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;
char read_buffer[1024],write_buffer[1024];
if(choice==0)
{
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0))<0) {
perror("Socket");
exit(1);
}
}
else
{
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("Socket");
exit(1);
}
}
printf("\n[Client] Socket created\n");
server = gethostbyname("127.0.0.1");
if (server == NULL)
{
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(clPort);
serv_addr.sin_addr = *((struct in_addr *)server->h_addr);
bzero(&(serv_addr.sin_zero),8);
if(choice==0)
{
while(connect(sockfd, (struct sockaddr
*)&serv_addr,sizeof(serv_addr))<0)

printf("Connecting\n");
sleep(1);

}
printf("\nClient:Connected to Port No: %d\n",clPort);

}
while(1)
{
bzero(write_buffer , 1024);
printf("\nMessage: ");
fgets(write_buffer,1024,stdin);
printf("\n");
int len=strlen(write_buffer);
if(len>0 && write_buffer[len-1]=='\n')
{
write_buffer[len-1]='\0';
len--;
}
if(strcmp(write_buffer , "Q")==0 || strcmp(write_buffer ,
"q")==0)
{
n = write(sockfd,write_buffer,1024);
if (n < 0)
error("ERROR writing to socket");
printf("[Client] Connection closed\n");
kill(pid,SIGTERM);
break;
}
else if(strncmp(write_buffer,"IndexGet",8)==0 ||
strncmp(write_buffer,"FileHash",8)==0)
{
n = write(sockfd,write_buffer,1024);
if (n < 0)
error("ERROR writing to socket");
cIndexget(write_buffer,&sockfd);
}
else if(strncmp(write_buffer,"FileDownload",12)==0)
{
n = write(sockfd,write_buffer,1024);
if (n < 0)
error("ERROR writing to socket");
cFiledownload(write_buffer,&sockfd);
}
else if(strncmp(write_buffer,"FileUpload",10)==0)
{
n = write(sockfd,write_buffer,1024);
if (n < 0)
error("ERROR writing to socket");
cFileUpload(write_buffer,&sockfd);
}
else
{
if(write(sockfd,write_buffer,1024)<0)
error("ERROR writing to socket");
}
}
close(sockfd);
exit(0);

}
int main(int argc,char *argv[])
{
pipe(fd);
printf("Enter Port Number on which you want to listen\n");
scanf("%d",&serPort);
printf("0->TCP Mode\n1->UDP Mode\n");
scanf("%d",&choice);
//printf("Enter IP address on which you want to send the data\n");
//scanf("%s",clIp);
printf("Enter Port Number on which you want to send the data\n");
scanf("%d",&clPort);
pid=fork();
if(pid==-1)
{
printf("Error:Creating Fork\n");
exit(0);
}
else if(pid==0)
{
close(fd[0]);
client();
}
else
{
close(fd[1]);
server();
}
return 0;
}