C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/eyespy.py

Go to the documentation of this file.

# Copyright (C) 2008-2009  Mark Hanegraaff
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.


import wx
from objects.gui.mainFrame import mainFrame
from objects.logic.network import networkMonitor
from objects.logic.entity import entityManager
from objects.storage import storageManager
from objects.logic.common.exception import exception

from objects.logic.configuration.displayConfigurator import displayConfigurator
from objects.logic.configuration.optionsConfigurator import optionsConfigurator

from objects.logic.common.globalStrings import globalStrings
from objects.geoip.geoIPUtils import geoIPUtils

## The eyespy class essentially acts as the main entry point for the application
# Every wxWidgets application must have a class derived from wx.App
#
# Defined in this module (after the eyespy class definition) is also the equivalent of the "main" function. 
class eyespy(wx.App):

    ## Initializes the application and all the associated global variables
    def OnInit(self):
        
        
        err, ex = self.loadConfiguration()
                    
        if err == True: 
            errMsg = "Could not read startup configuration files. Although you configuration will be restored some application parameters will be set to their starting values. \nThis is usually due to a missing or corrupt configuration file\n\nDetailed Error:\n%s " % (str(ex))            
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()
            
        
            
        try:
            geoIPUtils.installGeoIPIfNecessary()
        except Exception, e:
            errMsg = str(e) + "\nPlease try and update the GEO IP again."             
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()
            
        
        self.netMon         = networkMonitor.networkMonitor()        
        self.entityMan      = entityManager.entityManager()
        self.storage        = None
        
        self.initStorage(True)
        self.storage.deleteStorage()
    
        """
            register packet listener
        """
        self.netMon.attach(self.entityMan)        
         
        self.createMainWindow(self)
        # Return a success flag
        return True



    ## Creates the main application window.
    def createMainWindow(self, app):
        # Create an instance of our customized Frame class
        stringVer = "EyeSpy V 1.1 (%s)" % globalStrings.VERSION
        frame = mainFrame(None, -1, stringVer, app, self.dispConf, self.optConfig)
        frame.Show(True)

        # Tell wxWindows that this is our main window
        self.SetTopWindow(frame)
      
      
      
    ## Loads the "Options.ini" and "DisplaySettings.ini" configuration files  
    def loadConfiguration(self):
        
        ex = ""
        error = False
        
        try:
            # load the display configuration
            self.dispConf = displayConfigurator(globalStrings.displaySettingsPath)
            self.dispConf.loadConfig()
        except Exception, ex:
            error = True
        #else: ex = ""
            
        try:
            # now load the options
            self.optConfig = optionsConfigurator(globalStrings.appOptionsPath)
            self.optConfig.loadConfig()
        except Exception, ex:
            error = True
        #else: ex = ""
            
        return error, ex
    
    
    ## Initializes the database storage
    # @param clearStorageFirst Boolean. True if the storage data should be deleted first.
    # @param reloadConfig Boolean. True if "Options.ini" should be loaded again.
    def initStorage(self, clearStorageFirst, reloadConfig = False):
        self.storageInitted = False
        
        if self.storage != None:
            self.netMon.detach(self.storage)
        
        if reloadConfig:
            try:
                self.optConfig.loadConfig()
            except Exception, e:
                pass
        
        # storage initialization
        monStorage = self.optConfig.network_getRecordTraffic()
        maxSize    = self.optConfig.network_getRecordingMaxLimit()
        
        if self.optConfig.network_getNeverStopRecording() == True:
            maxSize = -1
        
        self.storage = storageManager.storageManager(monStorage, maxSize)
        
        if clearStorageFirst == True:
            try:
                self.storage.initializeStorage()
            except Exception, ex:
                
                # if the users opts out of storing trace data, then there is no need
                # to display this error so prominently
                if monStorage == True:
                    dlg = wx.MessageDialog(None, str(ex), 'Error', wx.ICON_ERROR)
                    result = dlg.ShowModal()
                    dlg.Destroy()
                
                self.storageInitted = False
                return
        
        if monStorage == True:
            self.netMon.attach(self.storage)
            
        self.storageInitted = True
    
    
    ## Starts the Storage manager 
    def startStorageManager(self):
        if self.storageInitted == True and self.storage != None:
            self.storage.startupStorage()
    
    
    ## Halts the storage manager    
    def shutdownStorage(self):
        if self.storageInitted == True and self.storage != None:
            self.storage.shutdownStorage()
        

        

app = eyespy(0)     # Create an instance of the application class
app.MainLoop()     # Tell it to start processing events

#cleanup

app.netMon.stopListening()

---