Changeset 885:464de76db543

Show
Ignore:
Timestamp:
08/28/08 10:52:46 (4 months ago)
Author:
Phil <phil@secdev.org>
Message:

Reworked supersocket definition and pcap/dnet usage

architecture-specific supersockets are defined in arch specific files
ability to force pcap or dnet usage redefining conf.use_pcap/dnet
ability to use libpcap and pypcap wrappers. pcapy partly supported.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • scapy/arch/__init__.py

    r884 r885  
    88from fcntl import ioctl 
    99from scapy.error import * 
     10import scapy.config 
    1011 
    1112try: 
    …… 
    7273if LINUX: 
    7374    from linux import * 
     75    if scapy.config.conf.use_pcap or scapy.config.conf.use_dnet: 
     76        from pcapdnet import * 
    7477elif OPENBSD or FREEBSD or NETBSD or DARWIN: 
    7578    from bsd import * 
    …… 
    7780    from solaris import * 
    7881     
     82if scapy.config.conf.iface is None: 
     83    scapy.config.conf.iface = LOOPBACK_NAME 
    7984 
    80 import scapy.config 
    81 scapy.config.conf.iface = get_working_if() 

  • scapy/arch/linux.py

    r884 r885  
    99from fcntl import ioctl 
    1010import scapy.utils 
     11from scapy.config import conf 
     12from scapy.data import * 
     13from scapy.supersocket import SuperSocket 
     14 
    1115 
    1216 
    …… 
    5761 
    5862 
    59 DNET=PCAP=0 
    6063LOOPBACK_NAME="lo" 
    6164 
    …… 
    193196 
    194197 
    195  
     198def _flush_fd(fd): 
     199    if type(fd) is not int: 
     200        fd = fd.fileno() 
     201    while 1: 
     202        r,w,e = select([fd],[],[],0) 
     203        if r: 
     204            os.read(fd,MTU) 
     205        else: 
     206            break 
     207 
     208 
     209 
     210 
     211 
     212class L3PacketSocket(SuperSocket): 
     213    def __init__(self, type = ETH_P_ALL, filter=None, promisc=None, iface=None, nofilter=0): 
     214        self.type = type 
     215        self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
     216        self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) 
     217        _flush_fd(self.ins) 
     218        if iface: 
     219            self.ins.bind((iface, type)) 
     220        if not nofilter: 
     221            if conf.except_filter: 
     222                if filter: 
     223                    filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
     224                else: 
     225                    filter = "not (%s)" % conf.except_filter 
     226            if filter is not None: 
     227                arch.attach_filter(self.ins, filter) 
     228        self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) 
     229        self.outs = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
     230        self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2**30) 
     231        if promisc is None: 
     232            promisc = conf.promisc 
     233        self.promisc = promisc 
     234        if self.promisc: 
     235            if iface is None: 
     236                self.iff = arch.get_if_list() 
     237            else: 
     238                if iface.__class__ is list: 
     239                    self.iff = iface 
     240                else: 
     241                    self.iff = [iface] 
     242            for i in self.iff: 
     243                arch.set_promisc(self.ins, i) 
     244    def close(self): 
     245        if self.closed: 
     246            return 
     247        self.closed=1 
     248        if self.promisc: 
     249            for i in self.iff: 
     250                arch.set_promisc(self.ins, i, 0) 
     251        SuperSocket.close(self) 
     252    def recv(self, x): 
     253        pkt, sa_ll = self.ins.recvfrom(x) 
     254        if sa_ll[2] == socket.PACKET_OUTGOING: 
     255            return None 
     256        if sa_ll[3] in conf.l2types: 
     257            cls = conf.l2types[sa_ll[3]] 
     258            lvl = 2 
     259        elif sa_ll[1] in conf.l3types: 
     260            cls = conf.l3types[sa_ll[1]] 
     261            lvl = 3 
     262        else: 
     263            warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using Ethernet" % (sa_ll[0],sa_ll[1],sa_ll[3])) 
     264            cls = Ether 
     265            lvl = 2 
     266 
     267        try: 
     268            pkt = cls(pkt) 
     269        except KeyboardInterrupt: 
     270            raise 
     271        except: 
     272            if conf.debug_dissector: 
     273                raise 
     274            pkt = Raw(pkt) 
     275        if lvl == 2: 
     276            pkt = pkt.payload 
     277             
     278        if pkt is not None: 
     279            pkt.time = arch.get_last_packet_timestamp(self.ins) 
     280        return pkt 
     281     
     282    def send(self, x): 
     283        iff,a,gw  = x.route() 
     284        if iff is None: 
     285            iff = conf.iface 
     286        sdto = (iff, self.type) 
     287        self.outs.bind(sdto) 
     288        sn = self.outs.getsockname() 
     289        ll = lambda x:x 
     290        if sn[3] in (ARPHDR_PPP,ARPHDR_TUN): 
     291            sdto = (iff, ETH_P_IP) 
     292        if sn[3] in conf.l2types: 
     293            ll = lambda x:conf.l2types[sn[3]]()/x 
     294        try: 
     295            sx = str(ll(x)) 
     296            x.sent_time = time.time() 
     297            self.outs.sendto(sx, sdto) 
     298        except socket.error,msg: 
     299            x.sent_time = time.time()  # bad approximation 
     300            if conf.auto_fragment and msg[0] == 90: 
     301                for p in fragment(x): 
     302                    self.outs.sendto(str(ll(p)), sdto) 
     303            else: 
     304                raise 
     305                     
     306 
     307 
     308 
     309class L2Socket(SuperSocket): 
     310    def __init__(self, iface = None, type = ETH_P_ALL, filter=None, nofilter=0): 
     311        if iface is None: 
     312            iface = conf.iface 
     313        self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
     314        self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) 
     315        _flush_fd(self.ins) 
     316        if not nofilter:  
     317            if conf.except_filter: 
     318                if filter: 
     319                    filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
     320                else: 
     321                    filter = "not (%s)" % conf.except_filter 
     322            if filter is not None: 
     323                arch.attach_filter(self.ins, filter) 
     324        self.ins.bind((iface, type)) 
     325        self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) 
     326        self.outs = self.ins 
     327        self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2**30) 
     328        sa_ll = self.outs.getsockname() 
     329        if sa_ll[3] in conf.l2types: 
     330            self.LL = conf.l2types[sa_ll[3]] 
     331        elif sa_ll[1] in conf.l3types: 
     332            self.LL = conf.l3types[sa_ll[1]] 
     333        else: 
     334            warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using Ethernet" % (sa_ll[0],sa_ll[1],sa_ll[3])) 
     335            self.LL = Ether 
     336             
     337    def recv(self, x): 
     338        pkt, sa_ll = self.ins.recvfrom(x) 
     339        if sa_ll[2] == socket.PACKET_OUTGOING: 
     340            return None 
     341        try: 
     342            q = self.LL(pkt) 
     343        except KeyboardInterrupt: 
     344            raise 
     345        except: 
     346            if conf.debug_dissector: 
     347                raise 
     348            q = Raw(pkt) 
     349        q.time = get_last_packet_timestamp(self.ins) 
     350        return q 
     351 
     352 
     353class L2ListenSocket(SuperSocket): 
     354    def __init__(self, iface = None, type = ETH_P_ALL, promisc=None, filter=None, nofilter=0): 
     355        self.type = type 
     356        self.outs = None 
     357        self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
     358        self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) 
     359        _flush_fd(self.ins) 
     360        if iface is not None: 
     361            self.ins.bind((iface, type)) 
     362        if not nofilter: 
     363            if conf.except_filter: 
     364                if filter: 
     365                    filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
     366                else: 
     367                    filter = "not (%s)" % conf.except_filter 
     368            if filter is not None: 
     369                arch.attach_filter(self.ins, filter) 
     370        if promisc is None: 
     371            promisc = conf.sniff_promisc 
     372        self.promisc = promisc 
     373        if iface is None: 
     374            self.iff = arch.get_if_list() 
     375        else: 
     376            if iface.__class__ is list: 
     377                self.iff = iface 
     378            else: 
     379                self.iff = [iface] 
     380        if self.promisc: 
     381            for i in self.iff: 
     382                arch.set_promisc(self.ins, i) 
     383        self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) 
     384    def close(self): 
     385        if self.promisc: 
     386            for i in self.iff: 
     387                arch.set_promisc(self.ins, i, 0) 
     388        SuperSocket.close(self) 
     389 
     390    def recv(self, x): 
     391        pkt, sa_ll = self.ins.recvfrom(x) 
     392        if sa_ll[3] in conf.l2types : 
     393            cls = conf.l2types[sa_ll[3]] 
     394        elif sa_ll[1] in conf.l3types: 
     395            cls = conf.l3types[sa_ll[1]] 
     396        else: 
     397            warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using Ethernet" % (sa_ll[0],sa_ll[1],sa_ll[3])) 
     398            cls = Ether 
     399 
     400        try: 
     401            pkt = cls(pkt) 
     402        except KeyboardInterrupt: 
     403            raise 
     404        except: 
     405            if conf.debug_dissector: 
     406                raise 
     407            pkt = Raw(pkt) 
     408        pkt.time = get_last_packet_timestamp(self.ins) 
     409        return pkt 
     410     
     411    def send(self, x): 
     412        raise Scapy_Exception("Can't send anything with L2ListenSocket") 
     413 
     414 
     415conf.L3socket = L3PacketSocket 
     416conf.L2socket = L2Socket 
     417conf.L2listen = L2ListenSocket 
     418 
     419conf.iface = get_working_if() 

  • scapy/arch/unix.py

    r884 r885  
    77import sys,os,struct,socket,time 
    88from fcntl import ioctl 
     9import scapy.config 
    910import scapy.utils 
    1011import scapy.arch 
    1112 
    12 DNET=PCAP=1 
     13scapy.config.conf.use_pcap = 1 
     14scapy.config.conf.use_dnet = 1 
     15from pcapdnet import * 
    1316 
    1417 
    15 try: 
    16     import pcap 
    17     PCAP = 1 
    18 except ImportError: 
    19     if __name__ == "__main__": 
    20         log_loading.error("did not find pcap module") 
    21         raise SystemExit 
    22     else: 
    23         raise 
    24  
    25 try: 
    26     import dnet 
    27     DNET = 1 
    28 except ImportError: 
    29     if __name__ == "__main__": 
    30         log_loading.error("did not find dnet module") 
    31         raise SystemExit 
    32     else: 
    33         raise 
    34  
    35  
    36 def get_if_raw_hwaddr(iff): 
    37     if iff[:2] == scapy.arch.LOOPBACK_NAME: 
    38         return (772, '\x00'*6) 
    39     try: 
    40         l = dnet.intf().get(iff) 
    41         l = l["link_addr"] 
    42     except: 
    43         raise Scapy_Exception("Error in attempting to get hw address for interface [%s]" % iff) 
    44     return l.type,l.data 
    45 def get_if_raw_addr(ifname): 
    46     i = dnet.intf() 
    47     return i.get(ifname)["addr"].data 
    48  
    49 def get_if_list(): 
    50     # remove 'any' interface 
    51     return map(lambda x:x[0],filter(lambda x:x[1] is None,pcap.findalldevs())) 
    52 def get_working_if(): 
    53     try: 
    54         return pcap.lookupdev() 
    55     except Exception: 
    56         return scapy.arch.LOOPBACK_NAME 
    57  
    58 def attach_filter(s, filter): 
    59     warning("attach_filter() should not be called in PCAP mode") 
    60 def set_promisc(s,iff,val=1): 
    61     warning("set_promisc() should not be called in DNET/PCAP mode") 
    6218     
    6319 
    …… 
    6723################## 
    6824 
    69 def new_read_routes(): 
    70  
    71     rtlst = [] 
    72     def addrt(rt,lst): 
    73         dst,gw = rt 
    74         lst.append(rt) 
    75  
    76     r = dnet.route() 
    77     print r.loop(addrt, rtlst) 
    78     return rtlst 
    7925 
    8026def read_routes(): 
    …… 
    13278    return routes 
    13379 
    134 def read_interfaces(): 
    135     i = dnet.intf() 
    136     ifflist = {} 
    137     def addif(iff,lst): 
    138         if not iff.has_key("addr"): 
    139             return 
    140         if not iff.has_key("link_addr"): 
    141             return 
    142         rawip = iff["addr"].data 
    143         ip = inet_ntoa(rawip) 
    144         rawll = iff["link_addr"].data 
    145         ll = scapy.arch.str2mac(rawll) 
    146         lst[iff["name"]] = (rawll,ll,rawip,ip) 
    147     i.loop(addif, ifflist) 
    148     return ifflist 
    14980 
    15081             

  • scapy/config.py

    r884 r885  
    224224""" 
    225225    version = "2.0.0.5 beta" 
    226     session = ""   
     226    session = "" 
     227    interactive = False 
    227228    stealth = "not implemented" 
    228     iface = "none" 
     229    iface = None 
    229230    layers = LayersList() 
    230231    commands = CommandsList() 
    …… 
    256257    resolve = Resolve() 
    257258    noenum = Resolve() 
     259    use_pcap = False 
     260    use_dnet = False 
    258261    ethertypes = ETHER_TYPES 
    259262    protocols = IP_PROTOS 

  • scapy/main.py

    r862 r885  
    8686    import code,sys,cPickle,os,imp,getopt,logging,re 
    8787    from config import conf 
    88  
     88    conf.interactive = True 
    8989    if loglevel is not None: 
    9090        conf.logLevel=loglevel 

  • scapy/supersocket.py

    r884 r885  
    77from select import select 
    88from packet import Raw 
     9from config import conf 
    910from data import * 
    10 from config import conf 
    11 import arch 
    1211 
    13 # From BSD net/bpf.h 
    14 #BIOCIMMEDIATE=0x80044270 
    15 BIOCIMMEDIATE=-2147204496 
    16  
    17  
    18 def flush_fd(fd): 
    19     if type(fd) is not int: 
    20         fd = fd.fileno() 
    21     while 1: 
    22         r,w,e = select([fd],[],[],0) 
    23         if r: 
    24             os.read(fd,MTU) 
    25         else: 
    26             break 
    2712 
    2813class SuperSocket: 
    …… 
    6954        except socket.error,msg: 
    7055            log_runtime.error(msg) 
    71          
    72  
    73  
    74 class L3PacketSocket(SuperSocket): 
    75     def __init__(self, type = ETH_P_ALL, filter=None, promisc=None, iface=None, nofilter=0): 
    76         self.type = type 
    77         self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
    78         self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) 
    79         flush_fd(self.ins) 
    80         if iface: 
    81             self.ins.bind((iface, type)) 
    82         if not nofilter: 
    83             if conf.except_filter: 
    84                 if filter: 
    85                     filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
    86                 else: 
    87                     filter = "not (%s)" % conf.except_filter 
    88             if filter is not None: 
    89                 arch.attach_filter(self.ins, filter) 
    90         self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) 
    91         self.outs = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
    92         self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2**30) 
    93         if promisc is None: 
    94             promisc = conf.promisc 
    95         self.promisc = promisc 
    96         if self.promisc: 
    97             if iface is None: 
    98                 self.iff = arch.get_if_list() 
    99             else: 
    100                 if iface.__class__ is list: 
    101                     self.iff = iface 
    102                 else: 
    103                     self.iff = [iface] 
    104             for i in self.iff: 
    105                 arch.set_promisc(self.ins, i) 
    106     def close(self): 
    107         if self.closed: 
    108             return 
    109         self.closed=1 
    110         if self.promisc: 
    111             for i in self.iff: 
    112                 arch.set_promisc(self.ins, i, 0) 
    113         SuperSocket.close(self) 
    114     def recv(self, x): 
    115         pkt, sa_ll = self.ins.recvfrom(x) 
    116         if sa_ll[2] == socket.PACKET_OUTGOING: 
    117             return None 
    118         if sa_ll[3] in conf.l2types: 
    119             cls = conf.l2types[sa_ll[3]] 
    120             lvl = 2 
    121         elif sa_ll[1] in conf.l3types: 
    122             cls = conf.l3types[sa_ll[1]] 
    123             lvl = 3 
    124         else: 
    125             warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using Ethernet" % (sa_ll[0],sa_ll[1],sa_ll[3])) 
    126             cls = Ether 
    127             lvl = 2 
    128  
    129         try: 
    130             pkt = cls(pkt) 
    131         except KeyboardInterrupt: 
    132             raise 
    133         except: 
    134             if conf.debug_dissector: 
    135                 raise 
    136             pkt = Raw(pkt) 
    137         if lvl == 2: 
    138             pkt = pkt.payload 
    139              
    140         if pkt is not None: 
    141             pkt.time = arch.get_last_packet_timestamp(self.ins) 
    142         return pkt 
    143      
    144     def send(self, x): 
    145         iff,a,gw  = x.route() 
    146         if iff is None: 
    147             iff = conf.iface 
    148         sdto = (iff, self.type) 
    149         self.outs.bind(sdto) 
    150         sn = self.outs.getsockname() 
    151         ll = lambda x:x 
    152         if sn[3] in (ARPHDR_PPP,ARPHDR_TUN): 
    153             sdto = (iff, ETH_P_IP) 
    154         if sn[3] in conf.l2types: 
    155             ll = lambda x:conf.l2types[sn[3]]()/x 
    156         try: 
    157             sx = str(ll(x)) 
    158             x.sent_time = time.time() 
    159             self.outs.sendto(sx, sdto) 
    160         except socket.error,msg: 
    161             x.sent_time = time.time()  # bad approximation 
    162             if conf.auto_fragment and msg[0] == 90: 
    163                 for p in fragment(x): 
    164                     self.outs.sendto(str(ll(p)), sdto) 
    165             else: 
    166                 raise 
    167                      
    168  
    169  
    170  
    171 class L2Socket(SuperSocket): 
    172     def __init__(self, iface = None, type = ETH_P_ALL, filter=None, nofilter=0): 
    173         if iface is None: 
    174             iface = conf.iface 
    175         self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
    176         self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) 
    177         flush_fd(self.ins) 
    178         if not nofilter:  
    179             if conf.except_filter: 
    180                 if filter: 
    181                     filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
    182                 else: 
    183                     filter = "not (%s)" % conf.except_filter 
    184             if filter is not None: 
    185                 arch.attach_filter(self.ins, filter) 
    186         self.ins.bind((iface, type)) 
    187         self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) 
    188         self.outs = self.ins 
    189         self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2**30) 
    190         sa_ll = self.outs.getsockname() 
    191         if sa_ll[3] in conf.l2types: 
    192             self.LL = conf.l2types[sa_ll[3]] 
    193         elif sa_ll[1] in conf.l3types: 
    194             self.LL = conf.l3types[sa_ll[1]] 
    195         else: 
    196             warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using Ethernet" % (sa_ll[0],sa_ll[1],sa_ll[3])) 
    197             self.LL = Ether 
    198              
    199     def recv(self, x): 
    200         pkt, sa_ll = self.ins.recvfrom(x) 
    201         if sa_ll[2] == socket.PACKET_OUTGOING: 
    202             return None 
    203         try: 
    204             q = self.LL(pkt) 
    205         except KeyboardInterrupt: 
    206             raise 
    207         except: 
    208             if conf.debug_dissector: 
    209                 raise 
    210             q = Raw(pkt) 
    211         q.time = get_last_packet_timestamp(self.ins) 
    212         return q 
    213  
    214  
    215 class L2ListenSocket(SuperSocket): 
    216     def __init__(self, iface = None, type = ETH_P_ALL, promisc=None, filter=None, nofilter=0): 
    217         self.type = type 
    218         self.outs = None 
    219         self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) 
    220         self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) 
    221         flush_fd(self.ins) 
    222         if iface is not None: 
    223             self.ins.bind((iface, type)) 
    224         if not nofilter: 
    225             if conf.except_filter: 
    226                 if filter: 
    227                     filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
    228                 else: 
    229                     filter = "not (%s)" % conf.except_filter 
    230             if filter is not None: 
    231                 arch.attach_filter(self.ins, filter) 
    232         if promisc is None: 
    233             promisc = conf.sniff_promisc 
    234         self.promisc = promisc 
    235         if iface is None: 
    236             self.iff = arch.get_if_list() 
    237         else: 
    238             if iface.__class__ is list: 
    239                 self.iff = iface 
    240             else: 
    241                 self.iff = [iface] 
    242         if self.promisc: 
    243             for i in self.iff: 
    244                 arch.set_promisc(self.ins, i) 
    245         self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) 
    246     def close(self): 
    247         if self.promisc: 
    248             for i in self.iff: 
    249                 arch.set_promisc(self.ins, i, 0) 
    250         SuperSocket.close(self) 
    251  
    252     def recv(self, x): 
    253         pkt, sa_ll = self.ins.recvfrom(x) 
    254         if sa_ll[3] in conf.l2types : 
    255             cls = conf.l2types[sa_ll[3]] 
    256         elif sa_ll[1] in conf.l3types: 
    257             cls = conf.l3types[sa_ll[1]] 
    258         else: 
    259             warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using Ethernet" % (sa_ll[0],sa_ll[1],sa_ll[3])) 
    260             cls = Ether 
    261  
    262         try: 
    263             pkt = cls(pkt) 
    264         except KeyboardInterrupt: 
    265             raise 
    266         except: 
    267             if conf.debug_dissector: 
    268                 raise 
    269             pkt = Raw(pkt) 
    270         pkt.time = get_last_packet_timestamp(self.ins) 
    271         return pkt 
    272      
    273     def send(self, x): 
    274         raise Scapy_Exception("Can't send anything with L2ListenSocket") 
    275  
    276  
    277  
    278 class L3dnetSocket(SuperSocket): 
    279     def __init__(self, type = ETH_P_ALL, filter=None, promisc=None, iface=None, nofilter=0): 
    280         self.iflist = {} 
    281         self.ins = pcap.pcapObject() 
    282         if iface is None: 
    283             iface = conf.iface 
    284         self.iface = iface 
    285         self.ins.open_live(iface, 1600, 0, 100) 
    286         try: 
    287             ioctl(self.ins.fileno(),BIOCIMMEDIATE,struct.pack("I",1)) 
    288         except: 
    289             pass 
    290         if nofilter: 
    291             if type != ETH_P_ALL:  # PF_PACKET stuff. Need to emulate this for pcap 
    292                 filter = "ether proto %i" % type 
    293             else: 
    294                 filter = None 
    295         else: 
    296             if conf.except_filter: 
    297                 if filter: 
    298                     filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
    299                 else: 
    300                     filter = "not (%s)" % conf.except_filter 
    301             if type != ETH_P_ALL:  # PF_PACKET stuff. Need to emulate this for pcap 
    302                 if filter: 
    303                     filter = "(ether proto %i) and (%s)" % (type,filter) 
    304                 else: 
    305                     filter = "ether proto %i" % type 
    306         if filter: 
    307             self.ins.setfilter(filter, 0, 0) 
    308     def send(self, x): 
    309         iff,a,gw  = x.route() 
    310         if iff is None: 
    311             iff = conf.iface 
    312         ifs = self.iflist.get(iff) 
    313         if ifs is None: 
    314             self.iflist[iff] = ifs = dnet.eth(iff) 
    315         sx = str(Ether()/x) 
    316         x.sent_time = time.time() 
    317         ifs.send(sx) 
    318     def recv(self,x=MTU): 
    319         ll = self.ins.datalink() 
    320         if ll in conf.l2types: 
    321             cls = conf.l2types[ll] 
    322         else: 
    323             warning("Unable to guess datalink type (interface=%s linktype=%i). Using Ethernet" % (self.iface, ll)) 
    324             cls = Ether 
    325  
    326         pkt = self.ins.next() 
    327         if pkt is not None: 
    328             l,pkt,ts = pkt 
    329         if pkt is None: 
    330             return 
    331  
    332         try: 
    333             pkt = cls(pkt) 
    334         except KeyboardInterrupt: 
    335             raise 
    336         except: 
    337             if conf.debug_dissector: 
    338                 raise 
    339             pkt = Raw(pkt) 
    340         pkt.time = ts 
    341         return pkt.payload 
    342  
    343     def nonblock_recv(self): 
    344         self.ins.setnonblock(1) 
    345         p = self.recv() 
    346         self.ins.setnonblock(0) 
    347         return p 
    348  
    349     def close(self): 
    350         if hasattr(self, "ins"): 
    351             del(self.ins) 
    352         if hasattr(self, "outs"): 
    353             del(self.outs) 
    354  
    355 class L2dnetSocket(SuperSocket): 
    356     def __init__(self, iface = None, type = ETH_P_ALL, filter=None, nofilter=0): 
    357         if iface is None: 
    358             iface = conf.iface 
    359         self.iface = iface 
    360         self.ins = pcap.pcapObject() 
    361         self.ins.open_live(iface, 1600, 0, 100) 
    362         try: 
    363             ioctl(self.ins.fileno(),BIOCIMMEDIATE,struct.pack("I",1)) 
    364         except: 
    365             pass 
    366         if nofilter: 
    367             if type != ETH_P_ALL:  # PF_PACKET stuff. Need to emulate this for pcap 
    368                 filter = "ether proto %i" % type 
    369             else: 
    370                 filter = None 
    371         else: 
    372             if conf.except_filter: 
    373                 if filter: 
    374                     filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
    375                 else: 
    376                     filter = "not (%s)" % conf.except_filter 
    377             if type != ETH_P_ALL:  # PF_PACKET stuff. Need to emulate this for pcap 
    378                 if filter: 
    379                     filter = "(ether proto %i) and (%s)" % (type,filter) 
    380                 else: 
    381                     filter = "ether proto %i" % type 
    382         if filter: 
    383             self.ins.setfilter(filter, 0, 0) 
    384         self.outs = dnet.eth(iface) 
    385     def recv(self,x): 
    386         ll = self.ins.datalink() 
    387         if ll in conf.l2types: 
    388             cls = conf.l2types[ll] 
    389         else: 
    390             warning("Unable to guess datalink type (interface=%s linktype=%i). Using Ethernet" % (self.iface, ll)) 
    391             cls = Ether 
    392  
    393         pkt = self.ins.next() 
    394         if pkt is not None: 
    395             l,pkt,ts = pkt 
    396         if pkt is None: 
    397             return 
    398          
    399         try: 
    400             pkt = cls(pkt) 
    401         except KeyboardInterrupt: 
    402             raise 
    403         except: 
    404             if conf.debug_dissector: 
    405                 raise 
    406             pkt = Raw(pkt) 
    407         pkt.time = ts 
    408         return pkt 
    409  
    410     def nonblock_recv(self): 
    411         self.ins.setnonblock(1) 
    412         p = self.recv(MTU) 
    413         self.ins.setnonblock(0) 
    414         return p 
    415  
    416     def close(self): 
    417         if hasattr(self, "ins"): 
    418             del(self.ins) 
    419         if hasattr(self, "outs"): 
    420             del(self.outs) 
    421      
    422      
    423      
    424  
    425  
    426 class L2pcapListenSocket(SuperSocket): 
    427     def __init__(self, iface = None, type = ETH_P_ALL, promisc=None, filter=None): 
    428         self.type = type 
    429         self.outs = None 
    430         self.ins = pcap.pcapObject() 
    431         self.iface = iface 
    432         if iface is None: 
    433             iface = conf.iface 
    434         if promisc is None: 
    435             promisc = conf.sniff_promisc 
    436         self.promisc = promisc 
    437         self.ins.open_live(iface, 1600, self.promisc, 100) 
    438         try: 
    439             ioctl(self.ins.fileno(),BIOCIMMEDIATE,struct.pack("I",1)) 
    440         except: 
    441             pass 
    442         if type == ETH_P_ALL: # Do not apply any filter if Ethernet type is given 
    443             if conf.except_filter: 
    444                 if filter: 
    445                     filter = "(%s) and not (%s)" % (filter, conf.except_filter) 
    446                 else: 
    447                     filter = "not (%s)" % conf.except_filter 
    448             if filter: 
    449                 self.ins.setfilter(filter, 0, 0) 
    450  
    451     def close(self): 
    452         del(self.ins) 
    453          
    454     def recv(self, x): 
    455         ll = self.ins.datalink() 
    456         if ll in conf.l2types: 
    457             cls = conf.l2types[ll] 
    458         else: 
    459             warning("Unable to guess datalink type (interface=%s linktype=%i). Using Ethernet" % (self.iface, ll)) 
    460             cls = Ether 
    461  
    462         pkt = None 
    463         while pkt is None: 
    464             pkt = self.ins.next() 
    465             if pkt is not None: 
    466                 l,pkt,ts = pkt 
    467          
    468         try: 
    469             pkt = cls(pkt) 
    470         except KeyboardInterrupt: 
    471             raise 
    472         except: 
    473             if conf.debug_dissector: 
    474                 raise 
    475             pkt = Raw(pkt) 
    476         pkt.time = ts 
    477         return pkt 
    478  
    479     def send(self, x): 
    480         raise Scapy_Exception("Can't send anything with L2pcapListenSocket") 
    481  
    48256 
    48357class SimpleSocket(SuperSocket): 
    …… 
    50882         
    50983 
    510 conf.L3socket = L3PacketSocket 
    511 conf.L2socket = L2Socket 
    512 conf.L2listen = L2ListenSocket 
    51384 
    514 if arch.PCAP: 
    515     conf.L2listen=L2pcapListenSocket 
    516     if arch.DNET: 
    517         conf.L3socket=L3dnetSocket 
    518         conf.L2socket=L2dnetSocket 
    519  
     85if conf.L3socket is None: 
     86    conf.L3socket = L3RawSocket