np_tscreen.py

该软件根据网络数据生成NetFlow记录。NetFlow可用于网络规划、负载均衡、安全监控等

 	conns = canv.tree.client.connlist
	
	items = list(canv.find_overlapping(canv.startx, canv.starty, x, y))
	#print 'items',
	#print items
	connlist = []
	for conn in conns:
	    if canv.mode == 'detailed':
		handle = conn.handle
	    elif canv.mode == 'time':
		handle = conn.vhandle
	    else:
		sys.stderr.write('Goof - unmatched canvas')
		sys.exit(0)
	    if items.count(handle):
		connlist.append(conn)

        if not connlist:
            # restore the tree info display
            self.pktinfo.pack_forget()
            self.conninfo.pack_forget()
            self.canvlist[self.indx][0].pack(side=TOP, fill=BOTH, expand=1)
            return
        
	if mod == 'ctrl':
            np_TCPDisplay.TcpDisplay(connlist, standalone = 'no',
                                     logfun=self.nullf, trace=1)
        elif mod == 'shift':
            self.canvlist[self.indx][0].pack_forget()
            self.conninfo.pack_forget()
            self.pktinfo.list_pkts(connlist[0], 1)
            self.pktinfo.pack(side=TOP, fill=BOTH, expand=1)
        else:
            self.canvlist[self.indx][0].pack_forget()
            self.pktinfo.pack_forget()
            self.conninfo.transdata = None
            self.conninfo.list_trans(connlist[0])
            self.conninfo.pack(side=TOP, fill=BOTH, expand=1)

##############################################################################

    def tcanv_b3(self, ev):

        # time scaler
	canv = ev.widget
	x = int(canv.canvasx(ev.x))
	y = int(canv.canvasy(ev.y))

        # in case we have to scroll
	tcanv = canv.scroll_with
	canv.scan_mark(int(x), int(y))
	tcanv.scan_mark(int(x), 0) #want x-pan only
	canv.mark_set = 1

	canv.xmark = x
	tcanv.xmark = x
	canv.ymark = y
        canv.xsi = 1
        canv.last_dir = 0

	#print 'B1 %d, %d' % (x, y)

	canv.scaleline = None
	canv.scaletxt = None
        
        canv.startscalex=x
        canv.startscaley=y

        if canv.mode == 'detailed':
            # non -linear - find base time once and for all
            t = self.trees[self.indx]
            gaps = t.gaps
            try:
                i = t.find_gap(x, gaps, 0, len(gaps)-1,  np_Obtree.G_AFTER)
                post = 0
            except NotInRange:
                if x < gaps[0][3]:
                    i = 0
                    post = 0
                else:
                    i = len(gaps)-1
                    # after gap - add in duration 
                    post = gaps[i][2]
            canv.startscaletm = gaps[i][1] + post - (gaps[i][3]-x)/canv.scalef
            tm = canv.startscaletm
        else:
            tm = (x-canv.leftmargin)/canv.scalef
         
        # for button down show time
        if ev.x + 100 > self.dframe_width:
            anch = E
        else:
            anch = W   
        canv.scaletxt = canv.create_text(x+5, y-5, anchor=anch,
                                  fill='red', text='%+.3fms' % (tm/1000))
            

    def tcanv_b3_drag(self, ev):

        # for drag show delta

        def draw_scale(canv, x, y, delta, anch): 
	    canv.delete(canv.scaleline) 
	    canv.delete(canv.scaletxt)
            canv.scaleline = canv.create_line(canv.startscalex,
                                canv.startscaley, x, y, fill='red')
            canv.scaletxt = canv.create_text(x+5, y-5, anchor=anch,
                                  fill='red', text='%+.3fms' % (delta/1000))

        def get_tdelta(self, canv, x):

            if canv.mode == 'time':
                tdelta = (x-canv.startscalex)/canv.scalef
            else:
                tr = self.trees[self.indx]
                gaps = tr.gaps
                try:
                    i = tr.find_gap(x, gaps, 0, len(gaps)-1, np_Obtree.G_AFTER)
                    post = 0
                except NotInRange:
                    if x < gaps[0][3]:
                        i = 0
                        post = 0
                    else:
                        i = len(gaps)-1
                        # after gap - add in duration
                        post = gaps[i][2]
                t = gaps[i][1] + post - (gaps[i][3]-x)/canv.scalef
                tdelta = t - canv.startscaletm

            return tdelta
                
        if not 0 < ev.x < self.dframe_width:
            return
	# draw scale line
	canv = ev.widget

        if not 0 < ev.y < canv.ysize:
            return
        
	x = canv.canvasx(ev.x)
	y = canv.canvasy(ev.y)

	if (canv.startscalex != x) or (canv.startscaley != y): 

            if ev.x + 100 > self.dframe_width:
                anch = E
            else:
                anch = W

            tdelta = get_tdelta(self, canv, x)

            # scroll needed?
            dir = 0
            if ev.x >= self.dframe_width-10 and x + canv.xsi < canv.xsize:
                dir = 1
            if ev.x <= 10 and canv.tlc[0] > canv.xmin:
                dir = -1
                
            if dir and dir != canv.last_dir:
                canv.xsi = 1
                canv.last_dir = dir

            if dir:
                si = dir*canv.xsi
                canv.scan_dragto(canv.xmark-si, 
                                 canv.ymark+0)
                canv.scroll_with.scan_dragto(canv.xmark-si, 0)
                canv.tlc[0] = canv.canvasx(x)-x
                canv.draw_map_port(canv)
                draw_scale(canv, x, y, tdelta, anch)
                canv.xsi += 1
                # re-draw from within handler
                self.root.update_idletasks()
            draw_scale(canv, x, y, tdelta, anch)
	    
    def tcanv_b3_up(self, ev):
	# 
	canv = ev.widget
	canv.delete(canv.scaleline)
	canv.delete(canv.scaletxt)
	canv.mark_set = 0
        

##############################################################################
	

    def draw_next(self):

	#print self.indx
	if self.indx + 1 == len(self.clist):
	    return
        constructed = 1
	old_indx = self.indx
	self.indx += 1
	if self.indx == self.ncanv:
	    canvasses = self.make_canvasses()
	    self.canvlist.append(canvasses)
            client = self.clist[self.indx]
            try:
                if client.Class == 'Filerec':
                    #still have to build it from scratch
                    constructed = 0
                    try:
                        client = client.reconstruct(trace=self.trace)
                        self.clist[self.indx] = client
                        constructed = 1
                    except:
                        print 'Can\'t reconstruct client'
                        raise
                try:
                    tree = np_Obtree.ObTree(self.clist[self.indx],
                                        lookup=self.lookup, trace=self.trace)
                    self.trees.append(tree)
                    self.trees_pure.append(copy(tree))
                except:
                    print 'Can\'t construct tree'
                    self.trees.append(None)
                    self.trees_pure.append(None)
                    raise
                tree.draw(self)
            except:
                print 'Can\'t draw tree',
                if constructed:
                    print 'for client', client.addr_str()
                self.indx -= 1
                self.canvlist.pop()
                raise
	    self.ncanv += 1
	else:
	    canvasses = self.canvlist[self.indx]
            client = self.clist[self.indx]

	if self.started:
	    self.hide_set(self.canvlist[old_indx])
            if self.tree_picked:
                self.toolbar.delete('Trees')

	self.display_set(canvasses)

	self.set_titlebar(self.trees[self.indx])
        self.make_trees_entry(client)

	self.started = 1
	self.set_pnbuttons()
	    
##############################################################################

    def draw_prev(self):

	if self.indx == 0:
	    return
	old_indx = self.indx
	self.indx -= 1
	canvasses = self.canvlist[self.indx]
	self.hide_set(self.canvlist[old_indx])
        if self.tree_picked:
            self.toolbar.delete('Trees')
	self.display_set(canvasses)
        self.make_trees_entry(self.clist[self.indx])

	self.set_pnbuttons()
	    
##############################################################################

    def redo(self, rooturl=None, dist=None):

        canvasses = self.canvlist[self.indx]
        for c in canvasses[0:2]:
            c.delete(ALL)
            c.drawn = 0
        for set in canvasses[2:]:
            for c in set:
                c.delete(ALL)
                c.drawn = 0

        self.pktinfo.pack_forget()
        self.conninfo.pack_forget()
        self.conninfo.transdata=None
	canvasses[0].pack(expand=1, fill=BOTH)
        
        if self.tree_picked:
            self.toolbar.delete('Trees')

        reload(np_WebHost)
        reload(np_TCPConn)
        reload(np_HTTPTrans)
        reload(np_Obtree)
        reload (np_filerec)

        client = self.clist[self.indx].FileRec.reconstruct()
        self.clist[self.indx] = client
        client.rooturl = rooturl
        tree = np_Obtree.ObTree(client, lookup=self.lookup,
                                trace=self.trace)
        if dist:
            tree.rooturl = (None, None)
            tree.tree_trans = [t for t in client.translist if t.order in dist[0]]
            tree.tree_conns = [c for c in client.connlist if c.id in dist[1]]
        self.trees[self.indx] = tree
        self.trees_pure[self.indx] = copy(tree)
        tree.draw(self)
        self.make_trees_entry(self.clist[self.indx])
	    
##############################################################################

    def redraw(self, rooturl=None, dist=None):

        canvasses = self.canvlist[self.indx]
        for c in canvasses[0:2]:
            c.delete(ALL)
            c.drawn = 0
        for set in canvasses[2:]:
            for c in set:
                c.delete(ALL)
                c.drawn = 0

        self.pktinfo.pack_forget()
        self.conninfo.pack_forget()
        self.conninfo.transdata=None
	canvasses[0].pack(expand=1, fill=BOTH)
        
        if self.tree_picked:
            self.toolbar.delete('Trees')

        client = self.clist[self.indx]
        client.rooturl = rooturl

        for conn in client.connlist:
            try:
                del conn.reqlabelstart
                del conn.replabelstart
                del conn.vreqlabelstart
                del conn.vreplabelstart
            except AttributeError:
                pass

        tree = self.trees_pure[self.indx]
        self.trees_pure[self.indx] = copy(tree)

        tree.LinkDict = np_obnode.LinkDict().dict

        if dist:
            tree.rooturl = (None, None)
            tree.tree_trans = [t for t in client.translist if t.order in dist[0]]
            tree.tree_conns = [c for c in client.connlist if c.id in dist[1]]
        
        #print tree
        tree.draw(self)
        self.make_trees_entry(self.clist[self.indx])
	    
##############################################################################

    def picktree(self):

        tree = self.treevar.get()
        if tree == -1:
            rooturl = None
            dist = None
            entry = 'All'
        elif tree == -2:
            rooturl = None
            unlinked = self.clist[self.indx].unlinkedlist
            dist = [[t.order for t in unlinked], [t.connid for t in unlinked]]
            entry = 'Unlinked'
        else:
            client = self.clist[self.indx]
            trans = client.rootlist[tree]
            rooturl = (trans.absurl, trans.connid)
            dist = None
            entry = tree+3
            #entry = '%d' % (tree)

        self.redraw(rooturl=rooturl, dist=dist)
        self.treemenu.entryconfig(entry, background='lightblue')
	    
##############################################################################

    def change_view(self):

	#self.toolbar.viewb.config(text=self.mode)

	if self.mode == 'Detail':
	    show = 3
	    hide = 2
	    newmode = 'Time'
	else:
	    show = 2
	    hide = 3
	    newmode = 'Detail'
            
	self.toolbar.entryconfig(newmode, label=self.mode)

        self.mode = newmode

	canvasses = self.canvlist[self.indx]
	self.hide_mode(canvasses[hide])
	self.display_mode(canvasses[show])
	    
##############################################################################

    def display_conns(self):

        np_TCPDisplay.TcpDisplay(self.clist[self.indx].connlist,
                                 standalone='no', logfun = self.nullf, trace=1)

##############################################################################
##############################################################################

def main():

    Tscreen([1, 2, 3, 4])
	    
##############################################################################


# Call main when run as script
if __name__ == '__main__':
        main()