#
# CORE
# Copyright (c)2011-2014 the Boeing Company.
# See the LICENSE file included in this distribution.
#
# authors: Tom Goff <thomas.goff@boeing.com>
#          Jeff Ahrenholz <jeffrey.m.ahrenholz@boeing.com>
#
'''
vif.py: PyCoreNetIf classes that implement the interfaces available
under Linux.
'''

import os, signal, shutil, sys, subprocess, vnodeclient, threading, string
import random, time
from core.api import coreapi
from core.misc.utils import *
from core.constants import *
from core.coreobj import PyCoreObj, PyCoreNode, PyCoreNetIf, Position
from core.emane.nodes import EmaneNode

checkexec([IP_BIN])

class VEth(PyCoreNetIf):
    def __init__(self, node, name, localname, mtu = 1500, net = None,
                 start = True):
        # note that net arg is ignored
        PyCoreNetIf.__init__(self, node = node, name = name, mtu = mtu)
        self.localname = localname
        self.up = False
        if start:
            self.startup()

    def startup(self):
        check_call([IP_BIN, "link", "add", "name", self.localname,
                    "type", "veth", "peer", "name", self.name])
        check_call([IP_BIN, "link", "set", self.localname, "up"])
        self.up = True

    def shutdown(self):
        if not self.up:
            return
        if self.node:
            self.node.cmd([IP_BIN, "-6", "addr", "flush", "dev", self.name])
        if self.localname:
            mutedetach([IP_BIN, "link", "delete", self.localname])
        self.up = False


class TunTap(PyCoreNetIf):
    ''' TUN/TAP virtual device in TAP mode
    '''
    def __init__(self, node, name, localname, mtu = 1500, net = None,
                 start = True):
        PyCoreNetIf.__init__(self, node = node, name = name, mtu = mtu)
        self.localname = localname
        self.up = False
        self.transport_type = "virtual"
        if start:
            self.startup()

    def startup(self):
        # TODO: more sophisticated TAP creation here
        #   Debian does not support -p (tap) option, RedHat does.
        # For now, this is disabled to allow the TAP to be created by another 
        # system (e.g. EMANE's emanetransportd)
        #check_call(["tunctl", "-t", self.name])
        # self.install()
        self.up = True

    def shutdown(self):
        if not self.up:
            return
        self.node.cmd([IP_BIN, "-6", "addr", "flush", "dev", self.name])
        #if self.name:
        #    mutedetach(["tunctl", "-d", self.localname])
        self.up = False

    def install(self):
        ''' Install this TAP into its namespace. This is not done from the
            startup() method but called at a later time when a userspace
            program (running on the host) has had a chance to open the socket
            end of the TAP.
        '''
        netns = str(self.node.pid)
        # check for presence of device - tap device may not appear right away
        # waits ~= stime * ( 2 ** attempts) seconds 
        attempts = 9
        stime = 0.01
        while attempts > 0:
            try:
                mutecheck_call([IP_BIN, "link", "show", self.localname])
                break
            except Exception, e:
                msg = "ip link show %s error (%d): %s" % \
                        (self.localname, attempts, e)
                if attempts > 1:
                    msg += ", retrying..."
                self.node.info(msg)
            time.sleep(stime)
            stime *= 2
            attempts -= 1
        # install tap device into namespace
        try:
            check_call([IP_BIN, "link", "set", self.localname, "netns", netns])
        except Exception, e:
            msg = "error installing TAP interface %s, command:" % self.localname
            msg += "ip link set %s netns %s" % (self.localname, netns)
            self.node.exception(coreapi.CORE_EXCP_LEVEL_ERROR, self.localname, msg)
            self.node.warn(msg)
            return
        self.node.cmd([IP_BIN, "link", "set", self.localname,
                       "name", self.name])
        self.node.cmd([IP_BIN, "link", "set", self.name,  "up"])
        
    def setaddrs(self):
        ''' Set interface addresses based on self.addrlist.
        '''
        for addr in self.addrlist:
            self.node.cmd([IP_BIN, "addr", "add", str(addr),
                  "dev", self.name])

class GreTap(PyCoreNetIf):
    ''' GRE TAP device for tunneling between emulation servers.
        Uses the "gretap" tunnel device type from Linux which is a GRE device
        having a MAC address. The MAC address is required for bridging.
    '''
    def __init__(self, node = None, name = None, session = None, mtu = 1458,
                 remoteip = None, objid = None, localip = None, ttl = 255,
                 key = None, start = True):
        PyCoreNetIf.__init__(self, node = node, name = name, mtu = mtu)
        self.session = session
        if objid is None:
            # from PyCoreObj
            objid = (((id(self) >> 16) ^ (id(self) & 0xffff)) & 0xffff)
        self.objid = objid
        sessionid = self.session.shortsessionid()
        # interface name on the local host machine
        self.localname = "gt.%s.%s" % (self.objid, sessionid)
        self.transport_type = "raw"
        if not start:
            self.up = False
            return
        
        if remoteip is None:
            raise ValueError, "missing remote IP required for GRE TAP device"
        cmd = ("ip", "link", "add", self.localname, "type", "gretap",
               "remote", str(remoteip))
        if localip:
            cmd += ("local", str(localip))
        if ttl:
            cmd += ("ttl", str(ttl))
        if key:
            cmd += ("key", str(key))
        check_call(cmd)
        cmd = ("ip", "link", "set", self.localname, "up")
        check_call(cmd)
        self.up = True

    def shutdown(self):
        if self.localname:
            cmd = ("ip", "link", "set", self.localname, "down")
            check_call(cmd)
            cmd = ("ip", "link", "del", self.localname)
            check_call(cmd)
            self.localname = None
    
    def tonodemsg(self, flags):
        return None
        
    def tolinkmsgs(self, flags):
        return []