dhcpccommonlib.c

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

    pParamList->mask_discover = pDhcpcParam->mask_discover;
    pParamList->mask_supplier = pDhcpcParam->mask_supplier;
    pParamList->router_discover = pDhcpcParam->router_discover;
    pParamList->trailer = pDhcpcParam->trailer;
    pParamList->ether_encap = pDhcpcParam->ether_encap;
    pParamList->keepalive_garba = pDhcpcParam->keepalive_garba;

    /* Process all single numeric parameters. */

    pParamList->time_offset = pDhcpcParam->time_offset;
    pParamList->bootsize = pDhcpcParam->bootsize;
    pParamList->max_dgram_size = pDhcpcParam->max_dgram_size;
    pParamList->default_ip_ttl = pDhcpcParam->default_ip_ttl;
    pParamList->mtu_aging_timeout = pDhcpcParam->mtu_aging_timeout;
    pParamList->intf_mtu = pDhcpcParam->intf_mtu;
    pParamList->arp_cache_timeout = pDhcpcParam->arp_cache_timeout;
    pParamList->default_tcp_ttl = pDhcpcParam->default_tcp_ttl;
    pParamList->keepalive_inter = pDhcpcParam->keepalive_inter;
    pParamList->nb_nodetype = pDhcpcParam->nb_nodetype;
    pParamList->lease_origin = pDhcpcParam->lease_origin;
    pParamList->lease_duration = pDhcpcParam->lease_duration;
    pParamList->dhcp_t1 = pDhcpcParam->dhcp_t1;
    pParamList->dhcp_t2 = pDhcpcParam->dhcp_t2;

    /* Process multiple numeric parameters. */

    if (pParamList->mtu_plateau_table != NULL &&
        pDhcpcParam->mtu_plateau_table != NULL)
        {
        limit = 0;
        if (pParamList->mtu_plateau_table->shortnum != NULL)
            {
            limit = (pParamList->mtu_plateau_table->num <
                     pDhcpcParam->mtu_plateau_table->num) ?
                     pParamList->mtu_plateau_table->num :
                     pDhcpcParam->mtu_plateau_table->num;
            for (loop = 0; loop < limit; loop++)
                {
                pParamList->mtu_plateau_table->shortnum [loop] =
                pDhcpcParam->mtu_plateau_table->shortnum [loop];
                }
            }
        pParamList->mtu_plateau_table->num = limit;
        }

    /* Process single IP addresses. */

    pParamList->server_id = pDhcpcParam->server_id;
    pParamList->ciaddr = pDhcpcParam->ciaddr;
    pParamList->yiaddr = pDhcpcParam->yiaddr;
    pParamList->siaddr = pDhcpcParam->siaddr;
    pParamList->giaddr = pDhcpcParam->giaddr;

    if (pParamList->subnet_mask != NULL && pDhcpcParam->subnet_mask != NULL)
        bcopy ( (char *)pDhcpcParam->subnet_mask,
               (char *)pParamList->subnet_mask, sizeof (struct in_addr));

    if (pParamList->swap_server != NULL && pDhcpcParam->swap_server != NULL)
        bcopy ( (char *)pDhcpcParam->swap_server,
               (char *)pParamList->swap_server, sizeof (struct in_addr));

    if (pParamList->brdcast_addr != NULL &&
        pDhcpcParam->brdcast_addr != NULL)
        bcopy ( (char *)pDhcpcParam->brdcast_addr,
               (char *)pParamList->brdcast_addr, sizeof (struct in_addr));

    pParamList->router_solicit = pDhcpcParam->router_solicit;

    /* Process multiple IP addresses. */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    if (pParamList->mobileip_ha != NULL && pDhcpcParam->mobileip_ha != NULL)
        {
        limit = 0;
        if (pParamList->mobileip_ha->addr != NULL)
            {
            limit = (pParamList->mobileip_ha->num <
                     pDhcpcParam->mobileip_h