pibp.nc

tinyos-2.x.rar

            (mhr[MHR_INDEX_FC1] & FC1_PAN_ID_COMPRESSION) ? TRUE: FALSE);
    return SUCCESS;
  }

  command uint8_t Frame.getFrameType(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    return (mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK);
  }

  command void* Frame.getHeader(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    return (void*) &(mhr[MHR_INDEX_FC1]);
  }

  command uint8_t Frame.getHeaderLength(message_t* frame)
  {
    uint8_t len;
    uint8_t *mhr = MHR(frame);
    call FrameUtility.getMHRLength(mhr[0], mhr[1], &len);
    return len;
  }

  command void* Frame.getPayload(message_t* frame)
  {
    uint8_t *payload = (uint8_t *) frame->data;
    return payload;
  }

  command uint8_t Frame.getPayloadLength(message_t* frame)
  {
    uint8_t len = ((ieee154_header_t*) frame->header)->length & FRAMECTL_LENGTH_MASK;
    return len;
  }

  command uint32_t Frame.getTimestamp(message_t* frame)
  {
    ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata;
    return metadata->timestamp;
  }

  command bool Frame.isTimestampValid(message_t* frame)
  {
    ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata;
    if (metadata->timestamp == IEEE154_INVALID_TIMESTAMP)
      return FALSE;
    else
      return TRUE;
  }

  command uint8_t Frame.getDSN(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    return mhr[MHR_INDEX_SEQNO];
  }

  command uint8_t Frame.getLinkQuality(message_t* frame)
  {
    ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata;
    return metadata->linkQuality;
  }

  command uint8_t Frame.getSrcAddrMode(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    return (mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) >> FC2_SRC_MODE_OFFSET;
  }

  command error_t Frame.getSrcAddr(message_t* frame, ieee154_address_t *address)
  {
    uint8_t *mhr = MHR(frame);
    uint8_t offset = MHR_INDEX_ADDRESS;
    uint8_t destMode = (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK);
    if (!(mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_SHORT))
      return FAIL;
    if (destMode == FC2_DEST_MODE_SHORT)
      offset += 4;
    else if (destMode == FC2_DEST_MODE_EXTENDED)
      offset += 10;
    if (!((mhr[MHR_INDEX_FC1] & FC1_PAN_ID_COMPRESSION) && (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT)))
      offset += 2;
    if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT)
      address->shortAddress = *((nxle_uint16_t*) (&(mhr[offset])));
    else
      call FrameUtility.convertToNative(&address->extendedAddress, (&(mhr[offset])));
    return SUCCESS;
  }

  command error_t Frame.getSrcPANId(message_t* frame, uint16_t *PANID)
  {
    uint8_t *mhr = MHR(frame);
    uint8_t offset = MHR_INDEX_ADDRESS;
    uint8_t destMode = (mhr[1] & FC2_DEST_MODE_MASK);
    if (!(mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_SHORT))
      return FAIL;
    if (destMode == FC2_DEST_MODE_SHORT)
      offset += 4;
    else if (destMode == FC2_DEST_MODE_EXTENDED)
      offset += 10;
    if ((mhr[MHR_INDEX_FC1] & FC1_PAN_ID_COMPRESSION) && (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT))
      *PANID = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS])));
    else if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT)
      *PANID = *((nxle_uint16_t*) (&(mhr[offset])));
    else
      *PANID = *((nxle_uint16_t*) (&(mhr[offset])));
    return SUCCESS;
  }

  command uint8_t Frame.getDstAddrMode(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    return (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) >> FC2_DEST_MODE_OFFSET;
  }

  command error_t Frame.getDstAddr(message_t* frame, ieee154_address_t *address)
  { 
    uint8_t *mhr = MHR(frame);
    if (!(mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT))
      return FAIL;
    if ((mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_SHORT)
      address->shortAddress = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS]) + 2));
    else
      call FrameUtility.convertToNative(&address->extendedAddress, (&(mhr[MHR_INDEX_ADDRESS]) + 2));
    return SUCCESS;
  }

  command error_t Frame.getDstPANId(message_t* frame, uint16_t *PANID)
  {
    uint8_t *mhr = MHR(frame);
    if (!(mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT))
      return FAIL;
    *PANID = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS])));
    return SUCCESS;
  }

  command bool Frame.wasPromiscuousModeEnabled(message_t* frame)
  {
    return (((ieee154_header_t*) frame->header)->length & FRAMECTL_PROMISCUOUS) ? TRUE : FALSE;
  }

  command bool Frame.hasStandardCompliantHeader(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    if (((mhr[0] & FC1_FRAMETYPE_MASK) > 0x03) ||
         ((mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == 0x04) || 
         ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == 0x40) || 
#ifndef IEEE154_SECURITY_ENABLED
         ((mhr[0] & FC1_SECURITY_ENABLED)) || 
#endif
         (mhr[MHR_INDEX_FC2] & FC2_FRAME_VERSION_2))
      return FALSE;
    else
      return TRUE;
  }

  /* ----------------------- Beacon Frame Access ----------------------- */

  uint8_t getPendAddrSpecOffset(uint8_t *macPayloadField)
  {
    uint8_t gtsDescriptorCount = macPayloadField[BEACON_INDEX_GTS_SPEC] & GTS_DESCRIPTOR_COUNT_MASK;
    return BEACON_INDEX_GTS_SPEC + 1 + ((gtsDescriptorCount > 0) ? 1 + gtsDescriptorCount * 3: 0);
  }    

  command error_t BeaconFrame.getPendAddrSpec(message_t* frame, uint8_t* pendAddrSpec)
  {
    uint8_t *mhr = MHR(frame);
    if (((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON))
      return FAIL;
    else {
      uint8_t *payload = (uint8_t *) frame->data;
      uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload);      
      *pendAddrSpec = payload[pendAddrSpecOffset];
      return SUCCESS;
    }
  }

  command error_t BeaconFrame.getPendAddr(message_t* frame, uint8_t addrMode, 
      ieee154_address_t buffer[], uint8_t bufferSize)
  {
    uint8_t *mhr = MHR(frame);
    uint8_t *payload = (uint8_t *) frame->data;
    uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload);      
    uint8_t pendAddrSpec = payload[pendAddrSpecOffset], i;
    if (((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON))
      return FAIL;
    if (addrMode == ADDR_MODE_SHORT_ADDRESS) {
      for (i=0; i<(pendAddrSpec & PENDING_ADDRESS_SHORT_MASK) && i<bufferSize; i++)
        buffer[i].shortAddress = *((nxle_uint16_t*) (payload + pendAddrSpecOffset + 1 + 2*i));
      return SUCCESS;
    } else if (addrMode == ADDR_MODE_EXTENDED_ADDRESS) {
      for (i=0; i<((pendAddrSpec & PENDING_ADDRESS_EXT_MASK) >> 4) && i<bufferSize; i++)
        call FrameUtility.convertToNative(&(buffer[i].extendedAddress),
            ((payload + pendAddrSpecOffset +
              1 + (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK)*2 + 8*i)));
      return SUCCESS;
    }
    return EINVAL;
  }

  command uint8_t BeaconFrame.isLocalAddrPending(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    uint8_t *payload = (uint8_t *) frame->data;
    uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload);      
    uint8_t pendAddrSpec = payload[pendAddrSpecOffset], i;
    ieee154_macShortAddress_t shortAddress = call MLME_GET.macShortAddress();
    if (((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON))
      return ADDR_MODE_NOT_PRESENT;
    for (i=0; i<(pendAddrSpec & PENDING_ADDRESS_SHORT_MASK); i++)
      if (*((nxle_uint16_t*) (payload + pendAddrSpecOffset + 1 + 2*i)) == shortAddress)
        return ADDR_MODE_SHORT_ADDRESS;
    for (i=0; i<((pendAddrSpec & PENDING_ADDRESS_EXT_MASK) >> 4); i++)
      if (isLocalExtendedAddress(((payload + pendAddrSpecOffset + 
              1 + (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK)*2 + 8*i))))
        return ADDR_MODE_EXTENDED_ADDRESS;
    return ADDR_MODE_NOT_PRESENT;
  }

  command void* BeaconFrame.getBeaconPayload(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    uint8_t *payload = (uint8_t *) frame->data;
    if ((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_BEACON) {
      uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload);
      uint8_t pendAddrSpec = payload[pendAddrSpecOffset];
      payload += (pendAddrSpecOffset + 1);
      if (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK)
        payload += (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK) * 2;
      if (pendAddrSpec & PENDING_ADDRESS_EXT_MASK)
        payload += ((pendAddrSpec & PENDING_ADDRESS_EXT_MASK) >> 4) * 8;
    }
    return payload;    
  }

  command uint8_t BeaconFrame.getBeaconPayloadLength(message_t* frame)
  {
    uint8_t *mhr = MHR(frame);
    uint8_t len = ((ieee154_header_t*) frame->header)->length & FRAMECTL_LENGTH_MASK;
    if ((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_BEACON) {
      uint8_t *payload = call BeaconFrame.getBeaconPayload(frame);
      len = len - (payload - (uint8_t *) frame->data);
    } 
    return len;
  }

  command uint8_t BeaconFrame.getBSN(message_t* frame)
  {
    return call Frame.getDSN(frame);
  }

  command error_t BeaconFrame.parsePANDescriptor(
      message_t *frame,
      uint8_t LogicalChannel,
      uint8_t ChannelPage,
      ieee154_PANDescriptor_t *pdescriptor)
  {
    uint8_t *mhr = MHR(frame);
    uint8_t offset;
    ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata;

    if ((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON ||
         (((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) != FC2_SRC_MODE_SHORT) && 
          ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) != FC2_SRC_MODE_EXTENDED)))
      return FAIL;

    pdescriptor->CoordAddrMode = (mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) >> FC2_SRC_MODE_OFFSET;
    offset = MHR_INDEX_ADDRESS;
    pdescriptor->CoordPANId = *((nxle_uint16_t*) &mhr[offset]);
    offset += sizeof(ieee154_macPANId_t);

    if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT)
      pdescriptor->CoordAddress.shortAddress = *((nxle_uint16_t*) &mhr[offset]);
    else
      call FrameUtility.convertToNative(&pdescriptor->CoordAddress.extendedAddress, &mhr[offset]);

    pdescriptor->LogicalChannel = LogicalChannel;
    pdescriptor->ChannelPage = ChannelPage;
    ((uint8_t*) &pdescriptor->SuperframeSpec)[0] = frame->data[BEACON_INDEX_SF_SPEC1]; // little endian
    ((uint8_t*) &pdescriptor->SuperframeSpec)[1] = frame->data[BEACON_INDEX_SF_SPEC2];
    pdescriptor->GTSPermit = (frame->data[BEACON_INDEX_GTS_SPEC] & GTS_SPEC_PERMIT) ? 1 : 0;
    pdescriptor->LinkQuality = metadata->linkQuality;
    pdescriptor->TimeStamp = metadata->timestamp;
#ifndef IEEE154_SECURITY_ENABLED
    pdescriptor->SecurityFailure = IEEE154_SUCCESS;
    pdescriptor->SecurityLevel = 0;
    pdescriptor->KeyIdMode = 0;
    pdescriptor->KeySource = 0;
    pdescriptor->KeyIndex = 0;    
#else
#error Implementation of BeaconFrame.parsePANDescriptor() needs to be adapted!
#endif
    return SUCCESS;   
  }

  /* ----------------------- FrameUtility, etc. ----------------------- */

  command uint64_t GetLocalExtendedAddress.get()
  {
    return m_aExtendedAddressLE;
  }

  async command void FrameUtility.convertToLE(uint8_t *destLE, const uint64_t *src)
  {
    uint8_t i;
    uint64_t srcCopy = *src;
    for (i=0; i<8; i++) {
      destLE[i] = srcCopy;
      srcCopy >>= 8;
    }
  }

  async command void FrameUtility.convertToNative(uint64_t *dest, const uint8_t *srcLE)
  {
    // on msp430 nxle_uint64_t doesn't work, this is a workaround
    uint32_t lower = *((nxle_uint32_t*) srcLE);
    uint64_t upper = *((nxle_uint32_t*) (srcLE+4));
    *dest = (upper << 32) + lower;

  }

  async command void FrameUtility.copyLocalExtendedAddressLE(uint8_t *destLE)
  {
    call FrameUtility.convertToLE(destLE, &m_aExtendedAddressLE);
  }

  command void FrameUtility.copyCoordExtendedAddressLE(uint8_t *destLE)
  {
    call FrameUtility.convertToLE(destLE, &m_pib.macCoordExtendedAddress);
  }

  bool isLocalExtendedAddress(uint8_t *addrLE)
  {
    uint64_t dest;
    call FrameUtility.convertToNative(&dest, addrLE);
    return dest == m_aExtendedAddressLE;
  }

  bool isCoordExtendedAddress(uint8_t *addrLE)
  {
    uint64_t dest;
    call FrameUtility.convertToNative(&dest, addrLE);
    return dest == m_pib.macCoordExtendedAddress;
  }

  default event void PIBUpdate.notify[uint8_t PIBAttributeID](const void* PIBAttributeValue) {}
  command error_t PIBUpdate.enable[uint8_t PIBAttributeID]() {return FAIL;}
  command error_t PIBUpdate.disable[uint8_t PIBAttributeID]() {return FAIL;}
  async event void RadioToken.transferredFrom(uint8_t fromClient){ASSERT(0);}
}