Synnefo » snf-nfdhcpd

def get_indev(payload):

    try:

        indev_ifindex = payload.get_physindev()

        if indev_ifindex:

            logging.debug("Incomming packet from bridge %s", indev_ifindex)

            return indev_ifindex

    return indev_ifindex

def get_binding(proxy, ifindex, mac):

    try:

        if proxy.mac_indexed_clients:

            b = proxy.clients[mac]

        else:

            b = proxy.clients[ifindex]

        return b

    except KeyError:

        logging.debug("No client found for mac/ifindex %s/%s", mac, ifindex)

        return None

def parse_binding_file(path):

    """ Read a client configuration from a tap file

    """

    try:

        iffile = open(path, 'r')

    except EnvironmentError, e:

    def get_value(line):

        v = line.strip().split('=')[1]

        if v == '':

        return v

    for line in iffile:

    except:

        return None

class ClientFileHandler(pyinotify.ProcessEvent):

    def __init__(self, server):

        pyinotify.ProcessEvent.__init__(self)

        self.server = server

        """ Delete file handler

        Currently this removes an interface from the watch list

        """

        self.server.remove_tap(event.name)

        """ Add file handler

        Currently this adds an interface to the watch list

        return self._make_eui64("fe80::", mac)

                 rs_queue_num=None, ns_queue_num=None,

                 dhcp_lease_lifetime=DEFAULT_LEASE_LIFETIME,

                 dhcp_lease_renewal=DEFAULT_LEASE_RENEWAL,

        logging.info("Cleanup finished")

    def _setup_nfqueue(self, queue_num, family, callback):

                      queue_num, family)

        q = nfqueue.queue()

        q.set_callback(callback)

        # This is mandatory for the queue to operate

        q.set_mode(nfqueue.NFQNL_COPY_PACKET)

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

    def sendp(self, data, dev):

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

        """

        if isinstance(data, BasePacket):

            data = str(data)

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

            self.add_tap(path)

        for b in self.clients.values():

    def get_ifindex(self, iface):

        """ Get the interface index from sysfs

        """

        path = os.path.abspath(os.path.join(SYSFS_NET, iface, "ifindex"))

        if not path.startswith(SYSFS_NET):

            return None

        return ifindex

    def get_iface_hw_addr(self, iface):

        """ Get the interface hardware address from sysfs

        """

        path = os.path.abspath(os.path.join(SYSFS_NET, iface, "address"))

        if not path.startswith(SYSFS_NET):

            return None

        except:

            logging.debug("Client on %s disappeared!!!", tap)

        """ Generate a reply to bnetfilter-queue-deva BOOTP/DHCP request

        """

        resp = pkt.getlayer(BOOTP).copy()

        hlen = resp.hlen

        mac = resp.chaddr[:hlen].encode("hex")

        # Server responses are always BOOTREPLYs

        resp.op = "BOOTREPLY"

            payload.set_verdict(nfqueue.NF_ACCEPT)

            return

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

        payload.set_verdict(nfqueue.NF_DROP)

                 ("lease_time", self.lease_lifetime),

            ]

            if subnet.gw:

            dhcp_options += [("name_server", x) for x in self.dhcp_nameservers]

        elif req_type == DHCPINFORM:

        elif req_type == DHCPRELEASE:

            # Log and ignore

            return

        # Finally, always add the server identifier and end options

            logging.warn("Unkown error during DHCP response on %s: %s",

                         binding.indev, str(e))

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

        """

        pkt = IPv6(payload.get_data())

        #logging.debug(pkt.show())

        try:

            mac = pkt.lladdr

            logging.debug("Cannot obtain lladdr in rs")

            return

        indev = get_indev(payload)

        subnet = binding.net6

        if subnet.net is None:

        indevmac = self.get_iface_hw_addr(binding.indev)

        ifll = subnet.make_ll64(indevmac)

        if ifll is None:

            return

        resp = Ether(src=indevmac)/\

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

               ICMPv6NDOptPrefixInfo(prefix=str(subnet.prefix),

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

                         binding.indev, str(e))

        """ Generate a reply to an ICMPv6 neighbor solicitation

        """

        ns = IPv6(payload.get_data())

        #logging.debug(ns.show())

        try:

            mac = ns.lladdr

            logging.debug("Cannot obtain lladdr from ns")

            return

        indev = get_indev(payload)

        subnet = binding.net6

        if subnet.net is None:

        indevmac = self.get_iface_hw_addr(binding.indev)

        for binding in self.clients.values():

            tap = binding.tap

            indev = binding.indev

            subnet = binding.net6

            if subnet.net is None:

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

        # Yes, we are accessing _fd directly, but it's the only way to have a

        # single select() loop ;-)

        start = time.time()

        if self.ipv6_enabled:

            rlist, _, xlist = select(self.nfq.keys() + [iwfd], [], [], timeout)

            if xlist:

                logging.warn("Warning: Exception on %s",

            if rlist:

                if iwfd in rlist:

    validator.functions["ip_addr_list"] = is_ip_list

    config_spec = StringIO(CONFIG_SPEC)

    parser = optparse.OptionParser()

    parser.add_option("-c", "--config", dest="config_file",

                      help="The location of the data files", metavar="FILE",

                      dest="daemonize", default=True,

                      help="Do not daemonize, stay in the foreground")

    opts, args = parser.parse_args()

    try:

    # CAP_NET_ADMIN: we need to send nfqueue packet verdicts to a netlinkgroup

    capng.capng_clear(capng.CAPNG_SELECT_BOTH)

    capng.capng_update(capng.CAPNG_ADD,

                       capng.CAP_NET_ADMIN)

    capng.capng_change_id(uid.pw_uid, uid.pw_gid,

    logging.info("Ready to serve requests")

    try: