Ejemplo n.º 1
0
    def _marshaled_dispatch(self, data, dispatch_method=None):
        """override SimpleXMLRPCDispatcher._marshaled_dispatch() fault string"""

        try:
            import xmlrpc.client as client
            from xmlrpc.client import Fault
        except ImportError:
            import xmlrpclib as client
            from xmlrpclib import Fault

        params, method = client.loads(data)

        # generate response
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)
            # wrap response in a singleton tuple
            response = (response,)
            response = client.dumps(response, methodresponse=1)
        except Fault as fault: # breaks 2.5 compatibility
            fault.faultString = print_exc_info()
            response = client.dumps(fault)
        except:
            # report exception back to server
            response = client.dumps(
                client.Fault(1, "\n%s" % print_exc_info())
                )

        return _b(response)
Ejemplo n.º 2
0
    def _marshaled_dispatch(self, data, dispatch_method=None):
        """override SimpleXMLRPCDispatcher._marshaled_dispatch() fault string"""

        try:
            import xmlrpc.client as client
            from xmlrpc.client import Fault
        except ImportError:
            import xmlrpclib as client
            from xmlrpclib import Fault

        params, method = client.loads(data)

        # generate response
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)
            # wrap response in a singleton tuple
            response = (response, )
            response = client.dumps(response, methodresponse=1)
        except Fault as fault:  # breaks 2.5 compatibility
            fault.faultString = print_exc_info()
            response = client.dumps(fault)
        except:
            # report exception back to server
            response = client.dumps(client.Fault(1, "\n%s" % print_exc_info()))

        return _b(response)
Ejemplo n.º 3
0
    def do_POST(self):
        """ Access point from HTTP handler """

        def onParent(pid, fromchild, tochild):
            self._server._registerChild(pid, fromchild)
            tochild.write("done\n")
            tochild.flush()

        def onChild(pid, fromparent, toparent):
            try:
                response = self._server._marshaled_dispatch(data)
                self._sendResponse(response)
                line = fromparent.readline()
                toparent.write("done\n")
                toparent.flush()
            except:
                logger(name="pathos.xmlrpc", level=30).error(print_exc_info())
            os._exit(0)

        try:
            data = self.rfile.read(int(self.headers["content-length"]))
            params, method = xmlrpclib.loads(data)
            if method == "run":
                return spawn2(onParent, onChild)
            else:
                response = self._server._marshaled_dispatch(data)
                self._sendResponse(response)
                return
        except:
            self._debug.error(print_exc_info())
            self.send_response(500)
            self.end_headers()
            return
Ejemplo n.º 4
0
    def do_POST(self):
        """ Access point from HTTP handler """
        def onParent(pid, fromchild, tochild):
            self._server._registerChild(pid, fromchild)
            tochild.write(_b('done\n'))
            tochild.flush()

        def onChild(pid, fromparent, toparent):
            try:
                response = self._server._marshaled_dispatch(data)
                self._sendResponse(response)
                line = _str(fromparent.readline())
                toparent.write(_b('done\n'))
                toparent.flush()
            except:
                logger(name='pathos.xmlrpc', level=30).error(print_exc_info())
            os._exit(0)

        try:
            data = self.rfile.read(int(self.headers['content-length']))
            params, method = client.loads(data)
            if method == 'run':  #XXX: _str?
                return spawn2(onParent, onChild)
            else:
                response = self._server._marshaled_dispatch(data)
                self._sendResponse(response)
                return
        except:
            self._debug.error(print_exc_info())
            self.send_response(500)
            self.end_headers()
            return
Ejemplo n.º 5
0
    def do_POST(self):
        """ Access point from HTTP handler """

        
        def onParent(pid, fromchild, tochild):
            self._server._registerChild(pid, fromchild)
            tochild.write('done\n')
            tochild.flush()

        def onChild(pid, fromparent, toparent):
            try:
                response = self._server._marshaled_dispatch(data)
                self._sendResponse(response)
                line = fromparent.readline()
                toparent.write('done\n')
                toparent.flush()
            except:
                journal.debug('pathos').log(print_exc_info())
            os._exit(0)

        try:
            data = self.rfile.read(int(self.headers['content-length']))
            params, method = xmlrpclib.loads(data)
            if method == 'run':
                return spawn2(onParent, onChild)
            else:
                response = self._server._marshaled_dispatch(data)
                self._sendResponse(response)
                return
        except:
            self._error.log(print_exc_info())
            self.send_response(500)
            self.end_headers()
            return
Ejemplo n.º 6
0
 def onChild(pid, fromparent, toparent):
     try:
         response = self._server._marshaled_dispatch(data)
         self._sendResponse(response)
         line = fromparent.readline()
         toparent.write("done\n")
         toparent.flush()
     except:
         logger(name="pathos.xmlrpc", level=30).error(print_exc_info())
     os._exit(0)
Ejemplo n.º 7
0
 def onChild(pid, fromparent, toparent):
     try:
         response = self._server._marshaled_dispatch(data)
         self._sendResponse(response)
         line = _str(fromparent.readline())
         toparent.write(_b('done\n'))
         toparent.flush()
     except:
         logger(name='pathos.xmlrpc', level=30).error(print_exc_info())
     os._exit(0)
Ejemplo n.º 8
0
 def onChild(pid, fromparent, toparent):
     try:
         response = self._server._marshaled_dispatch(data)
         self._sendResponse(response)
         line = fromparent.readline()
         toparent.write('done\n')
         toparent.flush()
     except:
         journal.debug('pathos').log(print_exc_info())
     os._exit(0)
Ejemplo n.º 9
0
def decompile_one_apk(apk_fp, out_dir):
    try:
        app_dir, package = prep_dir_apk(out_dir, apk_fp)
        apktool_decompile(apk_fp, app_dir)
        clean(app_dir)
        validity_check(app_dir)
        print()
        return app_dir
    except DecompileException as e:
        print(print_exc_info())
        print()
        remove(app_dir, package)
        return None
Ejemplo n.º 10
0
    def _marshaled_dispatch(self, data, dispatch_method=None):
        """override SimpleXMLRPCDispatcher._marshaled_dispatch() fault string"""

        import xmlrpclib
        from xmlrpclib import Fault

        params, method = xmlrpclib.loads(data)

        # generate response
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)
            # wrap response in a singleton tuple
            response = (response,)
            response = xmlrpclib.dumps(response, methodresponse=1)
        except Fault, fault:
            fault.faultString = print_exc_info()
            response = xmlrpclib.dumps(fault)
Ejemplo n.º 11
0
    def _marshaled_dispatch(self, data, dispatch_method=None):
        """override SimpleXMLRPCDispatcher._marshaled_dispatch() fault string"""

        import xmlrpclib
        from xmlrpclib import Fault

        params, method = xmlrpclib.loads(data)

        # generate response
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)
            # wrap response in a singleton tuple
            response = (response, )
            response = xmlrpclib.dumps(response, methodresponse=1)
        except Fault, fault:
            fault.faultString = print_exc_info()
            response = xmlrpclib.dumps(fault)
Ejemplo n.º 12
0
        # generate response
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)
            # wrap response in a singleton tuple
            response = (response,)
            response = xmlrpclib.dumps(response, methodresponse=1)
        except Fault, fault:
            fault.faultString = print_exc_info()
            response = xmlrpclib.dumps(fault)
        except:
            # report exception back to server
            response = xmlrpclib.dumps(xmlrpclib.Fault(1, "\n%s" % print_exc_info()))

        return response

    def _registerChild(self, pid, fromchild):
        """register a child process so it can be retrieved on select events"""

        self._activeProcesses[fromchild] = pid
        self._selector.notifyOnReadReady(fromchild, self._handleMessageFromChild)

    def _unRegisterChild(self, fd):
        """remove a child process from active process register"""

        del self._activeProcesses[fd]

    def _handleMessageFromChild(self, selector, fd):
Ejemplo n.º 13
0
        # generate response
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)
            # wrap response in a singleton tuple
            response = (response, )
            response = xmlrpclib.dumps(response, methodresponse=1)
        except Fault, fault:
            fault.faultString = print_exc_info()
            response = xmlrpclib.dumps(fault)
        except:
            # report exception back to server
            response = xmlrpclib.dumps(
                xmlrpclib.Fault(1, "\n%s" % print_exc_info()))

        return response

    def _registerChild(self, pid, fromchild):
        """register a child process so it can be retrieved on select events"""

        self._activeProcesses[fromchild] = pid
        self._selector.notifyOnReadReady(fromchild,
                                         self._handleMessageFromChild)

    def _unRegisterChild(self, fd):
        """remove a child process from active process register"""

        del self._activeProcesses[fd]
Ejemplo n.º 14
0
        # generate response
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)
            # wrap response in a singleton tuple
            response = (response,)
            response = xmlrpclib.dumps(response, methodresponse=1)
        except Fault, fault:
            fault.faultString = print_exc_info()
            response = xmlrpclib.dumps(fault)
        except:
            # report exception back to server
            response = xmlrpclib.dumps(
                xmlrpclib.Fault(1, "\n%s" % print_exc_info())
                )

        return response


    def _registerChild(self, pid, fromchild):
        """register a child process so it can be retrieved on select events"""
        
        self._activeProcesses[fromchild] = pid
        self._selector.notifyOnReadReady(fromchild,
                                         self._handleMessageFromChild)


    def _unRegisterChild(self, fd):
        """remove a child process from active process register"""