void
rel_output (rel_t *r)
{
// printf("rel_output\n");
int numPacketsInWindow = r->LAST_PACKET_SENT - r->LAST_PACKET_ACKED;
int i;
// fprintf(stderr, "lastpacksent: %d, lackPackacked: %d\n", r->LAST_PACKET_SENT, r->LAST_PACKET_ACKED);
for (i = 0; i < r->windowSize; i++) {
// fprintf(stderr, "Recvpacket of %d has ack %d\n", i, r->recvPackets[i]->acked);
if(r->recvPackets[i]->acked == 0) {
break;
}
packet_t *pkt = r->recvPackets[i]->packet;
uint16_t packet_len = ntohs(pkt->len);
size_t len = conn_bufspace(r->c);
// fprintf(stderr, "Packet len: %d\n", (int) packet_len);
if(len >= packet_len - HEADER_SIZE) {
if(packet_len == HEADER_SIZE) {
r->eofRecv = 1;
}
// fprintf(stderr, "Outputting packet %d from recvPackets \n", i);
conn_output(r->c, pkt->data, packet_len - HEADER_SIZE);
r->recvPackets[i]->acked = 0;
}
else {
break;
}
}
// fprintf(stderr, "value of i: %d\n", i);
// fprintf(stderr, "Next Packet Expected Before: %d\n", r->NEXT_PACKET_EXPECTED );
r->NEXT_PACKET_EXPECTED += i;
struct ack_packet *ack = createAckPacket(r, r->NEXT_PACKET_EXPECTED);
// fprintf(stderr, "Next Packet Expected: %d\n", r->NEXT_PACKET_EXPECTED);
conn_sendpkt(r->c, (packet_t *)ack, ACK_PACKET_SIZE);
free(ack);
// fprintf(stderr, "reloutput -- numPackets: %d, eofRecv: %d, eofSend: %d\n", numPacketsInWindow, r->eofRecv, r->eofSent);
if(numPacketsInWindow == 0 && r->eofRecv == 1 && r->eofSent == 1) {
rel_destroy(r);
return;
}
shiftRecvPacketList(r);
}
bool RfidReaderMac::handleRecvdMacPacket(PacketPtr packet,
t_uint sendingLayerIdx)
{
RfidTagMacDataPtr macData =
boost::dynamic_pointer_cast<RfidTagMacData>
(packet->getData(Packet::DataTypes_Link));
bool wasSuccessful = true;
// For now, we'll only handle MAC packets from tags.
if(macData.get() != 0) {
if(packetIsForMe(macData)) {
switch(macData->getType()) {
case RfidTagMacData::Types_Reply:
// If we ended the cycle early due to too many
// consecutive missed reads, then the timer will
// be stopped and we shouldn't handle anymore
// REPLY packets.
if(m_cycleTimer->isRunning()) {
// It could be the case that this reply is received
// in a contention cycle after the a SELECT packet
// was lost. In response to the SELECT packet being
// lost in slot i, the reader will reset in
// slot i+2 and send a REQUEST in slot i+3.
// If this reply is received in slot i+2, we should
// ignore it since m_packetToTransmit already
// has a REQUEST packet pending.
if(m_packetToTransmit.get() == 0) {
assert(m_currentAppReadPacket.get() != 0);
// Send SELECT message header on the original
// app packet.
addSelectHeader(m_currentAppReadPacket,
macData->getSenderId());
m_packetToTransmit = m_currentAppReadPacket;
m_txSlotNumber = m_currentSlotNumber;
assert(m_slotTimer.get() != 0 &&
m_slotTimer->isRunning());
}
}
break;
case RfidTagMacData::Types_Generic:
// Subtract three from the winning slot number for:
// 1. The current slot number was incremented
// at the beginning of the slot.
// 2. The REPLY was sent two slots prior
// to this packet being received (the SELECT
// packet was sent one slot prior).
m_winningSlotNumbers.push_back(
make_pair(macData->getSenderId(),
(m_currentSlotNumber - 3)));
// Just pass the packet to upper layers.
wasSuccessful = sendToLinkLayer(
CommunicationLayer::Directions_Upper, packet);
m_packetToTransmit = createAckPacket(macData->getSenderId());
m_txSlotNumber = m_currentSlotNumber;
assert(m_slotTimer.get() != 0 &&
m_slotTimer->isRunning());
break;
default:
wasSuccessful = false;
}
}
}
return wasSuccessful;
}
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);
// }
}
}
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);
// }
}
}
