C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/logic/network/pcapyImplementation.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 pcapy
from pcapy import findalldevs, open_live
from objects.logic.common.exception import exception
from objects.logic.network.captureInterface import captureInterface

from threading import Thread, Event, RLock

from packetDecoder import packetDecoder
from objects.logic.common.logger import logger

from objects.logic.common.threads.appThreadBase import appThreadBase


## The pcapyWorkerThread is a very simple long living worker thread which will periodically
# call pcapy's "dispatch" Reader method. This class essentially is the main collector of raw
# network data.
class pcapyWorkerThread(appThreadBase):    
        
    def run(self):
        logger.log("Starting Network Capture worker thread.")
        while(self.killSwitch == False):
           
           try:
               self.parent.deviceObject.dispatch(100, self.parent.handleReceivePacet)
           except Exception, ex:
               logger.log(__name__ + ": There was an unknown Error while listening to network packet stream")
               logger.log(ex)
               
               self.killSwitch = True
               if self.parent.errorCallBackFunc is not None:
                   self.parent.errorCallBackFunc(ex)
                   
           except pcapy.PcapError, pce:
               logger.log(__name__ + ": There was an Pcapy Error while listening to network packet stream")
               logger.log(pce)
               
               self.killSwitch = True
               if self.parent.errorCallBackFunc is not None:
                   self.parent.errorCallBackFunc(pce)
                   
           finally:
               self.threadEvent.set()
               self.threadEvent.clear()            
        
        logger.log(__name__ + "Network Capture worker thread is done")
        
        
## the pcapyImplementation is the implementation of the captureInterface interface using
# pcapy's packet capture library. For further information see the  captureInterface class.
class pcapyImplementation(captureInterface):
    def __init__(self):
        captureInterface.__init__(self)
        
        self.deviceObject = None
        
        self.decoder = packetDecoder()
        
        #Threading related objects
        self.listenThread = None
        
        self.lck = RLock()
    
    
        
    ## Returns a list of all known device names in their NPF form
    # @return List of Strings
    def getDeviceList(self):
        try:
            devices = findalldevs()
        except pcapy.PcapError, pce:
            raise exception(str(pce), True)
        else:
            return devices
    
    
    
    ## Does nothing. Pcapy does not support querying a device.
    # @param device String representing a device name (NPF Form)
    def queryDevice(self, device):
        #no device queries for pcapy?
        return "no info"
    
    
    
    # Opens a device
    # @param device String representing a device name (NPF Form)
    def openDevice(self, device):
        logger.log(__name__ + ": Opening network Device: " + device)
        try:
            self.deviceObject = open_live(device, 8192, 0, 100)
        except pcapy.PcapError, pce:
            logger.log(__name__ + ": " + str(pce))
            raise exception(str(pce), 1)
        else:
            # pass the reader to the decoder
            self.decoder.setReader(self.deviceObject)
            self.deviceName = device



    ## Does nothing. Pcapy does not support querying a device.
    # @param device String representing a device name (NPF Form)
    def closeDevice(self, device):
        # no device close for pcapy ?
        pass
    
    
    
    ## start listening to the supplied device. Calling this method will
    # start the main instance of the pcapyWorkerThread class
    # @param device String representing a device name (NPF Form)
    def startListening(self, device):
                
        self.stopListening()
            
        try:
            self.openDevice(device) # throws exception
        except exception, e:
            raise e
        else:                            
            self.listenThread  = pcapyWorkerThread(self)
            self.listenThread.start()
            
    ## stops listening to a device. It does little more than stopping the pcapyWorkerThread worker thread
    def stopListening(self):        
        if self.listenThread != None and self.listenThread.isAlive() == True:
            self.listenThread.killSignalAndWait(1)

        
    
    ## Callback method supplied to the pcapyWorkerThread class.
    # @param header Raw DataLink header
    # @param data  Raw DataLink frame
    def handleReceivePacet(self, header, data):        
        self.lck.acquire(1)
        try:            
            # decode the packet...
            self.notify(header, data, self.deviceName)            
        except exception, e:
            logger.log(__name__ + ": Caught an exception while processing packet data: " + e.reason)
        except Exception, ex:
            logger.log(__name__ + ": Caught an unknown exception while processing packet data: " + str(ex))
            
        finally:
            self.lck.release()
    

---