rasamm.c

这是全套的PPP协议的源码

/********************************************************************************
*
* RAS_getAddrPoolexptDrv
*
* Utility function that retrieves the drv exported to the protocol stack.
*
* RETURNS: the driver or NULL on ERROR
*
*/
void *RAS_getAddrPoolexptDrv(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETEXPTDDRIVER, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolexptDrv) --> %x\n",
                errnoGet()); 
         return (0);
         }
     if (doprintf)
        printf  ("Address Pool #%d Export Driver PMP: 0x%x\n",
                  poolId, (UINT32)arg.info.exportedDrv);
     return (arg.info.exportedDrv);
}


/********************************************************************************
*
* RAS_setAddrPoolexptDrv
*
* Utility function that sets the exported drv field.
*
* RETURNS: OK or ERROR
*
*/
STATUS RAS_setAddrPoolexptDrv(UINT32 poolId, void *drv, int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     arg.poolId = --poolId;
     arg.info.exportedDrv = drv;
     if (RAS_Ioctl(RASIOCSETEXPTDDRIVER, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_setAddrPoolexptDrv) --> %x\n",
                errnoGet()); 
	 	 return (ERROR);
         }
     if (doprintf)
         printf ("Address Pool #%d Export Driver PMP: 0x%x\n",
                poolId, (UINT32)arg.info.exportedDrv);
     return (OK);
}


/********************************************************************************
*
* RAS_getAddrPoolNumDrvs
*
* Utility function for retrieving the number of multiplexed drivers in the
* address pool.
*
* RETURNS: none 0 value or 0 on ERROR
*
*/
UINT32 RAS_getAddrPoolNumDrvs(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETNUMDRIVERS, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolNumDrvs) --> %x\n",
                errnoGet()); 
	 	 return (0);
         }
     if (doprintf)
         printf ("Address Pool #%d contains %d drivers\n",
                 poolId, arg.info.numDrvs);
     return (arg.info.numDrvs);
}


/********************************************************************************
*
* RAS_getAddrPool1stDrv
*
* Utility function for retrieving the 1st multiplexed driver in the list.
*
* RETURNS: 1st driver or NULL on ERROR
* 
*/
void *RAS_getAddrPool1stDrv(UINT32 poolId, UINT32 *srcipAddr, UINT32 *dstipAddr, int doprintf)
{
     ADDR_POOL_ENTRY *apptr;
     RAS_PMP_MUX_ENTRY *muxptr=NULL;
     void *drv=NULL;
     register UINT32 i;

     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 (NULL);
     }
     if ((!apptr->supportPMP) || (!apptr->lkupTbl))
     {
         errnoSet(ERASAMMNOPMPLKUPTBL);
         semGive(rasapLock);
         return (NULL);
     }
     for (i=0; i < apptr->lkupTblSz; i++)
     {
         muxptr = apptr->lkupTbl[i];
         if (muxptr)
         {
             *srcipAddr = muxptr->srcipAddr;
             *dstipAddr = muxptr->dstipAddr;
             drv = muxptr->drv;
             break;
         }
     }
     if (doprintf)
         printf ("Address Pool #%d Export Driver PMP: 0x%x\n",
                 poolId, (UINT32)muxptr);
     semGive(rasapLock);
     return (drv);
}


/********************************************************************************
*
* RAS_printAddrPoolInfo
*
* Utility function prints out all of the relevant information on an address pool.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
void RAS_printAddrPoolInfo(UINT32 poolId)
{
     int doprintf=1;
     UINT32 firstIp;
     UINT32 poolSz, numIpAddrs;
     RASAMM_IOCTL_ARG arg;
     FAST UINT32 i;
     struct in_addr ipaddr;
     char ipString [INET_ADDR_LEN];

     printf ("\n");
     if (!(RAS_getAddrPoolPrefix(poolId, doprintf)))
         return;
     if (!(RAS_getAddrPoolRouterId(poolId, doprintf)))
         return;
     firstIp = RAS_getAddrPoolFirstIp(poolId, doprintf);
     if (!firstIp)
         return;
     poolSz = RAS_getAddrPoolSize(poolId, doprintf);
     if (!poolSz)
         return;
     numIpAddrs = RAS_getAddrPoolNumFreeAddrs(poolId, doprintf);
     if (poolSz == numIpAddrs)
         printf ("All addresses are available in this address pool.\n");
     arg.poolId = poolId-1;
     arg.info.freeAddrs = (UINT32 *)malloc(numIpAddrs * 4);
     if (!arg.info.freeAddrs)
         {
         printf ("can not allocate memory for retrieving IP addresses!\n");
         return;
         }
     if (RAS_Ioctl(RASIOCGETGETFREEADDRS, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RASIOCGETGETFREEADDRS) --> %x\n",
                errnoGet()); 
         return;
         }
     for (i=0; i < numIpAddrs; i++)
         {
         ipaddr.s_addr = htonl(arg.info.freeAddrs[i]+firstIp);
         inet_ntoa_b (ipaddr, ipString);
         printf ("\t\tIP: %s\n", ipString);
         }
     free(arg.info.freeAddrs);
}


/********************************************************************************
*
* ras_pmpUpdateLkupTbl
*
* This function is called to insert a multiplexed driver into or removing it from
* an address pool.
*
* RETURNS: OK or ERROR
*
*/
LOCAL STATUS ras_pmpUpdateLkupTbl(UINT32 poolId, UINT32 srcipAddr, UINT32 dstipAddr, 
                                  UINT doInsert, void *drv)
{
     ADDR_POOL_ENTRY *apptr;
     RAS_PMP_MUX_ENTRY **muxptr, *nptr;

     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 ((!apptr->supportPMP) || (!apptr->lkupTbl))
     {
         errnoSet(ERASAMMNOPMPLKUPTBL);
         semGive(rasapLock);
         return (ERROR);
     }
     /*
      * insert into the lookup table
      */
     muxptr = &(apptr->lkupTbl[(dstipAddr % apptr->lkupTblSz)]);
     if (doInsert)
     {
         nptr = (RAS_PMP_MUX_ENTRY *)malloc(sizeof(*nptr));
         if (!nptr)
         {
             errnoSet(ERASAMMNOMEMORY);
             semGive(rasapLock);
             return (ERROR);
         }
         if (apptr->exportedDrv == NULL)
             apptr->exportedDrv = drv;
         nptr->next = NULL;
         nptr->srcipAddr = srcipAddr;
         nptr->dstipAddr = dstipAddr;
         nptr->drv = drv;
         while (*muxptr)
             muxptr = &((*muxptr)->next);
         *muxptr = nptr;
         apptr->numDrvs++;
     }
     /*
      * delete from the lookup table
      */
     else
     {
         while (*muxptr)
         {
             if ((*muxptr)->dstipAddr == dstipAddr)
                 break;
             muxptr = &((*muxptr)->next);
         } 
         if (!(*muxptr))
         {
             errnoSet(ERASAMMINVALIDPARM);
             semGive(rasapLock);
             return (ERROR);
         }
         nptr = *muxptr;
         *muxptr = nptr->next;
         if (nptr->drv == apptr->exportedDrv)
             apptr->exportedDrv = NULL;
         free(nptr);   
         apptr->numDrvs--;
     }
     semGive(rasapLock);
     return (OK);
}


/********************************************************************************
*
* RAS_pmpInsertDriver
*
* Insert a multiplexed driver into an address pool.
*
* RETURNS: OK or ERROR
*/
STATUS RAS_pmpInsertDriver(UINT32 poolId, UINT32 srcipAddr, UINT32 dstipAddr, void *drv)
{
     return (ras_pmpUpdateLkupTbl(poolId, srcipAddr, dstipAddr, 1, drv));
}


/********************************************************************************
*
* RAS_pmpRemoveDriver
*
* Remove a multiplexed driver from an address pool.
*
* RETURNS: OK or ERROR
*
*/
STATUS RAS_pmpRemoveDriver(UINT32 poolId, UINT32 dstipAddr)
{
     return (ras_pmpUpdateLkupTbl(poolId, 0, dstipAddr, 0, NULL));
}


/********************************************************************************
*
* RAS_pmpGetDriver
*
* Utility function used to obtain the multiplexed driver associated with a
* particular host.
* 
* RETURNS: the driver or NULL on error
*
*/
void *RAS_pmpGetDriver(UINT32 poolId, UINT32 dstipAddr)
{
     ADDR_POOL_ENTRY *apptr;
     RAS_PMP_MUX_ENTRY *nptr;

     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 (NULL);
     }
     if ((!apptr->supportPMP) || (!apptr->lkupTbl))
     {
         errnoSet(ERASAMMNOPMPLKUPTBL);
         semGive(rasapLock);
         return (NULL);
     }
     nptr = apptr->lkupTbl[(dstipAddr % apptr->lkupTblSz)];
     while (nptr)
     {
         if (nptr->dstipAddr == dstipAddr)
             break;
         nptr = nptr->next;
     }
     semGive(rasapLock);
     if (nptr)
         return (nptr->drv);
     return (NULL);
}


/********************************************************************************
*
* RAS_pmpAddrPoolDrvsInit
*
* Utility function used to reinitialize all of the multiplexed drivers when
* the exported on is modified.
* 
* RETURNS: OK or ERROR
*
*/
STATUS RAS_pmpAddrPoolDrvsInit(UINT32 poolId, void (*callback)(void *, void*))
{
     ADDR_POOL_ENTRY *apptr;
     RAS_PMP_MUX_ENTRY *muxptr=NULL;
     void *exportedDrv=NULL;
     register UINT32 i;

     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 ((!apptr->supportPMP) || (!apptr->lkupTbl))
     {
         errnoSet(ERASAMMNOPMPLKUPTBL);
         semGive(rasapLock);
         return (ERROR);
     }
     exportedDrv = apptr->exportedDrv;
     if (!exportedDrv)
     {
         errnoSet(ERASAMMINVALIDPARM);
         semGive(rasapLock);
         return (ERROR);
     }
     for (i=0; i < apptr->lkupTblSz; i++)
     {
         muxptr = apptr->lkupTbl[i];
         while (muxptr)
         {
             callback(exportedDrv, muxptr->drv);
             muxptr = muxptr->next;
         }
     }
     semGive(rasapLock);
     return (OK);
}