Synnefo » snf-network

function clear_tap {

 arptables -D OUTPUT -o $INTERFACE --opcode request -j mangle >/dev/null 2>&1

}

	arptables -A OUTPUT -o $INTERFACE --opcode request -j mangle --mangle-ip-s    "$GATEWAY"

	# route interface to the proper routing table

	# static route mapping IP -> INTERFACE

	ip route replace $IP proto static dev $INTERFACE table $TABLE

	uplink=$GATEWAY6

	eui64=$($MAC2EUI64 $MAC $prefix)

	ip -6 rule add dev $INTERFACE table $TABLE

	ip -6 ro replace $eui64/128 dev $INTERFACE table $TABLE

	# disable proxy NDP since we're handling this on userspace

	# this should be the default, but better safe than sorry

fi

if [ -n "$SUBNET6" ]; then

 echo SUBNET6=$SUBNET6 >> $FILE

fi

}

  exist=$(ebtables -L | grep $TAP)

  if [ ! -z "$exist" ]; then

  fi

}

if [ "$MODE" = "routed" ]; then

  TABLE=rt_$NETWORK

	# special proxy-ARP/NDP routing mode

	# use a constant predefined MAC address for the tap

	ip link set $INTERFACE addr $TAP_CONSTANT_MAC

	# bring the tap up

	# Drop unicast BOOTP/DHCP packets

	iptables -A FORWARD -i $INTERFACE -p udp --dport 67 -j DROP

	routed_setup_firewall

	setup_nfdhcpd $INTERFACE

elif [ "$MODE" = "bridged" ]; then

  clear_ebtables >/dev/null 2>&1

	ifconfig $INTERFACE 0.0.0.0 up

	brctl addif $BRIDGE $INTERFACE

    gateway = None

    subnet6 = None

    gateway6 = None

    for line in iffile:

        if line.startswith("IP="):

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

        elif line.startswith("GATEWAY6="):

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

    return Client(tap=tap, mac=mac, ips=ips, 

                  hostname=hostname, indev=indev, subnet=subnet,

class ClientFileHandler(pyinotify.ProcessEvent):

    def __init__(self, server):

class Client(object):

    def __init__(self, tap=None, indev=None, mac=None, ips=None, hostname=None, 

        self.mac = mac

        self.ips = ips

        self.hostname = hostname

        self.subnet6 = subnet6

        self.gateway6 = gateway6

        self.net6 = Subnet(net=subnet6, gw=gateway6, dev=tap)

    @property

    def ip(self):

        self.clients = {}

        #self.subnets = {}

        #self.v6nets = {}

        self.nfq = {}

        self.l2socket = socket.socket(socket.AF_PACKET,

            if binding.is_valid():

                self.clients[binding.mac] = binding

                logging.debug("Added client %s on %s", binding.hostname, tap)

    def remove_tap(self, tap):

        """ Cleanup clients on a removed interface

        """

        logging.debug("Removed interface %s", tap)

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

        """

        # Decode the response - NFQUEUE relays IP packets

        pkt = IP(payload.get_data())

        # Get the client MAC address

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

        hlen = resp.hlen

        try:

            binding = self.clients[mac]

        except KeyError:

            return

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

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

        subnet = binding.net

        ]

        resp /= DHCP(options=dhcp_options)

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

                     binding.ip, binding.tap)

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

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

        """

        try:

        except KeyError:

            logging.debug("Ignoring router solicitation on"

            # We don't know what to do with this packet, so let the kernel

            # handle it

            payload.set_verdict(nfqueue.NF_ACCEPT)

            return

        if subnet.net is None:

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

          return

        ifll = subnet.make_ll64(ifmac)

               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

        """

            logging.debug("Ignoring neighbour solicitation on"

            # We don't know what to do with this packet, so let the kernel

            # handle it

            payload.set_verdict(nfqueue.NF_ACCEPT)

            return

        if subnet.net is None:

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

          return

        ifll = subnet.make_ll64(indevmac)

        if not (subnet.net.overlaps(ns.tgt) or str(ns.tgt) == str(ifll)):

            logging.debug("Received NS for a non-routable IP (%s)", ns.tgt)

            payload.set_verdict(nfqueue.NF_ACCEPT)

            return 1

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

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

               ICMPv6NDOptDstLLAddr(lladdr=indevmac)

    def send_periodic_ra(self):

        # Use a separate thread as this may take a _long_ time with