URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [services/] [bootp.c] - Blame information for rev 406

Details | Compare with Previous | View Log


/*
 *      Based on LiMon - BOOTP.
 *
 *      Copyright 1994, 1995, 2000 Neil Russell.
 *      (See License)
 *      Copyright 2000 Roland Borde
 *      Copyright 2000 Paolo Scaffardi
 */
 
#if 1
#define DEBUG           1       /* general debug */
#define DEBUG_BOOTP_EXT 1       /* Debug received vendor fields */
#endif
 
#ifdef DEBUG_BOOTP_EXT
#define debug_ext(fmt,args...)  printf (fmt ,##args)
#else
#define debug_ext(fmt,args...)
#endif
 
#include "common.h"
#include "net.h"
#include "bootp.h"
#include "tftp.h"
#include "arp.h"
 
#define BOOTP_VENDOR_MAGIC      0x63825363      /* RFC1048 Magic Cookie         */
 
#if (CONFIG_COMMANDS & CFG_CMD_NET)
 
#define TIMEOUT         5       /* Seconds before trying BOOTP again    */
#define TIMEOUT_COUNT   1       /* # of timeouts before giving up       */
 
#define PORT_BOOTPS     67      /* BOOTP server UDP port                */
#define PORT_BOOTPC     68      /* BOOTP client UDP port                */
 
#ifndef CONFIG_DHCP_MIN_EXT_LEN /* minimal length of extension list     */
#define CONFIG_DHCP_MIN_EXT_LEN 64
#endif
 
ulong BootpID;
int BootpTry;
#ifdef CONFIG_BOOTP_RANDOM_DELAY
ulong seed1, seed2;
#endif
 
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
dhcp_state_t dhcp_state = INIT;
unsigned int dhcp_leasetime = 0;
static void DhcpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len);
 
/* For Debug */
char *dhcpmsg2str(int type)
{
        switch (type) {
        case 1:
                return "DHCPDISCOVER";
                break;
        case 2:
                return "DHCPOFFER";
                break;
        case 3:
                return "DHCPREQUEST";
                break;
        case 4:
                return "DHCPDECLINE";
                break;
        case 5:
                return "DHCPACK";
                break;
        case 6:
                return "DHCPNACK";
                break;
        case 7:
                return "DHCPRELEASE";
                break;
        default:
                return "UNKNOWN/INVALID MSG TYPE";
                break;
        }
}
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)
extern u8 *dhcp_vendorex_prep(u8 * e);  /*rtn new e after add own opts. */
extern u8 *dhcp_vendorex_proc(u8 * e);  /*rtn next e if mine,else NULL  */
#endif
 
#endif /* CFG_CMD_DHCP */
 
static int BootpCheckPkt(uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
        Bootp_t *bp = (Bootp_t *) pkt;
        int retval = 0;
 
        if (dest != PORT_BOOTPC || src != PORT_BOOTPS)
                retval = -1;
        if (len < sizeof(Bootp_t) - OPT_SIZE)
                retval = -2;
        if (bp->bp_op != OP_BOOTREQUEST &&
            bp->bp_op != OP_BOOTREPLY &&
            bp->bp_op != DHCP_OFFER &&
            bp->bp_op != DHCP_ACK && bp->bp_op != DHCP_NAK) {
                retval = -3;
        }
        if (bp->bp_htype != HWT_ETHER)
                retval = -4;
        if (bp->bp_hlen != HWL_ETHER)
                retval = -5;
        if (bp->bp_id != BootpID)
                retval = -6;
 
        debug("Filtering pkt = %d\n", retval);
 
        return retval;
}
 
/*
 * Copy parameters of interest from BOOTP_REPLY/DHCP_OFFER packet
 */
void BootpCopyNetParams(Bootp_t * bp)
{
        NetOurIP = bp->bp_yiaddr;
        NetServerIP = bp->bp_siaddr;
        NetCopyEther(NetServerEther, ((Ethernet_t *) NetRxPkt)->et_src);
        copy_filename(BootFile, bp->bp_file, sizeof(BootFile));
 
        debug("Bootfile: %s\n", BootFile);
 
        /* Propagate to environment:
         * don't delete exising entry when BOOTP / DHCP reply does
         * not contain a new value
         */
        if (*BootFile) {
                setenv("bootfile", BootFile);
        }
}
 
static int truncate_sz(const char *name, int maxlen, int curlen)
{
        if (curlen >= maxlen) {
                printf
                    ("*** WARNING: %s is too long (%d - max: %d) - truncated\n",
                     name, curlen, maxlen);
                curlen = maxlen - 1;
        }
        return (curlen);
}
 
#if !(CONFIG_COMMANDS & CFG_CMD_DHCP)
 
static void BootpVendorFieldProcess(u8 * ext)
{
        int size = *(ext + 1);
 
        debug_ext("[BOOTP] Processing extension %d... (%d bytes)\n", *ext,
                  *(ext + 1));
 
        NetBootFileSize = 0;
 
        switch (*ext) {
                /* Fixed length fields */
        case 1:         /* Subnet mask                                  */
                if (NetOurSubnetMask == 0)
                        memcpy(&NetOurSubnetMask, ext + 2, 4);
                break;
        case 2:         /* Time offset - Not yet supported              */
                break;
                /* Variable length fields */
        case 3:         /* Gateways list                                */
                if (NetOurGatewayIP == 0) {
                        memcpy(&NetOurGatewayIP, ext + 2, 4);
                }
                break;
        case 4:         /* Time server - Not yet supported              */
                break;
        case 5:         /* IEN-116 name server - Not yet supported      */
                break;
        case 6:
                if (NetOurDNSIP == 0) {
                        memcpy(&NetOurDNSIP, ext + 2, 4);
                }
                break;
        case 7:         /* Log server - Not yet supported               */
                break;
        case 8:         /* Cookie/Quote server - Not yet supported      */
                break;
        case 9:         /* LPR server - Not yet supported               */
                break;
        case 10:                /* Impress server - Not yet supported           */
                break;
        case 11:                /* RPL server - Not yet supported               */
                break;
        case 12:                /* Host name                                    */
                if (NetOurHostName[0] == 0) {
                        size =
                            truncate_sz("Host Name", sizeof(NetOurHostName),
                                        size);
                        memcpy(&NetOurHostName, ext + 2, size);
                        NetOurHostName[size] = 0;
                }
                break;
        case 13:                /* Boot file size                               */
                memcpy(&NetBootFileSize, ext + 2, size);
                break;
        case 14:                /* Merit dump file - Not yet supported          */
                break;
        case 15:                /* Domain name - Not yet supported              */
                break;
        case 16:                /* Swap server - Not yet supported              */
                break;
        case 17:                /* Root path                                    */
                if (NetOurRootPath[0] == 0) {
                        size =
                            truncate_sz("Root Path", sizeof(NetOurRootPath),
                                        size);
                        memcpy(&NetOurRootPath, ext + 2, size);
                        NetOurRootPath[size] = 0;
                }
                break;
        case 18:                /* Extension path - Not yet supported           */
                /*
                 * This can be used to send the informations of the
                 * vendor area in another file that the client can
                 * access via TFTP.
                 */
                break;
                /* IP host layer fields */
        case 40:                /* NIS Domain name                              */
                if (NetOurNISDomain[0] == 0) {
                        size = truncate_sz("NIS Domain Name",
                                           sizeof(NetOurNISDomain), size);
                        memcpy(&NetOurNISDomain, ext + 2, size);
                        NetOurNISDomain[size] = 0;
                }
                break;
                /* Application layer fields */
        case 43:                /* Vendor specific info - Not yet supported     */
                /*
                 * Binary informations to exchange specific
                 * product information.
                 */
                break;
                /* Reserved (custom) fields (128..254) */
        }
}
 
static void BootpVendorProcess(u8 * ext, int size)
{
        u8 *end = ext + size;
 
        debug_ext("[BOOTP] Checking extension (%d bytes)...\n", size);
 
        while ((ext < end) && (*ext != 0xff)) {
                if (*ext == 0) {
                        ext++;
                } else {
                        u8 *opt = ext;
                        ext += ext[1] + 2;
                        if (ext <= end)
                                BootpVendorFieldProcess(opt);
                }
        }
 
#ifdef DEBUG_BOOTP_EXT
        printf("[BOOTP] Received fields: \n");
        if (NetOurSubnetMask) {
                puts("NetOurSubnetMask  : ");
                print_IPaddr(NetOurSubnetMask);
                putc('\n');
        }
 
        if (NetOurGatewayIP) {
                puts("NetOurGatewayIP   : ");
                print_IPaddr(NetOurGatewayIP);
                putc('\n');
        }
 
        if (NetBootFileSize) {
                printf("NetBootFileSize : %d\n", NetBootFileSize);
        }
 
        if (NetOurHostName[0]) {
                printf("NetOurHostName  : %s\n", NetOurHostName);
        }
 
        if (NetOurRootPath[0]) {
                printf("NetOurRootPath  : %s\n", NetOurRootPath);
        }
 
        if (NetOurNISDomain[0]) {
                printf("NetOurNISDomain : %s\n", NetOurNISDomain);
        }
#endif /* DEBUG_BOOTP_EXT */
}
 
/*
 *      Handle a BOOTP received packet.
 */
static void BootpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
        Bootp_t *bp;
        char *s;
 
        debug("got BOOTP packet (src=%d, dst=%d, len=%d want_len=%d)\n",
              src, dest, len, sizeof(Bootp_t));
 
        bp = (Bootp_t *) pkt;
 
        if (BootpCheckPkt(pkt, dest, src, len)) /* Filter out pkts we don't want */
                return;
 
        /*
         *      Got a good BOOTP reply.  Copy the data into our variables.
         */
#ifdef CONFIG_STATUS_LED
        status_led_set(STATUS_LED_BOOT, STATUS_LED_OFF);
#endif
 
        BootpCopyNetParams(bp); /* Store net parameters from reply */
 
        /* Retrieve extended informations (we must parse the vendor area) */
        if ((*(uint *) bp->bp_vend) == BOOTP_VENDOR_MAGIC)
                BootpVendorProcess(&bp->bp_vend[4], len);
 
        NetSetTimeout(0, (thand_f *) 0);
 
        debug("Got good BOOTP\n");
 
        if (((s = getenv("autoload")) != NULL) && (*s == 'n')) {
                /*
                 * Just use BOOTP to configure system;
                 * Do not use TFTP to load the bootfile.
                 */
                NetState = NETLOOP_SUCCESS;
                return;
        }
 
        /* Send ARP request to get TFTP server ethernet address.
         * This automagically starts TFTP, too.
         */
        ArpRequest();
}
#endif /* !CFG_CMD_DHCP */
 
/*
 *      Timeout on BOOTP/DHCP request.
 */
static void BootpTimeout(void)
{
        if (BootpTry >= TIMEOUT_COUNT) {
                puts("\nRetry count exceeded; starting again\n");
                NetStartAgain();
        } else {
                NetSetTimeout(TIMEOUT * CFG_HZ, BootpTimeout);
                BootpRequest();
        }
}
 
/*
 *      Initialize BOOTP extension fields in the request.
 */
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
static int DhcpExtended(u8 * e, int message_type, IPaddr_t ServerID,
                        IPaddr_t RequestedIP)
{
        u8 *start = e;
        u8 *cnt;
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)
        u8 *x;
#endif
 
        *e++ = 99;              /* RFC1048 Magic Cookie */
        *e++ = 130;
        *e++ = 83;
        *e++ = 99;
 
        *e++ = 53;              /* DHCP Message Type */
        *e++ = 1;
        *e++ = message_type;
 
        *e++ = 57;              /* Maximum DHCP Message Size */
        *e++ = 2;
        *e++ = (576 - 312 + OPT_SIZE) >> 8;
        *e++ = (576 - 312 + OPT_SIZE) & 0xff;
 
        if (ServerID) {
                *e++ = 54;      /* ServerID */
                *e++ = 4;
                *e++ = ServerID >> 24;
                *e++ = ServerID >> 16;
                *e++ = ServerID >> 8;
                *e++ = ServerID & 0xff;
        }
 
        if (RequestedIP) {
                *e++ = 50;      /* Requested IP */
                *e++ = 4;
                *e++ = RequestedIP >> 24;
                *e++ = RequestedIP >> 16;
                *e++ = RequestedIP >> 8;
                *e++ = RequestedIP & 0xff;
        }
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)
        if ((x = dhcp_vendorex_prep(e)))
                return x - start;
#endif
 
        *e++ = 55;              /* Parameter Request List */
        cnt = e++;              /* Pointer to count of requested items */
        *cnt = 0;
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SUBNETMASK)
        *e++ = 1;               /* Subnet Mask */
        *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_GATEWAY)
        *e++ = 3;               /* Router Option */
        *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS)
        *e++ = 6;               /* DNS Server(s) */
        *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_HOSTNAME)
        *e++ = 12;              /* Hostname */
        *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTFILESIZE)
        *e++ = 13;              /* Boot File Size */
        *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTPATH)
        *e++ = 17;              /* Boot path */
        *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_NISDOMAIN)
        *e++ = 40;              /* NIS Domain name request */
        *cnt += 1;
#endif
        *e++ = 255;             /* End of the list */
 
        /* Pad to minimal length */
#ifdef  CONFIG_DHCP_MIN_EXT_LEN
        while ((e - start) <= CONFIG_DHCP_MIN_EXT_LEN)
                *e++ = 0;
#endif
 
        return e - start;
}
 
#else /* CFG_CMD_DHCP */
/*
 *      Warning: no field size check - change CONFIG_BOOTP_MASK at your own risk!
 */
static int BootpExtended(u8 * e)
{
        u8 *start = e;
 
        *e++ = 99;              /* RFC1048 Magic Cookie */
        *e++ = 130;
        *e++ = 83;
        *e++ = 99;
 
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
        *e++ = 53;              /* DHCP Message Type */
        *e++ = 1;
        *e++ = DHCP_DISCOVER;
 
        *e++ = 57;              /* Maximum DHCP Message Size */
        *e++ = 2;
        *e++ = (576 - 312 + OPT_SIZE) >> 16;
        *e++ = (576 - 312 + OPT_SIZE) & 0xff;
#endif /* CFG_CMD_DHCP */
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SUBNETMASK)
        *e++ = 1;               /* Subnet mask request */
        *e++ = 4;
        e += 4;
#endif
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_GATEWAY)
        *e++ = 3;               /* Default gateway request */
        *e++ = 4;
        e += 4;
#endif
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS)
        *e++ = 6;               /* Domain Name Server */
        *e++ = 4;
        e += 4;
#endif
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_HOSTNAME)
        *e++ = 12;              /* Host name request */
        *e++ = 32;
        e += 32;
#endif
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTFILESIZE)
        *e++ = 13;              /* Boot file size */
        *e++ = 2;
        e += 2;
#endif
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTPATH)
        *e++ = 17;              /* Boot path */
        *e++ = 32;
        e += 32;
#endif
 
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_NISDOMAIN)
        *e++ = 40;              /* NIS Domain name request */
        *e++ = 32;
        e += 32;
#endif
 
        *e++ = 255;             /* End of the list */
 
        return e - start;
}
#endif /* CFG_CMD_DHCP */
 
void BootpRequest(void)
{
        volatile uchar *pkt, *iphdr;
        Bootp_t *bp;
        int ext_len, pktlen, iplen;
 
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
        dhcp_state = INIT;
#endif
 
#ifdef CONFIG_BOOTP_RANDOM_DELAY        /* Random BOOTP delay */
        unsigned char bi_enetaddr[6];
        int reg;
        char *e, *s;
        uchar tmp[64];
        ulong tst1, tst2, sum, m_mask, m_value = 0;
 
        if (BootpTry == 0) {
                /* get our mac */
                reg = getenv_r("ethaddr", tmp, sizeof(tmp));
                s = (reg > 0) ? tmp : NULL;
 
                for (reg = 0; reg < 6; ++reg) {
                        bi_enetaddr[reg] = s ? simple_strtoul(s, &e, 16) : 0;
                        if (s) {
                                s = (*e) ? e + 1 : e;
                        }
                }
#ifdef DEBUG
                printf("BootpRequest => Our Mac: ");
                for (reg = 0; reg < 6; reg++) {
                        printf("%x%c", bi_enetaddr[reg], reg == 5 ? '\n' : ':');
                }
#endif /* DEBUG */
 
                /* Mac-Manipulation 2 get seed1 */
                tst1 = 0;
                tst2 = 0;
                for (reg = 2; reg < 6; reg++) {
                        tst1 = tst1 << 8;
                        tst1 = tst1 | bi_enetaddr[reg];
                }
                for (reg = 0; reg < 2; reg++) {
                        tst2 = tst2 | bi_enetaddr[reg];
                        tst2 = tst2 << 8;
                }
 
                seed1 = tst1 ^ tst2;
 
                /* Mirror seed1 */
                m_mask = 0x1;
                for (reg = 1; reg <= 32; reg++) {
                        m_value |= (m_mask & seed1);
                        seed1 = seed1 >> 1;
                        m_value = m_value << 1;
                }
                seed1 = m_value;
                seed2 = 0xB78D0945;
        }
 
        /* Random Number Generator */
 
        for (reg = 0; reg <= 0; reg++) {
                sum = seed1 + seed2;
                if (sum < seed1 || sum < seed2)
                        sum++;
                seed2 = seed1;
                seed1 = sum;
 
                if (BootpTry <= 2) {    /* Start with max 1024 * 1ms */
                        sum = sum >> (22 - BootpTry);
                } else {        /*After 3rd BOOTP request max 8192 * 1ms */
                        sum = sum >> 19;
                }
        }
 
        printf("Random delay: %ld ms...\n", sum);
        for (reg = 0; reg < sum; reg++) {
                udelay(1000);   /*Wait 1ms */
        }
#endif /* CONFIG_BOOTP_RANDOM_DELAY */
 
        printf("BOOTP broadcast %d\n", ++BootpTry);
        pkt = NetTxPacket;
        memset((void *)pkt, 0, PKTSIZE);
 
        NetSetEther(pkt, NetBcastAddr, PROT_IP);
        pkt += ETHER_HDR_SIZE;
 
        /*
         * Next line results in incorrect packet size being transmitted, resulting
         * in errors in some DHCP servers, reporting missing bytes.  Size must be
         * set in packet header after extension length has been determined.
         * C. Hallinan, DS4.COM, Inc.
         */
        /* NetSetIP(pkt, 0xffffffffL, PORT_BOOTPS, PORT_BOOTPC, sizeof (Bootp_t)); */
        iphdr = pkt;            /* We need this later for NetSetIP() */
        pkt += IP_HDR_SIZE;
 
        bp = (Bootp_t *) pkt;
        bp->bp_op = OP_BOOTREQUEST;
        bp->bp_htype = HWT_ETHER;
        bp->bp_hlen = HWL_ETHER;
        bp->bp_hops = 0;
        bp->bp_secs = SWAP16(get_timer(0) / CFG_HZ);
        bp->bp_ciaddr = 0;
        bp->bp_yiaddr = 0;
        bp->bp_siaddr = 0;
        bp->bp_giaddr = 0;
        NetCopyEther(bp->bp_chaddr, NetOurEther);
        copy_filename(bp->bp_file, BootFile, sizeof(bp->bp_file));
 
        /* Request additional information from the BOOTP/DHCP server */
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
        ext_len = DhcpExtended(bp->bp_vend, DHCP_DISCOVER, 0, 0);
#else
        ext_len = BootpExtended(bp->bp_vend);
#endif /* CFG_CMD_DHCP */
 
        /*
         *      Bootp ID is the lower 4 bytes of our ethernet address
         *      plus the current time in HZ.
         */
        BootpID = ((ulong) NetOurEther[2] << 24)
            | ((ulong) NetOurEther[3] << 16)
            | ((ulong) NetOurEther[4] << 8)
            | (ulong) NetOurEther[5];
        BootpID += get_timer(0);
        bp->bp_id = BootpID;
 
        /*
         * Calculate proper packet lengths taking into account the
         * variable size of the options field
         */
        pktlen = BOOTP_SIZE - sizeof(bp->bp_vend) + ext_len;
        iplen = BOOTP_HDR_SIZE - sizeof(bp->bp_vend) + ext_len;
        NetSetIP(iphdr, 0xffffffffL, PORT_BOOTPS, PORT_BOOTPC, iplen);
        NetSetTimeout(SELECT_TIMEOUT * CFG_HZ, BootpTimeout);
 
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
        dhcp_state = SELECTING;
        NetSetHandler(DhcpHandler);
#else
        NetSetHandler(BootpHandler);
#endif /* CFG_CMD_DHCP */
        NetSendPacket(NetTxPacket, pktlen);
}
 
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
void DhcpOptionsProcess(char *popt)
{
        char *end = popt + BOOTP_HDR_SIZE;
        int oplen, size;
 
        while (popt < end && *popt != 0xff) {
                oplen = *(popt + 1);
                switch (*popt) {
                case 1:
                        NetOurSubnetMask = *(IPaddr_t *) (popt + 2);
                        break;
                case 3:
                        NetOurGatewayIP = *(IPaddr_t *) (popt + 2);
                        break;
                case 6:
                        NetOurDNSIP = *(IPaddr_t *) (popt + 2);
                        break;
                case 12:
                        size = truncate_sz("Host Name",
                                           sizeof(NetOurHostName), oplen);
                        memcpy(&NetOurHostName, popt + 2, size);
                        NetOurHostName[size] = 0;
                        break;
                case 15:        /* Ignore Domain Name Option */
                        break;
                case 17:
                        size = truncate_sz("Root Path",
                                           sizeof(NetOurRootPath), oplen);
                        memcpy(&NetOurRootPath, popt + 2, size);
                        NetOurRootPath[size] = 0;
                        break;
                case 51:
                        dhcp_leasetime = *(unsigned int *)(popt + 2);
                        break;
                case 53:        /* Ignore Message Type Option */
                        break;
                case 54:
                        NetServerIP = *(IPaddr_t *) (popt + 2);
                        break;
                case 58:        /* Ignore Renewal Time Option */
                        break;
                case 59:        /* Ignore Rebinding Time Option */
                        break;
                default:
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)
                        if (dhcp_vendorex_proc(popt))
                                break;
#endif
                        printf("*** Unhandled DHCP Option in OFFER/ACK: %d\n",
                               *popt);
                        break;
                }
                popt += oplen + 2;      /* Process next option */
        }
}
 
static int DhcpMessageType(unsigned char *popt)
{
        if ((*(uint *) popt) != BOOTP_VENDOR_MAGIC)
                return -1;
 
        popt += 4;
        while (*popt != 0xff) {
                if (*popt == 53)        /* DHCP Message Type */
                        return *(popt + 2);
                popt += *(popt + 1) + 2;        /* Scan through all options */
        }
        return -1;
}
 
void DhcpSendRequestPkt(Bootp_t * bp_offer)
{
        volatile uchar *pkt, *iphdr;
        Bootp_t *bp;
        int pktlen, iplen, extlen;
 
        debug("DhcpSendRequestPkt: Sending DHCPREQUEST\n");
        pkt = NetTxPacket;
        memset((void *)pkt, 0, PKTSIZE);
 
        NetSetEther(pkt, NetBcastAddr, PROT_IP);
        pkt += ETHER_HDR_SIZE;
 
        iphdr = pkt;            /* We'll need this later to set proper pkt size */
        pkt += IP_HDR_SIZE;
 
        bp = (Bootp_t *) pkt;
        bp->bp_op = OP_BOOTREQUEST;
        bp->bp_htype = HWT_ETHER;
        bp->bp_hlen = HWL_ETHER;
        bp->bp_hops = 0;
        bp->bp_secs = SWAP16(get_timer(0) / CFG_HZ);
        bp->bp_ciaddr = bp_offer->bp_ciaddr;
        bp->bp_yiaddr = bp_offer->bp_yiaddr;
        bp->bp_siaddr = bp_offer->bp_siaddr;
        bp->bp_giaddr = bp_offer->bp_giaddr;
        NetCopyEther(bp->bp_chaddr, NetOurEther);
 
        /*
         * ID is the id of the OFFER packet
         */
 
        bp->bp_id = bp_offer->bp_id;
 
        /*
         * Copy options from OFFER packet if present
         */
        extlen =
            DhcpExtended(bp->bp_vend, DHCP_REQUEST, NetServerIP, bp->bp_yiaddr);
 
        pktlen = BOOTP_SIZE - sizeof(bp->bp_vend) + extlen;
        iplen = BOOTP_HDR_SIZE - sizeof(bp->bp_vend) + extlen;
        NetSetIP(iphdr, 0xffffffffL, PORT_BOOTPS, PORT_BOOTPC, iplen);
 
        debug("Transmitting DHCPREQUEST packet: len = %d\n", pktlen);
        NetSendPacket(NetTxPacket, pktlen);
}
 
/*
 *      Handle DHCP received packets.
 */
static void DhcpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
        Bootp_t *bp = (Bootp_t *) pkt;
 
        debug("DHCPHandler: got packet: (src=%d, dst=%d, len=%d) state: %d\n",
              src, dest, len, dhcp_state);
 
        if (BootpCheckPkt(pkt, dest, src, len)) /* Filter out pkts we don't want */
                return;
 
        debug
            ("DHCPHandler: got DHCP packet: (src=%d, dst=%d, len=%d) state: %d\n",
             src, dest, len, dhcp_state);
 
        switch (dhcp_state) {
        case SELECTING:
                /*
                 * Wait an appropriate time for any potential DHCPOFFER packets
                 * to arrive.  Then select one, and generate DHCPREQUEST response.
                 * If filename is in format we recognize, assume it is a valid
                 * OFFER from a server we want.
                 */
                debug("DHCP: state=SELECTING bp_file: \"%s\"\n", bp->bp_file);
#ifdef CFG_BOOTFILE_PREFIX
                if (strncmp(bp->bp_file,
                            CFG_BOOTFILE_PREFIX,
                            strlen(CFG_BOOTFILE_PREFIX)) == 0) {
#endif /* CFG_BOOTFILE_PREFIX */
 
                        debug("TRANSITIONING TO REQUESTING STATE\n");
                        dhcp_state = REQUESTING;
#if 0
                        if ((*(uint *) bp->bp_vend) == BOOTP_VENDOR_MAGIC)
                                DhcpOptionsProcess(&bp->bp_vend[4]);
 
#endif
                        BootpCopyNetParams(bp); /* Store net params from reply */
 
                        NetSetTimeout(TIMEOUT * CFG_HZ, BootpTimeout);
                        DhcpSendRequestPkt(bp);
#ifdef CFG_BOOTFILE_PREFIX
                }
#endif /* CFG_BOOTFILE_PREFIX */
 
                return;
                break;
        case REQUESTING:
                debug("DHCP State: REQUESTING\n");
 
                if (DhcpMessageType(bp->bp_vend) == DHCP_ACK) {
                        char *s;
 
                        if ((*(uint *) bp->bp_vend) == BOOTP_VENDOR_MAGIC)
                                DhcpOptionsProcess(&bp->bp_vend[4]);
                        BootpCopyNetParams(bp); /* Store net params from reply */
                        dhcp_state = BOUND;
                        printf("DHCP client bound to address ");
                        print_IPaddr(NetOurIP);
                        printf("\n");
 
                        /* Obey the 'autoload' setting */
                        if (((s = getenv("autoload")) != NULL) && (*s == 'n')) {
                                NetState = NETLOOP_SUCCESS;
                                return;
                        }
                        /* Send ARP request to get TFTP server ethernet address.
                         * This automagically starts TFTP, too.
                         */
                        ArpRequest();
                        return;
                }
                break;
        default:
                printf("DHCP: INVALID STATE\n");
                break;
        }
 
}
 
void DhcpRequest(void)
{
        BootpRequest();
}
#endif /* CFG_CMD_DHCP */
 
#endif /* CFG_CMD_NET */

Line No.	Rev	Author	Line
1	2	marcus.erl	`/*`
2			`* Based on LiMon - BOOTP.`
3			`*`
4			`* Copyright 1994, 1995, 2000 Neil Russell.`
5			`* (See License)`
6			`* Copyright 2000 Roland Borde`
7			`* Copyright 2000 Paolo Scaffardi`
8			`*/`
9
10	140	julius	`#if 1`
11	2	marcus.erl	`#define DEBUG 1 /* general debug */`
12	406	julius	`#define DEBUG_BOOTP_EXT 1 /* Debug received vendor fields */`
13	2	marcus.erl	`#endif`
14
15			`#ifdef DEBUG_BOOTP_EXT`
16			`#define debug_ext(fmt,args...) printf (fmt ,##args)`
17			`#else`
18			`#define debug_ext(fmt,args...)`
19			`#endif`
20
21			`#include "common.h"`
22			`#include "net.h"`
23			`#include "bootp.h"`
24			`#include "tftp.h"`
25			`#include "arp.h"`
26
27	406	julius	`#define BOOTP_VENDOR_MAGIC 0x63825363 /* RFC1048 Magic Cookie */`
28	2	marcus.erl
29			`#if (CONFIG_COMMANDS & CFG_CMD_NET)`
30
31	406	julius	`#define TIMEOUT 5 /* Seconds before trying BOOTP again */`
32			`#define TIMEOUT_COUNT 1 /* # of timeouts before giving up */`
33	2	marcus.erl
34	406	julius	`#define PORT_BOOTPS 67 /* BOOTP server UDP port */`
35			`#define PORT_BOOTPC 68 /* BOOTP client UDP port */`
36	2	marcus.erl
37	406	julius	`#ifndef CONFIG_DHCP_MIN_EXT_LEN /* minimal length of extension list */`
38	2	marcus.erl	`#define CONFIG_DHCP_MIN_EXT_LEN 64`
39			`#endif`
40
41	406	julius	`ulong BootpID;`
42			`int BootpTry;`
43	2	marcus.erl	`#ifdef CONFIG_BOOTP_RANDOM_DELAY`
44	406	julius	`ulong seed1, seed2;`
45	2	marcus.erl	`#endif`
46
47			`#if (CONFIG_COMMANDS & CFG_CMD_DHCP)`
48			`dhcp_state_t dhcp_state = INIT;`
49			`unsigned int dhcp_leasetime = 0;`
50			`static void DhcpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len);`
51
52			`/* For Debug */`
53			`char *dhcpmsg2str(int type)`
54			`{`
55			`switch (type) {`
56	406	julius	`case 1:`
57			`return "DHCPDISCOVER";`
58			`break;`
59			`case 2:`
60			`return "DHCPOFFER";`
61			`break;`
62			`case 3:`
63			`return "DHCPREQUEST";`
64			`break;`
65			`case 4:`
66			`return "DHCPDECLINE";`
67			`break;`
68			`case 5:`
69			`return "DHCPACK";`
70			`break;`
71			`case 6:`
72			`return "DHCPNACK";`
73			`break;`
74			`case 7:`
75			`return "DHCPRELEASE";`
76			`break;`
77			`default:`
78			`return "UNKNOWN/INVALID MSG TYPE";`
79			`break;`
80	2	marcus.erl	`}`
81			`}`
82
83			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)`
84	406	julius	`extern u8 dhcp_vendorex_prep(u8 e); /rtn new e after add own opts. /`
85			`extern u8 dhcp_vendorex_proc(u8 e); /rtn next e if mine,else NULL /`
86	2	marcus.erl	`#endif`
87
88	406	julius	`#endif /* CFG_CMD_DHCP */`
89	2	marcus.erl
90	406	julius	`static int BootpCheckPkt(uchar * pkt, unsigned dest, unsigned src, unsigned len)`
91	2	marcus.erl	`{`
92			`Bootp_t bp = (Bootp_t ) pkt;`
93			`int retval = 0;`
94
95			`if (dest != PORT_BOOTPC \|\| src != PORT_BOOTPS)`
96			`retval = -1;`
97	406	julius	`if (len < sizeof(Bootp_t) - OPT_SIZE)`
98	2	marcus.erl	`retval = -2;`
99			`if (bp->bp_op != OP_BOOTREQUEST &&`
100			`bp->bp_op != OP_BOOTREPLY &&`
101			`bp->bp_op != DHCP_OFFER &&`
102	406	julius	`bp->bp_op != DHCP_ACK && bp->bp_op != DHCP_NAK) {`
103	2	marcus.erl	`retval = -3;`
104			`}`
105			`if (bp->bp_htype != HWT_ETHER)`
106			`retval = -4;`
107			`if (bp->bp_hlen != HWL_ETHER)`
108			`retval = -5;`
109			`if (bp->bp_id != BootpID)`
110			`retval = -6;`
111
112	406	julius	`debug("Filtering pkt = %d\n", retval);`
113	2	marcus.erl
114			`return retval;`
115			`}`
116
117			`/*`
118			`* Copy parameters of interest from BOOTP_REPLY/DHCP_OFFER packet`
119			`*/`
120	406	julius	`void BootpCopyNetParams(Bootp_t * bp)`
121	2	marcus.erl	`{`
122			`NetOurIP = bp->bp_yiaddr;`
123			`NetServerIP = bp->bp_siaddr;`
124	406	julius	`NetCopyEther(NetServerEther, ((Ethernet_t *) NetRxPkt)->et_src);`
125			`copy_filename(BootFile, bp->bp_file, sizeof(BootFile));`
126	2	marcus.erl
127	406	julius	`debug("Bootfile: %s\n", BootFile);`
128	2	marcus.erl
129			`/* Propagate to environment:`
130	406	julius	`* don't delete exising entry when BOOTP / DHCP reply does`
131	2	marcus.erl	`* not contain a new value`
132			`*/`
133			`if (*BootFile) {`
134	406	julius	`setenv("bootfile", BootFile);`
135	2	marcus.erl	`}`
136			`}`
137
138	406	julius	`static int truncate_sz(const char *name, int maxlen, int curlen)`
139	2	marcus.erl	`{`
140			`if (curlen >= maxlen) {`
141	406	julius	`printf`
142			`("*** WARNING: %s is too long (%d - max: %d) - truncated\n",`
143			`name, curlen, maxlen);`
144	2	marcus.erl	`curlen = maxlen - 1;`
145			`}`
146			`return (curlen);`
147			`}`
148
149			`#if !(CONFIG_COMMANDS & CFG_CMD_DHCP)`
150
151	406	julius	`static void BootpVendorFieldProcess(u8 * ext)`
152	2	marcus.erl	`{`
153	406	julius	`int size = *(ext + 1);`
154	2	marcus.erl
155	406	julius	`debug_ext("[BOOTP] Processing extension %d... (%d bytes)\n", *ext,`
156			`*(ext + 1));`
157	2	marcus.erl
158	406	julius	`NetBootFileSize = 0;`
159	2	marcus.erl
160	406	julius	`switch (*ext) {`
161			`/* Fixed length fields */`
162			`case 1: /* Subnet mask */`
163	2	marcus.erl	`if (NetOurSubnetMask == 0)`
164	406	julius	`memcpy(&NetOurSubnetMask, ext + 2, 4);`
165	2	marcus.erl	`break;`
166	406	julius	`case 2: /* Time offset - Not yet supported */`
167	2	marcus.erl	`break;`
168	406	julius	`/* Variable length fields */`
169			`case 3: /* Gateways list */`
170	2	marcus.erl	`if (NetOurGatewayIP == 0) {`
171	406	julius	`memcpy(&NetOurGatewayIP, ext + 2, 4);`
172	2	marcus.erl	`}`
173			`break;`
174	406	julius	`case 4: /* Time server - Not yet supported */`
175	2	marcus.erl	`break;`
176	406	julius	`case 5: /* IEN-116 name server - Not yet supported */`
177	2	marcus.erl	`break;`
178			`case 6:`
179			`if (NetOurDNSIP == 0) {`
180	406	julius	`memcpy(&NetOurDNSIP, ext + 2, 4);`
181	2	marcus.erl	`}`
182			`break;`
183	406	julius	`case 7: /* Log server - Not yet supported */`
184	2	marcus.erl	`break;`
185	406	julius	`case 8: /* Cookie/Quote server - Not yet supported */`
186	2	marcus.erl	`break;`
187	406	julius	`case 9: /* LPR server - Not yet supported */`
188	2	marcus.erl	`break;`
189	406	julius	`case 10: /* Impress server - Not yet supported */`
190	2	marcus.erl	`break;`
191	406	julius	`case 11: /* RPL server - Not yet supported */`
192	2	marcus.erl	`break;`
193	406	julius	`case 12: /* Host name */`
194	2	marcus.erl	`if (NetOurHostName[0] == 0) {`
195	406	julius	`size =`
196			`truncate_sz("Host Name", sizeof(NetOurHostName),`
197			`size);`
198			`memcpy(&NetOurHostName, ext + 2, size);`
199			`NetOurHostName[size] = 0;`
200	2	marcus.erl	`}`
201			`break;`
202	406	julius	`case 13: /* Boot file size */`
203			`memcpy(&NetBootFileSize, ext + 2, size);`
204	2	marcus.erl	`break;`
205	406	julius	`case 14: /* Merit dump file - Not yet supported */`
206	2	marcus.erl	`break;`
207	406	julius	`case 15: /* Domain name - Not yet supported */`
208	2	marcus.erl	`break;`
209	406	julius	`case 16: /* Swap server - Not yet supported */`
210	2	marcus.erl	`break;`
211	406	julius	`case 17: /* Root path */`
212	2	marcus.erl	`if (NetOurRootPath[0] == 0) {`
213	406	julius	`size =`
214			`truncate_sz("Root Path", sizeof(NetOurRootPath),`
215			`size);`
216			`memcpy(&NetOurRootPath, ext + 2, size);`
217			`NetOurRootPath[size] = 0;`
218	2	marcus.erl	`}`
219			`break;`
220	406	julius	`case 18: /* Extension path - Not yet supported */`
221	2	marcus.erl	`/*`
222	406	julius	`* This can be used to send the informations of the`
223			`* vendor area in another file that the client can`
224			`* access via TFTP.`
225	2	marcus.erl	`*/`
226			`break;`
227	406	julius	`/* IP host layer fields */`
228			`case 40: /* NIS Domain name */`
229	2	marcus.erl	`if (NetOurNISDomain[0] == 0) {`
230	406	julius	`size = truncate_sz("NIS Domain Name",`
231			`sizeof(NetOurNISDomain), size);`
232			`memcpy(&NetOurNISDomain, ext + 2, size);`
233			`NetOurNISDomain[size] = 0;`
234	2	marcus.erl	`}`
235			`break;`
236	406	julius	`/* Application layer fields */`
237			`case 43: /* Vendor specific info - Not yet supported */`
238	2	marcus.erl	`/*`
239	406	julius	`* Binary informations to exchange specific`
240			`* product information.`
241	2	marcus.erl	`*/`
242			`break;`
243	406	julius	`/* Reserved (custom) fields (128..254) */`
244			`}`
245	2	marcus.erl	`}`
246
247	406	julius	`static void BootpVendorProcess(u8 * ext, int size)`
248	2	marcus.erl	`{`
249	406	julius	`u8 *end = ext + size;`
250	2	marcus.erl
251	406	julius	`debug_ext("[BOOTP] Checking extension (%d bytes)...\n", size);`
252	2	marcus.erl
253	406	julius	`while ((ext < end) && (*ext != 0xff)) {`
254			`if (*ext == 0) {`
255			`ext++;`
256			`} else {`
257			`u8 *opt = ext;`
258			`ext += ext[1] + 2;`
259			`if (ext <= end)`
260			`BootpVendorFieldProcess(opt);`
261			`}`
262	2	marcus.erl	`}`
263
264			`#ifdef DEBUG_BOOTP_EXT`
265	406	julius	`printf("[BOOTP] Received fields: \n");`
266			`if (NetOurSubnetMask) {`
267			`puts("NetOurSubnetMask : ");`
268			`print_IPaddr(NetOurSubnetMask);`
269			`putc('\n');`
270			`}`
271	2	marcus.erl
272	406	julius	`if (NetOurGatewayIP) {`
273			`puts("NetOurGatewayIP : ");`
274			`print_IPaddr(NetOurGatewayIP);`
275			`putc('\n');`
276			`}`
277	2	marcus.erl
278	406	julius	`if (NetBootFileSize) {`
279			`printf("NetBootFileSize : %d\n", NetBootFileSize);`
280			`}`
281	2	marcus.erl
282	406	julius	`if (NetOurHostName[0]) {`
283			`printf("NetOurHostName : %s\n", NetOurHostName);`
284			`}`
285	2	marcus.erl
286	406	julius	`if (NetOurRootPath[0]) {`
287			`printf("NetOurRootPath : %s\n", NetOurRootPath);`
288			`}`
289	2	marcus.erl
290	406	julius	`if (NetOurNISDomain[0]) {`
291			`printf("NetOurNISDomain : %s\n", NetOurNISDomain);`
292			`}`
293			`#endif /* DEBUG_BOOTP_EXT */`
294	2	marcus.erl	`}`
295
296			`/*`
297			`* Handle a BOOTP received packet.`
298			`*/`
299	406	julius	`static void BootpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)`
300	2	marcus.erl	`{`
301			`Bootp_t *bp;`
302	406	julius	`char *s;`
303	2	marcus.erl
304	406	julius	`debug("got BOOTP packet (src=%d, dst=%d, len=%d want_len=%d)\n",`
305			`src, dest, len, sizeof(Bootp_t));`
306	2	marcus.erl
307	406	julius	`bp = (Bootp_t *) pkt;`
308	2	marcus.erl
309			`if (BootpCheckPkt(pkt, dest, src, len)) /* Filter out pkts we don't want */`
310			`return;`
311
312			`/*`
313	406	julius	`* Got a good BOOTP reply. Copy the data into our variables.`
314	2	marcus.erl	`*/`
315			`#ifdef CONFIG_STATUS_LED`
316	406	julius	`status_led_set(STATUS_LED_BOOT, STATUS_LED_OFF);`
317	2	marcus.erl	`#endif`
318
319	406	julius	`BootpCopyNetParams(bp); /* Store net parameters from reply */`
320	2	marcus.erl
321			`/* Retrieve extended informations (we must parse the vendor area) */`
322	406	julius	`if (((uint ) bp->bp_vend) == BOOTP_VENDOR_MAGIC)`
323			`BootpVendorProcess(&bp->bp_vend[4], len);`
324	2	marcus.erl
325	406	julius	`NetSetTimeout(0, (thand_f *) 0);`
326	2	marcus.erl
327	406	julius	`debug("Got good BOOTP\n");`
328	2	marcus.erl
329			`if (((s = getenv("autoload")) != NULL) && (*s == 'n')) {`
330			`/*`
331			`* Just use BOOTP to configure system;`
332			`* Do not use TFTP to load the bootfile.`
333			`*/`
334			`NetState = NETLOOP_SUCCESS;`
335			`return;`
336			`}`
337
338			`/* Send ARP request to get TFTP server ethernet address.`
339			`* This automagically starts TFTP, too.`
340			`*/`
341			`ArpRequest();`
342			`}`
343	406	julius	`#endif /* !CFG_CMD_DHCP */`
344	2	marcus.erl
345			`/*`
346			`* Timeout on BOOTP/DHCP request.`
347			`*/`
348	406	julius	`static void BootpTimeout(void)`
349	2	marcus.erl	`{`
350			`if (BootpTry >= TIMEOUT_COUNT) {`
351	406	julius	`puts("\nRetry count exceeded; starting again\n");`
352			`NetStartAgain();`
353	2	marcus.erl	`} else {`
354	406	julius	`NetSetTimeout(TIMEOUT * CFG_HZ, BootpTimeout);`
355			`BootpRequest();`
356	2	marcus.erl	`}`
357			`}`
358
359			`/*`
360			`* Initialize BOOTP extension fields in the request.`
361			`*/`
362			`#if (CONFIG_COMMANDS & CFG_CMD_DHCP)`
363	406	julius	`static int DhcpExtended(u8 * e, int message_type, IPaddr_t ServerID,`
364			`IPaddr_t RequestedIP)`
365	2	marcus.erl	`{`
366	406	julius	`u8 *start = e;`
367			`u8 *cnt;`
368	2	marcus.erl	`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)`
369	406	julius	`u8 *x;`
370	2	marcus.erl	`#endif`
371
372	406	julius	`e++ = 99; / RFC1048 Magic Cookie */`
373			`*e++ = 130;`
374			`*e++ = 83;`
375			`*e++ = 99;`
376	2	marcus.erl
377	406	julius	`e++ = 53; / DHCP Message Type */`
378			`*e++ = 1;`
379			`*e++ = message_type;`
380	2	marcus.erl
381	406	julius	`e++ = 57; / Maximum DHCP Message Size */`
382			`*e++ = 2;`
383			`*e++ = (576 - 312 + OPT_SIZE) >> 8;`
384			`*e++ = (576 - 312 + OPT_SIZE) & 0xff;`
385	2	marcus.erl
386	406	julius	`if (ServerID) {`
387			`e++ = 54; / ServerID */`
388			`*e++ = 4;`
389			`*e++ = ServerID >> 24;`
390			`*e++ = ServerID >> 16;`
391			`*e++ = ServerID >> 8;`
392			`*e++ = ServerID & 0xff;`
393			`}`
394	2	marcus.erl
395	406	julius	`if (RequestedIP) {`
396			`e++ = 50; / Requested IP */`
397			`*e++ = 4;`
398			`*e++ = RequestedIP >> 24;`
399			`*e++ = RequestedIP >> 16;`
400			`*e++ = RequestedIP >> 8;`
401			`*e++ = RequestedIP & 0xff;`
402			`}`
403	2	marcus.erl	`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)`
404	406	julius	`if ((x = dhcp_vendorex_prep(e)))`
405			`return x - start;`
406	2	marcus.erl	`#endif`
407
408	406	julius	`e++ = 55; / Parameter Request List */`
409			`cnt = e++; /* Pointer to count of requested items */`
410			`*cnt = 0;`
411	2	marcus.erl	`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SUBNETMASK)`
412	406	julius	`e++ = 1; / Subnet Mask */`
413			`*cnt += 1;`
414	2	marcus.erl	`#endif`
415			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_GATEWAY)`
416	406	julius	`e++ = 3; / Router Option */`
417			`*cnt += 1;`
418	2	marcus.erl	`#endif`
419			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS)`
420	406	julius	`e++ = 6; / DNS Server(s) */`
421			`*cnt += 1;`
422	2	marcus.erl	`#endif`
423			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_HOSTNAME)`
424	406	julius	`e++ = 12; / Hostname */`
425			`*cnt += 1;`
426	2	marcus.erl	`#endif`
427			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTFILESIZE)`
428	406	julius	`e++ = 13; / Boot File Size */`
429			`*cnt += 1;`
430	2	marcus.erl	`#endif`
431			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTPATH)`
432	406	julius	`e++ = 17; / Boot path */`
433			`*cnt += 1;`
434	2	marcus.erl	`#endif`
435			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_NISDOMAIN)`
436	406	julius	`e++ = 40; / NIS Domain name request */`
437			`*cnt += 1;`
438	2	marcus.erl	`#endif`
439	406	julius	`e++ = 255; / End of the list */`
440	2	marcus.erl
441	406	julius	`/* Pad to minimal length */`
442	2	marcus.erl	`#ifdef CONFIG_DHCP_MIN_EXT_LEN`
443	406	julius	`while ((e - start) <= CONFIG_DHCP_MIN_EXT_LEN)`
444			`*e++ = 0;`
445	2	marcus.erl	`#endif`
446
447	406	julius	`return e - start;`
448	2	marcus.erl	`}`
449
450	406	julius	`#else /* CFG_CMD_DHCP */`
451	2	marcus.erl	`/*`
452			`* Warning: no field size check - change CONFIG_BOOTP_MASK at your own risk!`
453			`*/`
454	406	julius	`static int BootpExtended(u8 * e)`
455	2	marcus.erl	`{`
456	406	julius	`u8 *start = e;`
457	2	marcus.erl
458	406	julius	`e++ = 99; / RFC1048 Magic Cookie */`
459			`*e++ = 130;`
460			`*e++ = 83;`
461			`*e++ = 99;`
462	2	marcus.erl
463			`#if (CONFIG_COMMANDS & CFG_CMD_DHCP)`
464	406	julius	`e++ = 53; / DHCP Message Type */`
465			`*e++ = 1;`
466			`*e++ = DHCP_DISCOVER;`
467	2	marcus.erl
468	406	julius	`e++ = 57; / Maximum DHCP Message Size */`
469			`*e++ = 2;`
470			`*e++ = (576 - 312 + OPT_SIZE) >> 16;`
471			`*e++ = (576 - 312 + OPT_SIZE) & 0xff;`
472			`#endif /* CFG_CMD_DHCP */`
473	2	marcus.erl
474			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SUBNETMASK)`
475	406	julius	`e++ = 1; / Subnet mask request */`
476			`*e++ = 4;`
477			`e += 4;`
478	2	marcus.erl	`#endif`
479
480			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_GATEWAY)`
481	406	julius	`e++ = 3; / Default gateway request */`
482			`*e++ = 4;`
483			`e += 4;`
484	2	marcus.erl	`#endif`
485
486			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS)`
487	406	julius	`e++ = 6; / Domain Name Server */`
488			`*e++ = 4;`
489			`e += 4;`
490	2	marcus.erl	`#endif`
491
492			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_HOSTNAME)`
493	406	julius	`e++ = 12; / Host name request */`
494			`*e++ = 32;`
495			`e += 32;`
496	2	marcus.erl	`#endif`
497
498			`#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTFILESIZE)`
499	406	julius	`e++ = 13; / Boot file size */`
500			`*e++ = 2;`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [services/] [bootp.c] - Blame information for rev 406