dhcpslib.c

vxworks的完整的源代码

                    (char *)&result, sizeof (result)) != 0)
        {
        dhcpsCleanup (5); 
        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 (pDhcpsCfg->dhcpMaxMsgSize) != OK)
        {
        logMsg ("Error: Couldn't allocate memory.\n", 0, 0, 0, 0, 0, 0);
        dhcpsCleanup (5);  
        return (ERROR);
        }

    dhcpsInitialized = TRUE;

    return (OK);
    }

/*******************************************************************************
*
* dhcpsVsInit - Initializes the Virtual Stack Portion of the code
*
* dhcpsVsInit is used to configure the VS specific portion of the DHCP server.
*
* RETURNS: ERROR if it could not allocate the needed memory
*	   OK otherwise
*
* NOMANUAL
*/

#ifdef VIRTUAL_STACK
STATUS dhcpsVsInit ()
    {
    struct bpf_insn mydhcpfilter[] = DHCPS_FILTER_DEFINE;
    unsigned char mydhcpsCookie[] = RFC1048_MAGIC;

    if (vsTbl[myStackNum]->pDhcpsGlobals && (dhcpsInitialized == TRUE))
	 return (OK);

    /* Allocate memory to the dhcps globals in this virtual stack */
    vsTbl[myStackNum]->pDhcpsGlobals = (VS_DHCPS *) KHEAP_ALLOC (sizeof (VS_DHCPS));
    if (vsTbl[myStackNum]->pDhcpsGlobals == (VS_DHCPS *) NULL)
	 return (ERROR);

    bzero ((char *)vsTbl[myStackNum]->pDhcpsGlobals, sizeof (VS_DHCPS));

    /* Copy over filter variables */
    memcpy (dhcpfilter, mydhcpfilter, MAX_DHCPFILTERS * sizeof (struct bpf_insn));

    dhcpread.bf_len = MAX_DHCPFILTERS;
    dhcpread.bf_insns = dhcpfilter;

    /* Copy over the magic cookie */
    memcpy (dhcpCookie, mydhcpsCookie, MAGIC_LEN * sizeof (unsigned char));

    return (OK);
    }
#endif /* VIRTUAL_STACK */

/*******************************************************************************
*
* 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;

    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)
            {
            if (pIf->bpfDev >= 0)
                close (pIf->bpfDev);
            free (pIf->buf);
            }

        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;

    /* Checkpoint 3 */

    if (dhcpsAddressHookRtn != NULL)
        (* dhcpsAddressHookRtn) (DHCPS_STORAGE_STOP, NULL, NULL, NULL, NULL);

    while (bindlist != NULL)
        {
        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;

    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)
        free (pTarget->dflt_irc_server.addr);

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

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

    if (pTarget->policy_filter.addr1 != NULL)
        free (pTarget->policy_filter.addr1);