np_obtree.py

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

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

    def label_conn(self, canv, conn, xfront, x, xback, y, dist):

	TEXT = canv.create_text
	flags = conn.flags
	cflags = conn.cflags
	sflags = conn.sflags

	if flags & TCP_CONN_ERROR:
	    error = 1
	    colour = 'red'
	else:
	    error = 0
	    colour = "blue"

        if not dist:
            colour = colour1 = 'grey72'
        else:
            colour1 = 'DarkOrchid1'

        #
	#label host(s)
        #
        if self.Class == 'WebClient':
            serverstr = '%s\n' % (self.nslookup(conn.server))
        elif self.Class == 'WebServer':
            serverstr = '%s\n' % (self.nslookup(conn.client))
        else:
            serverstr = '%s/%s\n' % (self.nslookup(conn.client),
                                     self.nslookup(conn.server))
        
	if conn.http_status & 0x40000:
	    #persistent connection
	    serverstr = serverstr + ' P '
	serverstr = serverstr + conn.http_verstr
	t = TEXT(xfront, y+4, fill=colour, anchor=E, 
			      text=serverstr, font = self.font10)

        # N conns previously open
        t = TEXT(canv.bbox(t)[0]-10, y+4, fill=colour1, anchor=E, font=self.font12bold,
             text='PO: %d/%d/%d ' % (conn.cop1, conn.cop2, conn.cop3))

        # Conn id etc.
        TEXT(canv.bbox(t)[0]-10, y+4, fill=colour, anchor=E, font=self.font12bold,
             text='  %d (%d)' % (conn.indx, conn.id))

	# label times
	optmstr = '%d' % (int(conn.open/1000))
	TEXT(x, y + 2, fill=colour, anchor=NE, 
			      text=optmstr, font = self.font10)

	clostr = '(+%d) C: %d/%d S: %d/%d ' % \
		 (int(conn.dur/1000), conn.cbytes, conn.cpkts, 
		  conn.sbytes, conn.spkts)
	if error:
	    clostr = clostr + 'ERROR '
	if flags & TCP_TIMEO :
	    clostr = clostr + 'TIMED OUT '
	if flags & TCP_FORCED_ALT:
	    clostr = clostr + 'ALT FORCED '
	if flags & TCP_QUICK_CLOSE:
	    clostr = clostr + 'QUICK CLOSE '
	if flags & TCP_RUNEND:
	    clostr = clostr + 'END OF RUN '
	if cflags & (TSP_SEQ_TIMEO | TSP_SEQ_TIMEO_FORCED | TSP_SEQ_TIMEO_QL \
		     | TSP_SEQ_TIMEO_ACK):
	    clostr = clostr + 'C SEQ TIMEO '
	if sflags & (TSP_SEQ_TIMEO | TSP_SEQ_TIMEO_FORCED | TSP_SEQ_TIMEO_QL \
		     | TSP_SEQ_TIMEO_ACK):
	    clostr = clostr + 'S SEQ TIMEO '
	if cflags & TSP_FORCED_ALT:
	    clostr = clostr + 'C FORCED ALT '
	if sflags & TSP_FORCED_ALT:
	    clostr = clostr + 'S FORCED ALT '
	if cflags & TSP_FORCED_OPEN:
	    clostr = clostr + 'C FORCED OPEN '
	if sflags & TSP_FORCED_OPEN:
	    clostr = clostr + 'S FORCED OPEN '
	if cflags & TSP_FORCED_CLOSE:
	    clostr = clostr + 'C FORCED CLOSE '
	if sflags & TSP_FORCED_CLOSE:
	    clostr = clostr + 'S FORCED CLOSE '

	t = TEXT(xback+2, y, fill=colour, anchor=W, 
			      text=clostr, font = self.font10)
        if canv == self.draw:
            conn.maxx = max(conn.maxx, canv.bbox(t)[2])
        else:
            conn.maxvx = max(conn.maxvx, canv.bbox(t)[2])
        
#############################################################################

    def label_req(self, canv, req, xreqstart, xreqend, xrepstart, 
			   xrepend, y0, yc, y1, dist):

	def checkstr(s):
	    ok = 1
	    for c in s:
		if not 31 < ord(c) < 127:
		    ok = 0
		    break;

	    if ok:
		return s
	    else:
		return 'XXX'

	cstatus = req.cstatus 
	sstatus = req.sstatus
	TEXT = canv.create_text
        TConn = req.TConn
	dur = req.reqdur + req.repdur

        if canv == self.draw:
            try:
                reqlabelstart = TConn.reqlabelstart + 20
                replabelstart = max(TConn.replabelstart + 20, reqlabelstart)
            except AttributeError: # first label
                reqlabelstart = xreqstart
                replabelstart = xrepstart
        elif canv == self.view:
            try:
                reqlabelstart = TConn.vreqlabelstart + 20
                replabelstart = max(TConn.vreplabelstart + 20, reqlabelstart)
            except AttributeError: # first label
                reqlabelstart = xreqstart
                replabelstart = xrepstart
  
        if not replabelstart:
            replabelstart = reqlabelstart

	## if req.cisdummy or req.sisdummy:
## 	    print 'XXXXXXX DUMMY XXXXX'
	
	if req.cvalid and not req.cisdummy:
	    tmbase = req.reqstart
	    #label request
            if not dist:
                ccolour = 'grey72'
	    elif req.cerr:
		ccolour = 'red'
		errstr = '(%d)' % (req.cerr)
		obstr = checkstr(req.obname)
	    else:
		ccolour = 'black'
		errstr = ''
		#obstr = req.obname
		obstr = req.absurl
                
            if canv == self.draw:
                count_mark = 1
            else:
                count_mark = 0
            marked = 0
            if req.reflink:
                refstr = '%d' % (req.reflink.trans.order)
                if req.reflink.type & LR_REDIRECT:
                    self.draw_mark(canv, 'Re-directed', reqlabelstart-5, y0-15,
                                   count=count_mark)
            else:
                refstr = '?'
                if not len(req.downlinks):
                    self.draw_mark(canv, 'Unlinked', reqlabelstart-5, y0-15,
                                   count=count_mark)
                    marked = 1

            if req.isfail:
                if marked:
                    self.draw_mark(canv, 'Transaction failed',
                                   reqlabelstart-5, y0-15, count=count_mark,
                                   rh=1)
                else:
                    self.draw_mark(canv, 'Transaction failed',
                                   reqlabelstart-5, y0-15, count=count_mark)
                    
            t = TEXT(reqlabelstart, y0-4, fill=ccolour, anchor=SW, 
                     text='%d (<-%s)' % (req.order, refstr),
                     font = self.font10bold)

            # if distinguished tree root mark it
            if self.rooturl and self.rooturl[0] == req.absurl:
                bb = canv.bbox(t)
                canv.create_rectangle(bb[0], bb[1], bb[2], bb[3],
                                      outline='red')

            if dist:

                uagent = req.uagent
                if uagent == None:
                    uagent = 'Unknown'
                labelstr = '(%s) %s %s %s' % (self.get_agentdict(uagent), 
                                 http_client_method_string(req.reqtype), 
                                      obstr, errstr)
                t = TEXT(canv.bbox(t)[2] + 4, y0-4, fill=ccolour, anchor=SW, 
                                      text=labelstr, font = self.font10)

                # label times
                TEXT(xreqstart, y1 + 2, fill=ccolour, anchor=N, 
                     text='%d' % (tmbase/1000), 
                     font = self.font10)

                if req.reqend != tmbase:
                    TEXT(xreqend, y1+2, fill=ccolour, anchor=N, 
                         text='+%d' % ((req.reqend - tmbase)/1000), 
                         font = self.font10)

        elif dist:
            # not valid etc
            t = TEXT(reqlabelstart, y0-4, fill='red', anchor=SW, 
                     text='Client request invalid',
                     font = self.font10)
        else:
            # just empty text for positioning
            t = TEXT(reqlabelstart, y0-4, anchor=SW, 
                     text=' ',
                     font = self.font10)
            

        end = canv.bbox(t)[2]
        if canv == self.draw:
            # don't know if we have a value yet
            try:
                maxx = TConn.maxx
            except AttributeError:
                maxx = 0
            TConn.maxx = max(maxx, end)
            TConn.reqlabelstart = end
        else:
            try:
                maxvx = TConn.maxvx
            except AttributeError:
                maxvx = 0
            TConn.maxvx = max(maxvx, end)
            TConn.vreqlabelstart = end

	if req.svalid and not req.sisdummy:
	    if not req.cvalid:
		tmbase = req.repstart
		repstart_pre = ''
	    else:
		tmbase = req.reqstart
		repstart_pre = '+'

	    #label response
            if not dist:
                scolour = 'grey72'
	    elif req.serr:
		scolour = 'red'
		errstr = '(%s)' % (req.serr)
	    else:
		scolour = 'black'
		errstr = ''
                

	    if not sstatus & TRANS_INCOMPLETE: #object complete
		cstr = 'C'
	    elif sstatus & TRANS_FINISHED: #transaction finished - eg redirected, not mod, etc
		cstr = 'F'
	    else:
		cstr = '*'

            if dist:

                server = req.server
                if server == None:
                    server = 'Unknown'
                labelstr = '(%s) %s (%d) %d/%d %s' % \
                           (self.get_agentdict(server), 
                            cstr, req.retcode,  
                            req.nbytes, req.npkts, errstr)
                t = TEXT(replabelstart, yc-1, fill=scolour, anchor=SW, 
                                      text=labelstr, font = self.font10)

                # label times

                TEXT(xrepstart, y1+2, fill=scolour, anchor=N, 
                        text='%s%d' % \
                     (repstart_pre, (req.repstart - tmbase)/1000), 
                     font = self.font10)
                
                if req.repend != req.repstart:
                    TEXT(xrepend, y1+2, fill=scolour, anchor=N, 
                         text='+%d' % ((req.repend - tmbase)/1000), 
                         font = self.font10)
            else:
                t = TEXT(replabelstart, yc-1, fill=scolour, anchor=SW, 
                                      text=cstr, font = self.font10)

        elif dist:
            # not valid etc - might need these next time round
            t = TEXT(replabelstart, yc-1, fill='red', anchor=SW, 
                     text='Server response invalid',
                     font = self.font10)
        else:
            # just empty text for positioning
            t = TEXT(replabelstart, yc-1, anchor=SW, 
                     text=' ',
                     font = self.font10)

        # record text end for next label op
        end = canv.bbox(t)[2]
        if canv == self.draw:
            # don't know if we have a value yet
            try:
                maxx = TConn.maxx
            except AttributeError:
                maxx = 0
            TConn.maxx = max(maxx, end)
            TConn.replabelstart = end
        else:
            try:
                maxvx = TConn.maxvx
            except AttributeError:
                maxvx = 0
            TConn.maxvx = max(maxvx, end)
            TConn.vreplabelstart = end 

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

    def label_lookup(self, canv, lookup, xfront, xback, y):
	TEXT = canv.create_text
	colour="red"

	# label times
	reqtmstr = '%d' % (lookup.reqtm/1000)
	TEXT(xfront, y + 2, fill=colour, anchor=NE, 
			      text=reqtmstr, font = self.font10)

	reptmstr = '+%d' % (lookup.dur/1000)
	TEXT(xback+2, y + 2, fill=colour, anchor=NW, 
			      text=reptmstr, font = self.font10)
	


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

    
    def draw_conns(self):

	tconns = self.client.connlist
	canv = self.draw
	scalef = canv.scalef
	LINE = canv.create_line

	topy = self.draw.topy
	if len(self.client.dummytrans):
	    #topy = topy+self.impobjht
	    topy = topy+self.connht

	canv.topconns = topy

        if self.pktdict:
            pd = 0
        else:
            pd = 1
            pktdict = self.pktdict

            
        pktdict = self.pktdict

	for conn in tconns:

            #if pd:
                #for p in conn.pktlist:
                    #pktdict[conn, p.tm] = p

            # in distinguished tree?
            if self.rooturl and not (conn in self.tree_conns):
                dist = 0
            else:
                dist = 1
                
	    optm = conn.open
	    clotm = conn.close
	    dur = conn.dur

	    csyn = conn.clisyn
	    ssyn = conn.servsyn
	    cacksyn = conn.clisyn
	    sacksyn = conn.servsyn
	    crst = conn.clirst
	    srst = conn.servrst
	    cfin = conn.clifin
	    servfin = conn.servfin

	    totgap = 0
	    ngaps = 0
	    gap_blanks = []
	    for gap in conn.gaps:
		tm = gap[0]
		gap_blanks.append((tm - totgap, ngaps))
		totgap = totgap + gap[1]
		ngaps = ngaps + 1
	  

## 	    print '#%d %9d-%9d %9d %9d %3d' % (conn.id, optm/1000,
## 					   clotm/1000, dur/1000, 
## 					   conn.gap_before, conn.ngaps_before),
            if dist:
                colour = "blue"
            else:
                colour = 'grey72'

	    y  = conn.y = topy + conn.indx*self.connht + self.connht/2
	    xopen = conn.x0 = self.leftmargin \
		 + int((optm - conn.gap_before)*scalef) \
		 + conn.ngaps_before*self.gapwidth
	    xclose = conn.x1 = xopen + int((dur - totgap)*scalef) + ngaps*self.gapwidth
	    #print '(%d-%d)' % (x0, xclose)

	    if conn.ns_attached:
		labelfront = self.draw_lookup(conn.lookup, y) - 8
	    else:
		labelfront = xopen - 8
		

	    conn.handle = LINE(xopen, y, xclose, y, fill=colour, width=2)
            # don't know if maxx set yet
            try:
                maxx = conn.maxx
            except AttributeError:
                maxx = 0
            conn.maxx = max(maxx, xclose)

	    # blank out the gaps
	    for blank in gap_blanks:
		blankx =  self.leftmargin \