Source Code for Module caldavclientlibrary.protocol.webdav.ace

  1  ## 
  2  # Copyright (c) 2007-2016 Apple Inc. All rights reserved. 
  3  # 
  4  # Licensed under the Apache License, Version 2.0 (the "License"); 
  5  # you may not use this file except in compliance with the License. 
  6  # You may obtain a copy of the License at 
  7  # 
  8  # http://www.apache.org/licenses/LICENSE-2.0 
  9  # 
 10  # Unless required by applicable law or agreed to in writing, software 
 11  # distributed under the License is distributed on an "AS IS" BASIS, 
 12  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 13  # See the License for the specific language governing permissions and 
 14  # limitations under the License. 
 15  ## 
 16   
 17  from xml.etree.ElementTree import QName 
 18  from caldavclientlibrary.protocol.webdav.definitions import davxml 
 19  from xml.etree.ElementTree import SubElement 
 20   
 21 -class ACE(object): 
 22   
 23 -    def __init__(self): 
 24   
 25          self.principal = None 
 26          self.data = None 
 27          self.invert = False 
 28          self.grant = True 
 29          self.privs = () 
 30          self.protected = False 
 31          self.inherited = False 
 32   
 33 -    def getPrincipal(self): 
 34          return self.principal 
 35   
 36 -    def setPrincipal(self, principal, data=None): 
 37          self.principal = principal 
 38          self.data = data 
 39   
 40 -    def canChange(self): 
 41          return not self.protected and not self.inherited 
 42   
 43      @staticmethod 
 44 -    def parseFromACL(aclnode): 
 45   
 46          aces = [] 
 47          acenodes = aclnode.findall(str(davxml.ace)) 
 48          for node in acenodes: 
 49              newace = ACE() 
 50              newace.parseACE(node) 
 51              aces.append(newace) 
 52          return aces 
 53            
 54 -    def parseACE(self, acenode): 
 55           
 56          assert(acenode and acenode.tag == davxml.ace) 
 57   
 58          # Get invert 
 59          self.invert = False 
 60          principal_parent = acenode 
 61          invert = acenode.find(str(davxml.invert)) 
 62          if invert: 
 63              self.invert = True 
 64              principal_parent = invert 
 65   
 66          # Get the principal 
 67          principal = principal_parent.find(str(davxml.principal)) 
 68          if not principal or len(principal.getchildren()) != 1: 
 69              return False 
 70           
 71          # Determine principal info 
 72          child = principal.getchildren()[0] 
 73          if child.tag == davxml.href: 
 74              self.setPrincipal(child.tag, child.text) 
 75   
 76          elif child.tag in (davxml.all, davxml.authenticated, davxml.unauthenticated, davxml.self,): 
 77              self.setPrincipal(child.tag) 
 78   
 79          elif child.tag == davxml.property: 
 80              if len(child.getchildren()) == 1: 
 81                  self.setPrincipal(child.tag, QName(child.getchildren()[0].tag)) 
 82              else: 
 83                  self.setPrincipal(child.tag) 
 84           
 85          # Determine rights 
 86          self.grant = True 
 87          child = acenode.find(str(davxml.grant)) 
 88          if not child: 
 89              child = acenode.find(str(davxml.deny)) 
 90              if child: 
 91                  self.grant = False 
 92          if child: 
 93              self.parsePrivileges(child) 
 94       
 95          # Determine protected/inherited state 
 96          self.protected = acenode.find(str(davxml.protected)) is not None 
 97          self.inherited = acenode.find(str(davxml.inherited)) is not None 
 98           
 99          return True 
100   
101 -    def parsePrivileges(self, parent): 
102           
103          assert(parent.tag in (davxml.grant, davxml.deny,)) 
104           
105          # Parent node contains one of more privilege nodes which we parse 
106          self.privs = () 
107          for privilege in parent.getchildren(): 
108              # Look for privilege 
109              if privilege.tag != davxml.privilege or len(privilege.getchildren()) != 1: 
110                  continue 
111   
112              # Now get rights within the privilege 
113              self.privs += (privilege.getchildren()[0].tag,) 
114   
115 -    def generateACE(self, aclnode): 
116          # Structure of ace is: 
117          # 
118          #   <DAV:ace> 
119          #     <DAV:principal>...</DAV:principal> 
120          #       <DAV:grant>...</DAV:grant> 
121          #   </DAV:ace> 
122       
123          # <DAV:ace> element 
124          ace = SubElement(aclnode, davxml.ace) 
125           
126          if self.invert: 
127              invert = SubElement(ace, davxml.invert) 
128   
129          # <DAV:principal> element 
130          principal = SubElement(invert if self.invert else ace, davxml.principal) 
131           
132          # Principal type 
133          if self.principal == davxml.href: 
134   
135              # <DAV:href> element 
136              href = SubElement(principal, davxml.href) 
137              href.text = self.data 
138   
139          elif self.principal in (davxml.all, davxml.authenticated, davxml.unauthenticated, davxml.self,): 
140   
141              # <DAV:all>/<DAV:authenticated>/<DAV:unauthenticated>/<DAV:self> elements 
142              SubElement(principal, self.principal) 
143   
144          elif self.principal == davxml.property: 
145   
146              # <DAV:property> element - the UID is the property element name 
147              property = SubElement(principal, davxml.property) 
148              SubElement(property, self.data) 
149           
150          # Do grant rights for each one set 
151          if self.grant: 
152              # <DAV:grant> element 
153              privs = SubElement(ace, davxml.grant) 
154           
155          # Do deny rights for each one set 
156          else: 
157              # <DAV:deny> element 
158              privs = SubElement(ace, davxml.deny) 
159           
160          for item in self.privs: 
161              priv = SubElement(privs, davxml.privilege) 
162              SubElement(priv, item) 
163   
164          # <DAV:protected> and <DAV:inherited> 
165          if self.protected: 
166              SubElement(ace, davxml.protected) 
167          if self.inherited: 
168              SubElement(ace, davxml.inherited) 
169