#
# Copyright 2005-2013 the Boeing Company.
# See the LICENSE file included in this distribution.
#

# shows the Two-node Tool
proc popupTwoNodeDialog { } {
    global twonodePID lastTwoNodeHop g_twoNodeSelect g_twoNodeSelectCallback
    
    markerOptions off
    set wi .twonodetool
    catch {destroy $wi}
    toplevel $wi

    wm transient $wi .
    wm resizable $wi 200 300
    wm title $wi "Two-node Tool"

    set twonodePID 0
    set lastTwoNodeHop ""
    set g_twoNodeSelect ""
    set g_twoNodeSelectCallback selectTwoNode_twonodetool

    global twoNode1 twoNode2
    frame $wi.e
    labelframe $wi.e.nodes -text "Nodes" -padx 4 -pady 4
    label $wi.e.nodes.srcl -text "source node"
    label $wi.e.nodes.dstl -text "destination node"
    radiobutton $wi.e.nodes.src -text " (none) " -variable g_twoNodeSelect \
	-value "$wi.e.nodes.src" -indicatoron off -activebackground green \
	-selectcolor green -padx 4 -pady 4
    radiobutton $wi.e.nodes.dst -text " (none) " -variable g_twoNodeSelect \
	-value "$wi.e.nodes.dst" -indicatoron off -activebackground red \
	-selectcolor red -padx 4 -pady 4
    label $wi.e.nodes.help -text "click to select nodes"
    pack $wi.e.nodes.srcl $wi.e.nodes.src $wi.e.nodes.dstl $wi.e.nodes.dst \
	-side left
    pack $wi.e.nodes.help -side left -padx 4 -pady 4
    pack $wi.e.nodes $wi.e -side top -fill x


    labelframe $wi.cmd -text "Command line"
    global twoNodeTool
    set twoNodeTool "traceroute"
    radiobutton $wi.cmd.trace -text "traceroute" -variable twoNodeTool \
	-value traceroute -command selectTwoNode_twonodetool
    radiobutton $wi.cmd.ping -text "ping" -variable twoNodeTool \
	-value ping -command selectTwoNode_twonodetool
    entry $wi.cmd.cmd -bg white -width 50
    pack $wi.cmd.trace $wi.cmd.ping $wi.cmd.cmd -side left -padx 4 -pady 4
    pack $wi.cmd -side top -fill x

    # results text box
    labelframe $wi.results -text "Command results"
    text $wi.results.text -bg white -width 80 -height 10 \
	-yscrollcommand "$wi.results.scroll set"
    scrollbar $wi.results.scroll -command "$wi.results.text yview"
    pack $wi.results.text -side left -fill both -expand true -padx 4 -pady 4
    pack $wi.results.scroll -side left -fill y -expand true -padx 4 -pady 4
    pack $wi.results -side top -expand true -fill both

    # buttons on the bottom
    frame $wi.butt -borderwidth 6
    button $wi.butt.run -text "Run" -command "runTwoNodeCommand $wi" 
    button $wi.butt.cancel -text "Clear" -command "clearTwoNodeDialog $wi 0"
    button $wi.butt.close -text "Close" -command "clearTwoNodeDialog $wi 1"
    pack $wi.butt.run $wi.butt.cancel $wi.butt.close -side left
    pack $wi.butt -side bottom
}

#
# reset the Two Node Tool window
proc clearTwoNodeDialog { wi done} {
    global eid activetool twonodePID lastTwoNodeHop systype

    $wi.results.text delete 1.0 end
    clearLinkHighlights
    set lastTwoNodeHop ""
    set node [string trim [$wi.e.nodes.src cget -text]]

    if { $twonodePID > 0 } {
	set os [lindex $systype 0]
	set emul [getEmulPlugin $node]
	set emulation_type [lindex $emul 1]
	    catch {
		if { $os == "FreeBSD" } {
		    exec sudo kill -9 $twonodePID 2> /dev/null
		} else {
		    exec kill -9 $twonodePID 2> /dev/null
		}
	    }
	set twonodePID 0
    }

    if {$done} { ;# close Two Node window
	set activetool select
	.c delete withtag "twonode"
	destroy $wi
    }
}

#
# called from editor.tcl:button1 when user clicks on a node
# g_twoNodeSelect is the global variable of the radio button, whose value is
#  set to the name of the button control to modify
proc selectTwoNode { node } {
    global activetool g_twoNodeSelect g_twoNodeSelectCallback

    if { ![winfo exists $g_twoNodeSelect] } { return }; # user has closed window

    set radius 30
    set color red
    catch {
	# works for radiobutton, but not ttk::checkbutton
        set color [$g_twoNodeSelect cget -selectcolor]
    }
    set deltags "twonode && twonode$g_twoNodeSelect"
    set tags "twonode $node twonode$g_twoNodeSelect"
    $g_twoNodeSelect configure -text " $node "
    drawNodeCircle $node $radius $color $tags $deltags

    eval $g_twoNodeSelectCallback
    set g_twoNodeSelect ""
    set activetool select; # allow moving nodes now
}

# draw a circle around a node
proc drawNodeCircle { node radius color tags deltags } {
    set c .c
    if { $deltags != "" } { $c delete withtag $deltags }
    if { $node == "" } { return }

    set coords [getNodeCoords $node]
    set x [lindex $coords 0]
    set y [lindex $coords 1]
    set x1 [expr {$x-$radius}]; set x2 [expr {$x+$radius}];
    set y1 [expr {$y-$radius}]; set y2 [expr {$y+$radius}];

    $c create oval $x1 $y1 $x2 $y2 -width 5 -outline $color -tags $tags
}

#
# generate a command line string for the two-node tool
# called when tool or either node is selected
proc selectTwoNode_twonodetool { } {
    global eid twoNodeTool
    set wi .twonodetool

    if { ![winfo exists $wi] } { return }; # user has closed window

    # get the tool and its options
    set tool $twoNodeTool
    set opts ""
    if {$twoNodeTool == "traceroute"} {
	set opts "-n -t 0"
    } elseif {$twoNodeTool == "ping"} {
	set opts "-R -n"
    }

    # get source node and destination ip address, if possible
    set src [string trim [$wi.e.nodes.src cget -text]]
    set dst "(none)"
    set node2 [string trim [$wi.e.nodes.dst cget -text]]
    if {$src != "(none)" && $node2 != "(none)"} {
        set dst [getDestinationAddress $src $node2]
    } else {
        $wi.cmd.cmd delete 0 end
	return
    }

    # erase existing command (edits are lost) and insert a new one
    global systype
    set os [lindex $systype 0]
    set emul [getEmulPlugin $src]
    set emulation_type [lindex $emul 1]
    if { $os == "Linux" } {
	if { $emulation_type == "openvz" } {
	    set node_id [string range $src 1 end]
	    incr node_id 1000
	    set cmd "/usr/sbin/vzctl exec $node_id $tool $opts $dst"
	    $wi.cmd.cmd delete 0 end
	    $wi.cmd.cmd insert 0 $cmd
	    return
	}
    }
    set cmd "$tool $opts $dst"
    set sock [lindex $emul 2]
    set flags 0x44;# set TTY, critical flags
    set exec_num [newExecCallbackRequest twonode]
    sendExecMessage $sock $src $cmd $exec_num $flags
}

#
# return an IP address for node2; if node1 is directly connected, return the
# address on that subnet, otherwise pick the first interface address
proc getDestinationAddress { node1 node2 } {
    set ifc ""
    if {$node1 != "" && $node2 != ""} {
        set ifc [ifcByPeer $node2 $node1]; # node2 directly connected to node1?
    }
    if {$ifc == ""} {;# node not directly connected, pick first interface
        set ifc [lindex [ifcList $node2] 0]
    }
    if { $node2 == "" } { return "" }
    return "[lindex [split [getIfcIPv4addr $node2 $ifc] /] 0]"
}

#
# callback when exec response is received
proc exec_twonode_callback { node execnum execcmd execres execstatus } {
    set wi .twonodetool
    if { ![winfo exists $wi] } { return }

    set i [string first "&&" $execres]
    if { $i >= 0 } {
	incr i 3
	set execres [string range $execres $i end]
    }
    $wi.cmd.cmd delete 0 end
    $wi.cmd.cmd insert 0 $execres
}

#
# run the command from the Two Node Tool window
proc runTwoNodeCommand { wi } {
    global twoNodeTool node_list
    set c .c

    if { ![winfo exists $wi] } { return }; # user has closed window

    clearTwoNodeDialog $wi 0; # clean up any previous processes

    set node [string trim [$wi.e.nodes.src cget -text]]
    if { [lsearch $node_list $node] < 0 } { return }
    set cmd [$wi.cmd.cmd get]
    set tool $twoNodeTool

    # de-select
    $c dtag node selected
    $c delete -withtags selectmark

    $wi.results.text delete 1.0 end
    $wi.results.text insert end "$cmd\n"
    $wi.results.text see end

    after 100 doTwoNode $tool $node \"$cmd\"
}

#
# dipatch command remotely or to fileevent handler
proc doTwoNode { tool node cmd } {
    global eid twonodePID exec_servers lastTwoNodeHop
    set wi .twonodetool

    set lastTwoNodeHop $node

    if { $cmd == "" } { return }

    # local execution - uses file event handler
    set fileId [open "|$cmd" r]
    fconfigure $fileId -buffering line
    set twonodePID [pid $fileId]
    fileevent $fileId readable [list readTwoNodeStream $node $fileId $tool]
}

#
# event handler for Two Node command pipe
proc readTwoNodeStream { node fileId tool } {
    fileevent $fileId readable ""; # turn handler off
    set wi .twonodetool

    if {![winfo exists $wi]} {
	catch { close $fileId }
	return; # the window has been closed
    }
    if { ![eof $fileId] } {
        gets $fileId line
	$wi.results.text insert end "$line\n"
	$wi.results.text see end
	drawTwoNodeLine $node $line $tool
	update
	# reinstall event handler
        fileevent $fileId readable [list readTwoNodeStream $node $fileId $tool]
    } else {
	#set p [pid $fileId]
	$wi.results.text insert end "done.\n"
	$wi.results.text see end
	catch { close $fileId }
	update
    }
}

#
# parse a line of trace/ping output and highlight the next hop
proc drawTwoNodeLine { node line type } {
    global lastTwoNodeHop

    # parse the nexthop from raw input
    set nexthop ""
    if {$type == "traceroute"} {
	set tmp [string range $line 2 17]
	set nexthop [regexp -inline {[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+} $tmp]
    } elseif {$type == "ping"} {
	set first [string range $line 0 0]
	if {$first == "R"} { ;# RR: (reroute header)
	    clearLinkHighlights ;# new route will be displayed, color old one?
	    set tmp [string range $line 4 end]
	} elseif {$first == "	" } { ;# tab character
	    set tmp [string range $line 1 end]
	} else { ;# not reroute info
	    set lastTwoNodeHop $node ;# need beginning node
	    return
	}
	set nexthop [regexp -inline {[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+} $tmp]
    }
    if { $nexthop == "" } { return }; # garbage

    # search for hops matching this nexthop address
    set hops [findNextHops $lastTwoNodeHop $nexthop ""]
    if {[llength $hops] == 0} {
    	puts "Couldn't highlight next hop: $nexthop"; 
	return
    }

    # highlight the path 
    set a $lastTwoNodeHop
    foreach b $hops {
	highlightLink $a $b
	set a $b
    }
    set lastTwoNodeHop $b
}

#
# search for a peer node having the nexthop address
# lastnode parameter prevents infinite recursion
proc findNextHops { node nexthop lastnode } {
    if { $node == "" } { return "" }; # initial lastTwoNodeHop value

    foreach ifc [ifcList $node] {
	set peer [peerByIfc $node $ifc]
	if { $peer == "" } { continue }
	if { $lastnode != "" && $peer == $lastnode } { continue };# no recursion
	set peertype [nodeType $peer]
	switch $peertype {
	lanswitch  -
	hub  -
	wlan {
	    set hops [findNextHops $peer $nexthop $node]
	    if { [llength $hops] > 0 } {
		# don't include wlan in list of hops
		if {$peertype == "wlan"} { return $hops }
		# include peer in list of hops
	    	return [linsert $hops 0 $peer]
	    }
	}
	default {
	    if { [nodeHasAddr $peer $nexthop] } { return $peer }
	}
	};# end switch
    }
    return ""
}

#
# returns 1 if node has address, 0 otherwise
# (getIfcByPeer and getIfcIPv4addr are not enough, since traceroute can report
# any of the peer's addresses)
proc nodeHasAddr { node addr } {
    foreach ifc [ifcList $node] {
	set nodeaddr [lindex [split [getIfcIPv4addr $node $ifc] /] 0]
	if { $nodeaddr == $addr } {
	    return 1
	}
    }	
    return 0
}

#
# Highlight the link between two nodes
proc highlightLink { node1 node2 } {
    global link_list
    set hlink ""

    set wlanlinks [.c find withtag "wlanlink && $node1 && $node2"]
    if { $wlanlinks != "" } {
	set hlink [lindex $wlanlinks 0]
    } else {
	set links [.c find withtag "link && $node1 && $node2"]
	if { $links != "" } { set hlink [lindex $links 0] }
    }
    if  { $hlink == "" } { return }
    # don't mess with link width! labels will redraw vertically
    .c itemconfigure "$hlink" -fill "#E4CF30" -width 5
    update
}

#
# Remove highlighting from all links
proc clearLinkHighlights { } {
	global link_list defLinkColor
	foreach link $link_list {
	    set limages [.c find withtag "link && $link"]
	    set limage1 [lindex $limages 0]
	    set tags [.c gettags $limage1]
	    set lnode1 [lindex $tags 2]
	    set lnode2 [lindex $tags 3]
	    set width [getLinkWidth $link]
	    set fill [getLinkColor $link]
	    .c itemconfigure "link && $link" -fill $fill -width $width
	    .c itemconfigure "linklabel && $link" -fill black
	    if { $lnode1 != "" && $link != "" } {
		.c itemconfigure "interface && $lnode1 && $link" -fill black
	    }
	    if { $lnode2 != "" && $link != "" } {
		.c itemconfigure "interface && $lnode2 && $link" -fill black
	    }
	}
	foreach wlanlink [.c find withtag wlanlink] {
	    set tags [.c gettags $wlanlink]
	    set wlan [lindex $tags 3]
	    set color [getWlanColor $wlan]
	    .c itemconfigure "$wlanlink" -fill $color -width 2
	}
	update
}

#
# Boeing: shows the Two-node Tool
proc popupRunDialog { } {
    global node_list activetool systype
   
    set activetool select
    markerOptions off
    set wi .runtool
    catch {destroy $wi}
    toplevel $wi

    wm transient $wi .
    wm resizable $wi 200 300
    wm title $wi "Run Tool"

    global runnodelist
    set runnodelist $node_list

    labelframe $wi.n -text "Run on these nodes"
    frame $wi.n.nodes
    listbox $wi.n.nodes.nodes -width 15 -height 11 -selectmode extended \
	-exportselection 0 \
	-listvariable runnodelist -yscrollcommand "$wi.n.nodes.scroll set"
    scrollbar $wi.n.nodes.scroll -command "$wi.n.nodes.nodes yview"
    frame $wi.n.nodesel -height 5
    button $wi.n.nodesel.all -text "all" \
 	-command "$wi.n.nodes.nodes selection set 0 end"
    button $wi.n.nodesel.none -text "none" \
 	-command "$wi.n.nodes.nodes selection clear 0 end"
    pack $wi.n.nodes.nodes $wi.n.nodes.scroll -side left -fill y -padx 4 -pady 4
    pack $wi.n.nodesel.all $wi.n.nodesel.none -side left -padx 4 -pady 4
    pack $wi.n.nodes -side top -expand true -fill both
    pack $wi.n.nodesel -side bottom -fill x
    pack $wi.n -side right -fill both

    $wi.n.nodes.nodes selection set 0 end ;# select all

    labelframe $wi.cmd -text "Command line"
    entry $wi.cmd.cmd -bg white -width 50
    pack $wi.cmd.cmd -side left -padx 4 -pady 4
    pack $wi.cmd -side top -fill x

    set cmd "ps ax"
    set os [lindex $systype 0]
    # TODO: use CORE API Execute message for all cases
    if { $os == "Linux" } {
	set emulation_type [lindex [getEmulPlugin "*"] 1]
	if { $emulation_type == "openvz" } {
	    set cmd "/usr/sbin/vzctl exec NODE $cmd"
	}
    }
    $wi.cmd.cmd insert 0 $cmd

    # results text box
    labelframe $wi.results -text "Command results"
    text $wi.results.text -bg white -width 80 -height 10 \
	-yscrollcommand "$wi.results.scroll set"
    scrollbar $wi.results.scroll -command "$wi.results.text yview"
    pack $wi.results.text -side left -fill both -expand true -padx 4 -pady 4
    pack $wi.results.scroll -side left -fill y 	-padx 4 -pady 4
    pack $wi.results -side top -expand true -fill both

    # buttons on the bottom
    frame $wi.butt -borderwidth 6
    button $wi.butt.run -text "Run" -command "runToolCommand $wi \"\"" 
    button $wi.butt.close -text "Close" -command "destroy $wi"
    pack $wi.butt.run $wi.butt.close -side left
    pack $wi.butt -side bottom
}

#
# run the command from the Run Tool window
proc runToolCommand { wi node } {
    global node_list eid systype
    set c .c

    if { ![winfo exists $wi] } { return }; # user has closed window

    # start running commands
    if { $node == "" } { 
	$wi.results.text delete 1.0 end
	set selected [$wi.n.nodes.nodes curselection]
	if { [llength $selected] == 0 } {
	    $wi.results.text insert end "No nodes are selected. Highlight one or more nodes on the right and try again."
	    return
	}
	set node [lindex $node_list [lindex $selected 0]]
	after 100 runToolCommand $wi $node; # callback for starting node
	return
    }

    set next ""
    set getnext 0
    foreach i [$wi.n.nodes.nodes curselection] { ;# find the next node 
        set n [lindex $node_list $i] 
	if {$n == $node } {
	    set getnext 1
	} elseif { $getnext == 1 } {
	    # only run commands on router/pc/host nodes
	    if {[lsearch {router pc host} [nodeType $n]] < 0} { continue }
	    set next $n
	    break
	}
    }

    # build the command (replace NODE with node name)
    set cmd [$wi.cmd.cmd get]
    set i [string first "NODE" $cmd]
    set os [lindex $systype 0]
    set node_id $node
    $wi.results.text insert end "> $cmd\n"
    $wi.results.text see end
    update

    # run the command via Execute API message
    set exec_num [newExecCallbackRequest runtool]
    set plugin [getEmulPlugin $node]
    set emulation_sock [lindex $plugin 2]
    sendExecMessage $emulation_sock $node $cmd $exec_num 0x30

    if { $next != "" } {
	runToolCommand $wi $next; # callback for next node in list
    }
}

# callback after receiving exec message response
proc exec_runtool_callback { node execnum cmd result status } {
    set wi .runtool
    
    if { ![winfo exists $wi] } { return }; # user has closed window

    $wi.results.text insert end "> $node > $cmd:\n"
    $wi.results.text insert end "$result\n"
    $wi.results.text see end
}