#!/usr/bin/env python
#
# Copyright (c) 2020, The OpenThread Authors.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
# 3. Neither the name of the copyright holder nor the
#    names of its contributors may be used to endorse or promote products
#    derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""
>> Thread Host Controller Interface
>> Device : OpenThread_BR THCI
>> Class : OpenThread_BR
"""
import logging
import re
import sys
import time
import ipaddress

import serial
from IThci import IThci
from THCI.OpenThread import OpenThreadTHCI, watched, API

RPI_FULL_PROMPT = 'pi@raspberrypi:~$ '
RPI_USERNAME_PROMPT = 'raspberrypi login: '
RPI_PASSWORD_PROMPT = 'Password: '
"""regex: used to split lines"""
LINESEPX = re.compile(r'\r\n|\n')

LOGX = re.compile(r'.*Under-voltage detected!')
"""regex: used to filter logging"""

assert LOGX.match('[57522.618196] Under-voltage detected! (0x00050005)')

OTBR_AGENT_SYSLOG_PATTERN = re.compile(r'raspberrypi otbr-agent\[\d+\]: (.*)')
assert OTBR_AGENT_SYSLOG_PATTERN.search(
    'Jun 23 05:21:22 raspberrypi otbr-agent[323]: =========[[THCI] direction=send | type=JOIN_FIN.req | len=039]==========]'
).group(1) == '=========[[THCI] direction=send | type=JOIN_FIN.req | len=039]==========]'

logging.getLogger('paramiko').setLevel(logging.WARNING)


class SSHHandle(object):
    # Unit: second
    KEEPALIVE_INTERVAL = 30

    def __init__(self, ip, port, username, password):
        self.ip = ip
        self.port = int(port)
        self.username = username
        self.password = password
        self.__handle = None

        self.__connect()

    def __connect(self):
        import paramiko

        self.close()

        self.__handle = paramiko.SSHClient()
        self.__handle.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        try:
            self.__handle.connect(self.ip, port=self.port, username=self.username, password=self.password)
        except paramiko.ssh_exception.AuthenticationException:
            if not self.password:
                self.__handle.get_transport().auth_none(self.username)
            else:
                raise

        # Avoid SSH disconnection after idle for a long time
        self.__handle.get_transport().set_keepalive(self.KEEPALIVE_INTERVAL)

    def close(self):
        if self.__handle is not None:
            self.__handle.close()
            self.__handle = None

    def bash(self, cmd, timeout):
        from paramiko import SSHException
        retry = 3
        for i in range(retry):
            try:
                stdin, stdout, stderr = self.__handle.exec_command(cmd, timeout=timeout)

                sys.stderr.write(stderr.read())
                output = [r.encode('utf8').rstrip('\r\n') for r in stdout.readlines()]
                return output

            except Exception:
                if i < retry - 1:
                    print('SSH connection is lost, try reconnect after 1 second.')
                    time.sleep(1)
                    self.__connect()
                else:
                    raise

    def log(self, fmt, *args):
        try:
            msg = fmt % args
            print('%s - %s - %s' % (self.port, time.strftime('%b %d %H:%M:%S'), msg))
        except Exception:
            pass


class SerialHandle:

    def __init__(self, port, baudrate):
        self.port = port
        self.__handle = serial.Serial(port, baudrate, timeout=0)

        self.__lines = ['']
        assert len(self.__lines) >= 1, self.__lines

        self.log("inputing username ...")
        self.__bashWriteLine('pi')
        deadline = time.time() + 20
        loginOk = False
        while time.time() < deadline:
            time.sleep(1)

            lastLine = None
            while True:
                line = self.__bashReadLine(timeout=1)

                if not line:
                    break

                lastLine = line

            if lastLine == RPI_FULL_PROMPT:
                self.log("prompt found, login success!")
                loginOk = True
                break

            if lastLine == RPI_PASSWORD_PROMPT:
                self.log("inputing password ...")
                self.__bashWriteLine('raspberry')
            elif lastLine == RPI_USERNAME_PROMPT:
                self.log("inputing username ...")
                self.__bashWriteLine('pi')
            elif not lastLine:
                self.log("inputing username ...")
                self.__bashWriteLine('pi')

        if not loginOk:
            raise Exception('login fail')

        self.bash('stty cols 256')

    def log(self, fmt, *args):
        try:
            msg = fmt % args
            print('%s - %s - %s' % (self.port, time.strftime('%b %d %H:%M:%S'), msg))
        except Exception:
            pass

    def close(self):
        self.__handle.close()

    def bash(self, cmd, timeout=10):
        """
        Execute the command in bash.
        """
        self.__bashClearLines()
        self.__bashWriteLine(cmd)
        self.__bashExpect(cmd, timeout=timeout, endswith=True)

        response = []

        deadline = time.time() + timeout
        while time.time() < deadline:
            line = self.__bashReadLine()
            if line is None:
                time.sleep(0.01)
                continue

            if line == RPI_FULL_PROMPT:
                # return response lines without prompt
                return response

            response.append(line)

        self.__bashWrite('\x03')
        raise Exception('%s: failed to find end of response' % self.port)

    def __bashExpect(self, expected, timeout=20, endswith=False):
        self.log('Expecting [%r]' % (expected))

        deadline = time.time() + timeout
        while time.time() < deadline:
            line = self.__bashReadLine()
            if line is None:
                time.sleep(0.01)
                continue

            print('[%s] Got line [%r]' % (self.port, line))

            if endswith:
                matched = line.endswith(expected)
            else:
                matched = line == expected

            if matched:
                print('[%s] Expected [%r]' % (self.port, expected))
                return

        # failed to find the expected string
        # send Ctrl+C to terminal
        self.__bashWrite('\x03')
        raise Exception('failed to find expected string[%s]' % expected)

    def __bashRead(self, timeout=1):
        deadline = time.time() + timeout
        data = ''
        while True:
            piece = self.__handle.read()
            data = data + piece.decode('utf8')
            if piece:
                continue

            if data or time.time() >= deadline:
                break

        if data:
            self.log('>>> %r', data)

        return data

    def __bashReadLine(self, timeout=1):
        line = self.__bashGetNextLine()
        if line is not None:
            return line

        assert len(self.__lines) == 1, self.__lines
        tail = self.__lines.pop()

        try:
            tail += self.__bashRead(timeout=timeout)
            tail = tail.replace(RPI_FULL_PROMPT, RPI_FULL_PROMPT + '\r\n')
            tail = tail.replace(RPI_USERNAME_PROMPT, RPI_USERNAME_PROMPT + '\r\n')
            tail = tail.replace(RPI_PASSWORD_PROMPT, RPI_PASSWORD_PROMPT + '\r\n')
        finally:
            self.__lines += [l.rstrip('\r') for l in LINESEPX.split(tail)]
            assert len(self.__lines) >= 1, self.__lines

        return self.__bashGetNextLine()

    def __bashGetNextLine(self):
        assert len(self.__lines) >= 1, self.__lines
        while len(self.__lines) > 1:
            line = self.__lines.pop(0)
            assert len(self.__lines) >= 1, self.__lines
            if LOGX.match(line):
                logging.info('LOG: %s', line)
                continue
            else:
                return line
        assert len(self.__lines) >= 1, self.__lines
        return None

    def __bashWrite(self, data):
        self.__handle.write(data)
        self.log("<<< %r", data)

    def __bashClearLines(self):
        assert len(self.__lines) >= 1, self.__lines
        while self.__bashReadLine(timeout=0) is not None:
            pass
        assert len(self.__lines) >= 1, self.__lines

    def __bashWriteLine(self, line):
        self.__bashWrite(line + '\n')


class OpenThread_BR(OpenThreadTHCI, IThci):
    DEFAULT_COMMAND_TIMEOUT = 20

    IsBorderRouter = True
    __is_root = False

    def _getHandle(self):
        if self.connectType == 'ip':
            return SSHHandle(self.telnetIp, self.telnetPort, self.telnetUsername, self.telnetPassword)
        else:
            return SerialHandle(self.port, 115200)

    def _connect(self):
        self.log("logging in to Raspberry Pi ...")
        self.__cli_output_lines = []
        self.__syslog_skip_lines = None
        self.__syslog_last_read_ts = 0

        self.__handle = self._getHandle()
        if self.connectType == 'ip':
            self.__is_root = self.telnetUsername == 'root'

    def _disconnect(self):
        if self.__handle:
            self.__handle.close()
            self.__handle = None

    def _deviceBeforeReset(self):
        if self.isPowerDown:
            self.log('Powering up the device')
            self.powerUp()
        if self.IsHost:
            self.__stopRadvdService()
            self.bash('ip -6 addr del 910b::1 dev %s || true' % self.backboneNetif)
            self.bash('ip -6 addr del fd00:7d03:7d03:7d03::1 dev %s || true' % self.backboneNetif)

        self.stopListeningToAddrAll()

    def _deviceAfterReset(self):
        self.__dumpSyslog()
        self.__truncateSyslog()
        self.__enableAcceptRa()
        if not self.IsHost:
            self._restartAgentService()
            time.sleep(2)

    def __enableAcceptRa(self):
        self.bash('sysctl net.ipv6.conf.%s.accept_ra=2' % self.backboneNetif)

    def _beforeRegisterMulticast(self, sAddr='ff04::1234:777a:1', timeout=300):
        """subscribe to the given ipv6 address (sAddr) in interface and send MLR.req OTA

        Args:
            sAddr   : str : Multicast address to be subscribed and notified OTA.
        """

        if self.externalCommissioner is not None:
            self.externalCommissioner.MLR([sAddr], timeout)
            return True

        cmd = 'nohup ~/repo/openthread/tests/scripts/thread-cert/mcast6.py wpan0 %s' % sAddr
        cmd = cmd + ' > /dev/null 2>&1 &'
        self.bash(cmd)

    @API
    def setupHost(self, setDp=False, setDua=False):
        self.IsHost = True

        self.bash('ip -6 addr add 910b::1 dev %s' % self.backboneNetif)

        if setDua:
            self.bash('ip -6 addr add fd00:7d03:7d03:7d03::1 dev %s' % self.backboneNetif)

        self.__startRadvdService(setDp)

    def _deviceEscapeEscapable(self, string):
        """Escape CLI escapable characters in the given string.

        Args:
            string (str): UTF-8 input string.

        Returns:
            [str]: The modified string with escaped characters.
        """
        return '"' + string + '"'

    @watched
    def bash(self, cmd, timeout=DEFAULT_COMMAND_TIMEOUT, sudo=True):
        return self.bash_unwatched(cmd, timeout=timeout, sudo=sudo)

    def bash_unwatched(self, cmd, timeout=DEFAULT_COMMAND_TIMEOUT, sudo=True):
        if sudo and not self.__is_root:
            cmd = 'sudo ' + cmd

        return self.__handle.bash(cmd, timeout=timeout)

    # Override send_udp
    @API
    def send_udp(self, interface, dst, port, payload):
        if interface == 0:  # Thread Interface
            super(OpenThread_BR, self).send_udp(interface, dst, port, payload)
            return

        if interface == 1:
            ifname = self.backboneNetif
        else:
            raise AssertionError('Invalid interface set to send UDP: {} '
                                 'Available interface options: 0 - Thread; 1 - Ethernet'.format(interface))
        cmd = '/home/pi/reference-device/send_udp.py %s %s %s %s' % (ifname, dst, port, payload)
        self.bash(cmd)

    @API
    def mldv2_query(self):
        ifname = self.backboneNetif
        dst = 'ff02::1'

        cmd = '/home/pi/reference-device/send_mld_query.py %s %s' % (ifname, dst)
        self.bash(cmd)

    @API
    def ip_neighbors_flush(self):
        # clear neigh cache on linux
        cmd1 = 'sudo ip -6 neigh flush nud all nud failed nud noarp dev %s' % self.backboneNetif
        cmd2 = ('sudo ip -6 neigh list nud all dev %s '
                '| cut -d " " -f1 '
                '| sudo xargs -I{} ip -6 neigh delete {} dev %s') % (self.backboneNetif, self.backboneNetif)
        cmd = '%s ; %s' % (cmd1, cmd2)
        self.bash(cmd, sudo=False)

    @API
    def ip_neighbors_add(self, addr, lladdr, nud='noarp'):
        cmd1 = 'sudo ip -6 neigh delete %s dev %s' % (addr, self.backboneNetif)
        cmd2 = 'sudo ip -6 neigh add %s dev %s lladdr %s nud %s' % (addr, self.backboneNetif, lladdr, nud)
        cmd = '%s ; %s' % (cmd1, cmd2)
        self.bash(cmd, sudo=False)

    @API
    def get_eth_ll(self):
        cmd = "ip -6 addr list dev %s | grep 'inet6 fe80' | awk '{print $2}'" % self.backboneNetif
        ret = self.bash(cmd)[0].split('/')[0]
        return ret

    @API
    def ping(self, strDestination, ilength=0, hop_limit=5, timeout=5):
        """ send ICMPv6 echo request with a given length to a unicast destination
            address

        Args:
            strDestination: the unicast destination address of ICMPv6 echo request
            ilength: the size of ICMPv6 echo request payload
            hop_limit: the hop limit
            timeout: time before ping() stops
        """
        if hop_limit is None:
            hop_limit = 5

        if self.IsHost or self.IsBorderRouter:
            ifName = self.backboneNetif
        else:
            ifName = 'wpan0'

        cmd = 'ping -6 -I %s %s -c 1 -s %d -W %d -t %d' % (
            ifName,
            strDestination,
            int(ilength),
            int(timeout),
            int(hop_limit),
        )

        self.bash(cmd, sudo=False)
        time.sleep(timeout)

    def multicast_Ping(self, destination, length=20):
        """send ICMPv6 echo request with a given length to a multicast destination
           address

        Args:
            destination: the multicast destination address of ICMPv6 echo request
            length: the size of ICMPv6 echo request payload
        """
        hop_limit = 5

        if self.IsHost or self.IsBorderRouter:
            ifName = self.backboneNetif
        else:
            ifName = 'wpan0'

        cmd = 'ping -6 -I %s %s -c 1 -s %d -t %d' % (ifName, destination, str(length), hop_limit)

        self.bash(cmd, sudo=False)

    @API
    def getGUA(self, filterByPrefix=None, eth=False):
        """get expected global unicast IPv6 address of Thread device

        note: existing filterByPrefix are string of in lowercase. e.g.
        '2001' or '2001:0db8:0001:0000".

        Args:
            filterByPrefix: a given expected global IPv6 prefix to be matched

        Returns:
            a global IPv6 address
        """
        # get global addrs set if multiple
        if eth:
            return self.__getEthGUA(filterByPrefix=filterByPrefix)
        else:
            return super(OpenThread_BR, self).getGUA(filterByPrefix=filterByPrefix)

    def __getEthGUA(self, filterByPrefix=None):
        globalAddrs = []

        cmd = 'ip -6 addr list dev %s | grep inet6' % self.backboneNetif
        output = self.bash(cmd, sudo=False)
        for line in output:
            # example: inet6 2401:fa00:41:23:274a:1329:3ab9:d953/64 scope global dynamic noprefixroute
            line = line.strip().split()

            if len(line) < 4 or line[2] != 'scope':
                continue

            if line[3] != 'global':
                continue

            addr = line[1].split('/')[0]
            addr = str(ipaddress.IPv6Address(addr.decode()).exploded)
            globalAddrs.append(addr)

        if not filterByPrefix:
            return globalAddrs[0]
        else:
            if filterByPrefix[-2:] != '::':
                filterByPrefix = '%s::' % filterByPrefix
            prefix = ipaddress.IPv6Network((filterByPrefix + '/64').decode())
            for fullIp in globalAddrs:
                address = ipaddress.IPv6Address(fullIp.decode())
                if address in prefix:
                    return fullIp

    def _cliReadLine(self):
        # read commissioning log if it's commissioning
        if not self.__cli_output_lines:
            self.__readSyslogToCli()

        if self.__cli_output_lines:
            return self.__cli_output_lines.pop(0)

        return None

    @watched
    def _deviceGetEtherMac(self):
        # Harness wants it in string. Because wireshark filter for eth
        # cannot be applies in hex
        return self.bash('ip addr list dev %s | grep ether' % self.backboneNetif, sudo=False)[0].strip().split()[1]

    @watched
    def _onCommissionStart(self):
        assert self.__syslog_skip_lines is None
        self.__syslog_skip_lines = int(self.bash('wc -l /var/log/syslog', sudo=False)[0].split()[0])
        self.__syslog_last_read_ts = 0

    @watched
    def _onCommissionStop(self):
        assert self.__syslog_skip_lines is not None
        self.__syslog_skip_lines = None

    @watched
    def __startRadvdService(self, setDp=False):
        assert self.IsHost, "radvd service runs on Host only"

        conf = "EOF"
        conf += "\ninterface %s" % self.backboneNetif
        conf += "\n{"
        conf += "\n    AdvSendAdvert on;"
        conf += "\n"
        conf += "\n    MinRtrAdvInterval 3;"
        conf += "\n    MaxRtrAdvInterval 30;"
        conf += "\n    AdvDefaultPreference low;"
        conf += "\n"
        conf += "\n    prefix 910b::/64"
        conf += "\n    {"
        conf += "\n        AdvOnLink on;"
        conf += "\n        AdvAutonomous on;"
        conf += "\n        AdvRouterAddr on;"
        conf += "\n    };"
        if setDp:
            conf += "\n"
            conf += "\n    prefix fd00:7d03:7d03:7d03::/64"
            conf += "\n    {"
            conf += "\n        AdvOnLink on;"
            conf += "\n        AdvAutonomous off;"
            conf += "\n        AdvRouterAddr off;"
            conf += "\n    };"
        conf += "\n};"
        conf += "\nEOF"
        cmd = 'sh -c "cat >/etc/radvd.conf <<%s"' % conf

        self.bash(cmd)
        self.bash(self.extraParams.get('cmd-restart-radvd', 'service radvd restart'))
        self.bash('service radvd status')

    @watched
    def __stopRadvdService(self):
        assert self.IsHost, "radvd service runs on Host only"
        self.bash('service radvd stop')

    def __readSyslogToCli(self):
        if self.__syslog_skip_lines is None:
            return 0

        # read syslog once per second
        if time.time() < self.__syslog_last_read_ts + 1:
            return 0

        self.__syslog_last_read_ts = time.time()

        lines = self.bash_unwatched('tail +%d /var/log/syslog' % self.__syslog_skip_lines, sudo=False)
        for line in lines:
            m = OTBR_AGENT_SYSLOG_PATTERN.search(line)
            if not m:
                continue

            self.__cli_output_lines.append(m.group(1))

        self.__syslog_skip_lines += len(lines)
        return len(lines)

    def _cliWriteLine(self, line):
        cmd = 'ot-ctl -- %s' % line
        output = self.bash(cmd)
        # fake the line echo back
        self.__cli_output_lines.append(line)
        for line in output:
            self.__cli_output_lines.append(line)

    def _restartAgentService(self):
        restart_cmd = self.extraParams.get('cmd-restart-otbr-agent', 'systemctl restart otbr-agent')
        self.bash(restart_cmd)

    def __truncateSyslog(self):
        self.bash('truncate -s 0 /var/log/syslog')

    def __dumpSyslog(self):
        cmd = self.extraParams.get('cmd-dump-otbr-log', 'grep "otbr-agent" /var/log/syslog')
        output = self.bash_unwatched(cmd)
        for line in output:
            self.log('%s', line)

    @API
    def get_eth_addrs(self):
        cmd = "ip -6 addr list dev %s | grep 'inet6 ' | awk '{print $2}'" % self.backboneNetif
        addrs = self.bash(cmd)
        return [addr.split('/')[0] for addr in addrs]

    @API
    def mdns_query(self, service='_meshcop._udp.local', addrs_allowlist=(), addrs_denylist=()):
        try:
            for deny_addr in addrs_denylist:
                self.bash('ip6tables -A INPUT -p udp --dport 5353 -s %s -j DROP' % deny_addr)

            if addrs_allowlist:
                for allow_addr in addrs_allowlist:
                    self.bash('ip6tables -A INPUT -p udp --dport 5353 -s %s -j ACCEPT' % allow_addr)

                self.bash('ip6tables -A INPUT -p udp --dport 5353 -j DROP')

            return self._mdns_query_impl(service, find_active=(addrs_allowlist or addrs_denylist))

        finally:
            self.bash('ip6tables -F INPUT')
            time.sleep(1)

    def _mdns_query_impl(self, service, find_active):
        # For BBR-TC-03 or DH test cases (empty arguments) just send a query
        output = self.bash('python3 ~/repo/openthread/tests/scripts/thread-cert/find_border_agents.py')

        if not find_active:
            return

        # For MATN-TC-17 and MATN-TC-18 use Zeroconf to get the BBR address and border agent port
        for line in output:
            print(line)
            alias, addr, port, thread_status = eval(line)
            if thread_status == 2 and addr:
                if ipaddress.IPv6Address(addr.decode()).is_link_local:
                    addr = '%s%%%s' % (addr, self.backboneNetif)
                return addr, port

        raise Exception('No active Border Agents found')

    # Override powerDown
    @API
    def powerDown(self):
        self.log('Powering down BBR')
        super(OpenThread_BR, self).powerDown()
        stop_cmd = self.extraParams.get('cmd-stop-otbr-agent', 'systemctl stop otbr-agent')
        self.bash(stop_cmd)

    # Override powerUp
    @API
    def powerUp(self):
        self.log('Powering up BBR')
        start_cmd = self.extraParams.get('cmd-start-otbr-agent', 'systemctl start otbr-agent')
        self.bash(start_cmd)
        super(OpenThread_BR, self).powerUp()

    # Override forceSetSlaac
    @API
    def forceSetSlaac(self, slaacAddress):
        self.bash('ip -6 addr add %s/64 dev wpan0' % slaacAddress)

    # Override stopListeningToAddr
    @API
    def stopListeningToAddr(self, sAddr):
        """
        Unsubscribe to a given IPv6 address which was subscribed earlier with `registerMulticast`.

        Args:
            sAddr   : str : Multicast address to be unsubscribed. Use an empty string to unsubscribe
                            all the active multicast addresses.
        """
        cmd = 'pkill -f mcast6.*%s' % sAddr
        self.bash(cmd)

    def stopListeningToAddrAll(self):
        return self.stopListeningToAddr('')

    @API
    def deregisterMulticast(self, sAddr):
        """
        Unsubscribe to a given IPv6 address.
        Only used by External Commissioner.

        Args:
            sAddr   : str : Multicast address to be unsubscribed.
        """
        self.externalCommissioner.MLR([sAddr], 0)
        return True

    @watched
    def _waitBorderRoutingStabilize(self):
        """
        Wait for Network Data to stabilize if BORDER_ROUTING is enabled.
        """
        if not self.isBorderRoutingEnabled():
            return

        MAX_TIMEOUT = 30
        MIN_TIMEOUT = 15
        CHECK_INTERVAL = 3

        time.sleep(MIN_TIMEOUT)

        lastNetData = self.getNetworkData()
        for i in range((MAX_TIMEOUT - MIN_TIMEOUT) // CHECK_INTERVAL):
            time.sleep(CHECK_INTERVAL)
            curNetData = self.getNetworkData()

            # Wait until the Network Data is not changing, and there is OMR Prefix and External Routes available
            if curNetData == lastNetData and len(curNetData['Prefixes']) > 0 and len(curNetData['Routes']) > 0:
                break

            lastNetData = curNetData

        return lastNetData