Home | History | Annotate | Download | only in dhcp
      1 package android.net.dhcp;
      2 
      3 import android.util.Log;
      4 
      5 import java.io.UnsupportedEncodingException;
      6 import java.net.InetAddress;
      7 import java.net.UnknownHostException;
      8 import java.nio.ByteBuffer;
      9 import java.nio.ByteOrder;
     10 import java.nio.charset.Charsets;
     11 import java.nio.ShortBuffer;
     12 
     13 import java.util.ArrayList;
     14 import java.util.List;
     15 
     16 /**
     17  * Defines basic data and operations needed to build and use packets for the
     18  * DHCP protocol.  Subclasses create the specific packets used at each
     19  * stage of the negotiation.
     20  */
     21 abstract class DhcpPacket {
     22     protected static final String TAG = "DhcpPacket";
     23 
     24     /**
     25      * Packet encapsulations.
     26      */
     27     public static final int ENCAP_L2 = 0;    // EthernetII header included
     28     public static final int ENCAP_L3 = 1;    // IP/UDP header included
     29     public static final int ENCAP_BOOTP = 2; // BOOTP contents only
     30 
     31     /**
     32      * IP layer definitions.
     33      */
     34     private static final byte IP_TYPE_UDP = (byte) 0x11;
     35 
     36     /**
     37      * IP: Version 4, Header Length 20 bytes
     38      */
     39     private static final byte IP_VERSION_HEADER_LEN = (byte) 0x45;
     40 
     41     /**
     42      * IP: Flags 0, Fragment Offset 0, Don't Fragment
     43      */
     44     private static final short IP_FLAGS_OFFSET = (short) 0x4000;
     45 
     46     /**
     47      * IP: TOS
     48      */
     49     private static final byte IP_TOS_LOWDELAY = (byte) 0x10;
     50 
     51     /**
     52      * IP: TTL -- use default 64 from RFC1340
     53      */
     54     private static final byte IP_TTL = (byte) 0x40;
     55 
     56     /**
     57      * The client DHCP port.
     58      */
     59     static final short DHCP_CLIENT = (short) 68;
     60 
     61     /**
     62      * The server DHCP port.
     63      */
     64     static final short DHCP_SERVER = (short) 67;
     65 
     66     /**
     67      * The message op code indicating a request from a client.
     68      */
     69     protected static final byte DHCP_BOOTREQUEST = (byte) 1;
     70 
     71     /**
     72      * The message op code indicating a response from the server.
     73      */
     74     protected static final byte DHCP_BOOTREPLY = (byte) 2;
     75 
     76     /**
     77      * The code type used to identify an Ethernet MAC address in the
     78      * Client-ID field.
     79      */
     80     protected static final byte CLIENT_ID_ETHER = (byte) 1;
     81 
     82     /**
     83      * The maximum length of a packet that can be constructed.
     84      */
     85     protected static final int MAX_LENGTH = 1500;
     86 
     87     /**
     88      * DHCP Optional Type: DHCP Subnet Mask
     89      */
     90     protected static final byte DHCP_SUBNET_MASK = 1;
     91     protected InetAddress mSubnetMask;
     92 
     93     /**
     94      * DHCP Optional Type: DHCP Router
     95      */
     96     protected static final byte DHCP_ROUTER = 3;
     97     protected InetAddress mGateway;
     98 
     99     /**
    100      * DHCP Optional Type: DHCP DNS Server
    101      */
    102     protected static final byte DHCP_DNS_SERVER = 6;
    103     protected List<InetAddress> mDnsServers;
    104 
    105     /**
    106      * DHCP Optional Type: DHCP Host Name
    107      */
    108     protected static final byte DHCP_HOST_NAME = 12;
    109     protected String mHostName;
    110 
    111     /**
    112      * DHCP Optional Type: DHCP DOMAIN NAME
    113      */
    114     protected static final byte DHCP_DOMAIN_NAME = 15;
    115     protected String mDomainName;
    116 
    117     /**
    118      * DHCP Optional Type: DHCP BROADCAST ADDRESS
    119      */
    120     protected static final byte DHCP_BROADCAST_ADDRESS = 28;
    121     protected InetAddress mBroadcastAddress;
    122 
    123     /**
    124      * DHCP Optional Type: DHCP Requested IP Address
    125      */
    126     protected static final byte DHCP_REQUESTED_IP = 50;
    127     protected InetAddress mRequestedIp;
    128 
    129     /**
    130      * DHCP Optional Type: DHCP Lease Time
    131      */
    132     protected static final byte DHCP_LEASE_TIME = 51;
    133     protected Integer mLeaseTime;
    134 
    135     /**
    136      * DHCP Optional Type: DHCP Message Type
    137      */
    138     protected static final byte DHCP_MESSAGE_TYPE = 53;
    139     // the actual type values
    140     protected static final byte DHCP_MESSAGE_TYPE_DISCOVER = 1;
    141     protected static final byte DHCP_MESSAGE_TYPE_OFFER = 2;
    142     protected static final byte DHCP_MESSAGE_TYPE_REQUEST = 3;
    143     protected static final byte DHCP_MESSAGE_TYPE_DECLINE = 4;
    144     protected static final byte DHCP_MESSAGE_TYPE_ACK = 5;
    145     protected static final byte DHCP_MESSAGE_TYPE_NAK = 6;
    146     protected static final byte DHCP_MESSAGE_TYPE_INFORM = 8;
    147 
    148     /**
    149      * DHCP Optional Type: DHCP Server Identifier
    150      */
    151     protected static final byte DHCP_SERVER_IDENTIFIER = 54;
    152     protected InetAddress mServerIdentifier;
    153 
    154     /**
    155      * DHCP Optional Type: DHCP Parameter List
    156      */
    157     protected static final byte DHCP_PARAMETER_LIST = 55;
    158     protected byte[] mRequestedParams;
    159 
    160     /**
    161      * DHCP Optional Type: DHCP MESSAGE
    162      */
    163     protected static final byte DHCP_MESSAGE = 56;
    164     protected String mMessage;
    165 
    166     /**
    167      * DHCP Optional Type: DHCP Renewal Time Value
    168      */
    169     protected static final byte DHCP_RENEWAL_TIME = 58;
    170 
    171     /**
    172      * DHCP Optional Type: Vendor Class Identifier
    173      */
    174     protected static final byte DHCP_VENDOR_CLASS_ID = 60;
    175 
    176     /**
    177      * DHCP Optional Type: DHCP Client Identifier
    178      */
    179     protected static final byte DHCP_CLIENT_IDENTIFIER = 61;
    180 
    181     /**
    182      * The transaction identifier used in this particular DHCP negotiation
    183      */
    184     protected final int mTransId;
    185 
    186     /**
    187      * The IP address of the client host.  This address is typically
    188      * proposed by the client (from an earlier DHCP negotiation) or
    189      * supplied by the server.
    190      */
    191     protected final InetAddress mClientIp;
    192     protected final InetAddress mYourIp;
    193     private final InetAddress mNextIp;
    194     private final InetAddress mRelayIp;
    195 
    196     /**
    197      * Does the client request a broadcast response?
    198      */
    199     protected boolean mBroadcast;
    200 
    201     /**
    202      * The six-octet MAC of the client.
    203      */
    204     protected final byte[] mClientMac;
    205 
    206     /**
    207      * Asks the packet object to signal the next operation in the DHCP
    208      * protocol.  The available actions are methods defined in the
    209      * DhcpStateMachine interface.
    210      */
    211     public abstract void doNextOp(DhcpStateMachine stateMachine);
    212 
    213     /**
    214      * Asks the packet object to create a ByteBuffer serialization of
    215      * the packet for transmission.
    216      */
    217     public abstract ByteBuffer buildPacket(int encap, short destUdp,
    218         short srcUdp);
    219 
    220     /**
    221      * Allows the concrete class to fill in packet-type-specific details,
    222      * typically optional parameters at the end of the packet.
    223      */
    224     abstract void finishPacket(ByteBuffer buffer);
    225 
    226     protected DhcpPacket(int transId, InetAddress clientIp, InetAddress yourIp,
    227                          InetAddress nextIp, InetAddress relayIp,
    228                          byte[] clientMac, boolean broadcast) {
    229         mTransId = transId;
    230         mClientIp = clientIp;
    231         mYourIp = yourIp;
    232         mNextIp = nextIp;
    233         mRelayIp = relayIp;
    234         mClientMac = clientMac;
    235         mBroadcast = broadcast;
    236     }
    237 
    238     /**
    239      * Returns the transaction ID.
    240      */
    241     public int getTransactionId() {
    242         return mTransId;
    243     }
    244 
    245     /**
    246      * Creates a new L3 packet (including IP header) containing the
    247      * DHCP udp packet.  This method relies upon the delegated method
    248      * finishPacket() to insert the per-packet contents.
    249      */
    250     protected void fillInPacket(int encap, InetAddress destIp,
    251         InetAddress srcIp, short destUdp, short srcUdp, ByteBuffer buf,
    252         byte requestCode, boolean broadcast) {
    253         byte[] destIpArray = destIp.getAddress();
    254         byte[] srcIpArray = srcIp.getAddress();
    255         int ipLengthOffset = 0;
    256         int ipChecksumOffset = 0;
    257         int endIpHeader = 0;
    258         int udpHeaderOffset = 0;
    259         int udpLengthOffset = 0;
    260         int udpChecksumOffset = 0;
    261 
    262         buf.clear();
    263         buf.order(ByteOrder.BIG_ENDIAN);
    264 
    265         // if a full IP packet needs to be generated, put the IP & UDP
    266         // headers in place, and pre-populate with artificial values
    267         // needed to seed the IP checksum.
    268         if (encap == ENCAP_L3) {
    269             // fake IP header, used in the IP-header checksum
    270             buf.put(IP_VERSION_HEADER_LEN);
    271             buf.put(IP_TOS_LOWDELAY);    // tos: IPTOS_LOWDELAY
    272             ipLengthOffset = buf.position();
    273             buf.putShort((short)0);  // length
    274             buf.putShort((short)0);  // id
    275             buf.putShort(IP_FLAGS_OFFSET); // ip offset: don't fragment
    276             buf.put(IP_TTL);    // TTL: use default 64 from RFC1340
    277             buf.put(IP_TYPE_UDP);
    278             ipChecksumOffset = buf.position();
    279             buf.putShort((short) 0); // checksum
    280 
    281             buf.put(srcIpArray);
    282             buf.put(destIpArray);
    283             endIpHeader = buf.position();
    284 
    285             // UDP header
    286             udpHeaderOffset = buf.position();
    287             buf.putShort(srcUdp);
    288             buf.putShort(destUdp);
    289             udpLengthOffset = buf.position();
    290             buf.putShort((short) 0); // length
    291             udpChecksumOffset = buf.position();
    292             buf.putShort((short) 0); // UDP checksum -- initially zero
    293         }
    294 
    295         // DHCP payload
    296         buf.put(requestCode);
    297         buf.put((byte) 1); // Hardware Type: Ethernet
    298         buf.put((byte) mClientMac.length); // Hardware Address Length
    299         buf.put((byte) 0); // Hop Count
    300         buf.putInt(mTransId);  // Transaction ID
    301         buf.putShort((short) 0); // Elapsed Seconds
    302 
    303         if (broadcast) {
    304             buf.putShort((short) 0x8000); // Flags
    305         } else {
    306             buf.putShort((short) 0x0000); // Flags
    307         }
    308 
    309         buf.put(mClientIp.getAddress());
    310         buf.put(mYourIp.getAddress());
    311         buf.put(mNextIp.getAddress());
    312         buf.put(mRelayIp.getAddress());
    313         buf.put(mClientMac);
    314         buf.position(buf.position() +
    315                      (16 - mClientMac.length) // pad addr to 16 bytes
    316                      + 64     // empty server host name (64 bytes)
    317                      + 128);  // empty boot file name (128 bytes)
    318         buf.putInt(0x63825363); // magic number
    319         finishPacket(buf);
    320 
    321         // round up to an even number of octets
    322         if ((buf.position() & 1) == 1) {
    323             buf.put((byte) 0);
    324         }
    325 
    326         // If an IP packet is being built, the IP & UDP checksums must be
    327         // computed.
    328         if (encap == ENCAP_L3) {
    329             // fix UDP header: insert length
    330             short udpLen = (short)(buf.position() - udpHeaderOffset);
    331             buf.putShort(udpLengthOffset, udpLen);
    332             // fix UDP header: checksum
    333             // checksum for UDP at udpChecksumOffset
    334             int udpSeed = 0;
    335 
    336             // apply IPv4 pseudo-header.  Read IP address src and destination
    337             // values from the IP header and accumulate checksum.
    338             udpSeed += intAbs(buf.getShort(ipChecksumOffset + 2));
    339             udpSeed += intAbs(buf.getShort(ipChecksumOffset + 4));
    340             udpSeed += intAbs(buf.getShort(ipChecksumOffset + 6));
    341             udpSeed += intAbs(buf.getShort(ipChecksumOffset + 8));
    342 
    343             // accumulate extra data for the pseudo-header
    344             udpSeed += IP_TYPE_UDP;
    345             udpSeed += udpLen;
    346             // and compute UDP checksum
    347             buf.putShort(udpChecksumOffset, (short) checksum(buf, udpSeed,
    348                                                              udpHeaderOffset,
    349                                                              buf.position()));
    350             // fix IP header: insert length
    351             buf.putShort(ipLengthOffset, (short)buf.position());
    352             // fixup IP-header checksum
    353             buf.putShort(ipChecksumOffset,
    354                          (short) checksum(buf, 0, 0, endIpHeader));
    355         }
    356     }
    357 
    358     /**
    359      * Converts a signed short value to an unsigned int value.  Needed
    360      * because Java does not have unsigned types.
    361      */
    362     private int intAbs(short v) {
    363         if (v < 0) {
    364             int r = v + 65536;
    365             return r;
    366         } else {
    367             return(v);
    368         }
    369     }
    370 
    371     /**
    372      * Performs an IP checksum (used in IP header and across UDP
    373      * payload) on the specified portion of a ByteBuffer.  The seed
    374      * allows the checksum to commence with a specified value.
    375      */
    376     private int checksum(ByteBuffer buf, int seed, int start, int end) {
    377         int sum = seed;
    378         int bufPosition = buf.position();
    379 
    380         // set position of original ByteBuffer, so that the ShortBuffer
    381         // will be correctly initialized
    382         buf.position(start);
    383         ShortBuffer shortBuf = buf.asShortBuffer();
    384 
    385         // re-set ByteBuffer position
    386         buf.position(bufPosition);
    387 
    388         short[] shortArray = new short[(end - start) / 2];
    389         shortBuf.get(shortArray);
    390 
    391         for (short s : shortArray) {
    392             sum += intAbs(s);
    393         }
    394 
    395         start += shortArray.length * 2;
    396 
    397         // see if a singleton byte remains
    398         if (end != start) {
    399             short b = buf.get(start);
    400 
    401             // make it unsigned
    402             if (b < 0) {
    403                 b += 256;
    404             }
    405 
    406             sum += b * 256;
    407         }
    408 
    409         sum = ((sum >> 16) & 0xFFFF) + (sum & 0xFFFF);
    410         sum = ((sum + ((sum >> 16) & 0xFFFF)) & 0xFFFF);
    411         int negated = ~sum;
    412         return intAbs((short) negated);
    413     }
    414 
    415     /**
    416      * Adds an optional parameter containing a single byte value.
    417      */
    418     protected void addTlv(ByteBuffer buf, byte type, byte value) {
    419         buf.put(type);
    420         buf.put((byte) 1);
    421         buf.put(value);
    422     }
    423 
    424     /**
    425      * Adds an optional parameter containing an array of bytes.
    426      */
    427     protected void addTlv(ByteBuffer buf, byte type, byte[] payload) {
    428         if (payload != null) {
    429             buf.put(type);
    430             buf.put((byte) payload.length);
    431             buf.put(payload);
    432         }
    433     }
    434 
    435     /**
    436      * Adds an optional parameter containing an IP address.
    437      */
    438     protected void addTlv(ByteBuffer buf, byte type, InetAddress addr) {
    439         if (addr != null) {
    440             addTlv(buf, type, addr.getAddress());
    441         }
    442     }
    443 
    444     /**
    445      * Adds an optional parameter containing a list of IP addresses.
    446      */
    447     protected void addTlv(ByteBuffer buf, byte type, List<InetAddress> addrs) {
    448         if (addrs != null && addrs.size() > 0) {
    449             buf.put(type);
    450             buf.put((byte)(4 * addrs.size()));
    451 
    452             for (InetAddress addr : addrs) {
    453                 buf.put(addr.getAddress());
    454             }
    455         }
    456     }
    457 
    458     /**
    459      * Adds an optional parameter containing a simple integer
    460      */
    461     protected void addTlv(ByteBuffer buf, byte type, Integer value) {
    462         if (value != null) {
    463             buf.put(type);
    464             buf.put((byte) 4);
    465             buf.putInt(value.intValue());
    466         }
    467     }
    468 
    469     /**
    470      * Adds an optional parameter containing and ASCII string.
    471      */
    472     protected void addTlv(ByteBuffer buf, byte type, String str) {
    473         if (str != null) {
    474             buf.put(type);
    475             buf.put((byte) str.length());
    476 
    477             for (int i = 0; i < str.length(); i++) {
    478                 buf.put((byte) str.charAt(i));
    479             }
    480         }
    481     }
    482 
    483     /**
    484      * Adds the special end-of-optional-parameters indicator.
    485      */
    486     protected void addTlvEnd(ByteBuffer buf) {
    487         buf.put((byte) 0xFF);
    488     }
    489 
    490     /**
    491      * Converts a MAC from an array of octets to an ASCII string.
    492      */
    493     public static String macToString(byte[] mac) {
    494         String macAddr = "";
    495 
    496         for (int i = 0; i < mac.length; i++) {
    497             String hexString = "0" + Integer.toHexString(mac[i]);
    498 
    499             // substring operation grabs the last 2 digits: this
    500             // allows signed bytes to be converted correctly.
    501             macAddr += hexString.substring(hexString.length() - 2);
    502 
    503             if (i != (mac.length - 1)) {
    504                 macAddr += ":";
    505             }
    506         }
    507 
    508         return macAddr;
    509     }
    510 
    511     public String toString() {
    512         String macAddr = macToString(mClientMac);
    513 
    514         return macAddr;
    515     }
    516 
    517     /**
    518      * Reads a four-octet value from a ByteBuffer and construct
    519      * an IPv4 address from that value.
    520      */
    521     private static InetAddress readIpAddress(ByteBuffer packet) {
    522         InetAddress result = null;
    523         byte[] ipAddr = new byte[4];
    524         packet.get(ipAddr);
    525 
    526         try {
    527             result = InetAddress.getByAddress(ipAddr);
    528         } catch (UnknownHostException ex) {
    529             // ipAddr is numeric, so this should not be
    530             // triggered.  However, if it is, just nullify
    531             result = null;
    532         }
    533 
    534         return result;
    535     }
    536 
    537     /**
    538      * Reads a string of specified length from the buffer.
    539      */
    540     private static String readAsciiString(ByteBuffer buf, int byteCount) {
    541         byte[] bytes = new byte[byteCount];
    542         buf.get(bytes);
    543         return new String(bytes, 0, bytes.length, Charsets.US_ASCII);
    544     }
    545 
    546     /**
    547      * Creates a concrete DhcpPacket from the supplied ByteBuffer.  The
    548      * buffer may have an L2 encapsulation (which is the full EthernetII
    549      * format starting with the source-address MAC) or an L3 encapsulation
    550      * (which starts with the IP header).
    551      * <br>
    552      * A subset of the optional parameters are parsed and are stored
    553      * in object fields.
    554      */
    555     public static DhcpPacket decodeFullPacket(ByteBuffer packet, int pktType)
    556     {
    557         // bootp parameters
    558         int transactionId;
    559         InetAddress clientIp;
    560         InetAddress yourIp;
    561         InetAddress nextIp;
    562         InetAddress relayIp;
    563         byte[] clientMac;
    564         List<InetAddress> dnsServers = new ArrayList<InetAddress>();
    565         InetAddress gateway = null; // aka router
    566         Integer leaseTime = null;
    567         InetAddress serverIdentifier = null;
    568         InetAddress netMask = null;
    569         String message = null;
    570         String vendorId = null;
    571         byte[] expectedParams = null;
    572         String hostName = null;
    573         String domainName = null;
    574         InetAddress ipSrc = null;
    575         InetAddress ipDst = null;
    576         InetAddress bcAddr = null;
    577         InetAddress requestedIp = null;
    578 
    579         // dhcp options
    580         byte dhcpType = (byte) 0xFF;
    581 
    582         packet.order(ByteOrder.BIG_ENDIAN);
    583 
    584         // check to see if we need to parse L2, IP, and UDP encaps
    585         if (pktType == ENCAP_L2) {
    586             // System.out.println("buffer len " + packet.limit());
    587             byte[] l2dst = new byte[6];
    588             byte[] l2src = new byte[6];
    589 
    590             packet.get(l2dst);
    591             packet.get(l2src);
    592 
    593             short l2type = packet.getShort();
    594 
    595             if (l2type != 0x0800)
    596                 return null;
    597         }
    598 
    599         if ((pktType == ENCAP_L2) || (pktType == ENCAP_L3)) {
    600             // assume l2type is 0x0800, i.e. IP
    601             byte ipType = packet.get();
    602             // System.out.println("ipType is " + ipType);
    603             byte ipDiffServicesField = packet.get();
    604             short ipTotalLength = packet.getShort();
    605             short ipIdentification = packet.getShort();
    606             byte ipFlags = packet.get();
    607             byte ipFragOffset = packet.get();
    608             byte ipTTL = packet.get();
    609             byte ipProto = packet.get();
    610             short ipChksm = packet.getShort();
    611 
    612             ipSrc = readIpAddress(packet);
    613             ipDst = readIpAddress(packet);
    614 
    615             if (ipProto != IP_TYPE_UDP) // UDP
    616                 return null;
    617 
    618             // assume UDP
    619             short udpSrcPort = packet.getShort();
    620             short udpDstPort = packet.getShort();
    621             short udpLen = packet.getShort();
    622             short udpChkSum = packet.getShort();
    623 
    624             if ((udpSrcPort != DHCP_SERVER) && (udpSrcPort != DHCP_CLIENT))
    625                 return null;
    626         }
    627 
    628         // assume bootp
    629         byte type = packet.get();
    630         byte hwType = packet.get();
    631         byte addrLen = packet.get();
    632         byte hops = packet.get();
    633         transactionId = packet.getInt();
    634         short elapsed = packet.getShort();
    635         short bootpFlags = packet.getShort();
    636         boolean broadcast = (bootpFlags & 0x8000) != 0;
    637         byte[] ipv4addr = new byte[4];
    638 
    639         try {
    640             packet.get(ipv4addr);
    641             clientIp = InetAddress.getByAddress(ipv4addr);
    642             packet.get(ipv4addr);
    643             yourIp = InetAddress.getByAddress(ipv4addr);
    644             packet.get(ipv4addr);
    645             nextIp = InetAddress.getByAddress(ipv4addr);
    646             packet.get(ipv4addr);
    647             relayIp = InetAddress.getByAddress(ipv4addr);
    648         } catch (UnknownHostException ex) {
    649             return null;
    650         }
    651 
    652         clientMac = new byte[addrLen];
    653         packet.get(clientMac);
    654 
    655         // skip over address padding (16 octets allocated)
    656         packet.position(packet.position() + (16 - addrLen)
    657                         + 64    // skip server host name (64 chars)
    658                         + 128); // skip boot file name (128 chars)
    659 
    660         int dhcpMagicCookie = packet.getInt();
    661 
    662         if (dhcpMagicCookie !=  0x63825363)
    663             return null;
    664 
    665         // parse options
    666         boolean notFinishedOptions = true;
    667 
    668         while ((packet.position() < packet.limit()) && notFinishedOptions) {
    669             byte optionType = packet.get();
    670 
    671             if (optionType == (byte) 0xFF) {
    672                 notFinishedOptions = false;
    673             } else {
    674                 byte optionLen = packet.get();
    675                 int expectedLen = 0;
    676 
    677                 switch(optionType) {
    678                     case DHCP_SUBNET_MASK:
    679                         netMask = readIpAddress(packet);
    680                         expectedLen = 4;
    681                         break;
    682                     case DHCP_ROUTER:
    683                         gateway = readIpAddress(packet);
    684                         expectedLen = 4;
    685                         break;
    686                     case DHCP_DNS_SERVER:
    687                         expectedLen = 0;
    688 
    689                         for (expectedLen = 0; expectedLen < optionLen;
    690                              expectedLen += 4) {
    691                             dnsServers.add(readIpAddress(packet));
    692                         }
    693                         break;
    694                     case DHCP_HOST_NAME:
    695                         expectedLen = optionLen;
    696                         hostName = readAsciiString(packet, optionLen);
    697                         break;
    698                     case DHCP_DOMAIN_NAME:
    699                         expectedLen = optionLen;
    700                         domainName = readAsciiString(packet, optionLen);
    701                         break;
    702                     case DHCP_BROADCAST_ADDRESS:
    703                         bcAddr = readIpAddress(packet);
    704                         expectedLen = 4;
    705                         break;
    706                     case DHCP_REQUESTED_IP:
    707                         requestedIp = readIpAddress(packet);
    708                         expectedLen = 4;
    709                         break;
    710                     case DHCP_LEASE_TIME:
    711                         leaseTime = Integer.valueOf(packet.getInt());
    712                         expectedLen = 4;
    713                         break;
    714                     case DHCP_MESSAGE_TYPE:
    715                         dhcpType = packet.get();
    716                         expectedLen = 1;
    717                         break;
    718                     case DHCP_SERVER_IDENTIFIER:
    719                         serverIdentifier = readIpAddress(packet);
    720                         expectedLen = 4;
    721                         break;
    722                     case DHCP_PARAMETER_LIST:
    723                         expectedParams = new byte[optionLen];
    724                         packet.get(expectedParams);
    725                         expectedLen = optionLen;
    726                         break;
    727                     case DHCP_MESSAGE:
    728                         expectedLen = optionLen;
    729                         message = readAsciiString(packet, optionLen);
    730                         break;
    731                     case DHCP_VENDOR_CLASS_ID:
    732                         expectedLen = optionLen;
    733                         vendorId = readAsciiString(packet, optionLen);
    734                         break;
    735                     case DHCP_CLIENT_IDENTIFIER: { // Client identifier
    736                         byte[] id = new byte[optionLen];
    737                         packet.get(id);
    738                         expectedLen = optionLen;
    739                     } break;
    740                     default:
    741                         // ignore any other parameters
    742                         for (int i = 0; i < optionLen; i++) {
    743                             expectedLen++;
    744                             byte throwaway = packet.get();
    745                         }
    746                 }
    747 
    748                 if (expectedLen != optionLen) {
    749                     return null;
    750                 }
    751             }
    752         }
    753 
    754         DhcpPacket newPacket;
    755 
    756         switch(dhcpType) {
    757             case -1: return null;
    758             case DHCP_MESSAGE_TYPE_DISCOVER:
    759                 newPacket = new DhcpDiscoverPacket(
    760                     transactionId, clientMac, broadcast);
    761                 break;
    762             case DHCP_MESSAGE_TYPE_OFFER:
    763                 newPacket = new DhcpOfferPacket(
    764                     transactionId, broadcast, ipSrc, yourIp, clientMac);
    765                 break;
    766             case DHCP_MESSAGE_TYPE_REQUEST:
    767                 newPacket = new DhcpRequestPacket(
    768                     transactionId, clientIp, clientMac, broadcast);
    769                 break;
    770             case DHCP_MESSAGE_TYPE_DECLINE:
    771                 newPacket = new DhcpDeclinePacket(
    772                     transactionId, clientIp, yourIp, nextIp, relayIp,
    773                     clientMac);
    774                 break;
    775             case DHCP_MESSAGE_TYPE_ACK:
    776                 newPacket = new DhcpAckPacket(
    777                     transactionId, broadcast, ipSrc, yourIp, clientMac);
    778                 break;
    779             case DHCP_MESSAGE_TYPE_NAK:
    780                 newPacket = new DhcpNakPacket(
    781                     transactionId, clientIp, yourIp, nextIp, relayIp,
    782                     clientMac);
    783                 break;
    784             case DHCP_MESSAGE_TYPE_INFORM:
    785                 newPacket = new DhcpInformPacket(
    786                     transactionId, clientIp, yourIp, nextIp, relayIp,
    787                     clientMac);
    788                 break;
    789             default:
    790                 System.out.println("Unimplemented type: " + dhcpType);
    791                 return null;
    792         }
    793 
    794         newPacket.mBroadcastAddress = bcAddr;
    795         newPacket.mDnsServers = dnsServers;
    796         newPacket.mDomainName = domainName;
    797         newPacket.mGateway = gateway;
    798         newPacket.mHostName = hostName;
    799         newPacket.mLeaseTime = leaseTime;
    800         newPacket.mMessage = message;
    801         newPacket.mRequestedIp = requestedIp;
    802         newPacket.mRequestedParams = expectedParams;
    803         newPacket.mServerIdentifier = serverIdentifier;
    804         newPacket.mSubnetMask = netMask;
    805         return newPacket;
    806     }
    807 
    808     /**
    809      * Parse a packet from an array of bytes.
    810      */
    811     public static DhcpPacket decodeFullPacket(byte[] packet, int pktType)
    812     {
    813         ByteBuffer buffer = ByteBuffer.wrap(packet).order(ByteOrder.BIG_ENDIAN);
    814         return decodeFullPacket(buffer, pktType);
    815     }
    816 
    817     /**
    818      * Builds a DHCP-DISCOVER packet from the required specified
    819      * parameters.
    820      */
    821     public static ByteBuffer buildDiscoverPacket(int encap, int transactionId,
    822         byte[] clientMac, boolean broadcast, byte[] expectedParams) {
    823         DhcpPacket pkt = new DhcpDiscoverPacket(
    824             transactionId, clientMac, broadcast);
    825         pkt.mRequestedParams = expectedParams;
    826         return pkt.buildPacket(encap, DHCP_SERVER, DHCP_CLIENT);
    827     }
    828 
    829     /**
    830      * Builds a DHCP-OFFER packet from the required specified
    831      * parameters.
    832      */
    833     public static ByteBuffer buildOfferPacket(int encap, int transactionId,
    834         boolean broadcast, InetAddress serverIpAddr, InetAddress clientIpAddr,
    835         byte[] mac, Integer timeout, InetAddress netMask, InetAddress bcAddr,
    836         InetAddress gateway, List<InetAddress> dnsServers,
    837         InetAddress dhcpServerIdentifier, String domainName) {
    838         DhcpPacket pkt = new DhcpOfferPacket(
    839             transactionId, broadcast, serverIpAddr, clientIpAddr, mac);
    840         pkt.mGateway = gateway;
    841         pkt.mDnsServers = dnsServers;
    842         pkt.mLeaseTime = timeout;
    843         pkt.mDomainName = domainName;
    844         pkt.mServerIdentifier = dhcpServerIdentifier;
    845         pkt.mSubnetMask = netMask;
    846         pkt.mBroadcastAddress = bcAddr;
    847         return pkt.buildPacket(encap, DHCP_CLIENT, DHCP_SERVER);
    848     }
    849 
    850     /**
    851      * Builds a DHCP-ACK packet from the required specified parameters.
    852      */
    853     public static ByteBuffer buildAckPacket(int encap, int transactionId,
    854         boolean broadcast, InetAddress serverIpAddr, InetAddress clientIpAddr,
    855         byte[] mac, Integer timeout, InetAddress netMask, InetAddress bcAddr,
    856         InetAddress gateway, List<InetAddress> dnsServers,
    857         InetAddress dhcpServerIdentifier, String domainName) {
    858         DhcpPacket pkt = new DhcpAckPacket(
    859             transactionId, broadcast, serverIpAddr, clientIpAddr, mac);
    860         pkt.mGateway = gateway;
    861         pkt.mDnsServers = dnsServers;
    862         pkt.mLeaseTime = timeout;
    863         pkt.mDomainName = domainName;
    864         pkt.mSubnetMask = netMask;
    865         pkt.mServerIdentifier = dhcpServerIdentifier;
    866         pkt.mBroadcastAddress = bcAddr;
    867         return pkt.buildPacket(encap, DHCP_CLIENT, DHCP_SERVER);
    868     }
    869 
    870     /**
    871      * Builds a DHCP-NAK packet from the required specified parameters.
    872      */
    873     public static ByteBuffer buildNakPacket(int encap, int transactionId,
    874         InetAddress serverIpAddr, InetAddress clientIpAddr, byte[] mac) {
    875         DhcpPacket pkt = new DhcpNakPacket(transactionId, clientIpAddr,
    876             serverIpAddr, serverIpAddr, serverIpAddr, mac);
    877         pkt.mMessage = "requested address not available";
    878         pkt.mRequestedIp = clientIpAddr;
    879         return pkt.buildPacket(encap, DHCP_CLIENT, DHCP_SERVER);
    880     }
    881 
    882     /**
    883      * Builds a DHCP-REQUEST packet from the required specified parameters.
    884      */
    885     public static ByteBuffer buildRequestPacket(int encap,
    886         int transactionId, InetAddress clientIp, boolean broadcast,
    887         byte[] clientMac, InetAddress requestedIpAddress,
    888         InetAddress serverIdentifier, byte[] requestedParams, String hostName) {
    889         DhcpPacket pkt = new DhcpRequestPacket(transactionId, clientIp,
    890             clientMac, broadcast);
    891         pkt.mRequestedIp = requestedIpAddress;
    892         pkt.mServerIdentifier = serverIdentifier;
    893         pkt.mHostName = hostName;
    894         pkt.mRequestedParams = requestedParams;
    895         ByteBuffer result = pkt.buildPacket(encap, DHCP_SERVER, DHCP_CLIENT);
    896         return result;
    897     }
    898 }
    899