Synnefo » snf-network

  #needed in bridged mode where the packets seems to arrive from the

  #bridge and not from the tap

	cat >$FILE <<EOF

IP=$IP

MAC=$MAC

HOSTNAME=$INSTANCE

        logging.warn("Unable to open binding file %s: %s", path, str(e))

        return None

    mac = None

    ips = None

    hostname = None

    subnet = None

    gateway = None

            mac = line.strip().split("=")[1]

        elif line.startswith("HOSTNAME="):

            hostname = line.strip().split("=")[1]

        elif line.startswith("SUBNET="):

            subnet = line.strip().split("=")[1]

        elif line.startswith("GATEWAY="):

        elif line.startswith("GATEWAY6="):

            gateway6 = line.strip().split("=")[1]

                  gateway=gateway, subnet6=subnet6, gateway6=gateway6 )

class ClientFileHandler(pyinotify.ProcessEvent):

        Currently this removes an interface from the watch list

        """

    def process_IN_CLOSE_WRITE(self, event): # pylint: disable=C0103

        """ Add file handler

        Currently this adds an interface to the watch list

        """

class Client(object):

        self.mac = mac

        self.ips = ips

        self.hostname = hostname

        self.subnet = subnet

        self.gateway = gateway

        self.subnet6 = subnet6

        self.gateway6 = gateway6

    @property

    def ip(self):

        q.set_mode(nfqueue.NFQNL_COPY_PACKET)

        self.nfq[q.get_fd()] = q

        """ Send a raw packet using a layer-2 socket

        """

        if isinstance(data, BasePacket):

            data = str(data)

        count = self.l2socket.send(data)

        ldata = len(data)

        if count != ldata:

            logging.warn("Truncated send on %s (%d/%d bytes sent)",

    def build_config(self):

        self.clients.clear()

        for path in glob.glob(os.path.join(self.data_path, "*")):

    def get_ifindex(self, iface):

        """ Get the interface index from sysfs

            f = open(path, 'r')

        except EnvironmentError:

            logging.debug("%s is probably down, removing", iface)

            return ifindex

        except EnvironmentError, e:

            logging.warn("Error reading %s's ifindex from sysfs: %s",

                         iface, str(e))

        finally:

            f.close()

            f = open(path, 'r')

        except EnvironmentError:

            logging.debug("%s is probably down, removing", iface)

            return addr

        try:

        return addr

        """ Add an interface to monitor

        """

        binding = parse_binding_file(path)

        if binding is None:

            return

        if ifindex is None:

        else:

            if binding.is_valid():

                self.clients[binding.mac] = binding

        """ Cleanup clients on a removed interface

        """

        for mac in self.clients.keys():

                del self.clients[mac]

        for ifindex in self.ifaces.keys():

                del self.ifaces[ifindex]

    def dhcp_response(self, i, payload): # pylint: disable=W0613,R0914

        """

        try:

            # Get the actual interface from the ifindex

        except KeyError:

            # We don't know anything about this interface, so accept the packet

            # and return

        try:

            binding = self.clients[mac]

        except KeyError:

            return

            logging.warn("Received spoofed DHCP request for %s from interface"

            return

               IP(src=DHCP_DUMMY_SERVER_IP, dst=binding.ip)/\

               UDP(sport=pkt.dport, dport=pkt.sport)/resp

        subnet = binding.net

        if not DHCP in pkt:

            logging.warn("Invalid request from %s on %s, no DHCP"

            return

        dhcp_options = []

                requested_addr = opt[1]

        logging.info("%s from %s on %s", DHCP_TYPES.get(req_type, "UNKNOWN"),

        if req_type == DHCPREQUEST and requested_addr != binding.ip:

            resp_type = DHCPNAK

            logging.info("Sending DHCPNAK to %s on %s: requested %s"

                         binding.ip)

        elif req_type in (DHCPDISCOVER, DHCPREQUEST):

        elif req_type == DHCPRELEASE:

            # Log and ignore

            return

        # Finally, always add the server identifier and end options

        resp /= DHCP(options=dhcp_options)

        logging.info("%s to %s (%s) on %s", DHCP_TYPES[resp_type], mac,

    def rs_response(self, i, payload): # pylint: disable=W0613

        """ Generate a reply to a BOOTP/DHCP request

        """

        try:

            # Get the actual interface from the ifindex

        except KeyError:

            logging.debug("Ignoring router solicitation on"

                          " unknown interface %d", indev)

            payload.set_verdict(nfqueue.NF_ACCEPT)

            return

        subnet = binding[0].net6

        if subnet.net is None:

          logging.debug("No IPv6 network assigned for the interface")

        # Signal the kernel that it shouldn't further process the packet

        payload.set_verdict(nfqueue.NF_DROP)

               IPv6(src=str(ifll))/ICMPv6ND_RA(routerlifetime=14400)/\

               ICMPv6NDOptPrefixInfo(prefix=str(subnet.prefix),

                                     prefixlen=subnet.prefixlen)

            resp /= ICMPv6NDOptRDNSS(dns=self.ipv6_nameservers,

                                     lifetime=self.ra_period * 3)

    def ns_response(self, i, payload): # pylint: disable=W0613

        """ Generate a reply to an ICMPv6 neighbor solicitation

        """

        try:

            # Get the actual interface from the ifindex

        except KeyError:

            logging.debug("Ignoring neighbour solicitation on"

                          " unknown interface %d", indev)

            payload.set_verdict(nfqueue.NF_ACCEPT)

            return

        subnet = binding[0].net6

        if subnet.net is None:

          logging.debug("No IPv6 network assigned for the interface")

          return

        ns = IPv6(payload.get_data())

            client_lladdr = ns.lladdr

        except AttributeError:

            return 1

               IPv6(src=str(ifll), dst=ns.src)/\

               ICMPv6ND_NA(R=1, O=0, S=1, tgt=ns.tgt)/\

        return 1

    def send_periodic_ra(self):

        start = time.time()

        i = 0

        for binding in self.clients.values():

            subnet = binding.net6

            if subnet.net is None:

                logging.debug("Skipping periodic RA on interface %s,"

                continue

                   IPv6(src=str(ifll))/ICMPv6ND_RA(routerlifetime=14400)/\

                   ICMPv6NDOptPrefixInfo(prefix=str(subnet.prefix),

                                         prefixlen=subnet.prefixlen)

                resp /= ICMPv6NDOptRDNSS(dns=self.ipv6_nameservers,

                                         lifetime=self.ra_period * 3)

            try:

            except socket.error, e:

            except Exception, e:

                logging.warn("Unkown error during periodic RA on %s: %s",

            i += 1

        logging.debug("Sent %d RAs in %.2f seconds", i, time.time() - start)