Changeset 5591

Timestamp:

06/04/10 22:38:07 (3 years ago)

Author:

kosma

Message:

Initial version of SocketL2 - Linux and FreeBSD supported. With tests.
L2 tests fail under BSD. L3 support not touched.

Location:

UMPA/branch/link-layer-integration

Files:

• tests/a_unit/test_sockets.py (modified) (4 diffs)
• tests/utils.py (modified) (1 diff)
• umit/umpa/__init__.py (modified) (1 diff)
• umit/umpa/_sockets.py (modified) (2 diffs)

UMPA/branch/link-layer-integration/tests/a_unit/test_sockets.py

@@ -2 +2 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2009 Adriano Monteiro Marques.
+# Copyright (C) 2009-2010 Adriano Monteiro Marques.
 #
-# Author: Bartosz SKOWRON <getxsick at gmail dot com>
+# Authors: Bartosz SKOWRON <getxsick at gmail dot com>
+#          Kosma Moczek <kosma at kosma dot pl>
 #
 # This library is free software; you can redistribute it and/or modify 
@@ -23 +24 @@
 import py.test
 
-from umit.umpa import Socket, Packet
-from umit.umpa.protocols import IP, TCP
+from umit.umpa import Socket, SocketL2, Packet
+import umit.umpa.sniffing
+from umit.umpa.protocols import Ethernet, IP, TCP, UDP, Payload
 from umit.umpa.utils.exceptions import UMPAException, UMPANotPermittedException
-
+from tests.utils import SendPacket, SendPacketL2
 
 class TestUMPASockets(object):
@@ -35 +37 @@
     def test_sent_size(self):
         if os.name == 'posix' and os.geteuid() != 0:
-            py.test.skip('root-priviliges are needed')
+            py.test.skip('root-privileges are needed')
 
         p1 = Packet(IP(), TCP())
@@ -42 +44 @@
         s = Socket()
         size = s.send(p1, p2)
+        assert size == [40, 40]
 
-        assert size == [40, 40]
+    def test_send_size_L2(self):
+        if os.name == 'posix' and os.geteuid() != 0:
+            py.test.skip('root-privileges are needed')
+
+        p1 = Packet(Ethernet(src='00:11:22:33:44:55', dst='00:11:22:33:44:55'),
+                    IP(src="127.0.0.1", dst="127.0.0.1"),
+                    TCP(srcport=1234, dstport=4321),
+                    Payload('xyz'))
+        p2 = Packet(Ethernet(src='00:11:22:33:44:55', dst='00:11:22:33:44:55'),
+                    IP(src="127.0.0.1", dst="127.0.0.1"),
+                    TCP(srcport=1234, dstport=4321),
+                    Payload('xyz'))
+
+        s = SocketL2(iface='lo')
+        size = s.send(p1, p2)
+
+        assert size == [57, 57]
+
+    def test_send_sniff_tcp(self):
+        if os.name == 'posix' and os.geteuid() != 0:
+            py.test.skip('root-privileges are needed')
+
+        p = Packet(Ethernet(src='00:11:22:33:44:55', dst='00:11:22:33:44:55'),
+                   IP(src="127.0.0.1", dst="127.0.0.1"),
+                   UDP(srcport=1234, dstport=4321),
+                   Payload('xyz'))
+
+        th = SendPacketL2(p, iface='lo')
+        th.start()
+        result = umit.umpa.sniffing.sniff(1, device='lo', filter="src port 1234")
+        th.join()
+
+        assert len(result) == 1
+        assert result[0].ethernet.src == '00:11:22:33:44:55'
+        assert result[0].ip.src == '127.0.0.1'
+        assert result[0].udp.srcport == 1234
+        assert result[0].udp.dstport == 4321
+
+    def test_send_sniff_tcp_L2(self):
+        if os.name == 'posix' and os.geteuid() != 0:
+            py.test.skip('root-privileges are needed')
+
+        p = Packet(Ethernet(src='00:11:22:33:44:55', dst='00:11:22:33:44:55'),
+                   IP(src="127.0.0.1", dst="127.0.0.1"),
+                   TCP(srcport=1234, dstport=4321),
+                   Payload('xyz'))
+
+        th = SendPacketL2(p, iface='lo')
+        th.start()
+        result = umit.umpa.sniffing.sniff(1, device='lo', filter="src port 1234")
+        th.join()
+
+        assert len(result) == 1
+        assert result[0].ethernet.src == '00:11:22:33:44:55'
+        assert result[0].ip.src == '127.0.0.1'
+        assert result[0].tcp.srcport == 1234
+        assert result[0].tcp.dstport == 4321

UMPA/branch/link-layer-integration/tests/utils.py

@@ -35 +35 @@
             time.sleep(2)
             s.send(self._packet)
+
+class SendPacketL2(threading.Thread):
+    def __init__(self, packet, amount=1, iface=None):
+        super(SendPacketL2, self).__init__()
+        self._packet = packet
+        self._amount = amount
+        self._iface  = iface
+    def run(self):
+        s = umit.umpa.SocketL2(iface=self._iface)
+        for i in xrange(self._amount):
+            time.sleep(2)
+            s.send(self._packet)

UMPA/branch/link-layer-integration/umit/umpa/__init__.py

@@ -41 +41 @@
 from umit.umpa._config import config
 from umit.umpa._packets import Packet
-from umit.umpa._sockets import Socket
+from umit.umpa._sockets import Socket, SocketL2
 
 # UMPA handles with the local directory $HOME/.umpa

UMPA/branch/link-layer-integration/umit/umpa/_sockets.py

@@ -2 +2 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2008-2009 Adriano Monteiro Marques.
-#
-# Author: Bartosz SKOWRON <getxsick at gmail dot com>
+# Copyright (C) 2008-2010 Adriano Monteiro Marques.
+#
+# Authors: Bartosz SKOWRON <getxsick at gmail dot com>
+#          Kosma Moczek <kosma at kosma dot pl>
 #
 # This library is free software; you can redistribute it and/or modify 
@@ -21 +22 @@
 
 """
-Socket connection management.
-
-It contains Socket class which should be used instead of
-socket.socket() directly from the standard library.
-
-But it's correctly to use socket module directly if needed.
+Raw sockets support.
+
+Contains Socket classes which can be used to send raw packets in
+a platform-independent manner. The standard Python socket module can be used
+instead if advanced functionalities are needed.
 """
 
 import socket
+import sys
+import re
+from fcntl import ioctl
 
 from umit.umpa.utils.exceptions import UMPAException, UMPANotPermittedException
+
+# constants from various header files not available under Python
+ETH_P_ALL = 3                     # from linux/if_ether.h
+BIOCSETIF = 2149597804            # from net/bpf.h
+
+# Detect socket programming model. This greatly simplifies socket code.
+if re.match('linux', sys.platform):
+    _l2model = 'AF_PACKET'
+    _l3model = 'AF_INET'
+    _l3quirk = None
+elif re.match('freebsd|netbsd|darwin', sys.platform):
+    _l2model = 'bpf'
+    _l3model = 'AF_INET'
+    _l3quirk = 'ntohs'
+elif re.match('openbsd', sys.platform):
+    _l2model = 'bpf'
+    _l3model = 'AF_INET',
+    _l3quirk = None
+elif re.match('win', sys.platform):
+    _l2model = 'NDIS'
+    _l3model = 'AF_INET'
+    _l3quirk = 'windows'
+else:
+    _l2model = None
+    _l3model = None
+    _l3quirk = None
+
+def send(*packets, **kwargs):
+    """
+    Send arbitrary packets.
+
+    The function creates sockets of proper level as needed. The 'iface'
+    named argument must be supplied for L2 (link-layer) sockets.
+
+    @type packets: C{Packet}
+    @param packets: list of umit.umpa.Packet objects to send.
+
+    @returns: List of return values (byte counts) from the send() function.
+    """
+
+    sent_bytes = []
+    for packet in packets:
+        # create appropriate socket based on packet's lowermost layer
+        if packet.protos[0].layer == 2:
+            sock = SocketL2(iface=kwargs.get('iface'))
+        else:
+            sock = SocketL3()
+        sent_bytes.extend(sock.send(packet))
+    return sent_bytes
+
+class SocketL2(object):
+    """
+    Level 2 (link-layer) socket class.
+
+    Supported platforms: Linux (AF_PACKET), BSD (bpf).
+    """
+
+    def __init__(self, iface=None):
+        """
+        Create a new SocketL2.
+
+        @type iface: C{str}
+        @param iface: Interface to use for sending the packets.
+        """
+        if iface is None:
+            # TODO: port interface detection from the link-layer branch
+            raise NotImplementedError("You need to specify iface")
+
+        if _l2model == 'AF_PACKET':
+            try:
+                self._sock = socket.socket(socket.AF_PACKET,
+                        socket.SOCK_RAW,
+                        ETH_P_ALL)
+            except socket.error, msg:
+                raise UMPANotPermittedException(msg)
+
+            self._sock.bind((iface, ETH_P_ALL))
+            self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2**20)
+        elif _l2model == 'bpf':
+            try:
+                self._sock = open("/dev/bpf", 'w')
+            except IOError, msg:
+                raise UMPAException('cannot open /dev/bpf: ' + msg)
+
+            ioctl(self._sock, BIOCSETIF, iface)
+        else:
+            raise NotImplementedError("L2 sockets unsupported on your platform")
+
+    def send(self, *packets):
+        """
+        Send packets through the socket.
+
+        @type packets: C{Packet}
+        @param packets: List of umit.umpa.Packet objects to send.
+
+        @returns: List of return values (byte counts) from the send() function.
+        """
+
+        sent_bytes = []
+        for packet in packets:
+            if _l2model == 'AF_PACKET':
+                sent_bytes.append(self._sock.send(packet.get_raw()))
+            elif _l2model == 'bpf':
+                sent_bytes.append(self._sock.write(packet.get_raw()))
+            else:
+                raise NotImplementedError("L2 send unsupported on your platform")
+        return sent_bytes
+
+# TODO: legacy L3 code below, not integrated yet
 
 class Socket(object):