dhcp.c File Reference

#include <xinu.h>

Include dependency graph for dhcp.c:

Go to the source code of this file.

Functions
void	dhcp_bld_bootp_msg (struct dhcpmsg *dmsg)
int32	dhcp_bld_disc (struct dhcpmsg *dmsg)
int32	dhcp_bld_req (struct dhcpmsg *dmsg, const struct dhcpmsg *dmsg_offer, uint32 dsmg_offer_size)
char *	dhcp_get_opt_val (const struct dhcpmsg *dmsg, uint32 dmsg_size, uint8 option_key)
uint32	getlocalip (void)

Function Documentation

dhcp_bld_bootp_msg()

void dhcp_bld_bootp_msg

(

struct dhcpmsg *

dmsg

)

Definition at line 45 of file dhcp.c.

References dhcpmsg::dc_bootp, dhcpmsg::dc_bop, dhcpmsg::dc_chaddr, dhcpmsg::dc_cip, dhcpmsg::dc_cookie, dhcpmsg::dc_flags, dhcpmsg::dc_gip, dhcpmsg::dc_hlen, dhcpmsg::dc_hops, dhcpmsg::dc_htype, dhcpmsg::dc_secs, dhcpmsg::dc_sip, dhcpmsg::dc_xid, dhcpmsg::dc_yip, ETH_ADDR_LEN, network::ethucast, htonl, memcpy(), memset(), and NetData.

Referenced by dhcp_bld_disc(), and dhcp_bld_req().

{
    uint32  xid;            /* Xid used for the exchange    */

    memcpy(&xid, NetData.ethucast, 4); /* Use 4 bytes from MAC as   */
                       /*    unique XID     */
    memset(dmsg, 0x00, sizeof(struct dhcpmsg));

    dmsg->dc_bop = 0x01;            /* Outgoing request     */
    dmsg->dc_htype = 0x01;      /* Hardware type is Ethernet    */
    dmsg->dc_hlen = 0x06;       /* Hardware address length  */
    dmsg->dc_hops = 0x00;       /* Hop count            */
    dmsg->dc_xid = htonl(xid);  /* Xid (unique ID)      */
    dmsg->dc_secs = 0x0000;     /* Seconds          */
    dmsg->dc_flags = 0x0000;    /* Flags            */
    dmsg->dc_cip = 0x00000000;  /* Client IP address        */
    dmsg->dc_yip = 0x00000000;  /* Your IP address      */
    dmsg->dc_sip = 0x00000000;  /* Server IP address        */
    dmsg->dc_gip = 0x00000000;  /* Gateway IP address       */
    memset(&dmsg->dc_chaddr,'\0',16);/* Client hardware address */
    memcpy(&dmsg->dc_chaddr, NetData.ethucast, ETH_ADDR_LEN);
    memset(&dmsg->dc_bootp,'\0',192);/* Zero the bootp area     */
    dmsg->dc_cookie = htonl(0x63825363); /* Magic cookie for DHCP   */
}

Here is the call graph for this function:

Here is the caller graph for this function:

dhcp_bld_disc()

int32 dhcp_bld_disc

(

struct dhcpmsg *

dmsg

)

Definition at line 74 of file dhcp.c.

References dhcpmsg::dc_opt, and dhcp_bld_bootp_msg().

Referenced by getlocalip().

{
    uint32  j = 0;

    dhcp_bld_bootp_msg(dmsg);

    dmsg->dc_opt[j++] = 0xff & 53;  /* DHCP message type option */
    dmsg->dc_opt[j++] = 0xff &  1;  /* Option length        */
    dmsg->dc_opt[j++] = 0xff &  1;  /* DHCP Dicover message     */
    dmsg->dc_opt[j++] = 0xff &  0;  /* Options padding      */

    dmsg->dc_opt[j++] = 0xff & 55;  /* DHCP parameter request list  */
    dmsg->dc_opt[j++] = 0xff &  2;  /* Option length        */
    dmsg->dc_opt[j++] = 0xff &  1;  /* Request subnet mask      */
    dmsg->dc_opt[j++] = 0xff &  3;  /* Request default router addr->*/
    dmsg->dc_opt[j++] = 0xff;   /* End of options       */

    return (uint32)((char *)&dmsg->dc_opt[j] - (char *)dmsg + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

dhcp_bld_req()

int32 dhcp_bld_req	(	struct dhcpmsg *	dmsg,
		const struct dhcpmsg *	dmsg_offer,
		uint32	dsmg_offer_size
	)

Definition at line 98 of file dhcp.c.

References dhcpmsg::dc_opt, dhcpmsg::dc_sip, dhcpmsg::dc_yip, dhcp_bld_bootp_msg(), dhcp_get_opt_val(), DHCP_SERVER_ID, kprintf(), memcpy(), and SYSERR.

Referenced by getlocalip().

{
    uint32  j = 0;
    uint32* server_ip;          /* Take the DHCP server IP addr */
                    /*   from DHCP offer message    */

    dhcp_bld_bootp_msg(dmsg);
    dmsg->dc_sip = dmsg_offer->dc_sip; /* Server IP address     */
    dmsg->dc_opt[j++] = 0xff & 53;  /* DHCP message type option */
    dmsg->dc_opt[j++] = 0xff &  1;  /* Option length        */
    dmsg->dc_opt[j++] = 0xff &  3;  /* DHCP Request message     */
    dmsg->dc_opt[j++] = 0xff &  0;  /* Options padding      */

    dmsg->dc_opt[j++] = 0xff & 50;  /* Requested IP         */
    dmsg->dc_opt[j++] = 0xff &  4;  /* Option length        */
    memcpy(((void *)&dmsg->dc_opt[j]), &dmsg_offer->dc_yip, 4);
    j += 4;

    /* Retrieve the DHCP server IP from the DHCP options */
    server_ip = (uint32*)dhcp_get_opt_val(dmsg_offer,
                    dsmg_offer_size, DHCP_SERVER_ID);

    if(server_ip == 0) {
        kprintf("Unable to get server IP add. from DHCP Offer\n");
        return SYSERR;
    }

    dmsg->dc_opt[j++] = 0xff & 54;  /* Server IP            */
    dmsg->dc_opt[j++] = 0xff &  4;  /* Option length        */
    memcpy((void *)&dmsg->dc_opt[j], server_ip, 4);
    j += 4;
    dmsg->dc_opt[j++] = 0xff;   /* End of options       */

    return (uint32)((char *)&dmsg->dc_opt[j] - (char *)dmsg + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

dhcp_get_opt_val()

char* dhcp_get_opt_val	(	const struct dhcpmsg *	dmsg,
		uint32	dmsg_size,
		uint8	option_key
	)

Definition at line 10 of file dhcp.c.

References dhcpmsg::dc_opt, and NULL.

Referenced by dhcp_bld_req(), and getlocalip().

{
    unsigned char* opt_tmp;
    unsigned char* eom;

    eom = (unsigned char*)dmsg + dmsg_size - 1;
    opt_tmp = (unsigned char*)dmsg->dc_opt;

    while(opt_tmp < eom) {

        /* If the option value matches return the value */

        if((*opt_tmp) == option_key) {

            /* Offset past the option value and the size    */

            return (char*)(opt_tmp+2);
        }
        opt_tmp++;  /* Move to length octet */
        opt_tmp += *(uint8*)opt_tmp + 1;
    }

    /* Option value not found */

    return NULL;
}

Here is the caller graph for this function:

getlocalip()

uint32 getlocalip

(

void

)

Definition at line 142 of file dhcp.c.

References network::bootfile, network::bootserver, dhcp_bld_disc(), dhcp_bld_req(), dhcp_get_opt_val(), DHCP_RETRY, DHCP_SERVER_ID, network::dnsserver, dot2ip(), IP_BCAST, network::ipbcast, network::ipmask, network::ipprefix, network::iprouter, network::ipucast, network::ipvalid, kprintf(), memcpy(), NetData, ntohl, network::ntpserver, OK, SYSERR, TIMEOUT, TRUE, UDP_DHCP_CPORT, UDP_DHCP_SPORT, udp_recv(), udp_register(), udp_release(), and udp_sendto().

Referenced by dnslookup(), getutime(), rdscomm(), startup(), xsh_netinfo(), and xsh_udpeserver().

{
    int32   slot;           /* UDP slot to use      */
    struct  dhcpmsg dmsg_snd;   /* Holds outgoing DHCP messages */
    struct  dhcpmsg dmsg_rvc;   /* Holds incoming DHCP messages */

    int32   i, j;           /* Retry counters       */
    int32   len;            /* Length of data sent      */
    int32   inlen;          /* Length of data received  */
    char    *optptr;        /* Pointer to options area  */
    char    *eop;           /* Address of end of packet */
    int32   msgtype;        /* Type of DCHP message     */
    uint32  addrmask;       /* Address mask for network */
    uint32  routeraddr;     /* Default router address   */
    uint32  dnsaddr;        /* DNS server address       */
    uint32  ntpaddr;        /* NTP server address       */
    uint32  tmp;            /* Used for byte conversion */
    uint32* tmp_server_ip;      /* Temporary DHCP server pointer*/

    slot = udp_register(0, UDP_DHCP_SPORT, UDP_DHCP_CPORT);
    if (slot == SYSERR) {
        kprintf("getlocalip: cannot register with UDP\n");
        return SYSERR;
    }

    len = dhcp_bld_disc(&dmsg_snd);
    if(len == SYSERR) {
        kprintf("getlocalip: Unable to build DHCP discover\n");
        return SYSERR;
    }

    for (i = 0; i < DHCP_RETRY; i++) {
        udp_sendto(slot, IP_BCAST, UDP_DHCP_SPORT,
                        (char *)&dmsg_snd, len);

        /* Read 3 incoming DHCP messages and check for an offer */
        /*  or wait for three timeout periods if no message */
        /*  arrives.                    */

        for (j=0; j<3; j++) {
        inlen = udp_recv(slot, (char *)&dmsg_rvc,
                    sizeof(struct dhcpmsg), 2000);
        if (inlen == TIMEOUT) {
            continue;
        } else if (inlen == SYSERR) {
            return SYSERR;
        }
        /* Check that incoming message is a valid   */
        /*   response (ID matches our request)      */

        if (dmsg_rvc.dc_xid != dmsg_snd.dc_xid) {
            continue;
        }

        eop = (char *)&dmsg_rvc + inlen - 1;
        optptr = (char *)&dmsg_rvc.dc_opt;
        msgtype = addrmask = routeraddr = dnsaddr = ntpaddr = 0;

        while (optptr < eop) {

            switch (*optptr) {
            case 53:    /* Message type */
                msgtype = 0xff & *(optptr+2);
                break;

            case 1:     /* Subnet mask */
                memcpy((void *)&tmp, optptr+2, 4);
                addrmask = ntohl(tmp);
                break;

            case 3:     /* Router address */
                memcpy((void *)&tmp, optptr+2, 4);
                routeraddr = ntohl(tmp);
                break;

            case 6:     /* DNS server address */
                memcpy((void *)&tmp, optptr+2, 4);
                dnsaddr = ntohl(tmp);
                break;

            case 42:    /* NTP server address */
                memcpy((void *)&tmp, optptr+2, 4);
                ntpaddr = ntohl(tmp);
                break;

            }
            optptr++;   /* Move to length octet */
            optptr += (0xff & *optptr) + 1;
        }

        if (msgtype == 0x02) {  /* Offer - send request */
            len = dhcp_bld_req(&dmsg_snd, &dmsg_rvc, inlen);
            if(len == SYSERR) {
                kprintf("getlocalip: %s\n",
                  "Unable to build DHCP request");
                return SYSERR;
            }
            udp_sendto(slot, IP_BCAST, UDP_DHCP_SPORT,
                    (char *)&dmsg_snd, len);
            continue;

        } else if (dmsg_rvc.dc_opt[2] != 0x05) {
            /* If not an ack skip it */
            continue;
        }
        if (addrmask != 0) {
            NetData.ipmask = addrmask;
        }
        if (routeraddr != 0) {
            NetData.iprouter = routeraddr;
        }
        if (dnsaddr != 0) {
            NetData.dnsserver = dnsaddr;
        }
        if (ntpaddr != 0) {
            NetData.ntpserver = ntpaddr;
        }

        NetData.ipucast = ntohl(dmsg_rvc.dc_yip);
        NetData.ipprefix = NetData.ipucast & NetData.ipmask;
        NetData.ipbcast = NetData.ipprefix | ~NetData.ipmask;
        NetData.ipvalid = TRUE;
        udp_release(slot);

        /* Retrieve the boot server IP */
        if (dot2ip((char*)dmsg_rvc.sname,
                        &NetData.bootserver) != OK) {
            /* Could not retrieve the boot server from  */
            /*  the  BOOTP fields, so use the DHCP server   */
            /*  address                 */
            tmp_server_ip = (uint32*)dhcp_get_opt_val(
                    &dmsg_rvc, len, DHCP_SERVER_ID);
            memcpy((char *)&tmp, tmp_server_ip, 4);
            NetData.bootserver = ntohl(tmp);
        }
        memcpy(NetData.bootfile, dmsg_rvc.bootfile,
                         sizeof(dmsg_rvc.bootfile));
        return NetData.ipucast;
        }
    }

    kprintf("DHCP failed to get a response\n");
    udp_release(slot);
    return (uint32)SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function: