?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
samba-tool: Unify usage messages.
[Samba/gebeck_regimport.git] / source4 / scripting / python / samba / netcmd / dns.py
blob8bd3249ae231a175949f7ba5cf777bfe33f1ff33
1 # DNS management tool
2 #
3 # Copyright (C) Amitay Isaacs 2011-2012
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
17 #
18
19 import samba.getopt as options
20 from struct import pack
21 from socket import inet_ntoa
22 import shlex
23
24 from samba.netcmd import (
25 Command,
26 CommandError,
27 Option,
28 SuperCommand,
29 )
30 from samba.dcerpc import dnsp, dnsserver
31
32
33 def dns_connect(server, lp, creds):
34 binding_str = "ncacn_ip_tcp:%s[sign]" % server
35 dns_conn = dnsserver.dnsserver(binding_str, lp, creds)
36 return dns_conn
37
38
39 def bool_string(flag):
40 if flag == 0:
41 ret = 'FALSE'
42 elif flag == 1:
43 ret = 'TRUE'
44 else:
45 ret = 'UNKNOWN (0x%x)' % flag
46 return ret
47
48
49 def enum_string(module, enum_defs, value):
50 ret = None
51 for e in enum_defs:
52 if value == getattr(module, e):
53 ret = e
54 break
55 if not ret:
56 ret = 'UNKNOWN (0x%x)' % value
57 return ret
58
59
60 def bitmap_string(module, bitmap_defs, value):
61 ret = ''
62 for b in bitmap_defs:
63 if value & getattr(module, b):
64 ret += '%s ' % b
65 if not ret:
66 ret = 'NONE'
67 return ret
68
69
70 def boot_method_string(boot_method):
71 enum_defs = [ 'DNS_BOOT_METHOD_UNINITIALIZED', 'DNS_BOOT_METHOD_FILE',
72 'DNS_BOOT_METHOD_REGISTRY', 'DNS_BOOT_METHOD_DIRECTORY' ]
73 return enum_string(dnsserver, enum_defs, boot_method)
74
75
76 def name_check_flag_string(check_flag):
77 enum_defs = [ 'DNS_ALLOW_RFC_NAMES_ONLY', 'DNS_ALLOW_NONRFC_NAMES',
78 'DNS_ALLOW_MULTIBYTE_NAMES', 'DNS_ALLOW_ALL_NAMES' ]
79 return enum_string(dnsserver, enum_defs, check_flag)
80
81
82 def zone_type_string(zone_type):
83 enum_defs = [ 'DNS_ZONE_TYPE_CACHE', 'DNS_ZONE_TYPE_PRIMARY',
84 'DNS_ZONE_TYPE_SECONDARY', 'DNS_ZONE_TYPE_STUB',
85 'DNS_ZONE_TYPE_FORWARDER', 'DNS_ZONE_TYPE_SECONDARY_CACHE' ]
86 return enum_string(dnsp, enum_defs, zone_type)
87
88
89 def zone_update_string(zone_update):
90 enum_defs = [ 'DNS_ZONE_UPDATE_OFF', 'DNS_ZONE_UPDATE_SECURE',
91 'DNS_ZONE_UPDATE_SECURE' ]
92 return enum_string(dnsp, enum_defs, zone_update)
93
94
95 def zone_secondary_security_string(security):
96 enum_defs = [ 'DNS_ZONE_SECSECURE_NO_SECURITY', 'DNS_ZONE_SECSECURE_NS_ONLY',
97 'DNS_ZONE_SECSECURE_LIST_ONLY', 'DNS_ZONE_SECSECURE_NO_XFER' ]
98 return enum_string(dnsserver, enum_defs, security)
99
100
101 def zone_notify_level_string(notify_level):
102 enum_defs = [ 'DNS_ZONE_NOTIFY_OFF', 'DNS_ZONE_NOTIFY_ALL_SECONDARIES',
103 'DNS_ZONE_NOTIFY_LIST_ONLY' ]
104 return enum_string(dnsserver, enum_defs, notify_level)
105
106
107 def dp_flags_string(dp_flags):
108 bitmap_defs = [ 'DNS_DP_AUTOCREATED', 'DNS_DP_LEGACY', 'DNS_DP_DOMAIN_DEFAULT',
109 'DNS_DP_FOREST_DEFAULT', 'DNS_DP_ENLISTED', 'DNS_DP_DELETED' ]
110 return bitmap_string(dnsserver, bitmap_defs, dp_flags)
111
112
113 def zone_flags_string(flags):
114 bitmap_defs = [ 'DNS_RPC_ZONE_PAUSED', 'DNS_RPC_ZONE_SHUTDOWN',
115 'DNS_RPC_ZONE_REVERSE', 'DNS_RPC_ZONE_AUTOCREATED',
116 'DNS_RPC_ZONE_DSINTEGRATED', 'DNS_RPC_ZONE_AGING',
117 'DNS_RPC_ZONE_UPDATE_UNSECURE', 'DNS_RPC_ZONE_UPDATE_SECURE',
118 'DNS_RPC_ZONE_READONLY']
119 return bitmap_string(dnsserver, bitmap_defs, flags)
120
121
122 def ip4_array_string(array):
123 ret = []
124 if not array:
125 return ret
126 for i in xrange(array.AddrCount):
127 addr = '%s' % inet_ntoa(pack('i', array.AddrArray[i]))
128 ret.append(addr)
129 return ret
130
131
132 def dns_addr_array_string(array):
133 ret = []
134 if not array:
135 return ret
136 for i in xrange(array.AddrCount):
137 if array.AddrArray[i].MaxSa[0] == 0x02:
138 addr = '%d.%d.%d.%d (%d)' % \
139 tuple(array.AddrArray[i].MaxSa[4:8] + [array.AddrArray[i].MaxSa[3]])
140 elif array.AddrArray[i].MaxSa[0] == 0x17:
141 addr = '%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x (%d)' % \
142 tuple(array.AddrArray[i].MaxSa[4:20] + [array.AddrArray[i].MaxSa[3]])
143 else:
144 addr = 'UNKNOWN'
145 ret.append(addr)
146 return ret
147
148
149 def dns_type_flag(rec_type):
150 rtype = rec_type.upper()
151 if rtype == 'A':
152 record_type = dnsp.DNS_TYPE_A
153 elif rtype == 'AAAA':
154 record_type = dnsp.DNS_TYPE_AAAA
155 elif rtype == 'PTR':
156 record_type = dnsp.DNS_TYPE_PTR
157 elif rtype == 'NS':
158 record_type = dnsp.DNS_TYPE_NS
159 elif rtype == 'CNAME':
160 record_type = dnsp.DNS_TYPE_CNAME
161 elif rtype == 'SOA':
162 record_type = dnsp.DNS_TYPE_SOA
163 elif rtype == 'MX':
164 record_type = dnsp.DNS_TYPE_MX
165 elif rtype == 'SRV':
166 record_type = dnsp.DNS_TYPE_SRV
167 elif rtype == 'TXT':
168 record_type = dnsp.DNS_TYPE_TXT
169 elif rtype == 'ALL':
170 record_type = dnsp.DNS_TYPE_ALL
171 else:
172 raise CommandError('Unknown type of DNS record %s' % rec_type)
173 return record_type
174
175
176 def dns_client_version(cli_version):
177 version = cli_version.upper()
178 if version == 'W2K':
179 client_version = dnsserver.DNS_CLIENT_VERSION_W2K
180 elif version == 'DOTNET':
181 client_version = dnsserver.DNS_CLIENT_VERSION_DOTNET
182 elif version == 'LONGHORN':
183 client_version = dnsserver.DNS_CLIENT_VERSION_LONGHORN
184 else:
185 raise CommandError('Unknown client version %s' % cli_version)
186 return client_version
187
188
189 def print_serverinfo(outf, typeid, serverinfo):
190 outf.write(' dwVersion : 0x%x\n' % serverinfo.dwVersion)
191 outf.write(' fBootMethod : %s\n' % boot_method_string(serverinfo.fBootMethod))
192 outf.write(' fAdminConfigured : %s\n' % bool_string(serverinfo.fAdminConfigured))
193 outf.write(' fAllowUpdate : %s\n' % bool_string(serverinfo.fAllowUpdate))
194 outf.write(' fDsAvailable : %s\n' % bool_string(serverinfo.fDsAvailable))
195 outf.write(' pszServerName : %s\n' % serverinfo.pszServerName)
196 outf.write(' pszDsContainer : %s\n' % serverinfo.pszDsContainer)
197
198 if typeid != dnsserver.DNSSRV_TYPEID_SERVER_INFO:
199 outf.write(' aipServerAddrs : %s\n' %
200 ip4_array_string(serverinfo.aipServerAddrs))
201 outf.write(' aipListenAddrs : %s\n' %
202 ip4_array_string(serverinfo.aipListenAddrs))
203 outf.write(' aipForwarders : %s\n' %
204 ip4_array_string(serverinfo.aipForwarders))
205 else:
206 outf.write(' aipServerAddrs : %s\n' %
207 dns_addr_array_string(serverinfo.aipServerAddrs))
208 outf.write(' aipListenAddrs : %s\n' %
209 dns_addr_array_string(serverinfo.aipListenAddrs))
210 outf.write(' aipForwarders : %s\n' %
211 dns_addr_array_string(serverinfo.aipForwarders))
212
213 outf.write(' dwLogLevel : %d\n' % serverinfo.dwLogLevel)
214 outf.write(' dwDebugLevel : %d\n' % serverinfo.dwDebugLevel)
215 outf.write(' dwForwardTimeout : %d\n' % serverinfo.dwForwardTimeout)
216 outf.write(' dwRpcPrototol : 0x%x\n' % serverinfo.dwRpcProtocol)
217 outf.write(' dwNameCheckFlag : %s\n' % name_check_flag_string(serverinfo.dwNameCheckFlag))
218 outf.write(' cAddressAnswerLimit : %d\n' % serverinfo.cAddressAnswerLimit)
219 outf.write(' dwRecursionRetry : %d\n' % serverinfo.dwRecursionRetry)
220 outf.write(' dwRecursionTimeout : %d\n' % serverinfo.dwRecursionTimeout)
221 outf.write(' dwMaxCacheTtl : %d\n' % serverinfo.dwMaxCacheTtl)
222 outf.write(' dwDsPollingInterval : %d\n' % serverinfo.dwDsPollingInterval)
223 outf.write(' dwScavengingInterval : %d\n' % serverinfo.dwScavengingInterval)
224 outf.write(' dwDefaultRefreshInterval : %d\n' % serverinfo.dwDefaultRefreshInterval)
225 outf.write(' dwDefaultNoRefreshInterval : %d\n' % serverinfo.dwDefaultNoRefreshInterval)
226 outf.write(' fAutoReverseZones : %s\n' % bool_string(serverinfo.fAutoReverseZones))
227 outf.write(' fAutoCacheUpdate : %s\n' % bool_string(serverinfo.fAutoCacheUpdate))
228 outf.write(' fRecurseAfterForwarding : %s\n' % bool_string(serverinfo.fRecurseAfterForwarding))
229 outf.write(' fForwardDelegations : %s\n' % bool_string(serverinfo.fForwardDelegations))
230 outf.write(' fNoRecursion : %s\n' % bool_string(serverinfo.fNoRecursion))
231 outf.write(' fSecureResponses : %s\n' % bool_string(serverinfo.fSecureResponses))
232 outf.write(' fRoundRobin : %s\n' % bool_string(serverinfo.fRoundRobin))
233 outf.write(' fLocalNetPriority : %s\n' % bool_string(serverinfo.fLocalNetPriority))
234 outf.write(' fBindSecondaries : %s\n' % bool_string(serverinfo.fBindSecondaries))
235 outf.write(' fWriteAuthorityNs : %s\n' % bool_string(serverinfo.fWriteAuthorityNs))
236 outf.write(' fStrictFileParsing : %s\n' % bool_string(serverinfo.fStrictFileParsing))
237 outf.write(' fLooseWildcarding : %s\n' % bool_string(serverinfo.fLooseWildcarding))
238 outf.write(' fDefaultAgingState : %s\n' % bool_string(serverinfo.fDefaultAgingState))
239
240 if typeid != dnsserver.DNSSRV_TYPEID_SERVER_INFO_W2K:
241 outf.write(' dwRpcStructureVersion : 0x%x\n' % serverinfo.dwRpcStructureVersion)
242 outf.write(' aipLogFilter : %s\n' % dns_addr_array_string(serverinfo.aipLogFilter))
243 outf.write(' pwszLogFilePath : %s\n' % serverinfo.pwszLogFilePath)
244 outf.write(' pszDomainName : %s\n' % serverinfo.pszDomainName)
245 outf.write(' pszForestName : %s\n' % serverinfo.pszForestName)
246 outf.write(' pszDomainDirectoryPartition : %s\n' % serverinfo.pszDomainDirectoryPartition)
247 outf.write(' pszForestDirectoryPartition : %s\n' % serverinfo.pszForestDirectoryPartition)
248
249 outf.write(' dwLocalNetPriorityNetMask : 0x%x\n' % serverinfo.dwLocalNetPriorityNetMask)
250 outf.write(' dwLastScavengeTime : %d\n' % serverinfo.dwLastScavengeTime)
251 outf.write(' dwEventLogLevel : %d\n' % serverinfo.dwEventLogLevel)
252 outf.write(' dwLogFileMaxSize : %d\n' % serverinfo.dwLogFileMaxSize)
253 outf.write(' dwDsForestVersion : %d\n' % serverinfo.dwDsForestVersion)
254 outf.write(' dwDsDomainVersion : %d\n' % serverinfo.dwDsDomainVersion)
255 outf.write(' dwDsDsaVersion : %d\n' % serverinfo.dwDsDsaVersion)
256
257 if typeid == dnsserver.DNSSRV_TYPEID_SERVER_INFO:
258 outf.write(' fReadOnlyDC : %s\n' % bool_string(serverinfo.fReadOnlyDC))
259
260
261 def print_zoneinfo(outf, typeid, zoneinfo):
262 outf.write(' pszZoneName : %s\n' % zoneinfo.pszZoneName)
263 outf.write(' dwZoneType : %s\n' % zone_type_string(zoneinfo.dwZoneType))
264 outf.write(' fReverse : %s\n' % bool_string(zoneinfo.fReverse))
265 outf.write(' fAllowUpdate : %s\n' % zone_update_string(zoneinfo.fAllowUpdate))
266 outf.write(' fPaused : %s\n' % bool_string(zoneinfo.fPaused))
267 outf.write(' fShutdown : %s\n' % bool_string(zoneinfo.fShutdown))
268 outf.write(' fAutoCreated : %s\n' % bool_string(zoneinfo.fAutoCreated))
269 outf.write(' fUseDatabase : %s\n' % bool_string(zoneinfo.fUseDatabase))
270 outf.write(' pszDataFile : %s\n' % zoneinfo.pszDataFile)
271 if typeid != dnsserver.DNSSRV_TYPEID_ZONE_INFO:
272 outf.write(' aipMasters : %s\n' %
273 ip4_array_string(zoneinfo.aipMasters))
274 else:
275 outf.write(' aipMasters : %s\n' %
276 dns_addr_array_string(zoneinfo.aipMasters))
277 outf.write(' fSecureSecondaries : %s\n' % zone_secondary_security_string(zoneinfo.fSecureSecondaries))
278 outf.write(' fNotifyLevel : %s\n' % zone_notify_level_string(zoneinfo.fNotifyLevel))
279 if typeid != dnsserver.DNSSRV_TYPEID_ZONE_INFO:
280 outf.write(' aipSecondaries : %s\n' %
281 ip4_array_string(zoneinfo.aipSecondaries))
282 outf.write(' aipNotify : %s\n' %
283 ip4_array_string(zoneinfo.aipNotify))
284 else:
285 outf.write(' aipSecondaries : %s\n' %
286 dns_addr_array_string(zoneinfo.aipSecondaries))
287 outf.write(' aipNotify : %s\n' %
288 dns_addr_array_string(zoneinfo.aipNotify))
289 outf.write(' fUseWins : %s\n' % bool_string(zoneinfo.fUseWins))
290 outf.write(' fUseNbstat : %s\n' % bool_string(zoneinfo.fUseNbstat))
291 outf.write(' fAging : %s\n' % bool_string(zoneinfo.fAging))
292 outf.write(' dwNoRefreshInterval : %d\n' % zoneinfo.dwNoRefreshInterval)
293 outf.write(' dwRefreshInterval : %d\n' % zoneinfo.dwRefreshInterval)
294 outf.write(' dwAvailForScavengeTime : %d\n' % zoneinfo.dwAvailForScavengeTime)
295 if typeid != dnsserver.DNSSRV_TYPEID_ZONE_INFO:
296 outf.write(' aipScavengeServers : %s\n' %
297 ip4_array_string(zoneinfo.aipScavengeServers))
298 else:
299 outf.write(' aipScavengeServers : %s\n' %
300 dns_addr_array_string(zoneinfo.aipScavengeServers))
301
302 if typeid != dnsserver.DNSSRV_TYPEID_ZONE_INFO_W2K:
303 outf.write(' dwRpcStructureVersion : 0x%x\n' % zoneinfo.dwRpcStructureVersion)
304 outf.write(' dwForwarderTimeout : %d\n' % zoneinfo.dwForwarderTimeout)
305 outf.write(' fForwarderSlave : %d\n' % zoneinfo.fForwarderSlave)
306 if typeid != dnsserver.DNSSRV_TYPEID_ZONE_INFO:
307 outf.write(' aipLocalMasters : %s\n' %
308 ip4_array_string(zoneinfo.aipLocalMasters))
309 else:
310 outf.write(' aipLocalMasters : %s\n' %
311 dns_addr_array_string(zoneinfo.aipLocalMasters))
312 outf.write(' dwDpFlags : %s\n' % dp_flags_string(zoneinfo.dwDpFlags))
313 outf.write(' pszDpFqdn : %s\n' % zoneinfo.pszDpFqdn)
314 outf.write(' pwszZoneDn : %s\n' % zoneinfo.pwszZoneDn)
315 outf.write(' dwLastSuccessfulSoaCheck : %d\n' % zoneinfo.dwLastSuccessfulSoaCheck)
316 outf.write(' dwLastSuccessfulXfr : %d\n' % zoneinfo.dwLastSuccessfulXfr)
317
318 if typeid == dnsserver.DNSSRV_TYPEID_ZONE_INFO:
319 outf.write(' fQueuedForBackgroundLoad : %s\n' % bool_string(zoneinfo.fQueuedForBackgroundLoad))
320 outf.write(' fBackgroundLoadInProgress : %s\n' % bool_string(zoneinfo.fBackgroundLoadInProgress))
321 outf.write(' fReadOnlyZone : %s\n' % bool_string(zoneinfo.fReadOnlyZone))
322 outf.write(' dwLastXfrAttempt : %d\n' % zoneinfo.dwLastXfrAttempt)
323 outf.write(' dwLastXfrResult : %d\n' % zoneinfo.dwLastXfrResult)
324
325
326 def print_zone(outf, typeid, zone):
327 outf.write(' pszZoneName : %s\n' % zone.pszZoneName)
328 outf.write(' Flags : %s\n' % zone_flags_string(zone.Flags))
329 outf.write(' ZoneType : %s\n' % zone_type_string(zone.ZoneType))
330 outf.write(' Version : %s\n' % zone.Version)
331
332 if typeid != dnsserver.DNSSRV_TYPEID_ZONE_W2K:
333 outf.write(' dwDpFlags : %s\n' % dp_flags_string(zone.dwDpFlags))
334 outf.write(' pszDpFqdn : %s\n' % zone.pszDpFqdn)
335
336
337 def print_enumzones(outf, typeid, zones):
338 outf.write(' %d zone(s) found\n' % zones.dwZoneCount)
339 for zone in zones.ZoneArray:
340 outf.write('\n')
341 print_zone(outf, typeid, zone)
342
343
344 def print_dns_record(outf, rec):
345 if rec.wType == dnsp.DNS_TYPE_A:
346 mesg = 'A: %s' % (rec.data)
347 elif rec.wType == dnsp.DNS_TYPE_AAAA:
348 mesg = 'AAAA: %s' % (rec.data)
349 elif rec.wType == dnsp.DNS_TYPE_PTR:
350 mesg = 'PTR: %s' % (rec.data.str)
351 elif rec.wType == dnsp.DNS_TYPE_NS:
352 mesg = 'NS: %s' % (rec.data.str)
353 elif rec.wType == dnsp.DNS_TYPE_CNAME:
354 mesg = 'CNAME: %s' % (rec.data.str)
355 elif rec.wType == dnsp.DNS_TYPE_SOA:
356 mesg = 'SOA: serial=%d, refresh=%d, retry=%d, expire=%d, ns=%s, email=%s' % (
357 rec.data.dwSerialNo,
358 rec.data.dwRefresh,
359 rec.data.dwRetry,
360 rec.data.dwExpire,
361 rec.data.NamePrimaryServer.str,
362 rec.data.ZoneAdministratorEmail.str)
363 elif rec.wType == dnsp.DNS_TYPE_MX:
364 mesg = 'MX: %s (%d)' % (rec.data.nameExchange.str, rec.data.wPreference)
365 elif rec.wType == dnsp.DNS_TYPE_SRV:
366 mesg = 'SRV: %s (%d, %d, %d)' % (rec.data.nameTarget.str, rec.data.wPort,
367 rec.data.wPriority, rec.data.wWeight)
368 elif rec.wType == dnsp.DNS_TYPE_TXT:
369 slist = ['"%s"' % name.str for name in rec.data.str]
370 mesg = 'TXT: %s' % ','.join(slist)
371 else:
372 mesg = 'Unknown: '
373 outf.write(' %s (flags=%x, serial=%d, ttl=%d)\n' % (
374 mesg, rec.dwFlags, rec.dwSerial, rec.dwTtlSeconds))
375
376
377 def print_dnsrecords(outf, records):
378 for rec in records.rec:
379 outf.write(' Name=%s, Records=%d, Children=%d\n' % (
380 rec.dnsNodeName.str,
381 rec.wRecordCount,
382 rec.dwChildCount))
383 for dns_rec in rec.records:
384 print_dns_record(outf, dns_rec)
385
386
387 #
388 # Always create a copy of strings when creating DNS_RPC_RECORDs
389 # to overcome the bug in pidl generated python bindings.
390 #
391
392 class ARecord(dnsserver.DNS_RPC_RECORD):
393 def __init__(self, ip_addr, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE,
394 node_flag=0):
395 super(ARecord, self).__init__()
396 self.wType = dnsp.DNS_TYPE_A
397 self.dwFlags = rank | node_flag
398 self.dwSerial = serial
399 self.dwTtlSeconds = ttl
400 self._ip_addr = ip_addr[:]
401 self.data = self._ip_addr
402
403
404 class AAAARecord(dnsserver.DNS_RPC_RECORD):
405
406 def __init__(self, ip6_addr, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE,
407 node_flag=0):
408 super(AAAARecord, self).__init__()
409 self.wType = dnsp.DNS_TYPE_AAAA
410 self.dwFlags = rank | node_flag
411 self.dwSerial = serial
412 self.dwTtlSeconds = ttl
413 self._ip6_addr = ip6_addr[:]
414 self.data = self._ip6_addr
415
416
417 class PTRRecord(dnsserver.DNS_RPC_RECORD):
418
419 def __init__(self, ptr, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE,
420 node_flag=0):
421 super(PTRRecord, self).__init__()
422 self.wType = dnsp.DNS_TYPE_PTR
423 self.dwFlags = rank | node_flag
424 self.dwSerial = serial
425 self.dwTtleSeconds = ttl
426 self._ptr = ptr[:]
427 ptr_name = dnsserver.DNS_RPC_NAME()
428 ptr_name.str = self._ptr
429 ptr_name.len = len(ptr)
430 self.data = ptr_name
431
432
433 class CNameRecord(dnsserver.DNS_RPC_RECORD):
434
435 def __init__(self, cname, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE,
436 node_flag=0):
437 super(CNameRecord, self).__init__()
438 self.wType = dnsp.DNS_TYPE_CNAME
439 self.dwFlags = rank | node_flag
440 self.dwSerial = serial
441 self.dwTtlSeconds = ttl
442 self._cname = cname[:]
443 cname_name = dnsserver.DNS_RPC_NAME()
444 cname_name.str = self._cname
445 cname_name.len = len(cname)
446 self.data = cname_name
447
448
449 class NSRecord(dnsserver.DNS_RPC_RECORD):
450
451 def __init__(self, dns_server, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE,
452 node_flag=0):
453 super(NSRecord, self).__init__()
454 self.wType = dnsp.DNS_TYPE_NS
455 self.dwFlags = rank | node_flag
456 self.dwSerial = serial
457 self.dwTtlSeconds = ttl
458 self._dns_server = dns_server[:]
459 ns = dnsserver.DNS_RPC_NAME()
460 ns.str = self._dns_server
461 ns.len = len(dns_server)
462 self.data = ns
463
464
465 class MXRecord(dnsserver.DNS_RPC_RECORD):
466
467 def __init__(self, mail_server, preference, serial=1, ttl=900,
468 rank=dnsp.DNS_RANK_ZONE, node_flag=0):
469 super(MXRecord, self).__init__()
470 self.wType = dnsp.DNS_TYPE_MX
471 self.dwFlags = rank | node_flag
472 self.dwSerial = serial
473 self.dwTtlSeconds = ttl
474 self._mail_server = mail_server[:]
475 mx = dnsserver.DNS_RPC_RECORD_NAME_PREFERENCE()
476 mx.wPreference = preference
477 mx.nameExchange.str = self._mail_server
478 mx.nameExchange.len = len(mail_server)
479 self.data = mx
480
481
482 class SOARecord(dnsserver.DNS_RPC_RECORD):
483
484 def __init__(self, mname, rname, serial=1, refresh=900, retry=600,
485 expire=86400, minimum=3600, ttl=3600, rank=dnsp.DNS_RANK_ZONE,
486 node_flag=dnsp.DNS_RPC_FLAG_AUTH_ZONE_ROOT):
487 super(SOARecord, self).__init__()
488 self.wType = dnsp.DNS_TYPE_SOA
489 self.dwFlags = rank | node_flag
490 self.dwSerial = serial
491 self.dwTtlSeconds = ttl
492 self._mname = mname[:]
493 self._rname = rname[:]
494 soa = dnsserver.DNS_RPC_RECORD_SOA()
495 soa.dwSerialNo = serial
496 soa.dwRefresh = refresh
497 soa.dwRetry = retry
498 soa.dwExpire = expire
499 soa.NamePrimaryServer.str = self._mname
500 soa.NamePrimaryServer.len = len(mname)
501 soa.ZoneAdministratorEmail.str = self._rname
502 soa.ZoneAdministratorEmail.len = len(rname)
503 self.data = soa
504
505
506 class SRVRecord(dnsserver.DNS_RPC_RECORD):
507
508 def __init__(self, target, port, priority=0, weight=100, serial=1, ttl=900,
509 rank=dnsp.DNS_RANK_ZONE, node_flag=0):
510 super(SRVRecord, self).__init__()
511 self.wType = dnsp.DNS_TYPE_SRV
512 self.dwFlags = rank | node_flag
513 self.dwSerial = serial
514 self.dwTtlSeconds = ttl
515 self._target = target[:]
516 srv = dnsserver.DNS_RPC_RECORD_SRV()
517 srv.wPriority = priority
518 srv.wWeight = weight
519 srv.wPort = port
520 srv.nameTarget.str = self._target
521 srv.nameTarget.len = len(target)
522 self.data = srv
523
524
525 class TXTRecord(dnsserver.DNS_RPC_RECORD):
526
527 def __init__(self, slist, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE,
528 node_flag=0):
529 super(TXTRecord, self).__init__()
530 self.wType = dnsp.DNS_TYPE_TXT
531 self.dwFlags = rank | node_flag
532 self.dwSerial = serial
533 self.dwTtlSeconds = ttl
534 self._slist = []
535 for s in slist:
536 self._slist.append(s[:])
537 names = []
538 for s in self._slist:
539 name = dnsserver.DNS_RPC_NAME()
540 name.str = s
541 name.len = len(s)
542 names.append(name)
543 txt = dnsserver.DNS_RPC_RECORD_STRING()
544 txt.count = len(slist)
545 txt.str = names
546 self.data = txt
547
548
549 # Convert data into a dns record
550 def data_to_dns_record(record_type, data):
551 if record_type == dnsp.DNS_TYPE_A:
552 rec = ARecord(data)
553 elif record_type == dnsp.DNS_TYPE_AAAA:
554 rec = AAAARecord(data)
555 elif record_type == dnsp.DNS_TYPE_PTR:
556 rec = PTRRecord(data)
557 elif record_type == dnsp.DNS_TYPE_CNAME:
558 rec = CNameRecord(data)
559 elif record_type == dnsp.DNS_TYPE_NS:
560 rec = NSRecord(data)
561 elif record_type == dnsp.DNS_TYPE_MX:
562 tmp = data.split(' ')
563 if len(tmp) != 2:
564 raise CommandError('Data requires 2 elements - mail_server, preference')
565 mail_server = tmp[0]
566 preference = int(tmp[1])
567 rec = MXRecord(mail_server, preference)
568 elif record_type == dnsp.DNS_TYPE_SRV:
569 tmp = data.split(' ')
570 if len(tmp) != 4:
571 raise CommandError('Data requires 4 elements - server, port, priority, weight')
572 server = tmp[0]
573 port = int(tmp[1])
574 priority = int(tmp[2])
575 weight = int(tmp[3])
576 rec = SRVRecord(server, port, priority=priority, weight=weight)
577 elif record_type == dnsp.DNS_TYPE_SOA:
578 tmp = data.split(' ')
579 if len(tmp) != 7:
580 raise CommandError('Data requires 7 elements - nameserver, email, serial, '
581 'refresh, retry, expire, minimumttl')
582 nameserver = tmp[0]
583 email = tmp[1]
584 serial = int(tmp[2])
585 refresh = int(tmp[3])
586 retry = int(tmp[4])
587 expire = int(tmp[5])
588 minimum = int(tmp[6])
589 rec = SOARecord(nameserver, email, serial=serial, refresh=refresh,
590 retry=retry, expire=expire, minimum=minimum)
591 elif record_type == dnsp.DNS_TYPE_TXT:
592 slist = shlex.split(data)
593 rec = TXTRecord(slist)
594 else:
595 raise CommandError('Unsupported record type')
596 return rec
597
598
599 # Match dns name (of type DNS_RPC_NAME)
600 def dns_name_equal(n1, n2):
601 return n1.str.rstrip('.').lower() == n2.str.rstrip('.').lower()
602
603
604 # Match a dns record with specified data
605 def dns_record_match(dns_conn, server, zone, name, record_type, data):
606 urec = data_to_dns_record(record_type, data)
607
608 select_flags = dnsserver.DNS_RPC_VIEW_AUTHORITY_DATA
609
610 try:
611 buflen, res = dns_conn.DnssrvEnumRecords2(
612 dnsserver.DNS_CLIENT_VERSION_LONGHORN, 0, server, zone, name, None,
613 record_type, select_flags, None, None)
614 except RuntimeError, e:
615 return None
616
617 if not res or res.count == 0:
618 return None
619
620 rec_match = None
621 for rec in res.rec[0].records:
622 if rec.wType != record_type:
623 continue
624
625 found = False
626 if record_type == dnsp.DNS_TYPE_A:
627 if rec.data == urec.data:
628 found = True
629 elif record_type == dnsp.DNS_TYPE_AAAA:
630 if rec.data == urec.data:
631 found = True
632 elif record_type == dnsp.DNS_TYPE_PTR:
633 if dns_name_equal(rec.data, urec.data):
634 found = True
635 elif record_type == dnsp.DNS_TYPE_CNAME:
636 if dns_name_equal(rec.data, urec.data):
637 found = True
638 elif record_type == dnsp.DNS_TYPE_NS:
639 if dns_name_equal(rec.data, urec.data):
640 found = True
641 elif record_type == dnsp.DNS_TYPE_MX:
642 if dns_name_equal(rec.data.nameExchange, urec.data.nameExchange) and \
643 rec.data.wPreference == urec.data.wPreference:
644 found = True
645 elif record_type == dnsp.DNS_TYPE_SRV:
646 if rec.data.wPriority == urec.data.wPriority and \
647 rec.data.wWeight == urec.data.wWeight and \
648 rec.data.wPort == urec.data.wPort and \
649 dns_name_equal(rec.data.nameTarget, urec.data.nameTarget):
650 found = True
651 elif record_type == dnsp.DNS_TYPE_SOA:
652 if rec.data.dwSerialNo == urec.data.dwSerialNo and \
653 rec.data.dwRefresh == urec.data.dwRefresh and \
654 rec.data.dwRetry == urec.data.dwRetry and \
655 rec.data.dwExpire == urec.data.dwExpire and \
656 rec.data.dwMinimumTtl == urec.data.dwMinimumTtl and \
657 dns_name_equal(rec.data.NamePrimaryServer,
658 urec.data.NamePrimaryServer) and \
659 dns_name_equal(rec.data.ZoneAdministratorEmail,
660 urec.data.ZoneAdministratorEmail):
661 found = True
662 elif record_type == dnsp.DNS_TYPE_TXT:
663 if rec.data.count == urec.data.count:
664 found = True
665 for i in xrange(rec.data.count):
666 found = found and \
667 (rec.data.str[i].str == urec.data.str[i].str)
668
669 if found:
670 rec_match = rec
671 break
672
673 return rec_match
674
675
676 class cmd_serverinfo(Command):
677 """Query for Server information."""
678
679 synopsis = '%prog <server> [options]'
680
681 takes_args = [ 'server' ]
682
683 takes_optiongroups = {
684 "sambaopts": options.SambaOptions,
685 "versionopts": options.VersionOptions,
686 "credopts": options.CredentialsOptions,
687 }
688
689 takes_options = [
690 Option('--client-version', help='Client Version',
691 default='longhorn', metavar='w2k|dotnet|longhorn',
692 choices=['w2k','dotnet','longhorn'], dest='cli_ver'),
693 ]
694
695 def run(self, server, cli_ver, sambaopts=None, credopts=None,
696 versionopts=None):
697 self.lp = sambaopts.get_loadparm()
698 self.creds = credopts.get_credentials(self.lp)
699 dns_conn = dns_connect(server, self.lp, self.creds)
700
701 client_version = dns_client_version(cli_ver)
702
703 typeid, res = dns_conn.DnssrvQuery2(client_version, 0, server,
704 None, 'ServerInfo')
705 print_serverinfo(self.outf, typeid, res)
706
707
708 class cmd_zoneinfo(Command):
709 """Query for zone information."""
710
711 synopsis = '%prog <server> <zone> [options]'
712
713 takes_args = [ 'server', 'zone' ]
714
715 takes_optiongroups = {
716 "sambaopts": options.SambaOptions,
717 "versionopts": options.VersionOptions,
718 "credopts": options.CredentialsOptions,
719 }
720
721 takes_options = [
722 Option('--client-version', help='Client Version',
723 default='longhorn', metavar='w2k|dotnet|longhorn',
724 choices=['w2k','dotnet','longhorn'], dest='cli_ver'),
725 ]
726
727 def run(self, server, zone, cli_ver, sambaopts=None, credopts=None,
728 versionopts=None):
729 self.lp = sambaopts.get_loadparm()
730 self.creds = credopts.get_credentials(self.lp)
731 dns_conn = dns_connect(server, self.lp, self.creds)
732
733 client_version = dns_client_version(cli_ver)
734
735 typeid, res = dns_conn.DnssrvQuery2(client_version, 0, server, zone,
736 'ZoneInfo')
737 print_zoneinfo(self.outf, typeid, res)
738
739
740 class cmd_zonelist(Command):
741 """Query for zones."""
742
743 synopsis = '%prog <server> [options]'
744
745 takes_args = [ 'server' ]
746
747 takes_optiongroups = {
748 "sambaopts": options.SambaOptions,
749 "versionopts": options.VersionOptions,
750 "credopts": options.CredentialsOptions,
751 }
752
753 takes_options = [
754 Option('--client-version', help='Client Version',
755 default='longhorn', metavar='w2k|dotnet|longhorn',
756 choices=['w2k','dotnet','longhorn'], dest='cli_ver'),
757 Option('--primary', help='List primary zones (default)',
758 action='store_true', dest='primary'),
759 Option('--secondary', help='List secondary zones',
760 action='store_true', dest='secondary'),
761 Option('--cache', help='List cached zones',
762 action='store_true', dest='cache'),
763 Option('--auto', help='List automatically created zones',
764 action='store_true', dest='auto'),
765 Option('--forward', help='List forward zones',
766 action='store_true', dest='forward'),
767 Option('--reverse', help='List reverse zones',
768 action='store_true', dest='reverse'),
769 Option('--ds', help='List directory integrated zones',
770 action='store_true', dest='ds'),
771 Option('--non-ds', help='List non-directory zones',
772 action='store_true', dest='nonds')
773 ]
774
775 def run(self, server, cli_ver, primary=False, secondary=False, cache=False,
776 auto=False, forward=False, reverse=False, ds=False, nonds=False,
777 sambaopts=None, credopts=None, versionopts=None):
778 request_filter = 0
779
780 if primary:
781 request_filter |= dnsserver.DNS_ZONE_REQUEST_PRIMARY
782 if secondary:
783 request_filter |= dnsserver.DNS_ZONE_REQUEST_SECONDARY
784 if cache:
785 request_filter |= dnsserver.DNS_ZONE_REQUEST_CACHE
786 if auto:
787 request_filter |= dnsserver.DNS_ZONE_REQUEST_AUTO
788 if forward:
789 request_filter |= dnsserver.DNS_ZONE_REQUEST_FORWARD
790 if reverse:
791 request_filter |= dnsserver.DNS_ZONE_REQUEST_REVERSE
792 if ds:
793 request_filter |= dnsserver.DNS_ZONE_REQUEST_DS
794 if nonds:
795 request_filter |= dnsserver.DNS_ZONE_REQUEST_NON_DS
796
797 if request_filter == 0:
798 request_filter = dnsserver.DNS_ZONE_REQUEST_PRIMARY
799
800 self.lp = sambaopts.get_loadparm()
801 self.creds = credopts.get_credentials(self.lp)
802 dns_conn = dns_connect(server, self.lp, self.creds)
803
804 client_version = dns_client_version(cli_ver)
805
806 typeid, res = dns_conn.DnssrvComplexOperation2(client_version,
807 0, server, None,
808 'EnumZones',
809 dnsserver.DNSSRV_TYPEID_DWORD,
810 request_filter)
811
812 if client_version == dnsserver.DNS_CLIENT_VERSION_W2K:
813 typeid = dnsserver.DNSSRV_TYPEID_ZONE_W2K
814 else:
815 typeid = dnsserver.DNSSRV_TYPEID_ZONE
816 print_enumzones(self.outf, typeid, res)
817
818
819 class cmd_zonecreate(Command):
820 """Create a zone."""
821
822 synopsis = '%prog <server> <zone> [options]'
823
824 takes_args = [ 'server', 'zone' ]
825
826 takes_optiongroups = {
827 "sambaopts": options.SambaOptions,
828 "versionopts": options.VersionOptions,
829 "credopts": options.CredentialsOptions,
830 }
831
832 takes_options = [
833 Option('--client-version', help='Client Version',
834 default='longhorn', metavar='w2k|dotnet|longhorn',
835 choices=['w2k','dotnet','longhorn'], dest='cli_ver')
836 ]
837
838 def run(self, server, zone, cli_ver, sambaopts=None, credopts=None,
839 versionopts=None):
840
841 self.lp = sambaopts.get_loadparm()
842 self.creds = credopts.get_credentials(self.lp)
843 dns_conn = dns_connect(server, self.lp, self.creds)
844
845 zone = zone.lower()
846
847 client_version = dns_client_version(cli_ver)
848 if client_version == dnsserver.DNS_CLIENT_VERSION_W2K:
849 typeid = dnsserver.DNSSRV_TYPEID_ZONE_CREATE_W2K
850 zone_create_info = dnsserver.DNS_RPC_ZONE_CREATE_INFO_W2K()
851 zone_create_info.pszZoneName = zone
852 zone_create_info.dwZoneType = dnsp.DNS_ZONE_TYPE_PRIMARY
853 zone_create_info.fAllowUpdate = dnsp.DNS_ZONE_UPDATE_SECURE
854 zone_create_info.fAging = 0
855 elif client_version == dnsserver.DNS_CLIENT_VERSION_DOTNET:
856 typeid = dnsserver.DNSSRV_TYPEID_ZONE_CREATE_DOTNET
857 zone_create_info = dnsserver.DNS_RPC_ZONE_CREATE_INFO_DOTNET()
858 zone_create_info.pszZoneName = zone
859 zone_create_info.dwZoneType = dnsp.DNS_ZONE_TYPE_PRIMARY
860 zone_create_info.fAllowUpdate = dnsp.DNS_ZONE_UPDATE_SECURE
861 zone_create_info.fAging = 0
862 zone_create_info.dwDpFlags = dnsserver.DNS_DP_DOMAIN_DEFAULT
863 else:
864 typeid = dnsserver.DNSSRV_TYPEID_ZONE_CREATE
865 zone_create_info = dnsserver.DNS_RPC_ZONE_CREATE_INFO_LONGHORN()
866 zone_create_info.pszZoneName = zone
867 zone_create_info.dwZoneType = dnsp.DNS_ZONE_TYPE_PRIMARY
868 zone_create_info.fAllowUpdate = dnsp.DNS_ZONE_UPDATE_SECURE
869 zone_create_info.fAging = 0
870 zone_create_info.dwDpFlags = dnsserver.DNS_DP_DOMAIN_DEFAULT
871
872 res = dns_conn.DnssrvOperation2(client_version, 0, server, None,
873 0, 'ZoneCreate', typeid,
874 zone_create_info)
875 self.outf.write('Zone %s created successfully\n' % zone)
876
877
878 class cmd_zonedelete(Command):
879 """Delete a zone."""
880
881 synopsis = '%prog <server> <zone> [options]'
882
883 takes_args = [ 'server', 'zone' ]
884
885 takes_optiongroups = {
886 "sambaopts": options.SambaOptions,
887 "versionopts": options.VersionOptions,
888 "credopts": options.CredentialsOptions,
889 }
890
891 def run(self, server, zone, sambaopts=None, credopts=None,
892 versionopts=None):
893
894 self.lp = sambaopts.get_loadparm()
895 self.creds = credopts.get_credentials(self.lp)
896 dns_conn = dns_connect(server, self.lp, self.creds)
897
898 zone = zone.lower()
899 res = dns_conn.DnssrvOperation2(dnsserver.DNS_CLIENT_VERSION_LONGHORN,
900 0, server, zone, 0, 'DeleteZoneFromDs',
901 dnsserver.DNSSRV_TYPEID_NULL,
902 None)
903 self.outf.write('Zone %s delete successfully\n' % zone)
904
905
906 class cmd_query(Command):
907 """Query a name."""
908
909 synopsis = '%prog <server> <zone> <name> <A|AAAA|CNAME|MX|NS|SOA|SRV|TXT|ALL> [options]'
910
911 takes_args = [ 'server', 'zone', 'name', 'rtype' ]
912
913 takes_optiongroups = {
914 "sambaopts": options.SambaOptions,
915 "versionopts": options.VersionOptions,
916 "credopts": options.CredentialsOptions,
917 }
918
919 takes_options = [
920 Option('--authority', help='Search authoritative records (default)',
921 action='store_true', dest='authority'),
922 Option('--cache', help='Search cached records',
923 action='store_true', dest='cache'),
924 Option('--glue', help='Search glue records',
925 action='store_true', dest='glue'),
926 Option('--root', help='Search root hints',
927 action='store_true', dest='root'),
928 Option('--additional', help='List additional records',
929 action='store_true', dest='additional'),
930 Option('--no-children', help='Do not list children',
931 action='store_true', dest='no_children'),
932 Option('--only-children', help='List only children',
933 action='store_true', dest='only_children')
934 ]
935
936 def run(self, server, zone, name, rtype, authority=False, cache=False,
937 glue=False, root=False, additional=False, no_children=False,
938 only_children=False, sambaopts=None, credopts=None,
939 versionopts=None):
940 record_type = dns_type_flag(rtype)
941
942 select_flags = 0
943 if authority:
944 select_flags |= dnsserver.DNS_RPC_VIEW_AUTHORITY_DATA
945 if cache:
946 select_flags |= dnsserver.DNS_RPC_VIEW_CACHE_DATA
947 if glue:
948 select_flags |= dnsserver.DNS_RPC_VIEW_GLUE_DATA
949 if root:
950 select_flags |= dnsserver.DNS_RPC_VIEW_ROOT_HINT_DATA
951 if additional:
952 select_flags |= dnsserver.DNS_RPC_VIEW_ADDITIONAL_DATA
953 if no_children:
954 select_flags |= dnsserver.DNS_RPC_VIEW_NO_CHILDREN
955 if only_children:
956 select_flags |= dnsserver.DNS_RPC_VIEW_ONLY_CHILDREN
957
958 if select_flags == 0:
959 select_flags = dnsserver.DNS_RPC_VIEW_AUTHORITY_DATA
960
961 if select_flags == dnsserver.DNS_RPC_VIEW_ADDITIONAL_DATA:
962 self.outf.write('Specify either --authority or --root along with --additional.\n')
963 self.outf.write('Assuming --authority.\n')
964 select_flags |= dnsserver.DNS_RPC_VIEW_AUTHORITY_DATA
965
966 self.lp = sambaopts.get_loadparm()
967 self.creds = credopts.get_credentials(self.lp)
968 dns_conn = dns_connect(server, self.lp, self.creds)
969
970 buflen, res = dns_conn.DnssrvEnumRecords2(
971 dnsserver.DNS_CLIENT_VERSION_LONGHORN, 0, server, zone, name,
972 None, record_type, select_flags, None, None)
973 print_dnsrecords(self.outf, res)
974
975
976 class cmd_roothints(Command):
977 """Query root hints."""
978
979 synopsis = '%prog <server> [<name>] [options]'
980
981 takes_args = [ 'server', 'name?' ]
982
983 takes_optiongroups = {
984 "sambaopts": options.SambaOptions,
985 "versionopts": options.VersionOptions,
986 "credopts": options.CredentialsOptions,
987 }
988
989 def run(self, server, name='.', sambaopts=None, credopts=None,
990 versionopts=None):
991 record_type = dnsp.DNS_TYPE_NS
992 select_flags = (dnsserver.DNS_RPC_VIEW_ROOT_HINT_DATA |
993 dnsserver.DNS_RPC_VIEW_ADDITIONAL_DATA)
994
995 self.lp = sambaopts.get_loadparm()
996 self.creds = credopts.get_credentials(self.lp)
997 dns_conn = dns_connect(server, self.lp, self.creds)
998
999 buflen, res = dns_conn.DnssrvEnumRecords2(
1000 dnsserver.DNS_CLIENT_VERSION_LONGHORN, 0, server, '..RootHints',
1001 name, None, record_type, select_flags, None, None)
1002 print_dnsrecords(self.outf, res)
1003
1004
1005 class cmd_add_record(Command):
1006 """Add a DNS record
1007
1008 For each type data contents are as follows:
1009 A ipv4_address_string
1010 AAAA ipv6_address_string
1011 PTR fqdn_string
1012 CNAME fqdn_string
1013 NS fqdn_string
1014 MX "fqdn_string preference"
1015 SRV "fqdn_string port priority weight"
1016 TXT "'string1' 'string2' ..."
1017 """
1018
1019 synopsis = '%prog <server> <zone> <name> <A|AAAA|PTR|CNAME|NS|MX|SRV|TXT> <data>'
1020
1021 takes_args = [ 'server', 'zone', 'name', 'rtype', 'data' ]
1022
1023 takes_optiongroups = {
1024 "sambaopts": options.SambaOptions,
1025 "versionopts": options.VersionOptions,
1026 "credopts": options.CredentialsOptions,
1027 }
1028
1029 def run(self, server, zone, name, rtype, data, sambaopts=None,
1030 credopts=None, versionopts=None):
1031
1032 if rtype.upper() not in ('A','AAAA','PTR','CNAME','NS','MX','SRV','TXT'):
1033 raise CommandError('Adding record of type %s is not supported' % rtype)
1034
1035 record_type = dns_type_flag(rtype)
1036 rec = data_to_dns_record(record_type, data)
1037
1038 self.lp = sambaopts.get_loadparm()
1039 self.creds = credopts.get_credentials(self.lp)
1040 dns_conn = dns_connect(server, self.lp, self.creds)
1041
1042 rec_match = dns_record_match(dns_conn, server, zone, name, record_type,
1043 data)
1044 if rec_match is not None:
1045 raise CommandError('Record already exists')
1046
1047 add_rec_buf = dnsserver.DNS_RPC_RECORD_BUF()
1048 add_rec_buf.rec = rec
1049
1050 dns_conn.DnssrvUpdateRecord2(dnsserver.DNS_CLIENT_VERSION_LONGHORN,
1051 0, server, zone, name, add_rec_buf, None)
1052 self.outf.write('Record added successfully\n')
1053
1054
1055 class cmd_update_record(Command):
1056 """Update a DNS record
1057
1058 For each type data contents are as follows:
1059 A ipv4_address_string
1060 AAAA ipv6_address_string
1061 PTR fqdn_string
1062 CNAME fqdn_string
1063 NS fqdn_string
1064 MX "fqdn_string preference"
1065 SRV "fqdn_string port priority weight"
1066 TXT "'string1' 'string2' ..."
1067 """
1068
1069 synopsis = '%prog <server> <zone> <name> <A|AAAA|PTR|CNAME|NS|MX|SRV|TXT> <olddata> <newdata>'
1070
1071 takes_args = [ 'server', 'zone', 'name', 'rtype', 'olddata', 'newdata' ]
1072
1073 takes_optiongroups = {
1074 "sambaopts": options.SambaOptions,
1075 "versionopts": options.VersionOptions,
1076 "credopts": options.CredentialsOptions,
1077 }
1078
1079 def run(self, server, zone, name, rtype, olddata, newdata,
1080 sambaopts=None, credopts=None, versionopts=None):
1081
1082 if rtype.upper() not in ('A','AAAA','PTR','CNAME','NS','MX','SRV','TXT'):
1083 raise CommandError('Updating record of type %s is not supported' % rtype)
1084
1085 record_type = dns_type_flag(rtype)
1086 rec = data_to_dns_record(record_type, newdata)
1087
1088 self.lp = sambaopts.get_loadparm()
1089 self.creds = credopts.get_credentials(self.lp)
1090 dns_conn = dns_connect(server, self.lp, self.creds)
1091
1092 rec_match = dns_record_match(dns_conn, server, zone, name, record_type,
1093 olddata)
1094 if not rec_match:
1095 raise CommandError('Record does not exist')
1096
1097 # Copy properties from existing record to new record
1098 rec.dwFlags = rec_match.dwFlags
1099 rec.dwSerial = rec_match.dwSerial
1100 rec.dwTtlSeconds = rec_match.dwTtlSeconds
1101 rec.dwTimeStamp = rec_match.dwTimeStamp
1102
1103 add_rec_buf = dnsserver.DNS_RPC_RECORD_BUF()
1104 add_rec_buf.rec = rec
1105
1106 del_rec_buf = dnsserver.DNS_RPC_RECORD_BUF()
1107 del_rec_buf.rec = rec_match
1108
1109 dns_conn.DnssrvUpdateRecord2(dnsserver.DNS_CLIENT_VERSION_LONGHORN,
1110 0,
1111 server,
1112 zone,
1113 name,
1114 add_rec_buf,
1115 del_rec_buf)
1116 self.outf.write('Record updated succefully\n')
1117
1118
1119 class cmd_delete_record(Command):
1120 """Delete a DNS record
1121
1122 For each type data contents are as follows:
1123 A ipv4_address_string
1124 AAAA ipv6_address_string
1125 PTR fqdn_string
1126 CNAME fqdn_string
1127 NS fqdn_string
1128 MX "fqdn_string preference"
1129 SRV "fqdn_string port priority weight"
1130 TXT "'string1' 'string2' ..."
1131 """
1132
1133 synopsis = '%prog <server> <zone> <name> <A|AAAA|PTR|CNAME|NS|MX|SRV|TXT> <data>'
1134
1135 takes_args = [ 'server', 'zone', 'name', 'rtype', 'data' ]
1136
1137 takes_optiongroups = {
1138 "sambaopts": options.SambaOptions,
1139 "versionopts": options.VersionOptions,
1140 "credopts": options.CredentialsOptions,
1141 }
1142
1143 def run(self, server, zone, name, rtype, data, sambaopts=None, credopts=None, versionopts=None):
1144
1145 if rtype.upper() not in ('A','AAAA','PTR','CNAME','NS','MX','SRV','TXT'):
1146 raise CommandError('Deleting record of type %s is not supported' % rtype)
1147
1148 record_type = dns_type_flag(rtype)
1149
1150 self.lp = sambaopts.get_loadparm()
1151 self.creds = credopts.get_credentials(self.lp)
1152 dns_conn = dns_connect(server, self.lp, self.creds)
1153
1154 rec_match = dns_record_match(dns_conn, server, zone, name, record_type, data)
1155 if not rec_match:
1156 raise CommandError('Record does not exist')
1157
1158 del_rec_buf = dnsserver.DNS_RPC_RECORD_BUF()
1159 del_rec_buf.rec = rec_match
1160
1161 dns_conn.DnssrvUpdateRecord2(dnsserver.DNS_CLIENT_VERSION_LONGHORN,
1162 0,
1163 server,
1164 zone,
1165 name,
1166 None,
1167 del_rec_buf)
1168 self.outf.write('Record deleted succefully\n')
1169
1170
1171 class cmd_dns(SuperCommand):
1172 """Domain Name Service (DNS) management."""
1173
1174 subcommands = {}
1175 subcommands['serverinfo'] = cmd_serverinfo()
1176 subcommands['zoneinfo'] = cmd_zoneinfo()
1177 subcommands['zonelist'] = cmd_zonelist()
1178 subcommands['zonecreate'] = cmd_zonecreate()
1179 subcommands['zonedelete'] = cmd_zonedelete()
1180 subcommands['query'] = cmd_query()
1181 subcommands['roothints'] = cmd_roothints()
1182 subcommands['add'] = cmd_add_record()
1183 subcommands['update'] = cmd_update_record()
1184 subcommands['delete'] = cmd_delete_record()
reg import