int
rel_read_input_into_packet(rel_t *r, send_bq_element_t *elem)
{
assert(r);
assert(elem);
/* Read data directly into our packet */
int len = conn_input(r->c, &(elem->pkt.data[0]), 500);
if (len == 0) return -1; /* no more data to read */
if (len == -1) {
len = 0; /* send an EOF */
}
/* Build packet frame data */
elem->pkt.ackno = htonl(r->ackno);
elem->pkt.seqno = htonl(r->seqno);
elem->pkt.len = htons(12 + len);
elem->pkt.cksum = 0;
elem->pkt.cksum = cksum(&elem->pkt, 12 + len);
/* Time sent is 1970, so when there's free window, it'll be sent */
elem->time_sent.tv_sec = 0;
elem->time_sent.tv_nsec = 0;
elem->sent = 0;
return len;
}
void
rel_read (rel_t *s)
{
if (send_check(s)) {
packet_t out_pkt;
int count = conn_input(s->c, out_pkt.data, READ_SIZE);
if (count == 0) {
// no input
return;
} else {
if (count == -1) {
// EOF
count = 0;
s->SEND_EOF = true;
}
// send
out_pkt.cksum = 0;
out_pkt.len = htons(count + 12);
out_pkt.ackno = htonl(1);
out_pkt.seqno = htonl(s->LSS+1);
out_pkt.cksum = cksum(&out_pkt, count+12);
conn_sendpkt(s->c, &out_pkt, count+12);
addPktToSWindow(s, out_pkt);
}
}
}
void
rel_read (rel_t *s)
{
int numPacketsInWindow = s->LAST_PACKET_SENT - s->LAST_PACKET_ACKED;
fprintf(stderr, "REL_READ -- lastpacketsent: %d, lastacked: %d\n", s->LAST_PACKET_SENT, s->LAST_PACKET_ACKED);
if (numPacketsInWindow == 0 && s->eofSent == 1 && s->eofRecv == 1) {
rel_destroy(s);
return;
}
if (numPacketsInWindow >= s->windowSize || s->eofSent) {
// don't send, window's full, waiting for acks
return;
}
// can send packet
char payloadBuffer[MAX_PAYLOAD_SIZE];
int bytesReceived = conn_input(s->c, payloadBuffer, MAX_PAYLOAD_SIZE);
if (bytesReceived == 0) {
return; // no data is available at the moment, just return
}
else if (bytesReceived == -1) { // eof or error
s->eofSent = 1;
bytesReceived = 0;
// Why do we need to create and send a packet here?
// packet_t *packet = createDataPacket(s, payloadBuffer, bytesReceived);
// conn_sendpkt(s->c, packet, HEADER_SIZE + bytesReceived);
// free(packet);
// return;
}
// TODO: Need to handle overflow bytes here as well
packet_t *packet = createDataPacket(s, payloadBuffer, bytesReceived);
s->LAST_PACKET_SENT++;
fprintf(stderr, "Sent sequence number: %d\n", ntohl(packet->seqno));
conn_sendpkt(s->c, packet, HEADER_SIZE + bytesReceived);
// Save packet until it's acked/in case it needs to be retransmitted
int slot = s->LAST_PACKET_SENT - s->LAST_PACKET_ACKED - 1;
// fprintf(stderr, "Slot: %d\n", slot);
memcpy(s->sentPackets[slot]->packet, packet, HEADER_SIZE + bytesReceived);
s->sentPackets[slot]->sentTime = getCurrentTime();
s->sentPackets[slot]->acked = 1;
fprintf(stderr, "%s\n", "====================SENDING PACKET================");
// fprintf(stderr, "Packet data: %s\n", packet->data);
free(packet);
}
void rel_read(rel_t *s) {
int data_size = 0;
data_size = conn_input(s->c, s->sender.packet.data, MAX_DATA_SIZE);
if (data_size == 0) {
return;
}
else if (data_size > 0 && data_size <= MAX_DATA_SIZE) {
send_data_pkt(s, data_size);
}
else if (data_size > MAX_DATA_SIZE) {
send_data_pkt(s, MAX_DATA_SIZE);
}
}
void sendRead(rel_t *s){
if (s && s->inputEOF == 0) {
int size = s->recvWindows;
if(size > s->cwndSize){
size = s->cwndSize;
}
size = (size > 9) ? 9 : size;
while (sizeOfQueue(s->senderBuff) < size) {
packetQueue* tempPack = new_packet();
int dataIn = conn_input(s->c, tempPack->packet->data, 1000);
if (dataIn == 0) {
break;
}
if(dataIn > 0){
tempPack->packet->cksum = 0;
tempPack->packet->len = htons((16 + dataIn));
tempPack->packet->seqno = htonl(s->seqOut);
s->seqOut++;
tempPack->packet->rwnd = htonl(s->recvWindows - sizeOfQueue(s->receiverBuff));
tempPack->packet->ackno = htonl(s->seqIn);
tempPack->packet->cksum = cksum(tempPack->packet, (16 + dataIn));
addToQueue(&(s->senderBuff), tempPack);
conn_sendpkt(s->c, tempPack->packet, (16 + dataIn));
}
else{
s->inputEOF = 1;
s->seqLast = s->seqOut;
dataIn = 0;
tempPack->packet->cksum = 0;
tempPack->packet->len = htons((16 + dataIn));
tempPack->packet->seqno = htonl(s->seqOut);
s->seqOut++;
tempPack->packet->rwnd = htonl(s->recvWindows - sizeOfQueue(s->receiverBuff));
tempPack->packet->ackno = htonl(s->seqIn);
tempPack->packet->cksum = cksum(tempPack->packet, (16 + dataIn));
addToQueue(&(s->senderBuff), tempPack);
conn_sendpkt(s->c, tempPack->packet, (16 + dataIn));
}
}
return;
}
rel_destroy (s);
return;
}
/*
If the reliable program is running in the receiver mode
(see c.sender_receiver in rlib.c, you can get its value in
rel_create), this receiver should send an EOF to the sender
when rel_read is first called. After this first call, the
function rel_read can simply return for later calls. Note
that this EOF will wait in the receiver's sending window.
When timeout happens, the receiver have to retransmit this
EOF as well until an ACK is received. If the reliable is
running in the sender mode, the rel_read's behavior is the
same as that is described above in 3a.
*/
void
rel_read (rel_t *s)
{
// printf("rel_read\n");
if(s->c->sender_receiver == RECEIVER)
{
// if already sent eof to the sender/not first call
// return;
if(s->eofSent == 1) {
// fprintf(stderr, "%s\n", "EOF already sent in rel_read");
// s->eofSent = 0;
return;
}
else {
// first call
// set eofSent to 1
s->eofSent = 1;
// send eof
char payloadBuffer[MAX_PAYLOAD_SIZE];
int bytesReceived = 0;
packet_t *packet = createDataPacket(s, payloadBuffer, bytesReceived);
conn_sendpkt(s->c, packet, HEADER_SIZE + bytesReceived);
free(packet);
// printf("Sending EOF to sender in rel_read\n");
}
//if already sent EOF to the sender
// return;
//else
// send EOF to the sender
}
else //run in the sender mode
{
//same logic as lab 1
int numPacketsInWindow = s->LAST_PACKET_SENT - s->LAST_PACKET_ACKED;
// fprintf(stderr, "REL_READ -- lastpacketsent: %d, lastacked: %d\n", s->LAST_PACKET_SENT, s->LAST_PACKET_ACKED);
// fprintf(stderr, "relread -- numPackets: %d, eofRecv: %d, eofSend: %d\n", numPacketsInWindow, s->eofRecv, s->eofSent);
if (numPacketsInWindow == 0 && s->eofSent == 1 && s->eofRecv == 1) {
rel_destroy(s);
return;
}
if (numPacketsInWindow >= s->windowSize || s->eofSent) {
// don't send, window's full, waiting for acks
return;
}
// can send packet
char payloadBuffer[MAX_PAYLOAD_SIZE];
memset(payloadBuffer, 0, MAX_PAYLOAD_SIZE);
int bytesReceived = conn_input(s->c, payloadBuffer, MAX_PAYLOAD_SIZE);
// fprintf(stderr, "Bytes received: %d\n", bytesReceived );
if (bytesReceived == 0) {
return; // no data is available at the moment, just return
}
else if (bytesReceived == -1) { // eof or error
s->eofSent = 1;
bytesReceived = 0;
// Why do we need to create and send a packet here?
// packet_t *packet = createDataPacket(s, payloadBuffer, bytesReceived);
// conn_sendpkt(s->c, packet, HEADER_SIZE + bytesReceived);
// free(packet);
// return;
}
// TODO: Need to handle overflow bytes here as well
packet_t *packet = createDataPacket(s, payloadBuffer, bytesReceived);
s->LAST_PACKET_SENT++;
// fprintf(stderr, "Sent sequence number: %d\n", ntohl(packet->seqno));
// fprintf(stderr, "PACKET INFO: %s\n", packet->data);
// fprintf(stderr, "PACKET INFO: %s\n", strdup(payloadBuffer));
// fprintf(stderr, "String Compare Value: %d\n", strcmp(packet->data, ""));
conn_sendpkt(s->c, packet, HEADER_SIZE + bytesReceived);
// Save packet until it's acked/in case it needs to be retransmitted
int slot = s->LAST_PACKET_SENT - s->LAST_PACKET_ACKED - 1;
// fprintf(stderr, "Slot: %d\n", slot);
memcpy(s->sentPackets[slot]->packet, packet, HEADER_SIZE + bytesReceived);
s->sentPackets[slot]->sentTime = getCurrentTime();
s->sentPackets[slot]->acked = 1;
// fprintf(stderr, "%s\n", "====================SENDING PACKET================");
// fprintf(stderr, "Packet data: %s\n", packet->data);
free(packet);
}
}
