np_tcp_window.py

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

		scaletxt = textf(tmd, sd, ib)
		canv.scaletxt = canv.create_text(x+5, y-5, anchor=anch, 
				fill=col, font=("helvetica", 8), text=scaletxt)
	except AttributeError:
	    pass
	    

    def mouse_3_up(self, event):

	canv = event.widget
	x = canv.canvasx(event.x)
	y = canv.canvasy(event.y)

    #if inside(x, y, self.bounds) or inside(x, y, self.rtt_bounds):
	if 1:
	    if canv.scaleline != None:
		canv.delete(canv.scaleline)
		canv.delete(canv.scaletxt)


    def mouse_3_dblclick(self, event):
	# pop canvas zoom stack
	canv = event.widget


    def mouse_2_down_rtt(self, event):
	# get and display rtt point
	canv = event.widget
	x = canv.canvasx(event.x)
	y = canv.canvasy(event.y)

	t = canv.find_overlapping(x-5, y-5, x+5, y+5)
	#print t
	items = list(t)
	#print items
	#print self.rtthandles

	for h in self.rtthandles:
	    if items.count(h[1]): 
		c = Canvas(canv, width=500, height=500)
		c.config(bg=self.bgcol)
		p = h[0]
		if p.dir == SERVER:
		    col = self.fgcol
		else:
		    col = FG_COL2
		tstr = '%d %s' % (p.indx, trig_str(p))
		if p.prtt:
		    tstr = tstr + ' prtt %.3f' % (p.prtt/1000.0)
		if p.trtt:
		    tstr = tstr + ' trtt %.3f' % (p.trtt/1000.0)
		if p.delay:
		    tstr = tstr + ' delay %.3f' % (p.delay/1000.0)
		t = c.create_text(0, 0, fill=col, anchor=NW, 
				  font=("helvetica", 8, 'bold'), text=tstr)
		b = c.bbox(t)
		wi = b[2]-b[0]
		xpos = MIN(x+5, TCP_WDW_WI - wi)
		c.place(x=xpos, y=y+5, anchor=SW, width=wi, 
			height=b[3]-b[1])
		self.rttinfo.append(c)
		break
		    


    def mouse_2_up_rtt(self, event):

	for w in self.rttinfo:
	    w.destroy()
	    self.rttinfo = []


    def mouse_2_down(self, event):

	canv = event.widget
	x = canv.canvasx(event.x)
	y = canv.canvasy(event.y)

	if y < self.yorg:
	   self.mouse_2_down_canv(event)
	elif y > self.flight_yorg:
	   self.mouse_2_down_rtt(event)


    def mouse_2_up(self, event):

	canv = event.widget
	x = canv.canvasx(event.x)
	y = canv.canvasy(event.y)

	if y < self.yorg:
	   self.mouse_2_up_canv(event)
	elif y > self.flight_yorg:
	   self.mouse_2_up_rtt(event) 
	
############################################################################### 
    def mouse_4(self, event):

	canv = event.widget
	x = canv.canvasx(event.x)
	y = canv.canvasy(event.y)

	if inside(x, y, self.rtt_bounds):
	    self.rtt_scaleup(RTT_SCROLL_FACT) 
	
############################################################################### 
    def mouse_5(self, event):

	canv = event.widget
	x = canv.canvasx(event.x)
	y = canv.canvasy(event.y)

	if inside(x, y, self.rtt_bounds):
	    self.rtt_scaledown(RTT_SCROLL_FACT)

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

    def draw(self):

	ht = self.ht
	wi = self.wi

	info_ht = self.draw_info()
	
	canv_ht = (TCP_CANVAS_HT_PROP*ht)/100 - info_ht
	flight_ht = (TCP_FLIGHT_HT_PROP*ht)/100
	rtt_ht = (TCP_RTT_HT_PROP*ht)/100
	#info_ht = ht - (canv_ht+flight_ht+rtt_ht) # balance

	canv_vmargin = (canv_ht*TCP_CANV_VMARGIN_PROP)/100
	flight_vmargin = (flight_ht*TCP_FLIGHT_VMARGIN_PROP)/100
	rtt_vmargin = (rtt_ht*TCP_RTT_VMARGIN_PROP)/100

	self.yorg = canv_ht+info_ht-canv_vmargin
	self.flight_yorg = canv_ht+info_ht+flight_ht-flight_vmargin
	self.rtt_yorg = canv_ht+info_ht+flight_ht+rtt_ht-rtt_vmargin

	self.yht = canv_ht-canv_vmargin
	self.flight_yht = flight_ht-(2*flight_vmargin) -25
	self.rtt_yht = rtt_ht-(2*rtt_vmargin) -25
	self.info_yht = info_ht

	self.bounds = [self.xorg, self.xrmargin, self.yorg-canv_ht, self.yorg]
	self.mouse_bounds = [self.xorg-15, self.xrmargin+15, 
			     self.yorg-canv_ht-15, self.yorg+15]
	#print self.bounds
	self.rtt_bounds = [self.hmargin, self.xrmargin, 
			   self.rtt_yorg-self.rtt_yht, self.rtt_yorg]

	self.canv_vmargin = canv_vmargin
	self.flight_vmargin = flight_vmargin

	self.min_xtic_wi = (self.xwi*MIN_XTIC_PROP)/100
	self.min_ytic_hi = (self.yht*MIN_YTIC_PROP)/100

	self.scale()
	
	self.draw_axes()
	self.draw_releases()
	self.draw_pkts()
	self.draw_highacks()
	self.draw_inflights()
	self.draw_rtts()
	
###############################################################################
	   

    def draw_info(self):

	conn = self.conn

	x = self.xorg
	wi = self.xwi
	y = 15

	TEXT = self.canv.create_text

	try:
	    trans = conn.tlist[0]
	    meth = trans.http_meth()
	    mstr = http_client_method_string(meth)
            #stype = trans.get_server()
            #ctype = trans.get_uagent()
	except IndexError:
	    mstr = ''

	if conn.http_status and conn.pers:
	    pstr = 'Persistent %d transactions' % (conn.ntrans)
	else:
	    pstr = 'Non-persistent'

	tstr= '#%d Client %s  Server %s port %d\n%s %s' % \
	       (conn.id, np_hostname(conn.client), np_hostname(conn.server), 
		conn.serverport, pstr, mstr)
	t = TEXT(x, y, fill=self.fgcol, width=wi, 
	     anchor=NW, text=tstr, font=INFO_FONT);
	y = self.canv.bbox(t)[3] + 5

	tstr= 'User agent %s  Server %s' % \
	       (conn.uagent, conn.sagent)
	t = TEXT(x, y, fill=self.fgcol, width=wi, 
	     anchor=NW, text=tstr, font=INFO_FONT);
	y = self.canv.bbox(t)[3] + 5
        
	tstr = 'Start %s duration %.3fms  ' % (tsDatestring(conn.abstart), 
					   conn.dur/1000)
	clostr = 'C: %d/%d mss %d S: %d/%d mss %d' % \
		 (conn.cbytes, conn.cpkts, conn.smss, 
		  conn.sbytes, conn.spkts, conn.cmss)
	t = TEXT(x, y, fill=self.fgcol, font=INFO_FONT, width=wi, 
	     anchor=NW, text=tstr+clostr);
	y = self.canv.bbox(t)[3] + 5

        if conn.modelled:
            text = 'Server imp %s Client imp %s' % (conn.simp.descr_str(), conn.cimp.descr_str())
        else:
            text = 'Not modelled'
        t = TEXT(x, y, fill=self.fgcol, font=INFO_FONT, width=wi, 
                     anchor=NW, text=text)
	return self.canv.bbox(t)[3] + 50 
	
###############################################################################

	
    def draw_pkts(self):
	#print self.phandles

	plist = self.pktlist
	i1 = self.indx1
	i2 = self.indx2

	LINE = self.canv.create_line
	TEXT = self.canv.create_text
	
	#draw packets
	for p in plist[i1:i2+1]:
	    #p.printself_rel()
	    seq = p.wseq
	    #flags = ord(p.flags)
	    flags = p.flags

	    x =  self.xorg + int((p.tm-self.tbase)*self.tscalef)
	    pno = '%d' % (p.indx)
	    self.canv.create_text(x, self.yaxpos+20, anchor=N, text=pno, 
				  fill= AXES_COL, font=PKT_LABEL_FONT)

	    #
	    # Draw the segment
	    #

	    if p.dir == SERVER:
		self.draw_seq(p, x, p.wseq-self.sseqbase, p.len, flags, 
			      S_SEG_COL)
	    else:
		self.draw_seq(p, x, p.wseq-self.cseqbase, p.len, flags, 
			      C_SEG_COL)
 
	
###############################################################################


    def draw_seq(self, pkt, x, seq, len, flags, col):

	LINE = self.canv.create_line
	TEXT = self.canv.create_text
	y0 = self.yorg - int(seq*self.sscalef)
	if len:
	    y1 = y0 - int(len*self.sscalef)
	    self.phandles.append((pkt, LINE(x, y0, x, y1, fill=col, 
					   arrow='both', arrowshape=(4,5,2))))
	    TEXT(x-5, (y0+y1)/2, fill=col, anchor=E, font=PKT_LABEL_FONT, 
		 text='%d/%d' % (pkt.indx, pkt.clu))
	    TEXT(x+5, (y0+y1)/2, fill=col, anchor=W, font=PKT_LABEL_FONT, 
		 width=100, text=pkt.tstr)
	else:
	    y1 = y0
	    self.phandles.append((pkt, self.draw_blob(x, y0, col)))

	if pkt.remark:
	    col = ATTENTION_COL
	    sz = MAX(y0-y1, 10)/2
	    ypos = (y0+y1)/2
	    self.canv.create_oval(x-sz, ypos-sz, x+sz, ypos+sz, outline=ATTENTION_COL)
	    

	if flags & TH_SYN:
	    TEXT(x, y1-2, fill=col, anchor=S, text='S', font=("helvetica", 8))
	txt = ''
	if flags & TH_FIN:
	    txt = txt + 'F'
	if flags & TH_RST:
	    txt = txt + 'R'
	    col = ATTENTION_COL
	if flags & TH_PUSH:
	    txt = txt + 'P'
	TEXT(x+2, y1, fill=col, anchor=W, text=txt, font=("helvetica", 8)) 

	if (pkt.trig & SEG_TRIG) and pkt.lag != None:
	    y = (y0+y1)/2
	    trigtm = pkt.tm - pkt.lag
	    ext = 0
	    x1 = self.xorg + int((trigtm-self.tbase)*self.tscalef)
	    if x1 < self.xorg:
		x1 = self.xorg
		ext = 1
	    LINE(x1, y, x, y, fill='salmon1', 
		 stipple=med_dash)
	    LINE(x-1, y, x, y, fill='blue', arrow='last', arrowshape=(4,5,2))
	    if ext:
		LINE(x1-5, y+5, x1+5, y-5, fill='blue')
	    
###############################################################################


    #
    # Draw the flight graph
    #
    def draw_inflights(self):

	plist = self.pktlist
	i1 = self.indx1
	i2 = self.indx2
	
	LINE = self.canv.create_line

	sinflight = plist[i1].sinflight
	cinflight = plist[i1].cinflight
	flightx = self.xorg
	sinflighty =  self.flight_yorg - sinflight*self.fscalef
	cinflighty = self.flight_yorg - cinflight*self.fscalef

	for p in plist[i1:i2+1]:

	    x =  self.xorg + int((p.tm-self.tbase)*self.tscalef)

	    # extend from last position
	    LINE(flightx, sinflighty, x, sinflighty, fill= S_SEG_COL)
	    LINE(flightx, cinflighty, x, cinflighty, fill= C_SEG_COL)
	    # any change
	    sy = self.flight_yorg - p.sinflight*self.fscalef
	    cy = self.flight_yorg - p.cinflight*self.fscalef
	    LINE(x, sinflighty, x, sy, fill=S_SEG_COL)
	    LINE(x, cinflighty, x, cy, fill=C_SEG_COL)
	    flightx = x
	    sinflighty = sy
	    cinflighty = cy 
	
###############################################################################

    #
    # Find current ack highwaters - return -1 if none
    #
    def find_curr_acks(self, plist, indx):

	i = indx
	si = ci = -1
	got = 0
	while 1:
	   i = i-1 
	   if i < 0 or got == 2:
	       #print '%d %d' % (si, ci)
	       return (si, ci)
	   p = plist[i]
	   #flags = ord(p.flags)
	   flags = p.flags
	   if flags & TH_ACK:
	       if p.dir == SERVER:
		   if si < 0:
		       si = i
		       got = got +1
	       else:
		   if ci < 0:
		       ci = i
		       got = got +1
 
	
###############################################################################

    #
    # draw the acks and highwaters
    #
    def draw_highacks(self):

	plist = self.pktlist
	i1 = self.indx1
	i2 = self.indx2

	LINE = self.canv.create_line
	TEXT = self.canv.create_text

	sacking = 0
	cacking = 0
	ackx = self.xorg

	scurracki, ccurracki = self.find_curr_acks(plist, i1)
	if scurracki >= 0:
	    scurrack = plist[scurracki].wack
	    #print 's curr ack = %s' % (Longstring(scurrack))
	    sacking = 1
	    scurracky = self.yorg - int((scurrack - self.cseqbase)*self.sscalef)
	if ccurracki >= 0:
	    ccurrack = plist[ccurracki].wack
	    #print 'c curr ack = %s' % (Longstring(ccurrack))
	    cacking = 1
	    ccurracky = self.yorg - int((ccurrack - self.sseqbase)*self.sscalef)

	for p in plist[i1:i2+1]:
	    #flags = ord(p.flags)
	    flags = p.flags
	    way = p.dir
	    x =  self.xorg + int((p.tm-self.tbase)*self.tscalef)

	    # extend from last position
	    if sacking and scurracky <= self.yorg:
		LINE(ackx, scurracky, x, scurracky, fill=C_ACK_COL, 
		     tag='sack')
	    if cacking and ccurracky <= self.yorg:
		LINE(ackx, ccurracky, x, ccurracky, fill=S_ACK_COL, 
		     tag='cack')
	    # any change
	    if (flags & TH_ACK):
		ack = p.wack
		if way == SERVER:
		    col = C_ACK_COL
		    y = self.yorg - int((ack-self.cseqbase)*self.sscalef) 
		    if sacking:
			if ack != scurrack:
			    y1 = MIN(scurracky, self.yorg) 
			    LINE(x, y1, x, y, 
				 fill=col, tag='sack')    
			    self.phandles.append((p, self.draw_point(x, y, 
							    col, p.indx)))
			    if (p.trig & ACK_TRIG) and p.lag != None:
				#print 'ack %d' % (p.indx)
				yt = self.yorg - int(((p.pkt_acked.wseq+(p.pkt_acked.len/2))-self.cseqbase)*self.sscalef)
				#yt = (y+y1)/2
				trigtm = p.tm - p.lag
				ext = 0
				x1 = self.xorg + int((trigtm-self.tbase)*self.tscalef)
				if x1 < self.xorg:
				    x1 = self.xorg
				    ext = 1
				LINE(x1, yt, x, yt, fill='orchid1', 
				     stipple=med_dash, arrow='last', arrowshape=(4,5,2))
				if ext:
				    LINE(x1-5, y+5, x1+5, y-5, fill='blue')
			else:
			    self.draw_vtic(x, scurracky, col, p.indx)
		    scurrack = ack
		    scurracky = y
		    sacking = 1
		    #print 'server ack %s - %s = %s' % (Longstring(p.ack), Longstring(self.slowack), Longstring(p.ack-self.slowack))
		    #print 'server change to %d %d' % (x, y)
		else:
		    col = S_ACK_COL
		    y = self.yorg - int((ack-self.sseqbase)*self.sscalef)
		    if cacking:
			if ack != ccurrack:
			    y1 =  MIN(ccurracky, self.yorg)
			    LINE(x, y1, x, y, 
				 fill=col, tag='cack')    
			    self.phandles.append((p, self.draw_point(x, y, 
							    col, p.indx)))
			    if (p.trig & ACK_TRIG) and p.lag != None:
				#yt = (y+y1)/2
				yt = self.yorg - int(((p.pkt_acked.seq+(p.pkt_acked.len/2))-self.sseqbase)*self.sscalef)
				trigtm = p.tm - p.lag
				ext = 0
				x1 = self.xorg + int((trigtm-self.tbase)*self.tscalef)
				if x1 < self.xorg:
				    x1 = self.xorg
				    ext = 1
				LINE(x1, yt, x, yt, fill='cyan', 
				     stipple=med_dash, arrow='last', arrowshape=(4,5,2))
				if ext:
				    LINE(x1-5, y+5, x1+5, y-5, fill='blue')
			else:
			    self.draw_vtic(x, scurracky, col, p.indx)
		    ccurrack = ack
		    ccurracky = y
		    cacking = 1
		    #print 'client ack %s - %s = %s' % (Longstring(p.ack), Longstring(self.clowack), Longstring(p.ack-self.clowack))
		    #print 'client change to %d %d' % (x, y)

	    ackx = x 
	
###############################################################################

    #
    # Find current release - return -1 if none
    #

    def find_curr_rel(self, plist, indx, way):

	i = indx
	while 1:
	   i = i-1 

	   if i < 0:
	       return -1

	   p = plist[i]
	   #p.printself_rel()
	   if p.dir == way and (p.flags & TH_ACK and p.wrel != None):
		return i 
	
###############################################################################


    def draw_releases(self):

	plist = self.pktlist
	i1 = self.indx1
	i2 = self.indx2

	LINE = self.canv.create_line
	TEXT = self.canv.create_text

	crelcol_flowwin = S_WDW_COL_SC
	crelcol_conwin = S_WDW_COL_SS
	srelcol_flowwin = C_WDW_COL_SC
	srelcol_conwin = C_WDW_COL_SS

	sreling = 0
	creling = 0
	srelx = crelx = self.xorg
	

	i = self.find_curr_rel(plist, i1, SERVER)
	if i >= 0:
	    p = plist[i]
	    sreling = 1
	    scurrel = p.wrel
	    scurrely = self.yorg - int((scurrel - self.cseqbase)*self.sscalef)
	    if p.markers & P_REL_BOSS_CWND:
		scurrelcol = srelcol_conwin
	    else:
		scurrelcol = srelcol_flowwin
	

	i = self.find_curr_rel(plist, i1, CLIENT)
	if i >= 0:
	    p = plist[i]
	    creling = 1
	    ccurrel = p.wrel
	    ccurrely = self.yorg - int((ccurrel - self.sseqbase)*self.sscalef)
	    if p.markers & P_REL_BOSS_CWND:
		ccurrelcol = crelcol_conwin
	    else:
		ccurrelcol = crelcol_flowwin


	for p in plist[i1:i2+1]:

	    x =  self.xorg + int((p.tm-self.tbase)*self.tscalef)
	    way = p.dir


	    #
	    # Draw the releases - ack + min(snd_wnd, cwnd)