void
rel_recvpkt (rel_t *r, packet_t *pkt, size_t n)
{
//fprintf(stderr, "\n******************receive!********************\n");
if (!check_valid(pkt, n)) return;
//fprintf(stderr, "\n******************pass check!********************\n");
int i = 0;
if (ntohs(pkt->len) == 8) {
// sender side
// receive ack
//fprintf(stderr, "\n******************Receive Ack ack:%d, LAR:%d!********************\n", ntohl(pkt->ackno), r->LAR);
if (ntohl(pkt->ackno) > r->LAR) {
for (i=r->LAR; i<ntohl(pkt->ackno); i++) {
r->sendState[i% r->window_size] = 1; // got ack
}
r->LAR = ntohl(pkt->ackno) - 1;
if (r->SEND_EOF) {
// receive ack of eof
r->EOF_ACKED = true;
}
rel_read(r);
}
} else if (ntohs(pkt->len) >= 12) {
// receiver side
if (recv_check(r, pkt)) {
if (ntohl(pkt->seqno) == r->LSR+1) {
// right seqno, output buffer and change LSR, LAS and recvState
if (ntohs(pkt->len) == 12) {
// receive EOF
r->RECV_EOF = true;
}
addPktToRWindow(r, pkt); // add to buffer first
rel_output(r);
} else if (ntohl(pkt->seqno) <= r->LSR) {
// old seqno, send current ack
send_ack(r);
} else {
addPktToRWindow(r, pkt); // add to buffer
}
} else {
send_ack(r);
}
}
}
void
rel_recvpkt (rel_t *r, packet_t *pkt, size_t n)
{
// printf("rel_recvpkt\n");
uint16_t len = ntohs(pkt->len);
uint32_t ackno = ntohl(pkt->ackno);
int verified = verifyChecksum(r, pkt, n);
if (!verified || (len != n)) { // Drop packets with bad length
// fprintf(stderr, "Packet w/ sequence number %d dropped\n", ntohl(pkt->seqno));
return;
}
if (len == ACK_PACKET_SIZE) { // Received packet is an ack packet
// fprintf(stderr, "Received ack number: %d\n", ackno);
// fprintf(stderr, "%s\n", "======================RECEIVED ACK PACKET=========================");
if (ackno <= r->LAST_PACKET_ACKED + 1) { // Drop duplicate acks
// fprintf(stderr, "Duplicate ack: %d received\n", ackno);
return;
}
if (ackno == r->LAST_ACK_RECVD) {
r->LAST_ACK_COUNT++;
}
else {
r->LAST_ACK_RECVD = ackno;
r->LAST_ACK_COUNT = 1;
}
if (r->slowStart) {
// fprintf(stderr, "window size: %d\n", r->windowSize);
if (r->windowSize * 2 > r->ssThresh) {
// START AIMD
// return;
} else {
r->windowSize = r->windowSize * 2;
}
// fprintf(stderr, "success? %d\n", r->windowSize);
}
else {
if (r->windowSize + 1 == r->ssThresh) {
} else {
r->windowSize = r->windowSize + 1;
}
}
shiftSentPacketList(r, ackno);
r->LAST_PACKET_ACKED = ackno - 1;
rel_read(r);
}
else { // data packet
// fprintf(stderr, "%s\n", "======================RECEIVED DATA PACKET=========================");
uint32_t seqno = ntohl(pkt->seqno);
// fprintf(stderr, "Received Data: %s\n", pkt->data);
// fprintf(stderr, "Received data: %s\n", pkt->data);
// if (seqno > r->NEXT_PACKET_EXPECTED) {
// // Ghetto fix
// return;
// }
if (seqno < r->NEXT_PACKET_EXPECTED) { // duplicate packet
// fprintf(stderr, "Received duplicate packet w/ sequence number: %d\n", seqno);
struct ack_packet *ack = createAckPacket(r, r->NEXT_PACKET_EXPECTED);
conn_sendpkt(r->c, (packet_t *)ack, ACK_PACKET_SIZE);
free(ack);
return;
}
if (seqno - r->NEXT_PACKET_EXPECTED > r->windowSize) { // Packet outside window
return;
}
// fprintf(stderr, "Received sequence number: %d\n", seqno);
int slot = seqno - r->NEXT_PACKET_EXPECTED;
// fprintf(stderr, "RecvPacket slot number: %d\n", slot);
memcpy(r->recvPackets[slot]->packet, pkt, sizeof(packet_t));
r->recvPackets[slot]->sentTime = getCurrentTime();
r->recvPackets[slot]->acked = 1;
rel_output(r);
// if (seqno == r->NEXT_PACKET_EXPECTED) {
// struct ack_packet *ack = createAckPacket(r, r->NEXT_PACKET_EXPECTED + 1);
// conn_sendpkt(r->c, (packet_t *)ack, ACK_PACKET_SIZE);
// conn_output(r->c, pkt->data, len - HEADER_SIZE);
// // rel_output(r);
// r->NEXT_PACKET_EXPECTED++;
// free(ack);
// }
}
}
/* Creates a new reliable protocol session, returns NULL on failure.
* Exactly one of c and ss should be NULL. (ss is NULL when called
* from rlib.c, while c is NULL when this function is called from
* rel_demux.) */
rel_t *
rel_create (conn_t *c, const struct sockaddr_storage *ss,
const struct config_common *cc)
{
// printf("rel_create\n");
rel_t *r;
r = xmalloc (sizeof (*r));
memset (r, 0, sizeof (*r));
if (!c) {
c = conn_create (r, ss);
if (!c) {
free (r);
return NULL;
}
}
r->startTime = getCurrentTime();
r->endTime = 0;
r->c = c;
rel_list = r;
/* Do any other initialization you need here */
if(r->c->sender_receiver == RECEIVER) {
r->windowSize = cc->window;
}
else {
r->windowSize = 1;
}
r->ssThresh = cc->window;
r->slowStart = 1;
r->timeout = cc->timeout;
r->sentListSize = 0;
r->recvListSize = 0;
r->sentPackets = malloc(sizeof(wrapper *) * r->ssThresh);
r->recvPackets = malloc(sizeof(wrapper *) * r->ssThresh);
int i;
for (i = 0; i < r->ssThresh; i++) {
r->sentPackets[i] = malloc(sizeof(wrapper));
r->sentPackets[i]->packet = malloc(sizeof(packet_t));
r->sentPackets[i]->acked = 0;
r->recvPackets[i] = malloc(sizeof(wrapper));
r->recvPackets[i]->packet = malloc(sizeof(packet_t));
r->recvPackets[i]->acked = 0;
}
r->LAST_PACKET_ACKED = 0;
r->LAST_PACKET_SENT = 0;
r->NEXT_PACKET_EXPECTED = 1;
r->eofSent = 0;
r->eofRecv = 0;
// initialize w to 1?
r->w = 1;
if(r->c->sender_receiver == RECEIVER) {
rel_read(r);
}
return r;
}
void processAck2 (rel_t *r, packet_t *pkt){
processAck(r, (struct ack_packet*) pkt);
rel_read(r);
}
void
rel_recvpkt (rel_t *r, packet_t *pkt, size_t n)
{
uint16_t len = ntohs(pkt->len);
uint32_t ackno = ntohl(pkt->ackno);
int verified = verifyChecksum(r, pkt, n);
if (!verified || (len != n)) { // Drop packets with bad length
fprintf(stderr, "Packet w/ sequence number %d dropped\n", ntohl(pkt->seqno));
return;
}
if (len == ACK_PACKET_SIZE) { // Received packet is an ack packet
fprintf(stderr, "Received ack number: %d\n", ackno);
if (ackno <= r->LAST_PACKET_ACKED + 1) { // Drop duplicate acks
fprintf(stderr, "Duplicate ack: %d received\n", ackno);
return;
}
//if (ackno == r->LAST_PACKET_SENT + 1) { // REMOVE THIS AFTER WE FIX ACK SENDING!!!!
shiftSentPacketList(r, ackno);
r->LAST_PACKET_ACKED = ackno - 1;
rel_read(r);
//}
}
else { // data packet
fprintf(stderr, "%s\n", "======================RECEIVED DATA PACKET=========================");
uint32_t seqno = ntohl(pkt->seqno);
// fprintf(stderr, "Received data: %s\n", pkt->data);
// if (seqno > r->NEXT_PACKET_EXPECTED) {
// // Ghetto fix
// return;
// }
if (seqno < r->NEXT_PACKET_EXPECTED) { // duplicate packet
fprintf(stderr, "Received duplicate packet w/ sequence number: %d\n", seqno);
struct ack_packet *ack = createAckPacket(r, r->NEXT_PACKET_EXPECTED);
conn_sendpkt(r->c, (packet_t *)ack, ACK_PACKET_SIZE);
free(ack);
return;
}
if (seqno - r->NEXT_PACKET_EXPECTED > r->windowSize) { // Packet outside window
return;
}
fprintf(stderr, "Received sequence number: %d\n", seqno);
int slot = seqno - r->NEXT_PACKET_EXPECTED;
fprintf(stderr, "RecvPacket slot number: %d\n", slot);
memcpy(r->recvPackets[slot]->packet, pkt, sizeof(packet_t));
r->recvPackets[slot]->sentTime = getCurrentTime();
r->recvPackets[slot]->acked = 1;
rel_output(r);
// if (seqno == r->NEXT_PACKET_EXPECTED) {
// struct ack_packet *ack = createAckPacket(r, r->NEXT_PACKET_EXPECTED + 1);
// conn_sendpkt(r->c, (packet_t *)ack, ACK_PACKET_SIZE);
// conn_output(r->c, pkt->data, len - HEADER_SIZE);
// // rel_output(r);
// r->NEXT_PACKET_EXPECTED++;
// free(ack);
// }
}
}