** This routine relays a DHCP or BOOTP message to the specified target address.** RETURNS: N/A** ERRNO: N/A** NOMANUAL*/static STATUS forwarding (struct server *srvp){    int i, n;    int sockfd = -1;    int msgsize = DHCPLEN (dhcpMsgIn.udp);    struct sockaddr_in my_addr, serv_addr;    int result;#ifdef DHCPR_DEBUG    char output[INET_ADDR_LEN];#endif    if ((sockfd = socket (AF_INET, SOCK_DGRAM, 0)) < 0) {#ifdef DHCPR_DEBUG        logMsg ("socket() error in forwarding()\n", 0, 0, 0, 0, 0, 0);#endif        return (ERROR);    }    bzero ((char *) &my_addr, sizeof (my_addr));    my_addr.sin_family = AF_INET;    my_addr.sin_addr.s_addr = htonl (INADDR_ANY);    my_addr.sin_port = dhcpc_port;  /* Servers expect client port. */    if (bind (sockfd, (struct sockaddr *) &my_addr, sizeof (my_addr)) < 0) {#ifdef DHCPR_DEBUG        logMsg ("bind() error in forwarding()\n", 0, 0, 0, 0, 0, 0);#endif        close (sockfd);        return (ERROR);    }    dhcprMsgOut.dhcp = dhcpMsgIn.dhcp;    result = setsockopt (sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &msgsize, sizeof (msgsize));    if (result < 0) {#ifdef DHCPR_DEBUG        logMsg ("Warning: can't set send buffer in forwarding().\n", 0, 0, 0, 0, 0, 0);#endif        close (sockfd);        return (ERROR);    }    n = sizeof (serv_addr);    for (i = 0; i < dhcpNumTargets; i++) {        bzero ((char *) &serv_addr, n);        serv_addr.sin_family = AF_INET;        serv_addr.sin_addr.s_addr = srvp->ip.s_addr;        serv_addr.sin_port = dhcps_port;#ifdef DHCPR_DEBUG        inet_ntoa_b (srvp->ip, output);        printf ("Server relay: sending %d bytes to %s.\n", msgsize, output);#endif        sendto (sockfd, (char *) dhcprMsgOut.dhcp, msgsize, 0, (struct sockaddr *) &serv_addr, n);        srvp = srvp->next;    }    close (sockfd);    return (OK);}/********************************************************************************* dhcpClientRelay - send DHCP/BOOTP replies to client** This routine relays a DHCP or BOOTP reply to the client which generated* the initial request. The routine accesses global pointers already set to * indicate the reply. All messages are discarded after the hops field exceeds * 16 to comply with the relay agent behavior specified in RFC 1542. The relay * agent normally discards such messages before this routine is called. They * will only be received by this routine if the user ignores the instructions * in the manual and sets the value of DHCP_MAX_HOPS higher than 16.** RETURNS: N/A** ERRNO: N/A** NOMANUAL*/void dhcpClientRelay (struct if_info *list, int dhcplen, char *pSendBuf /* Transmit buffer for fragmented message. */    ){    int total;    char devName[10];    struct if_info *ifp;    struct sockaddr_in dest;    BOOL bcastFlag;    int msgtype = 0;    char *option = NULL;    struct ifnet *pIf;    STATUS result;#ifdef DHCPR_DEBUG    char srcAddr[INET_ADDR_LEN];    char dstAddr[INET_ADDR_LEN];#endif    if (dhcpMsgIn.dhcp->hops >= 17) /* RFC limits to 16 hops - ignore. */        return;    ifp = list;    while (ifp != NULL) {        if (ifp->ipaddr.s_addr == dhcpMsgIn.dhcp->giaddr.s_addr)            break;        ifp = ifp->next;    }    if (ifp == NULL) {#ifdef DHCPR_DEBUG        inet_ntoa_b (dhcpMsgIn.ip->ip_src, srcAddr);        logMsg ("Warning: DHCP message from server(%s) has no interface.\n",                srcAddr, 0, 0, 0, 0, 0);#endif        return;    }    sprintf (devName, "%s%d", ifp->name, ifp->unit);    pIf = ifunit (devName);    if (pIf == NULL) {#ifdef DHCPR_DEBUG        logMsg ("Warning: couldn't access network interface %s.\n", (int) ifp->name, 0, 0, 0, 0, 0);#endif        return;    }    if ((option = pickup_opt (dhcpMsgIn.dhcp, dhcplen, _DHCP_MSGTYPE_TAG))        != NULL)        msgtype = *OPTBODY (option);    /* There is already space for the IP and UDP headers. */    dhcprMsgOut.dhcp = dhcpMsgIn.dhcp;    dhcprMsgOut.udp = dhcpMsgIn.udp;    dhcprMsgOut.ip = dhcpMsgIn.ip;#ifdef DHCPR_DEBUG    logMsg ("Client relay: Headers found.\n", 0, 0, 0, 0, 0, 0);#endif#ifdef DHCPR_DEBUG    logMsg ("Setting parameters.\n", 0, 0, 0, 0, 0, 0);#endif    bzero ((char *) &dest, sizeof (struct sockaddr_in));    dest.sin_len = sizeof (struct sockaddr_in);    dest.sin_family = AF_INET;    if (ISBRDCST (dhcpMsgIn.dhcp->flags)) {#ifdef DHCPR_DEBUG        logMsg ("Broadcasting reply.\n", 0, 0, 0, 0, 0, 0);#endif        dest.sin_addr.s_addr = dhcprMsgOut.ip->ip_dst.s_addr = 0xffffffff;        dhcprMsgOut.ip->ip_src.s_addr = ifp->ipaddr.s_addr;        bcastFlag = TRUE;    } else {        if (msgtype == DHCPNAK) {            dest.sin_addr.s_addr = dhcprMsgOut.ip->ip_dst.s_addr = 0xffffffff;            bcastFlag = TRUE;        } else {            dhcprMsgOut.ip->ip_dst.s_addr = dhcpMsgIn.dhcp->yiaddr.s_addr;            dest.sin_addr.s_addr = dhcpMsgIn.dhcp->yiaddr.s_addr;            bcastFlag = FALSE;        }        dhcprMsgOut.ip->ip_src.s_addr = ifp->ipaddr.s_addr;#ifdef DHCPR_DEBUG        inet_ntoa_b (dhcprMsgOut.ip->ip_src, srcAddr);        inet_ntoa_b (dhcprMsgOut.ip->ip_dst, dstAddr);        logMsg ("Sending reply from %s to %s.\n", srcAddr, dstAddr, 0, 0, 0, 0);#endif    }    dhcprMsgOut.udp->uh_sport = dhcps_port;    dhcprMsgOut.udp->uh_dport = dhcpc_port;    dhcprMsgOut.udp->uh_ulen = htons (dhcplen + UDPHL);    dhcprMsgOut.udp->uh_sum = get_udpsum (dhcprMsgOut.ip, dhcprMsgOut.udp);    dhcprMsgOut.ip->ip_v = IPVERSION;    dhcprMsgOut.ip->ip_hl = IPHL >> 2;    dhcprMsgOut.ip->ip_tos = 0;    dhcprMsgOut.ip->ip_len = htons (dhcplen + UDPHL + IPHL);    dhcprMsgOut.ip->ip_id = dhcprMsgOut.udp->uh_sum;    dhcprMsgOut.ip->ip_ttl = 0x20;  /* XXX */    dhcprMsgOut.ip->ip_p = IPPROTO_UDP;    total = dhcplen + IPHL + UDPHL;    if (total <= pIf->if_mtu) {        /*         * The message fits within the MTU size of the outgoing interface.         * Send it "in place", altering the UDP and IP headers of the         * original (incoming) message's buffer.         */        dhcprMsgOut.ip->ip_off = 0;        dhcprMsgOut.ip->ip_sum = get_ipsum (dhcprMsgOut.ip);#ifdef DHCPR_DEBUG        logMsg ("Writing %d bytes.\n", total, 0, 0, 0, 0, 0);#endif        result = dhcpsSend (pIf,                            dhcprMsgOut.dhcp->chaddr, dhcprMsgOut.dhcp->hlen,                            &dest, (char *) dhcprMsgOut.ip, total, bcastFlag);#ifdef DHCPR_DEBUG        if (result != OK)            logMsg ("Error %d relaying message to client.\n", errno, 0, 0, 0, 0, 0);#endif    } else {        /*         * The message exceeds the MTU size of the outgoing interface.         * Split it into fragments and send them using the provided         * transmit buffer.         */        char *n, *end, *begin;        begin = (char *) dhcprMsgOut.udp;        end = &begin[total];        total = pIf->if_mtu - IPHL;        for (n = begin; n < end; n += total) {            if ((end - n) >= total) {                dhcprMsgOut.ip->ip_len = htons (pIf->if_mtu);                dhcprMsgOut.ip->ip_off = htons (IP_MF | ((((n - begin) / 8)) & 0x1fff));                dhcprMsgOut.ip->ip_sum = get_ipsum (dhcprMsgOut.ip);                bcopy ((char *) dhcprMsgOut.ip, pSendBuf, IPHL);                bcopy ((char *) n, &pSendBuf[IPHL], total);            } else {                /* Last fragment of message. */                dhcprMsgOut.ip->ip_len = htons (IPHL + end - n);                dhcprMsgOut.ip->ip_off = htons (((n - begin) / 8) & 0x1fff);                dhcprMsgOut.ip->ip_sum = get_ipsum (dhcprMsgOut.ip);                bcopy ((char *) dhcprMsgOut.ip, pSendBuf, IPHL);                bcopy ((char *) n, &pSendBuf[IPHL], end - n);            }            dhcpsSend (pIf,                       dhcprMsgOut.dhcp->chaddr, dhcprMsgOut.dhcp->hlen,                       &dest, pSendBuf, ntohs (dhcprMsgOut.ip->ip_len), bcastFlag);        }        /* Send complete: clean the transmit buffer before later use. */        bzero (pSendBuf, total + IPHL);    }    return;}/********************************************************************************* read_server_db - read IP addresses to receive relayed packets** This routine extracts the IP address entries hard-coded into usrNetwork.c as * dhcpTargetTbl[] and stores them in a circular linked list. Each of these * address entries must be on a different subnet from the calling server* or relay agent. Each entry in the list will receive a copy of every DHCP or* BOOTP message arriving at the client port.** RETURNS: N/A** ERRNO: N/A** NOMANUAL*/voidread_server_db (int dbsize){    char targetIP[sizeof ("255.255.255.255")];    struct server *srvp = NULL;    struct server *lastp = NULL;    int loop;    /* Read IP addresses of target servers or relay agents. */    for (loop = 0; (loop < dbsize) && (pDhcpRelayTargetTbl[loop].pAddress); loop++) {        sprintf (targetIP, "%s", pDhcpRelayTargetTbl[loop].pAddress);        srvp = (struct server *) calloc (1, sizeof (struct server));        if (srvp == NULL) {#ifdef DHCPR_DEBUG            logMsg ("Memory allocation error reading relay target database.\n", 0, 0, 0, 0, 0, 0);#endif            break;        }        srvp->ip.s_addr = inet_addr (targetIP);        if (srvp->ip.s_addr == -1) {#ifdef DHCPR_DEBUG            logMsg ("Conversion error reading relay target database.\n", 0, 0, 0, 0, 0, 0);#endif            free (srvp);            continue;        }        dhcpNumTargets++;        srvp->next = pDhcpTargetList;        if (pDhcpTargetList == NULL)            lastp = srvp;        pDhcpTargetList = srvp;    }    if (lastp == NULL)          /* No target DHCP servers. */        return;    /* Create circular list of DHCP server addresses. */    lastp->next = pDhcpTargetList;#ifdef DHCPR_DEBUG    logMsg ("read %d entries from relay target database", dhcpNumTargets, 0, 0, 0, 0, 0);#endif    return;}