import ctypes
from ctypes import wintypes




class sockaddr(ctypes.Structure):
    _fields_ =[("sa_family",ctypes.c_uint16),
               ("sa_data",ctypes.c_char_p)
               ]
class sockaddrin(ctypes.Structure):
    _fields_ =[("sin_family",ctypes.c_int16),
               ("sin_port",ctypes.c_uint16),
               ("sin_addr",ctypes.c_char_p),
               ("sin_zero",ctypes.c_char_p)
               ]
class pcap_addr(ctypes.Structure):
    pass

pcap_addr._fields_ =[
    ("next1",ctypes.POINTER(pcap_addr)),
    ("addr",ctypes.POINTER(sockaddrin)),
    ("netmask",ctypes.POINTER(sockaddrin)),
    ("broadaddr",ctypes.POINTER(sockaddrin)),
    ("dstaddr",ctypes.POINTER(sockaddrin))
    ]


PCAP_SRC_IF_STRING=ctypes.c_char_p( "rpcap://")



class pcap_if (ctypes.Structure):
    pass
pcap_if._fields_ =[("next1",ctypes.POINTER(pcap_if)),
                   ("name1",ctypes.c_char_p),
                   ("description1", ctypes.c_char_p),
                   ("address",ctypes.POINTER(pcap_addr)),
                   ("flags",ctypes.c_uint)
                    ]


wpcap=ctypes.CDLL("wpcap.dll")
pcap_findalldevs=wpcap.pcap_findalldevs
pcap_findalldevs_ex=wpcap.pcap_findalldevs_ex
pcap_findalldevs_ex.restype=wintypes.DWORD
pcap_freealldevs=wpcap.pcap_freealldevs
pcap_open=wpcap.pcap_open
pcap_close=wpcap.pcap_close
pcap_next_ex=wpcap.pcap_next_ex
pcap_next_ex.restype=wintypes.DWORD
pcap_sendpacket=wpcap.pcap_sendpacket
pcap_sendpacket.restype=wintypes.DWORD


class address(object):
    def __init__(self,addr):
        self.addr=addr
    def __str__(self):
        return str(dir(self.addr))
    pass
class timeval(ctypes.Structure):
    _fields_ = [("tv_sec", ctypes.c_long), ("tv_usec", ctypes.c_long)]
class pcap_pkthdr(ctypes.Structure):
    _fields_ =[("ts",timeval),
               ("caplen",ctypes.c_uint32),
               ("len",ctypes.c_uint32)]

class Packet_Header(object):
    def __init__(self,hdr,data):
        self.sec=hdr.contents.ts.tv_sec
        self.usec=hdr.contents.ts.tv_usec
        self.caplen=hdr.contents.caplen
        self.len=hdr.contents.len
        self.ptrdata=data
        self.data=ctypes.string_at(data,self.len)
        return
    def __str__(self):
        o1=""
        o1+="("
        o1+=str(self.sec)
        o1+=":"
        o1+=str(self.usec)
        o1+=")["
        o1+=str(self.caplen)
        o1+=","
        o1+=str(self.len)
        o1+="]==>\r\n"
        o1+=self.data
        o1+="\r\n"
        o1+=self.data.encode("hex")
        return o1
    pass
class interface(object):
    def __init__(self,inter):
        self.name=inter.name1
        self.desc=inter.description1
        self.address=address(inter.address)
        self.flags=inter.flags
        self.fpr=None
        self.fpw=None
        pass
    def Name(self):
        return self.name
    def popen(self):
        self.terr=ctypes.create_string_buffer("\x00",256)
        self.fp=pcap_open(self.name,100,1,20,0x0,ctypes.byref(self.terr))
##        print dir(self.terr)
        return
    def read(self):
        str1=ctypes.c_char_p()
        hdr=ctypes.pointer(pcap_pkthdr())
        res=pcap_next_ex(self.fp,ctypes.byref(hdr),ctypes.byref(str1))
        return (res,Packet_Header(hdr,str1))
    def write(self,value):
        packet=ctypes.c_char_p(value)
        psize=ctypes.c_int(len(value))
        res=pcap_sendpacket(self.fp,packet,psize)
        return res
    def pclose(self):
        if self.fpr:
            pcap_close(self.fpr)
            self.fpr=None
        if self.fpw:
            pcap_close(self.fpw)
            self.fpw=None
        return
    def __str__(self):
        return str(self.name)
    def __del__(self):
        self.pclose()
        pass
        
class interfaces(object):
    def __init__(self):
        self.bf1=ctypes.pointer(pcap_if())
        self.terr=ctypes.create_string_buffer("\x00",256)
        pcap_findalldevs_ex(PCAP_SRC_IF_STRING,0x0,ctypes.byref(self.bf1),ctypes.byref(self.terr))
        return
    def __iter__(self):
        self.ptr=self.bf1
        return self
    def next(self):
        if not self.ptr:
            raise StopIteration
        o1= self.ptr.contents
        self.ptr=self.ptr.contents.next1
        return interface(o1)
    def __getitem__(self,key):
        cnt=1
        pt1=self.bf1
        while(cnt<key):
            cnt+=1
            pt1=pt1.contents.next1
        return interface(pt1.contents)
    def __del__(self):
        pcap_freealldevs(self.bf1)
    def __str__(self):
        o1="{"
        cnt=0
        spacer=""
        for itm in self:
            cnt+=1
            o1+=spacer+str(cnt)+":"+str(itm)
            spacer=","
        o1+="}"
        return o1


##
##
##
##if (==-1):
##    exit(0)
##p0=ctypes.POINTER(pcap_if)
##p0=bf1
##while(p0):
##    print p0.contents.name1
##    print p0.contents.decription1
##    ad1=p0.contents.adress
##    while(ad1):
##        print ad1.contents.addr.contents.sin_family
##        print ad1.contents.addr.contents.sin_port
##        print ad1.contents.addr.contents.sin_addr
##        ad1=ad1.contents.next1
##    
##    p0=p0.contents.next1
##pcap_freealldevs(bf1)