802_11.pc

simulator for ad hoc

   } else {
      if (hdr->destAddr == ANY_DEST)
      {
         GLOMO_MsgRemoveHeader(node, frame, sizeof(M802_11FrameHdr));
         NetworkIpReceivePacketFromMacLayer(node, frame, sourceAddr);
         M802->pktsGotBroadcast++;
         Mac802_11CheckForOutgoingPacket(node, M802);
      }
      else
      {
         Mac802_11CancelTimer(node, M802);
         Mac802_11TransmitAck(node, M802, frame);
   
         if (Mac802_11CorrectSeqenceNumber(node, M802, hdr->sourceAddr,
                                           hdr->seqNo))
         {
            SeqNoEntry* entry;
            
            GLOMO_MsgRemoveHeader(node, frame, sizeof(M802_11FrameHdr));
   
            NetworkIpReceivePacketFromMacLayer(node, frame, sourceAddr);
   
            /* Upate sequence number. */
            entry = Mac802_11GetSeqNo(node, M802, sourceAddr);
            assert(entry);
            entry->fromSeqNo += 1;
   
            M802->pktsGotUnicast++;
         } else {
            // Wrong sequence number, Drop.
            
            GLOMO_MsgFree(node, frame);
         }//if//
      }//if//
   }//if//
}


/*
 * NAME:        Mac802_11ProcessFrag.
 *
 * PURPOSE:     Process local fragmented data frames.
 *
 * PARAMETERS:  node, node processing local fragmented data frames.
 *              frame, local fragmented frames.
 *
 * RETURN:      None.
 *
 * ASSUMPTION:  None.
 */

static 
void Mac802_11ProcessFrag(GlomoNode *node, GlomoMac802_11 *M802, Message *frame)
{
   M802_11FrameHdr hdr;

   Message *pktToNetwork;

   
   assert(FALSE); abort();  // Fragmentation Needs to be rewritten. (Jay)
   
//NoFrag    M802->IsInExtendedIfsMode = FALSE;
//NoFrag    
//NoFrag    memcpy(&(hdr), frame->packet, sizeof(M802_11FrameHdr));
//NoFrag 
//NoFrag    GLOMO_MsgRemoveHeader(node, frame, sizeof(M802_11FrameHdr));
//NoFrag 
//NoFrag 
//NoFrag    if (Mac802_11CorrectSeqenceNumber(node, M802, 
//NoFrag                                      hdr.sourceAddr,
//NoFrag                                      hdr.seqNo))
//NoFrag    {
//NoFrag       if ((hdr.fragId*M802_11_FRAG_THRESH) >= frame->packetSize)
//NoFrag       {
//NoFrag          NODE_ADDR sourceAddr;
//NoFrag          SeqNoEntry *entry;
//NoFrag          char *where = (M802->PartialFrame) +
//NoFrag                        (hdr.fragId * M802_11_FRAG_THRESH);
//NoFrag 
//NoFrag          sourceAddr = hdr.sourceAddr;
//NoFrag          memcpy(where,
//NoFrag                 frame->packet,
//NoFrag                 (frame->packetSize - ((hdr.fragId-1)*
//NoFrag                 M802_11_FRAG_THRESH)));
//NoFrag 
//NoFrag          pktToNetwork = GLOMO_MsgAlloc(node, 0, 0, 0);
//NoFrag 
//NoFrag          GLOMO_MsgPacketAlloc(node, pktToNetwork, frame->packetSize);
//NoFrag 
//NoFrag          memcpy(pktToNetwork->packet,
//NoFrag                 M802->PartialFrame,
//NoFrag                 frame->packetSize);
//NoFrag 
//NoFrag          NetworkIpReceivePacketFromMacLayer(node, pktToNetwork, sourceAddr);
//NoFrag 
//NoFrag          M802->pktsGotUnicast++;
//NoFrag 
//NoFrag 
//NoFrag          entry = Mac802_11GetSeqNo(node, M802, hdr.sourceAddr);
//NoFrag          assert(entry);
//NoFrag          entry->fromSeqNo += 1;
//NoFrag 
//NoFrag          Mac802_11TransmitAck(node, M802, frame);
//NoFrag       }
//NoFrag       else
//NoFrag       {
//NoFrag          SeqNoEntry *entry;
//NoFrag 
//NoFrag 
//NoFrag          /* Update sequence number. */
//NoFrag          entry = Mac802_11GetSeqNo(node, M802, hdr.sourceAddr);
//NoFrag          assert(entry);
//NoFrag          entry->fromSeqNo += 1;
//NoFrag 
//NoFrag          if (hdr.fragId == 1)
//NoFrag          {
//NoFrag             memcpy(M802->PartialFrame,
//NoFrag                    frame->packet,
//NoFrag                    M802_11_FRAG_THRESH);
//NoFrag          }
//NoFrag          else
//NoFrag          {
//NoFrag             char *where = (M802->PartialFrame) +
//NoFrag                           (hdr.fragId * M802_11_FRAG_THRESH);
//NoFrag 
//NoFrag             memcpy(where,
//NoFrag                    frame->packet,
//NoFrag                    M802_11_FRAG_THRESH);
//NoFrag          }
//NoFrag 
//NoFrag          Mac802_11TransmitFragAck(node, M802, hdr);
//NoFrag       }
//NoFrag    }
//NoFrag    else
//NoFrag    {
//NoFrag 
//NoFrag       Mac802_11TransmitFragAck(node, M802, hdr);
//NoFrag    }
}

/*
 * NAME:        Mac802_11ContinueBackoff.
 *
 * PURPOSE:     Continues decreasing backoff counter in collision avoidance
 *              (CA) process.
 *
 * PARAMETERS:  node, node that is continuing its backoff.
 *
 * RETURN:      None.
 *
 * ASSUMPTION:  None.
 */

static 
void Mac802_11ContinueBackoff(GlomoNode *node, GlomoMac802_11 *M802)
{
   M802->lastBOTimeStamp = simclock();

   if (M802->BO < 0)
   {
      char clockStr[GLOMO_MAX_STRING_LENGTH];
      ctoa(M802->BO, clockStr);
      printf("Node %ld continuing backoff to a negative timer: %s\n",
             node->nodeAddr, clockStr);
      exit(0);
   }

}




/*
 * NAME:        Mac802_11TransmitRTSFrame.
 *
 * PURPOSE:     Send RTS to reserve channel for data frame.
 *
 * PARAMETERS:  node, node that wants to reserve channel for data frame.
 *
 * RETURN:      None.
 *
 * ASSUMPTION:  None.
 */

static 
void Mac802_11TransmitRTSFrame(GlomoNode *node, GlomoMac802_11 *M802)
{
   M802_11LongControlFrame* hdr;
   Message *pktToRadio;
   Message *tmpPktPtr;
   NODE_ADDR destAddr;

   NetworkIpOutputQueueTopPacketForAPriority(
      node, M802->myGlomoMac->interfaceIndex, M802->currentPriority,
      &tmpPktPtr, &destAddr);

   if  (tmpPktPtr ==NULL)
   {
      assert(FALSE); abort();
      Mac802_11CheckForOutgoingPacket(node, M802);
      return;
   }

   pktToRadio = GLOMO_MsgAlloc(node, 0, 0, 0);
   
   GLOMO_MsgPacketAlloc(node, pktToRadio, sizeof(M802_11LongControlFrame));
   hdr = (M802_11LongControlFrame*)pktToRadio->packet;

   hdr->frameType = M802_11_RTS;
   hdr->sourceAddr = node->nodeAddr,
   hdr->destAddr = destAddr;

   M802->waitingForAckOrCtsFromAddress = destAddr;
   
   if (tmpPktPtr->packetSize <= M802_11_FRAG_THRESH)
   {
      clocktype packetTransmissionDuration =
         CalcFragmentTransmissionDuration(
            M802->bandwidth, tmpPktPtr->packetSize);
   
      hdr->duration =
         M802->extraPropDelay + M802_11_SIFS + 
         M802->ctsOrAckTransmissionDuration + 
         M802->extraPropDelay + M802_11_SIFS + 
         packetTransmissionDuration + 
         M802->extraPropDelay + M802_11_SIFS + 
         M802->ctsOrAckTransmissionDuration +
         M802->extraPropDelay;
         
   } else {
      assert(FALSE); abort();  // Fragmentation Needs to be rewritten. (Jay)
      
//NoFrag      hdr.duration = ((M802_11_SHORT_CTRL_FRAME_SIZE +
//NoFrag          M802_11_FRAG_THRESH + sizeof(M802_11FrameHdr) +
//NoFrag          M802_11_SHORT_CTRL_FRAME_SIZE ) * SECOND) /
//NoFrag          (M802->bandwidth) + (3 * M802_11_SIFS) +
//NoFrag          (3 * SYNCHRONIZATION_TIME) +
//NoFrag          (3 * M802_11_DELAY_UNTIL_SIGNAL_AIRBORN) + 
//NoFrag          (3 * M802->extraPropDelay);
   }//if//

   Mac802_11SetState(node, M802, M802_11_X_RTS);
   StartTransmittingPacket(
      node, M802, pktToRadio, M802_11_DELAY_UNTIL_SIGNAL_AIRBORN);
}


/*
 * NAME:        Mac802_11TransmitDataFrame.
 *
 * PURPOSE:     Transmit the data frame since channel is reserved.
 *
 * PARAMETERS:  node, node transmitting the data frame.
 *
 * RETURN:      None.
 *
 * ASSUMPTION:  None.
 */

static 
void Mac802_11TransmitDataFrame(GlomoNode *node, GlomoMac802_11 *M802)
{
   NODE_ADDR destAddr;
   Message* topPacket;
   
   NetworkIpOutputQueueTopPacketForAPriority(
      node, M802->myGlomoMac->interfaceIndex, M802->currentPriority,
      &topPacket, &destAddr);
   assert(topPacket != NULL);
   
   if (destAddr == ANY_DEST) {
      NODE_ADDR NotUsed;
      Message* dequeuedPacket;
      M802_11FrameHdr* hdr;
   
      NetworkIpOutputQueueDequeuePacketForAPriority(
         node, M802->myGlomoMac->interfaceIndex, M802->currentPriority,
         &dequeuedPacket, &NotUsed);
   
      assert(topPacket == dequeuedPacket);
      
      M802->currentPriority = INVALID_PRIORITY;
      M802->pktsSentBroadcast++;
      
      GLOMO_MsgAddHeader(node, dequeuedPacket, sizeof(M802_11FrameHdr) );
      
      hdr = (M802_11FrameHdr*)dequeuedPacket->packet; 
      hdr->frameType = M802_11_DATA;
      hdr->sourceAddr = node->nodeAddr;
      hdr->destAddr = destAddr;
      hdr->duration = 0;
      
      Mac802_11SetState(node, M802, M802_11_X_BROADCAST);
      
      StartTransmittingPacket(
         node, M802, dequeuedPacket, M802_11_DELAY_UNTIL_SIGNAL_AIRBORN);
   } else {
      SeqNoEntry *entry;
      M802_11FrameHdr hdr;
      Message* pktToRadio = GLOMO_MsgAlloc(node, 0, 0, 0);
      
      hdr.frameType = M802_11_DATA;
      hdr.sourceAddr = node->nodeAddr;
      hdr.destAddr = destAddr;
      M802->waitingForAckOrCtsFromAddress = destAddr;
   
      entry = Mac802_11GetSeqNo(node, M802, destAddr);
      assert(entry);
      hdr.seqNo = entry->toSeqNo;
      hdr.duration = 
         M802->extraPropDelay + M802_11_SIFS + 
         M802->ctsOrAckTransmissionDuration +
         M802->extraPropDelay;

      if (topPacket->packetSize > M802_11_FRAG_THRESH) {
         assert(FALSE); abort();  // Fragmentation Needs to be rewritten. (Jay)
      
      //int macPktLen;
      //int i, remainder;
      
//NoFrag       hdr.frameType = M802_11_FRAGMENT;
//NoFrag       M802->currentFrag = 1;
//NoFrag       remainder = packet->packetSize - M802_11_FRAG_THRESH;
//NoFrag 
//NoFrag       if (remainder > M802_11_FRAG_THRESH)
//NoFrag       {
//NoFrag 
//NoFrag          hdr.duration =
//NoFrag             (( M802_11_SHORT_CTRL_FRAME_SIZE +
//NoFrag             M802_11_FRAG_THRESH + sizeof(M802_11FrameHdr) +
//NoFrag             M802_11_SHORT_CTRL_FRAME_SIZE ) * SECOND) /
//NoFrag             (M802->bandwidth) +
//NoFrag             (3 * SYNCHRONIZATION_TIME) +
//NoFrag             (3 * M802_11_SIFS) + 
//NoFrag             (3 * M802_11_DELAY_UNTIL_SIGNAL_AIRBORN) +
//NoFrag             (3 * M802->extraPropDelay);
//NoFrag       }
//NoFrag       else
//NoFrag       {
//NoFrag 
//NoFrag          /* End of next FRAG/ACK period is last FRAG/ACK. */
//NoFrag          hdr.duration =
//NoFrag             (( M802_11_SHORT_CTRL_FRAME_SIZE +
//NoFrag             remainder + sizeof(M802_11FrameHdr) +
//NoFrag             M802_11_SHORT_CTRL_FRAME_SIZE) * SECOND) /
//NoFrag             (M802->bandwidth) +
//NoFrag             (3 * SYNCHRONIZATION_TIME) +
//NoFrag             (3 * M802_11_SIFS) + 
//NoFrag             (3 * M802_11_DELAY_UNTIL_SIGNAL_AIRBORN) +
//NoFrag             (3 * M802->extraPropDelay);
//NoFrag       }
//NoFrag 
//NoFrag       GLOMO_MsgPacketAlloc(node, pktToRadio, M802_11_FRAG_THRESH);
//NoFrag 
//NoFrag       macPktLen = M802_11_FRAG_THRESH;
//NoFrag       hdr.fragId = 1;
//NoFrag 
//NoFrag 
//NoFrag       memcpy(pktToRadio->packet, packet->packet, macPktLen);
//NoFrag       GLOMO_MsgAddHeader(node, pktToRadio, sizeof(M802_11FrameHdr) );
//NoFrag 
//NoFrag       memcpy(pktToRadio->packet, &(hdr), sizeof(M802_11FrameHdr));
//NoFrag 
//NoFrag       Mac802_11SetState(node, M802, M802_11_X_FRAGMENT);
//NoFrag       
//NoFrag       if ((packet->packetSize > M802_11_RTS_THRESH)
//NoFrag           && (destAddr != ANY_DEST))
//NoFrag       {
//NoFrag          /*
//NoFrag           * Since using RTS-CTS, data packets have to wait
//NoFrag           * an additional SIFS.
//NoFrag           */
//NoFrag          
//NoFrag          StartTransmittingPacket(node, M802, pktToRadio, M802_11_SIFS);
//NoFrag       }
//NoFrag       else
//NoFrag       {
//NoFrag          /*
//NoFrag           * Not using RTS-CTS, so don't need to wait for SIFS since already
//NoFrag           * waited for DIFS or BO.
//NoFrag           */
//NoFrag          
//NoFrag          StartTransmittingPacket(
//NoFrag             node, M802, pktToRadio, M802_11_DELAY_UNTIL_SIGNAL_AIRBORN);
//NoFrag       }

      }
      else
      {
         hdr.fragId = 0;
         GLOMO_MsgPacketAlloc(node, pktToRadio, topPacket->packetSize);
         memcpy(pktToRadio->packet, topPacket->packet, topPacket->packetSize);
         GLOMO_MsgAddHeader(node, pktToRadio, sizeof(M802_11FrameHdr) );
         memcpy(pktToRadio->packet, &hdr, sizeof(M802_11FrameHdr));
         
         Mac802_11SetState(node, M802, M802_11_X_UNICAST);
         
   
         if (topPacket->packetSize > M802_11_RTS_THRESH) {
            //
            // Since using RTS-CTS, data packets have to wait
            // an additional SIFS.
            //
            
            StartTransmittingPacket(node, M802, pktToRadio, M802_11_SIFS);
         }
         else
         {
            //
            // Not using RTS-CTS, so don't need to wait for SIFS since already
            // waited for DIFS or BO.
            //
            StartTransmittingPacket(
               node, M802, pktToRadio, M802_11_DELAY_UNTIL_SIGNAL_AIRBORN);
         }
   
      }
   }
}


/*
 * NAME:        Mac802_11TransmitFrame.
 *
 * PURPOSE:     In the process of sending a data frame.
 *
 * PARAMETERS:  node, node that wants to send a data frame.
 *
 * RETURN:      None.
 *
 * ASSUMPTION:  None.
 */

static 
void Mac802_11TransmitFrame(GlomoNode *node, GlomoMac802_11 *M802)
{
   Message *tmpPktPtr;
   Message *pktToRadio;
   int macPktLen;
   NODE_ADDR nextHopAddress;
   NetworkQueueingPriorityType priority;

   assert(RadioStatus(node, M802) == RADIO_IDLE);

   NetworkIpOutputQueueTopPacket(
      node, M802->myGlomoMac->interfaceIndex,
      &tmpPktPtr, &nextHopAddress, &priority);
   
   if  (tmpPktPtr == NULL)
   {
      assert(FALSE); abort();
      Mac802_11CheckForOutgoingPacket(node, M802);
      return;
   }

   M802->currentPriority = priority;

   if ((tmpPktPtr->packetSize > M802_11_RTS_THRESH) && 
       (nextHopAddress != ANY_DEST))
   {
      Mac802_11TransmitRTSFrame(node, M802);
   }
   else
   {
      Mac802_11TransmitDataFrame(node, M802);
   }
}







void TransmissionHasFinished(
   GlomoNode* node,
   GlomoMac802_11* M802)
{
   switch(M802->state) {
   case M802_11_X_ACK:
      Mac802_11AckTransmitted(node, M802);
      break;
   
   case M802_11_X_BROADCAST:
      Mac802_11CheckForOutgoingPacket(node, M802);
      break;
   
   case M802_11_X_UNICAST:
      Mac802_11UnicastTransmitted(node, M802);
      break;