/* *****************************************************
*
* receiver2.c
*
******************************************************* */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <pthread.h>

#define LOCALPORT 2000 + (100 * 7) + 6
#define LOCALPORT1 2000 + (100 * 7) + 1
#define LOCALPORT2 2000 + (100 * 7) + 2
#define LOCALPORT3 2000 + (100 * 7) + 3
#define LOCALPORT4 2000 + (100 * 7) + 4
#define LOCALPORT5 2000 + (100 * 7) + 5
#define MAXRCVBUFFER 64
#define LOCALIP "xxx.xx.xxx.xx"
#define SERVERIP "xxx.xx.xxx.xx"
#define MYSIZE 0
#define FILESTODO 5

int myconversion();
void conversion(int);
void itoc(int, int);
void assignment2(int);
void assignment3(int);
void assignment4(int);
void assignment5(int);
void assignment6(int);
void assignment7(int);
void assignment8(int);
void assignment9(int);
void assignment10(int);

int loopcontrol = 0;
int filesdone = 0;
int mybuffer = 0;
int mypac = 0;

char currentack[MAXRCVBUFFER] = "";
char buftmp[MAXRCVBUFFER] = "";
char buf[MAXRCVBUFFER] = "";
char myack[MAXRCVBUFFER] = "";
char clean[MAXRCVBUFFER] = "";

char file_name[MAXRCVBUFFER] = "";
char file_name1[MAXRCVBUFFER] = "";
char file_name2[MAXRCVBUFFER] = "";
char file_name3[MAXRCVBUFFER] = "";
char file_name4[MAXRCVBUFFER] = "";
char file_name5[MAXRCVBUFFER] = "";

char gargvv[MAXRCVBUFFER] = "";

char initial[MAXRCVBUFFER] = "";

void thread_one(int *);
void thread_two(int *);
void thread_three(int *);
void thread_four(int *);
void thread_five(int *);

void activate_one();
void activate_two();
void activate_three();
void activate_four();
void activate_five();

void displaypc();
void displayspc();
void displaypl();
void state_transition_diagram(int x, int y, int z);
void routing_table();

void runningf();

int n1 = 0;
int numberr = 0;

int runningthreads = 0;
int run1,run2,run3,run4,run5 = 0;

pthread_t thread1, thread2, thread3, thread4, thread5;

int rt1[50]={0};
int rt2[50]={0};
int rt3[50]={0};
int rt4[50]={0};
int rt5[50]={0};
int xx=0;

int pc1, pc2, pc3, pc4, pc5, tpc = 0;
int pcd1, pcd2, pcd3, pcd4, pcd5, tpcd = 0;
int pcs1, pcs2, pcs3, pcs4, pcs5, tpcs = 0;
int pcds1, pcds2, pcds3, pcds4, pcds5, tpcds = 0;

FILE *ofp;
FILE *ofp1;
FILE *ofp2;
FILE *ofp3;
FILE *ofp4;
FILE *ofp5;

/* main communication setup */
/* ------------------------ */
int sockfd, sockfd1, sockfd2, sockfd3, sockfd4, sockfd5;
struct sockaddr_in my_addr;
struct sockaddr_in their_addr;
int addr_len, addr_len1, addr_len2, addr_len3, addr_len4;
int addr_len5, addr_len6, numbytes;

/* ===================================================================== */
main(int argc, char *argv[], char *argvv[])
{
system("clear");
state_transition_diagram(1,0,0);

if ((sockfd = socket(AF_INET, SOCK_DGRAM,0)) == -1)
{
perror("Main Socket Error...");
exit(1);
}

my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(LOCALPORT);
my_addr.sin_addr.s_addr = inet_addr(LOCALIP);
bzero(&(my_addr.sin_zero),8);

if (bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr)) == -1)
{
perror("Main Binding Error...");
exit(1);
}

/* three way handshaks algorithm */
/* ----------------------------- */
addr_len = sizeof(struct sockaddr);
if ((numbytes = recvfrom(sockfd,initial,MAXRCVBUFFER,0,
(struct sockaddr*)&their_addr,&addr_len)) == -1)
{
perror("rs: Error Receiving: SYN, SequenceNum = x");
exit(1);
}
printf("\n ----------------------------------------------------------------");
printf("\n rs: Connection Establishment: Three-Way Handshake for Project 2");
printf("\n rs: Receiving : SYN, SequenceNum = x");
/* ----------------------------- */
numberr = myconversion();
numberr++;
conversion(numberr);
strcpy(myack,currentack);

if ((numbytes = sendto(sockfd,myack,strlen(myack),0,
(struct sockaddr *)&their_addr,sizeof(struct sockaddr))) ==-1)
{
perror("rs: Error Sending: SYN+ACK, SequenceNum = y");
exit(1);
}
printf("\n rs: Sending : SYN+ACK, SequenceNum = y");
/* ----------------------------- */
addr_len6 = sizeof(struct sockaddr);
if ((numbytes = recvfrom(sockfd,initial,MAXRCVBUFFER,0,
(struct sockaddr*)&their_addr,&addr_len6)) == -1)
{
perror("rs: Error Receiving: SYN, SequenceNum = x");
exit(1);
}
printf("\n rs: Receiving : ACK, Acknowlegnment = y + 1");
printf("\n ---------------------------------------------------------------- \n");
/* end three way handshaks algorithm */
/* --------------------------------- */
/* ***************************************** */
if (strcmp(argv[2],"1")==0)
strcpy(gargvv,"1");
if (strcmp(argv[2],"2")==0)
strcpy(gargvv,"2");
if (strcmp(argv[2],"3")==0)
strcpy(gargvv,"3");
if (strcmp(argv[2],"4")==0)
strcpy(gargvv,"4");
if (strcmp(argv[2],"5")==0)
strcpy(gargvv,"5");

if (strcmp(argv[1],"1")==0)
{
activate_one();
run1 =1;
runningf();
}
if (strcmp(argv[1],"2")==0)
{
activate_one();
activate_two();
run1 =1;
run2 =1;
runningf();
}
if (strcmp(argv[1],"3")==0)
{
activate_one();
activate_two();
activate_three();
run1 =1;
run2 =1;
run3 =1;
runningf();
}
if (strcmp(argv[1],"4")==0)
{
activate_one();
activate_two();
activate_three();
activate_four();
run1 =1;
run2 =1;
run3 =1;
run4 =1;
runningf();
}
if (strcmp(argv[1],"5")==0)
{
activate_one();
activate_two();
activate_three();
activate_four();
activate_five();
run1 =1;
run2 =1;
run3 =1;
run4 =1;
run5 =1;
runningf();
}
/* ***************************************** */
while ((run1!=0)||(run2!=0)||(run3!=0)||(run4!=0)||(run5!=0))
{
}
runningf();
displaypl();
displaypc();
displayspc();
return(0);
}
/* ===================================================================== */
void activate_one()
{
/* activation thread one */
/* --------------------- */
if (pthread_create(&thread1,NULL,thread_one,(void *)&n1)!=0)
{
perror("pthread_create Error thread_one");
exit(1);
}
printf("\n rs: Activating thread 1 with ID: %ld", (long int) &thread1);
}

void activate_two()
{
/* activation thread two */
/* --------------------- */
if (pthread_create(&thread2,NULL,thread_two, (void *) &n1) != 0)
{
perror("pthread_create Error thread_two");
exit(1);
}
printf("\n rs: Activating thread 2 with ID: %ld", (long int) &thread2);
}

void activate_three()
{
/* activation thread three */
/* ----------------------- */
if (pthread_create(&thread3,NULL,thread_three,(void *)&n1)!=0)
{
perror("pthread_create Error thread_three");
exit(1);
}
printf("\n rs: Activating thread 3 with ID: %ld",(long int)&thread3);
}

void activate_four()
{
/* activation thread four */
/* ----------------------- */
if (pthread_create(&thread4,NULL,thread_four,(void *)&n1)!=0)
{
perror("pthread_create Error thread_four");
exit(1);
}
printf("\n rs: Activating thread 4 with ID: %ld",(long int)&thread4);
}

void activate_five()
{
/* activation thread five */
/* ----------------------- */
if (pthread_create(&thread5,NULL,thread_five,(void *)&n1)!=0)
{
perror("pthread_create Error thread_five");
exit(1);
}
printf("\n rs: Activating thread 5 with ID: %ld",(long int)&thread5);
}

void thread_one(int *n)
{
int x = 0;
int ack1 = 0;

struct sockaddr_in my_addr1;
struct sockaddr_in their_addr1;
struct sockaddr_in theirs_addr1;
struct sockaddr_in t_addr1;

char my_file1[MAXRCVBUFFER] = "";
if (strcmp(gargvv,"1")==0)
strcpy(my_file1,"receive_client1_1");
if (strcmp(gargvv,"2")==0)
strcpy(my_file1,"receive_client1_2");
if (strcmp(gargvv,"3")==0)
strcpy(my_file1,"receive_client1_3");
if (strcmp(gargvv,"4")==0)
strcpy(my_file1,"receive_client1_4");
if (strcmp(gargvv,"5")==0)
strcpy(my_file1,"receive_client1_5");

ofp1 = fopen(my_file1,"w");

/* ------------- */
if ((sockfd1 = socket(AF_INET, SOCK_DGRAM,0)) == -1)
{
perror("Main Socket 1 Error...");
exit(1);
}

their_addr1.sin_family = AF_INET;
their_addr1.sin_addr.s_addr = inet_addr(LOCALIP);
their_addr1.sin_port = htons(LOCALPORT1);
bzero(&(my_addr1.sin_zero),8);

theirs_addr1.sin_family = AF_INET;
theirs_addr1.sin_addr.s_addr = inet_addr(SERVERIP);
theirs_addr1.sin_port = htons(LOCALPORT1);
/* bzero(&(my_addr2.sin_zero),8); */

if (bind(sockfd1,(struct sockaddr *)&their_addr1,sizeof(struct sockaddr))==-1)
{
perror("Main 1 Binding Error...");
exit(1);
}

/* state transition diagram */
state_transition_diagram(1,1,0); /* state transition diagram */
/* state transition diagram */

/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t1: Connection Establishment: Three-Way Handshake for Thread %d",(long int)&thread1);
printf("\n rs: t1: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(2,1,0); /* state transition diagram */
/* state transition diagram */

addr_len1 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd1,file_name1,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs_addr1,&addr_len1))== -1)
{
perror("rs: t1: Error receiving: SYN, SequenceNum = x in thread1");
exit(1);
}
pc1++;
printf("\n rs: t1: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(3,1,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd1,myack,strlen(myack),0,
(struct sockaddr *)&theirs_addr1,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t1: Error sending SYN+ACK, SequenceNum = y from thread 1 ->");
exit(1);
}
pcs1++;
printf("\n rs: t1: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(4,1,0); /* state transition diagram */
/* state transition diagram */

addr_len1 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd1,file_name1,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs_addr1,&addr_len1))== -1)
{
perror("Error receiving in thread1");
exit(1);
}
pc1++;
/* ------------- */
/* ------------- */
printf("\n Thread %ld has been activated\n",(long int)&thread1);

printf("\n rs: t1: Buffer: %s",file_name1);
printf("\n rs: t1: Port Used by %ld: ",(long int)&thread1);
printf("%d",LOCALPORT1);
printf("\n rs: t1: Server IP Address: %s",inet_ntoa(their_addr1.sin_addr));
printf("\n");

strcpy(file_name1,"");
while (strcmp(file_name1,"111110End111110Of111110File111110")!=0)
{
addr_len1 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd1,file_name1,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs_addr1,&addr_len1))== -1)
{
perror("Error receiving in thread1");
exit(1);
}
pc1++;
if (strcmp(file_name1,"111110End111110Of111110File111110")!=0)
{
pcd1++;
fprintf(ofp1,"%s",file_name1);
/* printf("%s",file_name1); */
}

ack1++;
strcpy(myack,"ack");
if((numbytes = sendto(sockfd1,myack,strlen(myack),0,
(struct sockaddr *)&theirs_addr1,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t1: Error sending ack from thread 1 ->");
exit(1);
}
pcs1++;
} /* end of while loop */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t1: Connection Termination : Three-Way Handshake for Thread %d",(long int)&thread1);
printf("\n rs: t1: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(5,1,0); /* state transition diagram */
/* state transition diagram */

addr_len1 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd1,file_name1,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs_addr1,&addr_len1))== -1)
{
perror("rs: t1: Error receiving: SYN, SequenceNum = x in thread1");
exit(1);
}
pc1++;
printf("\n rs: t1: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(8,1,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd1,myack,strlen(myack),0,
(struct sockaddr *)&theirs_addr1,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t1: Error sending SYN+ACK, SequenceNum = y from thread 1 ->");
exit(1);
}
pcs1++;
printf("\n rs: t1: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");
addr_len1 = sizeof(struct sockaddr);

/* state transition diagram */
state_transition_diagram(34,1,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = recvfrom(sockfd1,file_name1,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs_addr1,&addr_len1))== -1)
{
perror("Error receiving in thread1");
exit(1);
}
pc1++;
/* ------------- */
/* ------------- */
printf("\n rs t1: finish with client: %s",inet_ntoa(their_addr1.sin_addr));
printf("\n rs t1: finish receiving in thread 1 \n");

rt1[xx]=(long int) &thread1;
rt3[xx]=LOCALPORT1;
rt5[xx]=LOCALPORT1;
xx++;
routing_table();

close(sockfd1);
close(ofp1);
runningf();
run1 = 0;
}

void thread_two(int *n)
{
int x2 = 0;
int ack2 = 0;

struct sockaddr_in my_addr2;
struct sockaddr_in their2_addr2;
struct sockaddr_in theirs2_addr2;
struct sockaddr_in t_addr2;

char my_file2[MAXRCVBUFFER] = "";
if (strcmp(gargvv,"1")==0)
strcpy(my_file2,"receive_client2_1");
if (strcmp(gargvv,"2")==0)
strcpy(my_file2,"receive_client2_2");
if (strcmp(gargvv,"3")==0)
strcpy(my_file2,"receive_client2_3");
if (strcmp(gargvv,"4")==0)
strcpy(my_file2,"receive_client2_4");
if (strcmp(gargvv,"5")==0)
strcpy(my_file2,"receive_client2_5");

ofp2 = fopen(my_file2,"w");

/* ------------- */
if ((sockfd2 = socket(AF_INET, SOCK_DGRAM,0)) == -1)
{
perror("Main Socket 2 Error...");
exit(1);
}

their2_addr2.sin_family = AF_INET;
their2_addr2.sin_addr.s_addr = inet_addr(LOCALIP);
their2_addr2.sin_port = htons(LOCALPORT2);
bzero(&(my_addr2.sin_zero),8);

theirs2_addr2.sin_family = AF_INET;
theirs2_addr2.sin_addr.s_addr = inet_addr(SERVERIP);
theirs2_addr2.sin_port = htons(LOCALPORT2);
/* bzero(&(my_addr2.sin_zero),8); */

if (bind(sockfd2,(struct sockaddr *)&their2_addr2,sizeof(struct sockaddr))==-1)
{
perror("Main 2 Binding Error...");
exit(1);
}

/* state transition diagram */
state_transition_diagram(1,2,0); /* state transition diagram */
/* state transition diagram */

/* ------------- */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t2: Connection Establishment: Three-Way Handshake for Thread %d",(long int)&thread2);
printf("\n rs: t2: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(2,2,0); /* state transition diagram */
/* state transition diagram */

addr_len2 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd2,file_name2,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs2_addr2,&addr_len2))== -1)
{
perror("rs: t2: Error receiving: SYN, SequenceNum = x in thread2");
exit(1);
}
pc2++;
printf("\n rs: t2: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(3,2,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd2,myack,strlen(myack),0,
(struct sockaddr *)&theirs2_addr2,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t2: Error sending SYN+ACK, SequenceNum = y from thread 2 ->");
exit(1);
}
pcs2++;
printf("\n rs: t2: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(4,2,0); /* state transition diagram */
/* state transition diagram */

addr_len2 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd2,file_name2,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs2_addr2,&addr_len2))== -1)
{
perror("Error receiving in thread2");
exit(1);
}
pc2++;
/* ------------- */
/* ------------- */

printf("\n Thread %ld has been activated\n",(long int)&thread2);

printf("\n rs t2: Buffer: %s",file_name2);
printf("\n rs t2: Port Used by %ld: ",(long int)&thread2);
printf("%d",LOCALPORT2);
printf("\n rs t2: Server IP Address: %s",inet_ntoa(their2_addr2.sin_addr));
printf("\n");

strcpy(file_name2,"");
while (strcmp(file_name2,"111110End111110Of111110File111110")!=0)
{
addr_len2 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd2,file_name2,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs2_addr2,&addr_len2))== -1)
{
perror("Error receiving in thread2");
exit(1);
}
pc2++;
if (strcmp(file_name2,"111110End111110Of111110File111110")!=0)
{
pcd2++;
fprintf(ofp2,"%s",file_name2);
/* printf("%s",file_name2); */
}

ack2++;
strcpy(myack,"ack");
if((numbytes = sendto(sockfd2,myack,strlen(myack),0,
(struct sockaddr *)&theirs2_addr2,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t2: Error sending ack from thread 2 ->");
exit(1);
}
pcs2++;
} /* end of while loop */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t2: Connection Termination : Three-Way Handshake for Thread %d",(long int)&thread2);
printf("\n rs: t2: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(5,2,0); /* state transition diagram */
/* state transition diagram */

addr_len2 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd2,file_name2,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs2_addr2,&addr_len2))== -1)
{
perror("rs: t2: Error receiving: SYN, SequenceNum = x in thread2");
exit(1);
}
pc2++;
printf("\n rs: t2: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(8,2,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd2,myack,strlen(myack),0,
(struct sockaddr *)&theirs2_addr2,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t2: Error sending SYN+ACK, SequenceNum = y from thread 2 ->");
exit(1);
}
pcs2++;
printf("\n rs: t2: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(34,2,0); /* state transition diagram */
/* state transition diagram */

addr_len2 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd2,file_name2,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs2_addr2,&addr_len2))== -1)
{
perror("Error receiving in thread2");
exit(1);
}
pc2++;
/* ------------- */
/* ------------- */
printf("\n rs t2: finish with client: %s",inet_ntoa(their2_addr2.sin_addr));
printf("\n rs t2: finish receiving in thread 2 \n");

rt1[xx]=(long int) &thread2;
rt3[xx]=LOCALPORT2;
rt5[xx]=LOCALPORT2;
xx++;
routing_table();

close(sockfd2);
close(ofp2);
runningf();
run2 = 0;
}

void thread_three(int *n)
{
int x3 = 0;
int ack3 = 0;

struct sockaddr_in my_addr3;
struct sockaddr_in their3_addr3;
struct sockaddr_in theirs3_addr3;
struct sockaddr_in t_addr3;

char my_file3[MAXRCVBUFFER] = "";
if (strcmp(gargvv,"1")==0)
strcpy(my_file3,"receive_client3_1");
if (strcmp(gargvv,"2")==0)
strcpy(my_file3,"receive_client3_2");
if (strcmp(gargvv,"3")==0)
strcpy(my_file3,"receive_client3_3");
if (strcmp(gargvv,"4")==0)
strcpy(my_file3,"receive_client3_4");
if (strcmp(gargvv,"5")==0)
strcpy(my_file3,"receive_client3_5");

ofp3 = fopen(my_file3,"w");

/* ------------- */
if ((sockfd3 = socket(AF_INET, SOCK_DGRAM,0)) == -1)
{
perror("Main Socket 3 Error...");
exit(1);
}

their3_addr3.sin_family = AF_INET;
their3_addr3.sin_addr.s_addr = inet_addr(LOCALIP);
their3_addr3.sin_port = htons(LOCALPORT3);
bzero(&(my_addr3.sin_zero),8);

theirs3_addr3.sin_family = AF_INET;
theirs3_addr3.sin_addr.s_addr = inet_addr(SERVERIP);
theirs3_addr3.sin_port = htons(LOCALPORT3);
/* bzero(&(my_addr3.sin_zero),8); */

if (bind(sockfd3,(struct sockaddr *)&their3_addr3,sizeof(struct sockaddr))==-1)
{
perror("Main 3 Binding Error...");
exit(1);
}

/* state transition diagram */
state_transition_diagram(1,3,0); /* state transition diagram */
/* state transition diagram */

/* ------------- */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t3: Connection Establishment: Three-Way Handshake for Thread %d",(long int)&thread3);
printf("\n rs: t3: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(2,3,0); /* state transition diagram */
/* state transition diagram */

addr_len3 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd3,file_name3,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs3_addr3,&addr_len3))== -1)
{
perror("rs: t3: Error receiving: SYN, SequenceNum = x in thread3");
exit(1);
}
pc3++;
printf("\n rs: t3: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(3,3,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd3,myack,strlen(myack),0,
(struct sockaddr *)&theirs3_addr3,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t3: Error sending SYN+ACK, SequenceNum = y from thread 3 ->");
exit(1);
}
pcs3++;
printf("\n rs: t3: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(4,3,0); /* state transition diagram */
/* state transition diagram */

addr_len3 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd3,file_name3,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs3_addr3,&addr_len3))== -1)
{
perror("Error receiving in thread3");
exit(1);
}
pc3++;
/* ------------- */
/* ------------- */

printf("\n Thread %ld has been activated\n",(long int)&thread3);

printf("\n rs t3: Buffer: %s",file_name3);
printf("\n rs t3: Port Used by %ld: ",(long int)&thread3);
printf("%d",LOCALPORT3);
printf("\n rs t3: Server IP Address: %s",inet_ntoa(their3_addr3.sin_addr));
printf("\n");

strcpy(file_name3,"");
while (strcmp(file_name3,"111110End111110Of111110File111110")!=0)
{
addr_len3 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd3,file_name3,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs3_addr3,&addr_len3))== -1)
{
perror("Error receiving in thread3");
exit(1);
}
pc3++;
if (strcmp(file_name3,"111110End111110Of111110File111110")!=0)
{
pcd3++;
fprintf(ofp3,"%s",file_name3);
/* printf("%s",file_name3); */
}

ack3++;
strcpy(myack,"ack");
if((numbytes = sendto(sockfd3,myack,strlen(myack),0,
(struct sockaddr *)&theirs3_addr3,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t3: Error sending ack from thread 3 ->");
exit(1);
}
pcs3++;
} /* end of while loop */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t3: Connection Termination : Three-Way Handshake for Thread %d",(long int)&thread3);
printf("\n rs: t3: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(5,3,0); /* state transition diagram */
/* state transition diagram */

addr_len3 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd3,file_name3,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs3_addr3,&addr_len3))== -1)
{
perror("rs: t3: Error receiving: SYN, SequenceNum = x in thread3");
exit(1);
}
pc3++;
printf("\n rs: t3: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(8,3,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd3,myack,strlen(myack),0,
(struct sockaddr *)&theirs3_addr3,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t3: Error sending SYN+ACK, SequenceNum = y from thread 3 ->");
exit(1);
}
pcs3++;
printf("\n rs: t3: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(34,3,0); /* state transition diagram */
/* state transition diagram */

addr_len3 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd3,file_name3,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs3_addr3,&addr_len3))== -1)
{
perror("Error receiving in thread3");
exit(1);
}
pc3++;
/* ------------- */
/* ------------- */
printf("\n rs t3: finish with client: %s",inet_ntoa(their3_addr3.sin_addr));
printf("\n rs t3: finish receiving in thread 3 \n");

rt1[xx]=(long int) &thread3;
rt3[xx]=LOCALPORT3;
rt5[xx]=LOCALPORT3;
xx++;
routing_table();

close(sockfd3);
close(ofp3);
runningf();
run3 = 0;
}

void thread_four(int *n)
{
int x4 = 0;
int ack4 = 0;

struct sockaddr_in my_addr4;
struct sockaddr_in their4_addr4;
struct sockaddr_in theirs4_addr4;
struct sockaddr_in t_addr4;

char my_file4[MAXRCVBUFFER] = "";
if (strcmp(gargvv,"1")==0)
strcpy(my_file4,"receive_client4_1");
if (strcmp(gargvv,"2")==0)
strcpy(my_file4,"receive_client4_2");
if (strcmp(gargvv,"3")==0)
strcpy(my_file4,"receive_client4_3");
if (strcmp(gargvv,"4")==0)
strcpy(my_file4,"receive_client4_4");
if (strcmp(gargvv,"5")==0)
strcpy(my_file4,"receive_client4_5");

ofp4 = fopen(my_file4,"w");

/* ------------- */
if ((sockfd4 = socket(AF_INET, SOCK_DGRAM,0)) == -1)
{
perror("Main Socket 4 Error...");
exit(1);
}

their4_addr4.sin_family = AF_INET;
their4_addr4.sin_addr.s_addr = inet_addr(LOCALIP);
their4_addr4.sin_port = htons(LOCALPORT4);
bzero(&(my_addr4.sin_zero),8);

theirs4_addr4.sin_family = AF_INET;
theirs4_addr4.sin_addr.s_addr = inet_addr(SERVERIP);
theirs4_addr4.sin_port = htons(LOCALPORT4);
/* bzero(&(my_addr4.sin_zero),8); */

if (bind(sockfd4,(struct sockaddr *)&their4_addr4,sizeof(struct sockaddr))==-1)
{
perror("Main 4 Binding Error...");
exit(1);
}

/* state transition diagram */
state_transition_diagram(1,4,0); /* state transition diagram */
/* state transition diagram */

/* ------------- */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t4: Connection Establishment: Three-Way Handshake for Thread %d",(long int)&thread4);
printf("\n rs: t4: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(2,4,0); /* state transition diagram */
/* state transition diagram */

addr_len4 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd4,file_name4,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs4_addr4,&addr_len4))== -1)
{
perror("rs: t4: Error receiving: SYN, SequenceNum = x in thread4");
exit(1);
}
pc4++;
printf("\n rs: t4: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(3,4,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd4,myack,strlen(myack),0,
(struct sockaddr *)&theirs4_addr4,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t4: Error sending SYN+ACK, SequenceNum = y from thread 4 ->");
exit(1);
}
pcs4++;
printf("\n rs: t4: Receiving : ACK, Acknowlegment = y + 1w");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(4,4,0); /* state transition diagram */
/* state transition diagram */

addr_len4 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd4,file_name4,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs4_addr4,&addr_len4))== -1)
{
perror("Error receiving in thread4");
exit(1);
}
pc4++;
/* ------------- */
/* ------------- */

printf("\n Thread %ld has been activated\n",(long int)&thread4);

printf("\n rs t4: Buffer: %s",file_name4);
printf("\n rs t4: Port Used by %ld: ",(long int)&thread4);
printf("%d",LOCALPORT4);
printf("\n rs t4: Server IP Address: %s",inet_ntoa(their4_addr4.sin_addr));
printf("\n");

strcpy(file_name4,"");
while (strcmp(file_name4,"111110End111110Of111110File111110")!=0)
{
addr_len4 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd4,file_name4,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs4_addr4,&addr_len4))== -1)
{
perror("Error receiving in thread4");
exit(1);
}
pc4++;
if (strcmp(file_name4,"111110End111110Of111110File111110")!=0)
{
pcd4++;
fprintf(ofp4,"%s",file_name4);
/* printf("%s",file_name4); */
}

ack4++;
strcpy(myack,"ack");
if((numbytes = sendto(sockfd4,myack,strlen(myack),0,
(struct sockaddr *)&theirs4_addr4,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t4: Error sending ack from thread 4 ->");
exit(1);
}
pcs4++;
} /* end of while loop */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t4: Connection Termination : Three-Way Handshake for Thread %d",(long int)&thread4);
printf("\n rs: t4: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(5,4,0); /* state transition diagram */
/* state transition diagram */

addr_len4 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd4,file_name4,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs4_addr4,&addr_len4))== -1)
{
perror("rs: t4: Error receiving: SYN, SequenceNum = x in thread4");
exit(1);
}
pc4++;
printf("\n rs: t4: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(8,4,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd4,myack,strlen(myack),0,
(struct sockaddr *)&theirs4_addr4,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t4: Error sending SYN+ACK, SequenceNum = y from thread 4 ->");
exit(1);
}
pcs4++;
printf("\n rs: t4: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(34,4,0); /* state transition diagram */
/* state transition diagram */

addr_len4 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd4,file_name4,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs4_addr4,&addr_len4))== -1)
{
perror("Error receiving in thread4");
exit(1);
}
pc4++;
/* ------------- */
/* ------------- */
printf("\n rs t4: finish with client: %s",inet_ntoa(their4_addr4.sin_addr));
printf("\n rs t4: finish receiving in thread 4 \n");

rt1[xx]=(long int) &thread4;
rt3[xx]=LOCALPORT4;
rt5[xx]=LOCALPORT4;
xx++;
routing_table();

close(sockfd4);
close(ofp4);
runningf();
run4 = 0;
}

void thread_five(int *n)
{
int x5 = 0;
int ack5 = 0;

struct sockaddr_in my_addr5;
struct sockaddr_in their5_addr5;
struct sockaddr_in theirs5_addr5;
struct sockaddr_in t_addr5;

char my_file5[MAXRCVBUFFER] = "";
if (strcmp(gargvv,"1")==0)
strcpy(my_file5,"receive_client5_1");
if (strcmp(gargvv,"2")==0)
strcpy(my_file5,"receive_client5_2");
if (strcmp(gargvv,"3")==0)
strcpy(my_file5,"receive_client5_3");
if (strcmp(gargvv,"4")==0)
strcpy(my_file5,"receive_client5_4");
if (strcmp(gargvv,"5")==0)
strcpy(my_file5,"receive_client5_5");

ofp5 = fopen(my_file5,"w");

/* ------------- */
if ((sockfd5 = socket(AF_INET, SOCK_DGRAM,0)) == -1)
{
perror("Main Socket 5 Error...");
exit(1);
}

their5_addr5.sin_family = AF_INET;
their5_addr5.sin_addr.s_addr = inet_addr(LOCALIP);
their5_addr5.sin_port = htons(LOCALPORT5);
bzero(&(my_addr5.sin_zero),8);

theirs5_addr5.sin_family = AF_INET;
theirs5_addr5.sin_addr.s_addr = inet_addr(SERVERIP);
theirs5_addr5.sin_port = htons(LOCALPORT5);
/* bzero(&(my_addr5.sin_zero),8); */

if (bind(sockfd5,(struct sockaddr *)&their5_addr5,sizeof(struct sockaddr))==-1)
{
perror("Main 5 Binding Error...");
exit(1);
}

/* state transition diagram */
state_transition_diagram(1,5,0); /* state transition diagram */
/* state transition diagram */

/* ------------- */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t5: Connection Establishment: Three-Way Handshake for Thread %d",(long int)&thread5);
printf("\n rs: t5: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(2,5,0); /* state transition diagram */
/* state transition diagram */

addr_len5 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd5,file_name5,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs5_addr5,&addr_len5))== -1)
{
perror("rs: t5: Error receiving: SYN, SequenceNum = x in thread5");
exit(1);
}
pc5++;
printf("\n rs: t5: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(3,5,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd5,myack,strlen(myack),0,
(struct sockaddr *)&theirs5_addr5,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t5: Error sending SYN+ACK, SequenceNum = y from thread 5 ->");
exit(1);
}
pcs5++;
printf("\n rs: t5: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(4,5,0); /* state transition diagram */
/* state transition diagram */

addr_len5 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd5,file_name5,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs5_addr5,&addr_len5))== -1)
{
perror("Error receiving in thread5");
exit(1);
}
pc5++;
/* ------------- */
/* ------------- */

printf("\n Thread %ld has been activated\n",(long int)&thread5);

printf("\n rs t5: Buffer: %s",file_name5);
printf("\n rs t5: Port Used by %ld: ",(long int)&thread5);
printf("%d",LOCALPORT5);
printf("\n rs t5: Server IP Address: %s",inet_ntoa(their5_addr5.sin_addr));
printf("\n");

strcpy(file_name5,"");
while (strcmp(file_name5,"111110End111110Of111110File111110")!=0)
{
addr_len5 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd5,file_name5,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs5_addr5,&addr_len5))== -1)
{
perror("Error receiving in thread5");
exit(1);
}
pc5++;
if (strcmp(file_name5,"111110End111110Of111110File111110")!=0)
{
pcd5++;
fprintf(ofp5,"%s",file_name5);
/* printf("%s",file_name5); */
}

ack5++;
strcpy(myack,"ack");
if((numbytes = sendto(sockfd5,myack,strlen(myack),0,
(struct sockaddr *)&theirs5_addr5,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t5: Error sending ack from thread 5 ->");
exit(1);
}
pcs5++;
} /* end of while loop */
/* ------------------- */
/* three way handshake
/* ------------------- */
printf("\n -------------------------------------------------------------------------");
printf("\n rs: t5: Connection Termination : Three-Way Handshake for Thread %d",(long int)&thread4);
printf("\n rs: t5: Receiving : SYN, SequenceNum = x");

/* state transition diagram */
state_transition_diagram(5,5,0); /* state transition diagram */
/* state transition diagram */

addr_len5 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd5,file_name5,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs5_addr5,&addr_len5))== -1)
{
perror("rs: t5: Error receiving: SYN, SequenceNum = x in thread5");
exit(1);
}
pc5++;
printf("\n rs: t5: Sending : SYN+ACK, SequenceNum = y");

/* state transition diagram */
state_transition_diagram(8,5,0); /* state transition diagram */
/* state transition diagram */

if((numbytes = sendto(sockfd5,myack,strlen(myack),0,
(struct sockaddr *)&theirs5_addr5,sizeof(struct sockaddr)))==-1)
{
perror("\n rs: t5: Error sending SYN+ACK, SequenceNum = y from thread 5 ->");
exit(1);
}
pcs5++;
printf("\n rs: t5: Receiving : ACK, Acknowlegment = y + 1");
printf("\n -------------------------------------------------------------------------");

/* state transition diagram */
state_transition_diagram(34,5,0); /* state transition diagram */
/* state transition diagram */

addr_len5 = sizeof(struct sockaddr);
if((numbytes = recvfrom(sockfd5,file_name5,MAXRCVBUFFER,0,
(struct sockaddr *)&theirs5_addr5,&addr_len5))== -1)
{
perror("Error receiving in thread5");
exit(1);
}
pc5++;
/* ------------- */
/* ------------- */
printf("\n rs t5: finish with client: %s",inet_ntoa(their5_addr5.sin_addr));
printf("\n rs t5: finish receiving in thread 5 \n");

rt1[xx]=(long int) &thread5;
rt3[xx]=LOCALPORT5;
rt5[xx]=LOCALPORT5;
xx++;
routing_table();

close(sockfd5);
close(ofp5);
runningf();
run5 = 0;
}

void displaypc()
{
tpc = pc1+pc2+pc3+pc4+pc5;
printf("\n ---------------------------------------------------------");
printf("\n Packets Counter -Received- (data and ack):");
printf("\n Thread1:%d Thread2:%d Thread3 :%d",pc1,pc2,pc3);
printf("\n Thread4:%d Thread5:%d Total Count:%d",pc4,pc5,tpc);

tpcd = pcd1+pcd2+pcd3+pcd4+pcd5;
printf("\n ");
printf("\n Packets Counter -Received- (data only):");
printf("\n Thread1:%d Thread2:%d Thread3 :%d",pcd1,pcd2,pcd3);
printf("\n Thread4:%d Thread5:%d Total Count:%d",pcd4,pcd5,tpcd);
printf("\n ---------------------------------------------------------\n");
}

void displayspc()
{
tpcs = pcs1+pcs2+pcs3+pcs4+pcs5;
printf("\n ---------------------------------------------------------");
printf("\n Packets Counter -Sent- (data and ack):");
printf("\n Thread1:%d Thread2:%d Thread3 :%d",pcs1,pcs2,pcs3);
printf("\n Thread4:%d Thread5:%d Total Count:%d",pcs4,pcs5,tpcs);

tpcds = pcds1+pcds2+pcds3+pcds4+pcds5;
printf("\n ");
printf("\n Packets Counter -Sent- (data only):");
printf("\n Thread1:%d Thread2:%d Thread3 :%d",pcds1,pcds2,pcds3);
printf("\n Thread4:%d Thread5:%d Total Count:%d",pcds4,pcds5,tpcds);
printf("\n ---------------------------------------------------------\n");
}

void displaypl()
{
printf("\n ---------------------------------------------------------");
printf("\n Packets Loss By Thread -Sent- (data and ack):");
printf("\n Thread1:%d Thread2:%d Thread3 :%d",pc1-pcs1,pcs2-pcd2,pc3-pcs3);
printf("\n Thread4:%d Thread5:%d",pcs4-pcd4,pcs5-pcd5);
printf("\n ---------------------------------------------------------");
}

void state_transition_diagram(int x, int y, int z)
{
int x1 = x;
int y1 = y;
int z1 = z;
char my_message[MAXRCVBUFFER]="";
char my_section[MAXRCVBUFFER]="";

if (x1 == 1)
strcpy(my_message,"CLOSED");
if (x1 == 2)
strcpy(my_message,"LISTEN");
if (x1 == 3)
strcpy(my_message,"SYN_RCVD");
if (x1 == 4)
strcpy(my_message,"ESTABLISHED");
if (x1 == 5)
strcpy(my_message,"FIN_WAIT_1");
if (x1 == 6)
strcpy(my_message,"FIN_WAIT_2");
if (x1 == 7)
strcpy(my_message,"CLOSING");
if (x1 == 8)
strcpy(my_message,"TIME_WAIT");
if (x1 == 31)
strcpy(my_message,"SYN_SENT");
if (x1 == 32)
strcpy(my_message,"CLOSE_WAIT");
if (x1 == 33)
strcpy(my_message,"LAST_ACK");
if (x1 == 34)
strcpy(my_message,"CLOSED");

if (y1 == 0)
strcpy(my_section,"PROJECT 2, MAIN SECTION");
if (y1 == 1)
strcpy(my_section,"PROJECT 2, THREAD 1");
if (y1 == 2)
strcpy(my_section,"PROJECT 2, THREAD 2");
if (y1 == 3)
strcpy(my_section,"PROJECT 2, THREAD 3");
if (y1 == 4)
strcpy(my_section,"PROJECT 2, THREAD 4");
if (y1 == 5)
strcpy(my_section,"PROJECT 2, THREAD 5");

printf("\n______________________________________________________________");
printf("\nrs: Entering the Following State of State Transition Diagram:");
printf("\nrs: -> %s <-",my_message);
printf(" in %s",my_section);
printf("\n______________________________________________________________\n");
}

void routing_table()
{
int x = 0;

printf("\n -------------------------------------------------------------------------");
printf("\n Routing Table:");
printf("\n THREAD HOST-FROM PORT-FROM HOST-TO PORT-TO COST");

for (x=0; x<50; x++)
{
if (rt1[x]>0)
{
printf("\n %d %s %d %s %d %d",rt1[x],LOCALIP,rt3[x],SERVERIP,rt5[x],1);
}
}
for (x=0; x<50; x++)
{
if (rt1[x]>0)
{
printf("\n %d %s %d %s %d %d",rt1[x],SERVERIP,rt3[x],SERVERIP,rt5[x],0);
}
}
printf("\n -------------------------------------------------------------------------");
}
void runningf()
{
int x = 0;
x = run1 + run2 + run3 + run4 + run5;
printf("\n ++++++++++++++++++++++++++++++++++++++++++");
printf("\n rs: Threads Actually Running: %d",x);
printf("\n rs: %d %d %d %d %d",run1,run2,run3,run4,run5);
printf("\n ++++++++++++++++++++++++++++++++++++++++++\n");
}

void conversion(int n)
{
strcpy(currentack,"");
if ((n>=0)&&(n<=9))
itoc(n,0);
if ((n>=10)&&(n<=99))
assignment2(n);
if ((n>=100)&&(n<=999))
assignment3(n);
if ((n>=1000)&&(n<=9999))
assignment4(n);
if ((n>=10000)&&(n<=99999))
assignment5(n);
if ((n>=100000)&&(n<=999999))
assignment6(n);
if ((n>=1000000)&&(n<=9999999))
assignment7(n);
if ((n>=10000000)&&(n<=99999999))
assignment8(n);
if ((n>=100000000)&&(n<=999999999))
assignment9(n);
if ((n>=1000000000)&&(n<=9999999999))
assignment10(n);
}

void assignment2(int nn)
{
int digit0, digit1;
digit0 = nn/10;
digit1 = nn % 10;
itoc(digit0,0);
itoc(digit1,1);
}

void assignment3(int nn)
{
int digit0, digit1, digit2;
digit0 = nn/100;
digit1 = (nn%100) / 10;
digit2 = (nn%100) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
}

void assignment4(int nn)
{
int digit0, digit1, digit2, digit3;
digit0 = nn/1000;
digit1 = (nn%1000) / 100;
digit2 = ((nn%1000) % 100) / 10;
digit3 = ((nn%1000) % 100) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
itoc(digit3,3);
}

void assignment5(int nn)
{
int digit0, digit1, digit2, digit3, digit4;
digit0 = nn/10000;
digit1 = (nn%10000) / 1000;
digit2 = ((nn%10000) % 1000) / 100;
digit3 = (((nn%10000) % 1000) % 100 ) / 10;
digit4 = (((nn%10000) % 1000) % 100 ) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
itoc(digit3,3);
itoc(digit4,4);
}

void assignment6(int nn)
{
int digit0, digit1, digit2, digit3, digit4, digit5;
digit0 = nn/100000;
digit1 = (nn%100000) / 10000;
digit2 = ((nn%100000) % 10000) / 1000;
digit3 = (((nn%100000) % 10000) % 1000) / 100;
digit4 = ((((nn%100000) % 10000) % 1000) % 100) / 10;
digit5 = ((((nn%100000) % 10000) % 1000) % 100) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
itoc(digit3,3);
itoc(digit4,4);
itoc(digit5,5);
}

void assignment7(int nn)
{
int digit0, digit1, digit2, digit3, digit4, digit5, digit6;
digit0 = nn/1000000;
digit1 = (nn%1000000) / 100000;
digit2 = ((nn%1000000) % 100000) / 10000;
digit3 = (((nn%1000000) % 100000) % 10000) / 1000;
digit4 = ((((nn%1000000) % 100000) % 10000) % 1000) / 100;
digit5 = (((((nn%1000000) % 100000) % 10000) % 1000) % 100) / 10;
digit6 = (((((nn%1000000) % 100000) % 10000) % 1000) % 100) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
itoc(digit3,3);
itoc(digit4,4);
itoc(digit5,5);
itoc(digit6,6);
}

void assignment8(int nn)
{
int digit0, digit1, digit2, digit3, digit4, digit5, digit6, digit7;
digit0 = nn/10000000;
digit1 = (nn%10000000) / 1000000;
digit2 = ((nn%10000000) % 1000000) / 100000;
digit3 = (((nn%10000000) % 1000000) % 100000) / 10000;
digit4 = ((((nn%10000000) % 1000000) % 100000) % 10000) / 1000;
digit5 = (((((nn%10000000) % 1000000) % 100000) % 10000) % 1000) / 100;
digit6 = ((((((nn%10000000) % 1000000) % 100000) % 10000) % 1000) % 100) / 10;
digit7 = ((((((nn%10000000) % 1000000) % 100000) % 10000) % 1000) % 100) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
itoc(digit3,3);
itoc(digit4,4);
itoc(digit5,5);
itoc(digit6,6);
itoc(digit7,7);
}

void assignment9(int nn)
{
int digit0, digit1, digit2, digit3, digit4, digit5, digit6, digit7, digit8;
digit0 = nn/100000000;
digit1 = (nn%100000000) / 10000000;
digit2 = ((nn%100000000) % 10000000) / 1000000;
digit3 = (((nn%100000000) % 10000000) % 1000000) / 100000;
digit4 = ((((nn%100000000) % 10000000) % 1000000) % 100000) / 10000;
digit5 = (((((nn%100000000) % 10000000) % 1000000) % 100000) % 10000) / 1000;
digit6 = ((((((nn%100000000) % 10000000) % 1000000) % 100000) % 10000) % 1000) / 100;
digit7 = (((((((nn%100000000) % 10000000) % 1000000) % 100000) % 10000) % 1000) % 100) / 10;
digit8 = (((((((nn%100000000) % 10000000) % 1000000) % 100000) % 10000) % 1000) % 100) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
itoc(digit3,3);
itoc(digit4,4);
itoc(digit5,5);
itoc(digit6,6);
itoc(digit7,7);
itoc(digit8,8);
}

void assignment10(int nn)
{
int digit0, digit1, digit2, digit3, digit4, digit5, digit6, digit7, digit8, digit9;
digit0 = nn/1000000000;
digit1 = (nn%1000000000) / 100000000;
digit2 = ((nn%1000000000) % 100000000) / 10000000;
digit3 = (((nn%1000000000) % 100000000) % 10000000) / 1000000;
digit4 = ((((nn%1000000000) % 100000000) % 10000000) % 1000000) / 100000;
digit5 = (((((nn%1000000000) % 100000000) % 10000000) % 1000000) % 100000) / 10000;
digit6 = ((((((nn%1000000000) % 100000000) % 10000000) % 1000000) % 100000) % 10000) / 1000;
digit7 = (((((((nn%1000000000) % 100000000) % 10000000) % 1000000) % 100000) % 10000) % 1000) / 100;
digit8 = ((((((((nn%1000000000) % 100000000) % 10000000) % 1000000) % 100000) % 10000) % 1000) % 100) / 10;
digit9 = ((((((((nn%1000000000) % 100000000) % 10000000) % 1000000) % 100000) % 10000) % 1000) % 100) % 10;
itoc(digit0,0);
itoc(digit1,1);
itoc(digit2,2);
itoc(digit3,3);
itoc(digit4,4);
itoc(digit5,5);
itoc(digit6,6);
itoc(digit7,7);
itoc(digit8,8);
itoc(digit9,9);
}

void itoc(int nn, int k)
{
switch (nn)
{
case 0: currentack[k]='0'; break;
case 1: currentack[k]='1'; break;
case 2: currentack[k]='2'; break;
case 3: currentack[k]='3'; break;
case 4: currentack[k]='4'; break;
case 5: currentack[k]='5'; break;
case 6: currentack[k]='6'; break;
case 7: currentack[k]='7'; break;
case 8: currentack[k]='8'; break;
case 9: currentack[k]='9'; break;
}
}

int myconversion()
{
int i, ii, j = 0;
for (j=0; j<strlen(initial); j++)
{
if ((initial[j])=='0')
i = 0;
if ((initial[j])=='1')
i = 1;
if ((initial[j])=='2')
i = 2;
if ((initial[j])=='3')
i = 3;
if ((initial[j])=='4')
i = 4;
if ((initial[j])=='5')
i = 5;
if ((initial[j])=='6')
i = 6;
if ((initial[j])=='7')
i = 7;
if ((initial[j])=='8')
i = 8;
if ((initial[j])=='9')
i = 9;
if (j==0)
ii = i;
if (j!=0)
ii = (ii*10) + i;
}
return ii;
}

www.cpccci.com
www.cpcwebsolutions.com
www.cpcwebdevelopment.com