def _kerberos_client_request(self, host, handler, errcode, errmsg, headers): """Kerberos auth - create a client request string""" # check if "Negotiate" challenge is present in headers negotiate = [ i.lower() for i in headers.get("WWW-Authenticate", "").split(", ") ] if "negotiate" not in negotiate: # negotiate not supported, raise 401 error raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) # initialize GSSAPI service = "HTTP@%s" % host rc, vc = kerberos.authGSSClientInit(service) if rc != 1: errmsg = "KERBEROS: Could not initialize GSSAPI" raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) # do a client step rc = kerberos.authGSSClientStep(vc, "") if rc != 0: errmsg = "KERBEROS: Client step failed" raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) return vc, kerberos.authGSSClientResponse(vc)
def _kerberos_verify_response(self, vc, host, handler, errcode, errmsg, headers): """Kerberos auth - verify client identity""" # verify that headers contain WWW-Authenticate header auth_header = headers.get("WWW-Authenticate", None) if auth_header is None: errcode = 401 errmsg = "KERBEROS: No WWW-Authenticate header in second HTTP response" raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) # verify that WWW-Authenticate contains Negotiate splits = auth_header.split(" ", 1) if (len(splits) != 2) or (splits[0].lower() != "negotiate"): errcode = 401 errmsg = "KERBEROS: Incorrect WWW-Authenticate header in second HTTP response: %s" % auth_header raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) # do another client step to verify response from server errmsg = "KERBEROS: Could not verify server WWW-Authenticate header in second HTTP response" try: rc = kerberos.authGSSClientStep(vc, splits[1]) if rc == -1: errcode = 401 raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) except kerberos.GSSError, ex: errcode = 401 errmsg += ": %s/%s" % (ex[0][0], ex[1][0]) raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers)
def request(self, host, handler, request_body, verbose=0): # issue XML-RPC request h = self.make_connection(host) if verbose: h.set_debuglevel(1) self.send_request(h, handler, request_body) self.send_host(h, host) self.send_user_agent(h) if self.cookie is not None: h.putheader("Cookie", self.cookie) self.send_content(h, request_body) errcode, errmsg, headers = h.getreply() self.cookie = headers.getheader('set-cookie') or self.cookie if errcode != 200: raise xmlrpclib.ProtocolError( host + handler, errcode, errmsg, headers ) # do not print the response body self.verbose = False return self.parse_response(h.getfile())
class GAEXMLRPCTransport(object): """Handles an HTTP transaction to an XML-RPC server.""" def __init__(self): pass def request(self, host, handler, request_body, verbose=0): result = None url = 'http://%s%s' % (host, handler) try: response = urlfetch.fetch(url, payload=request_body, method=urlfetch.POST, headers={'Content-Type': 'text/xml'}) except Exception, e: msg = 'Failed to fetch %s, caused by: %s' % (url, traceback.format_exc()) logging.error(msg) raise xmlrpclib.ProtocolError(host + handler, 500, msg, {}) if response.status_code != 200: logging.error('%s returned status code %s' % (url, response.status_code)) raise xmlrpclib.ProtocolError(host + handler, response.status_code, "", response.headers) else: result = self.__parse_response(response.content) return result
def request(self, host, handler, request_body, verbose=0): if not self.connection: host, extra_headers, x509 = self.get_host_info(host) self.connection = httplib.HTTPSConnection(host) self.headers = { "User-Agent": self.user_agent, "Content-Type": "text/xml", "Accept": "text/xml" } if extra_headers: for key, item in extra_headers: self.headers[key] = item 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=0): # issue XML-RPC request h = self.cache.get_connection() try: self.set_connection_params(h) h.add_data(request_body) response = pycurllib.urlopen(h, close=False) #errcode, errmsg, headers = h.getreply() errcode = response.code errmsg = response.msg headers = "N/A" if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) self.verbose = verbose r = self._parse_response(response) finally: self.cache.put_connection(h) return r
def handle_error(self): t, v, nil = sys.exc_info() self.deferred.runErrback( xmlrpclib.ProtocolError(self.host, '500', "Socket Error (%s:%s)" % (t, v) , {}) ) self.close()
def request( self, host, handler, request_body, verbose=0, ): h = getattr(self, "make_connection_" + PYVERSION)(host) if verbose: h.set_debuglevel(1) # ADDED: construct the URL and Request object for proper cookie handling request_url = '%s://%s/' % (self.scheme, host) cookie_request = urllib2.Request(request_url) self.send_request(h, handler, request_body) self.send_host(h, host) self.send_cookies(h, cookie_request) # ADDED. creates cookiejar if None. self.send_user_agent(h) self.send_content(h, request_body) (errcode, errmsg, headers) = h.getreply() # ADDED: parse headers and get cookies here # fake a response object that we can fill with the headers above class CookieResponse: def __init__(self, headers): self.headers = headers def info(self): return self.headers cookie_response = CookieResponse(headers) # Okay, extract the cookies from the headers self.cookiejar.extract_cookies(cookie_response, cookie_request) # And write back any changes if hasattr(self.cookiejar, 'save'): self.cookiejar.save(self.cookiejar.filename) if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) self.verbose = verbose try: sock = h._conn.sock except AttributeError: sock = None return getattr(self, "_parse_response_" + PYVERSION)(h.getfile(), sock)
def request(self, host, handler, request_body, verbose=0): # issue XML-RPC request h = self.make_connection(host) if verbose: h.set_debuglevel(1) self.send_request(h, handler, request_body) self.send_host(h, host) if not self.mysessid is None: h.putheader("Cookie", "%s=%s" % (self.SESSION_ID_STRING,self.mysessid) ) self.send_user_agent(h) self.send_content(h, request_body) errcode, errmsg, headers = h.getreply() if self.mysessid is None: self.mycookies = self.parseCookies( headers.getheader('set-cookie') ) if self.mycookies.has_key(self.SESSION_ID_STRING): self.mysessid = self.mycookies[self.SESSION_ID_STRING] if errcode != 200: raise xmlrpclib.ProtocolError( host + handler, errcode, errmsg, headers ) self.verbose = verbose try: sock = h._conn.sock except AttributeError: sock = None return self._parse_response(h.getfile(), sock)
def request(self, host, handler, request_body, verbose=0): # issue XML-RPC request h = self.make_connection(host) if verbose: h.set_debuglevel(1) self.send_request(h, handler, request_body) self.send_host(h, host) self.send_user_agent(h) self.send_content(h, request_body) r = h.getresponse() errcode = r.status errmsg = r.reason headers = r.msg # Creati g cookie jar cresponse = CookieResponse(headers) crequest = CookieRequest('https://' + host + '/') if '<methodName>base.ldapAuth</methodName>' in request_body: cj = LWPCookieJar() cj.extract_cookies(cresponse, crequest) if len(cj): cj.save(COOKIES_FILE, ignore_discard=True, ignore_expires=True) os.chmod(COOKIES_FILE, stat.S_IRUSR | stat.S_IWUSR) if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) self.verbose = verbose return self.parse_response(r)
def retrieve(url, cacert=None, postdata=None, timeout=90): # command = ('/usr/bin/curl', '--fail', '--silent') command = ( '/usr/bin/curl', '--fail', ) if cacert: command += ('--cacert', cacert) if postdata: command += ('--data', '@-') if timeout: command += ('--max-time', str(timeout)) command += ('--connect-timeout', str(timeout)) command += (url, ) if verbose: print 'Invoking ', command if postdata: print 'with postdata=', postdata p = Sopen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True) if postdata: p.stdin.write(postdata) p.stdin.close() sout, sin, serr = select([p.stdout, p.stderr], [], [], timeout) if len(sout) == 0 and len(sin) == 0 and len(serr) == 0: logger.verbose("curlwrapper: timed out after %s" % timeout) p.kill(signal.SIGKILL) data = p.stdout.read() err = p.stderr.read() rc = p.wait() if rc != 0: # when this triggers, the error sometimes doesn't get printed logger.log("curlwrapper: retrieve, got stderr <%s>" % err) raise xmlrpclib.ProtocolError(url, rc, err, postdata) else: return data
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 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): """Request via urlfetch instead of socket connection. Args: host: string hostname. handler: string '/RPC2', defined in xmlrpclib. request_body: string XML-RPC request body. verbose: integer, defined in xmlrpclib, unused here. Returns: ServerProxy instance. Raises: ProtocolError: if urlfetch.fetch fails or returns an HTTP status code other than 200. """ result = None url = '%s://%s%s' % (self.PROTOCOL, host, handler) headers = { 'Content-Type': 'text/xml', 'use_intranet': 'yes', 'X-secureDataConnector-RouteDomain': 'google.com' } if self.DEBUG_HEADERS: headers['X-secureDataConnectorDebug'] = 'text' try: response = urlfetch.fetch(url, payload=request_body, method=urlfetch.POST, headers=headers, deadline=10) except urlfetch.Error, error: raise xmlrpclib.ProtocolError(host + handler, 500, error, {})
def request(self, arg_host, handler, request_body, verbose=0): # issue XML-RPC request self.verbose = verbose myHttp = httplib.HTTP(arg_host) myHttp.putrequest("POST", handler) # required by HTTP/1.1 myHttp.putheader("Host", arg_host) # required by XML-RPC myHttp.putheader("User-Agent", self.user_agent) myHttp.putheader("Content-Type", "text/xml") myHttp.putheader("Content-Length", str(len(request_body))) # basic auth if self.username is not None and self.password is not None: myHttp.putheader("AUTHORIZATION", "Basic %s" % encodestring("%s:%s" % (self.username, self.password) ).replace("\012", "")) myHttp.endheaders() if request_body: myHttp.send(request_body) errcode, errmsg, headers = myHttp.getreply() if errcode != 200: raise xmlrpclib.ProtocolError(arg_host + handler, errcode, errmsg, headers) return self.parse_response(myHttp.getfile())
def request(self, host, handler, request_body, verbose=0): # issue XML-RPC request if self.proxy != "": h = self.make_connection(self.proxy) else: h = self.make_connection(host) if verbose: h.set_debuglevel(1) if self.proxy != "": self.send_request(h, "http://" + host + handler, request_body) else: self.send_request(h, handler, request_body) self.send_host(h, host) self.send_user_agent(h) self.send_content(h, request_body) errcode, errmsg, headers = h.getreply() if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) self.verbose = verbose return self.parse_response(h.getfile())
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 = base64.encodestring(unencoded).replace('\n', '') 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 connect(self): # Set the connection with the proxy HTTPProxyConnection.connect(self) # Use the stock HTTPConnection putrequest host = "%s:%s" % (self._host, self._port) HTTPConnection.putrequest(self, "CONNECT", host) # Add proxy-specific stuff self._add_proxy_headers() # And send the request HTTPConnection.endheaders(self) # Save the response class response_class = self.response_class # And replace the response class with our own one, which does not # close the connection after self.response_class = HTTPSProxyResponse response = HTTPConnection.getresponse(self) # Restore the response class self.response_class = response_class # Close the response object manually response.close() if response.status != 200: # Close the connection manually self.close() raise xmlrpclib.ProtocolError(host, response.status, response.reason, response.msg) self.sock = SSL.SSLSocket(self.sock, self.trusted_certs) self.sock.init_ssl()
def request(self, host, handler, request_body, verbose=0): """ 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, timeout=self.timeout, proxies=self.proxies, verify=self.verify) 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 _single_request(self, host, handler, request_body, verbose=0): # issue XML-RPC request request_url = "%s://%s/" % (self.scheme, host) cookie_request = urllib2.Request(request_url) h = self.make_connection(host) self.verbose = verbose if verbose: h.set_debuglevel(1) try: self.send_request(h, handler, request_body) self.send_host(h, host) self.send_cookies(h, cookie_request) self.send_user_agent(h) self.send_content(h, request_body) response = h.getresponse(buffering=True) if response.status == 401 and USE_KERBEROS: vc, challenge = self._kerberos_client_request( host, handler, response.status, response.reason, response.msg) # discard any response data if (response.getheader("content-length", 0)): response.read() # retry the original request & add the Authorization header: self.send_request(h, handler, request_body) self._extra_headers = [("Authorization", "Negotiate %s" % challenge)] self.send_host(h, host) self.send_user_agent(h) self.send_content(h, request_body) self._extra_headers = [] response = h.getresponse(buffering=True) self._kerberos_verify_response(vc, host, handler, response.status, response.reason, response.msg) if response.status == 200: self.verbose = verbose self._save_cookies(response.msg, cookie_request) return self.parse_response(response) except xmlrpclib.Fault: raise except Exception: # All unexpected errors leave connection in # a strange state, so we clear it. if hasattr(self, 'close'): 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): request = "POST %s HTTP/1.0\n" % (handler, ) request += "Content-Length: %i\n" % len(request_body) request += "Content-Type: text/xml\n" host, extra_headers, x509 = self.get_host_info(host) if extra_headers: request += "Authorization: %s\n" \ % (dict(extra_headers)["Authorization"],) request += "\n" + request_body response = HTTPCaller()(request, handle_errors=self.handleErrors) errcode = response.getStatus() errmsg = response.getStatusString() # This is not the same way that the normal transport deals # with the headers. headers = response.getHeaders() if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) return self._parse_response(StringIO.StringIO(response.getBody()), sock=None)
def 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_content(h, request_body) response = h.getresponse() if response.status == 200: self.verbose = verbose return self.parse_response(response) except xmlrpclib.Fault: raise except Exception: # All unexpected errors leave connection in # a strange state, so we clear it. 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=None): # issue XML-RPC request h = httplib.HTTP(host) h.putrequest("POST", handler) # required by HTTP/1.1 h.putheader("Host", host) # required by XML-RPC h.putheader("User-Agent", self.user_agent) h.putheader("Content-Type", "text/xml") h.putheader("Content-Length", str(len(request_body))) # basic auth if self.username is not None and self.password is not None: h.putheader( "AUTHORIZATION", "Basic %s" % string.replace( encodestring("%s:%s" % (self.username, self.password)), "\012", "")) h.endheaders() if request_body: h.send(request_body) errcode, errmsg, headers = h.getreply() print errcode, errmsg, headers if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) return self.parse_response(h.getfile())
def send_http(self, host, handler="/RPC2"): if not self.__processed: raise NotProcessed self._host = host if self._connection is None: raise Exception("No connection object found") self._connection.connect() # wrap self data into binary object, otherwise HTTPConnection.request # will encode it as ISO-8859-1 https://docs.python.org/3/library/http.client.html#httpconnection-objects self._connection.request(self.method, handler, body=bstr(self.data), headers=self.headers) response = self._connection.getresponse() if not self.response_acceptable(response): raise xmlrpclib.ProtocolError("%s %s" % (self._host, handler), response.status, response.reason, response.msg) # A response object has read() and close() methods, so we can safely # pass the whole object back return response.msg, response
def patched_request(self, host, handler, request_body, verbose=0): req = urllib2.Request(self.uri) req.add_header('User-Agent', self.user_agent) req.add_header('Content-Type', 'text/xml') if hasattr(self, 'accept_gzip_encoding') and \ self.accept_gzip_encoding: req.add_header('Accept-Encoding', 'gzip') req.add_data(request_body) resp = self.opener.open(req, timeout=longer_timeout) # In Python 2, resp is a urllib.addinfourl instance, # which does not # have the getheader method that parse_response expects. if not hasattr(resp, 'getheader'): resp.getheader = resp.headers.getheader if resp.code == 200: self.verbose = verbose return self.parse_response(resp) resp.close() raise xmlrpclib.ProtocolError(self.uri, resp.status, resp.reason, resp.msg)
def request(self, host, handler, request_body, verbose=0): # issue XML-RPC request h = self.make_connection(host) if verbose: h.set_debuglevel(1) self.send_request(h, handler, request_body) self.send_host(h, host) self.send_user_agent(h) self.send_content(h, request_body) errcode, errmsg, headers = h.getreply() if errcode != 200: raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers) self.verbose = verbose # Here's where we differ from the superclass. It says: # try: # sock = h._conn.sock # except AttributeError: # sock = None # return self._parse_response(h.getfile(), sock) return self.parse_response(h.getfile())
def request(self, *args, **kwargs): if len(args) == 2: uri, body = args handler = uri.path username = uri.userpass[0] password = uri.userpass[1] host = str(uri.hostport.host.name) full_url = str(uri) else: uri, handler, body = args username = uri._substArgs['user'] password = uri._substArgs['password'] host = uri._substArgs['host'] full_url = uri + handler verbose = kwargs.get('verbose', 0) method = util.xmlrpcLoad(body)[1] self.calls.append((username, password, host, handler, method)) if self.fail: raise xmlrpclib.ProtocolError(full_url, 500, 'Totally Awesome Error', {}) return ()
def request(self, host, handler, request_body, verbose=0): ''' Handle the request ''' host_connection = self.make_connection(host) if verbose: host_connection.set_debuglevel(1) # ADDED: construct the URL and Request object for proper cookie handling request_url = "%s://%s/" % (self.scheme, host) cookie_request = urllib2.Request(request_url) self.send_request(host_connection, handler, request_body) self.send_host(host_connection, host) # ADDED. creates cookiejar if None. self.send_cookies(host_connection, cookie_request) self.send_user_agent(host_connection) self.send_content(host_connection, request_body) errcode, errmsg, headers = host_connection.getreply() # ADDED: parse headers and get cookies here class CookieResponse: ''' fake a response object that we can fill with the headers above ''' def __init__(self, headers): self.headers = headers def info(self): return self.headers cookie_response = CookieResponse(headers) # Okay, extract the cookies from the headers self.cookiejar.extract_cookies(cookie_response, cookie_request) # And write back any changes # DH THIS DOESN'T WORK # self.cookiejar.save(self.cookiejar.filename) if errcode != 200: raise xmlrpclib.ProtocolError( host + handler, errcode, errmsg, headers ) self.verbose = verbose try: sock = host_connection._conn.sock except AttributeError: sock = None return self._parse_response(host_connection.getfile(), sock)
def _check_return(self, host, handler, httpcode, buf): """Check for SSL certs validity""" if httpcode == 60: raise xmlrpclib.ProtocolError( host + handler, httpcode, "SSL certificate validation failed", None)
def request(self, host, handler, request_body, verbose=0): """ Send a complete request, and parse the response. See xmlrpclib.py. :Parameters: host : str target host handler : str RPC handler on server (i.e., path to handler) request_body : str XML-RPC request body verbose : bool/int debugging flag. Ignored by this implementation :rtype: dict :return: parsed response, as key/value pairs """ # issue XML-RPC request result = None url = 'http://%s%s' % (host, handler) try: response = urlfetch.fetch(url, payload=request_body, method=urlfetch.POST, headers={'Content-Type': 'text/xml'}) except: msg = 'Failed to fetch %s' % url raise xmlrpclib.ProtocolError(host + handler, 500, msg, {}) if response.status_code != 200: logging.error('%s returned status code %s' % (url, response.status_code)) raise xmlrpclib.ProtocolError(host + handler, response.status_code, "", response.headers) else: result = self.__parse_response(response.content) return result
class UrlfetchTransport(xmlrpclib.Transport): """Handles an HTTP request to an XML-RPC server using urlfetch.""" PROTOCOL = 'http' DEBUG_RESPONSE = False DEBUG_HEADERS = False # pylint: disable-msg=W0613 # Disable warning for unused argument. def request(self, host, handler, request_body, verbose=0): """Request via urlfetch instead of socket connection. Args: host: string hostname. handler: string '/RPC2', defined in xmlrpclib. request_body: string XML-RPC request body. verbose: integer, defined in xmlrpclib, unused here. Returns: ServerProxy instance. Raises: ProtocolError: if urlfetch.fetch fails or returns an HTTP status code other than 200. """ result = None url = '%s://%s%s' % (self.PROTOCOL, host, handler) headers = { 'Content-Type': 'text/xml', 'use_intranet': 'yes', 'X-secureDataConnector-RouteDomain': 'google.com' } if self.DEBUG_HEADERS: headers['X-secureDataConnectorDebug'] = 'text' try: response = urlfetch.fetch(url, payload=request_body, method=urlfetch.POST, headers=headers, deadline=10) except urlfetch.Error, error: raise xmlrpclib.ProtocolError(host + handler, 500, error, {}) if response.status_code != 200: raise xmlrpclib.ProtocolError(host + handler, response.status_code, '', response.headers) else: if response: if self.DEBUG_RESPONSE: logging.debug('Response from xmlrpc call: %s', response.content) result = self._parse_response(response.content) else: logging.warning( 'urlfetch.fetch of %s returned nothing.' ' This may be due to access restrictions' ' in sdc.', url) return result