zdsecmgr.lst

用IAR开发的ZIGBEE网络路由例子

    662            ZStatus_t status;
    663            uint16    index;
    664          
    665          
    666            // initialize results
    667            *entry = NULL;
    668            status = ZNwkUnknownDevice;
    669          
    670            // verify data is available
    671            if ( ZDSecMgrEntries != NULL )
    672            {
    673              for ( index = 0; index < ZDSECMGR_ENTRY_MAX ; index++ )
    674              {
    675                if ( ZDSecMgrEntries[index].ami == ami )
    676                {
    677                  // return successful results
    678                  *entry = &ZDSecMgrEntries[index];
    679                  status = ZSuccess;
    680          
    681                  // break from loop
    682                  index = ZDSECMGR_ENTRY_MAX;
    683                }
    684              }
    685            }
    686          
    687            return status;
    688          }
    689          #endif // defined ( ZDSECMGR_COMMERCIAL )
    690          
    691          #if defined ( ZDSECMGR_COMMERCIAL )
    692          /******************************************************************************
    693           * @fn          ZDSecMgrEntryLookupExt
    694           *
    695           * @brief       Lookup entry index using specified EXT address.
    696           *
    697           * @param       extAddr - [in] EXT address
    698           * @param       entry   - [out] valid entry
    699           *
    700           * @return      ZStatus_t
    701           */
    702          ZStatus_t ZDSecMgrEntryLookupExt( uint8* extAddr, ZDSecMgrEntry_t** entry )
    703          {
    704            ZStatus_t status;
    705            uint16    ami;
    706          
    707          
    708            // initialize results
    709            *entry = NULL;
    710            status = ZNwkUnknownDevice;
    711          
    712            // lookup address index
    713            if ( ZDSecMgrExtAddrLookup( extAddr, &ami ) == ZSuccess )
    714            {
    715              status = ZDSecMgrEntryLookupAMI( ami, entry );
    716            }
    717          
    718            return status;
    719          }
    720          #endif // defined ( ZDSECMGR_COMMERCIAL )
    721          
    722          #if defined ( ZDSECMGR_COMMERCIAL )
    723          /******************************************************************************
    724           * @fn          ZDSecMgrEntryFree
    725           *
    726           * @brief       Free entry.
    727           *
    728           * @param       entry - [in] valid entry
    729           *
    730           * @return      ZStatus_t
    731           */
    732          void ZDSecMgrEntryFree( ZDSecMgrEntry_t* entry )
    733          {
    734            entry->ami = INVALID_NODE_ADDR;
    735          }
    736          #endif // defined ( ZDSECMGR_COMMERCIAL )
    737          
    738          #if defined ( ZDSECMGR_COMMERCIAL )
    739          /******************************************************************************
    740           * @fn          ZDSecMgrEntryNew
    741           *
    742           * @brief       Get a new entry.
    743           *
    744           * @param       entry - [out] valid entry
    745           *
    746           * @return      ZStatus_t
    747           */
    748          ZStatus_t ZDSecMgrEntryNew( ZDSecMgrEntry_t** entry )
    749          {
    750            ZStatus_t status;
    751            uint16    index;
    752          
    753          
    754            // initialize results
    755            *entry = NULL;
    756            status = ZNwkUnknownDevice;
    757          
    758            // verify data is available
    759            if ( ZDSecMgrEntries != NULL )
    760            {
    761              // find available entry
    762              for ( index = 0; index < ZDSECMGR_ENTRY_MAX ; index++ )
    763              {
    764                if ( ZDSecMgrEntries[index].ami == INVALID_NODE_ADDR )
    765                {
    766                  // return successful result
    767                  *entry = &ZDSecMgrEntries[index];
    768                  status = ZSuccess;
    769          
    770                  // break from loop
    771                  index = ZDSECMGR_ENTRY_MAX;
    772                }
    773              }
    774            }
    775          
    776            return status;
    777          }
    778          #endif // defined ( ZDSECMGR_COMMERCIAL )
    779          
    780          #if defined ( ZDSECMGR_COMMERCIAL )
    781          /******************************************************************************
    782           * @fn          ZDSecMgrCtrlInit
    783           *
    784           * @brief       Initialize control sub module
    785           *
    786           * @param       none
    787           *
    788           * @return      none
    789           */
    790          void ZDSecMgrCtrlInit( void )
    791          {
    792            //---------------------------------------------------------------------------
    793            #if defined ( ZDO_COORDINATOR )
    794            //---------------------------------------------------------------------------
    795            uint16 size;
    796            uint16 index;
    797          
    798          
    799            // allocate entry data
    800            size = (short)( sizeof(ZDSecMgrCtrl_t) * ZDSECMGR_CTRL_MAX );
    801          
    802            ZDSecMgrCtrlData = osal_mem_alloc( size );
    803          
    804            // initialize data
    805            if ( ZDSecMgrCtrlData != NULL )
    806            {
    807              for( index = 0; index < ZDSECMGR_CTRL_MAX; index++ )
    808              {
    809                ZDSecMgrCtrlData[index].state = ZDSECMGR_CTRL_NONE;
    810              }
    811            }
    812            //---------------------------------------------------------------------------
    813            #endif // defined ( ZDO_COORDINATOR )
    814            //---------------------------------------------------------------------------
    815          }
    816          #endif // defined ( ZDSECMGR_COMMERCIAL )
    817          
    818          #if defined ( ZDSECMGR_COMMERCIAL )
    819          #if defined ( ZDO_COORDINATOR )
    820          /******************************************************************************
    821           * @fn          ZDSecMgrCtrlRelease
    822           *
    823           * @brief       Release control data.
    824           *
    825           * @param       ctrl - [in] valid control data
    826           *
    827           * @return      none
    828           */
    829          void ZDSecMgrCtrlRelease( ZDSecMgrCtrl_t* ctrl )
    830          {
    831            // should always be enough entry control data
    832            ctrl->state = ZDSECMGR_CTRL_NONE;
    833          }
    834          #endif // defined ( ZDO_COORDINATOR )
    835          #endif // defined ( ZDSECMGR_COMMERCIAL )
    836          
    837          #if defined ( ZDSECMGR_COMMERCIAL )
    838          #if defined ( ZDO_COORDINATOR )
    839          /******************************************************************************
    840           * @fn          ZDSecMgrCtrlLookup
    841           *
    842           * @brief       Lookup control data.
    843           *
    844           * @param       entry - [in] valid entry data
    845           * @param       ctrl  - [out] control data - NULL if not found
    846           *
    847           * @return      none
    848           */
    849          void ZDSecMgrCtrlLookup( ZDSecMgrEntry_t* entry, ZDSecMgrCtrl_t** ctrl )
    850          {
    851            uint16 index;
    852          
    853          
    854            // initialize search results
    855            *ctrl = NULL;
    856          
    857            // verify data is available
    858            if ( ZDSecMgrCtrlData != NULL )
    859            {
    860              for ( index = 0; index < ZDSECMGR_CTRL_MAX; index++ )
    861              {
    862                // make sure control data is in use
    863                if ( ZDSecMgrCtrlData[index].state != ZDSECMGR_CTRL_NONE )
    864                {
    865                  // check for entry match
    866                  if ( ZDSecMgrCtrlData[index].entry == entry )
    867                  {
    868                    // return this control data
    869                    *ctrl = &ZDSecMgrCtrlData[index];
    870          
    871                    // break from loop
    872                    index = ZDSECMGR_CTRL_MAX;
    873                  }
    874                }
    875              }
    876            }
    877          }
    878          #endif // defined ( ZDO_COORDINATOR )
    879          #endif // defined ( ZDSECMGR_COMMERCIAL )
    880          
    881          
    882          #if defined ( ZDSECMGR_COMMERCIAL )
    883          #if defined ( ZDO_COORDINATOR )
    884          /******************************************************************************
    885           * @fn          ZDSecMgrCtrlSet
    886           *
    887           * @brief       Set control data.
    888           *
    889           * @param       device - [in] valid device data
    890           * @param       entry  - [in] valid entry data
    891           * @param       ctrl   - [in] valid control data
    892           *
    893           * @return      none
    894           */
    895          void ZDSecMgrCtrlSet( ZDSecMgrDevice_t* device,
    896                                ZDSecMgrEntry_t*  entry,
    897                                ZDSecMgrCtrl_t*   ctrl )
    898          {
    899            // set control date
    900            ctrl->parentAddr = device->parentAddr;
    901            ctrl->secure     = device->secure;
    902            ctrl->entry      = entry;
    903            ctrl->state      = ZDSECMGR_CTRL_INIT;
    904            ctrl->cntr       = 0;
    905          
    906            // set device pointer
    907            device->ctrl = ctrl;
    908          }
    909          #endif // defined ( ZDO_COORDINATOR )
    910          #endif // defined ( ZDSECMGR_COMMERCIAL )
    911          
    912          #if defined ( ZDSECMGR_COMMERCIAL )
    913          /******************************************************************************
    914           * @fn          ZDSecMgrCtrlAdd
    915           *
    916           * @brief       Add control data.
    917           *
    918           * @param       device - [in] valid device data
    919           * @param       entry  - [in] valid entry data
    920           *
    921           * @return      none
    922           */
    923          ZStatus_t ZDSecMgrCtrlAdd( ZDSecMgrDevice_t* device, ZDSecMgrEntry_t*  entry )