|
35 |
import univention.debug2 as ud |
35 |
import univention.debug2 as ud |
36 |
import univention.s4connector.s4 |
36 |
import univention.s4connector.s4 |
37 |
import univention.admin.uldap |
37 |
import univention.admin.uldap |
38 |
|
|
|
39 |
from samba.dcerpc import dnsp |
40 |
from samba.ndr import ndr_print |
41 |
from samba.ndr import ndr_pack |
42 |
from samba.ndr import ndr_unpack |
43 |
import binascii |
44 |
|
38 |
|
|
|
39 |
from samba.dcerpc import dnsp |
40 |
from samba.ndr import ndr_print, ndr_pack, ndr_unpack |
41 |
import binascii |
42 |
import copy |
43 |
import time |
44 |
|
45 |
from samba.provision.sambadns import ARecord |
45 |
from samba.provision.sambadns import ARecord |
46 |
# def __init__(self, ip_addr, serial=1, ttl=3600): |
46 |
# def __init__(self, ip_addr, serial=1, ttl=3600): |
47 |
|
47 |
|
|
90 |
import univention.admin.handlers.dns.reverse_zone |
90 |
import univention.admin.handlers.dns.reverse_zone |
91 |
import univention.admin.handlers.dns.ptr_record |
91 |
import univention.admin.handlers.dns.ptr_record |
92 |
|
92 |
|
|
|
93 |
# mapping funtions |
94 |
def dns_dn_mapping(s4connector, given_object, dn_mapping_stored, isUCSobject): |
95 |
''' |
96 |
map dn of given object (which must have an s4_RR_attr in S4) |
97 |
ol_oc_filter and s4_RR_filter are objectclass filters in UCS and S4 |
98 |
''' |
99 |
obj = copy.deepcopy(given_object) |
100 |
|
101 |
propertyname = 'dns' |
102 |
propertyattrib = u'relativeDomainName' ## using LDAP name here, for simplicity |
103 |
ol_oc_filter = '(objectClass=dNSZone)' ## all OpenLDAP DNS records match |
104 |
ol_RR_attr = 'relativeDomainName' |
105 |
s4_RR_filter = u'(objectClass=dnsNode)' ## This also matches the DC=@ SOA object |
106 |
s4_RR_attr = 'dc' ## Note: the S4 attribute itself is lowercase |
107 |
|
108 |
if obj['dn'] != None: |
109 |
try: |
110 |
s4_RR_val = obj['attributes'][s4_RR_attr][0] |
111 |
except (KeyError, IndexError): |
112 |
s4_RR_val = '' |
113 |
|
114 |
def dn_premapped(given_object, dn_key, dn_mapping_stored): |
115 |
if (not dn_key in dn_mapping_stored) or (not given_object[dn_key]): |
116 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: not premapped (in first instance)") |
117 |
return False |
118 |
else: # check if DN exists |
119 |
if isUCSobject: |
120 |
premapped_dn = s4connector.get_object_dn(given_object[dn_key]) |
121 |
if premapped_dn != None: |
122 |
# ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: premapped S4 object found") |
123 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: premapped S4 object: %s" % premapped_dn) |
124 |
return True |
125 |
else: |
126 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: premapped S4 object not found") |
127 |
return False |
128 |
else: |
129 |
premapped_dn = s4connector.get_ucs_ldap_object_dn(given_object[dn_key]) |
130 |
if premapped_dn != None: |
131 |
# ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: premapped UCS object found") |
132 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: premapped UCS object: %s" % premapped_dn) |
133 |
return True |
134 |
else: |
135 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: premapped UCS object not found") |
136 |
return False |
137 |
|
138 |
for dn_key in ['dn', 'olddn']: |
139 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: check newdn for key '%s'" % dn_key) |
140 |
if dn_key in obj and not dn_premapped(obj, dn_key, dn_mapping_stored): |
141 |
|
142 |
dn = obj[dn_key] |
143 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: dn: %s" % dn) |
144 |
|
145 |
# Skip Configuration objects with empty DNs |
146 |
if dn == None: |
147 |
break |
148 |
|
149 |
pos = string.find(dn,'=') |
150 |
rdn = univention.s4connector.s4.explode_unicode_dn(dn) |
151 |
pos2 = len(rdn[0]) |
152 |
|
153 |
if isUCSobject: |
154 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: got an UCS-Object") |
155 |
# lookup the relativeDomainName as DC/dnsNode in S4 to get corresponding DN, if not found create new |
156 |
|
157 |
try: |
158 |
relativeDomainName = obj['attributes'][ol_RR_attr][0] |
159 |
except (KeyError, IndexError): |
160 |
### Safety fallback for the unexpected case, where relativeDomainName would not be set |
161 |
rdn0_attrib = dn[:pos] |
162 |
if 'zoneName' == rdn0_attrib: |
163 |
relativeDomainName = '@' |
164 |
else: |
165 |
raise ## can't determine relativeDomainName |
166 |
|
167 |
if s4connector.property[propertyname].mapping_table and propertyattrib in s4connector.property[propertyname].mapping_table.keys(): |
168 |
for ucsval, conval in s4connector.property[propertyname].mapping_table[propertyattrib]: |
169 |
try: |
170 |
if relativeDomainName.lower() == ucsval.lower(): |
171 |
relativeDomainName = conval |
172 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: map relativeDomainName according to mapping-table") |
173 |
continue |
174 |
except UnicodeDecodeError: |
175 |
pass # values are not the same codec |
176 |
|
177 |
try: |
178 |
ol_zone_name = obj['attributes']['zoneName'][0] |
179 |
except (KeyError, IndexError): |
180 |
### Safety fallback for the unexpected case, where zoneName would not be set |
181 |
rdn0_attrib = dn[:pos] |
182 |
if ol_RR_attr == rdn0_attrib: |
183 |
## get parent following the recipe from __split_s4_dns_dn: |
184 |
rdn1_tmp = rdn[1].split('=') |
185 |
rdn1_key, rdn1_val = (rdn1_tmp[0], string.join(rdn1_tmp[1:], '=')) |
186 |
if 'zoneName' == rdn1_key: |
187 |
ol_zone_name = rdn1_val |
188 |
else: |
189 |
raise ## can't determine zoneName for this relativeDomainName |
190 |
|
191 |
if '@' == relativeDomainName: ## or dn starts with 'zoneName=' |
192 |
s4_filter = '(&(objectClass=dnsZone)(%s=%s))' % (s4_RR_attr, ol_zone_name) |
193 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: search in S4 %s" % s4_filter) |
194 |
for base in s4connector.s4_ldap_partitions: |
195 |
result = s4connector._s4__search_s4( |
196 |
base, |
197 |
ldap.SCOPE_SUBTREE, |
198 |
univention.s4connector.s4.compatible_modstring(s4_filter), |
199 |
attrlist=(s4_RR_attr,), |
200 |
show_deleted=False) |
201 |
|
202 |
if result: |
203 |
break |
204 |
else: |
205 |
## identify position by parent zone name |
206 |
ol_zone_dn = s4connector.lo.parentDn(dn) |
207 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: get dns_dn_mapping for %s" % ol_zone_dn) |
208 |
fake_ol_zone_object = { |
209 |
'dn': ol_zone_dn, |
210 |
'attributes': { |
211 |
'objectClass': ['top', 'dNSZone'], |
212 |
'relativeDomainName': ['@'], |
213 |
'zoneName': [ol_zone_name], |
214 |
}, |
215 |
'olddn': None, ## Just fake, not used |
216 |
} |
217 |
s4_zone_object = dns_dn_mapping(s4connector, fake_ol_zone_object, dn_mapping_stored, isUCSobject) |
218 |
## and use its parent as the search base |
219 |
s4_zone_dn = s4connector.lo_s4.parentDn(s4_zone_object['dn']) |
220 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: search in s4 %s=%s" % (s4_RR_attr, relativeDomainName)) |
221 |
result = s4connector._s4__search_s4( |
222 |
s4_zone_dn, |
223 |
ldap.SCOPE_SUBTREE, |
224 |
univention.s4connector.s4.compatible_modstring('(&%s(%s=%s))' % (s4_RR_filter, s4_RR_attr, relativeDomainName)), |
225 |
attrlist=('dn',), |
226 |
show_deleted=False) |
227 |
|
228 |
try: |
229 |
s4dn_utf16_le = result[0][0] |
230 |
except (IndexError, TypeError): |
231 |
s4dn_utf16_le = None |
232 |
|
233 |
if s4dn_utf16_le: # no referral, so we've got a valid result |
234 |
s4dn = univention.s4connector.s4.encode_attrib(result[0][0]) |
235 |
s4pos2 = len(univention.s4connector.s4.explode_unicode_dn(s4dn)[0]) |
236 |
if dn_key == 'olddn' or (dn_key == 'dn' and not 'olddn' in obj): |
237 |
## TODO: Why do we differenciate here? |
238 |
newdn = s4dn |
239 |
else: |
240 |
## TODO: Why do we need to patch the DNs here? Rename case? Modify case? |
241 |
s4dn = s4dn[:s4pos2] + dn[pos2:] |
242 |
newdn = s4dn.lower().replace(s4connector.lo_s4.base.lower(), s4connector.lo.base.lower()) |
243 |
else: |
244 |
## Ok, it's a new object, so propose a S4 DN for it: |
245 |
if '@' == relativeDomainName: ## or dn starts with 'zoneName=' |
246 |
new_rdn = 'dc=%s' % ol_zone_name |
247 |
else: |
248 |
new_rdn = 'dc=%s,dc=%s' % (relativeDomainName, ol_zone_name) |
249 |
newdn = new_rdn + ',' + s4connector.property['dns'].con_default_dn |
250 |
|
251 |
else: |
252 |
# get the object to read the s4_RR_attr in S4 and use it as name |
253 |
# we have no fallback here, the given dn must be found in S4 or we've got an error |
254 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: got an S4-Object") |
255 |
i = 0 |
256 |
|
257 |
while ( not s4_RR_val ): # in case of olddn this is already set |
258 |
i = i + 1 |
259 |
search_dn = obj.get('deleted_dn', dn) |
260 |
try: |
261 |
s4_RR_val = univention.s4connector.s4.encode_attrib( |
262 |
s4connector.lo_s4.lo.search_ext_s(univention.s4connector.s4.compatible_modstring(search_dn), ldap.SCOPE_BASE, |
263 |
s4_RR_filter, [s4_RR_attr]) [0][1][s4_RR_attr][0]) |
264 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: got %s from S4" % s4_RR_attr) |
265 |
except ldap.NO_SUCH_OBJECT: # S4 may need time |
266 |
if i > 5: |
267 |
raise |
268 |
time.sleep(1) # S4 may need some time... |
269 |
|
270 |
if s4connector.property[propertyname].mapping_table and propertyattrib in s4connector.property[propertyname].mapping_table.keys(): |
271 |
for ucsval, conval in s4connector.property[propertyname].mapping_table[propertyattrib]: |
272 |
if s4_RR_val.lower() == conval.lower(): |
273 |
s4_RR_val = ucsval |
274 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: map %s according to mapping-table" % s4_RR_attr) |
275 |
continue |
276 |
else: |
277 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: %s not in mapping-table" % s4_RR_attr) |
278 |
|
279 |
# search for object with this dn in ucs, needed if it is located in a different container |
280 |
try: |
281 |
s4_ocs = obj['attributes']['objectClass'] |
282 |
except (KeyError, TypeError): |
283 |
s4_ocs = [] |
284 |
|
285 |
if 'dnsZone' in s4_ocs: |
286 |
s4_zone_name = s4_RR_val |
287 |
base = s4connector.lo.base |
288 |
ol_search_attr = 'zoneName' |
289 |
## could use a specific LDAP filter here, but not necessary: |
290 |
# ol_oc_filter = '(&(objectClass=dNSZone)(|(univentionObjectType=dns/forward_zone)(univentionObjectType=dns/reverse_zone)))' |
291 |
elif 'dnsNode' in s4_ocs: |
292 |
## identify position of the parent zone |
293 |
s4pos = string.find(rdn[1], '=') |
294 |
s4_zone_name = rdn[1][s4pos+1:] |
295 |
s4_zone_dn = s4connector.lo_s4.parentDn(dn) |
296 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: get dns_dn_mapping for %s" % s4_zone_dn) |
297 |
fake_s4_zone_object = { |
298 |
'dn': s4_zone_dn, |
299 |
'attributes': { |
300 |
'objectClass': ['top', 'dnsZone'], |
301 |
'dc': [s4_zone_name], |
302 |
}, |
303 |
'olddn': None, ## Just fake, not used |
304 |
} |
305 |
ol_zone_object = dns_dn_mapping(s4connector, fake_s4_zone_object, dn_mapping_stored, isUCSobject) |
306 |
## and use that as the search base |
307 |
base = ol_zone_object['dn'] |
308 |
ol_search_attr = ol_RR_attr |
309 |
## could use a specific LDAP filter here, but not necessary: |
310 |
# ol_oc_filter = '(&(objectClass=dNSZone)(!(|(univentionObjectType=dns/forward_zone)(univentionObjectType=dns/reverse_zone))))' |
311 |
|
312 |
ud.debug(ud.LDAP, ud.WARN, "dns_dn_mapping: UCS filter: (&%s(%s=%s))" % (ol_oc_filter, ol_search_attr, s4_RR_val)) |
313 |
ucsdn_result = s4connector.search_ucs(filter=u'(&%s(%s=%s))' % (ol_oc_filter, ol_search_attr, s4_RR_val), |
314 |
base=base, scope='sub', attr=('dn',)) |
315 |
|
316 |
try: |
317 |
ucsdn = ucsdn_result[0][0] |
318 |
except (IndexError, TypeError): |
319 |
ucsdn = None |
320 |
|
321 |
ud.debug(ud.LDAP, ud.ALL, "dns_dn_mapping: Found ucsdn: %s" % ucsdn) |
322 |
if ucsdn: |
323 |
## In this case we have found the old or first known DN: |
324 |
newdn = ucsdn |
325 |
## HACK: |
326 |
# pos = string.find(ucsdn, '=') |
327 |
# newdn = ol_search_attr + ucsdn[pos:] ## adjust for zoneName |
328 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: newdn is ucsdn") |
329 |
else: |
330 |
## Ok, it's a new object, so propose a S4 DN for it: |
331 |
if 'dnsZone' in s4_ocs or '@' == s4_RR_val: |
332 |
new_rdn = 'zoneName=%s' % s4_zone_name |
333 |
else: |
334 |
new_rdn = 'relativeDomainName=%s,zoneName=%s' % (s4_RR_val, s4_zone_name) |
335 |
newdn = new_rdn + ',' + s4connector.property['dns'].ucs_default_dn |
336 |
|
337 |
try: |
338 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: mapping for key '%s':" % dn_key) |
339 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: source DN: %s" % dn) |
340 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: mapped DN: %s" % newdn) |
341 |
except: # FIXME: which exception is to be caught? |
342 |
ud.debug(ud.LDAP, ud.INFO, "dns_dn_mapping: dn-print failed") |
343 |
|
344 |
obj[dn_key]=newdn |
345 |
|
346 |
return obj |
347 |
|
93 |
''' HELPER functions ''' |
348 |
''' HELPER functions ''' |
94 |
def __append_dot(str): |
349 |
def __append_dot(str): |
95 |
if str[-1] != '.': |
350 |
if str[-1] != '.': |
|
109 |
raise |
364 |
raise |
110 |
return zoneName |
365 |
return zoneName |
111 |
|
366 |
|
112 |
def __create_default_s4_zone_dn(s4connector, object): |
367 |
def __create_s4_forward_zone(s4connector, zoneDn): |
113 |
zoneName=__get_zone_name(object) |
|
|
114 |
dn='DC=%s,%s' % (zoneName[0], s4connector.property['dns'].con_default_dn) |
115 |
return (dn, zoneName) |
116 |
|
117 |
def __create_s4_forward_zone(s4connector, zoneDn, zoneName): |
118 |
al=[] |
368 |
al=[] |
119 |
al.append(('objectClass', ['top', 'dnsZone'])) |
369 |
al.append(('objectClass', ['top', 'dnsZone'])) |
120 |
al.append(('DC', univention.s4connector.s4.compatible_list(zoneName))) |
|
|
121 |
|
370 |
|
122 |
ud.debug(ud.LDAP, ud.INFO, '_dns_zone_forward_con_create: dn: %s' % zoneDn) |
371 |
ud.debug(ud.LDAP, ud.INFO, '_dns_zone_forward_con_create: dn: %s' % zoneDn) |
123 |
ud.debug(ud.LDAP, ud.INFO, '_dns_zone_forward_con_create: al: %s' % al) |
372 |
ud.debug(ud.LDAP, ud.INFO, '_dns_zone_forward_con_create: al: %s' % al) |
124 |
s4connector.lo_s4.lo.add_s(zoneDn, al) |
373 |
s4connector.lo_s4.lo.add_s(zoneDn, al) |
125 |
|
374 |
|
126 |
def __create_s4_forward_zone_at(s4connector, zoneDnAt, zoneName): |
375 |
def __create_s4_forward_zone_at(s4connector, zoneDnAt): |
127 |
al=[] |
376 |
al=[] |
128 |
al.append(('objectClass', ['top', 'dnsNode'])) |
377 |
al.append(('objectClass', ['top', 'dnsNode'])) |
129 |
al.append(('dc', ['@'])) |
378 |
al.append(('dc', ['@'])) |
|
295 |
def s4_zone_create(s4connector, object): |
544 |
def s4_zone_create(s4connector, object): |
296 |
_d=ud.function('s4_zone_create') |
545 |
_d=ud.function('s4_zone_create') |
297 |
|
546 |
|
298 |
zoneDn, zoneName=__create_default_s4_zone_dn(s4connector, object) |
547 |
zoneDn = object['dn'] |
|
|
548 |
zoneName = __get_zone_name(object) |
299 |
|
549 |
|
300 |
# Create the forward zone in S4 if it does not exist |
550 |
# Create the forward zone in S4 if it does not exist |
301 |
try: |
551 |
try: |
302 |
searchResult=s4connector.lo_s4.lo.search_s(zoneDn, ldap.SCOPE_BASE, '(objectClass=*)',['dn']) |
552 |
searchResult=s4connector.lo_s4.lo.search_s(zoneDn, ldap.SCOPE_BASE, '(objectClass=*)',['dn']) |
303 |
except ldap.NO_SUCH_OBJECT: |
553 |
except ldap.NO_SUCH_OBJECT: |
304 |
__create_s4_forward_zone(s4connector, zoneDn, zoneName) |
554 |
__create_s4_forward_zone(s4connector, zoneDn) |
305 |
|
555 |
|
306 |
# Create @ object |
556 |
# Create @ object |
307 |
zoneDnAt='DC=@,%s' % zoneDn |
557 |
zoneDnAt='DC=@,%s' % zoneDn |
|
313 |
if searchResult and searchResult[0][1]: |
563 |
if searchResult and searchResult[0][1]: |
314 |
old_dnsRecords=searchResult[0][1].get('dnsRecord') |
564 |
old_dnsRecords=searchResult[0][1].get('dnsRecord') |
315 |
except ldap.NO_SUCH_OBJECT: |
565 |
except ldap.NO_SUCH_OBJECT: |
316 |
__create_s4_forward_zone_at(s4connector, zoneDnAt, zoneName) |
566 |
__create_s4_forward_zone_at(s4connector, zoneDnAt) |
317 |
|
567 |
|
318 |
dnsRecords=[] |
568 |
dnsRecords=[] |
319 |
|
569 |
|
|
354 |
def s4_zone_delete(s4connector, object): |
604 |
def s4_zone_delete(s4connector, object): |
355 |
_d=ud.function('s4_zone_delete') |
605 |
_d=ud.function('s4_zone_delete') |
356 |
|
606 |
|
357 |
zoneDn, zoneName=__create_default_s4_zone_dn(s4connector, object) |
607 |
zoneDn = object['dn'] |
358 |
|
608 |
|
359 |
zoneDnAt='DC=@,%s' % zoneDn |
609 |
zoneDnAt='DC=@,%s' % zoneDn |
360 |
|
610 |
|
|
373 |
def s4_dns_node_base_create(s4connector, object, dnsRecords): |
623 |
def s4_dns_node_base_create(s4connector, object, dnsRecords): |
374 |
_d=ud.function('s4_dns_node_base_create') |
624 |
_d=ud.function('s4_dns_node_base_create') |
375 |
|
625 |
|
376 |
zoneDn, zoneName=__create_default_s4_zone_dn(s4connector, object) |
|
|
377 |
|
378 |
relativeDomainNames=object['attributes'].get('relativeDomainName') |
626 |
relativeDomainNames=object['attributes'].get('relativeDomainName') |
379 |
relativeDomainNames=univention.s4connector.s4.compatible_list(relativeDomainNames) |
627 |
relativeDomainNames=univention.s4connector.s4.compatible_list(relativeDomainNames) |
380 |
|
628 |
|
|
381 |
old_dnsRecords=[] |
629 |
old_dnsRecords=[] |
382 |
|
630 |
|
383 |
# Create dnsNode object |
631 |
# Create dnsNode object |
384 |
dnsNodeDn='DC=%s,%s' % (relativeDomainNames[0],zoneDn) |
632 |
dnsNodeDn=object['dn'] |
385 |
try: |
633 |
try: |
386 |
searchResult=s4connector.lo_s4.lo.search_s(dnsNodeDn, ldap.SCOPE_BASE, '(objectClass=*)') |
634 |
searchResult=s4connector.lo_s4.lo.search_s(dnsNodeDn, ldap.SCOPE_BASE, '(objectClass=*)') |
387 |
if searchResult and searchResult[0][1]: |
635 |
if searchResult and searchResult[0][1]: |
|
396 |
def s4_dns_node_base_delete(s4connector, object): |
644 |
def s4_dns_node_base_delete(s4connector, object): |
397 |
_d=ud.function('s4_dns_node_base_delete') |
645 |
_d=ud.function('s4_dns_node_base_delete') |
398 |
|
646 |
|
399 |
zoneDn, zoneName=__create_default_s4_zone_dn(s4connector, object) |
|
|
400 |
|
401 |
relativeDomainNames=object['attributes'].get('relativeDomainName') |
647 |
relativeDomainNames=object['attributes'].get('relativeDomainName') |
402 |
relativeDomainNames=univention.s4connector.s4.compatible_list(relativeDomainNames) |
648 |
relativeDomainNames=univention.s4connector.s4.compatible_list(relativeDomainNames) |
403 |
|
649 |
|
404 |
dnsNodeDn='DC=%s,%s' % (relativeDomainNames[0],zoneDn) |
650 |
dnsNodeDn=object['dn'] |
405 |
try: |
651 |
try: |
406 |
res=s4connector.lo_s4.lo.delete_s(dnsNodeDn) |
652 |
res=s4connector.lo_s4.lo.delete_s(dnsNodeDn) |
407 |
except ldap.NO_SUCH_OBJECT: |
653 |
except ldap.NO_SUCH_OBJECT: |
|
422 |
|
668 |
|
423 |
return True |
669 |
return True |
424 |
|
670 |
|
425 |
def __split_s4_dn(dn): |
671 |
def __split_s4_dns_dn(dn): |
426 |
# split zone |
672 |
# split zone |
427 |
dn=ldap.explode_dn(dn) |
673 |
dn=ldap.explode_dn(dn) |
428 |
|
674 |
|
|
436 |
_d=ud.function('ucs_host_record_create') |
682 |
_d=ud.function('ucs_host_record_create') |
437 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_host_record_create: object: %s' % object) |
683 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_host_record_create: object: %s' % object) |
438 |
|
684 |
|
439 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
685 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
440 |
|
686 |
|
441 |
# unpack the host record |
687 |
# unpack the host record |
442 |
a=__unpack_aRecord(object) |
688 |
a=__unpack_aRecord(object) |
|
472 |
_d=ud.function('ucs_host_record_delete') |
718 |
_d=ud.function('ucs_host_record_delete') |
473 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_host_record_delete: object: %s' % object) |
719 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_host_record_delete: object: %s' % object) |
474 |
|
720 |
|
475 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
721 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
476 |
|
722 |
|
477 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
723 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
478 |
if len(searchResult) > 0: |
724 |
if len(searchResult) > 0: |
|
501 |
_d=ud.function('ucs_ptr_record_create') |
747 |
_d=ud.function('ucs_ptr_record_create') |
502 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_ptr_record_create: object: %s' % object) |
748 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_ptr_record_create: object: %s' % object) |
503 |
|
749 |
|
504 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
750 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
505 |
|
751 |
|
506 |
# unpack the host record |
752 |
# unpack the host record |
507 |
ptr=__unpack_ptrRecord(object) |
753 |
ptr=__unpack_ptrRecord(object) |
|
536 |
_d=ud.function('ucs_ptr_record_delete') |
782 |
_d=ud.function('ucs_ptr_record_delete') |
537 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_ptr_record_delete: object: %s' % object) |
783 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_ptr_record_delete: object: %s' % object) |
538 |
|
784 |
|
539 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
785 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
540 |
|
786 |
|
541 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
787 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
542 |
if len(searchResult) > 0: |
788 |
if len(searchResult) > 0: |
|
553 |
_d=ud.function('ucs_cname_create') |
799 |
_d=ud.function('ucs_cname_create') |
554 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_cname_create: object: %s' % object) |
800 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_cname_create: object: %s' % object) |
555 |
|
801 |
|
556 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
802 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
557 |
|
803 |
|
558 |
# unpack the host record |
804 |
# unpack the host record |
559 |
c=__unpack_cName(object) |
805 |
c=__unpack_cName(object) |
|
588 |
_d=ud.function('ucs_cname_delete') |
834 |
_d=ud.function('ucs_cname_delete') |
589 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_cname_delete: object: %s' % object) |
835 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_cname_delete: object: %s' % object) |
590 |
|
836 |
|
591 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
837 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
592 |
|
838 |
|
593 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
839 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
594 |
if len(searchResult) > 0: |
840 |
if len(searchResult) > 0: |
|
614 |
_d=ud.function('ucs_srv_record_create') |
860 |
_d=ud.function('ucs_srv_record_create') |
615 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_srv_record_create: object: %s' % object) |
861 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_srv_record_create: object: %s' % object) |
616 |
|
862 |
|
617 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
863 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
618 |
|
864 |
|
619 |
# unpack the host record |
865 |
# unpack the host record |
620 |
srv=__unpack_sRVrecord(object) |
866 |
srv=__unpack_sRVrecord(object) |
|
673 |
_d=ud.function('ucs_srv_record_delete') |
919 |
_d=ud.function('ucs_srv_record_delete') |
674 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_srv_record_delete: object: %s' % object) |
920 |
ud.debug(ud.LDAP, ud.INFO, 'ucs_srv_record_delete: object: %s' % object) |
675 |
|
921 |
|
676 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
922 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
677 |
|
923 |
|
678 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
924 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
679 |
if len(searchResult) > 0: |
925 |
if len(searchResult) > 0: |
|
692 |
|
938 |
|
693 |
dnsRecords=[] |
939 |
dnsRecords=[] |
694 |
|
940 |
|
695 |
zoneDn, zoneName=__create_default_s4_zone_dn(s4connector, object) |
941 |
zoneDn = object['dn'] |
|
|
942 |
zoneName = __get_zone_name(object) |
696 |
|
943 |
|
697 |
relativeDomainName=object['attributes'].get('relativeDomainName') |
944 |
relativeDomainName=object['attributes'].get('relativeDomainName') |
698 |
relativeDomainName=univention.s4connector.s4.compatible_list(relativeDomainName) |
945 |
relativeDomainName=univention.s4connector.s4.compatible_list(relativeDomainName) |
|
727 |
def ucs_zone_create(s4connector, object, dns_type): |
974 |
def ucs_zone_create(s4connector, object, dns_type): |
728 |
_d=ud.function('ucs_zone_create') |
975 |
_d=ud.function('ucs_zone_create') |
729 |
|
976 |
|
730 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
977 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
731 |
|
978 |
|
732 |
# create the zone if the dc=@ object was created |
979 |
# create the zone if the dc=@ object was created |
733 |
if relativeDomainName != '@': |
980 |
if relativeDomainName != '@': |
|
804 |
def ucs_zone_delete(s4connector, object, dns_type): |
1051 |
def ucs_zone_delete(s4connector, object, dns_type): |
805 |
_d=ud.function('ucs_zone_delete') |
1052 |
_d=ud.function('ucs_zone_delete') |
806 |
|
1053 |
|
807 |
zoneName, relativeDomainName=__split_s4_dn(object['dn']) |
1054 |
zoneName, relativeDomainName=__split_s4_dns_dn(object['dn']) |
808 |
|
1055 |
|
809 |
if relativeDomainName == '@': |
1056 |
if relativeDomainName == '@': |
810 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
1057 |
searchResult=s4connector.lo.search(filter='(&(relativeDomainName=%s)(zoneName=%s))' % (relativeDomainName, zoneName), unique=1) |
|
890 |
ud.debug(ud.LDAP, ud.INFO, 'dns ucs2con: Ignore unkown dns object: %s' % object['dn']) |
1137 |
ud.debug(ud.LDAP, ud.INFO, 'dns ucs2con: Ignore unkown dns object: %s' % object['dn']) |
891 |
return True |
1138 |
return True |
892 |
|
1139 |
|
893 |
ud.debug(ud.LDAP, ud.INFO, 'dns ucs2con: Object (%s) is from type %s' % (object['dn'], dns_type)) |
1140 |
ud.debug(ud.LDAP, ud.INFO, 'dns ucs2con: Object (%s) is of type %s' % (object['dn'], dns_type)) |
894 |
|
1141 |
|
895 |
if dns_type == 'forward_zone' or dns_type == 'reverse_zone': |
1142 |
if dns_type == 'forward_zone' or dns_type == 'reverse_zone': |
896 |
if object['modtype'] in ['add', 'modify']: |
1143 |
if object['modtype'] in ['add', 'modify']: |