mobileInsight-core Part-I: Monitor¶

from ..element import Element, Event


class Monitor(Element):
    """
    An abstraction for mobile network monitors
    """

    def __init__(self):
        # No source for Monitor
        Element.__init__(self)

        self._skip_decoding = False

        self._save_log_path = None
        self._save_file = None

    def available_log_types(self):
        """
        Return available log types
        """
        return None

    def save_log_as(self,path):
        """
        Save the log as a mi2log file (for offline analysis)

        :param path: the file name to be saved
        :type path: string
        :param log_types: a filter of message types to be saved
        :type log_types: list of string
        """
        pass



    def set_skip_decoding(self, decoding):
        """
        Configure whether deferred message decoding is enabled

        :param decoding: if True, only the message header would be decoded, otherwise the entire packet would be decoded
        :type decoding: Boolean
        """
        self._skip_decoding = decoding


    # Add an analyzer that needs the message
    def register(self,analyzer):
        """
        Register an analyzer driven by this monitor

        :param analyzer: the analyzer to be added
        :type analyzer: Analyzer
        """
        if analyzer not in self.to_list:
            self.to_list.append(analyzer)

    def deregister(self,analyzer):
        """
        Deregister an analyzer driven by this monitor

        :param analyzer: the analyzer to be removed
        :type analyzer: Analyzer
        """
        if analyzer in self.to_list:
            self.to_list.remove(analyzer)

    def enable_log(self, type_name):
        """
        Enable the messages to be monitored.

        :param type_name: the message type(s) to be monitored
        :type type_name: string or list
        """
        pass

    def enable_log_all(self):
        """
        Enable all supported logs
        """
        pass

    def run(self):
        """
        Start monitoring the mobile network. This is usually the entrance of monitoring and analysis.

        This method should be overloaded in every subclass.
        """
        pass

from monitor import Monitor, Event
from dm_collector import dm_collector_c, DMLogPacket, FormatError

class OfflineReplayer(Monitor):
    """
    A log replayer for offline analysis.
    """

    def __init__(self):
        Monitor.__init__(self)

        # DMLogPacket is initialized here (with ws_dissector and libwireshark path)
        if is_android:
            libs_path = "./data"
            prefs={"ws_dissect_executable_path": os.path.join(libs_path,"android_pie_ws_dissector"),
                   "libwireshark_path": libs_path}
        else:
            prefs={}
        DMLogPacket.init(prefs)

        #...

    def enable_log(self, type_name):
        """
        Enable the messages to be monitored. Refer to cls.SUPPORTED_TYPES for supported types.

        If this method is never called, the config file existing on the SD card will be used.
        """

        # dm_collector_c: Get available cellular message types
        SUPPORTED_TYPES = set(dm_collector_c.log_packet_types)
        cls = self.__class__
        if isinstance(type_name, str):
            type_name = [type_name]
        for n in type_name:
            if n not in cls.SUPPORTED_TYPES:
                self.log_warning("Unsupported log message type: %s" % n)
            if n not in self._type_names:
                self._type_names.append(n)
                self.log_info("Enable "+n)
        # dm_collector_c: Enable filtering of messages
        dm_collector_c.set_filtered(self._type_names)

    def enable_log_all(self):
        """
        Enable all supported logs
        """
        cls = self.__class__
        self.enable_log(cls.SUPPORTED_TYPES)

    def set_input_path(self, path):
        """
        Set the replay trace path

        :param path: the replay file path. If it is a directory, the OfflineReplayer will read all logs under this directory (logs in subdirectories are ignored)
        :type path: string
        """
        dm_collector_c.reset()
        self._input_path = path

    def run(self):
        """
        Start monitoring the mobile network. This is usually the entrance of monitoring and analysis.
        """

        # Open log file
        self.log_info("Loading "+path)
        self._input_file = open(path, "rb")

        # Reset dm_collector_c
        dm_collector_c.reset()
        while True:
            s = self._input_file.read(64)
            if not s:   # EOF encountered
                break

            # dm_collector_c: feed binaries for parsing
            dm_collector_c.feed_binary(s)
            decoded = dm_collector_c.receive_log_packet(self._skip_decoding,
                                                        True,   # include_timestamp
                                                        )
            if decoded:
                try:
                    packet = DMLogPacket(decoded[0])
                    d = packet.decode()

                    if d["type_id"] in self._type_names:
                        event = Event(  timeit.default_timer(),
                                        d["type_id"],
                                        packet)
                        self.send(event)

                except FormatError, e:
                    # skip this packet
                    print "FormatError: ", e

        self._input_file.close()