def request(self, host, handler, request_body, verbose=0): if not self.connection: self.connection = self._get_connection() self.headers = { "User-Agent": self.user_agent, "Content-Type": "text/xml", "Accept": "text/xml" } # basic auth if self.username is not None and self.password is not None: unencoded = "%s:%s" % (self.username, self.password) encoded = as_string(encodestring(as_bytes(unencoded))) encoded = encoded.replace('\012', '') self.headers["Authorization"] = "Basic %s" % encoded self.headers["Content-Length"] = str(len(request_body)) self.connection.request('POST', handler, request_body, self.headers) r = self.connection.getresponse() if r.status != 200: self.connection.close() self.connection = None raise xmlrpclib.ProtocolError(host + handler, r.status, r.reason, '') data = r.read() p, u = self.getparser() p.feed(data) p.close() return u.close()
def request(self, host, handler, request_body, verbose): """ Make an xmlrpc request. """ headers = {'User-Agent': self.user_agent} url = self._build_url(host, handler) try: resp = requests.post(url, data=request_body, headers=headers, stream=True, cert=self.cert, verify=self.verify, timeout=self.timeout) except ValueError: raise except Exception: raise # something went wrong else: try: resp.raise_for_status() except requests.RequestException as e: raise xmlrpclib.ProtocolError(url, resp.status_code, str(e), resp.headers) else: self.verbose = verbose return self.parse_response(resp.raw)
def request(self, host, handler, request_body, verbose): """ Make an xmlrpc request. """ headers = { 'User-Agent': self.user_agent, #Proxy-Connection': 'Keep-Alive', #'Content-Range': 'bytes oxy1.0/-1', 'Accept': 'text/xml', 'Content-Type': 'text/xml' } url = self._build_url(host, handler) try: resp = requests.post(url, data=request_body, headers=headers) except ValueError: raise except Exception: raise # something went wrong else: try: resp.raise_for_status() except requests.RequestException as e: raise xmlrpc.ProtocolError(url, resp.status_code, str(e), resp.headers) else: return self.parse_response(resp)
def request(self, host, handler, request_body, verbose): """ Make an xmlrpc request. """ headers = { 'User-Agent': self.user_agent, 'Content-Type': 'text/xml', } url = self._build_url(host, handler) # print(f"generated url: {# url}") kwargs = {} if StrictVersion(requests.__version__) >= StrictVersion('0.8.8'): kwargs['verify'] = True else: if self.use_https: warnings.warn( 'using https transport but no certificate ' 'verification. (Hint: upgrade requests package.)') try: resp = requests.post(url, data=request_body, headers=headers, **kwargs) except ValueError: raise except Exception: raise # something went wrong else: try: resp.raise_for_status() except requests.RequestException as e: raise xmlrpc.ProtocolError(url, resp.status_code, str(e), resp.headers) else: return self.parse_response(resp)
def single_request(self, host, handler, request_body, verbose=0): # issue XML-RPC request h = self.make_connection(host) if verbose: h.set_debuglevel(1) try: self.send_request(h, handler, request_body) self.send_host(h, host) self.send_user_agent(h) self.send_auth(h) self.send_content(h, request_body) response = h.getresponse(buffering=True) if response.status == 200: self.verbose = verbose return self.parse_response(response) except xmlrpc_client.Fault: raise except Exception: self.close() raise #discard any response data and raise exception if response.getheader("content-length", 0): response.read() raise xmlrpc_client.ProtocolError( host + handler, response.status, response.reason, response.msg, )
def request(self, host, handler, request_body, verbose): """ Make an xmlrpc request. """ client = self.session or requests headers = { 'User-Agent': self.user_agent, 'Content-Type': 'text/xml', } url = self._build_url(host, handler) try: resp = client.post(url, data=request_body, headers=headers, timeout=self.timeout) except ValueError: raise except Exception: raise # something went wrong else: try: resp.raise_for_status() except requests.RequestException as e: raise xmlrpc.ProtocolError(url, resp.status_code, str(e), resp.headers) else: return self.parse_response(resp)
def request(self, host, handler, request_body, verbose=False): parser, unmarshaller = self.getparser() response = self.client.post(handler, request_body, 'text/xml') if response.status_code != 200: raise xmlrpclib.ProtocolError( '%s%s' % (host, handler), response.status_code, httplib.responses.get(response.status_code, ''), dict(response.items()), ) parser.feed(response.content) return unmarshaller.close()
def request(self, host, handler, request_body, verbose): """ Make an xmlrpc request. """ headers = {'User-Agent': self.user_agent} url = self._build_url(host, handler) resp = requests.post(url, data=request_body, headers=headers) try: resp.raise_for_status() except requests.RequestException as e: raise xmlrpc.ProtocolError(url, resp.status_code, str(e), resp.headers) else: return self.parse_response(resp)
def single_request(self, host, handler, request_body, verbose=0): if "@" in host: auth_details, host = host.rsplit("@", 1) self.auth_trac(host, auth_details) headers = { "User-Agent": self.user_agent, "Content-Type": self._content_type } if self._extra_headers: headers.update(dict(self._extra_headers)) response = self.session.get(self.get_url(host, handler), data=request_body, headers=headers) if response.ok: self.verbose = verbose return self.parse_response(response) response.close() raise client.ProtocolError(host + handler, response.status_codes, response.reason, "")
def single_request(self, host, handler, request_body, verbose=0): # issue XML-RPC request try: connection = self.send_request(host, handler, request_body, False) response = connection.getresponse() if response.status == 200: self.verbose = verbose return self.parse_response(response) except xmlrpclib.Fault: raise except Exception: self.close() raise #discard any response data and raise exception if response.getheader("content-length", 0): response.read() raise xmlrpclib.ProtocolError( host + handler, response.status, response.reason, response.msg, )
def request(self, host, handler, request_body, verbose=0): """Replace the xmlrpc request function. Process xmlrpc request via requests library. Args: host: Target host handler: Target PRC handler. request_body: XML-RPC request body. verbose: Debugging flag. Returns: Parsed response. Raises: RequestException: Error in requests """ if verbose: self._debug() if not self._check_ssl_cert: disable_warnings() headers = { 'User-Agent': self.user_agent, 'Content-Type': 'text/xml', } # Need to be done because the schema(http or https) is lost in # xmlrpc.Transport's init. if self._use_https: url = "https://{host}{handler}".format(host=host, handler=handler) else: url = "http://{host}{handler}".format(host=host, handler=handler) # TODO Construct kwargs query instead try: if self._authtype == "basic": response = requests.post(url, data=request_body, headers=headers, verify=self._check_ssl_cert, auth=HTTPBasicAuth( self._username, self._password), proxies=self._proxies) elif self._authtype == "digest": response = requests.post(url, data=request_body, headers=headers, verify=self._check_ssl_cert, auth=HTTPDigestAuth( self._username, self._password), proxies=self._proxies) else: response = requests.post(url, data=request_body, headers=headers, verify=self._check_ssl_cert, proxies=self._proxies) response.raise_for_status() except RequestException as error: raise xmlrpc_client.ProtocolError(url, error.message, traceback.format_exc(), response.headers) return self.parse_response(response)