addons/document_webdav/test_davclient.py

   1 #!/usr/bin/env python
   2 # -*- encoding: utf-8 -*-
   3 #
   4 # Copyright P. Christeas <p_christ@hol.gr> 2008,2009
   5 # Copyright OpenERP SA. (http://www.openerp.com) 2010
   6 #
   7 #
   8 # WARNING: This program as such is intended to be used by professional
   9 # programmers who take the whole responsability of assessing all potential
  10 # consequences resulting from its eventual inadequacies and bugs
  11 # End users who are looking for a ready-to-use solution with commercial
  12 # garantees and support are strongly adviced to contract a Free Software
  13 # Service Company
  14 #
  15 # This program is Free Software; you can redistribute it and/or
  16 # modify it under the terms of the GNU General Public License
  17 # as published by the Free Software Foundation; either version 2
  18 # of the License, or (at your option) any later version.
  19 #
  20 # This program is distributed in the hope that it will be useful,
  21 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 # GNU General Public License for more details.
  24 #
  25 # You should have received a copy of the GNU General Public License
  26 # along with this program; if not, write to the Free Software
  27 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28 ###############################################################################
  29
  30 """ A trivial HTTP/WebDAV client, used for testing the server
  31 """
  32 # code taken from the 'http-client.py' script:
  33 # http://git.hellug.gr/?p=xrg/openerp;a=history;f=tests/http-client.py;hb=refs/heads/xrg-60
  34
  35 import gzip
  36 import logging
  37 import xml.dom.minidom
  38
  39 import httplib
  40
  41 from tools import config
  42 from xmlrpclib import Transport, ProtocolError
  43 import StringIO
  44 import base64
  45
  46 log = logging.getLogger('http-client')
  47
  48 class HTTP11(httplib.HTTP):
  49         _http_vsn = 11
  50         _http_vsn_str = 'HTTP/1.1'
  51
  52 class PersistentTransport(Transport):
  53     """Handles an HTTP transaction to an XML-RPC server, persistently."""
  54
  55     def __init__(self, use_datetime=0):
  56         self._use_datetime = use_datetime
  57         self._http = {}
  58         log.debug("Using persistent transport")
  59
  60     def make_connection(self, host):
  61         # create a HTTP connection object from a host descriptor
  62         if not self._http.has_key(host):
  63                 host, extra_headers, x509 = self.get_host_info(host)
  64                 self._http[host] = HTTP11(host)
  65                 log.debug("New connection to %s", host)
  66         return self._http[host]
  67
  68     def get_host_info(self, host):
  69         host, extra_headers, x509 = Transport.get_host_info(self,host)
  70         if extra_headers == None:
  71                 extra_headers = []
  72
  73         extra_headers.append( ( 'Connection', 'keep-alive' ))
  74
  75         return host, extra_headers, x509
  76
  77     def _parse_response(self, file, sock, response):
  78         """ read response from input file/socket, and parse it
  79             We are persistent, so it is important to only parse
  80             the right amount of input
  81         """
  82
  83         p, u = self.getparser()
  84
  85         if response.msg.get('content-encoding') == 'gzip':
  86             gzdata = StringIO.StringIO()
  87             while not response.isclosed():
  88                 rdata = response.read(1024)
  89                 if not rdata:
  90                     break
  91                 gzdata.write(rdata)
  92             gzdata.seek(0)
  93             rbuffer = gzip.GzipFile(mode='rb', fileobj=gzdata)
  94             while True:
  95                 respdata = rbuffer.read()
  96                 if not respdata:
  97                     break
  98                 p.feed(respdata)
  99         else:
 100             while not response.isclosed():
 101                 rdata = response.read(1024)
 102                 if not rdata:
 103                         break
 104                 p.feed(rdata)
 105                 if len(rdata)<1024:
 106                         break
 107
 108         p.close()
 109         return u.close()
 110
 111     def request(self, host, handler, request_body, verbose=0):
 112         # issue XML-RPC request
 113
 114         h = self.make_connection(host)
 115         if verbose:
 116             h.set_debuglevel(1)
 117
 118         self.send_request(h, handler, request_body)
 119         self.send_host(h, host)
 120         self.send_user_agent(h)
 121         self.send_content(h, request_body)
 122
 123         resp = h._conn.getresponse()
 124         # TODO: except BadStatusLine, e:
 125
 126         errcode, errmsg, headers = resp.status, resp.reason, resp.msg
 127
 128
 129         if errcode != 200:
 130             raise ProtocolError(
 131                 host + handler,
 132                 errcode, errmsg,
 133                 headers
 134                 )
 135
 136         self.verbose = verbose
 137
 138         try:
 139             sock = h._conn.sock
 140         except AttributeError:
 141             sock = None
 142
 143         return self._parse_response(h.getfile(), sock, resp)
 144
 145 class CompressedTransport(PersistentTransport):
 146     def send_content(self, connection, request_body):
 147         connection.putheader("Content-Type", "text/xml")
 148
 149         if len(request_body) > 512 or True:
 150             buffer = StringIO.StringIO()
 151             output = gzip.GzipFile(mode='wb', fileobj=buffer)
 152             output.write(request_body)
 153             output.close()
 154             buffer.seek(0)
 155             request_body = buffer.getvalue()
 156             connection.putheader('Content-Encoding', 'gzip')
 157
 158         connection.putheader("Content-Length", str(len(request_body)))
 159         connection.putheader("Accept-Encoding",'gzip')
 160         connection.endheaders()
 161         if request_body:
 162             connection.send(request_body)
 163
 164     def send_request(self, connection, handler, request_body):
 165         connection.putrequest("POST", handler, skip_accept_encoding=1)
 166
 167 class SafePersistentTransport(PersistentTransport):
 168     def make_connection(self, host):
 169         # create a HTTP connection object from a host descriptor
 170         if not self._http.has_key(host):
 171                 host, extra_headers, x509 = self.get_host_info(host)
 172                 self._http[host] = httplib.HTTPS(host, None, **(x509 or {}))
 173                 log.debug("New connection to %s", host)
 174         return self._http[host]
 175
 176 class AuthClient(object):
 177     def getAuth(self, atype, realm):
 178         raise NotImplementedError("Cannot authenticate for %s" % atype)
 179
 180     def resolveFailedRealm(self, realm):
 181         """ Called when, using a known auth type, the realm is not in cache
 182         """
 183         raise NotImplementedError("Cannot authenticate for realm %s" % realm)
 184
 185 class BasicAuthClient(AuthClient):
 186     def __init__(self):
 187         self._realm_dict = {}
 188
 189     def getAuth(self, atype, realm):
 190         if atype != 'Basic' :
 191             return super(BasicAuthClient,self).getAuth(atype, realm)
 192
 193         if not self._realm_dict.has_key(realm):
 194             log.debug("realm dict: %r", self._realm_dict)
 195             log.debug("missing key: \"%s\"" % realm)
 196             self.resolveFailedRealm(realm)
 197         return 'Basic '+ self._realm_dict[realm]
 198
 199     def addLogin(self, realm, username, passwd):
 200         """ Add some known username/password for a specific login.
 201             This function should be called once, for each realm
 202             that we want to authenticate against
 203         """
 204         assert realm
 205         auths = base64.encodestring(username + ':' + passwd)
 206         if auths[-1] == "\n":
 207             auths = auths[:-1]
 208         self._realm_dict[realm] = auths
 209
 210 class addAuthTransport:
 211     """ Intermediate class that authentication algorithm to http transport
 212     """
 213
 214     def setAuthClient(self, authobj):
 215         """ Set the authentication client object.
 216             This method must be called before any request is issued, that
 217             would require http authentication
 218         """
 219         assert isinstance(authobj, AuthClient)
 220         self._auth_client = authobj
 221
 222
 223     def request(self, host, handler, request_body, verbose=0):
 224         # issue XML-RPC request
 225
 226         h = self.make_connection(host)
 227         if verbose:
 228             h.set_debuglevel(1)
 229
 230         tries = 0
 231         atype = None
 232         realm = None
 233
 234         while(tries < 3):
 235             self.send_request(h, handler, request_body)
 236             self.send_host(h, host)
 237             self.send_user_agent(h)
 238             if atype:
 239                 # This line will bork if self.setAuthClient has not
 240                 # been issued. That is a programming error, fix your code!
 241                 auths = self._auth_client.getAuth(atype, realm)
 242                 log.debug("sending authorization: %s", auths)
 243                 h.putheader('Authorization', auths)
 244             self.send_content(h, request_body)
 245
 246             resp = h._conn.getresponse()
 247             #  except BadStatusLine, e:
 248             tries += 1
 249
 250             if resp.status == 401:
 251                 if 'www-authenticate' in resp.msg:
 252                     (atype,realm) = resp.msg.getheader('www-authenticate').split(' ',1)
 253                     data1 = resp.read()
 254                     if data1:
 255                         log.warning("Why have data on a 401 auth. message?")
 256                     if realm.startswith('realm="') and realm.endswith('"'):
 257                         realm = realm[7:-1]
 258                     log.debug("Resp: %r %r", resp.version,resp.isclosed(), resp.will_close)
 259                     log.debug("Want to do auth %s for realm %s", atype, realm)
 260                     if atype != 'Basic':
 261                         raise ProtocolError(host+handler, 403,
 262                                         "Unknown authentication method: %s" % atype, resp.msg)
 263                     continue # with the outer while loop
 264                 else:
 265                     raise ProtocolError(host+handler, 403,
 266                                 'Server-incomplete authentication', resp.msg)
 267
 268             if resp.status != 200:
 269                 raise ProtocolError( host + handler,
 270                     resp.status, resp.reason, resp.msg )
 271
 272             self.verbose = verbose
 273
 274             try:
 275                 sock = h._conn.sock
 276             except AttributeError:
 277                 sock = None
 278
 279             return self._parse_response(h.getfile(), sock, resp)
 280
 281         raise ProtocolError(host+handler, 403, "No authentication",'')
 282
 283 class PersistentAuthTransport(addAuthTransport,PersistentTransport):
 284     pass
 285
 286 class PersistentAuthCTransport(addAuthTransport,CompressedTransport):
 287     pass
 288
 289 class HTTPSConnection(httplib.HTTPSConnection):
 290         certs_file = None
 291         def connect(self):
 292             "Connect to a host on a given (SSL) port. check the certificate"
 293             import socket, ssl
 294
 295             if HTTPSConnection.certs_file:
 296                 ca_certs = HTTPSConnection.certs_file
 297                 cert_reqs = ssl.CERT_REQUIRED
 298             else:
 299                 ca_certs = None
 300                 cert_reqs = ssl.CERT_NONE
 301             sock = socket.create_connection((self.host, self.port), self.timeout)
 302             self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
 303                                 ca_certs=ca_certs,
 304                                 cert_reqs=cert_reqs)
 305
 306
 307         def getpeercert(self):
 308                 import ssl
 309                 cert = None
 310                 if self.sock:
 311                         cert =  self.sock.getpeercert()
 312                 else:
 313                         cert = ssl.get_server_certificate((self.host,self.port),
 314                                 ssl_version=ssl.PROTOCOL_SSLv23 )
 315                         lf = (len(ssl.PEM_FOOTER)+1)
 316                         if cert[0-lf] != '\n':
 317                                 cert = cert[:0-lf]+'\n'+cert[0-lf:]
 318                         log.debug("len-footer: %s cert: %r", lf, cert[0-lf])
 319
 320                 return cert
 321
 322
 323 class DAVClient(object):
 324     """An instance of a WebDAV client, connected to the OpenERP server
 325     """
 326
 327     def __init__(self, user=None, passwd=None, dbg=0, use_ssl=False, useragent=False):
 328         if use_ssl:
 329             self.host = config.get_misc('httpsd', 'interface', False)
 330             self.port = config.get_misc('httpsd', 'port', 8071)
 331             if not self.host:
 332                 self.host = config.get('xmlrpcs_interface')
 333                 self.port = config.get('xmlrpcs_port')
 334         else:
 335             self.host = config.get_misc('httpd', 'interface')
 336             self.port = config.get_misc('httpd', 'port', 8069)
 337             if not self.host:
 338                 self.host = config.get('xmlrpc_interface')
 339                 self.port = config.get('xmlrpc_port') or self.port
 340         if self.host == '0.0.0.0' or not self.host:
 341             self.host = '127.0.0.1'
 342         self.port = int(self.port)
 343         if not config.get_misc('webdav','enable',True):
 344             raise Exception("WebDAV is disabled, cannot continue")
 345         self.davpath = '/' + config.get_misc('webdav','vdir','webdav')
 346         self.user = user
 347         self.passwd = passwd
 348         self.dbg = dbg
 349         self.hdrs = {}
 350         if useragent:
 351             self.set_useragent(useragent)
 352
 353     def get_creds(self, obj, cr, uid):
 354         """Read back the user credentials from cr, uid
 355
 356         @param obj is any orm object, in order to use its pool
 357         @param uid is the numeric id, which we will try to reverse resolve
 358
 359         note: this is a hackish way to get the credentials. It is expected
 360         to break if "base_crypt" is used.
 361         """
 362         ruob = obj.pool.get('res.users')
 363         res = ruob.read(cr, 1, [uid,], ['login', 'password'])
 364         assert res, "uid %s not found" % uid
 365         self.user = res[0]['login']
 366         self.passwd = res[0]['password']
 367         return True
 368
 369     def set_useragent(self, uastr):
 370         """ Set the user-agent header to something meaningful.
 371         Some shorthand names will be replaced by stock strings.
 372         """
 373         if uastr in ('KDE4', 'Korganizer'):
 374             self.hdrs['User-Agent'] = "Mozilla/5.0 (compatible; Konqueror/4.4; Linux) KHTML/4.4.3 (like Gecko)"
 375         elif uastr == 'iPhone3':
 376             self.hdrs['User-Agent'] = "DAVKit/5.0 (765); iCalendar/5.0 (79); iPhone/4.1 8B117"
 377         elif uastr == "MacOS":
 378             self.hdrs['User-Agent'] = "WebDAVFS/1.8 (01808000) Darwin/9.8.0 (i386)"
 379         else:
 380             self.hdrs['User-Agent'] = uastr
 381
 382     def _http_request(self, path, method='GET', hdrs=None, body=None):
 383         if not hdrs:
 384             hdrs = {}
 385         import base64
 386         dbg = self.dbg
 387         hdrs.update(self.hdrs)
 388         log.debug("Getting %s http://%s:%d/%s", method, self.host, self.port, path)
 389         conn = httplib.HTTPConnection(self.host, port=self.port)
 390         conn.set_debuglevel(dbg)
 391         if not path:
 392             path = "/index.html"
 393         if not hdrs.has_key('Connection'):
 394                 hdrs['Connection']= 'keep-alive'
 395         conn.request(method, path, body, hdrs )
 396         try:
 397                 r1 = conn.getresponse()
 398         except httplib.BadStatusLine, bsl:
 399                 log.warning("Bad status line: %s", bsl.line)
 400                 raise Exception('Bad status line')
 401         if r1.status == 401: # and r1.headers:
 402                 if 'www-authenticate' in r1.msg:
 403                         (atype,realm) = r1.msg.getheader('www-authenticate').split(' ',1)
 404                         data1 = r1.read()
 405                         if not self.user:
 406                                 raise Exception('Must auth, have no user/pass!')
 407                         log.debug("Ver: %s, closed: %s, will close: %s", r1.version,r1.isclosed(), r1.will_close)
 408                         log.debug("Want to do auth %s for realm %s", atype, realm)
 409                         if atype == 'Basic' :
 410                                 auths = base64.encodestring(self.user + ':' + self.passwd)
 411                                 if auths[-1] == "\n":
 412                                         auths = auths[:-1]
 413                                 hdrs['Authorization']= 'Basic '+ auths
 414                                 #sleep(1)
 415                                 conn.request(method, path, body, hdrs )
 416                                 r1 = conn.getresponse()
 417                         else:
 418                                 raise Exception("Unknown auth type %s" %atype)
 419                 else:
 420                         log.warning("Got 401, cannot auth")
 421                         raise Exception('No auth')
 422
 423         log.debug("Reponse: %s %s",r1.status, r1.reason)
 424         data1 = r1.read()
 425         if method != 'GET':
 426             log.debug("Body:\n%s\nEnd of body", data1)
 427             try:
 428                 ctype = r1.msg.getheader('content-type')
 429                 if ctype and ';' in ctype:
 430                     ctype, encoding = ctype.split(';',1)
 431                 if ctype == 'text/xml':
 432                     doc = xml.dom.minidom.parseString(data1)
 433                     log.debug("XML Body:\n %s", doc.toprettyxml(indent="\t"))
 434             except Exception:
 435                 log.warning("could not print xml", exc_info=True)
 436                 pass
 437         conn.close()
 438         return r1.status, r1.msg, data1
 439
 440     def _assert_headers(self, expect, msg):
 441         """ Assert that the headers in msg contain the expect values
 442         """
 443         for k, v in expect.items():
 444             hval = msg.getheader(k)
 445             if not hval:
 446                 raise AssertionError("Header %s not defined in http response" % k)
 447             if isinstance(v, (list, tuple)):
 448                 delim = ','
 449                 hits = map(str.strip, hval.split(delim))
 450                 mvits= []
 451                 for vit in v:
 452                     if vit not in hits:
 453                         mvits.append(vit)
 454                 if mvits:
 455                     raise AssertionError("HTTP header \"%s\" is missing: %s" %(k, ', '.join(mvits)))
 456             else:
 457                 if hval.strip() != v.strip():
 458                     raise AssertionError("HTTP header \"%s: %s\"" % (k, hval))
 459
 460     def gd_options(self, path='*', expect=None):
 461         """ Test the http options functionality
 462             If a dictionary is defined in expect, those options are
 463             asserted.
 464         """
 465         if path != '*':
 466             path = self.davpath + path
 467         hdrs = { 'Content-Length': 0
 468                 }
 469         s, m, d = self._http_request(path, method='OPTIONS', hdrs=hdrs)
 470         assert s == 200, "Status: %r" % s
 471         assert 'OPTIONS' in m.getheader('Allow')
 472         log.debug('Options: %r', m.getheader('Allow'))
 473
 474         if expect:
 475             self._assert_headers(expect, m)
 476
 477     def _parse_prop_response(self, data):
 478         """ Parse a propfind/propname response
 479         """
 480         def getText(node):
 481             rc = []
 482             for node in node.childNodes:
 483                 if node.nodeType == node.TEXT_NODE:
 484                     rc.append(node.data)
 485             return ''.join(rc)
 486
 487         def getElements(node, namespaces=None, strict=False):
 488             for cnod in node.childNodes:
 489                 if cnod.nodeType != node.ELEMENT_NODE:
 490                     if strict:
 491                         log.debug("Found %r inside <%s>", cnod, node.tagName)
 492                     continue
 493                 if namespaces and (cnod.namespaceURI not in namespaces):
 494                     log.debug("Ignoring <%s> in <%s>", cnod.tagName, node.localName)
 495                     continue
 496                 yield cnod
 497
 498         nod = xml.dom.minidom.parseString(data)
 499         nod_r = nod.documentElement
 500         res = {}
 501         assert nod_r.localName == 'multistatus', nod_r.tagName
 502         for resp in nod_r.getElementsByTagNameNS('DAV:', 'response'):
 503             href = None
 504             status = 200
 505             res_nss = {}
 506             for cno in getElements(resp, namespaces=['DAV:',]):
 507                 if cno.localName == 'href':
 508                     assert href is None, "Second href in same response"
 509                     href = getText(cno)
 510                 elif cno.localName == 'propstat':
 511                     for pno in getElements(cno, namespaces=['DAV:',]):
 512                         rstatus = None
 513                         if pno.localName == 'prop':
 514                             for prop in getElements(pno):
 515                                 key = prop.localName
 516                                 tval = getText(prop).strip()
 517                                 val = tval or (True, rstatus or status)
 518                                 if prop.namespaceURI == 'DAV:' and prop.localName == 'resourcetype':
 519                                     val = 'plain'
 520                                     for rte in getElements(prop, namespaces=['DAV:',]):
 521                                         # Note: we only look at DAV:... elements, we
 522                                         # actually expect only one DAV:collection child
 523                                         val = rte.localName
 524                                 res_nss.setdefault(prop.namespaceURI,{})[key] = val
 525                         elif pno.localName == 'status':
 526                             rstr = getText(pno)
 527                             htver, sta, msg = rstr.split(' ', 3)
 528                             assert htver == 'HTTP/1.1'
 529                             rstatus = int(sta)
 530                         else:
 531                             log.debug("What is <%s> inside a <propstat>?", pno.tagName)
 532
 533                 else:
 534                     log.debug("Unknown node: %s", cno.tagName)
 535
 536             res.setdefault(href,[]).append((status, res_nss))
 537
 538         return res
 539
 540     def gd_propfind(self, path, props=None, depth=0):
 541         if not props:
 542             propstr = '<allprop/>'
 543         else:
 544             propstr = '<prop>'
 545             nscount = 0
 546             for p in props:
 547                 ns = None
 548                 if isinstance(p, tuple):
 549                     p, ns = p
 550                 if ns is None or ns == 'DAV:':
 551                     propstr += '<%s/>' % p
 552                 else:
 553                     propstr += '<ns%d:%s xmlns:ns%d="%s" />' %(nscount, p, nscount, ns)
 554                     nscount += 1
 555             propstr += '</prop>'
 556
 557         body="""<?xml version="1.0" encoding="utf-8"?>
 558             <propfind xmlns="DAV:">%s</propfind>""" % propstr
 559         hdrs = { 'Content-Type': 'text/xml; charset=utf-8',
 560                 'Accept': 'text/xml',
 561                 'Depth': depth,
 562                 }
 563
 564         s, m, d = self._http_request(self.davpath + path, method='PROPFIND',
 565                                     hdrs=hdrs, body=body)
 566         assert s == 207, "Bad status: %s" % s
 567         ctype = m.getheader('Content-Type').split(';',1)[0]
 568         assert ctype == 'text/xml', m.getheader('Content-Type')
 569         res = self._parse_prop_response(d)
 570         if depth == 0:
 571             assert len(res) == 1
 572             res = res.values()[0]
 573         else:
 574             assert len(res) >= 1
 575         return res
 576
 577
 578     def gd_propname(self, path, depth=0):
 579         body="""<?xml version="1.0" encoding="utf-8"?>
 580             <propfind xmlns="DAV:"><propname/></propfind>"""
 581         hdrs = { 'Content-Type': 'text/xml; charset=utf-8',
 582                 'Accept': 'text/xml',
 583                 'Depth': depth
 584                 }
 585         s, m, d = self._http_request(self.davpath + path, method='PROPFIND',
 586                                     hdrs=hdrs, body=body)
 587         assert s == 207, "Bad status: %s" % s
 588         ctype = m.getheader('Content-Type').split(';',1)[0]
 589         assert ctype == 'text/xml', m.getheader('Content-Type')
 590         res = self._parse_prop_response(d)
 591         if depth == 0:
 592             assert len(res) == 1
 593             res = res.values()[0]
 594         else:
 595             assert len(res) >= 1
 596         return res
 597
 598     def gd_getetag(self, path, depth=0):
 599         return self.gd_propfind(path, props=['getetag',], depth=depth)
 600
 601     def gd_lsl(self, path):
 602         """ Return a list of 'ls -l' kind of data for a folder
 603
 604             This is based on propfind.
 605         """
 606
 607         lspairs = [ ('name', 'displayname', 'n/a'), ('size', 'getcontentlength', '0'),
 608                 ('type', 'resourcetype', '----------'), ('uid', 'owner', 'nobody'),
 609                 ('gid', 'group', 'nogroup'), ('mtime', 'getlastmodified', 'n/a'),
 610                 ('mime', 'getcontenttype', 'application/data'), ]
 611
 612         propnames = [ l[1] for l in lspairs]
 613         propres = self.gd_propfind(path, props=propnames, depth=1)
 614
 615         res = []
 616         for href, pr in propres.items():
 617             lsline = {}
 618             for st, nsdic in pr:
 619                 davprops = nsdic['DAV:']
 620                 if st == 200:
 621                     for lsp in lspairs:
 622                         if lsp[1] in davprops:
 623                             if lsp[1] == 'resourcetype':
 624                                 if davprops[lsp[1]] == 'collection':
 625                                     lsline[lsp[0]] = 'dr-xr-x---'
 626                                 else:
 627                                     lsline[lsp[0]] = '-r-xr-x---'
 628                             else:
 629                                 lsline[lsp[0]] = davprops[lsp[1]]
 630                 elif st in (404, 403):
 631                     for lsp in lspairs:
 632                         if lsp[1] in davprops:
 633                             lsline[lsp[0]] = lsp[2]
 634                 else:
 635                     log.debug("Strange status: %s", st)
 636
 637             res.append(lsline)
 638
 639         return res
 640
 641     def gd_get(self, path, crange=None, mime=None, compare=None):
 642         """ HTTP GET for path, supporting Partial ranges
 643         """
 644         hdrs = { 'Accept': mime or '*/*', }
 645         if crange:
 646             if isinstance(crange, tuple):
 647                 crange = [crange,]
 648             if not isinstance(crange, list):
 649                 raise TypeError("Range must be a tuple or list of tuples")
 650             rs = []
 651             for r in crange:
 652                 rs.append('%d-%d' % r)
 653             hdrs['Range'] = 'bytes='+ (','.join(rs))
 654         s, m, d = self._http_request(self.davpath + path, method='GET', hdrs=hdrs)
 655         assert s in (200, 206), "Bad status: %s" % s
 656         ctype = m.getheader('Content-Type')
 657         if ctype and ';' in ctype:
 658             ctype = ctype.split(';',1)[0]
 659         if mime:
 660             assert ctype == mime, m.getheader('Content-Type')
 661         rrange = None
 662         rrh = m.getheader('Content-Range')
 663         if rrh:
 664             assert rrh.startswith('bytes '), rrh
 665             rrh=rrh[6:].split('/',1)[0]
 666             rrange = map(int, rrh.split('-',1))
 667         if compare:
 668             # we need to compare the returned data with that of compare
 669             fd = open(compare, 'rb')
 670             d2 = fd.read()
 671             fd.close()
 672             if crange:
 673                 if len(crange) > 1:
 674                     raise NotImplementedError
 675                 r = crange[0]
 676                 d2 = d2[r[0]:r[1]+1]
 677             assert d2 == d, "Data does not match"
 678         return ctype, rrange, d
 679
 680     def gd_put(self, path, body=None, srcpath=None, mime=None, noclobber=False, ):
 681         """ HTTP PUT
 682             @param noclobber will prevent overwritting a resource (If-None-Match)
 683             @param mime will set the content-type
 684         """
 685         hdrs = { }
 686         if not (body or srcpath):
 687             raise ValueError("PUT must have something to send")
 688         if (not body) and srcpath:
 689             fd = open(srcpath, 'rb')
 690             body = fd.read()
 691             fd.close()
 692         if mime:
 693             hdrs['Content-Type'] = mime
 694         if noclobber:
 695             hdrs['If-None-Match'] = '*'
 696         s, m, d = self._http_request(self.davpath + path, method='PUT',
 697                             hdrs=hdrs, body=body)
 698         assert s == (201), "Bad status: %s" % s
 699         etag = m.getheader('ETag')
 700         return etag or True
 701
 702 #eof