# -*- test-case-name: twistedcaldav.test.test_sharing -*- # # # Copyright (c) 2010-2017 Apple Inc. All rights reserved. # # 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. # # """ Sharing behavior """ __all__ = [ "SharedResourceMixin", "SharedHomeMixin", ] from twext.who.idirectory import RecordType from twisted.internet.defer import succeed, inlineCallbacks, DeferredList, \ returnValue from twistedcaldav import customxml, caldavxml from twistedcaldav.config import config from twistedcaldav.customxml import calendarserver_namespace from twistedcaldav.linkresource import LinkFollowerMixIn from txdav.common.datastore.sql_tables import _ABO_KIND_GROUP, \ _BIND_MODE_DIRECT, _BIND_MODE_INDIRECT, _BIND_MODE_OWN, _BIND_MODE_READ, \ _BIND_MODE_WRITE, _BIND_STATUS_ACCEPTED, _BIND_STATUS_DECLINED, \ _BIND_STATUS_DELETED, _BIND_STATUS_INVALID, _BIND_STATUS_INVITED from txdav.common.idirectoryservice import DirectoryRecordNotFoundError from txdav.xml import element from txdav.who.wiki import RecordType as WikiRecordType, WikiAccessLevel from txweb2 import responsecode from txweb2.dav.http import ErrorResponse, MultiStatusResponse from txweb2.dav.resource import TwistedACLInheritable from txweb2.dav.util import allDataFromStream, joinURL from txweb2.http import HTTPError, Response, XMLResponse class SharedResourceMixin(object): """ A mix-in for calendar/addressbook resources that implements sharing-related functionality. """ @inlineCallbacks def inviteProperty(self, request): """ Calculate the customxml.Invite property (for readProperty) from the invites database. """ if config.Sharing.Enabled: @inlineCallbacks def invitePropertyElement(invitation, includeUID=True): userid = "urn:x-uid:" + invitation.shareeUID principal = yield self.principalForUID(invitation.shareeUID) cn = principal.displayName() if principal else invitation.shareeUID returnValue(customxml.InviteUser( customxml.UID.fromString(invitation.uid) if includeUID else None, element.HRef.fromString(userid), customxml.CommonName.fromString(cn), customxml.InviteAccess(invitationBindModeToXMLMap[invitation.mode]()), invitationBindStatusToXMLMap[invitation.status](), )) # See if this property is on the shared calendar if self.isSharedByOwner(): invitations = yield self.validateInvites(request) returnValue(customxml.Invite( *[(yield invitePropertyElement(invitation)) for invitation in invitations] )) # See if it is on the sharee calendar if self.isShareeResource(): original = yield self._newStoreObject.ownerView() if original is not None: invitations = yield original.allInvitations() invitations = yield self.validateInvites(request, invitations) ownerPrincipal = yield self.principalForUID(self._newStoreObject.ownerHome().uid()) if ownerPrincipal is None: owner = "invalid" ownerCN = "Invalid" else: # FIXME: use urn:x-uid in all cases if self.isCalendarCollection(): owner = ownerPrincipal.principalURL() else: owner = "urn:x-uid:" + ownerPrincipal.principalUID() ownerCN = ownerPrincipal.displayName() returnValue(customxml.Invite( customxml.Organizer( element.HRef.fromString(owner), customxml.CommonName.fromString(ownerCN), ), *[(yield invitePropertyElement(invitation, includeUID=False)) for invitation in invitations] )) returnValue(None) @inlineCallbacks def upgradeToShare(self): """ Set the resource-type property on this resource to indicate that this is the owner's version of a resource which has been shared. """ # Change status on store object yield self._newStoreObject.setShared(True) @inlineCallbacks def downgradeFromShare(self, request): # Change status on store object yield self._newStoreObject.setShared(False) # Remove all invitees for invitation in (yield self._newStoreObject.allInvitations()): yield self._newStoreObject.uninviteUIDFromShare(invitation.shareeUID) returnValue(True) @inlineCallbacks def directShare(self, request): """ Directly bind an accessible calendar/address book collection into the current principal's calendar/addressbook home. @param request: the request triggering this action @type request: L{IRequest} @return: the (asynchronous) HTTP result to respond to the direct-share request. @rtype: L{Deferred} firing L{txweb2.http.Response}, failing with L{HTTPError} """ # Need to have at least DAV:read to do this yield self.authorize(request, (element.Read(),)) # Find current principal authz_principal = self.currentPrincipal(request).children[0] if not isinstance(authz_principal, element.HRef): raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "valid-principal"), "Current user principal not a DAV:href", )) principalURL = str(authz_principal) if not principalURL: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "valid-principal"), "Current user principal not specified", )) sharee = (yield request.locateResource(principalURL)) # Check enabled for service from twistedcaldav.directory.principal import DirectoryCalendarPrincipalResource if not isinstance(sharee, DirectoryCalendarPrincipalResource): raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "invalid-principal"), "Current user principal is not a calendar/addressbook enabled principal", )) # Get the home collection if self.isCalendarCollection(): shareeHomeResource = yield sharee.calendarHome(request) elif self.isAddressBookCollection() or self.isGroup(): shareeHomeResource = yield sharee.addressBookHome(request) else: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "invalid-principal"), "No calendar/addressbook home for principal", )) # TODO: Make sure principal is not sharing back to themselves hostURL = (yield self.canonicalURL(request)) shareeHomeURL = shareeHomeResource.url() if hostURL.startswith(shareeHomeURL): raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "invalid-share"), "Can't share your own calendar or addressbook", )) # Accept it shareeView = yield self._newStoreObject.directShareWithUser( sharee.principalUID(), displayName=self.displayName() ) # Return the URL of the shared calendar sharedAsURL = joinURL(shareeHomeResource.url(), shareeView.name()) returnValue(XMLResponse( code=responsecode.OK, element=customxml.SharedAs( element.HRef.fromString(sharedAsURL) ) )) def isSharedByOwner(self): """ Return True if this is an owner shared calendar collection. """ try: return self._newStoreObject.isSharedByOwner() if self._newStoreObject else False except AttributeError: return False def setShare(self, share_url): """ Set the URL associated with this L{SharedResourceMixin}. (This is only invoked on the sharee's resource, not the owner's.) """ self._isShareeResource = True self._share_url = share_url def isShareeResource(self): """ Return True if this is a sharee view of a shared collection. """ return ( hasattr(self, "_newStoreObject") and hasattr(self._newStoreObject, "owned") and not self._newStoreObject.owned() and getattr(self._newStoreObject, "_bindMode", None) is not None ) def removeShareeResource(self, request): """ Called when the sharee DELETEs a shared collection. """ return self._newStoreObject.deleteShare() @inlineCallbacks def _checkAccessControl(self): """ Check the shared access mode of this resource, potentially consulting an external access method if necessary. @return: a L{Deferred} firing a L{bytes} or L{None}, with one of the potential values: C{"own"}, which means that the home is the owner of the collection and it is not shared; C{"read-only"}, meaning that the home that this collection is bound into has only read access to this collection; C{"read-write"}, which means that the home has both read and write access; C{"original"}, which means that it should inherit the ACLs of the owner's collection, whatever those happen to be, or C{None}, which means that the external access control mechanism has dictate the home should no longer have any access at all. """ if self._newStoreObject.direct(): owner = yield self.principalForUID(self._newStoreObject.ownerHome().uid()) sharee = yield self.principalForUID(self._newStoreObject.viewerHome().uid()) if owner.record.recordType == WikiRecordType.macOSXServerWiki: # Access level comes from what the wiki has granted to the # sharee access = (yield owner.record.accessForRecord(sharee.record)) if access == WikiAccessLevel.read: returnValue("read-only") elif access == WikiAccessLevel.write: returnValue("read-write") else: returnValue(None) else: # Check proxy access proxy_mode = yield sharee.proxyMode(owner) if proxy_mode == "none": returnValue("original") else: returnValue("read-write" if proxy_mode == "write" else "read-only") else: # Invited shares use access mode from the invite # Get the access for self bindMode = yield self._newStoreObject.effectiveShareMode() returnValue(invitationAccessFromBindModeMap.get(bindMode)) @inlineCallbacks def shareeAccessControlList(self, request, *args, **kwargs): """ Return WebDAV ACLs appropriate for the current user accessing the shared collection. For an "invite" share we take the privilege granted to the sharee in the invite and map that to WebDAV ACLs. For a "direct" share, if it is a wiki collection we map the wiki privileges into WebDAV ACLs, otherwise we use whatever privileges exist on the underlying shared collection. @param request: the request used to locate the owner resource. @type request: L{txweb2.iweb.IRequest} @param args: The arguments for L{txweb2.dav.idav.IDAVResource.accessControlList} @param kwargs: The keyword arguments for L{txweb2.dav.idav.IDAVResource.accessControlList}, plus keyword-only arguments. @return: the appropriate WebDAV ACL for the sharee @rtype: L{davxml.ACL} """ assert self._isShareeResource, "Only call this for a sharee resource" assert self.isCalendarCollection() or self.isAddressBookCollection(), "Only call this for a address book or calendar resource" sharee = yield self.principalForUID(self._newStoreObject.viewerHome().uid()) access = yield self._checkAccessControl() if access == "original" and not self._newStoreObject.ownerHome().external(): original = (yield request.locateResource(self._share_url)) result = (yield original.accessControlList(request, *args, **kwargs)) returnValue(result) # Direct shares use underlying privileges of shared collection userprivs = [ ] if access in ("read-only", "read-write",): userprivs.append(element.Privilege(element.Read())) userprivs.append(element.Privilege(element.ReadACL())) userprivs.append(element.Privilege(element.ReadCurrentUserPrivilegeSet())) if access in ("read-only",): userprivs.append(element.Privilege(element.WriteProperties())) if access in ("read-write",): userprivs.append(element.Privilege(element.Write())) proxyprivs = list(userprivs) try: proxyprivs.remove(element.Privilege(element.ReadACL())) except ValueError: # If wiki says no-access then ReadACL won't be in the list pass aces = ( # Inheritable specific access for the resource's associated principal. element.ACE( element.Principal(element.HRef(sharee.principalURL())), element.Grant(*userprivs), element.Protected(), TwistedACLInheritable(), ), ) if self.isCalendarCollection(): aces += ( # Inheritable CALDAV:read-free-busy access for authenticated users. element.ACE( element.Principal(element.Authenticated()), element.Grant(element.Privilege(caldavxml.ReadFreeBusy())), TwistedACLInheritable(), ), ) # Give read access to config.ReadPrincipals aces += config.ReadACEs # Give all access to config.AdminPrincipals aces += config.AdminACEs if self.isCalendarCollection() and config.EnableProxyPrincipals: aces += ( # DAV:read/DAV:read-current-user-privilege-set access for this principal's calendar-proxy-read users. element.ACE( element.Principal(element.HRef(joinURL(sharee.principalURL(), "calendar-proxy-read/"))), element.Grant( element.Privilege(element.Read()), element.Privilege(element.ReadCurrentUserPrivilegeSet()), element.Privilege(element.WriteProperties()), ), element.Protected(), TwistedACLInheritable(), ), # DAV:read/DAV:read-current-user-privilege-set/DAV:write access for this principal's calendar-proxy-write users. element.ACE( element.Principal(element.HRef(joinURL(sharee.principalURL(), "calendar-proxy-write/"))), element.Grant(*proxyprivs), element.Protected(), TwistedACLInheritable(), ), ) returnValue(element.ACL(*aces)) @inlineCallbacks def validUserIDForShare(self, userid, request=None): """ Test the user id to see if it is a valid identifier for sharing and return a "normalized" form for our own use (e.g. convert mailto: to urn:uuid). @param userid: the userid to test @type userid: C{str} @return: C{str} of normalized userid or C{None} if userid is not allowed. """ # First try to resolve as a calendar principal principal = yield self.principalForCalendarUserAddress(userid) if principal is None: principal = yield self.principalForCalendarGroupAddress(userid) if principal: if request: ownerPrincipal = (yield self.ownerPrincipal(request)) if ownerPrincipal is None or ownerPrincipal.principalURL() == principal.principalURL(): returnValue(None) returnValue(principal.principalURL()) # TODO: we do not support external users right now so this is being hard-coded # off in spite of the config option. # elif config.Sharing.AllowExternalUsers: # return userid else: returnValue(None) @inlineCallbacks def principalForCalendarGroupAddress(self, groupid): """ Get principal for group address if extant """ if ( config.Sharing.Enabled and config.Sharing.Calendars.Enabled and config.Sharing.Calendars.Groups.Enabled ): # see if group for principalCollection in self.principalCollections(): record = yield principalCollection.directory.recordWithCalendarUserAddress(groupid) if record is not None and record.recordType == RecordType.group: groupPrincipal = yield principalCollection.principalForRecord(record) if groupPrincipal is not None: returnValue(groupPrincipal) returnValue(None) @inlineCallbacks def validateInvites(self, request, invitations=None): """ Make sure each userid in an invite is valid - if not re-write status. """ # assert request if invitations is None: invitations = yield self._newStoreObject.allInvitations() adjusted_invitations = [] for invitation in invitations: if invitation.status != _BIND_STATUS_INVALID: if not (yield self.validUserIDForShare("urn:x-uid:" + invitation.shareeUID, request)): self.log.error("Invalid sharee detected: {uid}", uid=invitation.shareeUID) invitation = invitation._replace(status=_BIND_STATUS_INVALID) invitation = invitation._replace( mode=( yield self._newStoreObject._effectiveShareMode( invitation.mode, invitation.shareeUID, self._newStoreObject._txn ) ) ) adjusted_invitations.append(invitation) returnValue(adjusted_invitations) def inviteUIDToShare(self, userid, cn, ace, summary, request): """ Send out in invite first, and then add this user to the share list @param userid: @param ace: Must be one of customxml.ReadWriteAccess or customxml.ReadAccess """ # TODO: Check if this collection is shared, and error out if it isn't resultIsList = True if type(userid) is not list: userid = [userid] resultIsList = False if type(cn) is not list: cn = [cn] dl = [self.inviteSingleUserToShare(_user, _cn, ace, summary, request) for _user, _cn in zip(userid, cn)] return self._processShareActionList(dl, resultIsList) def uninviteUIDFromShare(self, userid, ace, request): """ Send out in uninvite first, and then remove this user from the share list. """ # Do not validate the userid - we want to allow invalid users to be removed because they # may have been valid when added, but no longer valid now. Clients should be able to clear out # anything known to be invalid. # TODO: Check if this collection is shared, and error out if it isn't resultIsList = True if type(userid) is not list: userid = [userid] resultIsList = False dl = [self.uninviteSingleUserFromShare(user, ace, request) for user in userid] return self._processShareActionList(dl, resultIsList) def inviteUserUpdateToShare(self, userid, cn, aceOLD, aceNEW, summary, request): resultIsList = True if type(userid) is not list: userid = [userid] resultIsList = False if type(cn) is not list: cn = [cn] dl = [self.inviteSingleUserUpdateToShare(_user, _cn, aceOLD, aceNEW, summary, request) for _user, _cn in zip(userid, cn)] return self._processShareActionList(dl, resultIsList) def _processShareActionList(self, dl, resultIsList): def _defer(resultset): results = [result if success else False for success, result in resultset] return results if resultIsList else results[0] return DeferredList(dl).addCallback(_defer) @inlineCallbacks def inviteSingleUserToShare(self, userid, cn, ace, summary, request): # @UnusedVariable # We currently only handle local users sharee = yield self.principalForCalendarUserAddress(userid) if sharee is None: sharee = yield self.principalForCalendarGroupAddress(userid) if sharee is None: returnValue(False) try: result = (yield self._newStoreObject.inviteUIDToShare( sharee.principalUID(), invitationBindModeFromXMLMap[type(ace)], summary, )) except Exception as e: self.log.error("Could not send sharing invite '{userid}': {ex}", userid=userid, ex=e) result = None returnValue(result) @inlineCallbacks def uninviteSingleUserFromShare(self, userid, aces, request): # @UnusedVariable # Cancel invites - we'll just use whatever userid we are given. However, if we # cannot find a matching principal, try to extract the uid from the userid # and use that (to allow invalid principals to be removed). sharee = yield self.principalForCalendarUserAddress(userid) if sharee is not None: uid = sharee.principalUID() elif userid.startswith("urn:x-uid:"): uid = userid[10:] else: returnValue(False) try: result = (yield self._newStoreObject.uninviteUIDFromShare(uid)) except Exception as e: self.log.error("Could not send sharing uninvite '{userid}': {ex}", userid=userid, ex=e) result = None returnValue(result) @inlineCallbacks def uninviteFromShare(self, invitation, request): yield self._newStoreObject.uninviteFromShare(invitation) returnValue(True) def inviteSingleUserUpdateToShare(self, userid, commonName, acesOLD, aceNEW, summary, request): # @UnusedVariable # Just update existing return self.inviteSingleUserToShare(userid, commonName, aceNEW, summary, request) @inlineCallbacks def _xmlHandleInvite(self, request, docroot): # Sharing must be enabled for this collection if not self.canBeShared(): raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (customxml.calendarserver_namespace, "valid-request"), "Sharing not supported on this resource", )) yield self.authorize(request, (element.Read(), element.Write())) result = (yield self._handleInvite(request, docroot)) returnValue(result) @inlineCallbacks def _handleInvite(self, request, invitedoc): def _handleInviteSet(inviteset): userid = None cn = None access = None summary = None for item in inviteset.children: if isinstance(item, element.HRef): userid = str(item) continue if isinstance(item, customxml.CommonName): cn = str(item) continue if isinstance(item, customxml.InviteSummary): summary = str(item) continue if isinstance(item, customxml.ReadAccess) or isinstance(item, customxml.ReadWriteAccess): access = item continue if userid and access and summary: return (userid, cn, access, summary) else: error_text = [] if userid is None: error_text.append("missing href") if access is None: error_text.append("missing access") if summary is None: error_text.append("missing summary") raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (customxml.calendarserver_namespace, "valid-request"), "%s: %s" % (", ".join(error_text), inviteset,), )) def _handleInviteRemove(inviteremove): userid = None access = [] for item in inviteremove.children: if isinstance(item, element.HRef): userid = str(item) continue if isinstance(item, customxml.ReadAccess) or isinstance(item, customxml.ReadWriteAccess): access.append(item) continue if userid is None: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (customxml.calendarserver_namespace, "valid-request"), "Missing href: %s" % (inviteremove,), )) if len(access) == 0: access = None else: access = set(access) return (userid, access) setDict, removeDict, updateinviteDict = {}, {}, {} okusers = set() badusers = set() for item in invitedoc.children: if isinstance(item, customxml.InviteSet): userid, cn, access, summary = _handleInviteSet(item) setDict[userid] = (cn, access, summary) # Validate each userid on add only uid = (yield self.validUserIDForShare(userid, request)) if uid is None: uid = yield self.principalForCalendarGroupAddress(userid) (badusers if uid is None else okusers).add(userid) elif isinstance(item, customxml.InviteRemove): userid, access = _handleInviteRemove(item) removeDict[userid] = access # Treat removed userids as valid as we will fail invalid ones silently okusers.add(userid) # Only make changes if all OK if len(badusers) == 0: okusers = set() badusers = set() # Special case removing and adding the same user and treat that as an add sameUseridInRemoveAndSet = [u for u in removeDict.keys() if u in setDict] for u in sameUseridInRemoveAndSet: removeACL = removeDict[u] cn, newACL, summary = setDict[u] updateinviteDict[u] = (cn, removeACL, newACL, summary) del removeDict[u] del setDict[u] for userid, access in removeDict.iteritems(): result = (yield self.uninviteUIDFromShare(userid, access, request)) # If result is False that means the user being removed was not # actually invited, but let's not return an error in this case. okusers.add(userid) for userid, (cn, access, summary) in setDict.iteritems(): result = (yield self.inviteUIDToShare(userid, cn, access, summary, request)) (okusers if result else badusers).add(userid) for userid, (cn, removeACL, newACL, summary) in updateinviteDict.iteritems(): result = (yield self.inviteUserUpdateToShare(userid, cn, removeACL, newACL, summary, request)) (okusers if result else badusers).add(userid) # In this case bad items do not prevent ok items from being processed ok_code = responsecode.OK else: # In this case a bad item causes all ok items not to be processed so failed dependency is returned ok_code = responsecode.FAILED_DEPENDENCY # Do a final validation of the entire set of invites invites = (yield self.validateInvites(request)) numRecords = len(invites) # Set the sharing state on the collection shared = self.isSharedByOwner() if shared and numRecords == 0: yield self.downgradeFromShare(request) elif not shared and numRecords != 0: yield self.upgradeToShare() # Create the multistatus response - only needed if some are bad if badusers: xml_responses = [] xml_responses.extend([ element.StatusResponse(element.HRef(userid), element.Status.fromResponseCode(ok_code)) for userid in sorted(okusers) ]) xml_responses.extend([ element.StatusResponse(element.HRef(userid), element.Status.fromResponseCode(responsecode.FORBIDDEN)) for userid in sorted(badusers) ]) # # Return response # returnValue(MultiStatusResponse(xml_responses)) else: returnValue(responsecode.OK) @inlineCallbacks def _xmlHandleInviteReply(self, request, docroot): # Sharing must be enabled for this collection if not self.canShare(): raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (customxml.calendarserver_namespace, "valid-request"), "Sharing not supported on this resource", )) yield self.authorize(request, (element.Read(), element.Write())) result = (yield self._handleInviteReply(request, docroot)) returnValue(result) def _handleInviteReply(self, request, docroot): raise NotImplementedError @inlineCallbacks def xmlRequestHandler(self, request): # Need to read the data and get the root element first xmldata = (yield allDataFromStream(request.stream)) try: doc = element.WebDAVDocument.fromString(xmldata) except ValueError, e: self.log.error("Error parsing doc ({ex}) Doc:\n {x}", ex=str(e), x=xmldata) raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (customxml.calendarserver_namespace, "valid-request"), "Invalid XML", )) root = doc.root_element if type(root) in self.xmlDocHandlers: result = (yield self.xmlDocHandlers[type(root)](self, request, root)) returnValue(result) else: self.log.error("Unsupported XML ({r})", r=root) raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (customxml.calendarserver_namespace, "valid-request"), "Unsupported XML", )) xmlDocHandlers = { customxml.InviteShare: _xmlHandleInvite, customxml.InviteReply: _xmlHandleInviteReply, } def isGroup(self): try: return self._newStoreObject._kind == _ABO_KIND_GROUP except AttributeError: return False def POST_handler_content_type(self, request, contentType): if self.isCollection() or self.isGroup(): if contentType: if contentType in self._postHandlers: return self._postHandlers[contentType](self, request) else: self.log.info("Got a POST on collection or group with an unsupported content type: {t}", t=contentType) else: self.log.info("Got a POST on collection or group with no content type") return succeed(responsecode.FORBIDDEN) _postHandlers = { ("application", "xml"): xmlRequestHandler, ("text", "xml"): xmlRequestHandler, } invitationBindStatusToXMLMap = { _BIND_STATUS_INVITED: customxml.InviteStatusNoResponse, _BIND_STATUS_ACCEPTED: customxml.InviteStatusAccepted, _BIND_STATUS_DECLINED: customxml.InviteStatusDeclined, _BIND_STATUS_INVALID: customxml.InviteStatusInvalid, _BIND_STATUS_DELETED: customxml.InviteStatusDeleted, } invitationBindStatusFromXMLMap = dict((v, k) for k, v in invitationBindStatusToXMLMap.iteritems()) invitationBindModeToXMLMap = { _BIND_MODE_READ: customxml.ReadAccess, _BIND_MODE_WRITE: customxml.ReadWriteAccess, } invitationBindModeFromXMLMap = dict((v, k) for k, v in invitationBindModeToXMLMap.iteritems()) invitationAccessFromBindModeMap = { _BIND_MODE_OWN: "own", _BIND_MODE_READ: "read-only", _BIND_MODE_WRITE: "read-write", _BIND_MODE_DIRECT: "read-write", _BIND_MODE_INDIRECT: "read-write", } class SharedHomeMixin(LinkFollowerMixIn): """ A mix-in for calendar/addressbook homes that defines the operations for manipulating a sharee's set of shared calendars. """ @inlineCallbacks def provisionShare(self, child, request=None): """ Set shared state and check access control. """ if child._newStoreObject is not None and not child._newStoreObject.owned(): ownerHomeURL = (yield self._otherPrincipalHomeURL(child._newStoreObject.ownerHome().uid())) ownerView = yield child._newStoreObject.ownerView() child.setShare(joinURL(ownerHomeURL, ownerView.name()) if ownerHomeURL else None) access = yield child._checkAccessControl() if access is None: returnValue(None) returnValue(child) def _otherPrincipalHomeURL(self, otherUID): # Is this only meant to be overridden? pass @inlineCallbacks def acceptShare(self, request, inviteUID, summary): # Accept the share try: shareeView = yield self._newStoreHome.acceptShare(inviteUID, summary) except DirectoryRecordNotFoundError: # Missing sharer record => fail request raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "invalid-share"), "Invite UID not valid", )) if shareeView is None: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "invalid-share"), "Invite UID not valid", )) # Return the URL of the shared collection sharedAsURL = joinURL(self.url(), shareeView.shareName()) returnValue(XMLResponse( code=responsecode.OK, element=customxml.SharedAs( element.HRef.fromString(sharedAsURL) ) )) @inlineCallbacks def declineShare(self, request, inviteUID): # Remove it if it is in the DB try: result = yield self._newStoreHome.declineShare(inviteUID) except DirectoryRecordNotFoundError: # Missing sharer record => just treat decline as success result = True if not result: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (calendarserver_namespace, "invalid-share"), "Invite UID not valid", )) returnValue(Response(code=responsecode.NO_CONTENT)) def _handleInviteReply(self, request, invitereplydoc): """ Handle a user accepting or declining a sharing invite """ hostUrl = None accepted = None summary = None replytoUID = None for item in invitereplydoc.children: if isinstance(item, customxml.InviteStatusAccepted): accepted = True elif isinstance(item, customxml.InviteStatusDeclined): accepted = False elif isinstance(item, customxml.InviteSummary): summary = str(item) elif isinstance(item, customxml.HostURL): for hosturlItem in item.children: if isinstance(hosturlItem, element.HRef): hostUrl = str(hosturlItem) elif isinstance(item, customxml.InReplyTo): replytoUID = str(item) if accepted is None or hostUrl is None or replytoUID is None: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, (customxml.calendarserver_namespace, "valid-request"), "Missing required XML elements", )) if accepted: return self.acceptShare(request, replytoUID, summary=summary) else: return self.declineShare(request, replytoUID)