/*Initial state of receiver side*/
void B_Initial_State(struct pkt packet)
{
struct msg message;
createMessageforLayer5(&packet,&message);
bool corrupt = isPacketCorrupt(packet.checksum,packet.seqnum,packet.acknum,message.data);
int seqnum = packet.seqnum;
struct pkt datapacket; //creating packet containing acknowledgment
int checksum=0;
if(!corrupt && seqnum==expectedSeqNum)
{
int ack=expectedSeqNum; //send ack for received packet
createDataPacket(&datapacket,0,ack,checksum,"");
createCheckSum(&datapacket); //set checksum
datapacket.acknum = expectedSeqNum; //re assigning value for correctness
tolayer3(B,datapacket);
tolayer5(B,message.data);
int i;
for(i=0;i<20;i++)
{
printf("%c",message.data[i]);
}
printf("\n");
//printf("\nB SIDE : Printing Packet payload Sent Above %s\n",message.data);
//printf("\nB SIDE : Printing Acknum %d sent from B to A \n",datapacket.acknum);
//incrementing the expected sequence number
expectedSeqNum++;
}
else //send previous acknowledgment
{
int ack =expectedSeqNum-1;
createDataPacket(&datapacket,0,ack,checksum,"");
createCheckSum(&datapacket); //set checksum
datapacket.acknum = expectedSeqNum-1; //reassign for correctness
tolayer3(B,datapacket);
}
}
/*Initial state of receiver side*/
void B_Initial_State(struct pkt packet) {
struct msg message;
createMessageforLayer5(&packet, &message);
bool corrupt = isPacketCorrupt(packet.checksum, packet.seqnum,
packet.acknum, message.data);
int seqnum = packet.seqnum;
struct pkt datapacket; //creating packet containing acknowledgment
int checksum = 0;
if (!corrupt) {
//send ack for all packets lying under below range
if (seqnum >= (receiverBase - receiverWindowSize)
&& seqnum <= (receiverBase + receiverWindowSize - 1)) {
int ack = seqnum; //send ack for received packet
createDataPacket(&datapacket, 0, ack, checksum, "");
createCheckSum(&datapacket); //set checksum
datapacket.acknum = seqnum; //re assigning value for correctness
tolayer3(B, datapacket); //this is done irrespective of any action
//printf("\nB SIDE : Printing Acknum %d sent from B to A \n",
// datapacket.acknum);
B_StoreMessageInReceiverBuffer(seqnum, &message); //marks AckSent as true
}
//for values lying under current window
if (seqnum >= receiverBase
&& seqnum <= (receiverBase + receiverWindowSize - 1)) {
/* Handling data sent to layer5*/
int returnVal = returnNextMaximumContiguousSequenceAcknowledged(B);
if (returnVal != -1) {
sendMessagestoLayer5(returnVal);
}
}
} //Un_corrupt packet Loop Ends
}
/*Initial State of Sender Side*/
void A_StorePacketInBuffer(char *message) {
struct pkt datapacket;
int checksum = 0;
createDataPacket(&datapacket, senderPacketCounter, 0, checksum, message);
createCheckSum(&datapacket); //modify checksum
datapacket.seqnum = senderPacketCounter;
//store packet in common senderBuffer for re-sending/sending
memcpy(&senderBuffer[senderPacketCounter], &datapacket, sizeof(datapacket));
/*printf(
"\nPrinting value is senderBuffer, SeqNum : %d\t checksum : %d\t and payload : %s\n",
senderBuffer[senderPacketCounter].seqnum,
senderBuffer[senderPacketCounter].checksum,
senderBuffer[senderPacketCounter].payload);*/
//increment sender packet counter
senderPacketCounter++;
}
int main(int argc, char *argv[])
{
msg r;
int task_index;
int fld; //file descriptor
task_index = atoi(argv[1]);
printf("[RECEIVER] Receiver starts.\n");
printf("[RECEIVER] Task index=%d\n", task_index);
init(HOST, PORT2);
/* Deschid fisierul de iesire */
//fld = open ("recv_fileX", O_WRONLY | O_TRUNC | O_CREAT, 0666);
/**********************************************
* TASK 0 *
**********************************************/
if (task_index == 0){
int no_frames;
char *filename;
/* Mai intai primesc un mesaj gol, in care mi se spune cate cadre se trimit */
if (recv_message(&r) < 0) {
perror("[RECEIVER] receive message");
return -1;
}
printf("[RECEIVER] Got msg with Init\n");
memcpy (&no_frames, r.payload, r.len);
send_message(&r);
/* Primesc numele fisierului, apoi il deschid */
if (recv_message(&r) < 0) {
perror("[RECEIVER] receive message");
return -1;
}
filename = (char *) malloc (r.len + 6);
strcpy (filename, "recv_");
memcpy (filename + 5, r.payload, r.len);
printf("[RECEIVER] Got msg with filename=%s\n", filename);
send_message (&r);
/* Deschid fisierul */
fld = open (filename, O_WRONLY | O_TRUNC | O_CREAT, 0666);
/* Acum urmeaza sa primesc no_frames cadre */
int i;
for (i = 0; i < no_frames; i++){
if (recv_message(&r) < 0) {
perror("[RECEIVER] receive message");
return -1;
}
//t.payload [t.len] = '\0';
printf("[RECEIVER] Got msg #%d.\n", i);
send_message (&r);
/* scriu in fisier continutul mesajului */
write (fld, r.payload, r.len);
}
}
/*************************************************
* END TASK 0 *
*************************************************/
/*************************************************
* TASK 1 *
*************************************************/
int crt = 0;
if (task_index == 1){
int expected_frame = 0, crt_frame;
int msg_size = MSGSIZE - sizeof (int);
int no_frames_to_recv;
char *filename;
if (recv_message (&r) < 0) {
perror("[RECEIVER] receive message");
return -1;
}
memcpy (&crt_frame, r.payload + msg_size, 4);
if (crt_frame == -1){
no_frames_to_recv = r.len;
printf ("[R]Got Init message with MAX=%d\n", no_frames_to_recv);
send_message (&r);
}else{
printf ("[R]Error: Something went worng!\n");
}
if (recv_message(&r) < 0) {
perror("[RECEIVER] receive message");
return -1;
}
memcpy (&crt_frame, r.payload+msg_size, 4);
/* Citesc numele fisierului de output, si apoi deschid fisierul */
filename = (char *) malloc (r.len + 6);
strcpy (filename, "recv_");
if (crt_frame == -2){
strncpy (filename + 5, r.payload, r.len);
printf ("[R]Got Init message with filename=%s\n", filename);
send_message (&r);
}else{
printf ("[S] need frame = -2\n");
}
fld = open (filename, O_WRONLY | O_TRUNC | O_CREAT, 0666);
while (1){
recv_message (&r);
memcpy (&crt_frame, r.payload+msg_size, 4);
if (crt_frame == no_frames_to_recv && expected_frame == no_frames_to_recv){
printf ("[R]Gata\n");
send_message (&r);
break;
}else{
if (crt_frame == expected_frame){
printf ("[R]recv %d\n", crt_frame);
write (fld, r.payload, r.len);
expected_frame ++;
send_message (&r);
}
}
}
}
/*************************************************
* END TASK 1 *
*************************************************/
/*************************************************
* TASK 2 *
*************************************************/
if (task_index == 2){
int expected_frame, crt_frame;
int msg_size = MSGSIZE - sizeof (int);
int no_frames_to_recv;
int DIM;
recv_message (&r);
memcpy (&crt_frame, r.payload+msg_size, 4);
if (crt_frame == -1){
no_frames_to_recv = r.len;
printf ("[R]Got Init message with MAX=%d\n", no_frames_to_recv);
send_message (&r);
}
recv_message(&r);
memcpy (&crt_frame, r.payload+msg_size, 4);
if (crt_frame == -2){
DIM = r.len;
printf ("[R]Got Init message with DIM=%d\n", DIM);
send_message (&r);
}
char *filename;
recv_message(&r);
filename = (char *) malloc (r.len + 6);
strcpy (filename, "recv_");
strncpy (filename+5, r.payload, r.len);
fld = open (filename, O_WRONLY | O_TRUNC | O_CREAT, 0666);
memcpy (&crt_frame, r.payload+msg_size, 4);
if (crt_frame == -3){
printf ("[R]Got Init message with filename=%s\n", filename);
send_message (&r);
}
msg buffered_msg[DIM];
int flag[DIM];
//int no_buffered;
int i;
/* Initializez flag[i] cu -1 */
for (i = 0; i < DIM; i++){
flag[i] = -1;
}
expected_frame = 0;
int stop;
int crt;
crt = 0;
no_frames_to_recv --;
while (1){
recv_message (&r);
memcpy (&crt_frame, r.payload+msg_size, 4);
if (crt_frame == no_frames_to_recv && expected_frame == no_frames_to_recv){
printf ("[R]Got last frame %d.END0\n", crt_frame);
send_message (&r);
write (fld, r.payload, r.len);
crt++;
break;
}else{
if (crt_frame == expected_frame){
printf ("[R]recv %d\n", crt_frame);
write (fld, r.payload, r.len);
crt++;
if (crt_frame == no_frames_to_recv){
printf("[R]Got last frame=%d. END1\n", expected_frame);
break;
}
flag[crt_frame % DIM] = -1;
send_message (&r);
expected_frame ++;
/* cat timp am in buffer, in continuarea lui expected,
* cadre ce au flagul 1, le scriu si pe ele in fisier
* si cresc expected_frame;
*/
stop = 0;
for (i = expected_frame % DIM; i < DIM; i++){
if (flag[i] == 1){
r = buffered_msg [i];
write (fld, r.payload, r.len);
crt++;
expected_frame ++;
flag[i] = -1;
}else{
stop = 1;
break;
}
}
//circularitate
if (stop == 0){
for (i = 0; i < crt_frame % DIM; i++){
if (flag[i] == 1){
r = buffered_msg [i];
write (fld, r.payload, r.len);
crt++;
expected_frame ++;
flag[i] = -1;
}else{
stop = 1;
break;
}
}
}
if (expected_frame > no_frames_to_recv){
printf ("[R]END!\n");
break;
}
}else{
/* daca primesc alt cadru decat cel asteptat, il retin in
* buffer si il marchez ca primit;
*/
if ((crt_frame <= expected_frame + DIM - 1) && (crt_frame <= no_frames_to_recv)){
printf ("[R]Recieved %d\n", crt_frame);
buffered_msg [crt_frame % DIM] = r;
flag [crt_frame % DIM] = 1;
send_message (&r);
}
}
}
}
}
/*************************************************
* END TASK 2 *
*************************************************/
/*************************************************
* TASK 3 *
*************************************************/
if (task_index == 3){
int expected_frame, crt_frame;
int msg_size = MSGSIZE - sizeof (int) - 1;//dimensiunea mesajului efectiv (a datelor citite din fisier)
int no_frames_to_recv;
int DIM;
char recvCheckSum;//suma de control trimisa de la sender
char actualCheckSum;//suma de control calculata de reciever
//NOTA: daca cele 2 sume de control difera, atunci cadrul este corup => discard!
int checkPos = MSGSIZE - 1;//pozitia sumei de control in cadrul t.payload
char *filename;
/* Testez suma de control a cadrului primit. In cazul in care nu trece
* testul, inseamna ca e corupt, asa ca nu fac nimic cu el. Deoarece
* nu-i trimit confirmare senderului, acesta va intra in timeout, si va
* trimite alt pachet.
*/
/* Primesc cadrul cu no_frames_to_recv */
recvCheckSum = '1';
actualCheckSum = '0';
while (recvCheckSum != actualCheckSum){
recv_message (&r);
memcpy (&crt_frame, r.payload+msg_size, 4);
memcpy (&recvCheckSum, r.payload + checkPos, 1);
actualCheckSum = createCheckSum (r);
}
if (crt_frame == -1){
//no_frames_to_recv = r.len;
memcpy (&no_frames_to_recv, r.payload, r.len);
printf ("[R]Got Init message with MAX=%d\n", no_frames_to_recv);
send_message (&r);
}else{
printf ("[R] Error Init msg -1\n");
}
/* Primesc cadrul cu no_frames_to_recv */
recvCheckSum = '1';
actualCheckSum = '0';
while (recvCheckSum != actualCheckSum){
recv_message (&r);
memcpy (&crt_frame, r.payload+msg_size, sizeof(int));
memcpy (&recvCheckSum, r.payload + checkPos, sizeof (char));
actualCheckSum = createCheckSum (r);
}
if (crt_frame == -2){
memcpy (&DIM, r.payload, r.len);
printf ("[R]Got Init message with DIM=%d\n", DIM);
send_message (&r);
}else{
printf ("[R] Error Init msg -2\n");
}
/* Primesc cadrul cu numele fisierului */
recvCheckSum = '1';
actualCheckSum = '0';
while (recvCheckSum != actualCheckSum){
recv_message (&r);
memcpy (&crt_frame, r.payload+msg_size, sizeof(int));
memcpy (&recvCheckSum, r.payload + checkPos, sizeof (char));
actualCheckSum = createCheckSum (r);
}
recv_message(&r);
filename = (char *) malloc (r.len + 6);
strcpy (filename, "recv_");
if (crt_frame == -3){
memcpy (filename + 5, r.payload, r.len);
printf ("[R]Got Init message with filename=%s\n", filename);
send_message (&r);
}else{
printf ("[R] Error Init msg -2\n");
}
/* Deschid fisierul de output */
fld = open (filename, O_WRONLY | O_TRUNC | O_CREAT, 0666);
msg buffered_msg[DIM];
int flag[DIM];
//int no_buffered;
int i;
/* Initializez flag[i] cu -1 */
for (i = 0; i < DIM; i++){
flag[i] = -1;
}
expected_frame = 0;
int stop;
int crt;
crt = 0;
no_frames_to_recv --;
while (1){
// recv_message (&r);
//memcpy (&crt_frame, r.payload+msg_size, 4);
recvCheckSum = '1';
actualCheckSum = '0';
while (recvCheckSum != actualCheckSum){
recv_message (&r);
memcpy (&crt_frame, r.payload+msg_size, sizeof(int));
memcpy (&recvCheckSum, r.payload + checkPos, sizeof (char));
actualCheckSum = createCheckSum (r);
}
if (crt_frame == no_frames_to_recv && expected_frame == no_frames_to_recv){
printf ("[R]Got last frame %d.END0\n", crt_frame);
send_message (&r);
write (fld, r.payload, r.len);
break;
}else{
if (crt_frame == expected_frame){
printf ("[R]recv %d\n", crt_frame);
write (fld, r.payload, r.len);
if (crt_frame == no_frames_to_recv){
printf("[R]Got last frame=%d. END1\n", expected_frame);
break;
}
flag[crt_frame % DIM] = -1;
send_message (&r);
expected_frame ++;
stop = 0;
for (i = expected_frame % DIM; i < DIM; i++){
if (flag[i] == 1){
r = buffered_msg [i];
write (fld, r.payload, r.len);
expected_frame ++;
flag[i] = -1;
}else{
stop = 1;
break;
}
}
//circularitate
if (stop == 0){
for (i = 0; i < crt_frame % DIM; i++){
if (flag[i] == 1){
r = buffered_msg [i];
write (fld, r.payload, r.len);
crt++;
expected_frame ++;
flag[i] = -1;
}else{
stop = 1;
break;
}
}
}
if (expected_frame > no_frames_to_recv){
printf ("[R]END\n");
break;
}
}else{
/* daca primesc alt cadru decat cel asteptat, il retin in
* buffer si il marchez ca primit;
*/
if ((crt_frame <= expected_frame + DIM - 1) && (crt_frame <= no_frames_to_recv)){
printf ("[R]Recieved %d\n", crt_frame);
buffered_msg [crt_frame % DIM] = r;
flag [crt_frame % DIM] = 1;
send_message (&r);
}
}
}
}
}
/*************************************************
* TASK 4 *
*************************************************/
if (task_index == 4){
int expected_frame, crt_frame;
//int msg_size = MSGSIZE - sizeof (int) - 11;//dimensiunea mesajului efectiv (a datelor citite din fisier)
int no_frames_to_recv;
int DIM;
msg correctMsg;
char *filename;
recv_message (&r);
correctMsg = correctHam (r);
r = getCodeFromHam (correctMsg);
r.len -= 4;
filename = (char *) malloc (r.len + 6);
strcpy (filename, "recv_");
strncpy (filename + 5, r.payload, r.len);
memcpy (&crt_frame, r.payload + r.len, sizeof (int));
if (crt_frame == -1){
printf ("[R]Got Init message with filename=%s\n", filename);
send_message (&r);
}
fld = open (filename, O_WRONLY | O_TRUNC | O_CREAT, 0666);
recv_message (&r);
correctMsg = correctHam (r);
r = getCodeFromHam (correctMsg);
r.len -= 4;
memcpy (&DIM, r.payload, r.len);
memcpy (&crt_frame, r.payload + r.len, sizeof (int));
if (crt_frame == -2){
printf ("[R]Got Init message with DIM=%d\n", DIM);
send_message (&r);
}
recv_message (&r);
correctMsg = correctHam (r);
r = getCodeFromHam (correctMsg);
r.len -= 4;
memcpy (&no_frames_to_recv, r.payload, r.len);
memcpy (&crt_frame, r.payload + r.len, sizeof (int));
if (crt_frame == -3){
printf ("[R]Got Init message with no_frames_to_recv=%d\n", no_frames_to_recv);
send_message (&r);
}
msg buffered_msg[DIM];
int flag[DIM];
int i;
/* Initializez flag[i] cu -1 */
for (i = 0; i < DIM; i++){
flag[i] = -1;
}
expected_frame = 0;
int stop;
int crt;
crt = 0;
no_frames_to_recv --;
while (1){
recv_message (&r);
correctMsg = correctHam (r);
r = getCodeFromHam (correctMsg);
r.len -= 4;
memcpy (&crt_frame, r.payload + r.len, sizeof(int));
if (crt_frame == no_frames_to_recv && expected_frame == no_frames_to_recv){
printf ("[R]Got last frame %d.END0\n", crt_frame);
send_message (&r);
write (fld, r.payload, r.len);
break;
}else{
if (crt_frame == expected_frame){
printf ("[R]recv %d\n", crt_frame);
write (fld, r.payload, r.len);
if (crt_frame == no_frames_to_recv){
printf("[R]Got last frame=%d. END1\n", expected_frame);
break;
}
flag[crt_frame % DIM] = -1;
send_message (&r);
expected_frame ++;
stop = 0;
for (i = expected_frame % DIM; i < DIM; i++){
if (flag[i] == 1){
r = buffered_msg [i];
write (fld, r.payload, r.len);
expected_frame ++;
flag[i] = -1;
}else{
stop = 1;
break;
}
}
//circularitate
if (stop == 0){
for (i = 0; i < crt_frame % DIM; i++){
if (flag[i] == 1){
r = buffered_msg [i];
write (fld, r.payload, r.len);
expected_frame ++;
flag[i] = -1;
}else{
stop = 1;
break;
}
}
}
if (expected_frame > no_frames_to_recv){
printf ("[R]END\n");
break;
}
}else{
/* daca primesc alt cadru decat cel asteptat, il retin in
* buffer si il marchez ca primit;
*/
if ((crt_frame <= expected_frame + DIM - 1) && (crt_frame <= no_frames_to_recv)){
printf ("[R]Recieved %d\n", crt_frame);
buffered_msg [crt_frame % DIM] = r;
flag [crt_frame % DIM] = 1;
send_message (&r);
}
}
}
}
printf ("[R] GOT CRT=%d messages!\n", crt);
}
close (fld);
printf("[RECEIVER] All done.\n");
return 0;
}
