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); } }