path: root/rpms/sugar/0105-uy-1769-1-to-N-Feature.patch

From b3c6fee84f9c3b612432b9131217a563c2a50c7a Mon Sep 17 00:00:00 2001
From: Ajay Garg <ajay@activitycentral.com>
Date: Fri, 4 May 2012 01:03:13 +0530
Subject: [sugar PATCH v5] uy#1769: 1-to-N Feature
Organization: Sugar Labs Foundation
Signed-off-by: Ajay Garg <ajay@activitycentral.com>
---

The feature specs, and workflow-screenshots, are listed at ::
http://wiki.sugarlabs.org/go/Features/Transfer_to_many_options



Changes of version-5 over version-4 ::
--------------------------------------


a)
Fixed the bug (Thanks Anish for catching this) ::

* Server adds files to "Shares" folder
* Client tries to add the Server's "Shares", by clicking on 
  "Access Share" in Neighborhood-View.
* The Server's Shares' button appears in the bottom panel-tray.
* Server disconnects from the network.
* Client tries to access the Server's Shares, by clicking on
  the Server's Shares' button.
* UI Freeze.
* No Exception in logs.


The solution is, again, to display the "Connection Failed" error, much on the 
same lines as "Entries without a file cannot be copied".
This holds true for both ===> batch-mode, and single-mode.



b)
Fixed the bug ::

* Server adds files to "Shares" folder
* Client tries to add the Server's "Shares", by clicking on 
  "Access Share" in Neighborhood-View.
* The Server's Shares' button appears in the bottom panel-tray.
* Client tries to access the Server's Shares, by clicking on
  the Server's Shares' button.
* Server's Shares' items are visible in the listview.
* Client starts copying a (large) file, say "big_image.img".
* Before the file could be downloaded from remote server, server disconnects 
  from the network.
* UI Freeze.
* No Exception in logs.


The solution is, again, to display the (socket) "Timed Out" error, much on the
same lines as "Entries without a file cannot be copied".
This holds true for both ===> batch-mode, and single-mode.



c)
Made the locally-mounted-remote-shares icon, the same as that of "Shares" folder.

Thanks to Anish for the motivation.



d)
There was a bug in "v4", wherein during server-disconnected cases, the "busy-cursor"
would persist, even when the operations were over during batch-mode. This was due to 
bug a) as listed above, which resulted in not-loading-of-listview after batch-operations
were over.

With a) fixed, this got fixed automatically.

Thanks to Anish for catching this.




===========================================================================




Changes of version-4 over version-3 ::
--------------------------------------

NOTE ::

The WebDAV backend-library being used is the one from 
https://launchpad.net/python-webdav-lib/trunk/0.3.0/+download/Python_WebDAV_Library-0.3.0.zip

The reason for using this, is purely based on not reinventing-the-wheel.
Moreover, it served the following three major purposes ::

   (i)   Open-Source, in python.
    
   (ii)  It provided the API for accessing URLs of type ::

         * dav://1.2.3.4/webdav/
         * dav://1.2.3.4/webdav/dir_1
         * dav://1.2.3.4/webdav/dir_1/dir_2
     
   (iii) It provided the API for downloading a resource (file) of type ::

         * dav://1.2.3.4/webdav/1.txt
         * dav://1.2.3.4/webdav/dir_1/2.png
         * dav://1.2.3.4/webdav/dir_1/dir_2/1743.avi


Thanks to Sascha, for the motivation of making it absolutely clear and explicit that 
the reason for using this 3rd-party library be mentioned (since I myself had to struggle 
quite a bit for finding the suitable one :) )




===========================================================================




Changes of version-3 over version-2 ::
--------------------------------------

a)
Added new icon for "Shares" folder.

For this to take effect, patch at http://patchwork.sugarlabs.org/patch/1419/
must be applied.

Thanks to Frederick Grose for the image, and Anish for validating it.




===========================================================================




Changes of version-2 over version-1 ::
--------------------------------------

a)
Fixed the bug, wherein it was required that activities should NOT be launched,
by clicking on the icons in "locally-mounted-remote-shares" listview.

Thanks Anish for providing the solution to this :)



b)
Fixed the bug (Thanks Anish for catching this) ::

* Server adds files to "Shares" folder.
* Client tries to add the Server's "Shares", by clicking on 
  "Access Share" in Neighborhood-View.
* The Server's Shares' button appears in the bottom panel-tray.
* Client tries to access the Server's Shares, by clicking on
  the Server's Shares' button.
* Server's Shares' items are visible in the listview.
* Server disconnects from the network.
* Client tries to copy files.
* UI Freeze.
* Exception in logs.


The solution is to "catch" the Connection-Failed exception, and display the error-message,
on similar lines as "Entries without a file cannot be copied."
This holds true for both ===> batch-mode, and single-mode.



c)
Did "Code Extraction" from "src/webdav/WebdavClient.py" to "src/jarabe/journal/webdavmanager.py".
Now, all files in "src/webdav" and "src/webdav/acp" directories contain code present at 
https://launchpad.net/python-webdav-lib/trunk/0.3.0/+download/Python_WebDAV_Library-0.3.0.zip

Thanks Anish, for providing the motivation.


 configure.ac                          |    4 +-
 src/Makefile.am                       |    4 +-
 src/jarabe/journal/Makefile.am        |    5 +-
 src/jarabe/journal/journalactivity.py |    3 +
 src/jarabe/journal/journaltoolbox.py  |    7 +
 src/jarabe/journal/listview.py        |    9 +
 src/jarabe/journal/model.py           |  205 ++++++++-
 src/jarabe/journal/palettes.py        |   79 +++
 src/jarabe/journal/volumestoolbar.py  |   94 ++++-
 src/jarabe/journal/webdavmanager.py   |  256 ++++++++++
 src/jarabe/model/buddy.py             |   11 +
 src/jarabe/model/neighborhood.py      |    3 +
 src/jarabe/view/buddymenu.py          |   11 +
 src/jarabe/view/palettes.py           |   33 ++
 src/webdav/Condition.py               |  475 +++++++++++++++++++
 src/webdav/Connection.py              |  321 +++++++++++++
 src/webdav/Constants.py               |  199 ++++++++
 src/webdav/Makefile.am                |   20 +
 src/webdav/NameCheck.py               |  193 ++++++++
 src/webdav/Utils.py                   |  154 ++++++
 src/webdav/VersionHandler.py          |  198 ++++++++
 src/webdav/WebdavClient.py            |  840 +++++++++++++++++++++++++++++++++
 src/webdav/WebdavRequests.py          |  205 ++++++++
 src/webdav/WebdavResponse.py          |  525 ++++++++++++++++++++
 src/webdav/__init__.py                |   16 +
 src/webdav/acp/Ace.py                 |  293 ++++++++++++
 src/webdav/acp/AceHandler.py          |  182 +++++++
 src/webdav/acp/Acl.py                 |  311 ++++++++++++
 src/webdav/acp/GrantDeny.py           |  241 ++++++++++
 src/webdav/acp/Makefile.am            |   12 +
 src/webdav/acp/Principal.py           |  189 ++++++++
 src/webdav/acp/Privilege.py           |  125 +++++
 src/webdav/acp/__init__.py            |   33 ++
 src/webdav/davlib.py                  |  336 +++++++++++++
 src/webdav/logger.py                  |   51 ++
 src/webdav/qp_xml.py                  |  240 ++++++++++
 src/webdav/uuid_.py                   |  476 +++++++++++++++++++
 37 files changed, 6340 insertions(+), 19 deletions(-)
 create mode 100644 src/jarabe/journal/webdavmanager.py
 create mode 100644 src/webdav/Condition.py
 create mode 100644 src/webdav/Connection.py
 create mode 100644 src/webdav/Constants.py
 create mode 100644 src/webdav/Makefile.am
 create mode 100644 src/webdav/NameCheck.py
 create mode 100644 src/webdav/Utils.py
 create mode 100644 src/webdav/VersionHandler.py
 create mode 100644 src/webdav/WebdavClient.py
 create mode 100644 src/webdav/WebdavRequests.py
 create mode 100644 src/webdav/WebdavResponse.py
 create mode 100644 src/webdav/__init__.py
 create mode 100644 src/webdav/acp/Ace.py
 create mode 100644 src/webdav/acp/AceHandler.py
 create mode 100644 src/webdav/acp/Acl.py
 create mode 100644 src/webdav/acp/GrantDeny.py
 create mode 100644 src/webdav/acp/Makefile.am
 create mode 100644 src/webdav/acp/Principal.py
 create mode 100644 src/webdav/acp/Privilege.py
 create mode 100644 src/webdav/acp/__init__.py
 create mode 100644 src/webdav/davlib.py
 create mode 100644 src/webdav/logger.py
 create mode 100644 src/webdav/qp_xml.py
 create mode 100644 src/webdav/uuid_.py

diff --git a/configure.ac b/configure.ac
index 8e6d871..e04bdec 100644
--- a/configure.ac
+++ b/configure.ac
@@ -61,8 +61,6 @@ extensions/cpsection/modemconfiguration/config.py
 extensions/cpsection/Makefile
 extensions/cpsection/network/Makefile
 extensions/cpsection/power/Makefile
-extensions/cpsection/updater/backends/Makefile
-extensions/cpsection/updater/Makefile
 extensions/deviceicon/Makefile
 extensions/globalkey/Makefile
 extensions/Makefile
@@ -79,6 +77,8 @@ src/jarabe/model/Makefile
 src/jarabe/util/Makefile
 src/jarabe/util/telepathy/Makefile
 src/jarabe/view/Makefile
+src/webdav/acp/Makefile
+src/webdav/Makefile
 src/Makefile
 ])
 
diff --git a/src/Makefile.am b/src/Makefile.am
index 83571a4..765da8b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1 +1,3 @@
-SUBDIRS = jarabe
+SUBDIRS =        \
+        jarabe   \
+	webdav
diff --git a/src/jarabe/journal/Makefile.am b/src/jarabe/journal/Makefile.am
index f24dcfe..8efca6d 100644
--- a/src/jarabe/journal/Makefile.am
+++ b/src/jarabe/journal/Makefile.am
@@ -15,5 +15,6 @@ sugar_PYTHON =				\
 	model.py			\
 	objectchooser.py		\
 	palettes.py			\
-	volumestoolbar.py			\
-	processdialog.py
+	volumestoolbar.py		\
+	processdialog.py                \
+	webdavmanager.py
diff --git a/src/jarabe/journal/journalactivity.py b/src/jarabe/journal/journalactivity.py
index fa308cd..1b841e9 100644
--- a/src/jarabe/journal/journalactivity.py
+++ b/src/jarabe/journal/journalactivity.py
@@ -485,6 +485,9 @@ class JournalActivity(JournalWindow):
     def is_editing_mode_present(self):
         return self._editing_mode
 
+    def get_volumes_toolbar(self):
+        return self._volumes_toolbar
+
 
 def get_journal():
     global _journal
diff --git a/src/jarabe/journal/journaltoolbox.py b/src/jarabe/journal/journaltoolbox.py
index fd14826..c3614d7 100644
--- a/src/jarabe/journal/journaltoolbox.py
+++ b/src/jarabe/journal/journaltoolbox.py
@@ -624,6 +624,13 @@ class BatchEraseButton(ToolButton, palettes.ActionItem):
                                      show_not_completed_ops_info=True)
         self.props.tooltip = _('Erase')
 
+        # De-sensitize Batch-Erase button, for locally-mounted-remote-shares.
+        from jarabe.journal.journalactivity import get_mount_point
+        current_mount_point = get_mount_point()
+
+        if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+            self.set_sensitive(False)
+
     def _get_actionable_signal(self):
         return 'clicked'
 
diff --git a/src/jarabe/journal/listview.py b/src/jarabe/journal/listview.py
index 8522dca..10f468f 100644
--- a/src/jarabe/journal/listview.py
+++ b/src/jarabe/journal/listview.py
@@ -634,6 +634,15 @@ class ListView(BaseListView):
         self.emit('volume-error', message, severity)
 
     def __icon_clicked_cb(self, cell, path):
+        # For locally-mounted remote shares, we do not want to launch
+        # by clicking on the icons.
+        # So, check if this is a part of locally-mounted-remote share,
+        # and if yes, return, without doing anything.
+        from jarabe.journal.journalactivity import get_mount_point
+        current_mount_point = get_mount_point()
+        if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+            return
+
         row = self.tree_view.get_model()[path]
         metadata = model.get(row[ListModel.COLUMN_UID])
         misc.resume(metadata)
diff --git a/src/jarabe/journal/model.py b/src/jarabe/journal/model.py
index 83e216f..527f78d 100644
--- a/src/jarabe/journal/model.py
+++ b/src/jarabe/journal/model.py
@@ -20,6 +20,7 @@
 
 import logging
 import os
+import stat
 import errno
 import subprocess
 from datetime import datetime
@@ -36,11 +37,14 @@ import gobject
 import dbus
 import gio
 import gconf
+import string
 
 from sugar import dispatch
 from sugar import mime
 from sugar import util
 
+from jarabe.journal.webdavmanager import get_remote_webdav_share_metadata
+
 DS_DBUS_SERVICE = 'org.laptop.sugar.DataStore'
 DS_DBUS_INTERFACE = 'org.laptop.sugar.DataStore'
 DS_DBUS_PATH = '/org/laptop/sugar/DataStore'
@@ -425,6 +429,123 @@ class InplaceResultSet(BaseResultSet):
         return
 
 
+class RemoteShareResultSet(object):
+    def __init__(self, ip_address, query):
+        self._ip_address = ip_address
+        self._file_list = []
+
+        self.ready = dispatch.Signal()
+        self.progress = dispatch.Signal()
+
+        # First time, query is none.
+        if query is None:
+            return
+
+        query_text = query.get('query', '')
+        if query_text.startswith('"') and query_text.endswith('"'):
+            self._regex = re.compile('*%s*' % query_text.strip(['"']))
+        elif query_text:
+            expression = ''
+            for word in query_text.split(' '):
+                expression += '(?=.*%s.*)' % word
+            self._regex = re.compile(expression, re.IGNORECASE)
+        else:
+            self._regex = None
+
+        if query.get('timestamp', ''):
+            self._date_start = int(query['timestamp']['start'])
+            self._date_end = int(query['timestamp']['end'])
+        else:
+            self._date_start = None
+            self._date_end = None
+
+        self._mime_types = query.get('mime_type', [])
+
+        self._sort = query.get('order_by', ['+timestamp'])[0]
+
+    def setup(self):
+        metadata_list_complete = get_remote_webdav_share_metadata(self._ip_address)
+        for metadata in metadata_list_complete:
+
+            add_to_list = False
+            if self._regex is not None:
+                for f in ['fulltext', 'title',
+                          'description', 'tags']:
+                    if f in metadata and \
+                            self._regex.match(metadata[f]):
+                        add_to_list = True
+                        break
+            else:
+                add_to_list = True
+            if not add_to_list:
+                continue
+
+            add_to_list = False
+            if self._date_start is not None:
+                if metadata['timestamp'] > self._date_start:
+                    add_to_list = True
+            else:
+                add_to_list = True
+            if not add_to_list:
+                continue
+
+            add_to_list = False
+            if self._date_end is not None:
+                if metadata['timestamp'] < self._date_end:
+                    add_to_list = True
+            else:
+                add_to_list = True
+            if not add_to_list:
+                continue
+
+            add_to_list = False
+            if self._mime_types:
+                mime_type = metadata['mime_type']
+                if mime_type in self._mime_types:
+                    add_to_list = True
+            else:
+                add_to_list = True
+            if not add_to_list:
+                continue
+
+            # If control reaches here, the current metadata has passed
+            # out all filter-tests.
+            file_info = (metadata['timestamp'],
+                         metadata['creation_time'],
+                         metadata['filesize'],
+                         metadata)
+            self._file_list.append(file_info)
+
+        if self._sort[1:] == 'filesize':
+            keygetter = itemgetter(2)
+        elif self._sort[1:] == 'creation_time':
+            keygetter = itemgetter(1)
+        else:
+            # timestamp
+            keygetter = itemgetter(0)
+
+        self._file_list.sort(lambda a, b: cmp(b, a),
+                             key=keygetter,
+                             reverse=(self._sort[0] == '-'))
+
+        self.ready.send(self)
+
+    def get_length(self):
+        return len(self._file_list)
+
+    length = property(get_length)
+
+    def seek(self, position):
+        self._position = position
+
+    def read(self):
+        modified_timestamp, creation_timestamp, filesize, metadata =  self._file_list[self._position]
+        return  metadata
+
+    def stop(self):
+        self._stopped = True
+
+
 def _get_file_metadata(path, stat, fetch_preview=True):
     """Return the metadata from the corresponding file.
 
@@ -436,10 +557,16 @@ def _get_file_metadata(path, stat, fetch_preview=True):
     dir_path = os.path.dirname(path)
     metadata = _get_file_metadata_from_json(dir_path, filename, fetch_preview)
     if metadata:
+        # For Documents/Shares/Mounted-Drives.
+        # Special case: for locally-mounted-remote-files, ensure that
+        # "metadata['filesize' is already present before-hand. This
+        # will have to be done at the time of fetching
+        # webdav-properties per resource.
         if 'filesize' not in metadata:
             metadata['filesize'] = stat.st_size
         return metadata
 
+    # For Journal.
     return {'uid': path,
             'title': os.path.basename(path),
             'timestamp': stat.st_mtime,
@@ -529,11 +656,33 @@ def find(query_, page_size):
         raise ValueError('Exactly one mount point must be specified')
 
     if mount_points[0] == '/':
+        """
+        For Journal.
+        """
         return DatastoreResultSet(query, page_size)
+    elif is_mount_point_for_locally_mounted_remote_share(mount_points[0]):
+        """
+        For Locally-Mounted-Remote-Shares.
+        Regex Matching is used, to ensure that the mount-point is an
+        IP-Address.
+        """
+        return RemoteShareResultSet(mount_points[0], query)
     else:
+        """
+        For Documents/Shares/Mounted-Drives.
+        """
         return InplaceResultSet(query, page_size, mount_points[0])
 
 
+def is_mount_point_for_locally_mounted_remote_share(mount_point):
+    import re
+
+    pattern = '[1-9][0-9]{0,2}\.[0-9]{0,3}\.[0-9]{0,3}\.[0-9]{0,3}'
+    if re.match(pattern, mount_point) is None:
+        return False
+    return True
+
+
 def _get_mount_point(path):
     dir_path = os.path.dirname(path)
     while dir_path:
@@ -544,14 +693,45 @@ def _get_mount_point(path):
     return None
 
 
+def is_locally_mounted_remote_share(path):
+    return string.find(path, '/tmp/') == 0
+
+
+def extract_ip_address_from_locally_mounted_remote_share_path(path):
+    """
+    Path is of type ::
+
+        /tmp/127.0.0.1/webdav/a.txt
+    """
+    return path.split('/')[2]
+
+
 def get(object_id):
     """Returns the metadata for an object
     """
-    if os.path.exists(object_id):
-        stat = os.stat(object_id)
+    if (os.path.exists(object_id) or (is_locally_mounted_remote_share(object_id))):
+        """
+        For Documents/Shares/Mounted-Drives/Locally-Mounted-Remote-Shares,
+        where ".Sugar-Metadata" folder exists.
+
+        The only thing is that, for locally-mounted-remote-shares, the
+        "file" is not physically present.
+        """
+        if os.path.exists(object_id):
+            # if the file is physically present, derive file-metadata
+            # by physical examination of the file.
+            stat = os.stat(object_id)
+        else:
+            # if the file is remote, derive file-metadata by fetching
+            # properties remotely (webdav properties).
+            stat = None
+
         metadata = _get_file_metadata(object_id, stat)
         metadata['mountpoint'] = _get_mount_point(object_id)
     else:
+        """
+        For journal, where ".Sugar-Metadata" folder does not exists.
+        """
         metadata = _get_datastore().get_properties(object_id, byte_arrays=True)
         metadata['mountpoint'] = '/'
     return metadata
@@ -561,9 +741,16 @@ def get_file(object_id):
     """Returns the file for an object
     """
     if os.path.exists(object_id):
+        """
+        For Documents/Shares/Mounted-Drives/
+        Locally-Mounted-Remote-Shares-in-case-when-it-is-present-already.
+        """
         logging.debug('get_file asked for file with path %r', object_id)
         return object_id
     else:
+        """
+        For Journal.
+        """
         logging.debug('get_file asked for entry with id %r', object_id)
         file_path = _get_datastore().get_filename(object_id)
         if file_path:
@@ -754,6 +941,20 @@ def _write_entry_on_external_device(metadata, file_path):
         _rename_entry_on_external_device(file_path, destination_path,
                                          metadata_dir_path)
 
+    # For "Shares" folder, we need to set the permissions of the newly
+    # copied file to 0777, else it will not be accessible by "httpd"
+    # service.
+    if metadata['mountpoint'] == '/var/www/web1/web':
+        fd = os.open(destination_path, os.O_RDONLY)
+        os.fchmod(fd, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+        os.close(fd)
+
+        metadata_file_path = os.path.join(metadata_dir_path, file_name + '.metadata')
+        fd = os.open(metadata_file_path, os.O_RDONLY)
+        os.fchmod(fd, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+        os.close(fd)
+
+
     object_id = destination_path
     created.send(None, object_id=object_id)
 
diff --git a/src/jarabe/journal/palettes.py b/src/jarabe/journal/palettes.py
index 740b65a..46ade98 100644
--- a/src/jarabe/journal/palettes.py
+++ b/src/jarabe/journal/palettes.py
@@ -29,6 +29,7 @@ import gconf
 import gio
 import glib
 import time
+import socket
 
 from sugar import _sugarext
 
@@ -45,6 +46,10 @@ from jarabe.model import mimeregistry
 from jarabe.journal import misc
 from jarabe.journal import model
 
+from webdav.Connection import WebdavError
+from jarabe.journal.webdavmanager import get_resource_by_ip_address_and_resource_key
+
+
 friends_model = friends.get_model()
 
 _copy_menu_helper = None
@@ -77,6 +82,9 @@ class ObjectPalette(Palette):
         Palette.__init__(self, primary_text=title,
                          icon=activity_icon)
 
+        from jarabe.journal.journalactivity import get_mount_point
+        current_mount_point = get_mount_point()
+
         if misc.get_activities(metadata) or misc.is_bundle(metadata):
             if metadata.get('activity_id', ''):
                 resume_label = _('Resume')
@@ -86,10 +94,15 @@ class ObjectPalette(Palette):
                 resume_with_label = _('Start with')
             menu_item = MenuItem(resume_label, 'activity-start')
             menu_item.connect('activate', self.__start_activate_cb)
+            if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+                menu_item.set_sensitive(False)
             self.menu.append(menu_item)
             menu_item.show()
 
             menu_item = MenuItem(resume_with_label, 'activity-start')
+            if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+                menu_item.set_sensitive(False)
+
             self.menu.append(menu_item)
             menu_item.show()
             start_with_menu = StartWithMenu(self._metadata)
@@ -101,6 +114,7 @@ class ObjectPalette(Palette):
             self.menu.append(menu_item)
             menu_item.show()
 
+
         menu_item = MenuItem(_('Copy to'))
         icon = Icon(icon_name='edit-copy', xo_color=color,
                     icon_size=gtk.ICON_SIZE_MENU)
@@ -120,16 +134,21 @@ class ObjectPalette(Palette):
         copy_menu.connect('volume-error', self.__volume_error_cb)
         menu_item.set_submenu(copy_menu)
 
+
         if self._metadata['mountpoint'] == '/':
             menu_item = MenuItem(_('Duplicate'))
             icon = Icon(icon_name='edit-duplicate', xo_color=color,
                         icon_size=gtk.ICON_SIZE_MENU)
             menu_item.set_image(icon)
             menu_item.connect('activate', self.__duplicate_activate_cb)
+            if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+                menu_item.set_sensitive(False)
             self.menu.append(menu_item)
             menu_item.show()
 
         menu_item = MenuItem(_('Send to'), 'document-send')
+        if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+            menu_item.set_sensitive(False)
         self.menu.append(menu_item)
         menu_item.show()
 
@@ -140,14 +159,19 @@ class ObjectPalette(Palette):
         if detail == True:
             menu_item = MenuItem(_('View Details'), 'go-right')
             menu_item.connect('activate', self.__detail_activate_cb)
+            if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+                menu_item.set_sensitive(False)
             self.menu.append(menu_item)
             menu_item.show()
 
         menu_item = MenuItem(_('Erase'), 'list-remove')
         menu_item.connect('activate', self.__erase_activate_cb)
+        if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+            menu_item.set_sensitive(False)
         self.menu.append(menu_item)
         menu_item.show()
 
+
     def __start_activate_cb(self, menu_item):
         misc.resume(self._metadata)
 
@@ -541,6 +565,31 @@ class ActionItem(gobject.GObject):
         self._post_operate_per_metadata_per_action(metadata)
 
     def _file_path_valid(self, metadata):
+        from jarabe.journal.journalactivity import get_mount_point
+        current_mount_point = get_mount_point()
+
+        # Now, for locally mounted remote-shares, download the file.
+        # Note that, always download the file, to avoid the problems
+        # of stale-cache.
+        if model.is_mount_point_for_locally_mounted_remote_share(current_mount_point):
+            file_path = metadata['uid']
+            filename = os.path.basename(file_path)
+            ip_address = model.extract_ip_address_from_locally_mounted_remote_share_path(file_path)
+            resource = get_resource_by_ip_address_and_resource_key(ip_address, '/webdav/' + filename)
+            download_file_path = '/tmp/' + ip_address + '/' + filename
+            try:
+                resource.downloadFile(download_file_path)
+                return True
+            except (WebdavError, socket.error), e:
+                error_message = e
+                logging.warn(error_message)
+                if self._batch_mode:
+                    self._handle_error_alert(error_message, metadata)
+                else:
+                    self.emit('volume-error', error_message,
+                            _('Error'))
+                return False
+
         file_path = model.get_file(metadata['uid'])
         if not file_path or not os.path.exists(file_path):
             logging.warn('Entries without a file cannot be copied.')
@@ -708,6 +757,25 @@ class DocumentsMenu(BaseCopyMenuItem):
         self._post_operate_per_metadata_per_action(metadata)
 
 
+class SharesMenu(BaseCopyMenuItem):
+    def __init__(self, metadata_list, show_editing_alert,
+                 show_progress_info_alert, batch_mode):
+        BaseCopyMenuItem.__init__(self, metadata_list, _('Shares'),
+                                  show_editing_alert,
+                                  show_progress_info_alert,
+                                  batch_mode)
+
+    def _operate(self, metadata):
+        if not self._file_path_valid(metadata):
+            return False
+        if not self._metadata_copy_valid(metadata,
+                                         '/var/www/web1/web'):
+            return False
+
+        # This is sync-operation. Call the post-operation now.
+        self._post_operate_per_metadata_per_action(metadata)
+
+
 class FriendsMenu(gtk.Menu):
     __gtype_name__ = 'JournalFriendsMenu'
 
@@ -835,6 +903,17 @@ class CopyMenuHelper(gtk.Menu):
             menu.append(documents_menu)
             documents_menu.show()
 
+        if get_mount_point() != '/var/www/web1/web':
+            documents_menu = SharesMenu(metadata_list,
+                                           show_editing_alert,
+                                           show_progress_info_alert,
+                                           batch_mode)
+            documents_menu.set_image(Icon(icon_name='emblem-neighborhood-shared',
+                                          icon_size=gtk.ICON_SIZE_MENU))
+            documents_menu.connect('volume-error', self.__volume_error_cb)
+            menu.append(documents_menu)
+            documents_menu.show()
+
         if get_mount_point() != '/':
             client = gconf.client_get_default()
             color = XoColor(client.get_string('/desktop/sugar/user/color'))
diff --git a/src/jarabe/journal/volumestoolbar.py b/src/jarabe/journal/volumestoolbar.py
index 94914e6..1f6e3ec 100644
--- a/src/jarabe/journal/volumestoolbar.py
+++ b/src/jarabe/journal/volumestoolbar.py
@@ -37,8 +37,10 @@ from sugar.graphics.palette import Palette
 from sugar.graphics.xocolor import XoColor
 from sugar import env
 
+from jarabe.frame.notification import NotificationIcon
 from jarabe.journal import model
-from jarabe.view.palettes import JournalVolumePalette, JournalXSPalette
+from jarabe.view.palettes import JournalVolumePalette, JournalXSPalette, RemoteSharePalette
+import jarabe.frame
 
 
 _JOURNAL_0_METADATA_DIR = '.olpc.store'
@@ -209,6 +211,7 @@ class VolumesToolbar(gtk.Toolbar):
 
     def _set_up_volumes(self):
         self._set_up_documents_button()
+        self._set_up_shares_button()
 
         volume_monitor = gio.volume_monitor_get()
         self._mount_added_hid = volume_monitor.connect('mount-added',
@@ -219,12 +222,11 @@ class VolumesToolbar(gtk.Toolbar):
         for mount in volume_monitor.get_mounts():
             self._add_button(mount)
 
-    def _set_up_documents_button(self):
-        documents_path = model.get_documents_path()
-        if documents_path is not None:
-            button = DocumentsButton(documents_path)
+    def _set_up_directory_button(self, dir_path, icon_name, label_text):
+        if dir_path is not None:
+            button = DirectoryButton(dir_path, icon_name)
             button.props.group = self._volume_buttons[0]
-            label = glib.markup_escape_text(_('Documents'))
+            label = glib.markup_escape_text(label_text)
             button.set_palette(Palette(label))
             button.connect('toggled', self._button_toggled_cb)
             button.show()
@@ -234,6 +236,39 @@ class VolumesToolbar(gtk.Toolbar):
             self._volume_buttons.append(button)
             self.show()
 
+    def _set_up_documents_button(self):
+        documents_path = model.get_documents_path()
+        self._set_up_directory_button(documents_path,
+                                      'user-documents',
+                                      _('Documents'))
+
+    def _set_up_shares_button(self):
+        shares_dir_path = '/var/www/web1/web'
+        self._set_up_directory_button(shares_dir_path,
+                                      'emblem-neighborhood-shared',
+                                      _('Shares'))
+
+    def _add_remote_share_button(self, buddy):
+        button = RemoteSharesButton(buddy)
+        button.props.group = self._volume_buttons[0]
+        label = glib.markup_escape_text(_('%s\'s share') % \
+                                        buddy.props.nick)
+        button.set_palette(RemoteSharePalette(buddy, button))
+        button.connect('toggled', self._button_toggled_cb)
+        button.show()
+
+        position = self.get_item_index(self._volume_buttons[-1]) + 1
+        self.insert(button, position)
+        self._volume_buttons.append(button)
+        self.show()
+
+        frame = jarabe.frame.get_view()
+        notif_icon = NotificationIcon()
+        notif_icon.props.icon_name = 'emblem-neighborhood-shared'
+        notif_icon.props.xo_color = buddy.props.color
+        frame.add_notification(notif_icon,
+                               gtk.CORNER_BOTTOM_RIGHT)
+
     def __mount_added_cb(self, volume_monitor, mount):
         self._add_button(mount)
 
@@ -271,8 +306,8 @@ class VolumesToolbar(gtk.Toolbar):
     def __volume_error_cb(self, button, strerror, severity):
         self.emit('volume-error', strerror, severity)
 
-    def _button_toggled_cb(self, button):
-        if button.props.active:
+    def _button_toggled_cb(self, button, force_toggle=False):
+        if button.props.active or force_toggle:
             self.emit('volume-changed', button.mount_point)
 
     def _unmount_activated_cb(self, menu_item, mount):
@@ -300,6 +335,19 @@ class VolumesToolbar(gtk.Toolbar):
         if len(self.get_children()) < 2:
             self.hide()
 
+    def _remove_remote_share_button(self, mount_point):
+        # Here, IP_Address is the mount_point.
+        for button in self.get_children():
+            if type(button) == RemoteSharesButton and \
+                    button.mount_point == mount_point:
+                        self._volume_buttons.remove(button)
+                        self.remove(button)
+                        self.get_children()[0].props.active = True
+
+                        if len(sel.get_children()) < 2:
+                            self.hide()
+                        break;
+
     def set_active_volume(self, mount):
         button = self._get_button_for_mount(mount)
         button.props.active = True
@@ -313,6 +361,12 @@ class VolumesToolbar(gtk.Toolbar):
             if button.mount_point != mount_point:
                 button.set_sensitive(sensitive)
 
+    def get_journal_button(self):
+        return self._volume_buttons[0]
+
+    def get_button_toggled_cb(self):
+        return self._button_toggled_cb
+
 
 class BaseButton(RadioToolButton):
     __gsignals__ = {
@@ -427,18 +481,34 @@ class JournalButtonPalette(Palette):
                 {'free_space': free_space / (1024 * 1024)}
 
 
-class DocumentsButton(BaseButton):
+class DirectoryButton(BaseButton):
 
-    def __init__(self, documents_path):
-        BaseButton.__init__(self, mount_point=documents_path)
+    def __init__(self, dir_path, icon_name):
+        BaseButton.__init__(self, mount_point=dir_path)
 
-        self.props.named_icon = 'user-documents'
+        self.props.named_icon = icon_name
 
         client = gconf.client_get_default()
         color = XoColor(client.get_string('/desktop/sugar/user/color'))
         self.props.xo_color = color
 
 
+class RemoteSharesButton(BaseButton):
+
+    def __init__(self, buddy):
+        BaseButton.__init__(self, mount_point=buddy.props.ip_address)
+
+        self._buddy = buddy
+        self.props.named_icon = 'emblem-neighborhood-shared'
+        self.props.xo_color = buddy.props.color
+        self._buddy_ip_address = buddy.props.ip_address
+
+    def create_palette(self):
+        palette = RemoteSharePalette(self._buddy)
+        return palette
+
+
+
 class XSButton(ToolButton):
     def __init__(self):
         ToolButton.__init__(self)
diff --git a/src/jarabe/journal/webdavmanager.py b/src/jarabe/journal/webdavmanager.py
new file mode 100644
index 0000000..6cd0713
--- /dev/null
+++ b/src/jarabe/journal/webdavmanager.py
@@ -0,0 +1,256 @@
+from gettext import gettext as _
+
+import os
+import sys
+
+import gobject
+import simplejson
+import shutil
+
+from webdav.Connection import AuthorizationError, WebdavError
+from webdav.WebdavClient import CollectionStorer
+
+def get_key_from_resource(resource):
+    return resource.path
+
+def ensure_correct_remote_webdav_hierarchy(remote_webdav_share_resources,
+                                           remote_webdav_share_collections):
+    pass
+    #assert len(remote_webdav_share_collections.keys()) == 1
+
+class WebDavUrlManager(gobject.GObject):
+    """
+    This class holds all data, relevant to a WebDavUrl.
+
+    One thing must be noted, that a valid WebDavUrl is the one which
+    may contain zero or more resources (files), or zero or more
+    collections (directories).
+
+    Thus, following are valid WebDavUrls ::
+
+        dav://1.2.3.4/webdav
+        dav://1.2.3.4/webdav/dir_1
+        dav://1.2.3.4/webdav/dir_1/dir_2
+
+    but following are not ::
+
+        dav://1.2.3.4/webdav/a.txt
+        dav://1.2.3.4/webdav/dir_1/b.jpg
+        dav://1.2.3.4/webdab/dir_1/dir_2/c.avi
+    """
+
+    def __init__(self, WebDavUrl, username, password):
+        self._WebDavUrl = WebDavUrl
+        self._username = username
+        self._password = password
+
+    def _get_key_from_resource(self, resource):
+        return resource.path.encode(sys.getfilesystemencoding())
+
+    def _get_number_of_collections(self):
+        return len(self._remote_webdav_share_collections)
+
+    def _get_resources_dict(self):
+        return self._remote_webdav_share_resources
+
+    def _get_collections_dict(self):
+        return self._remote_webdav_share_collections
+
+    def _get_resource_by_key(self, key):
+        return self._remote_webdav_share_resources[key]['resource']
+
+    def _get_metadata_list(self):
+        metadata_list = []
+        for key in self._remote_webdav_share_resources.keys():
+            metadata_list.append(self._remote_webdav_share_resources[key]['metadata'])
+        return metadata_list
+
+    def _get_live_properties(self, resource_key):
+        resource_container = self._remote_webdav_share_resources[resource_key]
+        return resource_container['webdav-properties']
+
+    def _set_metadata_for_resource(self, key, metadata):
+        self._remote_webdav_share_resources[key]['metadata'] = metadata
+
+    def _fetch_resources_and_collections(self):
+        webdavConnection = CollectionStorer(self._WebDavUrl, validateResourceNames=False)
+
+        authFailures = 0
+        while authFailures < 2:
+            try:
+                self._remote_webdav_share_resources = {}
+                self._remote_webdav_share_collections = {}
+
+                try:
+                    self._collection_contents = webdavConnection.getCollectionContents()
+                    for resource, properties in self._collection_contents:
+                        try:
+                            key = self._get_key_from_resource(resource)
+                            selected_dict = None
+
+                            if properties.getResourceType() == 'resource':
+                                selected_dict = self._remote_webdav_share_resources
+                            else:
+                                selected_dict = self._remote_webdav_share_collections
+
+                            selected_dict[key] = {}
+                            selected_dict[key]['resource'] = resource
+                            selected_dict[key]['webdav-properties'] = properties
+                        except UnicodeEncodeError:
+                            print("Cannot encode resource path or properties.")
+
+                    return True
+
+                except WebdavError, e:
+                    # Note that, we need to deal with all errors,
+                    # except "AuthorizationError", as that is not
+                    # really an error from our perspective.
+                    if not type(e) == AuthorizationError:
+                        from jarabe.journal.journalactivity import get_journal
+
+                        error_message = e
+                        get_journal()._volume_error_cb(None, error_message,_('Error'))
+
+                        # Simply return, in case of connection-not-available.
+                        return False
+
+                    else:
+                    # If this indeed is an Authorization Error,
+                    # re-raise it, so that it is caught by the outer
+                    # "except" block.
+                        raise e
+
+
+            except AuthorizationError, e:
+                if self._username is None or self._password is None:
+                    raise Exception("WebDav username or password is None. Please specify appropriate values.")
+
+                if e.authType == "Basic":
+                    webdavConnection.connection.addBasicAuthorization(self._username, self._password)
+                elif e.authType == "Digest":
+                    info = parseDigestAuthInfo(e.authInfo)
+                    webdavConnection.connection.addDigestAuthorization(self._username, self._password, realm=info["realm"], qop=info["qop"], nonce=info["nonce"])
+                else:
+                    raise
+                authFailures += 1
+
+        return False
+
+webdav_manager = {}
+
+
+def get_resource_by_ip_address_and_resource_key(ip_address, key):
+    global webdav_manager
+
+    if ip_address in webdav_manager.keys():
+        root_webdav = webdav_manager[ip_address]
+        resources_dict = root_webdav._get_resources_dict()
+        resource_dict = resources_dict[key]
+        resource = resource_dict['resource']
+
+        return resource
+
+
+def get_remote_webdav_share_metadata(ip_address):
+    protocol = 'dav://'
+
+    root_webdav_url = '/webdav'
+
+    complete_root_url = protocol + ip_address + root_webdav_url
+
+    root_webdav = WebDavUrlManager(complete_root_url, 'test', 'olpc')
+    if root_webdav._fetch_resources_and_collections() is False:
+        # Return empty metadata list.
+        return []
+
+    # Keep reference to the "WebDavUrlManager", keyed by IP-Address.
+    global webdav_manager
+    webdav_manager[ip_address] = root_webdav
+
+
+    # Assert that the number of collections is only one at this url
+    # (i.e. only ".Sugar-Metadata" is present).
+    assert root_webdav._get_number_of_collections() == 1
+
+    root_sugar_metadata_url = root_webdav_url + '/.Sugar-Metadata'
+
+    complete_root_sugar_metadata_url = protocol + ip_address + root_sugar_metadata_url
+    root_webdav_sugar_metadata = WebDavUrlManager(complete_root_sugar_metadata_url, 'test', 'olpc')
+    if root_webdav_sugar_metadata._fetch_resources_and_collections() is False:
+        # Return empty metadata list.
+        return []
+
+    # assert that the number of collections is zero at this url.
+    assert root_webdav_sugar_metadata._get_number_of_collections() == 0
+
+    # Now. associate sugar-metadata with each of the "root-webdav"
+    # resource.
+    root_webdav_resources = root_webdav._get_resources_dict()
+    root_webdav_sugar_metadata_resources = root_webdav_sugar_metadata._get_resources_dict()
+
+    # Prepare the metadata-download folder.
+    downloaded_data_root_dir = '/tmp/' + ip_address
+    downloaded_metadata_file_dir = downloaded_data_root_dir + '/.Sugar-Metadata'
+    if os.path.isdir(downloaded_data_root_dir):
+        shutil.rmtree(downloaded_data_root_dir)
+    os.makedirs(downloaded_metadata_file_dir)
+
+    for root_webdav_resource_name in root_webdav_resources.keys():
+        """
+        root_webdav_resource_name is of the type ::
+
+            /webdav/a.txt
+        """
+        split_tokens_array = root_webdav_resource_name.split('/')
+
+        # This will provide us with "a.txt"
+        basename = split_tokens_array[len(split_tokens_array) - 1]
+
+        # This will provide us with "a.txt.metadata"
+        sugar_metadata_basename = basename + '.metadata'
+
+        # Thus will provide us with "/webdav/.Sugar-Metadata/a.txt.metadata"
+        sugar_metadata_url = root_sugar_metadata_url + '/' + sugar_metadata_basename
+
+        # Ensure that "sugar_metadata_url" is present as one of the
+        # keys in "root_webdav_sugar_metadata_resources"
+        assert sugar_metadata_url in root_webdav_sugar_metadata_resources.keys()
+
+        # Now download the metadata file, read its contents, and store
+        # the metadata in memory.
+        # It is assumed that the metadata-file is small enough to be
+        # read in one call to "read".
+
+        downloaded_metadata_file_path = downloaded_metadata_file_dir + '/' + sugar_metadata_basename
+        metadata_resource = root_webdav_sugar_metadata._get_resource_by_key(sugar_metadata_url)
+        metadata_resource.downloadFile(downloaded_metadata_file_path)
+
+        file_pointer = open(downloaded_metadata_file_path)
+        metadata = eval(file_pointer.read())
+        file_pointer.close()
+
+        # Very critical.
+        # 1. CRITICAL ONE:
+        #    Fill in the uid.
+        #    Note that the file is not physically present.
+        metadata['uid'] = downloaded_data_root_dir + '/' + basename
+
+        # 2. CRITICAL TWO:
+        #    Fill in the properties, that can only be done by reading
+        #    in the webdav-properties.
+        live_properties = root_webdav._get_live_properties(root_webdav_resource_name)
+        metadata['filesize'] = live_properties.getContentLength()
+        metadata['timestamp'] = live_properties.getLastModified()
+        metadata['creation_time'] = live_properties.getCreationDate()
+
+        # Now, write this to the metadata-file, so that
+        # webdav-properties get gelled into sugar-metadata.
+
+        file_pointer = open(downloaded_metadata_file_path, 'w')
+        file_pointer.write(simplejson.dumps(metadata))
+        file_pointer.close()
+
+        root_webdav._set_metadata_for_resource(root_webdav_resource_name,
+                                               metadata)
+
+    return root_webdav._get_metadata_list()
diff --git a/src/jarabe/model/buddy.py b/src/jarabe/model/buddy.py
index 8f17d7e..c088aa9 100644
--- a/src/jarabe/model/buddy.py
+++ b/src/jarabe/model/buddy.py
@@ -43,6 +43,7 @@ class BaseBuddyModel(gobject.GObject):
         self._color = None
         self._tags = None
         self._current_activity = None
+        self._ip_address = None
 
         gobject.GObject.__init__(self, **kwargs)
 
@@ -87,6 +88,16 @@ class BaseBuddyModel(gobject.GObject):
                                         getter=get_current_activity,
                                         setter=set_current_activity)
 
+    def get_ip_address(self):
+        return self._ip_address
+
+    def set_ip_address(self, ip_address):
+        self._ip_address = ip_address
+
+    ip_address = gobject.property(type=object,
+                                  getter=get_ip_address,
+                                  setter=set_ip_address)
+
     def is_owner(self):
         raise NotImplementedError
 
diff --git a/src/jarabe/model/neighborhood.py b/src/jarabe/model/neighborhood.py
index 4528a15..39f648e 100644
--- a/src/jarabe/model/neighborhood.py
+++ b/src/jarabe/model/neighborhood.py
@@ -930,6 +930,9 @@ class Neighborhood(gobject.GObject):
         if 'key' in properties:
             buddy.props.key = properties['key']
 
+        if 'ip4-address' in properties:
+            buddy.props.ip_address = properties['ip4-address']
+
         nick_key = CONNECTION_INTERFACE_ALIASING + '/alias'
         if nick_key in properties:
             buddy.props.nick = properties[nick_key]
diff --git a/src/jarabe/view/buddymenu.py b/src/jarabe/view/buddymenu.py
index de5a772..dfbcfa3 100644
--- a/src/jarabe/view/buddymenu.py
+++ b/src/jarabe/view/buddymenu.py
@@ -73,6 +73,12 @@ class BuddyMenu(Palette):
         self.menu.append(menu_item)
         menu_item.show()
 
+        access_buddy_remote_share_menu_item = MenuItem(_('Access Share'), 'list-add')
+        access_buddy_remote_share_menu_item.connect('activate',
+                self._access_share_cb)
+        self.menu.append(access_buddy_remote_share_menu_item)
+        access_buddy_remote_share_menu_item.show()
+
         self._invite_menu = MenuItem('')
         self._invite_menu.connect('activate', self._invite_friend_cb)
         self.menu.append(self._invite_menu)
@@ -83,6 +89,11 @@ class BuddyMenu(Palette):
         activity = home_model.get_active_activity()
         self._update_invite_menu(activity)
 
+    def _access_share_cb(self, menuitem):
+        from jarabe.journal.journalactivity import get_journal
+        volumes_toolbar = get_journal().get_volumes_toolbar()
+        volumes_toolbar._add_remote_share_button(self._buddy)
+
     def _add_my_items(self):
         item = MenuItem(_('Shutdown'), 'system-shutdown')
         item.connect('activate', self.__shutdown_activate_cb)
diff --git a/src/jarabe/view/palettes.py b/src/jarabe/view/palettes.py
index 7a17f32..3b26faf 100644
--- a/src/jarabe/view/palettes.py
+++ b/src/jarabe/view/palettes.py
@@ -336,3 +336,36 @@ class JournalXSPalette(Palette):
     def __journal_restore_activate_cb(self, menu_item, xs_hostname):
         dialog = XSRestoreDialog(xs_hostname)
         dialog.show()
+
+
+class RemoteSharePalette(Palette):
+    def __init__(self, buddy, button):
+        Palette.__init__(self, label=('%s\'s share' % buddy.props.nick))
+        self._buddy = buddy
+        self._button = button
+
+        self.props.secondary_text = glib.markup_escape_text(buddy.props.ip_address)
+
+        vbox = gtk.VBox()
+        self.set_content(vbox)
+        vbox.show()
+
+        self.connect('popup', self.__popup_cb)
+
+        menu_item = MenuItem(pgettext('Share', 'Unmount'))
+
+        icon = Icon(icon_name='media-eject', icon_size=gtk.ICON_SIZE_MENU)
+        menu_item.set_image(icon)
+        icon.show()
+
+        menu_item.connect('activate', self.__unmount_activate_cb)
+        self.menu.append(menu_item)
+        menu_item.show()
+
+    def __unmount_activate_cb(self, menu_item):
+        from jarabe.journal.journalactivity import get_journal
+        singleton_volumes_toolbar = get_journal().get_volumes_toolbar()
+        singleton_volumes_toolbar._remove_remote_share_button(self._buddy.props.ip_address)
+
+    def __popup_cb(self, palette):
+        pass
diff --git a/src/webdav/Condition.py b/src/webdav/Condition.py
new file mode 100644
index 0000000..76acf94
--- /dev/null
+++ b/src/webdav/Condition.py
@@ -0,0 +1,475 @@
+# pylint: disable-msg=R0921,W0704,R0901,W0511,R0201
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+ 
+
+"""
+This module contains classes for creating a search condition according to the DASL draft.
+The classes will output the WHERE part of a search request to a WebDAV server.
+
+Instances of the classes defined in this module form a tree data structure which represents
+a search condition. This tree is made up of AND-nodes, OR-nodes, Operator- and comparison-
+nodes and from property (i.e. variable) and constant leaf nodes.
+"""
+
+
+import types
+from time import strftime
+from calendar import timegm
+from rfc822 import formatdate
+
+from webdav.Constants import NS_DAV, PROP_LAST_MODIFIED, DATE_FORMAT_ISO8601
+
+
+__version__ = "$Revision$"[11:-2]
+
+
+class ConditionTerm(object):
+    """
+    This is the abstact base class for all condition terms.
+    """
+    def __init__(self):
+        pass
+    
+    def toXML(self):
+        """
+        Abstact method which return a XML string which can be passed to a WebDAV server
+        for a search condition.
+        """
+        raise NotImplementedError
+    
+    # start Tamino workaround for missing like-op:
+    def postFilter(self, resultSet):
+        """
+        Abstact method for temporary workaround for Tamino's absense of the like-operator.
+        This method shall filter the given result set for those resources which match
+        all Contains-trems.
+        """
+        return resultSet
+    # end of workaround
+
+
+class IsCollectionTerm(ConditionTerm):
+    """ Leaf condition. Checks if the matching resources are collections. """
+    
+    def __init__(self):
+        """ Constructor. """
+        
+        ConditionTerm.__init__(self)
+
+    def toXML(self):
+        """
+        Returns XML encoding.
+        """
+        
+        return "<D:is-collection/>"
+
+
+class Literal(ConditionTerm):
+    """
+    A leaf class for condition expressions representing a constant value.
+    """
+    def __init__(self, literal):
+        ConditionTerm.__init__(self)
+        self.literal = literal
+        
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:literal>" + self.literal + "</D:literal>"
+    
+
+class UnaryTerm(ConditionTerm):
+    """
+    Base class of all nodes with a single child node.
+    """
+    def __init__(self, child):
+        ConditionTerm.__init__(self)
+        self.child = child
+    
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return self.child.toXML()
+    
+    
+class BinaryTerm(ConditionTerm):
+    """
+    Base class of all nodes with two child nodes
+    """
+    def __init__(self, left, right):
+        ConditionTerm.__init__(self)
+        self.left = left
+        self.right = right
+    
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return self.left.toXML() + self.right.toXML()
+
+class TupleTerm(ConditionTerm):
+    """
+    Base class of all nodes with multiple single child nodes.
+    """
+    def __init__(self, terms):
+        ConditionTerm.__init__(self)
+        self.terms = terms
+    
+    def addTerm(self, term):
+        '''
+        Removes a term.
+        
+        @param term: term to add
+        '''
+        self.terms.append(term)
+    
+    def removeTerm(self, term):
+        '''
+        Adds a term.
+        
+        @param term: term to remove
+        '''   
+        try:
+            self.terms.remove(term)
+        except ValueError:
+            pass
+                
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        result = ""
+        for term in self.terms:
+            result += term.toXML()
+        return result
+
+
+class AndTerm(TupleTerm):
+    """
+    This class represents and logical AND-condition with multiple sub terms.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:and>" + TupleTerm.toXML(self) + "</D:and>"
+
+    # start Tamino workaround for missing like-op:
+    def postFilter(self, resultSet):
+        '''
+        Filters the given result set. This is a TAMINO WebDav server workaround
+        for the missing 'like' tag.
+        
+        @param resultSet: the result set that needs to be filtered.
+        '''
+        for term in self.terms:
+            filtered = term.postFilter(resultSet)
+            resultSet = filtered
+        return resultSet
+    # end of workaround
+
+class OrTerm(TupleTerm):
+    """
+    This class represents and logical OR-condition with multiple sub terms.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:or>" + TupleTerm.toXML(self) + "</D:or>"
+    
+    # start Tamino workaround for missing like-op:
+    def postFilter(self, resultSet):
+        '''
+        Filters the given result set. This is a TAMINO WebDav server workaround
+        for the missing 'like' tag.
+        
+        @param resultSet: the result set that needs to be filtered.
+        '''
+        raise NotImplementedError
+
+   
+class NotTerm(UnaryTerm):
+    """
+    This class represents a negation term for the contained sub term.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        # start Tamino workaround for missing like-op:
+        if  isinstance(self.child, ContainsTerm):
+            return ""
+        # end of workaround        
+        return "<D:not>" + UnaryTerm.toXML(self) + "</D:not>"
+
+    # start Tamino workaround for missing like-op:
+    def postFilter(self, resultSet):
+        '''
+        Filters the given result set. This is a TAMINO WebDav server workaround
+        for the missing 'like' tag.
+        
+        @param resultSet: the result set that needs to be filtered.
+        '''
+        if  isinstance(self.child, ContainsTerm):
+            self.child.negate = 1
+            # TODO: pass on filter
+        return self.child.postFilter(resultSet)
+        
+
+class ExistsTerm(UnaryTerm):
+    """
+    Nodes of this class must have a single child with tuple type (of len 2) representing a 
+    WebDAV property.
+    This leaf term evaluates to true if the (child) property exists.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return '<D:is-defined><D:prop xmlns="%s"><%s' % self.child + ' /></D:prop></D:is-defined>'
+
+class ContentContainsTerm(UnaryTerm):
+    """
+    This class can be used to search for a given phrase in resources' contents.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:contains>" + self.child + "</D:contains>"
+
+
+
+class BinaryRelationTerm(BinaryTerm):
+    """
+    This is the abstact base class for the following relation operands.
+    """
+    def __init__(self, left, right):
+        BinaryTerm.__init__(self, left, right)
+        if isinstance(self.left, types.StringType):     # Must be namespace + name pair
+            self.left = ('DAV:', self.left)
+        if not isinstance(self.right, Literal):
+            self.right = Literal(self.right)             # Must be Literal instance
+
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        ## TODO: extract name space and create shortcut for left element
+        return '<D:prop xmlns="%s"><%s /></D:prop>' % self.left + self.right.toXML()
+
+        
+class StringRelationTerm(BinaryRelationTerm):
+    """
+    This is the abstact base class for the following string relation classes.
+    """
+    def __init__(self, left, right, caseless=None):
+        """
+        @param left: webdav property (namespace, name)
+        @param right: string/unicode literal
+        qparam caseless: 1 for case sensitive comparison
+        """
+        BinaryRelationTerm.__init__(self, left, Literal(right))
+        self.caseless = caseless
+        if self.caseless:
+            self.attrCaseless = "yes"
+        else:
+            self.attrCaseless = "no"
+        
+class NumberRelationTerm(BinaryRelationTerm):
+    """
+    This is the abstact base class for the following number comparison classes.
+    """
+    def __init__(self, left, right):
+        """
+        @param left: webdav property (namespace, name)
+        @param right: constant number
+        """
+        ## TODO: implemet typed literal
+        BinaryRelationTerm.__init__(self, left, Literal(str(right)))
+
+class DateRelationTerm(BinaryRelationTerm):
+    """
+    This is the abstact base class for the following date comparison classes.
+    """
+    def __init__(self, left, right):
+        """
+        @param left: webdav property (namespace, name)
+        @param right: string literal containing a date in ISO8601 format
+        """
+        ## TODO: implemet typed literal
+        assert len(right) == 9, "No time is specified for literal: " + str(right)
+        BinaryRelationTerm.__init__(self, left, right)        
+        if self.left == (NS_DAV, PROP_LAST_MODIFIED):
+            rfc822Time = formatdate(timegm(right))      # must not use locale setting                  
+            self.right = Literal(rfc822Time)
+        else:               
+            self.right = Literal(strftime(DATE_FORMAT_ISO8601, right))
+
+
+class MatchesTerm(StringRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (child) property's value matches the (child) string.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return '<D:eq caseless="%s">' % self.attrCaseless + StringRelationTerm.toXML(self) + "</D:eq>"
+
+class ContainsTerm(StringRelationTerm):        
+    """
+    Nodes of this class evaluate to true if the (left child) property's value contains the
+    (right child) string.
+    """
+    def __init__(self, left, right, isTaminoWorkaround=False):
+        right = unicode(right)
+        StringRelationTerm.__init__(self, left, "%" + right + "%")
+        # Tamino workaround: operator like is not yet implemented:
+        self.negate = 0
+        self.isTaminoWorkaround = isTaminoWorkaround 
+            
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        # Tamino workaround: operator like is not yet implemented:
+        # Produce a is-defined-condition instead
+        if self.isTaminoWorkaround:
+            return "<D:isdefined><D:prop xmlns='%s'><%s" % self.left + " /></D:prop></D:isdefined>"
+        else:
+            return '<D:like caseless="%s">' % self.attrCaseless + StringRelationTerm.toXML(self) + "</D:like>"
+        
+    # start Tamino workaround for missing like-op:
+    def postFilter(self, resultSet):
+        '''
+        Filters the given result set. This is a TAMINO WebDav server workaround
+        for the missing 'like' tag.
+        
+        @param resultSet: the result set that needs to be filtered.
+        '''
+        newResult = {}
+        word = self.right.literal[1:-1]       # remove leading and trailing '%' characters (see __init__())
+        for url, properties in resultSet.items():
+            value = properties.get(self.left)
+            if self.negate:
+                if not value or value.textof().find(word) < 0:
+                    newResult[url] = properties                
+            else:
+                if value and value.textof().find(word) >= 0:
+                    newResult[url] = properties
+        return newResult
+    # end of workaround
+
+class IsEqualTerm(NumberRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) numerical property's value is equal
+    to the (right child) number.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:eq>" + NumberRelationTerm.toXML(self) + "</D:eq>"
+
+class IsGreaterTerm(NumberRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) numerical property's value is greater
+    than the (right child) number.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:gt>" + NumberRelationTerm.toXML(self) + "</D:gt>"
+
+class IsGreaterOrEqualTerm(NumberRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) numerical property's value is greater
+    than or equal to the (right child) number.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:gte>" + NumberRelationTerm.toXML(self) + "</D:gte>"
+
+class IsSmallerTerm(NumberRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) numerical property's value is less
+    than the (right child) number.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:lt>" + NumberRelationTerm.toXML(self) + "</D:lt>"
+
+class IsSmallerOrEqualTerm(NumberRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) numerical property's value is less
+    than or equal to the (right child) number.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:lte>" + NumberRelationTerm.toXML(self) + "</D:lte>"
+
+
+class OnTerm(DateRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) property's value is a date
+    equal to the (right child) date.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:eq>" + DateRelationTerm.toXML(self) + "</D:eq>"
+
+class AfterTerm(DateRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) property's value is a date
+    succeeding the (right child) date.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:gt>" + DateRelationTerm.toXML(self) + "</D:gt>"
+
+class BeforeTerm(DateRelationTerm):
+    """
+    Nodes of this class evaluate to true if the (left child) property's value is a date
+    preceeding the (right child) date.
+    """
+    def toXML(self):
+        '''
+        Returns XML encoding.
+        '''
+        return "<D:lt>" + DateRelationTerm.toXML(self) + "</D:lt>"
+
+
+    
+# Simple module test
+if  __name__ == '__main__':
+    # use the example from the webdav specification
+    condition = AndTerm( (MatchesTerm('getcontenttype', 'image/gif'), \
+                IsGreaterTerm('getcontentlength', 4096)) )
+    print "Where: " + condition.toXML()
diff --git a/src/webdav/Connection.py b/src/webdav/Connection.py
new file mode 100644
index 0000000..66f7833
--- /dev/null
+++ b/src/webdav/Connection.py
@@ -0,0 +1,321 @@
+# pylint: disable-msg=W0142,W0102,R0901,R0904,E0203,E1101,C0103
+#
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+The contained class extends the HTTPConnection class for WebDAV support.
+"""
+
+
+from httplib import HTTPConnection, CannotSendRequest, BadStatusLine, ResponseNotReady
+from copy import copy
+import base64   # for basic authentication
+try:
+    import hashlib
+except ImportError: # for Python 2.4 compatibility
+    import md5
+    hashlib = md5
+import mimetypes
+import os       # file handling
+import urllib
+import types
+import socket   # to "catch" socket.error
+from threading import RLock
+try:
+    from uuid import uuid4
+except ImportError: # for Python 2.4 compatibility
+    from uuid_ import uuid4
+from xml.parsers.expat import ExpatError
+
+from davlib import DAV
+from qp_xml import Parser
+
+from webdav.WebdavResponse import MultiStatusResponse, ResponseFormatError
+from webdav import Constants
+from webdav.logger import getDefaultLogger
+
+
+__version__ = "$LastChangedRevision$"
+
+
+class Connection(DAV):
+    """
+    This class handles a connection to a WebDAV server.
+    This class is used internally. Client code should prefer classes
+    L{WebdavClient.ResourceStorer} and L{WebdavClient.CollectionStorer}.
+    
+    @author: Roland Betz
+    """
+    
+    # Constants
+    #  The following switch activates a workaround for the Tamino webdav server:
+    #  Tamino expects URLs which are passed in a HTTP header to be Latin-1 encoded
+    #  instead of Utf-8 encoded.
+    #  Set this switch to zero in order to communicate with conformant servers.
+    blockSize = 30000
+    MaxRetries = 10
+    
+    def __init__(self, *args, **kwArgs):
+        DAV.__init__(self, *args, **kwArgs)
+        self.__authorizationInfo = None
+        self.logger = getDefaultLogger()
+        self.isConnectedToCatacomb = True
+        self.serverTypeChecked = False
+        self._lock = RLock()
+         
+    def _request(self, method, url, body=None, extra_hdrs={}):
+        
+        self._lock.acquire()
+        try:
+            # add the authorization header
+            extraHeaders = copy(extra_hdrs)
+            if self.__authorizationInfo:
+
+                # update (digest) authorization data
+                if hasattr(self.__authorizationInfo, "update"):
+                    self.__authorizationInfo.update(method=method, uri=url)
+                
+                extraHeaders["AUTHORIZATION"] = self.__authorizationInfo.authorization
+            
+            # encode message parts
+            body = _toUtf8(body)
+            url = _urlEncode(url)
+            for key, value in extraHeaders.items():
+                extraHeaders[key] = _toUtf8(value)
+                if key == "Destination": # copy/move header
+                    if self.isConnectedToCatacomb:
+                        extraHeaders[key] = _toUtf8(value.replace(Constants.SHARP, Constants.QUOTED_SHARP))
+                        
+                    else: # in case of TAMINO 4.4
+                        extraHeaders[key] = _urlEncode(value)
+            # pass message to httplib class
+            for retry in range(0, Connection.MaxRetries):    # retry loop
+                try:
+                    self.logger.debug("REQUEST Send %s for %s" % (method, url))
+                    self.logger.debug("REQUEST Body: " + repr(body))
+                    for hdr in extraHeaders.items():
+                        self.logger.debug("REQUEST Header: " + repr(hdr))
+                    self.request(method, url, body, extraHeaders)
+                    response = self.getresponse()
+                    break  # no retry needed
+                except (CannotSendRequest, socket.error, BadStatusLine, ResponseNotReady), exc:
+                    # Workaround, start: reconnect and retry...
+                    self.logger.debug("Exception: " + str(exc) + " Retry ... ")
+                    self.close()
+                    try:
+                        self.connect()
+                    except (CannotSendRequest, socket.error, BadStatusLine, ResponseNotReady), exc:
+                        raise WebdavError("Cannot perform request. Connection failed.")
+                    if retry == Connection.MaxRetries - 1:
+                        raise WebdavError("Cannot perform request.")
+            return self.__evaluateResponse(method, response)
+        finally:
+            self._lock.release()
+        
+    def __evaluateResponse(self, method, response):
+        """ Evaluates the response of the WebDAV server. """
+        
+        status, reason = response.status, response.reason
+        self.logger.debug("Method: " + method + " Status %d: " % status + reason)
+        
+        if status >= Constants.CODE_LOWEST_ERROR:     # error has occured ?
+            self.logger.debug("ERROR Response: " + response.read())
+            
+            # identify authentication CODE_UNAUTHORIZED, throw appropriate exception
+            if status == Constants.CODE_UNAUTHORIZED:
+                raise AuthorizationError(reason, status, response.msg["www-authenticate"])
+            
+            response.close()
+            raise WebdavError(reason, status)
+        
+        if status == Constants.CODE_MULTISTATUS:
+            content = response.read()
+            ## check for UTF-8 encoding
+            try:
+                response.root = Parser().parse(content)
+            except ExpatError, error:
+                errorMessage = "Invalid XML document has been returned.\nReason: '%s'" % str(error.args)
+                raise WebdavError(errorMessage)
+            try:
+                response.msr = MultiStatusResponse(response.root)
+            except ResponseFormatError:
+                raise WebdavError("Invalid WebDAV response.")
+            response.close()
+            self.logger.debug("RESPONSE (Multi-Status): " + unicode(response.msr))
+        elif method == 'LOCK' and status == Constants.CODE_SUCCEEDED:
+            response.parse_lock_response()
+            response.close()
+        elif method != 'GET' and method != 'PUT':
+            self.logger.debug("RESPONSE Body: " + response.read())
+            response.close()
+        return response
+        
+    def addBasicAuthorization(self, user, password, realm=None):
+        if user and len(user) > 0:
+            self.__authorizationInfo = _BasicAuthenticationInfo(realm=realm, user=user, password=password)
+                   
+    def addDigestAuthorization(self, user, password, realm, qop, nonce, uri = None, method = None):
+        if user and len(user) > 0:
+            # username, realm, password, uri, method, qop are required
+            self.__authorizationInfo = _DigestAuthenticationInfo(realm=realm, user=user, password=password, uri=uri, method=method, qop=qop, nonce=nonce)
+
+    def putFile(self, path, srcfile, header={}):
+        self._lock.acquire()
+        try:
+            # Assemble header
+            try:
+                size = os.path.getsize(srcfile.name)    
+            except os.error, error:
+                raise WebdavError("Cannot determine file size.\nReason: ''" % str(error.args))
+            header["Content-length"] = str(size)
+            
+            contentType, contentEnc = mimetypes.guess_type(path)
+            if contentType:
+                header['Content-Type'] = contentType
+            if contentEnc:
+                header['Content-Encoding'] = contentEnc
+            if self.__authorizationInfo:
+                # update (digest) authorization data
+                if hasattr(self.__authorizationInfo, "update"):
+                    self.__authorizationInfo.update(method="PUT", uri=path)
+                header["AUTHORIZATION"] = self.__authorizationInfo.authorization
+                
+            # send first request
+            path = _urlEncode(path)
+            try:
+                HTTPConnection.request(self, 'PUT', path, "", header)
+                self._blockCopySocket(srcfile, self, Connection.blockSize)
+                srcfile.close()
+                response = self.getresponse()
+            except (CannotSendRequest, socket.error, BadStatusLine, ResponseNotReady), exc:
+                self.logger.debug("Exception: " + str(exc) + " Retry ... ")
+                raise WebdavError("Cannot perform request.")
+            status, reason = (response.status, response.reason)
+            self.logger.debug("Status %d: %s" % (status, reason))
+            try:
+                if status >= Constants.CODE_LOWEST_ERROR:     # error has occured ?
+                    raise WebdavError(reason, status)
+            finally:
+                self.logger.debug("RESPONSE Body: " + response.read())
+                response.close()        
+            return response
+        finally:
+            self._lock.release()
+                  
+    def _blockCopySocket(self, source, toSocket, blockSize):
+        transferedBytes = 0
+        block = source.read(blockSize)
+        #while source.readinto(block, blockSize):
+        while len(block):
+            toSocket.send(block)
+            self.logger.debug("Wrote %d bytes." % len(block))
+            transferedBytes += len(block)
+            block = source.read(blockSize)        
+        self.logger.info("Transfered %d bytes." % transferedBytes)
+
+    def __str__(self):
+        return self.protocol + "://" + self.host + ':' + str(self.port)
+        
+
+class _BasicAuthenticationInfo(object):
+    def __init__(self, **kwArgs):
+        self.__dict__.update(kwArgs)
+        self.cookie = base64.encodestring("%s:%s" % (self.user, self.password) ).strip()
+        self.authorization = "Basic " + self.cookie
+        self.password = None     # protect password security
+        
+class _DigestAuthenticationInfo(object):
+    
+    __nc = "0000000" # in hexadecimal without leading 0x
+    
+    def __init__(self, **kwArgs):
+
+        self.__dict__.update(kwArgs)
+        
+        if self.qop is None:
+            raise WebdavError("Digest without qop is not implemented.")
+        if self.qop == "auth-int":
+            raise WebdavError("Digest with qop-int is not implemented.")
+    
+    def update(self, **kwArgs):
+        """ Update input data between requests"""
+    
+        self.__dict__.update(kwArgs)
+
+    def _makeDigest(self):
+        """ Creates the digest information. """
+        
+        # increment nonce count
+        self._incrementNc()
+        
+        # username, realm, password, uri, method, qop are required
+        
+        a1 = "%s:%s:%s" % (self.user, self.realm, self.password)
+        ha1 = hashlib.md5(a1).hexdigest()
+
+        #qop == auth
+        a2 = "%s:%s" % (self.method, self.uri)
+        ha2 = hashlib.md5(a2).hexdigest()
+        
+        cnonce = str(uuid4())
+        
+        responseData = "%s:%s:%s:%s:%s:%s" % (ha1, self.nonce, _DigestAuthenticationInfo.__nc, cnonce, self.qop, ha2)
+        digestResponse = hashlib.md5(responseData).hexdigest()
+        
+        authorization = "Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", algorithm=MD5, response=\"%s\", qop=auth, nc=%s, cnonce=\"%s\"" \
+                        % (self.user, self.realm, self.nonce, self.uri, digestResponse, _DigestAuthenticationInfo.__nc, cnonce)
+        return authorization
+    
+    authorization = property(_makeDigest)
+    
+    def _incrementNc(self):
+        _DigestAuthenticationInfo.__nc = self._dec2nc(self._nc2dec() + 1)
+    
+    def _nc2dec(self):
+        return int(_DigestAuthenticationInfo.__nc, 16)
+    
+    def _dec2nc(self, decimal):
+        return hex(decimal)[2:].zfill(8)
+    
+
+class WebdavError(IOError):
+    def __init__(self, reason, code=0):
+        IOError.__init__(self, code)
+        self.code = code
+        self.reason = reason
+    def __str__(self):
+        return self.reason
+
+
+class AuthorizationError(WebdavError):
+    def __init__(self, reason, code, authHeader):
+        WebdavError.__init__(self, reason, code)
+        
+        self.authType = authHeader.split(" ")[0]
+        self.authInfo = authHeader
+
+
+def _toUtf8(body):
+    if not body is None:
+        if type(body) == types.UnicodeType:
+            body = body.encode('utf-8')
+    return body
+
+
+def _urlEncode(url):
+    if type(url) == types.UnicodeType:
+        url = url.encode('utf-8')
+    return urllib.quote(url)
diff --git a/src/webdav/Constants.py b/src/webdav/Constants.py
new file mode 100644
index 0000000..56dfd77
--- /dev/null
+++ b/src/webdav/Constants.py
@@ -0,0 +1,199 @@
+# pylint: disable-msg=C0103
+#
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Contains XML tag names for the WebDAV protocol (RFC 2815)
+and further WebDAV related constants.
+"""
+
+
+__version__ = "$Revision$"[11:-2]
+
+
+QUOTED_SHARP = "%23"
+SHARP = "#"
+
+# Date formats
+DATE_FORMAT_ISO8601 = r"%Y-%m-%dT%H:%M:%SZ"
+DATE_FORMAT_HTTP = r"%a, %d %b %Y %H:%M:%S GMT"  # not used, substituted by rfc822 function
+
+NS_DAV = 'DAV:'
+NS_TAMINO = 'http://namespaces.softwareag.com/tamino/response2'
+
+TAG_PROPERTY_FIND   = 'propfind'
+TAG_PROPERTY_NAME   = 'propname'
+TAG_PROPERTY_UPDATE = 'propertyupdate'
+TAG_PROPERTY_SET    = 'set'
+TAG_PROPERTY_REMOVE = 'remove'
+TAG_ALL_PROPERTY    = 'allprop'
+TAG_PROP            = 'prop'
+
+TAG_MULTISTATUS         = 'multistatus'
+TAG_RESPONSE            = 'response'
+TAG_HREF                = 'href'
+TAG_PROPERTY_STATUS     = 'propstat'
+TAG_STATUS              = 'status'
+TAG_RESPONSEDESCRIPTION = 'responsdescription'
+
+PROP_CREATION_DATE    = 'creationdate'
+PROP_DISPLAY_NAME     = 'displayname'
+PROP_CONTENT_LANGUAGE = 'getcontentlanguage'
+PROP_CONTENT_LENGTH   = 'getcontentlength'
+PROP_CONTENT_TYPE     = 'getcontenttype'
+PROP_ETAG             = 'getetag'
+PROP_MODIFICATION_DATE = 'modificationdate' # this property is supported by
+# Tamino 4.4 but not by Catacomb; the date format is ISO8601
+PROP_LAST_MODIFIED    = 'getlastmodified'
+PROP_LOCK_DISCOVERY   = 'lockdiscovery'
+PROP_RESOURCE_TYPE    = 'resourcetype'
+PROP_SOURCE           = 'source'
+PROP_SUPPORTED_LOCK   = 'supportedlock'
+PROP_OWNER            = 'owner'
+
+PROP_RESOURCE_TYPE_RESOURCE    = 'resource'
+PROP_RESOURCE_TYPE_COLLECTION  = 'collection'
+
+TAG_LINK             = 'link'
+TAG_LINK_SOURCE      = 'src'
+TAG_LINK_DESTINATION = 'dst'
+
+TAG_LOCK_ENTRY     = 'lockentry'
+TAG_LOCK_SCOPE     = 'lockscope'
+TAG_LOCK_TYPE      = 'locktype'
+TAG_LOCK_INFO      = 'lockinfo'
+TAG_ACTIVE_LOCK    = 'activelock'
+TAG_LOCK_DEPTH     = 'depth'
+TAG_LOCK_TOKEN     = 'locktoken'
+TAG_LOCK_TIMEOUT   = 'timeout'
+TAG_LOCK_EXCLUSIVE = 'exclusive'
+TAG_LOCK_SHARED    = 'shared'
+TAG_LOCK_OWNER     = 'owner'
+
+# HTTP error code constants
+CODE_MULTISTATUS = 207
+CODE_SUCCEEDED = 200
+CODE_CREATED = 201
+CODE_NOCONTENT = 204
+
+CODE_LOWEST_ERROR = 300
+
+CODE_UNAUTHORIZED = 401
+CODE_FORBIDDEN = 403
+CODE_NOT_FOUND = 404
+CODE_CONFLICT = 409
+CODE_PRECONDITION_FAILED = 412
+CODE_LOCKED = 423   # no permission
+CODE_FAILED_DEPENDENCY = 424
+
+CODE_OUTOFMEM = 507
+
+# ?
+CONFIG_UNICODE_URL = 1
+
+# constants for WebDAV DASL according to draft
+
+TAG_SEARCH_REQUEST = 'searchrequest'
+TAG_SEARCH_BASIC   = 'basicsearch'
+TAG_SEARCH_SELECT  = 'select'
+TAG_SEARCH_FROM    = 'from'
+TAG_SEARCH_SCOPE   = 'scope'
+TAG_SEARCH_WHERE   = 'where'
+
+# constants for WebDAV ACP (according to draft-ietf-webdav-acl-09) below ...
+
+TAG_ACL                 = 'acl'
+TAG_ACE                 = 'ace'
+TAG_GRANT               = 'grant'
+TAG_DENY                = 'deny'
+TAG_PRIVILEGE           = 'privilege'
+TAG_PRINCIPAL           = 'principal'
+TAG_ALL                 = 'all'
+TAG_AUTHENTICATED       = 'authenticated'
+TAG_UNAUTHENTICATED     = 'unauthenticated'
+TAG_OWNER               = 'owner'
+TAG_PROPERTY            = 'property'
+TAG_SELF                = 'self'
+TAG_INHERITED           = 'inherited'
+TAG_PROTECTED           = 'protected'
+TAG_SUPPORTED_PRIVILEGE = 'supported-privilege'
+TAG_DESCRIPTION         = 'description'
+
+# privileges for WebDAV ACP:
+TAG_READ = 'read'
+TAG_WRITE = 'write'
+TAG_WRITE_PROPERTIES = 'write-properties'
+TAG_WRITE_CONTENT = 'write-content'
+TAG_UNLOCK = 'unlock'
+TAG_READ_ACL = 'read-acl'
+TAG_READ_CURRENT_USER_PRIVILEGE_SET = 'read-current-user-privilege-set'
+TAG_WRITE_ACL = 'write-acl'
+TAG_ALL = 'all'
+TAG_BIND = 'bind'
+TAG_UNBIND = 'unbind'
+# Tamino-specific privileges
+TAG_TAMINO_SECURITY = 'security' 
+# Limestone-specific privileges
+TAG_BIND_COLLECTION = 'bind-collection'
+TAG_UNBIND_COLLECTION = 'unbind-collection'
+TAG_READ_PRIVATE_PROPERTIES = 'read-private-properties'
+TAG_WRITE_PRIVATE_PROPERTIES = 'write-private-properties'
+
+# properties for WebDAV ACP:
+PROP_CURRENT_USER_PRIVILEGE_SET = 'current-user-privilege-set'
+PROP_SUPPORTED_PRIVILEGE_SET    = 'supported-privilege-set'
+PROP_PRINCIPAL_COLLECTION_SET = 'principal-collection-set' 
+
+# reports for WebDAV ACP
+REPORT_ACL_PRINCIPAL_PROP_SET   = 'acl-principal-prop-set'
+
+
+
+# constants for WebDAV Delta-V
+
+#   WebDAV Delta-V method names
+METHOD_REPORT = 'REPORT'
+METHOD_VERSION_CONTROL = 'VERSION-CONTROL'
+METHOD_UNCHECKOUT = 'UNCHECKOUT'
+METHOD_CHECKOUT = 'CHECKOUT'
+METHOD_CHECKIN = 'CHECKIN'
+METHOD_UPDATE = 'UPDATE'
+
+#   Special properties
+PROP_SUCCESSOR_SET = (NS_DAV, 'successor-set')
+PROP_PREDECESSOR_SET = (NS_DAV, 'predecessor-set')
+PROP_VERSION_HISTORY = (NS_DAV, 'version-history')
+PROP_CREATOR = (NS_DAV, 'creator-displayname')
+PROP_VERSION_NAME = (NS_DAV, 'version-name')
+PROP_CHECKEDIN = (NS_DAV, 'checked-in')
+PROP_CHECKEDOUT = (NS_DAV, 'checked-out')
+PROP_COMMENT = (NS_DAV, 'comment')
+
+#   XML tags for request body
+TAG_VERSION_TREE = 'version-tree'
+TAG_LOCATE_BY_HISTORY = 'locate-by-history'
+TAG_UPDATE = 'update'
+TAG_VERSION = 'version'
+
+# HTTP header constants
+HTTP_HEADER_DEPTH_INFINITY  = 'infinity'
+HTTP_HEADER_IF  = 'if'
+HTTP_HEADER_DAV = 'dav'
+HTTP_HEADER_DASL = 'dasl'
+HTTP_HEADER_OPTION_ACL = 'access-control'
+HTTP_HEADER_OPTION_DAV_BASIC_SEARCH = 'DAV:basicsearch'
+HTTP_HEADER_SERVER = 'server'
+HTTP_HEADER_SERVER_TAMINO = 'Apache/2.0.54 (Win32)'
diff --git a/src/webdav/Makefile.am b/src/webdav/Makefile.am
new file mode 100644
index 0000000..3356daf
--- /dev/null
+++ b/src/webdav/Makefile.am
@@ -0,0 +1,20 @@
+SUBDIRS = acp
+
+sugardir = $(pythondir)/webdav
+sugar_PYTHON =                  \
+             Connection.py      \
+             davlib.py          \
+             logger.py          \
+             NameCheck.py       \
+             Utils.py           \
+             VersionHandler.py  \
+             WebdavRequests.py  \
+             Condition.py       \
+             Constants.py       \
+             __init__.py        \
+             qp_xml.py          \
+             uuid_.py           \
+             WebdavClient.py    \
+             WebdavResponse.py
+
+
diff --git a/src/webdav/NameCheck.py b/src/webdav/NameCheck.py
new file mode 100644
index 0000000..7976973
--- /dev/null
+++ b/src/webdav/NameCheck.py
@@ -0,0 +1,193 @@
+# pylint: disable-msg=R0904,W0142,W0511,W0104,C0321,E1103,W0212
+# 
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Check name of new collections/resources for "illegal" characters.
+"""
+
+
+import re
+import unicodedata
+
+
+__version__ = "$LastChangedRevision$"
+
+
+_unicodeUmlaut = [unicodedata.lookup("LATIN CAPITAL LETTER A WITH DIAERESIS"),
+                  unicodedata.lookup("LATIN SMALL LETTER A WITH DIAERESIS"),
+                  unicodedata.lookup("LATIN CAPITAL LETTER O WITH DIAERESIS"),
+                  unicodedata.lookup("LATIN SMALL LETTER O WITH DIAERESIS"),
+                  unicodedata.lookup("LATIN CAPITAL LETTER U WITH DIAERESIS"),
+                  unicodedata.lookup("LATIN SMALL LETTER U WITH DIAERESIS"),
+                  unicodedata.lookup("LATIN SMALL LETTER SHARP S")]
+ 
+# Define characters and character base sets
+_german  = u"".join(_unicodeUmlaut)
+_alpha = "A-Za-z"
+_num = "0-9"
+_alphaNum = _alpha + _num
+_space = " "
+_under = "_"
+_dash = "\-"
+_dot = "\."
+_exclam = "\!"
+_tilde   = "\~"
+_dollar  = "\$"
+_plus = "+"
+_equal = "="
+_sharp = "#"
+
+# Define character groups
+_letterNum = _alphaNum + _german
+_letter = _alpha + _german
+
+# Define character sets for names
+firstPropertyChar = _letter + _under
+propertyChar = firstPropertyChar + _num + _dash + _dot
+firstResourceChar = firstPropertyChar + _num + _tilde + _exclam + _dollar + \
+                     _dot + _dash + _plus + _equal + _sharp
+resourceChar = firstResourceChar + _space
+
+# Define regular expressions for name validation
+_propertyFirstRe = re.compile(u"^["+ firstPropertyChar +"]")
+
+_propertyRe = re.compile(u"[^"+ propertyChar +"]")
+_resourceFirstRe = re.compile(u"^["+ firstResourceChar +"]")
+_resourceRe = re.compile(u"[^"+ resourceChar +"]")
+                    
+                    
+def isValidPropertyName(name):
+    """
+    Check if the given property name is valid.
+    
+    @param name: Property name.
+    @type name: C{unicode}
+    
+    @return: Boolean indicating whether the given property name is valid or not. 
+    @rtype: C{bool}
+    """
+
+    illegalChar = _propertyRe.search(name)
+    return illegalChar == None  and  _propertyFirstRe.match(name) != None
+    
+    
+def isValidResourceName(name):
+    """
+    Check if the given resource name is valid.
+    
+    @param name: Resource name.
+    @type name: C{unicode}
+    
+    @return: Boolean indicating whether the given resource name is valid or not. 
+    @rtype: C{bool}
+    """
+    
+    illegalChar = _resourceRe.search(name)
+    return illegalChar == None  and  _resourceFirstRe.match(name) != None
+
+
+def validatePropertyName(name):
+    """
+    Check if the given property name is valid.
+    
+    @param name: Property name.
+    @type name: C{unicode}
+    @raise WrongNameError: if validation fails (see L{datafinder.common.NameCheck.WrongNameError})
+    """
+    
+    illegalChar = _propertyRe.search(name)
+    if illegalChar:
+        raise WrongNameError(illegalChar.start(), name[illegalChar.start()])
+    if not _propertyFirstRe.match(name):
+        if len(name) > 0:
+            raise WrongNameError(0, name[0])
+        else:
+            raise WrongNameError(0, 0)
+       
+    
+def validateResourceName(name):
+    """
+    Check if the given resource name is valid.
+    
+    @param name: name of resource/collection
+    @type name: C{unicode}
+    @raise WrongNameError: if validation fails (@see L{datafinder.common.NameCheck.WrongNameError})
+    """
+
+    illegalChar = _resourceRe.search(name)
+    if illegalChar:
+        raise WrongNameError(illegalChar.start(), name[illegalChar.start()])
+    if not _resourceFirstRe.match(name):
+        if len(name) > 0:
+            raise WrongNameError(0, name[0])
+        else:
+            raise WrongNameError(0, 0)
+
+
+def getResourceNameErrorPosition(name):
+    """
+    Get position of illegal character (and the error-message).
+    This method can be used to get this information if L{isValidPropertyName}
+    or L{isValidResourceName} failed.
+    
+    @param name: Resource name.
+    @type name: C{unicode}
+    
+    @return: Tuple of error position and message.
+    @rtype: C{tuple} of C{int} and C{unicode}
+    """
+
+    result = (-1, None)
+    illegalChar = _resourceRe.search(name)
+    if illegalChar:
+        result = (illegalChar.start(), \
+                  u"Illegal character '%s' at index %d." % \
+                      (name[illegalChar.start()], illegalChar.start()))
+    elif not _resourceFirstRe.match(name):
+        result = (0, u"Illegal character '%s' at index %d." % (name[0], 0))
+    return result
+
+    
+class WrongNameError(ValueError):
+    """
+    Exception raised if an "illegal" character was found.
+    
+    @ivar character: character that caused the exception
+    @type character: C{unicode}
+    @ivar position: position of C{character}
+    @type position: C{int}
+    """
+    
+    def __init__(self, position, character):
+        """
+        Constructor.
+        
+        @param character: Character that caused the exception.
+        @type character: C{unicode}
+        @param position: Position of C{character}
+        @type position: C{int}
+        """
+        
+        ValueError.__init__(self)        
+        self.character = character
+        self.position = position
+    
+    def __str__(self):
+        """ Returns string representation. """
+        
+        return ValueError.__str__(self) + \
+            "Character '%s' at index %d." % (self.character, self.position)
diff --git a/src/webdav/Utils.py b/src/webdav/Utils.py
new file mode 100644
index 0000000..ec05755
--- /dev/null
+++ b/src/webdav/Utils.py
@@ -0,0 +1,154 @@
+# pylint: disable-msg=W0141,R0912
+#
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+The module contains functions to support use of the WebDav functionalities.
+"""
+
+
+import os
+import sys
+
+from webdav.WebdavClient import CollectionStorer, ResourceStorer
+from webdav.Constants import NS_DAV, PROP_RESOURCE_TYPE, CODE_NOT_FOUND, PROP_RESOURCE_TYPE_RESOURCE
+from webdav.Connection import WebdavError
+
+
+__version__ = "$Revision$"[11:-2]
+
+
+def resourceExists(node, name = None, resourceType = PROP_RESOURCE_TYPE_RESOURCE):
+    """
+    Check if resource exists.
+    
+    Usage:
+      - resourceExists(ResourceStorer-object):
+        check if resource exists
+      - resourceExists(CollectionStorer-object, name):
+        check if resource name exists in collection
+    
+    @param node: node that has to be checked or node of collection
+    @type node: L{ResourceStorer<webdav.WebdavClient.ResourceStorer>}
+    @param name: name of resource (in collection node) that has to be checked
+    @type name: string
+    
+    @return: boolean
+    
+    @raise WebdavError: all WebDAV errors except WebDAV error 404 (not found)
+    """
+    
+    exists = False
+    if not node:
+        return exists
+    try:
+        myResourceType = ""
+        if name:
+            # make sure it's unicode:
+            if not isinstance(name, unicode):
+                name = name.decode(sys.getfilesystemencoding())
+            url = node.url
+            if url.endswith("/"):
+                url = url  + name
+            else:
+                url = url + "/" + name
+            newNode = ResourceStorer(url, node.connection)
+            element = newNode.readProperty(NS_DAV, PROP_RESOURCE_TYPE)
+        else: # name is "None":
+            element = node.readProperty(NS_DAV, PROP_RESOURCE_TYPE)
+        
+        if len(element.children) > 0:
+            myResourceType = element.children[0].name
+        if resourceType == myResourceType or resourceType == PROP_RESOURCE_TYPE_RESOURCE:
+            exists = True
+        else:
+            exists = False
+    except WebdavError, wderr:
+        if wderr.code == CODE_NOT_FOUND:
+            # node doesn't exist -> exists = False:
+            exists = False
+        else:
+            # another exception occured -> "re-raise" it:
+            raise
+    return exists
+
+
+def downloadCollectionContent(destinationPath, collectionToDownload):
+    """
+    Downloads the resources contained to the given directory.
+    
+    @param destinationPath: Path to download the files to, will be created if it not exists.
+    @type destinationPath: C{String}
+    @param collectionToDownload: Collection to download the content from.
+    @type collectionToDownload: instance of L{CollectionStorer<webdav.WebdavClient.CollectionStorer>}
+    
+    @raise  WebdavError: If something goes wrong.
+    """
+    
+    from time import mktime, gmtime
+
+    downloadCount = 0
+
+    listOfItems = collectionToDownload.getCollectionContents()
+    
+    if not os.path.exists(destinationPath):
+        try:
+            os.makedirs(destinationPath)
+        except OSError:
+            errorMessage = "Cannot create download destination directory '%s'." % destinationPath
+            raise WebdavError(errorMessage)
+        
+    try:
+        itemsInPath = os.listdir(destinationPath)
+    except OSError:
+        errorMessage = "Cannot read the content of download destination directory '%s'." % destinationPath
+        raise WebdavError(errorMessage)
+    
+    for item in listOfItems:
+        # skip collections
+        if not isinstance(item[0], CollectionStorer):
+            itemSavePath = os.path.join(destinationPath, item[0].name)
+            existsItemSavePath = os.path.exists(itemSavePath)
+            
+            # update?
+            if existsItemSavePath:
+                try:
+                    isUpdateNecessary = mktime(item[1].getLastModified()) > mktime(gmtime(os.path.getmtime(itemSavePath)))
+                except (ValueError, OverflowError):
+                    isUpdateNecessary = True
+                # windows is not case sensitive
+                for realItem in itemsInPath:
+                    if realItem.lower() == item[0].name.lower():
+                        itemsInPath.remove(realItem)
+            else:
+                isUpdateNecessary = True
+            
+            # download
+            if not existsItemSavePath or (existsItemSavePath and isUpdateNecessary):
+                item[0].downloadFile(itemSavePath)
+                downloadCount = downloadCount + 1
+    
+    # delete old items
+    try:
+        for item in itemsInPath:
+            os.remove(os.path.join(destinationPath, item))
+    except OSError, e:
+        if e.errno == 13:    # permission error
+            sys.stderr.write("permission problem on '%s' in %s\n" % (e.filename, e.strerror))
+        else:
+            raise  
+        
+    return downloadCount
diff --git a/src/webdav/VersionHandler.py b/src/webdav/VersionHandler.py
new file mode 100644
index 0000000..a1962c6
--- /dev/null
+++ b/src/webdav/VersionHandler.py
@@ -0,0 +1,198 @@
+# pylint: disable-msg=W0612,W0142
+#
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+The WebDAV client module forwards Delta-V related method invocations to
+the following VersionHandler class.
+"""
+
+__version__ = '$Revision$'[11:-2]
+
+
+import types
+
+from webdav import Constants
+from davlib import XML_CONTENT_TYPE, XML_DOC_HEADER
+
+
+class VersionHandler(object):
+    """
+    Implements a client interface for WebDAV Delta-V methods
+    For the Delta-V see RFC 3253 at http://www.ietf.org/rfc/rfc3253.txt
+    """
+    
+    # restrict instance variables
+    __slots__ = ('path', 'connection')
+ 
+    
+    def __init__(self, connection, path):
+        """
+        Construct a VersionHandler with a URL path and a WebDAV connection.
+        This constructor must not be called outside class ResourceStorer.
+        
+        @param connection: L{webdav.Connection} instance
+        @param path: resource's path part of URL
+        """
+        #assert isinstance(connection, Connection), \
+        #    "Class of connection is %s." % connection.__class__.__name__
+        self.connection = connection
+        self.path = path
+ 
+ 
+    def activateVersionControl(self):
+        """
+        Turns version control on for this resource.
+        The resource becomes a version controlled resource (VCR)
+        """
+        response = self.connection._request(Constants.METHOD_VERSION_CONTROL, self.path, None, {})
+        # set auto-versioning to DAV:locked-checkout
+        ## parse response body in case of an error
+
+    def uncheckout(self, lockToken=None):
+        """
+        Undos a previous check-out operation on this VCR.
+        The VCR is reverted to the state before the checkout/lock operation.
+        Beware: Property or content changes will be lost !
+        A (optional) lock has to be removed seperatedly.
+        
+        @param lockToken: returned by a preceeding lock() method invocation or None
+        """
+        headers = {}
+        if lockToken:
+            headers = lockToken.toHeader() 
+        response = self.connection._request(Constants.METHOD_UNCHECKOUT, self.path, None, headers)
+        ## parse response body in case of an error
+    
+    def listAllVersions(self):
+        """
+        List version history.
+        
+        @return: List of versions for this VCR. Each version entry is a tuple adhering
+            to the format (URL-path, name, creator, tuple of successor URL-paths).
+            If there are no branches then there is at most one successor within the tuple. 
+        """
+        # implementation is similar to the propfind method
+        headers                 = {}
+        headers['Content-Type'] = XML_CONTENT_TYPE
+        body = _createReportVersionTreeBody()
+        response = self.connection._request(Constants.METHOD_REPORT, self.path, body, headers)
+        # response is multi-status
+        result = []
+        for path, properties in response.msr.items():           
+            # parse the successor-set value from XML into alist
+            result.append( (path, str(properties[Constants.PROP_VERSION_NAME]), \
+                            str(properties[Constants.PROP_CREATOR]), \
+                            _extractSuccessorList(properties[Constants.PROP_SUCCESSOR_SET])) )
+        ## TODO: sort for path and produce list
+        result.sort()
+        return result
+
+    # warning: not tested yet
+    def readVersionProperties(self):
+        """
+        Provide version related information on this VCR.
+        This include a reference to the latest version resource,
+        check-out state information and a comment.
+        
+        @return: map of version properties with values.
+        """
+        versionProperties = (Constants.PROP_CHECKEDIN, Constants.PROP_CHECKEDOUT, Constants.PROP_COMMENT)
+        return self.connection.readProperties(*versionProperties)
+    
+
+    def revertToVersion(self, oldVersion):
+        """
+        Revert this VCR to the given version.
+        Beware: All versions succeeding the given version are made unavailable.
+        
+        @param oldVersion: URL-path of a previous version of this VCR.
+        """
+        ## send an update request
+        assert isinstance(oldVersion, types.StringType) or isinstance(oldVersion, types.UnicodeType)
+        response = self.connection._request(Constants.METHOD_UPDATE, self.path,
+                        _createUpdateBody(oldVersion), {})
+        return response
+
+
+    # the following is not needed when using auto-versioning
+    
+    # warning: not tested yet
+    def checkout(self):
+        """
+        Marks resource as checked-out
+        This is usually followed by a GET (download) operation.
+        """
+        response = self.connection._request(Constants.METHOD_CHECKOUT, self.path, None, {})
+        ## parse response body in case of an error
+
+    # warning: not tested yet
+    def checkin(self):
+        """
+        Creates a new version from the VCR's content.
+        This opeartion is usually preceeded by one or more write operations.
+        """
+        response = self.connection._request(Constants.METHOD_CHECKIN, self.path, None, {})
+        versionUrl = response.getheader('Location')
+        return versionUrl
+        ## parse response body in case of an error
+
+
+
+
+# Helper functions
+def _createReportVersionTreeBody():
+    """
+    TBD
+    
+    @return: ...
+    @rtype: string
+    """
+    versions = 'D:' + Constants.TAG_VERSION_TREE
+    prop = 'D:' + Constants.TAG_PROP
+    nameList = [Constants.PROP_SUCCESSOR_SET, Constants.PROP_VERSION_NAME, Constants.PROP_CREATOR]
+    return XML_DOC_HEADER + \
+        '<%s xmlns:D="DAV:"><%s>' % (versions, prop) + \
+        reduce(lambda xml, name: xml + "<D:%s/>" % name[1], [''] + nameList) + \
+        '</%s></%s>' % (prop, versions)
+
+def _createUpdateBody(path):
+    """
+    TBD
+    
+    @return: ...
+    @rtype: string
+    """
+    update = 'D:' + Constants.TAG_UPDATE
+    version = 'D:' + Constants.TAG_VERSION
+    href = 'D:' + Constants.TAG_HREF
+    #PROP = 'D:' + TAG_PROP
+    return XML_DOC_HEADER + \
+        '<%s xmlns:D="DAV:"><%s><%s>' % (update, version, href) + \
+        path + \
+        '</%s></%s></%s>' % (href, version, update)
+
+def _extractSuccessorList(element):
+    """
+    TBD
+    
+    @return: ...
+    @rtype: tuple of strings
+    """
+    result = []
+    for href in element.children:
+        result.append(href.textof())
+    return tuple(result)
diff --git a/src/webdav/WebdavClient.py b/src/webdav/WebdavClient.py
new file mode 100644
index 0000000..ab5cec3
--- /dev/null
+++ b/src/webdav/WebdavClient.py
@@ -0,0 +1,840 @@
+# pylint: disable-msg=R0904,W0142,W0511,W0104,C0321,E1103,W0212
+# 
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+ 
+
+"""
+This module contains the classes ResourceStorer and CollectionStorer for accessing WebDAV resources.
+"""
+
+
+from davlib import XML_CONTENT_TYPE
+
+from urlparse import urlsplit
+import re
+import types
+import sys
+import os
+import shutil
+import socket
+
+from webdav import Constants
+from webdav.WebdavResponse import LiveProperties
+from webdav.WebdavRequests import createFindBody, createUpdateBody, createDeleteBody, createSearchBody
+from webdav.Condition import ConditionTerm
+from webdav.Connection import Connection, WebdavError, AuthorizationError
+from webdav.VersionHandler import VersionHandler
+
+from webdav.acp.Privilege import Privilege
+from webdav.acp.Acl import ACL
+from webdav.NameCheck import validateResourceName, WrongNameError
+
+
+__version__ = '$Revision$'[11:-2]
+
+SOCKET_DEFAULT_TIMEOUT = 10
+
+
+def switchUnicodeUrlOn(switch):
+    """
+    Configure whether to use unicode (UTF-8) encoded URLs (default) or
+    Latin-1 encoded URLs.
+    
+    @param switch: 1 if unicode URLs shall be used
+    """
+
+    assert switch == 0 or switch == 1, "Pass boolean argument, please."
+    Constants.CONFIG_UNICODE_URL = switch
+
+
+def parseDigestAuthInfo(authInfo):
+    """ 
+    Parses the authentication information returned from a server and returns
+    a dictionary containing realm, qop, and nonce.
+    
+    @see: L{AuthorizationError<webdav.Connection.AuthorizationError>} 
+    or the main function of this module.
+    """
+    
+    info = dict()
+    info["realm"] = re.search('realm="([^"]+)"', authInfo).group(1)
+    info["qop"] = re.search('qop="([^"]+)"', authInfo).group(1)
+    info["nonce"] = re.search('nonce="([^"]+)"', authInfo).group(1)
+    return info
+
+
+class ResourceStorer(object):
+    """
+    This class provides client access to a WebDAV resource
+    identified by an URI. It provides all WebDAV class 2 features which include
+    uploading data, getting and setting properties qualified by a XML name space,
+    locking and unlocking the resource. 
+    This class does not cache resource data. This has to be performed by its clients.
+    
+    @author: Roland Betz
+    """
+        
+    # Instance properties
+    url = property(lambda self: str(self.connection) + self.path, None, None, "Resource's URL")
+
+    def __init__(self, url, connection=None, validateResourceNames=True):
+        """
+        Creates an instance for the given URL
+        User must invoke validate() after construction to check the resource on the server.
+        
+        @param url: Unique resource location for this storer.
+        @type  url: C{string}
+        @param connection: this optional parameter contains a Connection object 
+            for the host part of the given URL. Passing a connection saves 
+            memory by sharing this connection. (defaults to None)
+        @type  connection: L{webdav.Connection}
+        @raise WebdavError: If validation of resource name path parts fails.
+        """
+
+        assert connection == None or isinstance(connection, Connection)
+        parts = urlsplit(url, allow_fragments=False)
+        self.path = parts[2]
+        self.validateResourceNames = validateResourceNames
+        
+        # validate URL path
+        for part in self.path.split('/'):
+            if part != '' and not "ino:" in part: # explicitly allowing this character sequence as a part of a path (Tamino 4.4)
+                if self.validateResourceNames:
+                    try:
+                        validateResourceName(part)
+                    except WrongNameError:
+                        raise WebdavError("Found invalid resource name part.")
+                self.name = part
+        # was: filter(lambda part: part and validateResourceName(part), self.path.split('/'))
+        # but filter is deprecated
+        
+        self.defaultNamespace = None     # default XML name space of properties
+        if connection:
+            self.connection = connection
+        else:
+            conn = parts[1].split(":")
+            if len(conn) == 1:
+                self.connection = Connection(conn[0], protocol = parts[0])  # host and protocol
+            else:
+                self.connection = Connection(conn[0], int(conn[1]), protocol = parts[0])  # host and port and protocol
+        self.versionHandler = VersionHandler(self.connection, self.path)
+        
+
+    def validate(self):
+        """
+        Check whether URL contains a WebDAV resource
+        Uses the WebDAV OPTIONS method.
+        
+        @raise WebdavError: L{WebdavError} if URL does not contain a WebDAV resource
+        """
+        #davHeader = response.getheader(HTTP_HEADER_DAV)
+        davHeader = self.getSpecificOption(Constants.HTTP_HEADER_DAV)
+        self.connection.logger.debug("HEADER DAV: %s" % davHeader)
+        if not(davHeader) or davHeader.find("2") < 0:   # DAV class 2 supported ?
+            raise WebdavError("URL does not support WebDAV", 0)
+
+    def options(self):
+        """
+        Send an OPTIONS request to server and return all HTTP headers.
+        
+        @return: map of all HTTP headers returned by the OPTIONS method.
+        """
+        response = self.connection.options(self.path)
+        result = {}
+        result.update(response.msg)
+        self.connection.logger.debug("OPTION returns: " + str(result.keys()))
+        return result
+        
+    def _getAclSupportAvailable(self):
+        """
+        Returns True if the current connection has got ACL support.
+        
+        @return: ACL support (True / False)
+        @rtype: C{bool}
+        """
+        options = self.getSpecificOption(Constants.HTTP_HEADER_DAV)
+        if options.find(Constants.HTTP_HEADER_OPTION_ACL) >= 0:
+            return True
+        else:
+            return False
+        
+    aclSupportAvailable = property(_getAclSupportAvailable)
+        
+    def _getDaslBasicsearchSupportAvailable(self):
+        """
+        Returns True if the current connection supports DASL basic search.
+        
+        @return: DASL basic search support (True / False)
+        @rtype: C{bool}
+        """
+        options = self.getSpecificOption(Constants.HTTP_HEADER_DASL)
+        if not options or \
+           not options.find(Constants.HTTP_HEADER_OPTION_DAV_BASIC_SEARCH) >= 0:
+            return False
+        else:
+            return True
+    
+    daslBasicsearchSupportAvailable = property(_getDaslBasicsearchSupportAvailable)
+    
+    def isConnectedToCatacombServer(self):
+        """
+        Returns True if connected to a Catacomb WebDav server.
+        
+        @return: if connected to Catacomb Webdav server (True / False)
+        @rtype: C{bool}
+        """
+        if not self.connection.serverTypeChecked:
+            options = self.getSpecificOption(Constants.HTTP_HEADER_SERVER)
+            if options.find(Constants.HTTP_HEADER_SERVER_TAMINO) >= 0:
+                self.connection.isConnectedToCatacomb = False
+            else:
+                self.connection.isConnectedToCatacomb = True
+            self.connection.serverTypeChecked = True
+        return self.connection.isConnectedToCatacomb
+        
+    def getSpecificOption(self, option):
+        """
+        Returns specified WebDav options.
+        @param option: name of the option
+        
+        @return: String containing the value of the option.
+        @rtype: C{string}
+        """
+        options = ''
+        try:
+            options = self.options().get(option)
+        except KeyError:
+            return options
+        return options  
+        
+    ### delegate some method invocations    
+    def __getattr__(self, name):
+        """
+        Build-in method:
+        Forwards unknow lookups (methods) to delegate object 'versionHandler'.
+        
+        @param name: name of unknown attribute
+        """
+        # delegate Delta-V methods
+        return getattr(self.versionHandler, name)
+    
+    def copy(self, toUrl, infinity=True):
+        """
+        Copies this resource.
+        
+        @param toUrl: target URI path
+        @param infinity: Flag that indicates that the complete content of collection is copied. (default)  
+        @type depth: C{boolean}
+        """
+        self.connection.logger.debug("Copy to " + repr(toUrl));
+        _checkUrl(toUrl)
+        if infinity:
+            response = self.connection.copy(self.path, toUrl)
+        else:
+            response = self.connection.copy(self.path, toUrl, 0)
+        if  response.status == Constants.CODE_MULTISTATUS and response.msr.errorCount > 0:
+            raise WebdavError("Request failed: " + response.msr.reason, response.msr.code)        
+        
+    def delete(self, lockToken=None):
+        """
+        Deletes this resource.
+        
+        @param lockToken: String returned by last lock operation or null.
+        @type  lockToken: L{LockToken}
+        """
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        response = self.connection.delete(self.path, header)
+        if  response.status == Constants.CODE_MULTISTATUS and response.msr.errorCount > 0:
+            raise WebdavError("Request failed: " + response.msr.reason, response.msr.code)        
+
+    def move(self, toUrl):
+        """
+        Moves this resource to the given path or renames it.
+        
+        @param toUrl: new (URI) path
+        """
+        self.connection.logger.debug("Move to " + repr(toUrl));
+        _checkUrl(toUrl)
+        response = self.connection.move(self.path, toUrl)
+        if  response.status == Constants.CODE_MULTISTATUS and response.msr.errorCount > 0:
+            raise WebdavError("Request failed: " + response.msr.reason, response.msr.code)        
+
+ 
+    def lock(self, owner):
+        """
+        Locks this resource for exclusive write access. This means that for succeeding
+        write operations the returned lock token has to be passed.
+        If the methode does not throw an exception the lock has been granted.
+        
+        @param owner: describes the lock holder
+        @return: lock token string (automatically generated)
+        @rtype: L{LockToken}
+        """
+        response = self.connection.lock(self.path, owner)
+        if  response.status == Constants.CODE_MULTISTATUS and response.msr.errorCount > 0:
+            raise WebdavError("Request failed: " + response.msr.reason, response.msr.code)        
+        return LockToken(self.url, response.locktoken)
+
+    def unlock(self, lockToken):
+        """
+        Removes the lock from this resource.
+        
+        @param lockToken: which has been return by the lock() methode
+        @type  lockToken: L{LockToken}
+        """
+        self.connection.unlock(self.path, lockToken.token)
+
+
+    def deleteContent(self, lockToken=None):
+        """
+        Delete binary data at permanent storage.
+        
+        @param lockToken: None or lock token from last lock request
+        @type  lockToken: L{LockToken}
+        """
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        self.connection.put(self.path, "", extra_hdrs=header)
+
+    def uploadContent(self, content, lockToken=None):
+        """
+        Write binary data to permanent storage.
+        
+        @param content: containing binary data
+        @param lockToken: None or lock token from last lock request
+        @type  lockToken: L{LockToken}
+        """
+        assert not content or isinstance(content, types.UnicodeType) or\
+                isinstance(content, types.StringType), "Content is not a string: " + content.__class__.__name__
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        response = None
+        if not content is None:
+            header["Content-length"] = len(content)
+        else:
+            header["Content-length"] = 0
+
+        try: 
+            response = self.connection.put(self.path, content, extra_hdrs=header)
+        finally:
+            if response:        
+                self.connection.logger.debug(response.read())
+                response.close()
+
+    def uploadFile(self, newFile, lockToken=None):
+        """
+        Write binary data to permanent storage.
+        
+        @param newFile: File containing binary data.
+        @param lockToken: None or lock token from last lock request
+        @type  lockToken: L{LockToken}
+        """
+        assert isinstance(newFile, types.FileType), "Argument is no file: " + file.__class__.__name__
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        self.connection.putFile(self.path, newFile, header=header)
+
+    def downloadContent(self):
+        """
+        Read binary data from permanent storage.
+        """
+        response = self.connection.get(self.path)
+        # TODO: Other interface ? return self.connection.getfile()
+        return response
+
+    def downloadFile(self, localFileName):
+        """
+        Copy binary data from permanent storage to a local file.
+        
+        @param localFileName: file to write binary data to
+        """
+        localFile = open(localFileName, 'wb')
+        remoteFile = self.downloadContent()
+        try:
+            socket.setdefaulttimeout(SOCKET_DEFAULT_TIMEOUT)
+            _blockCopyFile(remoteFile, localFile, Connection.blockSize)
+        except socket.error, e:
+            raise e
+        remoteFile.close()
+        localFile.close()
+
+    def readProperties(self, *names):
+        """
+        Reads the given properties.
+        
+        @param names: a list of property names.
+                      A property name is a (XmlNameSpace, propertyName) tuple.
+        @return: a map from property names to DOM Element or String values.
+        """
+        assert names, "Property names are missing."
+        body = createFindBody(names, self.defaultNamespace)
+        response = self.connection.propfind(self.path, body, depth=0)
+        properties = response.msr.values()[0]
+        if  properties.errorCount > 0:
+            raise WebdavError("Property is missing on '%s': %s" % (self.path, properties.reason), properties.code)
+        return properties
+
+    def readProperty(self, nameSpace, name):
+        """
+        Reads the given property.
+        
+        @param nameSpace: XML-namespace
+        @type nameSpace: string
+        @param name: A property name.
+        @type name: string
+        
+        @return: a map from property names to DOM Element or String values.
+        """
+        results = self.readProperties((nameSpace, name))
+        if  len(results) == 0:
+            raise WebdavError("Property is missing: " + results.reason)
+        return results.values()[0]
+
+    def readAllProperties(self):
+        """
+        Reads all properties of this resource.
+        
+        @return: a map from property names to DOM Element or String values.
+        """
+        response = self.connection.allprops(self.path, depth=0)
+        return response.msr.values()[0]
+
+    def readAllPropertyNames(self):
+        """
+        Returns the names of all properties attached to this resource.
+        
+        @return: List of property names
+        """
+        response = self.connection.propnames(self.path, depth=0)
+        return response.msr.values()[0]
+
+    def readStandardProperties(self):
+        """
+        Read all WebDAV live properties.
+        
+        @return: A L{LiveProperties} instance which contains a getter method for each live property.
+        """
+        body = createFindBody(LiveProperties.NAMES, Constants.NS_DAV)
+        response = self.connection.propfind(self.path, body, depth=0)
+        properties = response.msr.values()[0]
+        return LiveProperties(properties)
+
+    def writeProperties(self, properties, lockToken=None):
+        """
+        Sets or updates the given properties.
+        
+        @param lockToken: if the resource has been locked this is the lock token.
+        @type  lockToken: L{LockToken}
+        @param properties: a map from property names to a String or
+                           DOM element value for each property to add or update.
+        """
+        assert isinstance(properties, types.DictType)
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        body = createUpdateBody(properties, self.defaultNamespace)
+        response = self.connection.proppatch(self.path, body, header)
+        if  response.msr.errorCount > 0:
+            raise WebdavError("Request failed: " + response.msr.reason, response.msr.code)
+
+    def deleteProperties(self, lockToken=None, *names):
+        """
+        Removes the given properties from this resource.
+        
+        @param lockToken: if the resource has been locked this is the lock token.
+        @type  lockToken: L{LockToken}
+        @param names: a collection of property names.
+               A property name is a (XmlNameSpace, propertyName) tuple.
+        """
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        body = createDeleteBody(names, self.defaultNamespace)
+        response = self.connection.proppatch(self.path, body, header)
+        if  response.msr.errorCount > 0:
+            raise WebdavError("Request failed: " + response.msr.reason, response.msr.code)
+
+    # ACP extension
+    def setAcl(self, acl, lockToken=None):
+        """
+        Sets ACEs in the non-inherited and non-protected ACL or the resource.
+        This is the implementation of the ACL method of the WebDAV ACP.
+        
+        @param acl: ACL to be set on resource as ACL object.
+        @param lockToken: If the resource has been locked this is the lock token (defaults to None).
+        @type  lockToken: L{LockToken}
+        """
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        headers = {}
+        if lockToken:
+            headers = lockToken.toHeader()
+        headers['Content-Type'] = XML_CONTENT_TYPE
+        body                    = acl.toXML()
+        response = self.connection._request('ACL', self.path, body, headers)
+        return response
+        ## TODO: parse DAV:error response
+
+    def getAcl(self):
+        """
+        Returns this resource's ACL in an ACL instance.
+        
+        @return: Access Control List.
+        @rtype: L{ACL<webdav.acp.Acl.ACL>}
+        """
+        xmlAcl = self.readProperty(Constants.NS_DAV, Constants.TAG_ACL)
+        return ACL(xmlAcl)
+
+    def getCurrentUserPrivileges(self):
+        """
+        Returns a tuple of the current user privileges.
+        
+        @return: list of Privilege instances
+        @rtype: list of L{Privilege<webdav.acp.Privilege.Privilege>}
+        """
+        privileges = self.readProperty(Constants.NS_DAV, Constants.PROP_CURRENT_USER_PRIVILEGE_SET)
+        result = []
+        for child in privileges.children:
+            result.append(Privilege(domroot=child))
+        return result
+    
+    def getPrincipalCollections(self):
+        """
+        Returns a list principal collection URLs.
+        
+        @return: list of principal collection URLs
+        @rtype: C{list} of C{unicode} elements
+        """
+        webdavQueryResult = self.readProperty(Constants.NS_DAV, Constants.PROP_PRINCIPAL_COLLECTION_SET)
+        principalCollectionList = []
+        for child in webdavQueryResult.children:
+            principalCollectionList.append(child.first_cdata)            
+        return principalCollectionList
+    
+    def getOwnerUrl(self):
+        """ Explicitly retireve the Url of the owner. """
+        
+        result = self.readProperty(Constants.NS_DAV, Constants.PROP_OWNER)
+        if result and len(result.children):
+            return result.children[0].textof()
+        return None
+
+class CollectionStorer(ResourceStorer):
+    """
+    This class provides client access to a WebDAV collection resource identified by an URI.
+    This class does not cache resource data. This has to be performed by its clients.
+    
+    @author: Roland Betz
+    """
+        
+    def __init__(self, url, connection=None, validateResourceNames=True):
+        """
+        Creates a CollectionStorer instance for a URL and an optional Connection object.
+        User must invoke validate() after constuction to check the resource on the server.
+        
+        @see: L{webdav.WebdavClient.ResourceStorer.__init__}
+        @param url: unique resource location for this storer
+        @param connection: this optional parameter contains a Connection object for the host part
+            of the given URL. Passing a connection saves memory by sharing this connection.    
+        """
+        if  url[-1] != '/':     # Collection URL must end with slash
+            url += '/'
+        ResourceStorer.__init__(self, url, connection, validateResourceNames)
+    
+    def getResourceStorer(self, name):
+        """
+        Return a ResourceStorer instance for a child resource (member) of this Collection.
+        
+        @param name: leaf name of child resource
+        @return: L{ResourceStorer} instance
+        """
+        assert isinstance(name, types.StringType) or isinstance(name, types.UnicodeType)
+        return ResourceStorer(self.url + name, self.connection, self.validateResourceNames)
+             
+    def validate(self):
+        """
+        Check whether this URL contains a WebDAV collection.
+        Uses the WebDAV OPTION method.
+        
+        @raise WebdavError: L{WebdavError} if URL does not contain a WebDAV collection resource.
+        """
+        super(CollectionStorer, self).validate()
+        isCollection = self.readProperty(Constants.NS_DAV, Constants.PROP_RESOURCE_TYPE)
+        if not (isCollection and isCollection.children):
+            raise WebdavError("Not a collection URL.", 0)        
+        
+    def addCollection(self, name, lockToken=None):
+        """
+        Make a new WebDAV collection resource within this collection.
+        
+        @param name: of the new collection
+        @param lockToken: None or token returned by last lock operation
+        @type  lockToken: L{LockToken}
+        """
+        assert isinstance(name, types.StringType) or isinstance(name, types.UnicodeType)
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        if self.validateResourceNames:
+            validateResourceName(name)
+        if  name[-1] != '/':     # Collection URL must end with slash
+            name += '/'
+        self.connection.mkcol(self.path + name, header)
+        return CollectionStorer(self.url + name, self.connection, self.validateResourceNames) 
+        
+    def addResource(self, name, content=None, properties=None, lockToken=None):
+        """
+        Create a new empty WebDAV resource contained in this collection with the given
+        properties.
+        
+        @param name: leaf name of the new resource    
+        @param content: None or initial binary content of resource
+        @param properties: name/value-map containing properties
+        @param lockToken: None or token returned by last lock operation
+        @type  lockToken: L{LockToken}
+        """
+        assert isinstance(name, types.StringType) or isinstance(name, types.UnicodeType)
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        if self.validateResourceNames:
+            validateResourceName(name) # check for invalid characters        
+        resource_ = ResourceStorer(self.url + name, self.connection, self.validateResourceNames)
+        resource_.uploadContent(content, lockToken)
+        if properties:
+            resource_.writeProperties(properties, lockToken)
+        return resource_
+        
+    def deleteResource(self, name, lockToken=None):
+        """
+        Delete a collection which is contained within this collection
+        
+        @param name: leaf name of a contained collection resource
+        @param lockToken: None or token returned by last lock operation
+        @type  lockToken: L{LockToken}
+        """
+        assert isinstance(name, types.StringType) or isinstance(name, types.UnicodeType)
+        assert lockToken == None or isinstance(lockToken, LockToken), \
+                "Invalid lockToken argument %s" % type(lockToken)
+        header = {}
+        if lockToken:
+            header = lockToken.toHeader()
+        if self.validateResourceNames:
+            validateResourceName(name)
+        response = self.connection.delete(self.path + name, header)
+        if  response.status == Constants.CODE_MULTISTATUS and response.msr.errorCount > 0:
+            raise WebdavError("Request failed: %s" % response.msr.reason, response.msr.code)        
+        
+    def lockAll(self, owner):
+        """
+        Locks this collection resource for exclusive write access. This means that for 
+        succeeding write operations the returned lock token has to be passed.
+        The operation is applied recursively to all contained resources.
+        If the methode does not throw an exception then the lock has been granted.
+        
+        @param owner: describes the lock holder
+        @return: Lock token string (automatically generated).
+        @rtype: L{LockToken}
+        """
+        assert isinstance(owner, types.StringType) or isinstance(owner, types.UnicodeType)
+        response = self.connection.lock(self.path, owner, depth=Constants.HTTP_HEADER_DEPTH_INFINITY)
+        return LockToken(self.url, response.locktoken)
+        
+    def listResources(self):
+        """
+        Describe all members within this collection.
+        
+        @return: map from URI to a L{LiveProperties} instance containing the WebDAV
+                 live attributes of the contained resource
+        """
+        # *LiveProperties.NAMES denotes the list of all live properties as an
+        # argument to the method call.
+        response = self.connection.getprops(self.path,
+                                            depth=1,
+                                            ns=Constants.NS_DAV,
+                                            *LiveProperties.NAMES)
+        result = {}
+        for path, properties in response.msr.items():
+            if path == self.path:      # omit this collection resource
+                continue
+            ## some servers do not append a trailing slash to collection paths
+            if self.path.endswith('/') and self.path[0:-1] == path:
+                continue
+            result[path] = LiveProperties(properties=properties)
+        return result
+
+    def getCollectionContents(self):
+        """
+        Return a list of the tuple (resources or collection) / properties)
+
+        @return: a list of the tuple (resources or collection) / properties)
+        @rtype: C{list} 
+        """
+        self.validate()
+        collectionContents = []
+        result = self.listResources()
+        for url, properties_ in result.items():
+            if not self.path == url:
+                if properties_.getResourceType() == 'resource':
+                    myWebDavStorer = ResourceStorer(url, self.connection, self.validateResourceNames)
+                else:
+                    myWebDavStorer = CollectionStorer(url, self.connection, self.validateResourceNames)
+                collectionContents.append((myWebDavStorer, properties_))
+        return collectionContents
+
+    def findProperties(self, *names):
+        """
+        Retrieve given properties for this collection and all directly contained resources.
+        
+        @param names: a list of property names
+        @return: a map from resource URI to a map from property name to value.
+        """
+        assert isinstance(names, types.ListType) or isinstance(names, types.TupleType), \
+                "Argument name has type %s" % str(type(names))
+        body = createFindBody(names, self.defaultNamespace)
+        response = self.connection.propfind(self.path, body, depth=1)
+        return response.msr
+        
+    def deepFindProperties(self, *names):
+        """
+        Retrieve given properties for this collection and all contained (nested) resources.
+        
+        Note:
+        =====
+          This operation can take a long time if used with recursive=true and is therefore
+          disabled on some WebDAV servers.
+        
+        @param names: a list of property names
+        @return: a map from resource URI to a map from property name to value.
+        """
+        assert isinstance(names, types.ListType.__class__) or isinstance(names, types.TupleType), \
+                "Argument name has type %s" % str(type(names))
+        body = createFindBody(names, self.defaultNamespace)
+        response = self.connection.propfind(self.path, body, depth=Constants.HTTP_HEADER_DEPTH_INFINITY)
+        return response.msr
+        
+    def findAllProperties(self):
+        """
+        Retrieve all properties for this collection and all directly contained resources.
+        
+        @return: a map from resource URI to a map from property name to value.
+        """
+        response = self.connection.allprops(self.path, depth=1)
+        return response.msr
+            
+        
+    # DASL extension
+    def search(self, conditions, selects):
+        """
+        Search for contained resources which match the given search condition.
+        
+        @param conditions: tree of ConditionTerm instances representing a logical search term
+        @param selects: list of property names to retrieve for the found resources
+        """
+        assert isinstance(conditions, ConditionTerm)
+        headers = { 'Content-Type' : XML_CONTENT_TYPE, "depth": Constants.HTTP_HEADER_DEPTH_INFINITY}
+        body = createSearchBody(selects, self.path, conditions)
+        response = self.connection._request('SEARCH', self.path, body, headers)
+        return response.msr
+        
+
+class LockToken(object):
+    """
+    This class provides help on handling WebDAV lock tokens.
+    
+    @author: Roland Betz
+    """
+    # restrict instance variables
+    __slots__ = ('url', 'token')
+
+    def __init__(self, url, token):
+        assert isinstance(url, types.StringType) or isinstance(url, types.UnicodeType), \
+            "Invalid url argument %s" % type(url)
+        assert isinstance(token, types.StringType) or isinstance(token, types.UnicodeType), \
+            "Invalid lockToken argument %s" % type(token)
+        self.url = url
+        self.token = token
+
+    def value(self):
+        """
+        Descriptive string containing the lock token's URL and the token itself.
+        
+        @return: Descriptive lock token with URL.
+        @rtype: C{string}
+        """
+        return "<" + self.url + "> (<" + self.token + ">)"
+
+    def toHeader(self):
+        """
+        Header fragment for WebDAV request.
+        
+        @return: Dictionary containing an entry for the lock token query.
+        @rtype: C{dictionary}
+        """
+        return {Constants.HTTP_HEADER_IF: self.value()}
+    
+    def __str__(self):
+        return self.value()
+
+
+def _blockCopyFile(source, dest, blockSize):
+    """
+    Copies a file in chunks of C{blockSize}.
+    
+    @param source: Source file.
+    @type  source: FileIO buffer.
+    @param dest: Destination file.
+    @type  dest: FileIO buffer.
+    @param blockSize: Size of block in bytes.
+    @type  blockSize: C{int}
+    """
+    transferedBytes = 0
+    block = source.read(blockSize)
+    while len(block):
+        dest.write(block)
+        transferedBytes += len(block);
+        block = source.read(blockSize)
+
+def _checkUrl(url):
+    """
+    Checks the given URL for validity.
+    
+    @param url: URL to check.
+    @type  url: C{string}
+    
+    @raise ValueError: If the URL does not contain valid/usable content.
+    """
+    
+    parts = urlsplit(url, allow_fragments=False)
+    if len(parts[0]) == 0 or len(parts[1]) == 0 or len(parts[2]) == 0:
+        raise ValueError("Invalid URL: " + repr(url))
diff --git a/src/webdav/WebdavRequests.py b/src/webdav/WebdavRequests.py
new file mode 100644
index 0000000..79e586a
--- /dev/null
+++ b/src/webdav/WebdavRequests.py
@@ -0,0 +1,205 @@
+# pylint: disable-msg=W0511,W0212,E1111
+#
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+ 
+ 
+"""
+This module handles WebDav server requests.
+"""
+
+
+import types
+from webdav import Constants
+import qp_xml
+from tempfile import TemporaryFile
+
+from davlib import XML_DOC_HEADER
+
+from webdav.NameCheck import validatePropertyName
+
+
+__version__ = "$LastChangedRevision$"
+
+
+## TODO: create a property list class
+    
+class XmlNameSpaceMangler(object):
+    '''
+    Handles WebDav requests.
+    '''
+    
+    # restrict instance variables
+    __slots__ = ('shortcuts', 'defaultNameSpace')
+    
+    def __init__(self, nameList, defaultNameSpace = None):
+        '''
+        
+        @param nameList:
+        @param defaultNameSpace:
+        '''
+        
+        assert isinstance(nameList, types.ListType) or isinstance(nameList, types.TupleType), \
+            "1. argument has wrong type %s" % type(nameList)
+        self.shortcuts = {}
+        self.defaultNameSpace = defaultNameSpace
+        for name in nameList:
+            if  not isinstance(name, types.TupleType):
+                name = (defaultNameSpace, name)            
+            assert isinstance(name, types.TupleType) and len(name) == 2, \
+                         "Name is not a namespace, name tuple: %s" % type(name)
+            validatePropertyName(name[1])
+            if  name[0] and not self.shortcuts.has_key(name[0]):
+                self.shortcuts[name[0]] = 'ns%d' % len(self.shortcuts)
+    
+    def getNameSpaces(self):
+        '''
+        Returns the namespace.
+        '''
+        
+        result = ""        
+        for namespace, short in self.shortcuts.items():
+            result += ' xmlns:%s="%s"' % (short, namespace)
+        return result
+    
+    def getUpdateElements(self, valueMap):
+        '''
+        
+        @param valueMap:
+        '''
+        
+        elements = ""
+        for name in valueMap.keys():
+            fullname = name
+            if  isinstance(name, types.StringType):
+                fullname = (self.defaultNameSpace, name)        
+            if  not fullname[0]:
+                tag = fullname[1]        
+            else:
+                tag = self.shortcuts[fullname[0]] + ':' + fullname[1]
+            value = valueMap[name]
+            if value:
+                if isinstance(value, qp_xml._element):
+                    tmpFile = TemporaryFile('w+')
+                    value = qp_xml.dump(tmpFile, value)
+                    tmpFile.flush()
+                    tmpFile.seek(0)
+                    tmpFile.readline()
+                    value = tmpFile.read()
+                else:
+                    value = "<![CDATA[%s]]>" % value
+            else:
+                value = ""
+            elements += "<%s>%s</%s>" % (tag, value, tag)
+        return elements
+    
+    def getNameElements(self, nameList):
+        '''
+        
+        @param nameList:
+        '''
+        
+        elements = ""
+        for name in nameList:
+            if  isinstance(name, types.StringType):
+                name = (self.defaultNameSpace, name)        
+            if  not name[0]:
+                tag = name[1]        
+            else:
+                tag = self.shortcuts[name[0]] + ':' + name[1]
+            elements += "<%s />" % tag
+        return elements
+                         
+
+
+def createUpdateBody(propertyDict, defaultNameSpace = None):
+    '''
+    
+    @param propertyDict:
+    @param defaultNameSpace:
+    '''
+    
+    updateTag = 'D:' + Constants.TAG_PROPERTY_UPDATE
+    setTag = 'D:' + Constants.TAG_PROPERTY_SET
+    propTag = 'D:' + Constants.TAG_PROP
+    mangler = XmlNameSpaceMangler(propertyDict.keys(), defaultNameSpace)
+    return XML_DOC_HEADER + \
+        '<%s xmlns:D="DAV:"><%s><%s %s>' % (updateTag, setTag, propTag, mangler.getNameSpaces()) + \
+        mangler.getUpdateElements(propertyDict) + \
+        '</%s></%s></%s>' % (propTag, setTag, updateTag)
+
+        
+def createDeleteBody(nameList, defaultNameSpace = None):
+    '''
+    
+    @param nameList:
+    @param defaultNameSpace:
+    '''
+    
+    updateTag = 'D:' + Constants.TAG_PROPERTY_UPDATE
+    removeTag = 'D:' + Constants.TAG_PROPERTY_REMOVE
+    propTag = 'D:' + Constants.TAG_PROP
+    mangler = XmlNameSpaceMangler(nameList, defaultNameSpace)
+    return XML_DOC_HEADER + \
+        '<%s xmlns:D="DAV:"><%s><%s %s>' % (updateTag, removeTag, propTag, mangler.getNameSpaces()) + \
+        mangler.getNameElements(nameList) + \
+        '</%s></%s></%s>' % (propTag, removeTag, updateTag)
+        
+        
+def createFindBody(nameList, defaultNameSpace = None):
+    '''
+    
+    @param nameList:
+    @param defaultNameSpace:
+    '''
+    
+    findTag = 'D:' + Constants.TAG_PROPERTY_FIND
+    propTag = 'D:' + Constants.TAG_PROP
+    mangler = XmlNameSpaceMangler(nameList, defaultNameSpace)
+    return XML_DOC_HEADER + \
+        '<%s xmlns:D="DAV:"><%s %s>' % (findTag, propTag, mangler.getNameSpaces()) + \
+        mangler.getNameElements(nameList) + \
+        '</%s></%s>' % (propTag, findTag)
+        
+        
+def createSearchBody(selects, path, conditions, defaultNameSpace = None):
+    '''
+    Creates DASL XML body.
+    
+    @param selects: list of property names to retrieve for the found resources
+    @param path: list of conditions
+    @param conditions: tree of ConditionTerm instances representing a logical search term
+    @param defaultNameSpace: default namespace
+    '''
+    
+    searchTag = 'D:' + Constants.TAG_SEARCH_REQUEST
+    basicTag = 'D:' + Constants.TAG_SEARCH_BASIC
+    selectTag = 'D:' + Constants.TAG_SEARCH_SELECT
+    fromTag = 'D:' + Constants.TAG_SEARCH_FROM
+    scopeTag = 'D:' + Constants.TAG_SEARCH_SCOPE
+    whereTag = 'D:' + Constants.TAG_SEARCH_WHERE
+    propTag = 'D:' + Constants.TAG_PROP
+    hrefTag = 'D:' + Constants.TAG_HREF
+    depthTag = 'D:' + Constants.TAG_LOCK_DEPTH
+    depthValue = Constants.HTTP_HEADER_DEPTH_INFINITY
+    mangler = XmlNameSpaceMangler(selects, defaultNameSpace)
+    return XML_DOC_HEADER + \
+        '<%s xmlns:D="DAV:"><%s>' % (searchTag, basicTag) + \
+        '<%s><%s %s>%s</%s></%s>' % (selectTag, propTag, mangler.getNameSpaces(), 
+                                     mangler.getNameElements(selects), propTag, selectTag) + \
+        '<%s><%s><%s>%s</%s><%s>%s</%s></%s></%s>' % (fromTag, scopeTag, hrefTag, path, hrefTag, 
+                                                      depthTag, depthValue, depthTag, scopeTag, fromTag) + \
+        '<%s>%s</%s>' % (whereTag, conditions.toXML(),whereTag) + \
+        '</%s></%s>' % (basicTag, searchTag)
+        
\ No newline at end of file
diff --git a/src/webdav/WebdavResponse.py b/src/webdav/WebdavResponse.py
new file mode 100644
index 0000000..c84943d
--- /dev/null
+++ b/src/webdav/WebdavResponse.py
@@ -0,0 +1,525 @@
+# pylint: disable-msg=R0903,W0142,W0221,W0212,W0104,W0511,C0103,R0901
+#
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Handles WebDAV responses.
+"""
+
+
+from davlib import _parse_status
+import qp_xml
+from webdav import Constants
+import time
+import rfc822
+import urllib
+# Handling Jython 2.5 bug concerning the date pattern
+# conversion in time.strptime
+try:
+    from java.lang import IllegalArgumentException
+except ImportError:
+    class IllegalArgumentException(object):
+        pass
+
+
+__version__ = "$LastChangedRevision$"
+
+
+class HttpStatus(object):
+    """
+    TBD
+    
+    @ivar code:
+    @type code:
+    @ivar reason:
+    @type reason:
+    @ivar errorCount:
+    @type errorCount: int
+    """
+    
+    def __init__(self, elem):
+        """
+        TBD
+        
+        @param elem: ...
+        @type elem: instance of L{Element}
+        """
+        self.code, self.reason = _parse_status(elem)
+        self.errorCount = (self.code >= Constants.CODE_LOWEST_ERROR)
+    def __str__(self):
+        return "HTTP status %d: %s" % (self.code, self.reason)
+
+        
+class MultiStatusResponse(dict):
+    """
+    TBD
+    
+    @ivar status:
+    @type status:
+    @ivar reason:
+    @type reason:
+    @ivar errorCount:
+    @type errorCount:
+    """
+    
+    # restrict instance variables
+    __slots__ = ('errorCount', 'reason', 'status')
+
+    def __init__(self, domroot):
+        dict.__init__(self)
+        self.errorCount = 0
+        self.reason = None
+        self.status = Constants.CODE_MULTISTATUS
+        if (domroot.ns != Constants.NS_DAV) or (domroot.name != Constants.TAG_MULTISTATUS):
+            raise ResponseFormatError(domroot, 'Invalid response: <DAV:multistatus> expected.')
+        self._scan(domroot)
+    
+    def getCode(self):
+        if self.errorCount == 0:
+            return Constants.CODE_SUCCEEDED
+        if  len(self) > self.errorCount:
+            return Constants.CODE_MULTISTATUS
+        return self.values()[0].code
+
+    def getReason(self):
+        result = ""
+        for response in self.values():
+            if response.code > Constants.CODE_LOWEST_ERROR:
+                result += response.reason
+        return result                    
+    
+    def __str__(self):
+        result = ""
+        for key, value in self.items():
+            if  isinstance(value, PropertyResponse):
+                result += "Resource at %s has %d properties and %d errors.\n" % (key, len(value), value.errorCount)
+            else:
+                result += "Resource at %s returned " % key + str(value)
+        return result
+    
+    def _scan(self, root):
+        for child in root.children:
+            if child.ns != Constants.NS_DAV:
+                continue
+            if child.name == Constants.TAG_RESPONSEDESCRIPTION:
+                self.reason = child.textof()
+            elif child.name == Constants.TAG_RESPONSE:
+                self._scanResponse(child)
+            ### unknown child element
+        
+    def _scanResponse(self, elem):
+        hrefs = []
+        response = None
+        for child in elem.children:
+            if child.ns != Constants.NS_DAV:
+                continue
+            if child.name == Constants.TAG_HREF:
+                try:
+                    href = _unquoteHref(child.textof())
+                except UnicodeDecodeError:
+                    raise ResponseFormatError(child, "Invalid 'href' data encoding.")
+                hrefs.append(href)
+            elif child.name == Constants.TAG_STATUS:
+                self._scanStatus(child, *hrefs)
+            elif child.name == Constants.TAG_PROPERTY_STATUS:
+                if not response:
+                    if len(hrefs) != 1:
+                        raise ResponseFormatError(child, 'Invalid response: One <DAV:href> expected.')
+                    response = PropertyResponse()                    
+                    self[hrefs[0]] = response                    
+                response._scan(child)
+            elif child.name == Constants.TAG_RESPONSEDESCRIPTION:
+                for href in hrefs:
+                    self[href].reasons.append(child.textOf())            
+            ### unknown child element
+        if response and response.errorCount > 0:
+            self.errorCount += 1
+                                    
+    def _scanStatus(self, elem, *hrefs):
+        if  len(hrefs) == 0:
+            raise ResponseFormatError(elem, 'Invalid response: <DAV:href> expected.')
+        status = HttpStatus(elem)
+        for href in hrefs:
+            self[href] = status
+            if  status.errorCount:
+                self.errorCount += 1
+
+    # Instance properties
+    code = property(getCode, None, None, "HTTP response code")
+
+
+
+class PropertyResponse(dict):
+    """
+    TBD
+    
+    @ivar errors:
+    @type errors: list of ...
+    @ivar reasons:
+    @type reasons: list of ...
+    @ivar failedProperties:
+    @type failedProperties: dict of ...
+    """
+
+    # restrict instance variables
+    __slots__ = ('errors', 'reasons', 'failedProperties')
+
+    def __init__(self):
+        dict.__init__(self)
+        self.errors = []
+        self.reasons = []
+        self.failedProperties = {}
+
+    def __str__(self):
+        result = ""
+        for value in self.values():
+            result += value.name + '= ' + value.textof() + '\n'
+        result += self.getReason()
+        return result
+        
+    def getCode(self):
+        if  len(self.errors) == 0:
+            return Constants.CODE_SUCCEEDED
+        if  len(self) > 0:
+            return Constants.CODE_MULTISTATUS
+        return self.errors[-1].code       
+
+    def getReason(self):
+        result = ""
+        if len(self.errors) > 0:
+            result = "Failed for: "   + repr(self.failedProperties.keys()) + "\n"
+        for error in self.errors:
+            result += "%s (%d).  " % (error.reason, error.code)
+        for reason in self.reasons:
+            result += "%s.  " % reason
+        return result
+        
+    def _scan(self, element):
+        status = None
+        statusElement = element.find(Constants.TAG_STATUS, Constants.NS_DAV)
+        if statusElement:
+            status = HttpStatus(statusElement)
+            if status.errorCount:
+                self.errors.append(status)
+        
+        propElement = element.find(Constants.TAG_PROP, Constants.NS_DAV)
+        if propElement:
+            for prop in propElement.children:
+                if status.errorCount:
+                    self.failedProperties[(prop.ns, prop.name)]= status
+                else:
+                    prop.__class__ = Element     # bad, bad trick
+                    self[prop.fullname] = prop
+        reasonElement = element.find(Constants.TAG_RESPONSEDESCRIPTION, Constants.NS_DAV)
+        if reasonElement:
+            self.reasons.append(reasonElement.textOf())
+        
+    # Instance properties
+    code = property(getCode, None, None, "HTTP response code")
+    errorCount = property(lambda self: len(self.errors), None, None, "HTTP response code")
+    reason = property(getReason, None, None, "HTTP response code")
+
+
+
+        
+class LiveProperties(object):
+    """
+    This class provides convenient access to the WebDAV 'live' properties of a resource.
+    WebDav 'live' properties are defined in RFC 2518, Section 13. 
+    Each property is converted from string to its natural data type.
+    
+    @version: $Revision$
+    @author: Roland Betz
+    """
+    
+    # restrict instance variables
+    __slots__ = ('properties')
+
+    NAMES = (Constants.PROP_CREATION_DATE, Constants.PROP_DISPLAY_NAME,
+             Constants.PROP_CONTENT_LENGTH, Constants.PROP_CONTENT_TYPE, Constants.PROP_ETAG,
+             Constants.PROP_LAST_MODIFIED, Constants.PROP_OWNER,
+             Constants.PROP_LOCK_DISCOVERY, Constants.PROP_RESOURCE_TYPE, Constants.PROP_SUPPORTED_LOCK )
+     
+    def __init__(self, properties=None, propElement=None):
+        """
+        Construct <code>StandardProperties</code> from a map of properties containing
+        live properties or from a XML 'prop' element containing live properties
+        
+        @param properties: map as implemented by class L{PropertyResponse}
+        @param propElement: an C{Element} value
+        """
+        assert isinstance(properties, PropertyResponse) or \
+               isinstance(propElement, qp_xml._element), \
+                "Argument properties has type %s" % str(type(properties))
+        self.properties = {}
+        for name, value in properties.items():
+            if  name[0] == Constants.NS_DAV  and  name[1] in self.NAMES:
+                self.properties[name[1]] = value
+
+    def getContentLanguage(self):
+        """
+        Return the language of a resource's textual content or null
+        
+        @return: string
+        """
+        
+        result = ""
+        if not self.properties.get(Constants.PROP_CONTENT_LANGUAGE, None) is None:
+            result = self.properties.get(Constants.PROP_CONTENT_LANGUAGE).textof()
+        return result
+
+    def getContentLength(self):
+        """
+        Returns the length of the resource's content in bytes.
+        
+        @return: number of bytes
+        """
+        
+        result = 0
+        if not self.properties.get(Constants.PROP_CONTENT_LENGTH, None) is None:
+            result = int(self.properties.get(Constants.PROP_CONTENT_LENGTH).textof())
+        return result
+
+    def getContentType(self):
+        """
+        Return the resource's content MIME type.
+        
+        @return: MIME type string
+        """
+        
+        result = ""
+        if not self.properties.get(Constants.PROP_CONTENT_TYPE, None) is None:
+            result = self.properties.get(Constants.PROP_CONTENT_TYPE).textof()
+        return result
+
+    def getCreationDate(self):
+        """
+        Return date of creation as time tuple.
+                
+        @return: time tuple
+        @rtype: C{time.struct_time}
+        
+        @raise ValueError: If string is not in the expected format (ISO 8601).
+        """
+        
+        datetimeString = ""
+        if not self.properties.get(Constants.PROP_CREATION_DATE, None) is None:
+            datetimeString = self.properties.get(Constants.PROP_CREATION_DATE).textof()
+
+        result = rfc822.parsedate(datetimeString)
+        if result is None:
+            result = _parseIso8601String(datetimeString)
+
+        return time.mktime(result)
+    
+    def getEntityTag(self):
+        """
+        Return a entity tag which is unique for a particular version of a resource.
+        Different resources or one resource before and after modification have different etags. 
+        
+        @return: entity tag string
+        """
+        
+        result = ""
+        if not self.properties.get(Constants.PROP_ETAG, None) is None:
+            result = self.properties.get(Constants.PROP_ETAG).textof()
+        return result
+            
+    def getDisplayName(self):
+        """
+        Returns a resource's display name.
+        
+        @return: string
+        """
+        
+        result = ""
+        if not self.properties.get(Constants.PROP_DISPLAY_NAME, None) is None:
+            result = self.properties.get(Constants.PROP_DISPLAY_NAME).textof()
+        return result
+
+    def getLastModified(self):
+        """
+        Return last modification of resource as time tuple.
+        
+        @return: Modification date time.
+        @rtype:  C{time.struct_time}
+        
+        @raise ValueError: If the date time string is not in the expected format (RFC 822 / ISO 8601).
+        """
+        
+        datetimeString = None
+        if not self.properties.get(Constants.PROP_LAST_MODIFIED, None) is None:
+            datetimeString = self.properties.get(Constants.PROP_LAST_MODIFIED).textof()
+        result = rfc822.parsedate(datetimeString)
+        if result is None:
+            result = _parseIso8601String(datetimeString)
+        return time.mktime(result)
+
+    def getLockDiscovery(self):
+        """
+        Return all current lock's applied to a resource or null if it is not locked.
+        
+        @return: a lockdiscovery DOM element according to RFC 2815
+        """
+        
+        xml = self.properties.get(Constants.PROP_LOCK_DISCOVERY)
+        return _scanLockDiscovery(xml)
+
+    def getResourceType(self):
+        """
+        Return a resource's WebDAV type.
+        
+        @return: 'collection' or 'resource'
+        """
+        
+        xml = self.properties.get(Constants.PROP_RESOURCE_TYPE)
+        if xml and xml.children:
+            return xml.children[0].name
+        return "resource"
+
+    def getSupportedLock(self):
+        """
+        Return a DOM element describing all supported lock options for a resource.
+        Usually this is shared and exclusive write lock.
+        
+        @return: supportedlock DOM element according to RFC 2815
+        """
+        
+        xml = self.properties.get(Constants.PROP_SUPPORTED_LOCK)
+        return xml
+
+    def getOwnerAsUrl(self):
+        """
+        Return a resource's owner in form of a URL.
+        
+        @return: string
+        """
+        
+        xml = self.properties.get(Constants.PROP_OWNER)
+        if xml and len(xml.children):
+            return xml.children[0].textof()
+        return None
+
+    def __str__(self):
+        result = ""
+        result += " Name=" + self.getDisplayName()
+        result += "\n Type=" + self.getResourceType()
+        result += "\n Length=" + str(self.getContentLength())
+        result += "\n Content Type="+ self.getContentType()
+        result += "\n ETag=" + self.getEntityTag()
+        result += "\n Created=" + time.strftime("%c GMT", self.getCreationDate())
+        result += "\n Modified=" + time.strftime("%c GMT", self.getLastModified())
+        return result
+
+
+def _parseIso8601String(date):
+    """ 
+    Parses the given ISO 8601 string and returns a time tuple.
+    The strings should be formatted according to RFC 3339 (see section 5.6).
+    But currently there are two exceptions:
+        1. Time offset is limited to "Z".
+        2. Fragments of seconds are ignored.
+    """
+    
+    if "." in date and "Z" in date: # Contains fragments of second?
+        secondFragmentPos = date.rfind(".")
+        timeOffsetPos = date.rfind("Z")
+        date = date[:secondFragmentPos] + date[timeOffsetPos:]
+    try:
+        timeTuple = time.strptime(date, Constants.DATE_FORMAT_ISO8601)
+    except IllegalArgumentException: # Handling Jython 2.5 bug concerning the date pattern accordingly
+        import _strptime # Using the Jython fall back solution directly
+        timeTuple = _strptime.strptime(date, Constants.DATE_FORMAT_ISO8601)
+    return timeTuple
+
+
+class ResponseFormatError(IOError):
+    """
+    An instance of this class is raised when the web server returned a webdav
+    reply which does not adhere to the standard and cannot be recognized.
+    """
+    def __init__(self, element, message= None):
+        IOError.__init__(self, "ResponseFormatError at element %s: %s"  % (element.name, message))
+        self.element = element
+        self.message = message
+        
+    
+class Element(qp_xml._element):
+    """
+    This class improves the DOM interface (i.e. element interface) provided by the qp_xml module
+    TODO: substitute qp_xml by 'real' implementation. e.g. domlette
+    """
+    def __init__(self, namespace, name, cdata=''):
+        qp_xml._element.__init__(self, ns=namespace, name=name, lang=None, parent=None,
+                    children=[], ns_scope={}, attrs={},
+                    first_cdata=cdata, following_cdata='')
+                    
+    def __str__(self):
+        return self.textof()
+        
+    def __getattr__(self, name):
+        if  (name == 'fullname'):
+            return (self.__dict__['ns'], self.__dict__['name'])
+        raise AttributeError, name
+
+    def add(self, child):
+        self.children.append(child)
+        return child
+
+def _scanLockDiscovery(root):
+    assert root.name == Constants.PROP_LOCK_DISCOVERY, "Invalid lock discovery XML element"
+    active = root.find(Constants.TAG_ACTIVE_LOCK, Constants.NS_DAV)
+    if active:
+        return _scanActivelock(active)
+    return None
+    
+def _scanActivelock(root):
+    assert root.name == Constants.TAG_ACTIVE_LOCK, "Invalid active lock XML element"
+    token = _scanOrError(root, Constants.TAG_LOCK_TOKEN)
+    value = _scanOrError(token, Constants.TAG_HREF)
+    owner = _scanOwner(root)
+    depth = _scanOrError(root, Constants.TAG_LOCK_DEPTH)
+    return (value.textof(), owner, depth.textof())
+
+def _scanOwner(root):
+    owner = root.find(Constants.TAG_LOCK_OWNER, Constants.NS_DAV)
+    if owner:
+        href = owner.find(Constants.TAG_HREF, Constants.NS_DAV)
+        if href:
+            return href.textof()
+        return owner.textof()
+    return None
+    
+def _scanOrError(elem, childName):
+    child = elem.find(childName, Constants.NS_DAV)
+    if not child:
+        raise ResponseFormatError(elem, "Invalid response: <"+childName+"> expected")
+    return child
+    
+         
+def _unquoteHref(href):
+    #print "*** Response HREF=", repr(href)
+    if type(href) == type(u""):
+        try: 
+            href = href.encode('ascii')
+        except UnicodeError:    # URL contains unescaped non-ascii character
+            # handle bug in Tamino webdav server
+            return urllib.unquote(href)
+    href = urllib.unquote(href)
+    if Constants.CONFIG_UNICODE_URL:
+        return unicode(href, 'utf-8')
+    else:
+        return unicode(href, 'latin-1')
diff --git a/src/webdav/__init__.py b/src/webdav/__init__.py
new file mode 100644
index 0000000..3e46609
--- /dev/null
+++ b/src/webdav/__init__.py
@@ -0,0 +1,16 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+__version__ = "$LastChangedRevision$"
diff --git a/src/webdav/acp/Ace.py b/src/webdav/acp/Ace.py
new file mode 100644
index 0000000..8321d41
--- /dev/null
+++ b/src/webdav/acp/Ace.py
@@ -0,0 +1,293 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+ACE object handling according to WebDAV ACP specification.
+"""
+
+
+from webdav.acp.Principal import Principal
+from webdav.acp.GrantDeny import GrantDeny
+from webdav import Constants
+from webdav.Connection import WebdavError
+
+
+__version__ = "$LastChangedRevision$"
+
+
+class ACE(object):
+    """
+    This class provides functionality for handling ACEs
+    
+    @ivar principal:   A principal (user or group)
+    @type principal:   L{Principal} object
+    @ivar invert:      Flag indicating whether ACE should invert the principal.
+    @type invert:      C{bool}
+    @ivar grantDenies: Grant or deny clauses for privileges
+    @type grantDenies: C{list} of L{GrantDeny} objects
+    @ivar protected:   Flag indicating whether ACE is protected.
+    @type protected:   C{bool}
+    @ivar inherited:   URL indicating the source from where the ACE is inherited.
+    @type inherited:   C{string}
+    """
+    
+    # restrict instance variables
+    __slots__ = ('principal', 'invert', 'grantDenies', 'protected', 'inherited')
+    
+    def __init__(self, domroot=None, principal=None, grantDenies=None):
+        """
+        Constructor should be called with either no parameters (create blank ACE),
+        one parameter (a DOM tree or principal), or two parameters (principal and 
+        sequence of GrantDenies).
+        
+        @param domroot:     A DOM tree (default: None).
+        @type  domroot:     L{webdav.WebdavResponse.Element} object
+        @param principal:   A principal (user or group), (default: None).
+        @type  principal:   L{Principal} object
+        @param grantDenies: Grant and deny clauses for privileges (default: None).
+        @type  grantDenies: sequence of L{GrantDeny} objects
+        
+        @raise WebdavError: When non-valid parameters are passed a L{WebdavError} is raised.
+        """
+        self.principal   = Principal()
+        self.protected   = None
+        self.inherited   = None
+        self.invert      = None
+        self.grantDenies = []
+
+        if domroot:
+            self.principal   = Principal(domroot=domroot.find(Constants.TAG_PRINCIPAL, Constants.NS_DAV))
+            self.inherited   = domroot.find(Constants.TAG_INHERITED, Constants.NS_DAV)
+            if self.inherited:
+                self.inherited = self.inherited.children[0].textof()
+            if domroot.find(Constants.TAG_PROTECTED, Constants.NS_DAV):
+                self.protected = 1
+            for child in domroot.children:
+                if child.ns == Constants.NS_DAV \
+                        and (child.name == Constants.TAG_GRANT or child.name == Constants.TAG_DENY):
+                    self.grantDenies.append(GrantDeny(domroot=child))
+        elif isinstance(principal, Principal):
+            newPrincipal = Principal()
+            newPrincipal.copy(principal)
+            self.principal = newPrincipal
+            if (isinstance(grantDenies, list) or isinstance(grantDenies, tuple)):
+                self.addGrantDenies(grantDenies)
+        elif domroot == None and grantDenies == None:
+            # no param ==> blank ACE
+            pass
+        else:
+            # This shouldn't happen, someone screwed up with the params ...
+            raise WebdavError('non-valid parameters handed to ACE constructor')
+
+    def __cmp__(self, other):
+        if not isinstance(other, ACE):
+            return 1
+        if self.principal == other.principal \
+                and self.invert == other.invert \
+                and self.protected == other.protected \
+                and self.inherited == other.inherited:
+            equal = 1
+            for grantDeny in self.grantDenies:
+                inList = 0
+                for otherGrantDeny in other.grantDenies:
+                    if grantDeny == otherGrantDeny:
+                        inList = 1
+                if inList == 0:
+                    equal = 0
+            return not equal
+        else:
+            return 1
+
+    def __repr__(self):
+        repr = '<class ACE: '
+        if self.invert:
+            repr += 'inverted principal, ' % (self.invert)
+        if self.principal:
+            repr += 'principal: %s, ' % (self.principal)
+        if self.protected:
+            repr += 'protected, '
+        if self.inherited:
+            repr += 'inherited href: %s, ' % (self.inherited)
+        first = 1
+        repr += 'grantDenies: ['
+        for grantDeny in self.grantDenies:
+            if first:
+                repr += '%s' % grantDeny
+                first = 0
+            else:
+                repr += ', %s' % grantDeny
+        return '%s]>' % (repr)
+
+    def copy(self, other):
+        '''Copy an ACE object.
+        
+        @param other: Another ACE to copy.
+        @type  other: L{ACE} object
+        
+        @raise WebdavError: When an object that is not an L{ACE} is passed 
+            a L{WebdavError} is raised.
+        '''
+        if not isinstance(other, ACE):
+            raise WebdavError('Non-ACE object passed to copy method: %s.' % other.__class__)
+        self.invert    = other.invert
+        self.protected = other.protected
+        self.inherited = other.inherited
+        self.principal = Principal()
+        if other.principal:
+            self.principal.copy(other.principal)
+        if other.grantDenies:
+            self.addGrantDenies(other.grantDenies)
+
+    def isValid(self):
+        """
+        Returns true/false (1/0) whether necessarry props 
+        principal and grantDenies are set and whether the ACE contains one 
+        grant or deny clauses.
+        
+        @return: Validity of ACE.
+        @rtype:  C{bool}
+        """
+        return self.principal and len(self.grantDenies) == 1
+
+    def isGrant(self):
+        '''
+        Returns true/false (1/0) if ACE contains only grant clauses.
+        
+        @return: Value whether the ACE is of grant type.
+        @rtype:  C{bool}
+        '''
+        if self.isMixed() or len(self.grantDenies) < 1:
+            return 0
+        else:
+            return self.grantDenies[0].isGrant()
+
+    def isDeny(self):
+        '''
+        Returns true/false (1/0) if ACE contains only deny clauses.
+        
+        @return: Value whether the ACE is of deny type.
+        @rtype:  C{bool}
+        '''
+        if self.isMixed() or len(self.grantDenies) < 1:
+            return 0
+        else:
+            return self.grantDenies[0].isDeny()
+
+    def isMixed(self):
+        '''
+        Returns true/false (1/0) if ACE contains both types (grant and deny) of clauses.
+        
+        @return: Value whether the ACE is of mixed (grant and deny) type.
+        @rtype:  C{bool}
+        '''
+        mixed = 0
+        if len(self.grantDenies):
+            first = self.grantDenies[0].grantDeny
+            for grantDeny in self.grantDenies:
+                if grantDeny.grantDeny != first:
+                    mixed = 1
+        return mixed
+
+    def toXML(self, defaultNameSpace=None):
+        """
+        Returns ACE content as a string of valid XML as described in WebDAV ACP.
+        
+        @param defaultNameSpace: Name space (default: None).
+        @type  defaultNameSpace: C(string)
+        """
+        assert self.isValid(), "ACE is not initialized or does not contain valid content!"
+        
+        ACE = 'D:' + Constants.TAG_ACE
+        res = self.principal.toXML(self.invert)
+        for grantDeny in self.grantDenies:
+            res += grantDeny.toXML()
+        if self.protected:
+            res += '<D:protected/>'
+        if self.inherited:
+            res += '<D:inherited><D:href>%s</D:href></D:inherited>' % (self.inherited)
+        return '<%s>%s</%s>' % (ACE, res, ACE)
+
+    def setPrincipal(self, principal):
+        '''
+        Sets the passed principal on the ACE.
+        
+        @param principal: A principal.
+        @type  principal: L{Principal} object
+        '''
+        self.principal = Principal()
+        self.principal.copy(principal)
+
+    def setInherited(self, href):
+        '''
+        Sets the passed URL on the ACE to denote from where it is inherited.
+        
+        @param href: A URL.
+        @type  href: C{string}
+        '''
+        self.inherited = href
+
+    def addGrantDeny(self, grantDeny):
+        '''
+        Adds the passed GrantDeny object to list if it's not in it, yet.
+        
+        @param grantDeny: A grant or deny clause.
+        @type  grantDeny: L{GrantDeny} object
+        '''
+        # only add it if it's not in the list, yet ...
+        inList = 0
+        for element in self.grantDenies:
+            if element == grantDeny:
+                inList = 1
+        if not inList:
+            newGrantDeny = GrantDeny()
+            newGrantDeny.copy(grantDeny)
+            self.grantDenies.append(newGrantDeny)
+
+    def addGrantDenies(self, grantDenies):
+        '''Adds the list of passed grant/deny objects to list.
+        
+        @param grantDenies: Grant or deny clauses.
+        @type  grantDenies: sequence of L{GrantDeny} objects
+        '''
+        map(lambda grantDeny: self.addGrantDeny(grantDeny), grantDenies)
+
+    def delGrantDeny(self, grantDeny):
+        '''Deletes the passed GrantDeny object from list.
+        
+        @param grantDeny: A grant or deny clause.
+        @type  grantDeny: L{GrantDeny} object
+        
+        @raise WebdavError: A L{WebdavError} is raised if the clause to be 
+            deleted is not present.
+        '''
+        # only add it if it's not in the list, yet ...
+        count = 0
+        index = 0
+        for element in self.grantDenies:
+            count += 1
+            if element == grantDeny:
+                index = count
+        if index:
+            self.grantDenies.pop(index - 1)
+        else:
+            raise WebdavError('GrantDeny to be deleted not in list: %s.' % grantDeny)
+
+    def delGrantDenies(self, grantDenies):
+        '''Deletes the list of passed grant/deny objects from list.
+        
+        @param grantDenies: Grant or deny clauses.
+        @type  grantDenies: sequence of L{GrantDeny} objects
+        '''
+        map(lambda grantDeny: self.delGrantDeny(grantDeny), grantDenies)
diff --git a/src/webdav/acp/AceHandler.py b/src/webdav/acp/AceHandler.py
new file mode 100644
index 0000000..e07b74d
--- /dev/null
+++ b/src/webdav/acp/AceHandler.py
@@ -0,0 +1,182 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Handling of WebDAV Access Protocol Extensions and ACL preparation for UI.
+"""
+
+
+from webdav import Constants
+from webdav.WebdavClient import ResourceStorer
+from webdav.Connection import WebdavError
+
+
+__version__ = "$LastChangedRevision$"
+
+
+def extractSupportedPrivilegeSet(userPrivileges):
+    """
+    Returns a dictionary of supported privileges.
+    
+    @param userPrivileges: A DOM tree.
+    @type  userPrivileges: L{webdav.WebdavResponse.Element} object
+    
+    @raise WebdavError: When unknown elements appear in the 
+        C{DAV:supported-privilege} appear a L{WebdavError} is raised.
+    
+    @return: A dictionary with privilege names as keys and privilege descriptions as values.
+    @rtype:  C{dictionary}
+    """
+    result = {}
+    for element in userPrivileges.children:
+        if element.name == Constants.TAG_SUPPORTED_PRIVILEGE:
+            privName        = ''
+            privDescription = ''
+            for privilege in element.children:
+                if privilege.name == Constants.TAG_PRIVILEGE:
+                    privName = privilege.children[0].name
+                elif privilege.name == Constants.TAG_DESCRIPTION:
+                    privDescription = privilege.textof()
+                else:
+                    raise WebdavError('Unknown element in DAV:supported-privilege: ' + privilege.name)
+                
+                if privName and privDescription:
+                    result[privName] = privDescription
+                    privName        = ''
+                    privDescription = ''
+        else:
+            raise WebdavError('Invalid element tag in DAV:supported-privilege-set: ' + element.name)
+    return result
+
+
+def _insertAclDisplaynames(acl):
+    """
+    Modifies the ACL by adding the human readable names 
+    (DAV:displayname property) of each principal found in an ACL.
+    
+    This should be done with the REPORT method, but it is not supported by 
+    Jacarta Slide, yet. (As of Aug. 1, 2003 in CVS repository)
+    
+    So we are going to do it differently by foot the harder way ...
+    
+    @param acl: An ACL object for which the displaynames should be retrieved.
+    @type  acl: L{ACL} object
+    """
+    ## This is redundant code to be still kept for the REPORT method way of doing it ...
+    ## property = '''<D:prop><D:displayname/></D:prop>'''
+    ## return self.getReport(REPORT_ACL_PRINCIPAL_PROP_SET, property)
+    for ace in acl.aces:
+        if not ace.principal.property:
+            principalConnection = \
+                ResourceStorer(ace.principal.principalURL)
+            ace.principal.displayname = \
+                principalConnection.readProperty(Constants.NS_DAV, Constants.PROP_DISPLAY_NAME)
+
+
+def prepareAcls(acls):
+    """
+    Returns all ACLs describing the behaviour of the resource. The information 
+    in the ACL is modified to contain all information needed to display in the UI.
+    
+    @param acls: ACL objects.
+    @type  acls: C{list} of L{ACL} objects
+    
+    @return: (non-valid) ACLs that contain both grant and deny clauses in an ACE.
+        Displaynames are added to the Principals where needed.
+    @rtype:  C{list} of L{ACL} objects
+    """
+    for acl in acls.keys():
+        acls[acl] = acls[acl].joinGrantDeny()
+        _insertAclDisplaynames(acls[acl])
+    return acls
+
+
+def prepareAcl(acl):
+    """
+    Returns an ACL describing the behaviour of the resource. The information 
+    in the ACL is modified to contain all information needed to display in the UI.
+    
+    @param acl: An ACL object.
+    @type  acl: L{ACL} object
+    
+    @return: A (non-valid) ACL that contains both grant and deny clauses in an ACE.
+        Displaynames are added to the Principals where needed.
+    @rtype:  L{ACL} object
+    """
+    acl = acl.joinGrantDeny()
+    _insertAclDisplaynames(acl)
+    return acl
+
+
+def refineAclForSet(acl):
+    """
+    Sets the ACL composed from the UI on the WebDAV server. For that purpose the 
+    ACL object gets refined first to form a well accepted ACL to be set by the 
+    ACL WebDAV method.
+
+    @param acl: An ACL object to be refined.
+    @type  acl: L{ACL} object
+    
+    @return: A valid ACL that contains only grant or deny clauses in an ACE.
+        Inherited and protected ACEs are stripped out.
+    @rtype:  L{ACL} object
+    """
+    acl = acl.splitGrantDeny()
+    acl = acl.stripAces()
+    return acl
+
+
+##~ unsupported or unfinished methods:
+##~ 
+##~ def report(self, report, request=None, lockToken=None):
+##~     """
+##~     This method implements the WebDAV ACP method: REPORT for given report 
+##~     types.
+##~     
+##~     Parameters:
+##~     
+##~       'report' -- Report type as a string.
+##~       
+##~       'request' -- XML content of the request for the report (defaults to None).
+##~       
+##~       'lockToken' -- Lock token to be set (defaults to None).
+##~     """
+##~     raise WebdavError('Reports are not supported by our Jacarta Slide, yet (as of Aug. 1, 2003 in CVS).')
+##~     
+##~     headers                 = createCondition(lockToken)
+##~     headers['Content-Type'] = XML_CONTENT_TYPE
+##~     body                    = '<D:%s xmlns:D="DAV:">%s</D:%s>' % (report, request, report)
+##~     #print "Body: ", body
+##~     response = self.connection._request('REPORT', self.path, body, headers)
+##~     return response
+##~     ## TODO: parse DAV:error response
+##~ 
+##~ 
+##~ def getAllAcls(self):
+##~    """
+##~     Returns a dictionary of ACL resources with respective ACL objects 
+##~     that apply to the given resource.
+##~     
+##~     ### This method needs to be extended for inherited ACLs when Tamino
+##~     support tells me (Guy) how to get to them.
+##~     """
+##~     acls = {self.path: self.getAcl()}
+##~     for ace in acls[self.path].aces:
+##~         if ace.inherited:
+##~             if not ace.inherited in acls:
+##~                 acls[ace.inherited] = self.getAcl()
+##~    
+##~     # append some more stuff here to acls for possible inherited ACLs
+##~     return acls
diff --git a/src/webdav/acp/Acl.py b/src/webdav/acp/Acl.py
new file mode 100644
index 0000000..8f2b36f
--- /dev/null
+++ b/src/webdav/acp/Acl.py
@@ -0,0 +1,311 @@
+# pylint: disable-msg=W0622
+#
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+
+"""
+ACL object handling according to WebDAV ACP specification.
+"""
+
+
+from webdav.acp.Ace import ACE
+from webdav import Constants
+from webdav.Connection import WebdavError
+from webdav.davlib import XML_DOC_HEADER
+
+
+__version__ = "$LastChangedRevision$"
+
+
+class ACL(object):
+    """
+    This class provides access to Access Control List funcionality
+    as specified in the WebDAV ACP.
+    
+    @ivar aces:          ACEs in ACL
+    @type aces:          C{list} of L{ACE} objects
+    @ivar withInherited: Flag indicating whether ACL contains inherited ACEs.
+    @type withInherited: C{bool}
+    """
+
+    # restrict instance variables
+    __slots__ = ('aces', 'withInherited')
+    
+    def __init__(self, domroot=None, aces=None):
+        """
+        Constructor should be called with either no parameters (create blank ACE),
+        or one parameter (a DOM tree or ACE list).
+        
+        @param domroot: A DOM tree (default: None).
+        @type  domroot: L{webdav.WebdavResponse.Element} object
+        @param aces:    ACE objects (default: None)
+        @type  aces:    C{list} of L{ACE} objects
+        
+        @raise WebdavError: When non-valid parameters are passed a L{WebdavError} is raised.
+        """
+        self.withInherited = None
+        self.aces          = []
+        
+        if domroot:
+            for child in domroot.children:
+                if child.name == Constants.TAG_ACE and child.ns == Constants.NS_DAV:
+                    self.addAce(ACE(child))
+                else:
+                    # This shouldn't happen, someone screwed up with the params ...
+                    raise WebdavError('Non-ACE tag handed to ACL constructor: ' + child.ns + child.name)
+        elif isinstance(aces, list) or isinstance(aces, tuple):
+            self.addAces(aces)
+        elif domroot == None and aces == None:
+            # no param ==> blank object
+            pass
+        else:
+            # This shouldn't happen, someone screwed up with the params ...
+            raise WebdavError('non-valid parameters handed to ACL constructor')
+
+    def __cmp__(self, other):
+        if not isinstance(other, ACL):
+            return 1
+        if self.withInherited == other.withInherited:
+            equal = 1
+            for ace in self.aces:
+                inList = 0
+                for otherAce in other.aces:
+                    if ace == otherAce:
+                        inList = 1
+                if inList == 0:
+                    equal = 0
+            return not equal
+        else:
+            return 1
+
+    def __repr__(self):
+        repr = '<class ACL: '
+        if self.withInherited:
+            repr += 'with inherited, '
+        first = 1
+        repr += 'aces: ['
+        for ace in self.aces:
+            if first:
+                repr += '%s' % ace
+                first = 0
+            else:
+                repr += ', %s' % ace
+        return '%s]>' % (repr)
+
+    def copy(self, other):
+        '''Copy an ACL object.
+        
+        @param other: Another ACL to copy.
+        @type  other: L{ACL} object
+        
+        @raise WebdavError: When an object that is not an L{ACL} is passed 
+            a L{WebdavError} is raised.
+        '''
+        if not isinstance(other, ACL):
+            raise WebdavError('Non-ACL object passed to copy method: %s' % other.__class__)
+        self.withInherited = other.withInherited
+        if other.aces:
+            self.addAces(other.aces)
+
+    def toXML(self):
+        """
+        Returns ACL content as a string of valid XML as described in WebDAV ACP.
+        """
+        aclTag = 'D:' + Constants.TAG_ACL
+        return XML_DOC_HEADER +\
+            '<' + aclTag + ' xmlns:D="DAV:">' + reduce(lambda xml, ace: xml + ace.toXML() + '\n', [''] + self.aces) +\
+            '</' + aclTag + '>'
+
+    def addAce(self, ace):
+        '''
+        Adds the passed ACE object to list if it's not in it, yet.
+        
+        @param ace: An ACE.
+        @type  ace: L{ACE} object
+        '''
+        newAce = ACE()
+        newAce.copy(ace)
+        # only add it if it's not in the list, yet ...
+        inList = 0
+        for element in self.aces:
+            if element == ace:
+                inList = 1
+        if not inList:
+            self.aces.append(newAce)
+
+    def addAces(self, aces):
+        '''Adds the list of passed ACE objects to list.
+        
+        @param aces: ACEs
+        @type  aces: sequence of L{ACE} objects
+        '''
+        for ace in aces:
+            self.addAce(ace)
+
+    def delAce(self, ace):
+        '''Deletes the passed ACE object from list.
+        
+        @param ace: An ACE.
+        @type  ace: L{ACE} object
+        
+        @raise WebdavError: When the ACE to be deleted is not within the ACL 
+            a L{WebdavError} is raised.
+        '''
+        # find where it is and delete it ...
+        count = 0
+        index = 0
+        for element in self.aces:
+            count += 1
+            if element == ace:
+                index = count
+        if index:
+            self.aces.pop(index - 1)
+        else:
+            raise WebdavError('ACE to be deleted not in list: %s.' % ace)
+
+    def delAces(self, aces):
+        '''Deletes the list of passed ACE objects from list.
+        
+        @param aces: ACEs
+        @type  aces: sequence of L{ACE} objects
+        '''
+        for ace in aces:
+            self.delAce(ace)
+
+    def delPrincipalsAces(self, principal):
+        """
+        Deletes all ACEs in ACL by given principal.
+        
+        @param principal: A principal.
+        @type  principal: L{Principal} object
+        """
+        # find where it is and delete it ...
+        index = 0
+        while index < len(self.aces):
+            if self.aces[index].principal.principalURL == principal.principalURL:
+                self.aces.pop(index)
+            else:
+                index += 1
+
+    def joinGrantDeny(self):
+        """
+        Returns a "refined" ACL of the ACL for ease of use in the UI. 
+        The purpose is to post the user an ACE that can contain both, granted 
+        and denied, privileges. So possible pairs of grant and deny ACEs are joined 
+        to return them in one ACE. This resulting ACE then of course IS NOT valid 
+        for setting ACLs anymore. They will have to be reconverted to yield valid 
+        ACLs for the ACL method.
+        
+        @return: A (non-valid) ACL that contains both grant and deny clauses in an ACE.
+        @rtype:  L{ACL} object
+        """
+        joinedAces = {}
+        for ace in self.aces:
+            if not ace.principal.principalURL is None:
+                principalKey = ace.principal.principalURL
+            elif not ace.principal.property is None:
+                principalKey = ace.principal.property
+            else:
+                principalKey = None
+            if ace.inherited:
+                principalKey = ace.inherited + ":" + principalKey
+            if principalKey in joinedAces:
+                joinedAces[principalKey].addGrantDenies(ace.grantDenies)
+            else:
+                joinedAces[principalKey] = ACE()
+                joinedAces[principalKey].copy(ace)
+        newAcl = ACL()
+        newAcl.addAces(joinedAces.values())
+        return newAcl
+
+    def splitGrantDeny(self):
+        """
+        Returns a "refined" ACL of the ACL for ease of use in the UI. 
+        The purpose is to post the user an ACE that can contain both, granted 
+        and denied, privileges. So possible joined grant and deny clauses in ACEs 
+        splitted to return them in separate ACEs. This resulting ACE then is valid 
+        for setting ACLs again. This method is to be seen in conjunction with the 
+        method joinGrantDeny as it reverts its effect.
+        
+        @return: A valid ACL that contains only ACEs with either grant or deny clauses.
+        @rtype:  L{ACL} object
+        """
+        acesGrant = {}
+        acesDeny  = {}
+        for ace in self.aces:
+            for grantDeny in ace.grantDenies:
+                if grantDeny.isGrant():
+                    if ace.principal.principalURL in acesGrant:
+                        ace.addGrantDeny(grantDeny)
+                    else:
+                        acesGrant[ace.principal.principalURL] = ACE()
+                        acesGrant[ace.principal.principalURL].copy(ace)
+                        acesGrant[ace.principal.principalURL].grantDenies = []
+                        acesGrant[ace.principal.principalURL].addGrantDeny(grantDeny)
+                else:
+                    if ace.principal.principalURL in acesDeny:
+                        ace.addGrantDeny(grantDeny)
+                    else:
+                        acesDeny[ace.principal.principalURL] = ACE()
+                        acesDeny[ace.principal.principalURL].copy(ace)
+                        acesDeny[ace.principal.principalURL].grantDenies = []
+                        acesDeny[ace.principal.principalURL].addGrantDeny(grantDeny)
+        newAcl = ACL()
+        newAcl.addAces(acesGrant.values())
+        newAcl.addAces(acesDeny.values())
+        return newAcl
+
+    def isValid(self):
+        """
+        Returns true (1) if all contained ACE objects are valid, 
+        otherwise false (0) is returned.
+        
+        @return: Validity of ACL.
+        @rtype:  C{bool}
+        """
+        valid = 1
+        if len(self.aces):
+            for ace in self.aces:
+                if not ace.isValid():
+                    valid = 0
+        return valid
+
+    def stripAces(self, inherited=True, protected=True):
+        """
+        Returns an ACL object with all ACEs stripped that are inherited 
+        and/or protected.
+        
+        @param inherited: Flag to indicate whether inherited ACEs should 
+            be stripped (default: True).
+        @type  inherited: C{bool}
+        @param protected: Flag to indicate whether protected ACEs should 
+            be stripped (default: True).
+        @type  protected: C{bool}
+        
+        @return: An ACL without the stripped ACEs.
+        @rtype:  L{ACL} object
+        """
+        newAcl = ACL()
+        if len(self.aces):
+            for ace in self.aces:
+                keep = 1
+                if inherited and ace.inherited:
+                    keep = 0
+                elif protected and ace.protected:
+                    keep = 0
+                if keep:
+                    newAcl.addAce(ace)
+        return newAcl
diff --git a/src/webdav/acp/GrantDeny.py b/src/webdav/acp/GrantDeny.py
new file mode 100644
index 0000000..52c9b93
--- /dev/null
+++ b/src/webdav/acp/GrantDeny.py
@@ -0,0 +1,241 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Handling of grant and deny clauses in ACEs according to WebDAV ACP specification.
+"""
+
+
+from webdav.acp.Privilege import Privilege
+from webdav import Constants
+from webdav.Connection import WebdavError
+
+
+__version__ = "$LastChangedRevision$"
+
+
+class GrantDeny(object):
+    """
+    This class provides functionality for handling
+    grant and deny clauses in ACEs.
+    
+    @ivar grantDeny:  Flag indicating whether clause grants or denies.
+    @type grantDeny:  C{bool}
+    @ivar privileges: Privileges to be granted or denied.
+    @type privileges: C{list} of L{Privilege} objects
+    """
+    
+    def __init__(self, domroot=None):
+        """
+        Constructor should be called with either no parameters 
+        (create blank GrantDeny), or one parameter (a DOM tree).
+        
+        @param domroot:     A DOM tree (default: None).
+        @type  domroot:     L{webdav.WebdavResponse.Element} object
+        
+        @raise WebdavError: When non-valid parameters are passed a L{WebdavError} is raised.
+        """
+        self.grantDeny  = 0   # 0: deny, 1: grant
+        self.privileges = []
+        
+        if domroot:
+            self.grantDeny = (domroot.name == Constants.TAG_GRANT)
+            for child in domroot.children:
+                if child.name == Constants.TAG_PRIVILEGE and child.ns == Constants.NS_DAV:
+                    self.privileges.append(Privilege(domroot=child))
+                else:
+                    # This shouldn't happen, someone screwed up with the params ...
+                    raise WebdavError('Non-privilege tag handed to GrantDeny constructor: %s' \
+                        % child.name)
+        elif domroot == None:
+            # no param ==> blank object
+            pass
+        else:
+            # This shouldn't happen, someone screwed up with the params ...
+            raise WebdavError('Non-valid parameters handed to GrantDeny constructor.')
+
+    def __cmp__(self, other):
+        """ Compares two GrantDeny instances. """
+        if not isinstance(other, GrantDeny):
+            return 1
+        if self.grantDeny == other.grantDeny:
+            equal = 1
+            for priv in self.privileges:
+                inList = 0
+                for otherPriv in other.privileges:
+                    if priv == otherPriv:
+                        inList = 1
+                if inList == 0:
+                    equal = 0
+            return not equal
+        else:
+            return 1
+
+    def __repr__(self):
+        """ Returns the representation of an instance. """
+        representation = '<class GrantDeny: '
+        if self.grantDeny:
+            representation += 'grant privileges: ['
+        else:
+            representation += 'deny privileges: ['
+        first = 1
+        for priv in self.privileges:
+            if first:
+                representation += '%s' % priv
+                first = 0
+            else:
+                representation += ', %s' % priv
+        return '%s]>' % (representation)
+
+    def copy(self, other):
+        """
+        Copy a GrantDeny object.
+        
+        @param other: Another grant or deny clause to copy.
+        @type  other: L{GrantDeny} object
+        
+        @raise WebdavError: When an object that is not an L{GrantDeny} is passed 
+            a L{WebdavError} is raised.
+        """
+        if not isinstance(other, GrantDeny):
+            raise WebdavError('Non-GrantDeny object passed to copy method: %s' \
+                % other)
+        self.grantDeny = other.grantDeny
+        if other.privileges:
+            self.addPrivileges(other.privileges)
+
+    def isGrant(self):
+        """
+        Returns whether the set of privileges is of type "grant"
+        indicating true or false.
+        
+        @return: Value whether the clause is of grant type.
+        @rtype:  C{bool}
+        """
+        return self.grantDeny
+
+    def isDeny(self):
+        """
+        Returns whether the set of privileges is of type "deny"
+        indicating true or false.
+        
+        @return: Value whether the clause is of deny type.
+        @rtype:  C{bool}
+        """
+        return not self.grantDeny
+
+    def setGrantDeny(self, grantDeny):
+        """
+        Sets the set of privileges to given value for grantDeny.
+        
+        @param grantDeny: Grant/deny value for clause (grant: True/1, deny: False/0).
+        @type  grantDeny: C{bool}
+        """
+        if grantDeny == 0 or grantDeny == 1:
+            self.grantDeny = grantDeny
+
+    def setGrant(self):
+        """ Sets the set of privileges to type "grant". """
+        self.grantDeny = 1
+
+    def setDeny(self):
+        """ Sets the set of privileges to type "deny". """
+        self.grantDeny = 0
+
+    def isAll(self):
+        """
+        Checks whether the privileges contained are equal
+        to aggregate DAV:all privilege.
+        
+        @return: Value whether all un-aggregated privileges are present.
+        @rtype:  C{bool}
+        """
+        
+        if len(self.privileges) == 1 and self.privileges[0].name == Constants.TAG_ALL:
+            return 1
+        return 0
+
+    def addPrivilege(self, privilege):
+        """
+        Adds the passed privilege to list if it's not in it, yet.
+        
+        @param privilege: A privilege.
+        @type  privilege: L{Privilege} object
+        """
+        inList = False
+        for priv in self.privileges:
+            if priv == privilege:
+                inList = True
+        if not inList:
+            newPrivilege = Privilege()
+            newPrivilege.copy(privilege)
+            self.privileges.append(newPrivilege)
+
+    def addPrivileges(self, privileges):
+        """
+        Adds the list of passed privileges to list.
+        
+        @param privileges: Several privileges.
+        @type  privileges: sequence of L{Privilege} objects
+        """
+        for priv in privileges:
+            self.addPrivilege(priv)
+
+    def delPrivilege(self, privilege):
+        """
+        Deletes the passed privilege from list if it's in it.
+        
+        @param privilege: A privilege.
+        @type  privilege: L{Privilege} object
+        
+        @raise WebdavError: A L{WebdavError} is raised if the privilege to be 
+            deleted is not present.
+        """
+        count = 0
+        index = 0
+        for priv in self.privileges:
+            count += 1
+            if priv == privilege:
+                index = count
+        if index:
+            self.privileges.pop(index - 1)
+        else:
+            raise WebdavError('Privilege to be deleted not in list: %s' % privilege)
+
+    def delPrivileges(self, privileges):
+        """
+        Deletes the list of passed privileges from list.
+        
+        @param privileges: Several privileges.
+        @type  privileges: sequence of L{Privilege} objects
+        """
+        for priv in privileges:
+            self.delPrivilege(priv)
+
+    def toXML(self):
+        """
+        Returns string of GrantDeny content to valid XML as described in WebDAV ACP.
+        """
+        assert self.privileges, "GrantDeny object is not initialized or does not contain content!"
+        
+        if self.isGrant():
+            tag = 'D:' + Constants.TAG_GRANT
+        else:
+            tag = 'D:' + Constants.TAG_DENY
+            
+        res = ''
+        for privilege in self.privileges:
+            res += privilege.toXML()
+        return '<%s>%s</%s>' % (tag, res, tag)
diff --git a/src/webdav/acp/Makefile.am b/src/webdav/acp/Makefile.am
new file mode 100644
index 0000000..506eb92
--- /dev/null
+++ b/src/webdav/acp/Makefile.am
@@ -0,0 +1,12 @@
+sugardir = $(pythondir)/webdav/acp
+sugar_PYTHON =                  \
+             AceHandler.py      \
+             Ace.py             \
+             Acl.py             \
+             GrantDeny.py       \
+             __init__.py        \
+             Principal.py       \
+             Privilege.py
+             
+
+
diff --git a/src/webdav/acp/Principal.py b/src/webdav/acp/Principal.py
new file mode 100644
index 0000000..a0d5ec9
--- /dev/null
+++ b/src/webdav/acp/Principal.py
@@ -0,0 +1,189 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Handling of principals for ACEs according to WebDAV ACP specification.
+"""
+
+
+from webdav import Constants
+from webdav.Connection import WebdavError
+
+
+__version__ = "$LastChangedRevision$"
+
+
+class Principal(object):
+    """
+    This class provides functionality for handling
+    principals according to the WebDAV ACP.
+     
+    @ivar displayname:  Name of the principal for output
+    @type displayname:  C{string}
+    @ivar principalURL: URL under which the principal can be referenced on the server.
+    @type principalURL: C{string}
+    @ivar property:     Information on type of a pseudo/jproperty principal, e. g. 
+        DAV:owner, DAV:authenticated, etc.
+    @type property:     C{string}
+    
+    @cvar _TAG_LIST_PRINCIPALS: List of allowed XML tags within a principal declaration.
+    @type _TAG_LIST_PRINCIPALS: C{tuple} of C{string}s
+    @cvar _TAG_LIST_STATUS:     List of XML tags for the status of a pseudo principal.
+    @type _TAG_LIST_STATUS:     C{tuple} of C{string}s
+    """
+    
+    # some local constants for this class to make things easier/more readable:
+    _TAG_LIST_PRINCIPALS = (Constants.TAG_HREF,     # directly by URL
+                            Constants.TAG_ALL, Constants.TAG_AUTHENTICATED, Constants.TAG_UNAUTHENTICATED, 
+                                                    # by log-in status
+                            Constants.TAG_PROPERTY, # for property info, e. g. 'owner'
+                            Constants.TAG_SELF,     # only if the resource is the principal itself
+                            Constants.TAG_PROP)     # contains property info like 'displayname'
+    _TAG_LIST_STATUS     = (Constants.TAG_ALL, Constants.TAG_AUTHENTICATED, Constants.TAG_UNAUTHENTICATED)
+    
+    # restrict instance variables
+    __slots__ = ('displayname', 'principalURL', 'property')
+    
+    def __init__(self, domroot=None, displayname=None, principalURL=None):
+        """
+        Constructor should be called with either no parameters (create blank Principal),
+        one parameter (a DOM tree), or two parameters (displayname and URL or property tag).
+        
+        @param domroot:      A DOM tree (default: None).
+        @type  domroot:      L{webdav.WebdavResponse.Element} object
+        @param displayname:  The display name of a principal (default: None).
+        @type  displayname:  C{string}
+        @param principalURL: The URL representing a principal (default: None).
+        @type  principalURL: C{string}
+        
+        @raise WebdavError: When non-valid parameters or sets of parameters are 
+            passed a L{WebdavError} is raised.
+        """
+        self.displayname  = None
+        self.principalURL = None
+        self.property     = None
+
+        if domroot:
+            for child in domroot.children:
+                if child.ns == Constants.NS_DAV and (child.name in self._TAG_LIST_PRINCIPALS):
+                    if child.name == Constants.TAG_PROP:
+                        self.displayname = \
+                            child.find(Constants.PROP_DISPLAY_NAME, Constants.NS_DAV)
+                    elif child.name == Constants.TAG_HREF:
+                        self.principalURL = child.textof()
+                        if self.principalURL and self.property in self._TAG_LIST_STATUS:
+                            raise WebdavError('Principal cannot contain a URL and "%s"' % (self.property))
+                    elif child.name == Constants.TAG_PROPERTY:
+                        if child.count() == 1:
+                            if self.property:
+                                raise WebdavError('Property for principal has already been set: old "%s", new "%s"' \
+                                    % (self.property, child.pop().name))
+                            elif self.principalURL:
+                                raise WebdavError('Principal cannot contain a URL and "%s"' % (self.property))
+                            else:
+                                self.property = child.pop().name
+                        else:
+                            raise WebdavError("There should be only one value in the property for a principal, we have: %s" \
+                                % child.name)
+                    else:
+                        if self.property:
+                            raise WebdavError('Property for principal has already been set: old "%s", new "%s"' \
+                                % (self.property, child.name))
+                        else:
+                            self.property = child.name
+                        if self.principalURL and self.property in self._TAG_LIST_STATUS:
+                            raise WebdavError('Principal cannot contain a URL and "%s"' % (self.property))
+                else: # This shouldn't happen, something's wrong with the DOM tree
+                    raise WebdavError('Non-valid tag in principal DOM tree for constructor: %s' % child.name)
+        elif displayname == None or principalURL == None:
+            if displayname:
+                self.displayname  = displayname
+            if principalURL:
+                self.principalURL = principalURL
+        else:
+            # This shouldn't happen, someone screwed up with the params ...
+            raise WebdavError('Non-valid parameters handed to Principal constructor.')
+
+    def __cmp__(self, other):
+        if not isinstance(other, Principal):
+            return 1
+        if self.displayname == other.displayname \
+                and self.principalURL == other.principalURL \
+                and self.property == other.property:
+            return 0
+        else:
+            return 1
+
+    def __repr__(self):
+        return '<class Principal: displayname: "%s", principalURL: "%s", property: "%s">' \
+            % (self.displayname, self.principalURL, self.property)
+
+    def copy(self, other):
+        """Copy Principal object.
+        
+        @param other: Another principal to copy.
+        @type  other: L{Principal} object
+        
+        @raise WebdavError: When an object that is not a L{Principal} is passed 
+            a L{WebdavError} is raised.
+        """
+        if not isinstance(other, Principal):
+            raise WebdavError('Non-Principal object passed to copy method: ' % other.__class__)
+        self.displayname  = other.displayname
+        self.principalURL = other.principalURL
+        self.property     = other.property
+
+    def isValid(self):
+        """
+        Checks whether necessarry props for principal are set.
+        
+        @return: Validity of principal.
+        @rtype:  C{bool}
+        """
+        return (self.displayname and
+                (self.principalURL or self.property) and
+                not (self.principalURL and self.property))
+        
+    def toXML(self, invert=False, displayname=False, defaultNameSpace=None):
+        """Returns string of Principal content in valid XML as described in WebDAV ACP.
+        
+        @param defaultNameSpace: Name space (default: None).
+        @type  defaultNameSpace: C(string)
+        @param invert:           True if principal should be inverted (default: False).
+        @type  invert:           C{bool}
+        @param displayname:      True if displayname should be in output (default: False).
+        @type  displayname:      C{bool}
+        """
+        # this check is needed for setting principals only:
+        # assert self.isValid(), "principal is not initialized or does not contain valid content!"
+        
+        PRINCIPAL = 'D:' + Constants.TAG_PRINCIPAL
+        res = ''
+        if self.principalURL:
+            res += '<D:%s>%s</D:%s>' % (Constants.TAG_HREF, self.principalURL, Constants.TAG_HREF)
+        elif self.property in self._TAG_LIST_STATUS \
+                or self.property == Constants.TAG_SELF:
+            res += '<D:%s/>' % (self.property)
+        elif self.property:
+            res += '<D:%s><D:%s/></D:%s>' \
+                % (Constants.TAG_PROPERTY, self.property, Constants.TAG_PROPERTY)
+        if self.displayname and displayname:
+            res += '<D:%s><D:%s>%s</D:%s></D:%s>' \
+                % (Constants.TAG_PROP, Constants.PROP_DISPLAY_NAME,
+                    self.displayname,
+                    Constants.PROP_DISPLAY_NAME, Constants.TAG_PROP)
+        if invert:
+            res = '<D:invert>%s</D:invert>' % (res)
+        return '<%s>%s</%s>' % (PRINCIPAL, res, PRINCIPAL)
diff --git a/src/webdav/acp/Privilege.py b/src/webdav/acp/Privilege.py
new file mode 100644
index 0000000..abfdcf9
--- /dev/null
+++ b/src/webdav/acp/Privilege.py
@@ -0,0 +1,125 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Handling for privileges for grant and deny clauses in ACEs 
+according to WebDAV ACP specification.
+"""
+
+
+from webdav import Constants
+from webdav.Connection import WebdavError
+
+
+__version__ = "$LastChangedRevision$"
+
+
+class Privilege(object):
+    """This class provides functionality for handling privileges for ACEs.
+     
+    @ivar name: Name of the privilege.
+    @type name: C{string}
+    
+    @cvar __privileges: List of allowed XML tags for privileges.
+    @type __privileges: C{tuple} of C{string}s
+    """
+
+
+    __privileges = list()
+        
+    
+    def __init__(self, privilege=None, domroot=None):
+        """
+        Constructor should be called with either no parameters (create blank Privilege),
+        one parameter (a DOM tree or privilege name to initialize it directly).
+        
+        @param domroot: A DOM tree (default: None).
+        @type  domroot: L{webdav.WebdavResponse.Element} object
+        @param privilege: The valid name of a privilege (default: None).
+        @type  privilege: C{string}
+        
+        @raise WebdavError: When non-valid parameters or sets of parameters are 
+                            passed a L{WebdavError} is raised.
+        """
+        
+        self.name = None
+        
+        if domroot:
+            if len(domroot.children) != 1:
+                raise WebdavError('Wrong number of elements for Privilege constructor, we have: %i' \
+                    % (len(domroot.children)))
+            else:
+                child = domroot.children[0]
+                if child.ns == Constants.NS_DAV and child.name in self.__privileges:
+                    self.name = child.name
+                else:
+                    raise WebdavError('Not a valid privilege tag, we have: %s%s' \
+                        % (child.ns, child.name))
+        elif privilege:
+            if privilege in self.__privileges:
+                self.name = privilege
+            else:
+                raise WebdavError('Not a valid privilege tag, we have: %s.' % str(privilege))
+
+    @classmethod
+    def registerPrivileges(cls, privileges):
+        """
+        Registers supported privilege tags.
+        
+        @param privileges: List of privilege tags.
+        @type privileges: C{list} of C{unicode}
+        """
+        
+        for privilege in privileges:
+            cls.__privileges.append(privilege)
+    
+    def __cmp__(self, other):
+        """ Compares two Privilege instances. """
+        if not isinstance(other, Privilege):
+            return 1
+        if self.name != other.name:
+            return 1
+        else:
+            return 0
+
+    def __repr__(self):
+        """ Returns the string representation of an instance. """
+        return '<class Privilege: name: "%s">' % (self.name)
+
+    def copy(self, other):
+        """
+        Copy Privilege object.
+        
+        @param other: Another privilege to copy.
+        @type  other: L{Privilege} object
+        
+        @raise WebdavError: When an object that is not a L{Privilege} is passed 
+            a L{WebdavError} is raised.
+        """
+        if not isinstance(other, Privilege):
+            raise WebdavError('Non-Privilege object passed to copy method: %s' % other.__class__)
+        self.name = other.name
+
+    def toXML(self):
+        """
+        Returns privilege content as string in valid XML as described in WebDAV ACP.
+        
+        @param defaultNameSpace: Name space (default: None).
+        @type  defaultNameSpace: C(string)
+        """
+        assert self.name != None, "privilege is not initialized or does not contain valid content!"
+        
+        privilege = 'D:' + Constants.TAG_PRIVILEGE
+        return '<%s><D:%s/></%s>' % (privilege, self.name, privilege)
diff --git a/src/webdav/acp/__init__.py b/src/webdav/acp/__init__.py
new file mode 100644
index 0000000..b5af299
--- /dev/null
+++ b/src/webdav/acp/__init__.py
@@ -0,0 +1,33 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from webdav import Constants 
+from webdav.acp.Acl import ACL
+from webdav.acp.Ace import ACE
+from webdav.acp.GrantDeny import GrantDeny
+from webdav.acp.Privilege import Privilege
+from webdav.acp.Principal import Principal
+
+
+__version__ = "$LastChangedRevision$"
+
+
+privileges = [Constants.TAG_READ, Constants.TAG_WRITE, Constants.TAG_WRITE_PROPERTIES, 
+              Constants.TAG_WRITE_CONTENT, Constants.TAG_UNLOCK, Constants.TAG_READ_ACL, 
+              Constants.TAG_READ_CURRENT_USER_PRIVILEGE_SET, Constants.TAG_WRITE_ACL, Constants.TAG_ALL, 
+              Constants.TAG_BIND, Constants.TAG_UNBIND, Constants.TAG_TAMINO_SECURITY,
+              Constants.TAG_BIND_COLLECTION, Constants.TAG_UNBIND_COLLECTION, Constants.TAG_READ_PRIVATE_PROPERTIES,
+              Constants.TAG_WRITE_PRIVATE_PROPERTIES]
+Privilege.registerPrivileges(privileges)
diff --git a/src/webdav/davlib.py b/src/webdav/davlib.py
new file mode 100644
index 0000000..f4dac91
--- /dev/null
+++ b/src/webdav/davlib.py
@@ -0,0 +1,336 @@
+# pylint: disable-msg=W0402,W0231,W0141,R0903,C0321,W0701,R0904,C0103,W0201,W0102,R0913,W0622,E1101,C0111,C0121,R0901
+# DAV client library
+#
+# Copyright (C) 1998-2000 Guido van Rossum. All Rights Reserved.
+# Written by Greg Stein. Given to Guido. Licensed using the Python license.
+#
+# This module is maintained by Greg and is available at:
+#    http://www.lyra.org/greg/python/davlib.py
+#
+# Since this isn't in the Python distribution yet, we'll use the CVS ID
+# for tracking:
+#   $Id: davlib.py 3182 2008-02-22 15:57:55 +0000 (Fr, 22 Feb 2008) schlauch $
+#
+
+import httplib
+import urllib
+import string
+import types
+import mimetypes
+import qp_xml
+
+
+INFINITY = 'infinity'
+XML_DOC_HEADER = '<?xml version="1.0" encoding="utf-8"?>'
+XML_CONTENT_TYPE = 'text/xml; charset="utf-8"'
+
+# block size for copying files up to the server
+BLOCKSIZE = 16384
+
+
+class HTTPProtocolChooser(httplib.HTTPSConnection):
+    def __init__(self, *args, **kw):
+        self.protocol = kw.pop('protocol')
+        if self.protocol == "https":
+            self.default_port = 443
+        else:
+            self.default_port = 80
+            
+        apply(httplib.HTTPSConnection.__init__, (self,) + args, kw)
+
+    def connect(self):
+        if self.protocol == "https":
+            httplib.HTTPSConnection.connect(self)
+        else:
+            httplib.HTTPConnection.connect(self)
+
+
+class HTTPConnectionAuth(HTTPProtocolChooser):
+    def __init__(self, *args, **kw):
+        apply(HTTPProtocolChooser.__init__, (self,) + args, kw)
+
+        self.__username = None
+        self.__password = None
+        self.__nonce = None
+        self.__opaque = None
+
+    def setauth(self, username, password):
+        self.__username = username
+        self.__password = password
+
+
+def _parse_status(elem):
+    text = elem.textof()
+    idx1 = string.find(text, ' ')
+    idx2 = string.find(text, ' ', idx1+1)
+    return int(text[idx1:idx2]), text[idx2+1:]
+
+class _blank:
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+class _propstat(_blank): pass
+class _response(_blank): pass
+class _multistatus(_blank): pass
+
+def _extract_propstat(elem):
+    ps = _propstat(prop={}, status=None, responsedescription=None)
+    for child in elem.children:
+        if child.ns != 'DAV:':
+            continue
+        if child.name == 'prop':
+            for prop in child.children:
+                ps.prop[(prop.ns, prop.name)] = prop
+        elif child.name == 'status':
+            ps.status = _parse_status(child)
+        elif child.name == 'responsedescription':
+            ps.responsedescription = child.textof()
+        ### unknown element name
+
+    return ps
+
+def _extract_response(elem):
+    resp = _response(href=[], status=None, responsedescription=None, propstat=[])
+    for child in elem.children:
+        if child.ns != 'DAV:':
+            continue
+        if child.name == 'href':
+            resp.href.append(child.textof())
+        elif child.name == 'status':
+            resp.status = _parse_status(child)
+        elif child.name == 'responsedescription':
+            resp.responsedescription = child.textof()
+        elif child.name == 'propstat':
+            resp.propstat.append(_extract_propstat(child))
+        ### unknown child element
+
+    return resp
+
+def _extract_msr(root):
+    if root.ns != 'DAV:' or root.name != 'multistatus':
+        raise 'invalid response: <DAV:multistatus> expected'
+
+    msr = _multistatus(responses=[ ], responsedescription=None)
+
+    for child in root.children:
+        if child.ns != 'DAV:':
+            continue
+        if child.name == 'responsedescription':
+            msr.responsedescription = child.textof()
+        elif child.name == 'response':
+            msr.responses.append(_extract_response(child))
+        ### unknown child element
+
+    return msr
+
+def _extract_locktoken(root):
+    if root.ns != 'DAV:' or root.name != 'prop':
+        raise 'invalid response: <DAV:prop> expected'
+    elem = root.find('lockdiscovery', 'DAV:')
+    if not elem:
+        raise 'invalid response: <DAV:lockdiscovery> expected'
+    elem = elem.find('activelock', 'DAV:')
+    if not elem:
+        raise 'invalid response: <DAV:activelock> expected'
+    elem = elem.find('locktoken', 'DAV:')
+    if not elem:
+        raise 'invalid response: <DAV:locktoken> expected'
+    elem = elem.find('href', 'DAV:')
+    if not elem:
+        raise 'invalid response: <DAV:href> expected'
+    return elem.textof()
+
+
+class DAVResponse(httplib.HTTPResponse):
+    def parse_multistatus(self):
+        self.root = qp_xml.Parser().parse(self)
+        self.msr = _extract_msr(self.root)
+
+    def parse_lock_response(self):
+        self.root = qp_xml.Parser().parse(self)
+        self.locktoken = _extract_locktoken(self.root)
+
+
+class DAV(HTTPConnectionAuth):
+
+    response_class = DAVResponse
+
+    def get(self, url, extra_hdrs={ }):
+        return self._request('GET', url, extra_hdrs=extra_hdrs)
+
+    def head(self, url, extra_hdrs={ }):
+        return self._request('HEAD', url, extra_hdrs=extra_hdrs)
+
+    def post(self, url, data={ }, body=None, extra_hdrs={ }):
+        headers = extra_hdrs.copy()
+
+        assert body or data, "body or data must be supplied"
+        assert not (body and data), "cannot supply both body and data"
+        if data:
+            body = ''
+            for key, value in data.items():
+                if isinstance(value, types.ListType):
+                    for item in value:
+                        body = body + '&' + key + '=' + urllib.quote(str(item))
+                else:
+                    body = body + '&' + key + '=' + urllib.quote(str(value))
+            body = body[1:]
+            headers['Content-Type'] = 'application/x-www-form-urlencoded'
+
+        return self._request('POST', url, body, headers)
+
+    def options(self, url='*', extra_hdrs={ }):
+        return self._request('OPTIONS', url, extra_hdrs=extra_hdrs)
+
+    def trace(self, url, extra_hdrs={ }):
+        return self._request('TRACE', url, extra_hdrs=extra_hdrs)
+
+    def put(self, url, contents,
+            content_type=None, content_enc=None, extra_hdrs={ }):
+
+        if not content_type:
+            content_type, content_enc = mimetypes.guess_type(url)
+
+        headers = extra_hdrs.copy()
+        if content_type:
+            headers['Content-Type'] = content_type
+        if content_enc:
+            headers['Content-Encoding'] = content_enc
+        return self._request('PUT', url, contents, headers)
+
+    def delete(self, url, extra_hdrs={ }):
+        return self._request('DELETE', url, extra_hdrs=extra_hdrs)
+
+    def propfind(self, url, body=None, depth=None, extra_hdrs={ }):
+        headers = extra_hdrs.copy()
+        headers['Content-Type'] = XML_CONTENT_TYPE
+        if depth is not None:
+            headers['Depth'] = str(depth)
+        return self._request('PROPFIND', url, body, headers)
+
+    def proppatch(self, url, body, extra_hdrs={ }):
+        headers = extra_hdrs.copy()
+        headers['Content-Type'] = XML_CONTENT_TYPE
+        return self._request('PROPPATCH', url, body, headers)
+
+    def mkcol(self, url, extra_hdrs={ }):
+        return self._request('MKCOL', url, extra_hdrs=extra_hdrs)
+
+    def move(self, src, dst, extra_hdrs={ }):
+        headers = extra_hdrs.copy()
+        headers['Destination'] = dst
+        return self._request('MOVE', src, extra_hdrs=headers)
+
+    def copy(self, src, dst, depth=None, extra_hdrs={ }):
+        headers = extra_hdrs.copy()
+        headers['Destination'] = dst
+        if depth is not None:
+            headers['Depth'] = str(depth)
+        return self._request('COPY', src, extra_hdrs=headers)
+
+    def lock(self, url, owner='', timeout=None, depth=None,
+             scope='exclusive', type='write', extra_hdrs={ }):
+        headers = extra_hdrs.copy()
+        headers['Content-Type'] = XML_CONTENT_TYPE
+        if depth is not None:
+            headers['Depth'] = str(depth)
+        if timeout is not None:
+            headers['Timeout'] = timeout
+        body = XML_DOC_HEADER + \
+               '<DAV:lockinfo xmlns:DAV="DAV:">' + \
+               '<DAV:lockscope><DAV:%s/></DAV:lockscope>' % scope + \
+               '<DAV:locktype><DAV:%s/></DAV:locktype>' % type + \
+               '<DAV:owner>' + owner + '</DAV:owner>' + \
+               '</DAV:lockinfo>'
+        return self._request('LOCK', url, body, extra_hdrs=headers)
+
+    def unlock(self, url, locktoken, extra_hdrs={ }):
+        headers = extra_hdrs.copy()
+        if locktoken[0] != '<':
+            locktoken = '<' + locktoken + '>'
+        headers['Lock-Token'] = locktoken
+        return self._request('UNLOCK', url, extra_hdrs=headers)
+
+    def _request(self, method, url, body=None, extra_hdrs={}):
+        "Internal method for sending a request."
+
+        self.request(method, url, body, extra_hdrs)
+        return self.getresponse()
+
+
+    #
+    # Higher-level methods for typical client use
+    #
+
+    def allprops(self, url, depth=None):
+        body = XML_DOC_HEADER + \
+               '<DAV:propfind xmlns:DAV="DAV:"><DAV:allprop/></DAV:propfind>'
+        return self.propfind(url, body, depth=depth)
+
+    def propnames(self, url, depth=None):
+        body = XML_DOC_HEADER + \
+               '<DAV:propfind xmlns:DAV="DAV:"><DAV:propname/></DAV:propfind>'
+        return self.propfind(url, body, depth)
+
+    def getprops(self, url, *names, **kw):
+        assert names, 'at least one property name must be provided'
+        if kw.has_key('ns'):
+            xmlns = ' xmlns:NS="' + kw['ns'] + '"'
+            ns = 'NS:'
+            del kw['ns']
+        else:
+            xmlns = ns = ''
+        if kw.has_key('depth'):
+            depth = kw['depth']
+            del kw['depth']
+        else:
+            depth = 0
+        assert not kw, 'unknown arguments'
+        body = XML_DOC_HEADER + \
+               '<DAV:propfind xmlns:DAV="DAV:"' + xmlns + '><DAV:prop><' + ns + \
+               string.joinfields(names, '/><' + ns) + \
+               '/></DAV:prop></DAV:propfind>'
+        return self.propfind(url, body, depth)
+
+    def delprops(self, url, *names, **kw):
+        assert names, 'at least one property name must be provided'
+        if kw.has_key('ns'):
+            xmlns = ' xmlns:NS="' + kw['ns'] + '"'
+            ns = 'NS:'
+            del kw['ns']
+        else:
+            xmlns = ns = ''
+        assert not kw, 'unknown arguments'
+        body = XML_DOC_HEADER + \
+               '<DAV:propertyupdate xmlns:DAV="DAV:"' + xmlns + \
+               '><DAV:remove><DAV:prop><' + ns + \
+               string.joinfields(names, '/><' + ns) + \
+               '/></DAV:prop></DAV:remove></DAV:propertyupdate>'
+        return self.proppatch(url, body)
+
+    def setprops(self, url, *xmlprops, **props):
+        assert xmlprops or props, 'at least one property must be provided'
+        xmlprops = list(xmlprops)
+        if props.has_key('ns'):
+            xmlns = ' xmlns:NS="' + props['ns'] + '"'
+            ns = 'NS:'
+            del props['ns']
+        else:
+            xmlns = ns = ''
+        for key, value in props.items():
+            if value:
+                xmlprops.append('<%s%s>%s</%s%s>' % (ns, key, value, ns, key))
+            else:
+                xmlprops.append('<%s%s/>' % (ns, key))
+        elems = string.joinfields(xmlprops, '')
+        body = XML_DOC_HEADER + \
+               '<DAV:propertyupdate xmlns:DAV="DAV:"' + xmlns + \
+               '><DAV:set><DAV:prop>' + \
+               elems + \
+               '</DAV:prop></DAV:set></DAV:propertyupdate>'
+        return self.proppatch(url, body)
+
+    def get_lock(self, url, owner='', timeout=None, depth=None):
+        response = self.lock(url, owner, timeout, depth)
+        response.parse_lock_response()
+        return response.locktoken
+    
\ No newline at end of file
diff --git a/src/webdav/logger.py b/src/webdav/logger.py
new file mode 100644
index 0000000..d2538ef
--- /dev/null
+++ b/src/webdav/logger.py
@@ -0,0 +1,51 @@
+# Copyright 2008 German Aerospace Center (DLR)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""" 
+Module provides access to a configured logger instance.
+The logger writes C{sys.stdout}.
+"""
+
+
+import logging
+import sys
+
+
+__version__ = "$LastChangedRevision$"[11:-2]
+
+
+_defaultLoggerName = "webdavLogger"
+_fileLogFormat = "%(asctime)s: %(levelname)s: %(message)s"
+    
+
+def getDefaultLogger(handler=None):
+    """ 
+    Returns a configured logger object.
+    
+    @return: Logger instance.
+    @rtype: C{logging.Logger}
+    """
+    
+    myLogger = logging.getLogger(_defaultLoggerName)
+    if len(myLogger.handlers) == 0: 
+        myLogger.level = logging.DEBUG
+        formatter = logging.Formatter(_fileLogFormat)
+        if handler is None:
+            stdoutHandler = logging.StreamHandler(sys.stdout)
+            stdoutHandler.setFormatter(formatter)
+            myLogger.addHandler(stdoutHandler)
+        else:
+            myLogger.addHandler(handler)
+    return myLogger
diff --git a/src/webdav/qp_xml.py b/src/webdav/qp_xml.py
new file mode 100644
index 0000000..f167e1b
--- /dev/null
+++ b/src/webdav/qp_xml.py
@@ -0,0 +1,240 @@
+# pylint: disable-msg=W0311,E1101,E1103,W0201,C0103,W0622,W0402,W0706,R0911,W0613,W0612,R0912,W0141,C0111,C0121
+
+# qp_xml: Quick Parsing for XML
+#
+# Written by Greg Stein. Public Domain.
+# No Copyright, no Rights Reserved, and no Warranties.
+#
+# This module is maintained by Greg and is available as part of the XML-SIG
+# distribution. This module and its changelog can be fetched at:
+#    http://www.lyra.org/cgi-bin/viewcvs.cgi/xml/xml/utils/qp_xml.py
+#
+# Additional information can be found on Greg's Python page at:
+#    http://www.lyra.org/greg/python/
+#
+# This module was added to the XML-SIG distribution on February 14, 2000.
+# As part of that distribution, it falls under the XML distribution license.
+#
+
+import string
+from xml.parsers import expat
+
+
+error = __name__ + '.error'
+
+
+#
+# The parsing class. Instantiate and pass a string/file to .parse()
+#
+class Parser:
+  def __init__(self):
+    self.reset()
+
+  def reset(self):
+    self.root = None
+    self.cur_elem = None
+
+  def find_prefix(self, prefix):
+    elem = self.cur_elem
+    while elem:
+      if elem.ns_scope.has_key(prefix):
+        return elem.ns_scope[prefix]
+      elem = elem.parent
+
+    if prefix == '':
+      return ''        # empty URL for "no namespace"
+
+    return None
+
+  def process_prefix(self, name, use_default):
+    idx = string.find(name, ':')
+    if idx == -1:
+      if use_default:
+        return self.find_prefix(''), name
+      return '', name    # no namespace
+
+    if string.lower(name[:3]) == 'xml':
+      return '', name    # name is reserved by XML. don't break out a NS.
+
+    ns = self.find_prefix(name[:idx])
+    if ns is None:
+      raise error, 'namespace prefix ("%s") not found' % name[:idx]
+
+    return ns, name[idx+1:]
+
+  def start(self, name, attrs):
+    elem = _element(name=name, lang=None, parent=None,
+                    children=[], ns_scope={}, attrs={},
+                    first_cdata='', following_cdata='')
+
+    if self.cur_elem:
+      elem.parent = self.cur_elem
+      elem.parent.children.append(elem)
+      self.cur_elem = elem
+    else:
+      self.cur_elem = self.root = elem
+
+    work_attrs = [ ]
+
+    # scan for namespace declarations (and xml:lang while we're at it)
+    for name, value in attrs.items():
+      if name == 'xmlns':
+        elem.ns_scope[''] = value
+      elif name[:6] == 'xmlns:':
+        elem.ns_scope[name[6:]] = value
+      elif name == 'xml:lang':
+        elem.lang = value
+      else:
+        work_attrs.append((name, value))
+
+    # inherit xml:lang from parent
+    if elem.lang is None and elem.parent:
+      elem.lang = elem.parent.lang
+
+    # process prefix of the element name
+    elem.ns, elem.name = self.process_prefix(elem.name, 1)
+
+    # process attributes' namespace prefixes
+    for name, value in work_attrs:
+      elem.attrs[self.process_prefix(name, 0)] = value
+
+  def end(self, name):
+    parent = self.cur_elem.parent
+
+    del self.cur_elem.ns_scope
+    del self.cur_elem.parent
+
+    self.cur_elem = parent
+
+  def cdata(self, data):
+    elem = self.cur_elem
+    if elem.children:
+      last = elem.children[-1]
+      last.following_cdata = last.following_cdata + data
+    else:
+      elem.first_cdata = elem.first_cdata + data
+
+  def parse(self, input):
+    self.reset()
+
+    p = expat.ParserCreate()
+    p.StartElementHandler = self.start
+    p.EndElementHandler = self.end
+    p.CharacterDataHandler = self.cdata
+
+    try:
+      if type(input) == type(''):
+        p.Parse(input, 1)
+      else:
+        while 1:
+          s = input.read(_BLOCKSIZE)
+          if not s:
+            p.Parse('', 1)
+            break
+
+          p.Parse(s, 0)
+
+    finally:
+      if self.root:
+        _clean_tree(self.root)
+
+    return self.root
+
+
+#
+# handy function for dumping a tree that is returned by Parser
+#
+def dump(f, root):
+  f.write('<?xml version="1.0"?>\n')
+  namespaces = _collect_ns(root)
+  _dump_recurse(f, root, namespaces, dump_ns=1)
+  f.write('\n')
+
+
+#
+# This function returns the element's CDATA. Note: this is not recursive --
+# it only returns the CDATA immediately within the element, excluding the
+# CDATA in child elements.
+#
+def textof(elem):
+  return elem.textof()
+
+
+#########################################################################
+#
+# private stuff for qp_xml
+#
+
+_BLOCKSIZE = 16384    # chunk size for parsing input
+
+class _element:
+  def __init__(self, **kw):
+    self.__dict__.update(kw)
+
+  def textof(self):
+    '''Return the CDATA of this element.
+
+    Note: this is not recursive -- it only returns the CDATA immediately
+    within the element, excluding the CDATA in child elements.
+    '''
+    s = self.first_cdata
+    for child in self.children:
+      s = s + child.following_cdata
+    return s
+
+  def find(self, name, ns=''):
+    for elem in self.children:
+      if elem.name == name and elem.ns == ns:
+        return elem
+    return None
+
+
+def _clean_tree(elem):
+  elem.parent = None
+  del elem.parent
+  map(_clean_tree, elem.children)
+
+
+def _collect_recurse(elem, dict):
+  dict[elem.ns] = None
+  for ns, name in elem.attrs.keys():
+    dict[ns] = None
+  for child in elem.children:
+    _collect_recurse(child, dict)
+
+def _collect_ns(elem):
+  "Collect all namespaces into a NAMESPACE -> PREFIX mapping."
+  d = { '' : None }
+  _collect_recurse(elem, d)
+  del d['']    # make sure we don't pick up no-namespace entries
+  keys = d.keys()
+  for i in range(len(keys)):
+    d[keys[i]] = i
+  return d
+
+def _dump_recurse(f, elem, namespaces, lang=None, dump_ns=0):
+  if elem.ns:
+    f.write('<ns%d:%s' % (namespaces[elem.ns], elem.name))
+  else:
+    f.write('<' + elem.name)
+  for (ns, name), value in elem.attrs.items():
+    if ns:
+      f.write(' ns%d:%s="%s"' % (namespaces[ns], name, value))
+    else:
+      f.write(' %s="%s"' % (name, value))
+  if dump_ns:
+    for ns, id in namespaces.items():
+      f.write(' xmlns:ns%d="%s"' % (id, ns))
+  if elem.lang != lang:
+    f.write(' xml:lang="%s"' % elem.lang)
+  if elem.children or elem.first_cdata:
+    f.write('>' + elem.first_cdata)
+    for child in elem.children:
+      _dump_recurse(f, child, namespaces, elem.lang)
+      f.write(child.following_cdata)
+    if elem.ns:
+      f.write('</ns%d:%s>' % (namespaces[elem.ns], elem.name))
+    else:
+      f.write('</%s>' % elem.name)
+  else:
+    f.write('/>')
diff --git a/src/webdav/uuid_.py b/src/webdav/uuid_.py
new file mode 100644
index 0000000..3b590e8
--- /dev/null
+++ b/src/webdav/uuid_.py
@@ -0,0 +1,476 @@
+r"""UUID objects (universally unique identifiers) according to RFC 4122.
+
+This module provides immutable UUID objects (class UUID) and the functions
+uuid1(), uuid3(), uuid4(), uuid5() for generating version 1, 3, 4, and 5
+UUIDs as specified in RFC 4122.
+
+If all you want is a unique ID, you should probably call uuid1() or uuid4().
+Note that uuid1() may compromise privacy since it creates a UUID containing
+the computer's network address.  uuid4() creates a random UUID.
+
+Typical usage:
+
+    >>> import uuid
+
+    # make a UUID based on the host ID and current time
+    >>> uuid.uuid1()
+    UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')
+
+    # make a UUID using an MD5 hash of a namespace UUID and a name
+    >>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')
+    UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')
+
+    # make a random UUID
+    >>> uuid.uuid4()
+    UUID('16fd2706-8baf-433b-82eb-8c7fada847da')
+
+    # make a UUID using a SHA-1 hash of a namespace UUID and a name
+    >>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')
+    UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')
+
+    # make a UUID from a string of hex digits (braces and hyphens ignored)
+    >>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')
+
+    # convert a UUID to a string of hex digits in standard form
+    >>> str(x)
+    '00010203-0405-0607-0809-0a0b0c0d0e0f'
+
+    # get the raw 16 bytes of the UUID
+    >>> x.bytes
+    '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
+
+    # make a UUID from a 16-byte string
+    >>> uuid.UUID(bytes=x.bytes)
+    UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')
+"""
+
+__author__ = 'Ka-Ping Yee <ping@zesty.ca>'
+__date__ = '$Date: 2006/06/12 23:15:40 $'.split()[1].replace('/', '-')
+__version__ = '$Revision: 1.30 $'.split()[1]
+
+RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE = [
+    'reserved for NCS compatibility', 'specified in RFC 4122',
+    'reserved for Microsoft compatibility', 'reserved for future definition']
+
+class UUID(object):
+    """Instances of the UUID class represent UUIDs as specified in RFC 4122.
+    UUID objects are immutable, hashable, and usable as dictionary keys.
+    Converting a UUID to a string with str() yields something in the form
+    '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
+    four possible forms: a similar string of hexadecimal digits, or a
+    string of 16 raw bytes as an argument named 'bytes', or a tuple of
+    six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
+    48-bit values respectively) as an argument named 'fields', or a single
+    128-bit integer as an argument named 'int'.
+
+    UUIDs have these read-only attributes:
+
+        bytes       the UUID as a 16-byte string
+
+        fields      a tuple of the six integer fields of the UUID,
+                    which are also available as six individual attributes
+                    and two derived attributes:
+
+            time_low                the first 32 bits of the UUID
+            time_mid                the next 16 bits of the UUID
+            time_hi_version         the next 16 bits of the UUID
+            clock_seq_hi_variant    the next 8 bits of the UUID
+            clock_seq_low           the next 8 bits of the UUID
+            node                    the last 48 bits of the UUID
+
+            time                    the 60-bit timestamp
+            clock_seq               the 14-bit sequence number
+
+        hex         the UUID as a 32-character hexadecimal string
+
+        int         the UUID as a 128-bit integer
+
+        urn         the UUID as a URN as specified in RFC 4122
+
+        variant     the UUID variant (one of the constants RESERVED_NCS,
+                    RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
+
+        version     the UUID version number (1 through 5, meaningful only
+                    when the variant is RFC_4122)
+    """
+
+    def __init__(self, hex=None, bytes=None, fields=None, int=None,
+                       version=None):
+        r"""Create a UUID from either a string of 32 hexadecimal digits,
+        a string of 16 bytes as the 'bytes' argument, a tuple of six
+        integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
+        8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
+        the 'fields' argument, or a single 128-bit integer as the 'int'
+        argument.  When a string of hex digits is given, curly braces,
+        hyphens, and a URN prefix are all optional.  For example, these
+        expressions all yield the same UUID:
+
+        UUID('{12345678-1234-5678-1234-567812345678}')
+        UUID('12345678123456781234567812345678')
+        UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
+        UUID(bytes='\x12\x34\x56\x78'*4)
+        UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
+        UUID(int=0x12345678123456781234567812345678)
+
+        Exactly one of 'hex', 'bytes', 'fields', or 'int' must be given.
+        The 'version' argument is optional; if given, the resulting UUID
+        will have its variant and version number set according to RFC 4122,
+        overriding bits in the given 'hex', 'bytes', 'fields', or 'int'.
+        """
+
+        if [hex, bytes, fields, int].count(None) != 3:
+            raise TypeError('need just one of hex, bytes, fields, or int')
+        if hex is not None:
+            hex = hex.replace('urn:', '').replace('uuid:', '')
+            hex = hex.strip('{}').replace('-', '')
+            if len(hex) != 32:
+                raise ValueError('badly formed hexadecimal UUID string')
+            int = long(hex, 16)
+        if bytes is not None:
+            if len(bytes) != 16:
+                raise ValueError('bytes is not a 16-char string')
+            int = long(('%02x'*16) % tuple(map(ord, bytes)), 16)
+        if fields is not None:
+            if len(fields) != 6:
+                raise ValueError('fields is not a 6-tuple')
+            (time_low, time_mid, time_hi_version,
+             clock_seq_hi_variant, clock_seq_low, node) = fields
+            if not 0 <= time_low < 1<<32L:
+                raise ValueError('field 1 out of range (need a 32-bit value)')
+            if not 0 <= time_mid < 1<<16L:
+                raise ValueError('field 2 out of range (need a 16-bit value)')
+            if not 0 <= time_hi_version < 1<<16L:
+                raise ValueError('field 3 out of range (need a 16-bit value)')
+            if not 0 <= clock_seq_hi_variant < 1<<8L:
+                raise ValueError('field 4 out of range (need an 8-bit value)')
+            if not 0 <= clock_seq_low < 1<<8L:
+                raise ValueError('field 5 out of range (need an 8-bit value)')
+            if not 0 <= node < 1<<48L:
+                raise ValueError('field 6 out of range (need a 48-bit value)')
+            clock_seq = (clock_seq_hi_variant << 8L) | clock_seq_low
+            int = ((time_low << 96L) | (time_mid << 80L) |
+                   (time_hi_version << 64L) | (clock_seq << 48L) | node)
+        if int is not None:
+            if not 0 <= int < 1<<128L:
+                raise ValueError('int is out of range (need a 128-bit value)')
+        if version is not None:
+            if not 1 <= version <= 5:
+                raise ValueError('illegal version number')
+            # Set the variant to RFC 4122.
+            int &= ~(0xc000 << 48L)
+            int |= 0x8000 << 48L
+            # Set the version number.
+            int &= ~(0xf000 << 64L)
+            int |= version << 76L
+        self.__dict__['int'] = int
+
+    def __cmp__(self, other):
+        if isinstance(other, UUID):
+            return cmp(self.int, other.int)
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self.int)
+
+    def __int__(self):
+        return self.int
+
+    def __repr__(self):
+        return 'UUID(%r)' % str(self)
+
+    def __setattr__(self, name, value):
+        raise TypeError('UUID objects are immutable')
+
+    def __str__(self):
+        hex = '%032x' % self.int
+        return '%s-%s-%s-%s-%s' % (
+            hex[:8], hex[8:12], hex[12:16], hex[16:20], hex[20:])
+
+    def get_bytes(self):
+        bytes = ''
+        for shift in range(0, 128, 8):
+            bytes = chr((self.int >> shift) & 0xff) + bytes
+        return bytes
+
+    bytes = property(get_bytes)
+
+    def get_fields(self):
+        return (self.time_low, self.time_mid, self.time_hi_version,
+                self.clock_seq_hi_variant, self.clock_seq_low, self.node)
+
+    fields = property(get_fields)
+
+    def get_time_low(self):
+        return self.int >> 96L
+
+    time_low = property(get_time_low)
+
+    def get_time_mid(self):
+        return (self.int >> 80L) & 0xffff
+
+    time_mid = property(get_time_mid)
+
+    def get_time_hi_version(self):
+        return (self.int >> 64L) & 0xffff
+
+    time_hi_version = property(get_time_hi_version)
+
+    def get_clock_seq_hi_variant(self):
+        return (self.int >> 56L) & 0xff
+
+    clock_seq_hi_variant = property(get_clock_seq_hi_variant)
+
+    def get_clock_seq_low(self):
+        return (self.int >> 48L) & 0xff
+
+    clock_seq_low = property(get_clock_seq_low)
+
+    def get_time(self):
+        return (((self.time_hi_version & 0x0fffL) << 48L) |
+                (self.time_mid << 32L) | self.time_low)
+
+    time = property(get_time)
+
+    def get_clock_seq(self):
+        return (((self.clock_seq_hi_variant & 0x3fL) << 8L) |
+                self.clock_seq_low)
+
+    clock_seq = property(get_clock_seq)
+
+    def get_node(self):
+        return self.int & 0xffffffffffff
+
+    node = property(get_node)
+
+    def get_hex(self):
+        return '%032x' % self.int
+
+    hex = property(get_hex)
+
+    def get_urn(self):
+        return 'urn:uuid:' + str(self)
+
+    urn = property(get_urn)
+
+    def get_variant(self):
+        if not self.int & (0x8000 << 48L):
+            return RESERVED_NCS
+        elif not self.int & (0x4000 << 48L):
+            return RFC_4122
+        elif not self.int & (0x2000 << 48L):
+            return RESERVED_MICROSOFT
+        else:
+            return RESERVED_FUTURE
+
+    variant = property(get_variant)
+
+    def get_version(self):
+        # The version bits are only meaningful for RFC 4122 UUIDs.
+        if self.variant == RFC_4122:
+            return int((self.int >> 76L) & 0xf)
+
+    version = property(get_version)
+
+def _ifconfig_getnode():
+    """Get the hardware address on Unix by running ifconfig."""
+    import os
+    for dir in ['', '/sbin/', '/usr/sbin']:
+        try:
+            pipe = os.popen(os.path.join(dir, 'ifconfig'))
+        except IOError:
+            continue
+        for line in pipe:
+            words = line.lower().split()
+            for i in range(len(words)):
+                if words[i] in ['hwaddr', 'ether']:
+                    return int(words[i + 1].replace(':', ''), 16)
+
+def _ipconfig_getnode():
+    """Get the hardware address on Windows by running ipconfig.exe."""
+    import os, re
+    dirs = ['', r'c:\windows\system32', r'c:\winnt\system32']
+    try:
+        import ctypes
+        buffer = ctypes.create_string_buffer(300)
+        ctypes.windll.kernel32.GetSystemDirectoryA(buffer, 300)
+        dirs.insert(0, buffer.value.decode('mbcs'))
+    except:
+        pass
+    for dir in dirs:
+        try:
+            pipe = os.popen(os.path.join(dir, 'ipconfig') + ' /all')
+        except IOError:
+            continue
+        for line in pipe:
+            value = line.split(':')[-1].strip().lower()
+            if re.match('([0-9a-f][0-9a-f]-){5}[0-9a-f][0-9a-f]', value):
+                return int(value.replace('-', ''), 16)
+
+def _netbios_getnode():
+    """Get the hardware address on Windows using NetBIOS calls.
+    See http://support.microsoft.com/kb/118623 for details."""
+    import win32wnet, netbios
+    ncb = netbios.NCB()
+    ncb.Command = netbios.NCBENUM
+    ncb.Buffer = adapters = netbios.LANA_ENUM()
+    adapters._pack()
+    if win32wnet.Netbios(ncb) != 0:
+        return
+    adapters._unpack()
+    for i in range(adapters.length):
+        ncb.Reset()
+        ncb.Command = netbios.NCBRESET
+        ncb.Lana_num = ord(adapters.lana[i])
+        if win32wnet.Netbios(ncb) != 0:
+            continue
+        ncb.Reset()
+        ncb.Command = netbios.NCBASTAT
+        ncb.Lana_num = ord(adapters.lana[i])
+        ncb.Callname = '*'.ljust(16)
+        ncb.Buffer = status = netbios.ADAPTER_STATUS()
+        if win32wnet.Netbios(ncb) != 0:
+            continue
+        status._unpack()
+        bytes = map(ord, status.adapter_address)
+        return ((bytes[0]<<40L) + (bytes[1]<<32L) + (bytes[2]<<24L) +
+                (bytes[3]<<16L) + (bytes[4]<<8L) + bytes[5])
+
+# Thanks to Thomas Heller for ctypes and for his help with its use here.
+
+# If ctypes is available, use it to find system routines for UUID generation.
+_uuid_generate_random = _uuid_generate_time = _UuidCreate = None
+try:
+    import ctypes, ctypes.util
+    _buffer = ctypes.create_string_buffer(16)
+
+    # The uuid_generate_* routines are provided by libuuid on at least
+    # Linux and FreeBSD, and provided by libc on Mac OS X.
+    for libname in ['uuid', 'c']:
+        try:
+            lib = ctypes.CDLL(ctypes.util.find_library(libname))
+        except:
+            continue
+        if hasattr(lib, 'uuid_generate_random'):
+            _uuid_generate_random = lib.uuid_generate_random
+        if hasattr(lib, 'uuid_generate_time'):
+            _uuid_generate_time = lib.uuid_generate_time
+
+    # On Windows prior to 2000, UuidCreate gives a UUID containing the
+    # hardware address.  On Windows 2000 and later, UuidCreate makes a
+    # random UUID and UuidCreateSequential gives a UUID containing the
+    # hardware address.  These routines are provided by the RPC runtime.
+    try:
+        lib = ctypes.windll.rpcrt4
+    except:
+        lib = None
+    _UuidCreate = getattr(lib, 'UuidCreateSequential',
+                          getattr(lib, 'UuidCreate', None))
+except:
+    pass
+
+def _unixdll_getnode():
+    """Get the hardware address on Unix using ctypes."""
+    _uuid_generate_time(_buffer)
+    return UUID(bytes=_buffer.raw).node
+
+def _windll_getnode():
+    """Get the hardware address on Windows using ctypes."""
+    if _UuidCreate(_buffer) == 0:
+        return UUID(bytes=_buffer.raw).node
+
+def _random_getnode():
+    """Get a random node ID, with eighth bit set as suggested by RFC 4122."""
+    import random
+    return random.randrange(0, 1<<48L) | 0x010000000000L
+
+_node = None
+
+def getnode():
+    """Get the hardware address as a 48-bit integer.  The first time this
+    runs, it may launch a separate program, which could be quite slow.  If
+    all attempts to obtain the hardware address fail, we choose a random
+    48-bit number with its eighth bit set to 1 as recommended in RFC 4122."""
+
+    global _node
+    if _node is not None:
+        return _node
+
+    import sys
+    if sys.platform == 'win32':
+        getters = [_windll_getnode, _netbios_getnode, _ipconfig_getnode]
+    else:
+        getters = [_unixdll_getnode, _ifconfig_getnode]
+
+    for getter in getters + [_random_getnode]:
+        try:
+            _node = getter()
+        except:
+            continue
+        if _node is not None:
+            return _node
+
+def uuid1(node=None, clock_seq=None):
+    """Generate a UUID from a host ID, sequence number, and the current time.
+    If 'node' is not given, getnode() is used to obtain the hardware
+    address.  If 'clock_seq' is given, it is used as the sequence number;
+    otherwise a random 14-bit sequence number is chosen."""
+
+    # When the system provides a version-1 UUID generator, use it (but don't
+    # use UuidCreate here because its UUIDs don't conform to RFC 4122).
+    if _uuid_generate_time and node is clock_seq is None:
+        _uuid_generate_time(_buffer)
+        return UUID(bytes=_buffer.raw)
+
+    import time
+    nanoseconds = int(time.time() * 1e9)
+    # 0x01b21dd213814000 is the number of 100-ns intervals between the
+    # UUID epoch 1582-10-15 00:00:00 and the Unix epoch 1970-01-01 00:00:00.
+    timestamp = int(nanoseconds/100) + 0x01b21dd213814000L
+    if clock_seq is None:
+        import random
+        clock_seq = random.randrange(1<<14L) # instead of stable storage
+    time_low = timestamp & 0xffffffffL
+    time_mid = (timestamp >> 32L) & 0xffffL
+    time_hi_version = (timestamp >> 48L) & 0x0fffL
+    clock_seq_low = clock_seq & 0xffL
+    clock_seq_hi_variant = (clock_seq >> 8L) & 0x3fL
+    if node is None:
+        node = getnode()
+    return UUID(fields=(time_low, time_mid, time_hi_version,
+                        clock_seq_hi_variant, clock_seq_low, node), version=1)
+
+def uuid3(namespace, name):
+    """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
+    import md5
+    hash = md5.md5(namespace.bytes + name).digest()
+    return UUID(bytes=hash[:16], version=3)
+
+def uuid4():
+    """Generate a random UUID."""
+
+    # When the system provides a version-4 UUID generator, use it.
+    if _uuid_generate_random:
+        _uuid_generate_random(_buffer)
+        return UUID(bytes=_buffer.raw)
+
+    # Otherwise, get randomness from urandom or the 'random' module.
+    try:
+        import os
+        return UUID(bytes=os.urandom(16), version=4)
+    except:
+        import random
+        bytes = [chr(random.randrange(256)) for i in range(16)]
+        return UUID(bytes=bytes, version=4)
+
+def uuid5(namespace, name):
+    """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
+    import sha
+    hash = sha.sha(namespace.bytes + name).digest()
+    return UUID(bytes=hash[:16], version=5)
+
+# The following standard UUIDs are for use with uuid3() or uuid5().
+
+NAMESPACE_DNS = UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
+NAMESPACE_URL = UUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8')
+NAMESPACE_OID = UUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8')
+NAMESPACE_X500 = UUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8')
-- 
1.7.4.4