dhcpslib.c

vxworks源码源码解读是学习vxworks的最佳途径

STATUS dhcpsInit
    (
    struct ifnet **	ppIf, 		/* network devices used by server */
    int			numDev, 	/* number of devices */
    DHCPS_LEASE_DESC *	pLeasePool, 	/* table of lease data */
    int                 poolSize, 	/* size of data table */
    DHCPS_RELAY_DESC *  pRelayTbl, 	/* table of relay agent data */
    int                 relaySize, 	/* size of relay agent table */
    DHCP_TARGET_DESC *	pTargetTbl, 	/* table of receiving DHCP servers */
    int                 targetSize
    )
    {
    struct if_info *pIf = NULL;          /* pointer to interface */
    struct ifreq ifreq;
    struct sockaddr_in send_addr;
    int loop;
    STATUS status;

    if (ppIf == NULL)
        return (ERROR);

    if (numDev == 0)
        return (ERROR);

    dhcpsMutexSem = semBCreate (SEM_Q_FIFO, SEM_FULL);
    if (dhcpsMutexSem == NULL)
        return (ERROR);

    bzero ( (char *)&ifreq, sizeof (ifreq));
 
    srand (taskIdSelf ());

    for (loop = 0; loop < numDev; loop++)
        {
        pIf = (struct if_info *)calloc (1, sizeof (struct if_info));
        if (pIf == NULL) 
            {
            logMsg ("Memory allocation error.\n", 0, 0, 0, 0, 0, 0);
            dhcpsCleanup (1); 
            return (ERROR);
            }
        pIf->buf = (char *)memalign (4, DHCP_MSG_SIZE + DHCPS_OFF);
        if (pIf->buf == NULL)
            {
            logMsg ("Memory allocation error.\n", 0, 0, 0, 0, 0, 0);
            dhcpsCleanup (1); 
            return (ERROR);
            }
        bzero (pIf->buf, DHCP_MSG_SIZE + DHCPS_OFF);

        pIf->next = dhcpsIntfaceList;
        dhcpsIntfaceList = pIf;

        /* Fill in device name and hardware address. */

        sprintf (pIf->name, "%s", ppIf[loop]->if_name);
        pIf->unit = ppIf[loop]->if_unit;
        pIf->htype = ETHER;
        pIf->hlen = _ETHERADDRLEN;

        bcopy ( (char *) ( (struct arpcom *)ppIf[loop])->ac_enaddr,
                          (char *)&pIf->haddr, pIf->hlen); 
        }

    /* Access address pool data. */

    pDhcpsLeasePool = pLeasePool;

    pDhcpsRelaySourceTbl = pRelayTbl;

    pDhcpRelayTargetTbl = pTargetTbl;

    status = read_addrpool_db (poolSize);  /* read address pool database */
    if (status == ERROR) 
        {
        dhcpsCleanup (2); 
        return (ERROR);
        }

    status = read_addrpool_file ();  /* retrieve additional address entries */
    if (status == ERROR)
        {
        dhcpsCleanup (2); 
        return (ERROR);
        }
    status = read_bind_db ();        /* read binding database */
    if (status == ERROR)
        {
        dhcpsCleanup (3);
        return (ERROR);
        }
     
    if (relaySize != 0)
        read_relay_db (relaySize);     /* read database of relay agents */

    /* read database of DHCP servers */

    if (targetSize != 0)
        read_server_db (targetSize);

    /* Always use default ports for client and server. */

    dhcps_port = htons (dhcpSPort);
    dhcpc_port = htons (dhcpCPort);

    /* Create a normal socket for sending messages across networks. */

    dhcpsIntfaceList->fd = socket (AF_INET, SOCK_DGRAM, 0);
    if (dhcpsIntfaceList->fd < 0)
        {
        dhcpsCleanup (4); 
        return (ERROR);
        }

    bzero ( (char *)&send_addr, sizeof (send_addr));
    send_addr.sin_family = AF_INET;
    send_addr.sin_addr.s_addr = htonl (INADDR_ANY);
    send_addr.sin_port = dhcps_port;
    status = bind (dhcpsIntfaceList->fd, (struct sockaddr *) &send_addr, 
                   sizeof (send_addr));
    if (status < 0)
        {
        dhcpsCleanup (5);
        return (ERROR);
        }

    /* Fill in subnet mask and IP address for each monitored interface. */

    pIf = dhcpsIntfaceList;
    while (pIf != NULL)
        { 
        if (open_if (pIf) < 0) 
            {
            dhcpsCleanup (5);
            return (ERROR);
            }
        pIf = pIf->next;
        }

    /* Create buffers for outgoing messages. */

    if (alloc_sbuf () != OK)
        {
        logMsg ("Error: Couldn't allocate memory.\n", 0, 0, 0, 0, 0, 0);
        dhcpsCleanup (5);  
        return (ERROR);
        }

    dhcpEventRing = rngCreate (EVENT_RING_SIZE);
    if (dhcpEventRing == NULL)
        {
        logMsg ("Error: Couldn't create event ring.\n", 0, 0, 0, 0, 0, 0);
        dhcpsCleanup (6);
        return (ERROR);
        }

    dhcpMsgRing = rngCreate (MESSAGE_RING_SIZE);
    if (dhcpMsgRing == NULL)
        {
        logMsg ("Error: Couldn't create message ring.\n", 0, 0, 0, 0, 0, 0);
        dhcpsCleanup (7);
        return (ERROR);
        }

    dhcpEventSem = semCCreate (SEM_Q_FIFO, 0); 
    if (dhcpEventSem == NULL)
        {
        logMsg("Error: Couldn't create semaphore.\n", 0, 0, 0, 0, 0, 0);
        dhcpsCleanup (8);
        return (ERROR);
        }

    return (OK);
    }

/*******************************************************************************
*
* dhcpsCleanup - remove data structures
* 
* This routine frees all dynamically allocated memory obtained by the DHCP 
* server.  It is called at multiple points before the program exits due to
* an error occurring or manual shutdown.  The checkpoint parameter indicates 
* which data structures have been created.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

void dhcpsCleanup 
    (
    int checkpoint 	/* Progress identifier indicating created resources */
    )
    {
    int current = 0;
    struct if_info *pIf;
    struct dhcp_resource * 	pResData;
    struct hash_member * 	pListElem;
    struct hash_member * 	pHashElem;
    struct hash_tbl * 		pHashTbl;
    struct dhcp_binding * 	pBindData;
    struct relay_acl * 		pRelayData;
    DHCP_SERVER_DESC * 		pSrvData;

    int loop;
    BOOL bsdDrvFlag = TRUE;

    semDelete (dhcpsMutexSem);               /* Checkpoint 0 */
    current++;
    if (current > checkpoint)
        return;
                                             /* Checkpoint 1 */
    if (checkpoint >= 5)     /* Close socket descriptor if present.  */
        close (dhcpsIntfaceList->fd);

    while (dhcpsIntfaceList != NULL)
        {
        pIf = dhcpsIntfaceList;
        if (pIf->buf != NULL)
            free (pIf->buf);

        if (checkpoint >= 10) 	/* Remove active input hooks. */
            {
            if (muxDevExists (pIf->name, pIf->unit))
                etherInputHookDelete (dhcpsInputHook, pIf->name, pIf->unit);
            else if (bsdDrvFlag)
                {
                /* Delete hook for BSD 4.4 drivers. */

                etherInputHookDelete (dhcpsInputHook, NULL, pIf->unit);
                bsdDrvFlag = FALSE;                 
                }
            }
        dhcpsIntfaceList = dhcpsIntfaceList->next;
        free (pIf);
        }
    current++;
    if (current > checkpoint)
        return;
   
    while (reslist != NULL)                  /* Checkpoint 2 */
        {
        pListElem = reslist;
        pResData = pListElem->data;
        reslist = reslist->next;
        dhcpsFreeResource (pResData);
        free (pListElem);
        }

    pHashTbl = &nmhashtable;
    for (loop = 0; loop < HASHTBL_SIZE; loop++)
        {
        pHashElem = (pHashTbl->head) [loop];

        while (pHashElem != NULL)
            {
            pListElem = pHashElem;
            pHashElem = pHashElem->next;
            free (pListElem);
            }
        }

    pHashTbl = &iphashtable;
    for (loop = 0; loop < HASHTBL_SIZE; loop++)
        {
        pHashElem = (pHashTbl->head) [loop];

        while (pHashElem != NULL)
            {
            pListElem = pHashElem;
            pHashElem = pHashElem->next;
            free (pListElem);
            }
        }

    /*
     * For the hash table holding additional parameters, also remove ID 
     * records (i.e. bindings), since these are not added to the bindlist.
     */

    pHashTbl = &paramhashtable;
    for (loop = 0; loop < HASHTBL_SIZE; loop++)
        {
        pHashElem = (pHashTbl->head) [loop];

        while (pHashElem != NULL)
            {
            pListElem = pHashElem;
            if (pHashElem->data != NULL)
                free (pHashElem->data);
            pHashElem = pHashElem->next;
            free (pListElem);
            }
        }
    current++;                      
    if (current > checkpoint)
        return;

    while (bindlist != NULL)                 /* Checkpoint 3 */
        {
        pListElem = bindlist;
        pBindData = bindlist->data;
        bindlist = bindlist->next;
        free (pBindData);
        free (pListElem);
        }

    pHashTbl = &cidhashtable;
    for (loop = 0; loop < HASHTBL_SIZE; loop++)
        {
        pHashElem = (pHashTbl->head) [loop];

        while (pHashElem != NULL)
            {
            pListElem = pHashElem;
            pHashElem = pHashElem->next;
            free (pListElem);
            }
        }
    current++;
    if (current > checkpoint)
        return;

    pHashTbl = &relayhashtable;             /* Checkpoint 4 */
    for (loop = 0; loop < HASHTBL_SIZE; loop++)
        {
        pHashElem = (pHashTbl->head) [loop];

        while (pHashElem != NULL)
            {
            pListElem = pHashElem;
            pRelayData = pHashElem->data;
            pHashElem = pHashElem->next;
            free (pRelayData);
            free (pListElem);
            }
        }

    /* Remove elements of circular list created by read_server_db(). */

    pSrvData = pDhcpTargetList;
    for (loop = 0; loop < dhcpNumTargets; loop++)
        {
        pDhcpTargetList = pDhcpTargetList->next;
        free (pSrvData);
        }
    current++;
    if (current > checkpoint)
        return;

    /* Checkpoint 5 (close socket) contained in checkpoint 1. */
    current++;
    if (current > checkpoint)
        return;

    free (dhcpsSendBuf);                     /* Checkpoint 6 */
    current++;
    if (current > checkpoint)
        return;

    rngDelete (dhcpEventRing);               /* Checkpoint 7 */
    current++;
    if (current > checkpoint)
        return;

    rngDelete (dhcpMsgRing);                 /* Checkpoint 8 */
    current++;
    if (current > checkpoint)
        return;

    semDelete (dhcpEventSem);                /* Checkpoint 9 */
    current++;
    if (current > checkpoint)
        return;

    return;
    }

/*******************************************************************************
*
* void dhcpsFreeResource - remove allocated memory for resource entry
*
* This routine removes any dynamically allocated memory used by the given 
* lease descriptor.  It is called during cleanup before the server shuts down.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

void dhcpsFreeResource 
    (
    struct dhcp_resource *pTarget    /* Pointer to resource to remove */
    )
    {
    if (pTarget->mtu_plateau_table.shorts != NULL)
        free (pTarget->mtu_plateau_table.shorts);

    if (pTarget->router.addr != NULL)
        free (pTarget->router.addr);

    if (pTarget->time_server.addr != NULL)
        free (pTarget->time_server.addr);

    if (pTarget->name_server.addr != NULL)
        free (pTarget->name_server.addr);

    if (pTarget->dns_server.addr != NULL)
        free (pTarget->dns_server.addr);

    if (pTarget->log_server.addr != NULL)
        free (pTarget->log_server.addr);

    if (pTarget->cookie_server.addr != NULL)
        free (pTarget->cookie_server.addr);

    if (pTarget->lpr_server.addr != NULL)
        free (pTarget->lpr_server.addr);

    if (pTarget->impress_server.addr != NULL)
        free (pTarget->impress_server.addr);

    if (pTarget->rls_server.addr != NULL)
        free (pTarget->rls_server.addr);

    if (pTarget->nis_server.addr != NULL)
        free (pTarget->nis_server.addr);

    if (pTarget->ntp_server.addr != NULL)
        free (pTarget->ntp_server.addr);

    if (pTarget->nbn_server.addr != NULL)
        free (pTarget->nbn_server.addr);

    if (pTarget->nbdd_server.addr != NULL)
        free (pTarget->nbdd_server.addr);

    if (pTarget->xfont_server.addr != NULL)
        free (pTarget->xfont_server.addr);

    if (pTarget->xdisplay_manager.addr != NULL)
        free (pTarget->xdisplay_manager.addr);

    if (pTarget->nisp_server.addr != NULL)
        free (pTarget->nisp_server.addr);

    if (pTarget->mobileip_ha.addr != NULL)
        free (pTarget->mobileip_ha.addr);

    if (pTarget->smtp_server.addr != NULL)
        free (pTarget->smtp_server.addr);

    if (pTarget->pop3_server.addr != NULL)
        free (pTarget->pop3_server.addr);

    if (pTarget->nntp_server.addr != NULL)
        free (pTarget->nntp_server.addr);

    if (pTarget->dflt_www_server.addr != NULL)
        free (pTarget->dflt_www_server.addr);

    if (pTarget->dflt_finger_server.addr != NULL)
        free (pTarget->dflt_finger_server.addr);

    if (pTarget->dflt_irc_server.addr != NULL)