DHCP query script not work.

[不坏阿峰]

Dear all

i got code recipes from here. and i want to run it on win 7. 
http://code.activestate.com/recipes/577649-dhcp-query/

i have do some modify and use print to check how it is work, but i am stucked now. 

hope someone can help me. thanks a lot.

i meet this error:

Traceback (most recent call last):
  File "D:/Workspace/TestExcel/Test/test_DHCP.py", line 138, in <module>
    offer = DHCPOffer(data, discoverPacket.transactionID)
  File "D:/Workspace/TestExcel/Test/test_DHCP.py", line 82, in __init__
    self.unpack()
  File "D:/Workspace/TestExcel/Test/test_DHCP.py", line 95, in unpack
    dnsNB = int(data[268] / 4)
TypeError: unsupported operand type(s) for /: 'str' and 'int'

########################################
__author__ = 'Administrator'

'''
Created on Mar 27, 2011

@author: hassane
'''
import socket
import struct
from uuid import getnode as get_mac
from random import randint


def getMacInBytes():
    print get_mac()
    mac = str(hex(get_mac()))
    print mac
    mac = mac[2:]
    mac = mac[:-1]  # i edited
    print mac, len(mac)
    while len(mac) < 12:
        mac = '0' + mac
        print mac
    macb = b''
    for i in range(0, 12, 2):
        print mac[i:i + 2]
        m = int(mac[i:i + 2], 16)
        #print m
        macb += struct.pack('!B', m)
        print repr(macb), struct.calcsize('!B'),"++"
    print macb,"=="
    return macb


class DHCPDiscover:
    def __init__(self):
        self.transactionID = b''
        for i in range(4):
            t = randint(0, 255)
            self.transactionID += struct.pack('!B', t)
            print self.transactionID, "=="
    def buildPacket(self):
        macb = getMacInBytes()
        print repr(macb)
        packet = b''
        packet += b'\x01'  # Message type: Boot Request (1)
        packet += b'\x01'  # Hardware type: Ethernet
        packet += b'\x06'  # Hardware address length: 6
        packet += b'\x00'  # Hops: 0
        packet += self.transactionID  # Transaction ID
        packet += b'\x00\x00'  # Seconds elapsed: 0
        packet += b'\x80\x00'  # Bootp flags: 0x8000 (Broadcast) + reserved flags
        packet += b'\x00\x00\x00\x00'  # Client IP address: 0.0.0.0
        packet += b'\x00\x00\x00\x00'  # Your (client) IP address: 0.0.0.0
        packet += b'\x00\x00\x00\x00'  # Next server IP address: 0.0.0.0
        packet += b'\x00\x00\x00\x00'  # Relay agent IP address: 0.0.0.0
        # packet += b'\x00\x26\x9e\x04\x1e\x9b'   #Client MAC address: 00:26:9e:04:1e:9b
        packet += macb
        packet += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'  #Client hardware address padding: 00000000000000000000
        packet += b'\x00' * 67  #Server host name not given
        packet += b'\x00' * 125  #Boot file name not given
        packet += b'\x63\x82\x53\x63'  #Magic cookie: DHCP
        packet += b'\x35\x01\x01'  #Option: (t=53,l=1) DHCP Message Type = DHCP Discover
        #packet += b'\x3d\x06\x00\x26\x9e\x04\x1e\x9b'   #Option: (t=61,l=6) Client identifier
        packet += b'\x3d\x06' + macb
        packet += b'\x37\x03\x03\x01\x06'  #Option: (t=55,l=3) Parameter Request List
        packet += b'\xff'  #End Option
        return packet

class DHCPOffer:
    def __init__(self, data, transID):
        self.data = data
        self.transID = transID
        self.offerIP = ''
        self.nextServerIP = ''
        self.DHCPServerIdentifier = ''
        self.leaseTime = ''
        self.router = ''
        self.subnetMask = ''
        self.DNS = []
        self.unpack()

    def unpack(self):
        if self.data[4:8] == self.transID:
            self.offerIP = '.'.join(map(lambda x: str(x), data[16:20]))
            self.nextServerIP = '.'.join(map(lambda x: str(x), data[20:24]))  # c'est une option
            self.DHCPServerIdentifier = '.'.join(map(lambda x: str(x), data[245:249]))
            self.leaseTime = str(struct.unpack('!L', data[251:255])[0])
            self.router = '.'.join(map(lambda x: str(x), data[257:261]))
            self.subnetMask = '.'.join(map(lambda x: str(x), data[263:267]))
            #print self.router, self.subnetMask, self.leaseTime, self.DHCPServerIdentifier, repr(self.offerIP)
            print repr(data)
            print repr(data[268])
            dnsNB = int(data[268] / 4)
            for i in range(0, 4 * dnsNB, 4):
                self.DNS.append('.'.join(map(lambda x: str(x), data[269 + i:269 + i + 4])))

    def printOffer(self):
        key = ['DHCP Server', 'Offered IP address', 'subnet mask', 'lease time (s)', 'default gateway']
        val = [self.DHCPServerIdentifier, self.offerIP, self.subnetMask, self.leaseTime, self.router]
        for i in range(4):
            print('{0:20s} : {1:15s}'.format(key[i], val[i]))

        print('{0:20s}'.format('DNS Servers') + ' : ', ) #end=''   here also have error.
        if self.DNS:
            print('{0:15s}'.format(self.DNS[0]))
        if len(self.DNS) > 1:
            for i in range(1, len(self.DNS)):
                print('{0:22s} {1:15s}'.format(' ', self.DNS[i]))


if __name__ == '__main__':
    # defining the socket
    dhcps = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  #internet, UDP
    dhcps.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)  #broadcast

    try:
        dhcps.bind(('', 68))  #we want to send from port 68
    except Exception as e:
        print('port 68 in use...')
        dhcps.close()
        input('press any key to quit...')
        exit()

    #buiding and sending the DHCPDiscover packet
    discoverPacket = DHCPDiscover()
    dhcps.sendto(discoverPacket.buildPacket(), ('<broadcast>', 67))

    print('DHCP Discover sent waiting for reply...\n')

    #receiving DHCPOffer packet
    dhcps.settimeout(3)
    try:
        while True:
            data = dhcps.recv(1024)
            print "here",repr(discoverPacket.transactionID), ">>>", len(data)
            offer = DHCPOffer(data, discoverPacket.transactionID)
            if offer.offerIP:
                offer.printOffer()
                break
    except socket.timeout as e:
        print(e)

    dhcps.close()  #we close the socket

    input('press any key to quit...')
    exit()