dhcpcbootlib.c

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

                }                      
            }
        pParamList->nis_server->num = limit;
        }

    if (pParamList->ntp_server != NULL && dhcpcBootParam->ntp_server != NULL) 
        {
        limit = 0;
        if (pParamList->ntp_server->addr != NULL)
            {
            limit = (pParamList->ntp_server->num <
                         dhcpcBootParam->ntp_server->num) ?
                     pParamList->ntp_server->num :
                     dhcpcBootParam->ntp_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->ntp_server->addr [loop],
                       (char *)&pParamList->ntp_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->ntp_server->num = limit;
        }

    if (pParamList->nbn_server != NULL && dhcpcBootParam->nbn_server != NULL) 
        {
        limit = 0;
        if (pParamList->nbn_server->addr != NULL)
            {
            limit = (pParamList->nbn_server->num <
                         dhcpcBootParam->nbn_server->num) ?
                     pParamList->nbn_server->num :
                     dhcpcBootParam->nbn_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->nbn_server->addr [loop],
                       (char *)&pParamList->nbn_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->nbn_server->num = limit;
        }

    if (pParamList->nbdd_server != NULL && dhcpcBootParam->nbdd_server != NULL) 
        {
        limit = 0;
        if (pParamList->nbdd_server->addr != NULL)
            {
            limit = (pParamList->nbdd_server->num <
                         dhcpcBootParam->nbdd_server->num) ?
                     pParamList->nbdd_server->num :
                     dhcpcBootParam->nbdd_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->nbdd_server->addr [loop],
                       (char *)&pParamList->nbdd_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->nbdd_server->num = limit;
        }

    if (pParamList->xfont_server != NULL && 
            dhcpcBootParam->xfont_server != NULL) 
        {
        limit = 0;
        if (pParamList->xfont_server->addr != NULL)
            {
            limit = (pParamList->xfont_server->num <
                         dhcpcBootParam->xfont_server->num) ?
                     pParamList->xfont_server->num :
                     dhcpcBootParam->xfont_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->xfont_server->addr [loop],
                       (char *)&pParamList->xfont_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->xfont_server->num = limit;
        }

    if (pParamList->xdisplay_manager != NULL &&
            dhcpcBootParam->xdisplay_manager != NULL) 
        {
        limit = 0;
        if (pParamList->xdisplay_manager->addr != NULL)
            {
            limit = (pParamList->xdisplay_manager->num <
                         dhcpcBootParam->xdisplay_manager->num) ?
                     pParamList->xdisplay_manager->num :
                     dhcpcBootParam->xdisplay_manager->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->xdisplay_manager->addr [loop],
                       (char *)&pParamList->xdisplay_manager->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->xdisplay_manager->num = limit;
        }

    if (pParamList->nisp_server != NULL && dhcpcBootParam->nisp_server != NULL)
        {
        limit = 0;
        if (pParamList->nisp_server->addr != NULL)
            {
            limit = (pParamList->nisp_server->num <
                         dhcpcBootParam->nisp_server->num) ?
                     pParamList->nisp_server->num :
                     dhcpcBootParam->nisp_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->nisp_server->addr [loop],
                       (char *)&pParamList->nisp_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->nisp_server->num = limit;
        }

    if (pParamList->mobileip_ha != NULL && dhcpcBootParam->mobileip_ha != NULL)
        {
        limit = 0;
        if (pParamList->mobileip_ha->addr != NULL)
            {
            limit = (pParamList->mobileip_ha->num <
                         dhcpcBootParam->mobileip_ha->num) ?
                     pParamList->mobileip_ha->num :
                     dhcpcBootParam->mobileip_ha->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->mobileip_ha->addr [loop],
                       (char *)&pParamList->mobileip_ha->addr [loop],
                       sizeof (struct in_addr));
                }
            }
        pParamList->mobileip_ha->num = limit;
        }

    if (pParamList->smtp_server != NULL && dhcpcBootParam->smtp_server != NULL)
        {
        limit = 0;
        if (pParamList->smtp_server->addr != NULL)
            {
            limit = (pParamList->smtp_server->num <
                         dhcpcBootParam->smtp_server->num) ?
                     pParamList->smtp_server->num :
                     dhcpcBootParam->smtp_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->smtp_server->addr [loop],
                       (char *)&pParamList->smtp_server->addr [loop],
                       sizeof (struct in_addr));
                }
            }
        pParamList->smtp_server->num = limit;
        }

    if (pParamList->pop3_server != NULL && dhcpcBootParam->pop3_server != NULL) 
        {
        limit = 0;
        if (pParamList->pop3_server->addr != NULL)
            {
            limit = (pParamList->pop3_server->num <
                         dhcpcBootParam->pop3_server->num) ?
                     pParamList->pop3_server->num :
                     dhcpcBootParam->pop3_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->pop3_server->addr [loop],
                       (char *)&pParamList->pop3_server->addr [loop],
                       sizeof (struct in_addr));
                }
            }
        pParamList->pop3_server->num = limit;
        }

    if (pParamList->nntp_server != NULL && dhcpcBootParam->nntp_server != NULL)
        {
        limit = 0;
        if (pParamList->nntp_server->addr != NULL)
            {
            limit = (pParamList->nntp_server->num <
                         dhcpcBootParam->nntp_server->num) ?
                     pParamList->nntp_server->num :
                     dhcpcBootParam->nntp_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->nntp_server->addr [loop],
                       (char *)&pParamList->nntp_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->nntp_server->num = limit;
        }

    if (pParamList->dflt_www_server != NULL && 
            dhcpcBootParam->dflt_www_server != NULL) 
        {
        limit = 0;
        if (pParamList->dflt_www_server->addr != NULL)
            {
            limit = (pParamList->dflt_www_server->num <
                         dhcpcBootParam->dflt_www_server->num) ?
                     pParamList->dflt_www_server->num :
                     dhcpcBootParam->dflt_www_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->dflt_www_server->addr [loop],
                       (char *)&pParamList->dflt_www_server->addr [loop],
                       sizeof (struct in_addr));
                }
            }
        pParamList->dflt_www_server->num = limit;
        }

    if (pParamList->dflt_finger_server != NULL && 
            dhcpcBootParam->dflt_finger_server != NULL) 
        {
        limit = 0;
        if (pParamList->dflt_finger_server->addr != NULL)
            {
            limit = (pParamList->dflt_finger_server->num <
                         dhcpcBootParam->dflt_finger_server->num) ?
                     pParamList->dflt_finger_server->num :
                     dhcpcBootParam->dflt_finger_server->num;
            for (loop = 0; loop < limit; loop++)
                {
              bcopy ( (char *)&dhcpcBootParam->dflt_finger_server->addr [loop],
                       (char *)&pParamList->dflt_finger_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->dflt_finger_server->num = limit;
        }

    if (pParamList->dflt_irc_server != NULL && 
            dhcpcBootParam->dflt_irc_server != NULL)
        {
        limit = 0;
        if (pParamList->dflt_irc_server->addr != NULL)
            {
            limit = (pParamList->dflt_irc_server->num <
                         dhcpcBootParam->dflt_irc_server->num) ?
                     pParamList->dflt_irc_server->num :
                     dhcpcBootParam->dflt_irc_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->dflt_irc_server->addr [loop],
                       (char *)&pParamList->dflt_irc_server->addr [loop],
                       sizeof (struct in_addr));
                }
            }
        pParamList->dflt_irc_server->num = limit;
        }

    if (pParamList->streettalk_server != NULL && 
            dhcpcBootParam->streettalk_server != NULL) 
        {
        limit = 0;
        if (pParamList->streettalk_server->addr != NULL)
            {
            limit = (pParamList->streettalk_server->num <
                         dhcpcBootParam->streettalk_server->num) ?
                     pParamList->streettalk_server->num :
                     dhcpcBootParam->streettalk_server->num;
            for (loop = 0; loop < limit; loop++)
                {
              bcopy ( (char *)&dhcpcBootParam->streettalk_server->addr [loop],
                       (char *)&pParamList->streettalk_server->addr [loop],
                       sizeof (struct in_addr));
                }                      
            }
        pParamList->streettalk_server->num = limit;
        }

    if (pParamList->stda_server != NULL && 
            dhcpcBootParam->stda_server != NULL) 
        {
        limit = 0;
        if (pParamList->stda_server->addr != NULL)
            {
            limit = (pParamList->stda_server->num <
                         dhcpcBootParam->stda_server->num) ?
                     pParamList->stda_server->num :
                     dhcpcBootParam->stda_server->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->stda_server->addr [loop],
                       (char *)&pParamList->stda_server->addr [loop],
                       sizeof (struct in_addr));
                }
            }
        pParamList->stda_server->num = limit;
        }

    /* Handle multiple IP address pairs. */

    if (pParamList->policy_filter != NULL && 
            dhcpcBootParam->policy_filter != NULL) 
        {
        limit = 0;
        if (pParamList->policy_filter->addr != NULL)
            {
            limit = (pParamList->policy_filter->num <
                         dhcpcBootParam->policy_filter->num) ?
                     pParamList->policy_filter->num :
                     dhcpcBootParam->policy_filter->num;
            for (loop = 0; loop < limit; loop++)
                {
               bcopy ( (char *)&dhcpcBootParam->policy_filter->addr [loop * 2],
                       (char *)&pParamList->policy_filter->addr [loop * 2],
                       2 * sizeof (struct in_addr));
                }
            }
        pParamList->policy_filter->num = limit;
        }

    if (pParamList->static_route != NULL && 
            dhcpcBootParam->static_route != NULL) 
        {
        limit = 0;
        if (pParamList->static_route->addr != NULL)
            {
            limit = (pParamList->static_route->num <
                         dhcpcBootParam->static_route->num) ?
                     pParamList->static_route->num :
                     dhcpcBootParam->static_route->num;
            for (loop = 0; loop < limit; loop++)
                {
                bcopy ( (char *)&dhcpcBootParam->static_route->addr [loop * 2],
                       (char *)&pParamList->static_route->addr [loop * 2],
                       2 * sizeof (struct in_addr));
                }
            }
        pParamList->static_route->num = limit;
        }

    /* Handle lists. */

    if (pParamList->vendlist != NULL && dhcpcBootParam->vendlist != NULL)
        {
        limit = (pParamList->vendlist->len < dhcpcBootParam->vendlist->len) ? 
                pParamList->vendlist->len : dhcpcBootParam->vendlist->len;
        bcopy (dhcpcBootParam->vendlist->list, pParamList->vendlist->list,
               limit);
        pParamList->vendlist->len = limit;
        }

    return;
    }

/******************************************************************************
*
* dhcpcBootCleanup - remove data structures used by boot-time DHCP client
*
* This routine removes all data structures used by the dhcp client. It is 
* called internally when the client exits.
*
* RETURNS: N/A
*
* ERRNO:   N/A
*
* NOMANUAL
*/

LOCAL void dhcpcBootCleanup (void)
    {
    wdCancel (dhcpcBootEventTimer);
    wdDelete (dhcpcBootEventTimer);

    if (muxDevExists (dhcpcDevice.name, dhcpcDevice.unit))
        {
        etherInputHookDelete (dhcpcBootOfferInputHook, 
                              dhcpcDevice.name, dhcpcDevice.unit);
        etherInputHookDelete (dhcpcBootReplyInputHook, 
                              dhcpcDevice.name, dhcpcDevice.unit);
        }
    else
        {
        etherInputHookDelete (dhcpcBootOfferInputHook, NULL, dhcpcDevice.unit);
        etherInputHookDelete (dhcpcBootReplyInputHook, NULL, dhcpcDevice.unit);
        }

    semDelete (dhcpcBootEventSem);

    rngDelete (dhcpcBootEventRing);
    rngDelete (dhcpcBootMsgRing);

    free (pDhcpcRbuf);

    return;
    }