rasamm.c

这是全套的PPP协议的源码

/* rasamm.c - definitions for the RAS Address Management library */

/* Copyright 2001 Wind River Systems, Inc. */

#include "copyright_wrs.h"

/*
modification history
--------------------
01h,15may03,ijm removed adv_net.h
01g,21nov02,ijm use printf instead of logMsg
01f,27aug02,ijm include adv_net.h for IPv6
01e,28jun02,rp  fixed SPR# 74027, address pools can be deleted only in
		the order in which they were created
01d,28may02,rvr fixed build warnings 
01c,03nov01,ijm fixed compiler warnings
01b,29oct01,ijm changed path name for include file from private/ras
                to private/ppp
01a,12jul00,qli created.  Support for ras pmp was originally added to
		open stack version of pppEnd.c
*/

/*
DESCRIPTION
This module provides basic functions to manage pools of IPv4 addresses.  WindNet
PPP uses these functions to manage addresses for the remote access server
demo configuration, in the Project Facility's remote access components.
*/

/* includes */

#include "vxWorks.h"

#include "private/ppp/rasammP.h"
#include "string.h"
#include "logLib.h"

ADDR_POOL_ENTRY *rasAddrPools;
UINT32 rasAddrPoolId;
UINT32 rasNumAddrPool;

typedef struct {
     UINT8 newmask;
     UINT8 hostId;
} HOST_ID_LKUP_ENTRY;

LOCAL HOST_ID_LKUP_ENTRY hostIdLookupTbl[16] = {
     {0x00, 0},
     {0x00, 3},
     {0x00, 2},
     {0x10, 2},
     {0x00, 1},
     {0x10, 1},
     {0x20, 1},
     {0x30, 1},
     {0x00, 0},
     {0x10, 0},
     {0x20, 0},
     {0x30, 0},
     {0x40, 0},
     {0x50, 0},
     {0x60, 0},
     {0x70, 0}
};

LOCAL SEM_ID rasapLock;

LOCAL STATUS rasamm_pool_getfreeAddrs(ADDR_POOL_ENTRY *aptr, UINT32 *freeAddrBuf);
LOCAL STATUS ras_pmpUpdateLkupTbl(UINT32 poolId, UINT32 srcipAddr, UINT32 dstipAddr, 
                                  UINT doInsert, void *drv);


/**********************************************************
 *                                                        *
 *    Internal APIs                                       *
 *                                                        *
 **********************************************************/

/********************************************************************************
*
* rasamm_pool_delete - delete an address pool from the system
*
* This routine deletes an address pool from the Address Management Module (AMM).
* 
* RETURNS: OK on success and ERROR on failure.
*
*/
LOCAL STATUS rasamm_pool_delete(UINT32 poolId, ADDR_POOL_ENTRY *prev)
{
     ADDR_POOL_ENTRY *apptr;

     semTake(rasapLock, WAIT_FOREVER);
     if (prev)
         apptr = prev->next;
     else
     {
         apptr = rasAddrPools;

         /* pool id validation: pools are sorted in ascending order */

         while (apptr && (poolId > apptr->poolId))
         {
             prev = apptr;
             apptr = apptr->next;
         }
         if (!apptr || 
             (apptr->poolId != poolId))
         {
             errnoSet(ERASAMMINVALIDPARM);
             semGive(rasapLock);
             return (ERROR);
         }
         if (apptr->allocated)   /* address pool is still in use */
         {
             errnoSet(ERASAMMDELINPGRES);
             apptr->poolState |= ADDRPOOL_DEL_INPGRES; /* mark for deletion */
             semGive(rasapLock);
             return (ERROR);
         }
     }
     /*
      * delete the address pool
      */
     rasNumAddrPool--;
     if (!prev)    /* removing the 1st entry */
         rasAddrPools = apptr->next;
     else
         prev->next = apptr->next;
     free((void *)apptr->faddrPool);
     if (apptr->supportPMP)
         free((void *)apptr->lkupTbl);
     free((void *)apptr);
     semGive(rasapLock);
     return (OK);     
}


/********************************************************************************
*
* rasamm_pool_getfreeAddrs - get free IP addresses from the address pool
*
* This routine retrieves all of the available IP addresses from a specific
* address pool for inspection.
* 
* RETURNS: OK on success and ERROR on failure.
*
*/
LOCAL STATUS rasamm_pool_getfreeAddrs(ADDR_POOL_ENTRY *aptr, UINT32 *freeAddrBuf)
{
     FAST UINT32 i, j, k, m, mask, index=0;

     if (!freeAddrBuf)
     {
         errnoSet(ERASAMMINVALIDPARM);
         return (ERROR);
     }

     i = aptr->firstFree;
     switch (aptr->poolType)
     {
         case RAS_ADDRM_FASTS_POOL:
	     m = aptr->poolSz;
	     while (i < m)
	     {
	         freeAddrBuf[index++] = i;
		 i = aptr->faddrPool[i];
	     }
             break;
         case RAS_ADDRM_SMALS_POOL:
             k = ((aptr->poolSz+7)&~7) >> 3;
	     j = i << 3;
	     while (i < k)
	     {
             mask = aptr->saddrPool[i];
	         if (mask)
	         {
	             m = 0x80;
		     while (m)
		     {
		         if (mask & m)
		             freeAddrBuf[index++] = j;
		         m >>= 1;
		         j++;
		     }
		 }
		 else
		     j += 8;
		 i++;
	     }
             break;
     }
     return (OK);
}


/**********************************************************
 *                                                        *
 *    External APIs                                       *
 *                                                        *
 **********************************************************/

/********************************************************************************
*
* RAS_AMM_Init - initializatio
*
* This routine initializes the Remote Access Server's Address Management Module.
* 
* RETURNS: OK on success and ERROR on failure.
*
*/
STATUS RAS_AMM_Init()
{
     rasAddrPools = NULL;
     rasAddrPoolId = 0;
     rasNumAddrPool = 0;
     rasapLock = semBCreate(SEM_Q_FIFO, SEM_FULL);
     if (!rasapLock)
         return (ERROR);
     return (OK);
}


/********************************************************************************
*
* RAS_InsAddrPool - add an address pool
*
* This routine inserts an address pool into the system to be managed by the AMM.
* 
* RETURNS: a non-zero integer value as address pool ID on success 
*          and 0 on failure.
*
*/
UINT32 RAS_InsAddrPool(UINT32 routerId,
                       UINT32 ipAddr,
                       UINT   prefixLen, 
                       UINT32 poolSz,
                       UINT   mMethod,
                       UINT   supportPMP,
                       UINT   pmpLkupTblSz)
{
     RAS_PMP_MUX_ENTRY **lkupTbl=NULL;
     ADDR_POOL_ENTRY **addrpptr, *aptr;
     UINT32 addrSpace;
     UINT32 *addrPool;
     UINT8  *sadrPool;
     UINT32 poolId;
     UINT32 mask;
     FAST UINT32 i=0, j=0;

     if (!prefixLen)
         return (0);
     /*
      * host address space should be as large as pool size
      */
     mask = IPV4_ADDR_BITS >> prefixLen;
     addrSpace = mask + 1 - (mask & ipAddr);
     if ( addrSpace < poolSz )
         return (0);
     /*
      * create the address pool
      */
     addrpptr = NULL;
     aptr = (ADDR_POOL_ENTRY *)malloc(sizeof(*rasAddrPools));
     if (!aptr)
     {
         errnoSet(ERASAMMNOMEMORY);
         return (0);
     }
     addrPool = NULL;
     sadrPool= NULL;
     switch (mMethod)
     {
         case RAS_ADDRM_FASTS_POOL:
             addrPool = (UINT32 *)malloc(poolSz * 4);
             break;
         case RAS_ADDRM_SMALS_POOL:
	     i = (poolSz+7) & ~7;
	     j = i - poolSz;
	     i >>= 3;
             addrPool = (UINT32 *)malloc(i);
             break;
         default:
             errnoSet(ERASAMMINVALIDPARM);
             break;
     }
     if (!addrPool)
     {
         errnoSet(ERASAMMNOMEMORY);
         free(aptr);
         return (0);
     }
     if (supportPMP)
     {
         lkupTbl = (RAS_PMP_MUX_ENTRY **)malloc(pmpLkupTblSz * sizeof(void *));
         if (!lkupTbl)
         {
             errnoSet(ERASAMMNOMEMORY);
             free(aptr);
             free(addrPool);
             return (0);
         }
         memset(lkupTbl, 0, pmpLkupTblSz * sizeof(void *));
     }
     /*
      */
     semTake(rasapLock, WAIT_FOREVER);
     addrpptr = &rasAddrPools;
     while (*addrpptr)
         addrpptr = &((*addrpptr)->next);
     *addrpptr = aptr;
     aptr->poolId = rasAddrPoolId;
     aptr->next = NULL;
     rasAddrPoolId++;     /* global allocation pool id */
     rasNumAddrPool++;
     /*
      */
     aptr->prefixLen   = prefixLen;
     aptr->poolState   = 0;
     aptr->poolType    = mMethod;
     aptr->routerId    = routerId;
     aptr->firstIpAddr = ipAddr;
     aptr->poolSz      = poolSz;
     aptr->allocated   = 0;
     aptr->faddrPool   = addrPool;
     aptr->supportPMP  = supportPMP;
     aptr->exportedDrv = NULL;
     aptr->numDrvs     = 0;
     aptr->lkupTblSz   = pmpLkupTblSz;
     aptr->lkupTbl     = lkupTbl;
     /*
      */
     aptr->firstFree = 0;
     switch (mMethod)
     {
         case RAS_ADDRM_FASTS_POOL:
             for (i=0, j=1; i < poolSz; i++, j++)
                 addrPool[i] = j;
             break;
         case RAS_ADDRM_SMALS_POOL:
             sadrPool = (UINT8 *)addrPool;
             memset((void *)sadrPool, 0xFF, i);
             sadrPool[i-1] = 0xFF << j;
             break;
     }
     poolId = aptr->poolId + 1;
     semGive(rasapLock);
     return (poolId);
}


/********************************************************************************
*
* RAS_DelAddrPool - deletes an address pool
*
* This routine deletes an address pool from the Address Management Module (AMM).
* 
* RETURNS: OK on success and ERROR on failure.
*
*/
STATUS RAS_DelAddrPool(UINT32 poolId)
{
     return (rasamm_pool_delete(--poolId, NULL));
}


/********************************************************************************
*
* RAS_GetIpAddr - get an IP address
*
* This routine retrieves an IP address, if available, from an address pool for
* use in an connection in progress.
* 
* RETURNS: OK on success and ERROR on failure.
*
*/
STATUS RAS_GetIpAddr(UINT32 poolId, UINT32 *routerId, UINT32 *ipAddr)
{
     ADDR_POOL_ENTRY *apptr;
     UINT32 hostid;
     FAST UINT32 i, j, mask;

     semTake(rasapLock, WAIT_FOREVER);
     poolId--;
     apptr = rasAddrPools;

     /* pool id validation: pools are sorted in ascending order */

     while (apptr && (poolId > apptr->poolId))
         apptr = apptr->next;
     if (!apptr || 
         (apptr->allocated == apptr->poolSz) ||
         (apptr->poolId != poolId))
     {
         errnoSet(ERASAMMINVALIDPARM);
         semGive(rasapLock);
         return (ERROR);
     }
     /*
      * if the pool is being deleted, then no more allocations 
      */
     if (apptr->poolState & ADDRPOOL_DEL_INPGRES)
     {
         errnoSet(ERASAMMDELINPGRES);
         semGive(rasapLock);
         return (ERROR);
     }
     /*
      * actual allocation
      */
     apptr->allocated++;
     switch (apptr->poolType)
     {
         case RAS_ADDRM_FASTS_POOL:
             hostid = apptr->firstFree;
             apptr->firstFree = apptr->faddrPool[hostid]; /* next in line */
             apptr->faddrPool[hostid] = 0;                /* in use */
             break;
         case RAS_ADDRM_SMALS_POOL:
             i = apptr->firstFree;
             mask = apptr->saddrPool[i];
             j = (mask & 0xF0) >> 4;  
             if (!j)  /* upper empty */
             { 
                 j = mask & 0x0F;     /* lower */
                 mask = hostIdLookupTbl[j].newmask;
                 apptr->saddrPool[i] = mask >> 4;
                 hostid = hostIdLookupTbl[j++].hostId;
                 i = (i << 1) + 1;
             }
             else    /* upper available */