(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_STACKSTATUS 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);