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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# 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 
# it under the terms of the GNU Lesser General Public License as published 
# by the Free Software Foundation; either version 2.1 of the License, or 
# (at your option) any later version.
#
# This library is distributed in the hope that it will be useful, but 
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
# License for more details.
#
# You should have received a copy of the GNU Lesser General Public License 
# along with this library; if not, write to the Free Software Foundation, 
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 

"""
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 os
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 sys.platform == 'linux2':
    _l2model = 'AF_PACKET'
    _l3model = 'AF_INET'
    _l3quirk = None
elif sys.platform.startswith('freebsd') or \
     sys.platform.startswith('netbsd') or \
     sys.platform.startswith('darwin'):
    _l2model = 'bpf'
    _l3model = 'AF_INET'
    _l3quirk = 'ntohs'
elif sys.platform.startswith('openbsd'):
    _l2model = 'bpf'
    _l3model = 'AF_INET',
    _l3quirk = None
elif os.name == 'nt':
    _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):
    """
    This class handles with sockets.

    To send built packets your need to create a socket.
    You can use socket module from Python Standard Library directly
    but it's recommended to use this class instead.

    That is because there are some other features,
    and for some security issues.
    """

    def __init__(self):
        """
        Create a new Socket().
        """

        # to create socket object we need root priviligies.
        # if non-root EUID, then exception is raised
        # use umit.umpa.utils.security.super_priviliges() to avoid exception
        # when a new Socket object is created
        try:
            self._sock = socket.socket(socket.AF_INET, socket.SOCK_RAW,
                                                            socket.IPPROTO_RAW)
        except socket.error, msg:
            raise UMPANotPermittedException(msg)

        # to build own headers of IP
        self._sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

    def send(self, *packets):
        """
        Send packets in to the network.

        @type packets: C{Packet}
        @param packets: packets which were built by umit.umpa.Packet objects.
        """

        sent_bits = []
        for packet in packets:
            # XXX try to use similar mechanism as is for SocketL2
            # to pick up correct interface, using bind() and send()
            # then there is no need to pick out a destination address
            dst_addr = self._get_address(packet)
            # if dst_addr is a tuple, convert it to a string; works only for IPv4
            if type(dst_addr) is tuple:
                dst_addr = ".".join(str(y) for y in dst_addr)
            sent_bits.append(self._sock.sendto(packet.get_raw(),
                                                            (dst_addr, 0)))
        return sent_bits

    def _get_address(self, packet):
        """
        Pick out the destination address from 3rd layer.

        @return: destination address from 3rd layer of OSI model.
        """
        for proto in packet.protos:
            if proto.layer == 3:    # XXX: if we included more than one protocol
                break               #   of layer 3 we got IP from the first one

        if not proto:
            raise UMPAException("There is not prototocol from 3rd layer.")

        return proto.dst