root/trunk/tool/renetcolGUI.py @ 148

##  File: renetcolGUI.py
  
##  Authors: ANDREU Francois-Xavier 
 
##  Copyright (C) 2005-2006-2007-2008 GIP RENATER 
 

##   This file is part of renetcol. 
 
##   renetcol is free software; you can redistribute it and/or modify
##   it under the terms of the GNU General Public License as published by
##   the Free Software Foundation; either version 2 of the License, or
##   (at your option) any later version.
 
##   renetcol is distributed in the hope that it will be useful,
##   but WITHOUT ANY WARRANTY; without even the implied warranty of
##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##   GNU General Public License for more details.
 
##   You should have received a copy of the GNU General Public License
##   along with renetcol; if not, write to the Free Software
##   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 

# Make Windows actually find the stuff installed
# You must check up if it's the good path to GTK 
gtkdir = 'C:/Program Files/Fichiers communs/GTK/'

import os
import binascii
import struct
import time
os.environ['PATH'] += ";%s/lib;%s/bin" % (gtkdir, gtkdir)

import operator
import threading
import string
import re
import socket
import sys
import gtk
import traceback
import pango
import commands
from optparse import OptionParser

########### DEFAULT VALUES, YOU MUST CHANGE IT ###############################
IPversion = 4
localAddr = ''
localAddr6 = '0::'
localPort = 2222
collectorAddr = "127.0.0.1"
collectorAddr6 = "0::"
collectorPort = 52571  # if you change this port number, apply the
                       # modification on the renetcolSender.h file
                       # and you'll need a new compilation of the colllector 
##############################################################################

myInputControlThread = None
printValue =      [ 0,1,1,0,1,0,0,1,1,0, # 0 to 9
                    0,1,1,0,0,0,0,0,0,0, # 10...
                    1,0,0,0,0,0,0,1,1,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,1,1,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    1,1,1,1,1,1,1,1,1,1, #
                    0,0,0,0,0,0,0,0,0,0,  # 80 to 89
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0 # 130 to 139
                    ]
firstParseValue = [ 0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0 # 130 to 139
                    ]
checkUpValues =   [ 0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0, #
                    0,0,0,0,0,0,0,0,0,0 # 130 to 139
                    ]
fieldsName =  [ "","IN_BYT","IN_PKTS","","PROT","TOS","TCP_FL","S_PORT","IPv4@S","S_MASK",
                "InSNMP","D_PORT","IPv4@D","D_MASK","OutSNMP","NextHop","S_AS","D_AS","","",
                "","Time","","","","","","IPv6@S","IPv6@D","IPv6_S_MASK",
                "IPv6_D_MASK","","","","","","","","","",
                "","","","","","","M_T_L_T","M_T_L_@","","",
                "","","","","","","","","","",
                "","","","","","","","","","ROUTER",
                "M_L_1","M_L_2","M_L_3","M_L_4","M_L_5","M_L_6","M_L_7","M_L_8","M_L_9","M_L_10",
                "","","","","","","","","","", # 80 to 89
                "","","","","","","","","","",
                "","","","","","","","","","",
                "","","","","","","","","","",
                "","","","","","","","","","",
                "","","","","","","","","","" # 130 to 139
                ]
flowCpt = 0
mask = [ 0,0,0 ]
spaceSep = " "
tabSep = "\t"
freeze = 0
record = 0
record_file_name = ""
record_file = None
is_already_see = 0
collectorRule=""
coll_window = gtk.Window()
router=0
tpl_def = {}
os_type = 0
oldTpl = 0
fromRouter = ""
myTimer = None
myCPT = 1

class InputControl(threading.Thread):
    def kill(self, timeout):
        self.imRunning = 0
        time.sleep(1)
        print "\n.\n..\n..."
        time.sleep(1)
        print "....\n.....\n......"        
        time.sleep(1)
        if self.myFlowInput:
            self.myFlowInput.socket_close()
        self.join(timeout)
        
    def __init__(self, address, port):
        self.imRunning = 1 
        self.currentflow = None
        threading.Thread.__init__(self)
        self.myFlowInput = FlowInput(address, port)

    def run(self):
        global freeze, record
        while self.imRunning:
            if self.myFlowInput:
                tmp = self.myFlowInput.get_flow()
                if (tmp[0]!=None):
                    self.currentflow = Flow(tmp)
                    if (freeze==0) & self.currentflow.enable():
                        self.currentflow.print_flow2()
                    if (record==1) & self.currentflow.enable():
                        self.currentflow.write_flow2()
##                else:
##                    self.myFlowInput = None
    
class Flow:
    def __init__(self, data):
        self.flow = [ data[0], data[1] ]

# flow selection
    def enable(self):
        global firstParseValue, checkUpValues, tpl_def, fromRouter
        res = 1
        resS = 1
        resD = 1
        for i in range (0, len(tpl_def[self.flow[0]])):
            f = tpl_def[self.flow[0]][i][0]
            # or f==15 or f==18 or f==47
            if ( f==8 ) and ( checkUpValues[f]==1 ):
                resS = resS & ( ((struct.unpack('>L',(socket.inet_aton(self.flow[1][i])))[0] & mask[1-1]) == firstParseValue[f]) )
            elif ( f==12 ) and ( checkUpValues[f]==1 ):
                resD = resD & ( ((struct.unpack('>L',(socket.inet_aton(self.flow[1][i])))[0] & mask[1-1]) == firstParseValue[f]) )
            elif ( i==27 or i==28 ):
                pass
            elif ( (f==1) and (checkUpValues[f]==1) ):
                res = res & ( (self.flow[1][i] <= ((firstParseValue[f])+((firstParseValue[f])*5/100))) and ((self.flow[1][i] >= ((firstParseValue[f])-((firstParseValue[f])*5/100)))) )
            elif (checkUpValues[f]==1):
                res = res & (self.flow[1][i] == firstParseValue[f])
        if ( checkUpValues[69]==1 ):
            res = res & ( (fromRouter == firstParseValue[69]) )
        res = res & (resS or resD)
        return res

# flow print
    def print_flow2(self):
        global printValue, tpl_def, flowCpt, fieldsName, oldTpl, os_type, fromRouter
        myliste = []
        myTpl = []
        strFlow = ""
        strField = ""
        underscore_line = ""
        flowCpt+=1
        if (flowCpt%60 == 0 or oldTpl != self.flow[0]):
##        if (flowCpt%100 == 0): 
            flowCpt = 0
            for i in range (0, len(tpl_def[self.flow[0]])):
                f = tpl_def[self.flow[0]][i][0]
                if printValue[f]:
                    if ( f==27 or f==28 or f==62 or f==63 ):
                        strField += str(fieldsName[f])
                        l = len(str(fieldsName[f]))
                        if ((40-l)%8 == 0):
                            tabNb = int((40-l)/8)
                        else:
                            tabNb = int((40-l)/8) + 1
                        for j in range (0, tabNb): 
                            strField += "\t"
                        for k in range (0, 40):
                            underscore_line += "-"
                    elif ( f==8 or f==15 or f==12 or f==18 or f==47 ):
                        strField += str(fieldsName[f])
                        l = len(str(fieldsName[f]))
                        if ((16-l)%8 == 0):
                            tabNb = int((16-l)/8)
                        else:
                            tabNb = int((16-l)/8) + 1
                        for j in range (0, tabNb): 
                            strField += "\t"
                        for k in range (0, 16):
                            underscore_line += "-"
                    else:
                        strField += str(fieldsName[f])
                        strField += "\t"
                        for k in range (0, 8):
                            underscore_line += "-"
            if (oldTpl != self.flow[0]):
                print " "
            if (os_type == 0):
                esc = '\x1b['
                sep = ';'
                end = 'm'
                if (printValue[69]):
                    rt = str(fieldsName[69])
                    toprint = esc+"37"+sep+"44"+end+strField+rt+esc+"0"+end
                else:
                    toprint = esc+"37"+sep+"44"+end+strField+esc+"0"+end
                print toprint
            else:
                if (printValue[69]):
                    strField += str(fieldsName[69])
                print strField
                print underscore_line
        for i in range (0, len(tpl_def[self.flow[0]])):
            f = tpl_def[self.flow[0]][i][0]
            if printValue[f]:
                if ( f==27 or f==28 or f==62 or f==63 ):
                    strFlow += str(self.flow[1][i])
                    l = len(str(self.flow[1][i]))
                    if ((40-l)%8 == 0):
                        tabNb = int((40-l)/8)
                    else:
                        tabNb = int((40-l)/8) + 1
                    for j in range (0, tabNb): 
                        strFlow += "\t"
                elif ( f==8 or f==12 or f==15 or f==18 or f==47 ):
                    strFlow += str(self.flow[1][i])
                    l = len(str(self.flow[1][i]))
                    if ((16-l)%8 == 0):
                        tabNb = int((16-l)/8)
                    else:
                        tabNb = int((16-l)/8) + 1
                    for j in range (0, tabNb): 
                        strFlow += "\t"
                elif (f==21):
                    myliste += [str(self.flow[1][i]-self.flow[1][i+1])]
                    strFlow += str(self.flow[1][i]-self.flow[1][i+1])
                    strFlow += "\t"
                elif (f==22):
                    pass
                else:
                    myliste += [str(self.flow[1][i])]
                    strFlow += str(self.flow[1][i])
                    for k in range (len(str(self.flow[1][i])), 7):
                        strFlow += " "
                    strFlow += "\t"
        if (printValue[69]):
            strFlow += fromRouter
        print strFlow
        oldTpl = self.flow[0]

# flow record
    def write_flow2(self):
        global printValue, record_file, tpl_def
        myliste = []
        for i in range (0, len(tpl_def[self.flow[0]])):
            f = tpl_def[self.flow[0]][i][0]
            if printValue[f]:
                if (f==21):
                    myliste += [str(self.flow[1][i]-self.flow[1][i+1])]
                elif (f==22):
                    pass
                else:
                    myliste += [str(self.flow[1][i])]
        theflow = string.join(myliste, "\t")+"\t"+fromRouter+"\n"
        if (record_file!=None):
            record_file.write(theflow)
        
class FlowInput:
    def __init__(self, h, p):
        self.HOST = h
        self.PORT = p
        if (IPversion == 4):
            self.socketnumber = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        elif (IPversion == 6):
            self.socketnumber = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
        else:
            print "IP protocol ", IPversion ," not supported"
            exit(0)
        self.socketnumber.bind((self.HOST, self.PORT))
    
    def get_flow(self):
        global collectorRule, tpl_def, os_type, fromRouter
        if (self.socketnumber!=None):
            data = self.socketnumber.recvfrom(1024)
            flow = data[0]
            code = struct.unpack('<H', flow[0:2])
            if (code[0] == 1): ## a def packet
                routerSrc = struct.unpack('<L', flow[2:6])
                sourceId = struct.unpack('<L', flow[6:10])
                tplId = struct.unpack('<H', flow[10:12])
                mykeylst = []
                mykeylst += [str(routerSrc[0])]
                mykeylst += [str(sourceId[0])]
                mykeylst += [str(tplId[0])]
                mykeystr = string.join(mykeylst,"");
                fields = []
                fieldNb = struct.unpack('<H', flow[12:14])
                for i in range(0, fieldNb[0]):
                    fd = struct.unpack('<H',flow[14+(i*4):16+(i*4)])
                    tp = struct.unpack('<H',flow[14+(2+i*4):16+(2+i*4)])
                    fields.insert(i,(fd[0],tp[0]))
                tpl_def[mykeystr] = fields
                return ( None, None)
            if (code[0]==11): ## a data packet
                routerSrc = struct.unpack('<L', flow[4:8])
                tmp =  struct.unpack('<L', flow[4:8])
                fromRouter = socket.inet_ntoa(struct.pack('>L', tmp[0]))
                sourceId = struct.unpack('<L', flow[8:12])
                tplId = struct.unpack('<H', flow[12:14])
                mykeylst = []
                mykeylst += [str(routerSrc[0])]
                mykeylst += [str(sourceId[0])]
                mykeylst += [str(tplId[0])]
                mykeystr = string.join(mykeylst,"")
                if (tpl_def.has_key(mykeystr)== True):
                    field_list = []
                    index = 0
                    for i in range (0, len(tpl_def[mykeystr])):
                        if (tpl_def[mykeystr][i][1]==1):
                            value = struct.unpack('<B',flow[14+index:15+index])
                            field_list.insert(i,value[0])
                        if (tpl_def[mykeystr][i][1]==2):
                            value = struct.unpack('>H',flow[14+index:16+index])
                            field_list.insert(i,value[0])
                        if (tpl_def[mykeystr][i][1]==3):
                            value = struct.unpack('<BBB',flow[14+index:17+index])
                            valueTmp = struct.pack('<BBBB',value[2],value[1],value[0],0)
                            valueFinal = struct.unpack('<L', valueTmp)
                            valueFinal2 = (valueFinal[0])>>4
                            field_list.insert(i,valueFinal2)
                        if (tpl_def[mykeystr][i][1]==4):
                            if (tpl_def[mykeystr][i][0]==8 or tpl_def[mykeystr][i][0]==12 or tpl_def[mykeystr][i][0]==15 or tpl_def[mykeystr][i][0]==18 or tpl_def[mykeystr][i][0]==47):
                                value = socket.inet_ntoa(flow[14+index:18+index])
                                field_list.insert(i,value)
                            else:
                                value = struct.unpack('<L', flow[14+index:18+index])
                                value = struct.unpack('>L', flow[14+index:18+index])
                                field_list.insert(i,value[0])
                        if (tpl_def[mykeystr][i][1]==16):
                            if (os_type==1):
                                field_list.insert(i,nt_inet_ntop(flow[14+index:30+index]))
                            else:
                                tmp = socket.inet_ntop(socket.AF_INET6,flow[14+index:30+index])
                                field_list.insert(i,tmp)
                        index += tpl_def[mykeystr][i][1]
                    return mykeystr, field_list 
##                else:
##                  print "I'm waiting the tpl def for the key", mykeystr
##                return (routerSrc[0], field_list)
            return ( None, None)
        return ( None, None)

    def socket_close(self):
        if self.socketnumber:
           try :
               self.socketnumber.shutdown(2)
               self.socketnumber = None
           except socket.error:
              pass

class FileSel:
    def file_ok_sel(self, w):
        global record, record_file, record_file_name
        record = 1
        record_file_name = self.fileSel.get_filename()
        record_file = file(record_file_name, 'w')
        print "%s" % self.fileSel.get_filename()
        self.fileSel.destroy()

    def destroy(self, widget):
        self.fileSel.destroy()

    def __init__(self):
        self.fileSel = gtk.FileSelection("File Selection")
        self.fileSel.connect("destroy", self.destroy)
        self.fileSel.ok_button.connect("clicked", self.file_ok_sel)
        self.fileSel.cancel_button.connect("clicked",
                                           lambda w: self.fileSel.destroy())
        self.fileSel.set_filename("flow_record.txt")
        self.fileSel.show()

def print_hello(widget, event):
    print "Hello, World!"

def nt_inet_ntop(packed_ip):
    cpt = 0
    double = 0
    string_ip = ""
    tmp = binascii.hexlify(packed_ip[0:2])
    if ( int(tmp,16)!=0 ):
        string_ip += tmp
        tmp = binascii.hexlify(packed_ip[2:4])
        if ( int(tmp,16)==0 ):
            cpt+=1
            double = 1
            if (cpt==1):
                string_ip += ":"
        else:
            cpt=0
            string_ip += ":"+tmp
        tmp = binascii.hexlify(packed_ip[4:6])
        if ( int(tmp,16)==0 ):
            cpt+=1
            double = 1
            if (cpt==1):
                string_ip += ":"
        else:
            cpt=0
            string_ip += ":"+tmp
        tmp = binascii.hexlify(packed_ip[6:8])
        if ( int(tmp,16)==0 ):
            if (double==1 and cpt==0):
                string_ip += ":0"
            else:
                cpt+=1
                double = 1
                if (cpt==1):
                    string_ip += ":"
        else:
            cpt=0
            string_ip += ":"+tmp
        tmp = binascii.hexlify(packed_ip[8:10])
        if ( int(tmp,16)==0 ):
            if (double==1 and cpt==0):
                string_ip += ":0"
            else:
                cpt+=1
                double = 1
                if (cpt==1):
                    string_ip += ":"
        else:
            cpt=0
            string_ip += ":"+tmp
        tmp = binascii.hexlify(packed_ip[10:12])
        if ( int(tmp,16)==0 ):
            if (double==1 and cpt==0):
                string_ip += ":0"
            else:
                cpt+=1
                double = 1
                if (cpt==1):
                    string_ip += ":"
        else:
            cpt=0
            string_ip += ":"+tmp
        tmp = binascii.hexlify(packed_ip[12:14])
        if ( int(tmp,16)==0 ):
            if (double==1 and cpt==0):
                string_ip += ":0"
            else:
                cpt+=1
                double = 1
                if (cpt==1):
                    string_ip += ":"
        else:
            cpt=0
            string_ip += ":"+tmp
        tmp = binascii.hexlify(packed_ip[14:16])
        if ( int(tmp,16) != 0 ):
            string_ip += ":"+tmp
        else:
            string_ip += ":"
    else:
        string_ip = "::"
    return string_ip

def get_main_menu(self, window):
    accel_group = gtk.AccelGroup()
    item_factory = gtk.ItemFactory(gtk.MenuBar, "<main>", accel_group)
    item_factory.create_items(menu_items)
    window.add_accel_group(accel_group)
    item_factory = item_factory
    return item_factory.get_widget("<main>")

def reception(widget, event):
    global myInputControlThread
    global localAddr, localPort
    myInputControlThread = InputControl(localAddr, localPort)
    myInputControlThread.start()

def close_recept(widget, event):
    global myInputControlThread
    if myInputControlThread != None:
        myInputControlThread.kill(1)
        myInputControlThread = None
        print "\n\n\n\n\n Input Stream closed. \n\n\n\n\n"

def about_dialog(widget, event):
    dialog = gtk.MessageDialog(
        parent         = None,
        flags          = gtk.DIALOG_MODAL,
        type           = gtk.MESSAGE_INFO,
        buttons        = gtk.BUTTONS_OK,
        message_format = "Author : FX Andreu\nemail andreu@renater.fr\nCopyright (C) 2005-2008 GIP RENATER\n\nThis file is part of renetcol.\n\nrenetcol is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\n\nrenetcol is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with renetcol; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA ") 
    dialog.set_title('About')
    dialog.connect('response', lambda dialog, response: dialog.destroy())
    dialog.show()

def check_dialog(widget, event, text):
    dialog = gtk.MessageDialog(
        parent         = None,
        flags          = gtk.DIALOG_MODAL,
        type           = gtk.MESSAGE_INFO,
        buttons        = gtk.BUTTONS_OK,
        message_format = text) 
    dialog.set_title('Value check ')
    dialog.connect('response', lambda dialog, response: dialog.destroy())
    dialog.show()

def info_dialog(widget, event, text):
    dialog = gtk.MessageDialog(
        parent         = None,
        flags          = gtk.DIALOG_MODAL,
        type           = gtk.MESSAGE_INFO,
        buttons        = gtk.BUTTONS_OK,
        message_format = text) 
    dialog.set_title('Information ')
    dialog.connect('response', lambda dialog, response: dialog.destroy())
    dialog.show()

def callback_freeze(widget, data=None):
    global freeze
    if widget.get_active() == 1:
        freeze = 1
        print "FREEZE ACTIF"
    if widget.get_active() == 0:
        freeze = 0
        print "FREEZE NOT ACTIF"

def wind_destroy(widget, data=None):
    widget.destroy()
    
def callback_record(widget, data=None):
    global record, record_file, record_file_name
    if widget.get_active() == 1:
        FileSel()
    if widget.get_active() == 0:
        record = 0
        time.sleep(2)
        record_file.close()

def strsend(target, message):
   global collectorAddr, collectorPort
   s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
   s.connect((collectorAddr, collectorPort))
   s.send(message)
   s.close()

def callback_refresh(widget, parent):
    global collectorAddr
    strsend(collectorAddr, 'REFRESH')
    parent.destroy()
    
def callback_delete_rule(widget, parent):
    global collectorAddr, collectorPort
    if widget.get_active() == 1:
        sent_rule(widget, "DELETE")
        widget.set_active(0)
        parent.destroy()

def callback_check_rule(widget, data=None):
    global router
    if widget.get_active()==1:
        router=1

def timer_action():
    global record_file, record_file_name, myTimer, myCPT
    myCPT+=1
    myTimer.cancel()
    my_new_file_name = "%s_%s_%d" % (record_file_name,time.strftime("%Y%m%d", time.gmtime()),myCPT)
    ##my_new_file_name = "%s_%d" % (record_file_name,myCPT)
    print my_new_file_name
    new_record_file = file(my_new_file_name, 'w')
    old_record_file = record_file
    record_file = new_record_file
    old_record_file.close()
    now2 = time.time()
    reste = 300-(operator.mod(now2,300))
    myTimer = threading.Timer(300.0,timer_action)
    myTimer.start()

def callback_RotRec(widget, data=None):
    global record, myTimer
    if ((record == 0) and (widget.get_active() == 1)):
        info_dialog(widget, None, "You must before activated the record ! ")
        widget.set_active(0)
    else:
        if widget.get_active() == 1:
            print "STARTING RECORD ROTATION"
            now2 = time.time()
            reste = 300-(operator.mod(now2,300))
            myTimer = threading.Timer(300,timer_action)
            myTimer.start()
        if widget.get_active() == 0:
            myTimer.cancel()
            print "STOPPING RECORD ROTATION"

def callback_collector(widget, controlWindow):
    global is_already_see, collectorRule, myInputControlThread, coll_window, collectorAddr
    if ((myInputControlThread == None) and (widget.get_active() == 1)):
        info_dialog(widget, None, "You must before activated the stream reception ! (File menu)")
        widget.set_active(0)
    else:
        if widget.get_active() == 1:
            widget.set_active(0)
            coll_window.connect("destroy", wind_destroy)
            coll_window.set_title("Collector control ")
            coll_window.set_size_request(500, 250)
            coll_vbox = gtk.VBox(False, 1)
            coll_vbox.set_border_width(1)
            coll_window.add(coll_vbox)
            coll_frame = gtk.Frame("Enter your filter (format described in tip), validate by enter")
            coll_vbox.pack_start(coll_frame, False, False, 5)
            coll_hbox = gtk.VBox(False, 0)
            coll_hbox.set_border_width(5)
            coll_frame.add(coll_hbox)
##            button = gtk.CheckButton(" router ")
##            button.connect("toggled", callback_check_rule, None)
##            coll_hbox.pack_start(button, False, False, 0)
##            mainTT.set_tip(button, "Check it to capture all flows from one router and enter the IPv4 address of this router. IN TEST")
##            button.show()
            coll_pbbox = gtk.HButtonBox()
            coll_hbox.pack_start(coll_pbbox, False, True, 5)
            prefix_entry(249, "Required Format : \n<field> = <value>[ & <field> = <value>]\
            \nlike \
            \n8 = 10.0.0.4 \
            \n\t(all flows from IP Source 10.0.0.4)\
            \nor 8 = 10.0.1.0/24 \
            \n\t(all flows with IP Source in subnet 10.0.1.0/24)\
            \nor 27 = 2001::1 (IPv6 address only on Linux system)\
            \n\t(all flows from IP Source 2001::1)\
            \nor 27 = 2001::/64 \
            \n\t(all flows with IP Source in subnet 2001::/64)\
            \nor 0 = 10.0.0.1 & 4 = 1\
            \n\t(all ICMP flows from router 10.0.0.1)\
            \nonly equal operator in this release\
            \nmaximum 4 logical '&' for one filter (limit 249 chars)\
            \n----------------------------------\
            \n---- NetFlow Fields list ------\
            \nROUTER_SRC_ADDR:\t 0\
            \nIN_BYTES:\t\t\t 1\
            \nL4_PROT:\t\t\t 4\
            \nL4_SRC_PORT:\t\t 7\
            \nIPV4_SRC_ADDR:\t\t 8\
            \nINPUT_SNMP:\t\t\t10\
            \nL4_DST_PORT:\t\t11\
            \nIPV4_DST_ADDR:\t\t12\
            \nOUTPUT_SNMP:\t\t14\
            \nIPV4_NEXT_HOP:\t\t15\
            \nSRC_AS:\t\t\t\t16\
            \nDST_AS:\t\t\t\t17\
            \nBGP_IPV4_NEXT_HOP:\t18\
            \nIPV6_SRC_ADDR:\t\t27\
            \nIPV6_DST_ADDR:\t\t28\
            \nIPV6_NEXT_HOP:\t\t62\
            \nBPG_IPV6_NEXT_HOP:\t63\
            \nIP_PROT_VERSION:\t60\
            \n---------------------------", coll_pbbox, "", 0)
            coll_frame2 = gtk.Frame("Disable rules")
            coll_vbox.pack_start(coll_frame2, False, False, 5)
            coll_hbox2 = gtk.VBox(False, 0)
            coll_hbox2.set_border_width(5)
            coll_frame2.add(coll_hbox2)
            coll_pbbox2 = gtk.HButtonBox()
            coll_hbox2.pack_start(coll_pbbox2, False, True, 5)
            buttondelete = gtk.ToggleButton("Delete")
            buttondelete.connect("toggled", callback_delete_rule, coll_window)
            mainTT.set_tip(buttondelete, "Delete all your rules of the collector configuration.")
            coll_hbox2.pack_start(buttondelete, False, False, 2)
            buttondelete.show()
            coll_vbox.show()
            coll_window.show_all()
            if (is_already_see==0):
                info_dialog(widget, None, "You should register only one rule for each GUI parser ! Think of using the DELETE button !")
                is_already_see=1

def callback_fields_printed( widget, data=None):
    global printValue
    printValue[data] = widget.get_active()
    if (data==16):
        printValue[29] = widget.get_active()
    if (data==17):
        printValue[30] = widget.get_active()

def callback_check_ip( widget, data=None):
    global src_Or_Dst_IP
    if widget.get_active()==1:
        if checkUpValues[1]:
            src_Or_Dst_IP = 1
        else:
            widget.set_active(0)
            check_dialog(widget, None, "First, enter a source address.")
    else:
            src_Or_Dst_IP = 0

def callback_comboR(widget, data=None):
    global comboRouter, routerHash
    nop = 0
    print struct.unpack('>L',socket.inet_aton(routerHash[comboRouter.entry.get_text()]))
    
def callback_src_mask(widget, data=None):
    nop = 0

def callback_dst_mask(widget, data=None):
    nop = 0

def callback_tos(widget, data=None):
    nop = 0

def callback_prot(widget, data=None):
    nop = 0

def create_button(title, state, callback_function, ptr_var, parent, tooltip_Text):
    global mainTT
    button = gtk.ToggleButton(title)
    if state==1:
        button.set_active(True)
    else:
        button.set_active(False)
    button.connect("toggled", callback_function, ptr_var)
    if tooltip_Text!=None:
        mainTT.set_tip(button, tooltip_Text)
    parent.pack_start(button, False, True, 2)
    button.show()

def create_entry(maxLen, tooltip_Text, parent, lab, id):
    global mainTT
    vbox = gtk.VBox(False, 0)
    parent.pack_start(vbox, False, True, 0)
    label = gtk.Label(lab)
    label.set_alignment(0, 0.5)
    vbox.pack_start(label, False, True, 0)
    entry = gtk.Entry(max=maxLen)
    entry.set_max_length(maxLen)
    entry.connect("activate", enter_callback, entry, id)
    entry.set_text("")
    entry.select_region(0, len(entry.get_text()))
    if tooltip_Text!=None:
        mainTT.set_tip(entry, tooltip_Text)
    vbox.pack_start(entry, False, True, 0)
    entry.show()

def sent_rule(widget, msg):
    global collectorAddr, collectorPort, collectorAddr6, IPversion
    s = None
    if (IPversion==4):
        tmpaf =  socket.AF_INET
        addr = collectorAddr
        port = collectorPort
    elif (IPversion == 6):
        tmpaf =  socket.AF_INET6
        addr = collectorAddr6
        port = collectorPort
    else:
        print "Wrong IP version : ", IPversion
        exit(0)
    for res in socket.getaddrinfo(addr, port, tmpaf, socket.SOCK_STREAM):
        af, socktype, proto, canonname, sa = res
        try:
            s = socket.socket(af, socktype, proto)
        except socket.error, msg:
            s = None
            continue
        try:
            s.connect(sa)
        except socket.error, msg:
            s.close()
            s = None
            continue
        break
    if s is None:
        check_dialog( widget, None, "could not open socket")
    else:
        s.send(msg)
        check_dialog( widget, None, "Action was sent")
        s.close()

def sent_rule_from_cli(msg):
    global collectorAddr, collectorPort, collectorAddr6, IPversion
    s = None
    if (IPversion==4):
        tmpaf =  socket.AF_INET
        addr = collectorAddr
        port = collectorPort
    elif (IPversion == 6):
        tmpaf =  socket.AF_INET6
        addr = collectorAddr6
        port = collectorPort
    else:
        print "Wrong IP version : ", IPversion
        exit(0)
    for res in socket.getaddrinfo(addr, port, tmpaf, socket.SOCK_STREAM):
        af, socktype, proto, canonname, sa = res
        try:
            s = socket.socket(af, socktype, proto)
        except socket.error, msg:
            s = None
            continue
        try:
            s.connect(sa)
        except socket.error, msg:
            s.close()
            s = None
            continue
        break
    if s is None:
        check_dialog( None, None, "could not open socket")
    else:
        s.send(msg)
        check_dialog( None, None, "Action was sent")
        s.close()

# dialog box to collector control
def prefix_callback( widget, entry, id):
    global collPrefix, coll_window, router, localPort
    entry_text = entry.get_text()
    is_good = 0
    mymsg = []
    if (id == 0):
        if ( entry_text==""):
            collPrefix = 0
        else:
            ## here we parse the filter, possibility of many filter concatened with '&' operator
            filters = entry_text.split('&')
            if len(filters)>5:
                check_dialog( widget, None, "No more 4 '&' !")
                is_ok = 0
            else:
                is_ok = 1
                for f in filters:
                    rule = f.split(' ')
                    if len(mymsg)==0:
                        field = rule[0]
                        operator = rule[1]
                        value = rule[2]
                        mymsg = "C" + "_" + field + "_" + operator + "_" + value
                    else:
                        field = rule[1]
                        operator = rule[2]
                        value = rule[3]                        
                        mymsg += "_C" + "_" + field + "_" + operator + "_" + value
                    print f
                    print mymsg
                    if (field=='0' or field=='8' or field=='12' or field=='15' or field=='18' or field=='47'):
                        if (re.match('^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(/\d{1,2})?$',value)):
                            splitter = value.split('/')
                            adip = struct.unpack('>L',socket.inet_aton(splitter[0]))[0]
                            if len(splitter)>1:
                                bits = int(splitter[1])
                                if bits <= 32 and bits > 0:
                                    mask[1] = 0xffffffffL << (32 - bits)
                                    is_good = 1
                                else:
                                    check_dialog( widget, None, "Wrong value in mask!")
                                    is_good = 0
                            else:
                                value = value+"/32"
                                mask[1] = 0xffffffffL
                                is_good = 1
                        else:
                            check_dialog( widget, None, "Wrong value !")
                    if (field=='27' or field=='28' or field=='62'):
                        ipv6ad_mask = value.split('/')
                        if len(ipv6ad_mask)==1:
                            try:
                                socket.gethostbyaddr(value)
                                is_good = 1
                            except socket.gaierror:
                                check_dialog( widget, None, "Wrong value !")
                            except socket.herror: ## can't resolv 
                                check_dialog( widget, None, "I can't resolv !")
                            except socket.error:
                                check_dialog( widget, None, "Error in gethostbyaddr()!")
                        else:
                            is_good = 1
                    ##here, check the prefix value?
                    if (field=='60' or field=='46'):
                        if (int(value) < 256):
                            is_good = 1
                        else:
                            check_dialog( widget, None, "Wrong value, must be < 256 !")
                            is_good = 0
                    if (field=='1'):
                        if (int(value) < 4294967295):
                            is_good = 1
                        else:
                            check_dialog( widget, None, "Wrong value, must be < 4294967295 !")
                            is_good = 0
                    if (field=='7' or field=='11' or field=='4'):
                        if (int(value) < 65536):
                            is_good = 1
                        else:
                            check_dialog( widget, None, "Wrong value, must be < 65536 !")
                            is_good = 0
                    if (field=='10' or field=='14' or field=='16' or field=='17'):
                        if (int(value) < 65536):
                            is_good = 1
                        else:
                            check_dialog( widget, None, "Wrong value, must be < 65536 !")
                            is_good = 0
            if (is_good==1 and is_ok==1):
                ##collPrefix = adip & mask[1]
                ## Here tcp exchange between collector & client
                ##msg = str(localPort) +" "+ field +" "+ operator+" "+ value
                msg = str(localPort) + " " + mymsg
                print msg
                sent_rule(widget, msg)
                widget.set_editable(False)
                coll_window.destroy()
    else:
        check_dialog( widget, None, "Internal program error ;) !")

# collector control button
def prefix_entry(maxLen, tooltip_Text, parent, lab, id):
    global mainTT
    vbox = gtk.VBox(False, 0)
    parent.pack_start(vbox, False, True, 0)
    label = gtk.Label(lab)
    label.set_alignment(0, 0.5)
    vbox.pack_start(label, False, True, 0)
    entry = gtk.Entry(max=maxLen)
    entry.set_max_length(maxLen)
    entry.connect("activate", prefix_callback, entry, id)
    entry.set_text("")
    entry.select_region(0, len(entry.get_text()))
    if tooltip_Text!=None:
        mainTT.set_tip(entry, tooltip_Text)
    vbox.pack_start(entry, False, True, 0)
    entry.show()

def user_quit(widget, data=None):
    global myInputControlThread, localPort, record_file, myTimer
    if myInputControlThread != None:
        myInputControlThread.kill(1)
        myInputControlThread = None
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(('localhost', localPort))
        s.send("FIN")
        s.close()
        if (record_file!=None):
            record_file.close()
        sent_rule_from_cli("DELETE")
        print "\n\n\n\n\n Input Stream closed. \n\n\n\n\n Bye :-) \n\n\n\n"
    if (myTimer != None):
        myTimer.cancel()
    gtk.main_quit()

# Flow Selection
def enter_callback( widget, entry, id):
    global firstParseValue
    entry_text = entry.get_text()
    if id == 0:
        if (entry_text==""):
            checkUpValues[0] = 0
        else: 
            if (re.search('\D',entry_text)) or (int(entry_text) >= 99) or (int(entry_text) <= 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[0] = int(entry_text)
                checkUpValues[0] = 1
    if id == 1:
        if ( entry_text==""):
            checkUpValues[8] = 0
            checkUpValues[12] = 0
            checkUpValues[27] = 0 ## ticket #6
            checkUpValues[28] = 0 ## ticket #6
        else:
            if (re.match('^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(/\d{1,2})?$',entry_text)):
                splitter = entry_text.split('/')
                adip = struct.unpack('>L',socket.inet_aton(splitter[0]))[0]
                if len(splitter)>1:
                    bits = int(splitter[1])
                    if bits <= 32 and bits > 0:
                        mask[0] = 0xffffffffL << (32 - bits)
                    else:
                        check_dialog( widget, None, "Wrong value in mask!")
                else:
                    mask[0] = 0xffffffffL
                firstParseValue[8] = adip & mask[0]
                checkUpValues[8] = 1
                firstParseValue[12] = adip & mask[0]
                checkUpValues[12] = 1
                firstParseValue[27] = 0x00000000L ## ticket #6
                firstParseValue[28] = 0x00000000L ## ticket #6
                checkUpValues[27] = 1 ## ticket #6
                checkUpValues[28] = 1 ## ticket #6
            else:
                check_dialog( widget, None, "Wrong value !")
    if id == 2:
        if ( entry_text==""):
            checkUpValues[2] = 0
        else:
            check_dialog( widget, None, "NOT YET IMPLEMEMTED")
            ## pb with IPv6 and getaddrinfo() ??
##            splitter = entry_text.split('/')
##            try:
##                socket.gethostbyaddr(splitter[0])
##            except socket.gaierror:
##                check_dialog( widget, None, "Wrong value !")
##            except socket.herror: ## can't resolv 
##                pass
##            except socket.error:
##                pass
    if id == 3:
        if ( entry_text==""):
            checkUpValues[15] = 0
        else:
            if (re.match('^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(/\d{1,2})?$',entry_text)):
                splitter = entry_text.split('/')
                adip = struct.unpack('>L',socket.inet_aton(splitter[0]))[0]
                if len(splitter)>1:
                    bits = int(splitter[1])
                    if bits <= 32 and bits > 0:
                        mask[2] = 0xffffffffL << (32 - bits)
                    else:
                        check_dialog( widget, None, "Wrong value in mask!")
                else:
                    mask[2] = 0xffffffffL
                firstParseValue[15] = adip & mask[2]
                checkUpValues[15] = 1
            else:
                check_dialog( widget, None, "Wrong value !")
    if id == 4: ## In|Out
        if ( entry_text==""):
            checkUpValues[10] = 0
            checkUpValues[14] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 65535) or (int(entry_text) < 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[10] = int(entry_text)
                checkUpValues[10] = 1
                firstParseValue[14] = int(entry_text)
                checkUpValues[14] = 1
    if id == 6: ## bytes
        if ( entry_text==""):
            checkUpValues[1] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 999999999) or (int(entry_text) <= 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[1] = int(entry_text)
                if ( int(entry_text) == 0 ):
                    firstParseValue[1] = 1000000000
                else:
                    firstParseValue[1] = int(entry_text)
                checkUpValues[1] = 1
    if id == 7: ## pkts
        if ( entry_text==""):
            checkUpValues[2] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 9999) or (int(entry_text) <= 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[2] = int(entry_text)
                checkUpValues[2] = 1
    if id == 8: ## time no concordance with nfv9 field number
        if ( entry_text==""):
            checkUpValues[0] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 99) or (int(entry_text) < 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[0] = int(entry_text)
                checkUpValues[0] = 1
    if id == 9: ## port range
        if ( entry_text==""):
            checkUpValues[7] = 0
        else:
            port_list = string.split(entry_text)
            if (len(port_list)!=2)or((re.search('\D',port_list[0])) or (int(port_list[0]) > 65535) or (int(port_list[0]) <= 0) or (re.search('\D',port_list[1])) or (int(port_list[1]) > 65535) or (int(port_list[1]) <= 0)):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[7] = int(port_list[0])
                firstParseValue[11] = int(port_list[1])
                checkUpValues[7] = 1
    if id == 11: ## tcp flags
        if ( entry_text==""):
            checkUpValues[6] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 255) or (int(entry_text) <= 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[6] = int(entry_text)
                checkUpValues[6] = 1
    if id == 12: ## prot
        if ( entry_text==""):
            checkUpValues[4] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 255) or (int(entry_text) <= 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[4] = int(entry_text)
                checkUpValues[4] = 1
    if id == 13: ## tos
        if ( entry_text==""):
            checkUpValues[5] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 255) or (int(entry_text) < 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[5] = int(entry_text)
                checkUpValues[5] = 1
    if id == 14: ## src AS
        if ( entry_text==""):
            checkUpValues[16] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 65535) or (int(entry_text) < 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[16] = int(entry_text)
                checkUpValues[16] = 1
    if id == 15: ## dst AS
        if ( entry_text==""):
            checkUpValues[17] = 0
        else:
            if (re.search('\D',entry_text)) or (int(entry_text) > 65535) or (int(entry_text) < 0):
                check_dialog( widget, None, "Wrong value !")
            else:
                firstParseValue[17] = int(entry_text)
                checkUpValues[17] = 1
    if id == 18: ## from router
        if ( entry_text==""):
            checkUpValues[69] = 0
        else:
            if (re.match('^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(/\d{1,2})?$',entry_text)):
                splitter = entry_text.split('/')
                adip = struct.unpack('>L',socket.inet_aton(splitter[0]))[0]
                if len(splitter)>1:
                    bits = int(splitter[1])
                    if bits <= 32 and bits > 0:
                        mask[0] = 0xffffffffL << (32 - bits)
                    else:
                        check_dialog( widget, None, "Wrong value in mask!")
                else:
                    mask[0] = 0xffffffffL
                firstParseValue[69] = splitter[0]
                checkUpValues[69] = 1
            else:
                check_dialog( widget, None, "Wrong value !")
    
if __name__ == "__main__":
    global window, mainTT, comboRouter, os_type, printShit
    global localAddr, localPort
    
    gtk.gdk.threads_init()
    
    if (os.name =="nt"):
        os_type = 1
    elif (os.name =="posix"):
        os_type = 0
    else:
        os_type = 3

    parser = OptionParser()
    parser.add_option("-r", "--router", dest="rtr", help ="router address used for NetFlow data export")
    parser.add_option("-i", "--index", dest="ind", help ="Interface index get with snmpwalk")
    (options, args) = parser.parse_args()
    rtr = options.rtr
    ind = options.ind

    if len(sys.argv)==5:
        myInputControlThread = InputControl(localAddr, localPort)
        myInputControlThread.start()
        msg = str(localPort) + " C_0_=_" + rtr + "/32_C_10_=_" + ind
        print msg
        sent_rule_from_cli(msg)
        
    print "---------------------------------------------------------------"
    print "In this version, you can only apply rules on the collector based on the following fields:"
    print "IN_BYTES: 1,"
    print "L4_PROT: 4,"
    print "L4_SRC_PORT: 7,"
    print "IPV4_SRC_ADDR: 8,"
    print "INPUT_SNMP: 10,"
    print "L4_DST_PORT: 11,"
    print "IPV4_DST_ADDR: 12,"
    print "OUTPUT_SNMP: 14,"
    print "IPV4_NEXT_HOP: 15,"
    print "SRC_AS: 16,"
    print "DST_AS: 17,"
    print "BGP_IPV4_NEXT_HOP: 18,"
    print "IPV6_SRC_ADDR: 27,"
    print "IPV6_DST_ADDR: 28,"
    print "MPLS_TOP_LABEL_TYPE: 46,"
    print "IPV6_NEXT_HOP: 62,"
    print "BPG_IPV6_NEXT_HOP: 63,"
    print "IP_PROTOCOL_VERSION: 60, please note that the IPv4 templates don't have this field"
    print "ROUTER_SRC_ADDR: 0, !!! it's not a real number for a field, but it's a great function"
    print "----------------------------------------------------------------"
    
    mainTT = gtk.Tooltips()
    window = gtk.Window(gtk.WINDOW_TOPLEVEL)    
    window.connect("destroy", gtk.main_quit, "WM destroy")
    window.set_title("RenetcolGUI")
    window.set_size_request(850, 550)
    
    main_vbox = gtk.VBox(False, 1)
    main_vbox.set_border_width(1)
    window.add(main_vbox)

##  menu
    file_menu = gtk.Menu()
    receive_item = gtk.MenuItem("Receive Stream")
    stop_item = gtk.MenuItem("Stop Stream")
    quit_item  = gtk.MenuItem("Quit")
    file_menu.append(receive_item)
    file_menu.append(stop_item)
    file_menu.append(quit_item)
    receive_item.connect("activate", reception, None)
    stop_item.connect("activate", close_recept, None)
    quit_item.connect("activate", user_quit, None)
    receive_item.show()
    stop_item.show()
    quit_item.show()

    help_menu = gtk.Menu()
    about_item = gtk.MenuItem("About")
    help_menu.append(about_item)
    about_item.connect("activate", about_dialog, None)
    about_item.show()

    menu_bar = gtk.MenuBar()
    main_vbox.pack_start(menu_bar, False, False, 0)
    menu_bar.show()
    file_item = gtk.MenuItem("File")
    file_item.show()
    help_item = gtk.MenuItem("Help")
    help_item.show()

    file_item.set_submenu(file_menu)
    menu_bar.append(file_item)
    menu_bar.append(file_menu)
    file_item.set_right_justified(0)

    help_item.set_submenu(help_menu)
    menu_bar.append(help_item)
    menu_bar.append(help_menu)
    help_item.set_right_justified(1)

##  first frame
    frame = gtk.Frame("Input Stream Control")
    main_vbox.pack_start(frame, False, True, 0)
    hbox = gtk.HBox(False, 0)
    hbox.set_border_width(5)
    frame.add(hbox)

    ## freeze button
    buttonfreeze = gtk.ToggleButton("Freeze")
    buttonfreeze.connect("toggled", callback_freeze, None)
    mainTT.set_tip(buttonfreeze, "Stop/Start the output in the window.")
    hbox.pack_start(buttonfreeze, False, False, 2)
    buttonfreeze.show()
    ## record button
    buttonrecord = gtk.ToggleButton("Record")
    buttonrecord.connect("toggled", callback_record, None)
    mainTT.set_tip(buttonrecord, "Stop/Start the record in a text file.")
    hbox.pack_start(buttonrecord, False, False, 2)
    buttonrecord.show()
    ## incremental record
    buttonRotRec = gtk.ToggleButton("Rot. Record")
    buttonRotRec.connect("toggled", callback_RotRec, None)
    mainTT.set_tip(buttonRotRec, "Stop/Start the record in a different file for each day.")
    hbox.pack_start(buttonRotRec, False, False, 2)
    buttonRotRec.show()
    ## control collector button
    buttoncollector = gtk.ToggleButton("Collector Control")
    buttoncollector.connect("toggled", callback_collector, None)
    mainTT.set_tip(buttoncollector, "Change the rule which is applied on the collector. You must have activated the input stream before.")
    hbox.pack_start(buttoncollector, False, False, 2)
    buttoncollector.show()

    ipv4_vbox = gtk.VBox(False, 1)
    ipv4_vbox.set_border_width(1)
    main_vbox.add(ipv4_vbox)
##  second frame 
    frame = gtk.Frame("Select printed fields")
    ipv4_vbox.pack_start(frame, False, False, 0)
    
    vbox = gtk.VBox(False, 0)
    vbox.set_border_width(5)
    frame.add(vbox)
    bbox = gtk.HButtonBox()
    vbox.pack_start(bbox, False, True, 5)
    
    create_button("Src \n IP", 1, callback_fields_printed, 8, bbox, "Source IP")
    create_button("Dst\n IP", 1, callback_fields_printed, 12, bbox, "Destination IP")
    create_button("Flw\n IP", 0, callback_fields_printed, 15, bbox, "Following IP")
    create_button("Index\n In", 0, callback_fields_printed, 10, bbox, "SNMP Index Input")
    create_button("Index\n Out", 0, callback_fields_printed, 14, bbox, "SNMP Index Output")
    create_button("Size (P)", 1, callback_fields_printed, 2, bbox, "Packets number")
    create_button("Size (B)", 1, callback_fields_printed, 1, bbox, "Size in Bytes")
    create_button("Time", 0, callback_fields_printed, 0, bbox, "Age of flow")

    b2box = gtk.HButtonBox()
    vbox.pack_start(b2box, False, True, 5)
    create_button("Src\n Port", 1, callback_fields_printed, 7, b2box, "TCP/UDP source port")
    create_button("Dst\n Port", 1, callback_fields_printed, 11, b2box, "TCP/UDP destination port")
    create_button("TCP\n Flags", 0, callback_fields_printed, 6, b2box, "TCP Flags")
    create_button("Prot", 1, callback_fields_printed, 4, b2box, "Protocol")
    create_button("Tos", 0, callback_fields_printed, 5, b2box, "Type of service")
    create_button("Src\nAs", 0, callback_fields_printed, 16, b2box, "Source AS")
    create_button("Dst\nAs", 0, callback_fields_printed, 17, b2box, "Destination AS")
    create_button("Src\nMask", 0, callback_fields_printed, 9, b2box, "Source Mask")
    create_button("Dst\nMask", 0, callback_fields_printed, 13, b2box, "Destination Mask")

    b3box = gtk.HButtonBox()
    vbox.pack_start(b3box, False, True, 5)
    create_button("Router", 0, callback_fields_printed, 69, b3box, "Router address")

##  third frame 
    frame = gtk.Frame("Parsing values")
    ipv4_vbox.pack_start(frame, False, False, 5)
    hbox = gtk.VBox(False, 0)
    hbox.set_border_width(5)
    frame.add(hbox)
    pbbox = gtk.HButtonBox()
    hbox.pack_start(pbbox, False, True, 5)
##  here entry button
    create_entry(18, "Required Format : \n an IPv4 address like x.x.x.x \n or a network address like x.x.x.x/x", pbbox, "IPv4 address :", 1)
    create_entry(39, "Required Format : \n an IPv6 address like x:x:x:x:x::x \n or a network address like x:x:x/x NOT YET SUPPORTED", pbbox, "(IPv6 address :)", 2)
    create_entry(18, "Required Format : \n an IP address like x.x.x.x \n or a network address like x.x.x.x/x", pbbox, "Flw IP ad. :", 3)
    dbbox = gtk.HButtonBox()
    hbox.pack_start(dbbox, False, True, 5)
    create_entry(5, "Required Format : a number less than 65535", dbbox, "SNMP Index In|Out :", 4)
    create_entry(4, "Required Format : a number less than 9999", dbbox, "Packet NB :", 7)
    create_entry(17, "Required Format : a number less than 999999999, each flow who the size equal this number +/- 5%", dbbox, "Bytes :", 6)
    tbbox = gtk.HButtonBox()
    hbox.pack_start(tbbox, False, True, 5)
    create_entry(2, "Required Format : a number less than 99", tbbox, "Time :", 8)
    create_entry(11, "Required Format : a range, each number less than 65535 and space as separator: \"6881 6889\"", tbbox, "Port :", 9)
    #create_entry(5, "Required Format : a number less than 65535", tbbox, "Dst port :", 10)
    create_entry(3, "Required Format : a number less than 255", tbbox, "TCP Flag :", 11)
    fbbox = gtk.HButtonBox()
    hbox.pack_start(fbbox, False, True, 5)
    create_entry(5, "Required Format : a number less than 65535", fbbox, "Protocol :", 12)
    create_entry(3, "Required Format : a number less than 255", fbbox, "ToS :", 13)
    create_entry(5, "Required Format : a number less than 65535", fbbox, "Src AS :", 14)
    create_entry(5, "Required Format : a number less than 65535", fbbox, "Dst AS :", 15)
    kbbox = gtk.HButtonBox()
    hbox.pack_start(kbbox, False, True, 5)
    create_entry(18, "Required Format : \n an IP address like x.x.x.x or x.x.x.x/x", kbbox, "The flows sending by this Router :", 18)

##  Show
    vbox.show()
    main_vbox.show()
    window.show_all()
    mainTT.enable()

##  gtk main loop
    gtk.gdk.threads_enter()
    gtk.main()
    gtk.gdk.threads_leave()