rasamm.c

这是全套的PPP协议的源码

             {
                 mask = (mask & 0x0F) | hostIdLookupTbl[j].newmask;
                 apptr->saddrPool[i] = mask;
                 hostid = hostIdLookupTbl[j++].hostId; 
                 i <<= 1;
             }
             hostid += i << 2;
             if (apptr->allocated == apptr->poolSz)
                 apptr->firstFree++;
             else
             {
                 if (!mask)   /* this slot is now empty */
                 {   
                     i = ((apptr->poolSz+7)&~7) >> 3;
                     j = apptr->firstFree+1;
                     while (j < i)
                     {
                         if (apptr->saddrPool[j])
                             break;
                         else
                             j++;
                     }
                     apptr->firstFree = j;
                 }
             }
             break;
         default:
             errnoSet(ERASAMMINVALIDPARM);
             semGive(rasapLock);
             return (ERROR);
     }
     /*
      * return results
      */
     *ipAddr   = apptr->firstIpAddr + hostid;
     *routerId = apptr->routerId;
     semGive(rasapLock);                
     return (OK);     
}


/********************************************************************************
*
* RAS_RelIpAddr - returns an IP address
*
* This routine releases an IP address back into the address pool for reuse
* after a connection has been terminated.
* 
* RETURNS: OK on success and ERROR on failure.
*
*/
STATUS RAS_RelIpAddr(UINT32 poolId, UINT32 ipAddr)
{
     ADDR_POOL_ENTRY *apptr, *prev;
     UINT32 hostid;
     FAST UINT32 i, j;

     /*
      * pool id validation
      */
     semTake(rasapLock, WAIT_FOREVER);
     poolId--;
     prev = 0;     
     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) ||
         (ipAddr < apptr->firstIpAddr))   /* ip address validation */
     {
         errnoSet(ERASAMMINVALIDPARM);
         semGive(rasapLock);
         return (ERROR);
     }
     /*
      * ip address validation
      */
     hostid = ipAddr - apptr->firstIpAddr;
     if (hostid >= apptr->poolSz)
     {
         errnoSet(ERASAMMINVALIDPARM);
         semGive(rasapLock);
         return (ERROR);
     }
     /*
      * change pool state
      */
     apptr->allocated--;
     switch (apptr->poolType)
     {
         case RAS_ADDRM_FASTS_POOL:
             apptr->faddrPool[hostid] = apptr->firstFree;
             apptr->firstFree = hostid;
             break;
         case RAS_ADDRM_SMALS_POOL:
             i = hostid >> 3;
             j = hostid - (i << 3);
             apptr->saddrPool[i] = apptr->saddrPool[i] | (0x80 >> j);
             if (i < apptr->firstFree)
                 apptr->firstFree = i;
             break;
     }
     semGive(rasapLock);
     /*
      * if previously marked for deletion and 
      * the last IP address has just been returned
      * then go ahead with the delete
      */
     if (!apptr->allocated && 
         (apptr->poolState & ADDRPOOL_DEL_INPGRES))
     {
         return (rasamm_pool_delete(poolId, prev));
     }
     return (OK);    
}


/********************************************************************************
*
* RAS_Ioctl - I/O control commands
*
* This routine supports various I/O control commands for retrieving information
* about the AMM as a whole or address pool specific information.
* 
* RETURNS: OK on success and ERROR on failure.
*
*/
STATUS RAS_Ioctl(UINT32 command, RASAMM_IOCTL_ARG *arg)
{
     STATUS error = OK;
     ADDR_POOL_ENTRY *apptr;

     semTake(rasapLock, WAIT_FOREVER);

     switch (command)
     {
         case RASIOCGETTOTALNUMPOOLS:
              arg->info.numPools = rasNumAddrPool;
              break;

         case RASIOCGETMAXPOOLID:
              arg->info.maxPoolId = rasAddrPoolId;
              break;

         case RASIOCGETADDRPOOLSZ:
         case RASIOCGETIPADDRPREFIX:
         case RASIOCGETROUTERID:
         case RASIOCGETFIRSTIPADDR:
         case RASIOCGETNUMFREEADDRS:
         case RASIOCGETGETFREEADDRS:
         case RASIOCGETPMPSUPPORT:
         case RASIOCGETEXPTDDRIVER:
         case RASIOCSETEXPTDDRIVER:
         case RASIOCGETNUMDRIVERS:
              apptr = rasAddrPools;

              /* pools are sorted in ascending order */

              while (apptr && (arg->poolId > apptr->poolId))
                  apptr = apptr->next;
              if (!apptr || (apptr->poolId != arg->poolId))
              {
                  error = ERROR;
                  errnoSet(ERASAMMINVALIDPARM);
                  break;
              }
              if (command == RASIOCGETADDRPOOLSZ)
                  arg->info.poolSz = apptr->poolSz;
              else if (command == RASIOCGETIPADDRPREFIX)
                  arg->info.prefxLen = apptr->prefixLen;
              else if (command == RASIOCGETROUTERID)
                  arg->info.routerId = apptr->routerId;
              else if (command == RASIOCGETFIRSTIPADDR)
                  arg->info.firstIp = apptr->firstIpAddr;
              else if (command == RASIOCGETNUMFREEADDRS)
                  arg->info.numFreeAddr = apptr->poolSz - apptr->allocated;
              else if (command == RASIOCGETPMPSUPPORT)
                  arg->info.supportPMP = apptr->supportPMP;
              else if (command == RASIOCGETEXPTDDRIVER)
                  arg->info.exportedDrv = apptr->exportedDrv;
              else if (command == RASIOCSETEXPTDDRIVER)
                  apptr->exportedDrv = arg->info.exportedDrv;
              else if (command == RASIOCGETGETFREEADDRS)
                  error = rasamm_pool_getfreeAddrs(apptr, arg->info.freeAddrs);
              else if (command == RASIOCGETNUMDRIVERS)
                  arg->info.numDrvs = apptr->numDrvs;
              break;

         default:
              error = ERROR;
              errnoSet(ERASAMMINVLDCOMMAND);
              break;
     }
     semGive(rasapLock);
     return (error);
}


/********************************************************************************
*
* RAS_getNumOfPools
*
* Utility function retrieves the number of address pools in the system.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
UINT32 RAS_getNumOfPools(int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     if (RAS_Ioctl(RASIOCGETTOTALNUMPOOLS, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getNumOfPools) --> %x\n", errnoGet()); 
         return (0);
         }
     if (doprintf)
         printf ("Total number of Address Pools in the System: %d\n", 
                arg.info.numPools);
     return (arg.info.numPools);
}


/********************************************************************************
*
* RAS_getMaxPoolId
*
* Utility function retrieves the maximum identification value used for address
* pools.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
UINT32 RAS_getMaxPoolId(int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     if (RAS_Ioctl(RASIOCGETMAXPOOLID, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getMaxPoolId) --> %x\n",
                 errnoGet()); 
         return (0);
         }
     if (doprintf)
         printf ("Maximum Address Pool ID in the System: %d\n",
                arg.info.maxPoolId);
     return (arg.info.maxPoolId);
}


/********************************************************************************
*
* RAS_getAddrPoolSize
*
* Utility function retrieves the number of IP addresses that exists in a 
* particular address pool.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
UINT32 RAS_getAddrPoolSize(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETADDRPOOLSZ, &arg) == ERROR)
         {
          printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolSize) --> %x\n",
                errnoGet()); 
         return (0);
         }
     if (doprintf)
         printf ("Address Pool (#%d) contains --> %d IP addresses\n",
                poolId, arg.info.poolSz);
     return (arg.info.poolSz);
}


/********************************************************************************
*
* RAS_getAddrPoolPrefix
*
* Utility function retrieves the address prefix used for an address pool.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
UINT32 RAS_getAddrPoolPrefix(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETIPADDRPREFIX, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolPrefix) --> %x\n",
                errnoGet()); 
         return (0);
         }
     if (doprintf)
         printf ("Address Pool (#%d) prefix length: %d\n",
                poolId, arg.info.prefxLen);
     return (arg.info.prefxLen);
}


/********************************************************************************
*
* RAS_getAddrPoolRouterid
*
* Utility function retrieves the router-id of the address pool.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
UINT32 RAS_getAddrPoolRouterId(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;
     struct in_addr ipaddr;
     char ipString [INET_ADDR_LEN];

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETROUTERID, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolRouterId) --> %x\n",
                errnoGet()); 
         return (0);
         }
     if (doprintf)
         {
         ipaddr.s_addr = htonl(arg.info.routerId);
         inet_ntoa_b (ipaddr, ipString);
         printf ("Address Pool (#%d) Router-ID: %s\n", poolId, ipString);
         }
     return (arg.info.routerId);
}


/********************************************************************************
*
* RAS_getAddrPoolFirstIp
*
* Utility function retrieves the starting IP address of the address pool.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
UINT32 RAS_getAddrPoolFirstIp(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;
     struct in_addr ipaddr;
     char ipString [INET_ADDR_LEN];

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETFIRSTIPADDR, &arg) == ERROR)
     {
         printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolFirstIp) --> %x\n",
                errnoGet()); 
         return (0);
     }
     if (doprintf)
         {
         ipaddr.s_addr = htonl(arg.info.firstIp);
         inet_ntoa_b (ipaddr, ipString);
         printf ("Address Pool (#%d) First IP addr: %s\n", poolId, ipString);
         }
     return (arg.info.firstIp);
}


/********************************************************************************
*
* RAS_getAddrPoolNumFreeAddrs
*
* Utility function retrieves all of the free IP addresses from an address pool.
* 
* RETURNS: non-zero integer on success and 0 on failure.
*
*/
UINT32 RAS_getAddrPoolNumFreeAddrs(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETNUMFREEADDRS, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolNumFreeAddrs) --> %x\n",
                errnoGet()); 
         return (0);
         }
     if (doprintf)
         printf ("Address Pool (#%d) Number of Free IP Addresses: %d\n",
                poolId, arg.info.numFreeAddr);
     return (arg.info.numFreeAddr);
}


/********************************************************************************
*
* RAS_getAddrPoolPMPmode
*
* Utility function that retrieves the status of Point-to-Multipoint support in
* an address pool.
*
* RETURNS: 1 = PMP supported, 0 = PMP not supported / ERROR
*
*/
UINT32 RAS_getAddrPoolPMPmode(UINT32 poolId, int doprintf)
{
     RASAMM_IOCTL_ARG arg;
     char YES[]="YES";
     char NO[]="NO";

     arg.poolId = --poolId;
     if (RAS_Ioctl(RASIOCGETPMPSUPPORT, &arg) == ERROR)
         {
         printf ("RAS_UTILS_ERROR: (RAS_getAddrPoolPMPmode) --> %x\n",
                errnoGet()); 
         return (0);
         }
     if (doprintf)
         printf ("Address Pool #%d support PMP: %s\n",
                 poolId,  (arg.info.supportPMP ? YES : NO));
     return (arg.info.supportPMP);
}