3 # Copyright (C) Amitay Isaacs 2011-2012
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.
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.
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/>.
19 import samba
.getopt
as options
20 from struct
import pack
21 from socket
import inet_ntoa
24 from samba
.netcmd
import (
30 from samba
.dcerpc
import dnsp
, dnsserver
33 def dns_connect(server
, lp
, creds
):
34 if server
.lower() == 'localhost':
36 binding_str
= "ncacn_ip_tcp:%s[sign]" % server
37 dns_conn
= dnsserver
.dnsserver(binding_str
, lp
, creds
)
41 def bool_string(flag
):
47 ret
= 'UNKNOWN (0x%x)' % flag
51 def enum_string(module
, enum_defs
, value
):
54 if value
== getattr(module
, e
):
58 ret
= 'UNKNOWN (0x%x)' % value
62 def bitmap_string(module
, bitmap_defs
, value
):
65 if value
& getattr(module
, b
):
72 def boot_method_string(boot_method
):
73 enum_defs
= [ 'DNS_BOOT_METHOD_UNINITIALIZED', 'DNS_BOOT_METHOD_FILE',
74 'DNS_BOOT_METHOD_REGISTRY', 'DNS_BOOT_METHOD_DIRECTORY' ]
75 return enum_string(dnsserver
, enum_defs
, boot_method
)
78 def name_check_flag_string(check_flag
):
79 enum_defs
= [ 'DNS_ALLOW_RFC_NAMES_ONLY', 'DNS_ALLOW_NONRFC_NAMES',
80 'DNS_ALLOW_MULTIBYTE_NAMES', 'DNS_ALLOW_ALL_NAMES' ]
81 return enum_string(dnsserver
, enum_defs
, check_flag
)
84 def zone_type_string(zone_type
):
85 enum_defs
= [ 'DNS_ZONE_TYPE_CACHE', 'DNS_ZONE_TYPE_PRIMARY',
86 'DNS_ZONE_TYPE_SECONDARY', 'DNS_ZONE_TYPE_STUB',
87 'DNS_ZONE_TYPE_FORWARDER', 'DNS_ZONE_TYPE_SECONDARY_CACHE' ]
88 return enum_string(dnsp
, enum_defs
, zone_type
)
91 def zone_update_string(zone_update
):
92 enum_defs
= [ 'DNS_ZONE_UPDATE_OFF', 'DNS_ZONE_UPDATE_SECURE',
93 'DNS_ZONE_UPDATE_SECURE' ]
94 return enum_string(dnsp
, enum_defs
, zone_update
)
97 def zone_secondary_security_string(security
):
98 enum_defs
= [ 'DNS_ZONE_SECSECURE_NO_SECURITY', 'DNS_ZONE_SECSECURE_NS_ONLY',
99 'DNS_ZONE_SECSECURE_LIST_ONLY', 'DNS_ZONE_SECSECURE_NO_XFER' ]
100 return enum_string(dnsserver
, enum_defs
, security
)
103 def zone_notify_level_string(notify_level
):
104 enum_defs
= [ 'DNS_ZONE_NOTIFY_OFF', 'DNS_ZONE_NOTIFY_ALL_SECONDARIES',
105 'DNS_ZONE_NOTIFY_LIST_ONLY' ]
106 return enum_string(dnsserver
, enum_defs
, notify_level
)
109 def dp_flags_string(dp_flags
):
110 bitmap_defs
= [ 'DNS_DP_AUTOCREATED', 'DNS_DP_LEGACY', 'DNS_DP_DOMAIN_DEFAULT',
111 'DNS_DP_FOREST_DEFAULT', 'DNS_DP_ENLISTED', 'DNS_DP_DELETED' ]
112 return bitmap_string(dnsserver
, bitmap_defs
, dp_flags
)
115 def zone_flags_string(flags
):
116 bitmap_defs
= [ 'DNS_RPC_ZONE_PAUSED', 'DNS_RPC_ZONE_SHUTDOWN',
117 'DNS_RPC_ZONE_REVERSE', 'DNS_RPC_ZONE_AUTOCREATED',
118 'DNS_RPC_ZONE_DSINTEGRATED', 'DNS_RPC_ZONE_AGING',
119 'DNS_RPC_ZONE_UPDATE_UNSECURE', 'DNS_RPC_ZONE_UPDATE_SECURE',
120 'DNS_RPC_ZONE_READONLY']
121 return bitmap_string(dnsserver
, bitmap_defs
, flags
)
124 def ip4_array_string(array
):
128 for i
in xrange(array
.AddrCount
):
129 addr
= '%s' % inet_ntoa(pack('i', array
.AddrArray
[i
]))
134 def dns_addr_array_string(array
):
138 for i
in xrange(array
.AddrCount
):
139 if array
.AddrArray
[i
].MaxSa
[0] == 0x02:
140 addr
= '%d.%d.%d.%d (%d)' % \
141 tuple(array
.AddrArray
[i
].MaxSa
[4:8] + [array
.AddrArray
[i
].MaxSa
[3]])
142 elif array
.AddrArray
[i
].MaxSa
[0] == 0x17:
143 addr
= '%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x (%d)' % \
144 tuple(array
.AddrArray
[i
].MaxSa
[4:20] + [array
.AddrArray
[i
].MaxSa
[3]])
151 def dns_type_flag(rec_type
):
152 rtype
= rec_type
.upper()
154 record_type
= dnsp
.DNS_TYPE_A
155 elif rtype
== 'AAAA':
156 record_type
= dnsp
.DNS_TYPE_AAAA
158 record_type
= dnsp
.DNS_TYPE_PTR
160 record_type
= dnsp
.DNS_TYPE_NS
161 elif rtype
== 'CNAME':
162 record_type
= dnsp
.DNS_TYPE_CNAME
164 record_type
= dnsp
.DNS_TYPE_SOA
166 record_type
= dnsp
.DNS_TYPE_MX
168 record_type
= dnsp
.DNS_TYPE_SRV
170 record_type
= dnsp
.DNS_TYPE_TXT
172 record_type
= dnsp
.DNS_TYPE_ALL
174 raise CommandError('Unknown type of DNS record %s' % rec_type
)
178 def dns_client_version(cli_version
):
179 version
= cli_version
.upper()
181 client_version
= dnsserver
.DNS_CLIENT_VERSION_W2K
182 elif version
== 'DOTNET':
183 client_version
= dnsserver
.DNS_CLIENT_VERSION_DOTNET
184 elif version
== 'LONGHORN':
185 client_version
= dnsserver
.DNS_CLIENT_VERSION_LONGHORN
187 raise CommandError('Unknown client version %s' % cli_version
)
188 return client_version
191 def print_serverinfo(outf
, typeid
, serverinfo
):
192 outf
.write(' dwVersion : 0x%x\n' % serverinfo
.dwVersion
)
193 outf
.write(' fBootMethod : %s\n' % boot_method_string(serverinfo
.fBootMethod
))
194 outf
.write(' fAdminConfigured : %s\n' % bool_string(serverinfo
.fAdminConfigured
))
195 outf
.write(' fAllowUpdate : %s\n' % bool_string(serverinfo
.fAllowUpdate
))
196 outf
.write(' fDsAvailable : %s\n' % bool_string(serverinfo
.fDsAvailable
))
197 outf
.write(' pszServerName : %s\n' % serverinfo
.pszServerName
)
198 outf
.write(' pszDsContainer : %s\n' % serverinfo
.pszDsContainer
)
200 if typeid
!= dnsserver
.DNSSRV_TYPEID_SERVER_INFO
:
201 outf
.write(' aipServerAddrs : %s\n' %
202 ip4_array_string(serverinfo
.aipServerAddrs
))
203 outf
.write(' aipListenAddrs : %s\n' %
204 ip4_array_string(serverinfo
.aipListenAddrs
))
205 outf
.write(' aipForwarders : %s\n' %
206 ip4_array_string(serverinfo
.aipForwarders
))
208 outf
.write(' aipServerAddrs : %s\n' %
209 dns_addr_array_string(serverinfo
.aipServerAddrs
))
210 outf
.write(' aipListenAddrs : %s\n' %
211 dns_addr_array_string(serverinfo
.aipListenAddrs
))
212 outf
.write(' aipForwarders : %s\n' %
213 dns_addr_array_string(serverinfo
.aipForwarders
))
215 outf
.write(' dwLogLevel : %d\n' % serverinfo
.dwLogLevel
)
216 outf
.write(' dwDebugLevel : %d\n' % serverinfo
.dwDebugLevel
)
217 outf
.write(' dwForwardTimeout : %d\n' % serverinfo
.dwForwardTimeout
)
218 outf
.write(' dwRpcPrototol : 0x%x\n' % serverinfo
.dwRpcProtocol
)
219 outf
.write(' dwNameCheckFlag : %s\n' % name_check_flag_string(serverinfo
.dwNameCheckFlag
))
220 outf
.write(' cAddressAnswerLimit : %d\n' % serverinfo
.cAddressAnswerLimit
)
221 outf
.write(' dwRecursionRetry : %d\n' % serverinfo
.dwRecursionRetry
)
222 outf
.write(' dwRecursionTimeout : %d\n' % serverinfo
.dwRecursionTimeout
)
223 outf
.write(' dwMaxCacheTtl : %d\n' % serverinfo
.dwMaxCacheTtl
)
224 outf
.write(' dwDsPollingInterval : %d\n' % serverinfo
.dwDsPollingInterval
)
225 outf
.write(' dwScavengingInterval : %d\n' % serverinfo
.dwScavengingInterval
)
226 outf
.write(' dwDefaultRefreshInterval : %d\n' % serverinfo
.dwDefaultRefreshInterval
)
227 outf
.write(' dwDefaultNoRefreshInterval : %d\n' % serverinfo
.dwDefaultNoRefreshInterval
)
228 outf
.write(' fAutoReverseZones : %s\n' % bool_string(serverinfo
.fAutoReverseZones
))
229 outf
.write(' fAutoCacheUpdate : %s\n' % bool_string(serverinfo
.fAutoCacheUpdate
))
230 outf
.write(' fRecurseAfterForwarding : %s\n' % bool_string(serverinfo
.fRecurseAfterForwarding
))
231 outf
.write(' fForwardDelegations : %s\n' % bool_string(serverinfo
.fForwardDelegations
))
232 outf
.write(' fNoRecursion : %s\n' % bool_string(serverinfo
.fNoRecursion
))
233 outf
.write(' fSecureResponses : %s\n' % bool_string(serverinfo
.fSecureResponses
))
234 outf
.write(' fRoundRobin : %s\n' % bool_string(serverinfo
.fRoundRobin
))
235 outf
.write(' fLocalNetPriority : %s\n' % bool_string(serverinfo
.fLocalNetPriority
))
236 outf
.write(' fBindSecondaries : %s\n' % bool_string(serverinfo
.fBindSecondaries
))
237 outf
.write(' fWriteAuthorityNs : %s\n' % bool_string(serverinfo
.fWriteAuthorityNs
))
238 outf
.write(' fStrictFileParsing : %s\n' % bool_string(serverinfo
.fStrictFileParsing
))
239 outf
.write(' fLooseWildcarding : %s\n' % bool_string(serverinfo
.fLooseWildcarding
))
240 outf
.write(' fDefaultAgingState : %s\n' % bool_string(serverinfo
.fDefaultAgingState
))
242 if typeid
!= dnsserver
.DNSSRV_TYPEID_SERVER_INFO_W2K
:
243 outf
.write(' dwRpcStructureVersion : 0x%x\n' % serverinfo
.dwRpcStructureVersion
)
244 outf
.write(' aipLogFilter : %s\n' % dns_addr_array_string(serverinfo
.aipLogFilter
))
245 outf
.write(' pwszLogFilePath : %s\n' % serverinfo
.pwszLogFilePath
)
246 outf
.write(' pszDomainName : %s\n' % serverinfo
.pszDomainName
)
247 outf
.write(' pszForestName : %s\n' % serverinfo
.pszForestName
)
248 outf
.write(' pszDomainDirectoryPartition : %s\n' % serverinfo
.pszDomainDirectoryPartition
)
249 outf
.write(' pszForestDirectoryPartition : %s\n' % serverinfo
.pszForestDirectoryPartition
)
251 outf
.write(' dwLocalNetPriorityNetMask : 0x%x\n' % serverinfo
.dwLocalNetPriorityNetMask
)
252 outf
.write(' dwLastScavengeTime : %d\n' % serverinfo
.dwLastScavengeTime
)
253 outf
.write(' dwEventLogLevel : %d\n' % serverinfo
.dwEventLogLevel
)
254 outf
.write(' dwLogFileMaxSize : %d\n' % serverinfo
.dwLogFileMaxSize
)
255 outf
.write(' dwDsForestVersion : %d\n' % serverinfo
.dwDsForestVersion
)
256 outf
.write(' dwDsDomainVersion : %d\n' % serverinfo
.dwDsDomainVersion
)
257 outf
.write(' dwDsDsaVersion : %d\n' % serverinfo
.dwDsDsaVersion
)
259 if typeid
== dnsserver
.DNSSRV_TYPEID_SERVER_INFO
:
260 outf
.write(' fReadOnlyDC : %s\n' % bool_string(serverinfo
.fReadOnlyDC
))
263 def print_zoneinfo(outf
, typeid
, zoneinfo
):
264 outf
.write(' pszZoneName : %s\n' % zoneinfo
.pszZoneName
)
265 outf
.write(' dwZoneType : %s\n' % zone_type_string(zoneinfo
.dwZoneType
))
266 outf
.write(' fReverse : %s\n' % bool_string(zoneinfo
.fReverse
))
267 outf
.write(' fAllowUpdate : %s\n' % zone_update_string(zoneinfo
.fAllowUpdate
))
268 outf
.write(' fPaused : %s\n' % bool_string(zoneinfo
.fPaused
))
269 outf
.write(' fShutdown : %s\n' % bool_string(zoneinfo
.fShutdown
))
270 outf
.write(' fAutoCreated : %s\n' % bool_string(zoneinfo
.fAutoCreated
))
271 outf
.write(' fUseDatabase : %s\n' % bool_string(zoneinfo
.fUseDatabase
))
272 outf
.write(' pszDataFile : %s\n' % zoneinfo
.pszDataFile
)
273 if typeid
!= dnsserver
.DNSSRV_TYPEID_ZONE_INFO
:
274 outf
.write(' aipMasters : %s\n' %
275 ip4_array_string(zoneinfo
.aipMasters
))
277 outf
.write(' aipMasters : %s\n' %
278 dns_addr_array_string(zoneinfo
.aipMasters
))
279 outf
.write(' fSecureSecondaries : %s\n' % zone_secondary_security_string(zoneinfo
.fSecureSecondaries
))
280 outf
.write(' fNotifyLevel : %s\n' % zone_notify_level_string(zoneinfo
.fNotifyLevel
))
281 if typeid
!= dnsserver
.DNSSRV_TYPEID_ZONE_INFO
:
282 outf
.write(' aipSecondaries : %s\n' %
283 ip4_array_string(zoneinfo
.aipSecondaries
))
284 outf
.write(' aipNotify : %s\n' %
285 ip4_array_string(zoneinfo
.aipNotify
))
287 outf
.write(' aipSecondaries : %s\n' %
288 dns_addr_array_string(zoneinfo
.aipSecondaries
))
289 outf
.write(' aipNotify : %s\n' %
290 dns_addr_array_string(zoneinfo
.aipNotify
))
291 outf
.write(' fUseWins : %s\n' % bool_string(zoneinfo
.fUseWins
))
292 outf
.write(' fUseNbstat : %s\n' % bool_string(zoneinfo
.fUseNbstat
))
293 outf
.write(' fAging : %s\n' % bool_string(zoneinfo
.fAging
))
294 outf
.write(' dwNoRefreshInterval : %d\n' % zoneinfo
.dwNoRefreshInterval
)
295 outf
.write(' dwRefreshInterval : %d\n' % zoneinfo
.dwRefreshInterval
)
296 outf
.write(' dwAvailForScavengeTime : %d\n' % zoneinfo
.dwAvailForScavengeTime
)
297 if typeid
!= dnsserver
.DNSSRV_TYPEID_ZONE_INFO
:
298 outf
.write(' aipScavengeServers : %s\n' %
299 ip4_array_string(zoneinfo
.aipScavengeServers
))
301 outf
.write(' aipScavengeServers : %s\n' %
302 dns_addr_array_string(zoneinfo
.aipScavengeServers
))
304 if typeid
!= dnsserver
.DNSSRV_TYPEID_ZONE_INFO_W2K
:
305 outf
.write(' dwRpcStructureVersion : 0x%x\n' % zoneinfo
.dwRpcStructureVersion
)
306 outf
.write(' dwForwarderTimeout : %d\n' % zoneinfo
.dwForwarderTimeout
)
307 outf
.write(' fForwarderSlave : %d\n' % zoneinfo
.fForwarderSlave
)
308 if typeid
!= dnsserver
.DNSSRV_TYPEID_ZONE_INFO
:
309 outf
.write(' aipLocalMasters : %s\n' %
310 ip4_array_string(zoneinfo
.aipLocalMasters
))
312 outf
.write(' aipLocalMasters : %s\n' %
313 dns_addr_array_string(zoneinfo
.aipLocalMasters
))
314 outf
.write(' dwDpFlags : %s\n' % dp_flags_string(zoneinfo
.dwDpFlags
))
315 outf
.write(' pszDpFqdn : %s\n' % zoneinfo
.pszDpFqdn
)
316 outf
.write(' pwszZoneDn : %s\n' % zoneinfo
.pwszZoneDn
)
317 outf
.write(' dwLastSuccessfulSoaCheck : %d\n' % zoneinfo
.dwLastSuccessfulSoaCheck
)
318 outf
.write(' dwLastSuccessfulXfr : %d\n' % zoneinfo
.dwLastSuccessfulXfr
)
320 if typeid
== dnsserver
.DNSSRV_TYPEID_ZONE_INFO
:
321 outf
.write(' fQueuedForBackgroundLoad : %s\n' % bool_string(zoneinfo
.fQueuedForBackgroundLoad
))
322 outf
.write(' fBackgroundLoadInProgress : %s\n' % bool_string(zoneinfo
.fBackgroundLoadInProgress
))
323 outf
.write(' fReadOnlyZone : %s\n' % bool_string(zoneinfo
.fReadOnlyZone
))
324 outf
.write(' dwLastXfrAttempt : %d\n' % zoneinfo
.dwLastXfrAttempt
)
325 outf
.write(' dwLastXfrResult : %d\n' % zoneinfo
.dwLastXfrResult
)
328 def print_zone(outf
, typeid
, zone
):
329 outf
.write(' pszZoneName : %s\n' % zone
.pszZoneName
)
330 outf
.write(' Flags : %s\n' % zone_flags_string(zone
.Flags
))
331 outf
.write(' ZoneType : %s\n' % zone_type_string(zone
.ZoneType
))
332 outf
.write(' Version : %s\n' % zone
.Version
)
334 if typeid
!= dnsserver
.DNSSRV_TYPEID_ZONE_W2K
:
335 outf
.write(' dwDpFlags : %s\n' % dp_flags_string(zone
.dwDpFlags
))
336 outf
.write(' pszDpFqdn : %s\n' % zone
.pszDpFqdn
)
339 def print_enumzones(outf
, typeid
, zones
):
340 outf
.write(' %d zone(s) found\n' % zones
.dwZoneCount
)
341 for zone
in zones
.ZoneArray
:
343 print_zone(outf
, typeid
, zone
)
346 def print_dns_record(outf
, rec
):
347 if rec
.wType
== dnsp
.DNS_TYPE_A
:
348 mesg
= 'A: %s' % (rec
.data
)
349 elif rec
.wType
== dnsp
.DNS_TYPE_AAAA
:
350 mesg
= 'AAAA: %s' % (rec
.data
)
351 elif rec
.wType
== dnsp
.DNS_TYPE_PTR
:
352 mesg
= 'PTR: %s' % (rec
.data
.str)
353 elif rec
.wType
== dnsp
.DNS_TYPE_NS
:
354 mesg
= 'NS: %s' % (rec
.data
.str)
355 elif rec
.wType
== dnsp
.DNS_TYPE_CNAME
:
356 mesg
= 'CNAME: %s' % (rec
.data
.str)
357 elif rec
.wType
== dnsp
.DNS_TYPE_SOA
:
358 mesg
= 'SOA: serial=%d, refresh=%d, retry=%d, expire=%d, minttl=%d, ns=%s, email=%s' % (
363 rec
.data
.dwMinimumTtl
,
364 rec
.data
.NamePrimaryServer
.str,
365 rec
.data
.ZoneAdministratorEmail
.str)
366 elif rec
.wType
== dnsp
.DNS_TYPE_MX
:
367 mesg
= 'MX: %s (%d)' % (rec
.data
.nameExchange
.str, rec
.data
.wPreference
)
368 elif rec
.wType
== dnsp
.DNS_TYPE_SRV
:
369 mesg
= 'SRV: %s (%d, %d, %d)' % (rec
.data
.nameTarget
.str, rec
.data
.wPort
,
370 rec
.data
.wPriority
, rec
.data
.wWeight
)
371 elif rec
.wType
== dnsp
.DNS_TYPE_TXT
:
372 slist
= ['"%s"' % name
.str for name
in rec
.data
.str]
373 mesg
= 'TXT: %s' % ','.join(slist
)
376 outf
.write(' %s (flags=%x, serial=%d, ttl=%d)\n' % (
377 mesg
, rec
.dwFlags
, rec
.dwSerial
, rec
.dwTtlSeconds
))
380 def print_dnsrecords(outf
, records
):
381 for rec
in records
.rec
:
382 outf
.write(' Name=%s, Records=%d, Children=%d\n' % (
386 for dns_rec
in rec
.records
:
387 print_dns_record(outf
, dns_rec
)
391 # Always create a copy of strings when creating DNS_RPC_RECORDs
392 # to overcome the bug in pidl generated python bindings.
395 class ARecord(dnsserver
.DNS_RPC_RECORD
):
396 def __init__(self
, ip_addr
, serial
=1, ttl
=900, rank
=dnsp
.DNS_RANK_ZONE
,
398 super(ARecord
, self
).__init
__()
399 self
.wType
= dnsp
.DNS_TYPE_A
400 self
.dwFlags
= rank | node_flag
401 self
.dwSerial
= serial
402 self
.dwTtlSeconds
= ttl
403 self
._ip
_addr
= ip_addr
[:]
404 self
.data
= self
._ip
_addr
407 class AAAARecord(dnsserver
.DNS_RPC_RECORD
):
409 def __init__(self
, ip6_addr
, serial
=1, ttl
=900, rank
=dnsp
.DNS_RANK_ZONE
,
411 super(AAAARecord
, self
).__init
__()
412 self
.wType
= dnsp
.DNS_TYPE_AAAA
413 self
.dwFlags
= rank | node_flag
414 self
.dwSerial
= serial
415 self
.dwTtlSeconds
= ttl
416 self
._ip
6_addr
= ip6_addr
[:]
417 self
.data
= self
._ip
6_addr
420 class PTRRecord(dnsserver
.DNS_RPC_RECORD
):
422 def __init__(self
, ptr
, serial
=1, ttl
=900, rank
=dnsp
.DNS_RANK_ZONE
,
424 super(PTRRecord
, self
).__init
__()
425 self
.wType
= dnsp
.DNS_TYPE_PTR
426 self
.dwFlags
= rank | node_flag
427 self
.dwSerial
= serial
428 self
.dwTtlSeconds
= ttl
430 ptr_name
= dnsserver
.DNS_RPC_NAME()
431 ptr_name
.str = self
._ptr
432 ptr_name
.len = len(ptr
)
436 class CNameRecord(dnsserver
.DNS_RPC_RECORD
):
438 def __init__(self
, cname
, serial
=1, ttl
=900, rank
=dnsp
.DNS_RANK_ZONE
,
440 super(CNameRecord
, self
).__init
__()
441 self
.wType
= dnsp
.DNS_TYPE_CNAME
442 self
.dwFlags
= rank | node_flag
443 self
.dwSerial
= serial
444 self
.dwTtlSeconds
= ttl
445 self
._cname
= cname
[:]
446 cname_name
= dnsserver
.DNS_RPC_NAME()
447 cname_name
.str = self
._cname
448 cname_name
.len = len(cname
)
449 self
.data
= cname_name
452 class NSRecord(dnsserver
.DNS_RPC_RECORD
):
454 def __init__(self
, dns_server
, serial
=1, ttl
=900, rank
=dnsp
.DNS_RANK_ZONE
,
456 super(NSRecord
, self
).__init
__()
457 self
.wType
= dnsp
.DNS_TYPE_NS
458 self
.dwFlags
= rank | node_flag
459 self
.dwSerial
= serial
460 self
.dwTtlSeconds
= ttl
461 self
._dns
_server
= dns_server
[:]
462 ns
= dnsserver
.DNS_RPC_NAME()
463 ns
.str = self
._dns
_server
464 ns
.len = len(dns_server
)
468 class MXRecord(dnsserver
.DNS_RPC_RECORD
):
470 def __init__(self
, mail_server
, preference
, serial
=1, ttl
=900,
471 rank
=dnsp
.DNS_RANK_ZONE
, node_flag
=0):
472 super(MXRecord
, self
).__init
__()
473 self
.wType
= dnsp
.DNS_TYPE_MX
474 self
.dwFlags
= rank | node_flag
475 self
.dwSerial
= serial
476 self
.dwTtlSeconds
= ttl
477 self
._mail
_server
= mail_server
[:]
478 mx
= dnsserver
.DNS_RPC_RECORD_NAME_PREFERENCE()
479 mx
.wPreference
= preference
480 mx
.nameExchange
.str = self
._mail
_server
481 mx
.nameExchange
.len = len(mail_server
)
485 class SOARecord(dnsserver
.DNS_RPC_RECORD
):
487 def __init__(self
, mname
, rname
, serial
=1, refresh
=900, retry
=600,
488 expire
=86400, minimum
=3600, ttl
=3600, rank
=dnsp
.DNS_RANK_ZONE
,
489 node_flag
=dnsp
.DNS_RPC_FLAG_AUTH_ZONE_ROOT
):
490 super(SOARecord
, self
).__init
__()
491 self
.wType
= dnsp
.DNS_TYPE_SOA
492 self
.dwFlags
= rank | node_flag
493 self
.dwSerial
= serial
494 self
.dwTtlSeconds
= ttl
495 self
._mname
= mname
[:]
496 self
._rname
= rname
[:]
497 soa
= dnsserver
.DNS_RPC_RECORD_SOA()
498 soa
.dwSerialNo
= serial
499 soa
.dwRefresh
= refresh
501 soa
.dwExpire
= expire
502 soa
.dwMinimumTtl
= minimum
503 soa
.NamePrimaryServer
.str = self
._mname
504 soa
.NamePrimaryServer
.len = len(mname
)
505 soa
.ZoneAdministratorEmail
.str = self
._rname
506 soa
.ZoneAdministratorEmail
.len = len(rname
)
510 class SRVRecord(dnsserver
.DNS_RPC_RECORD
):
512 def __init__(self
, target
, port
, priority
=0, weight
=100, serial
=1, ttl
=900,
513 rank
=dnsp
.DNS_RANK_ZONE
, node_flag
=0):
514 super(SRVRecord
, self
).__init
__()
515 self
.wType
= dnsp
.DNS_TYPE_SRV
516 self
.dwFlags
= rank | node_flag
517 self
.dwSerial
= serial
518 self
.dwTtlSeconds
= ttl
519 self
._target
= target
[:]
520 srv
= dnsserver
.DNS_RPC_RECORD_SRV()
521 srv
.wPriority
= priority
524 srv
.nameTarget
.str = self
._target
525 srv
.nameTarget
.len = len(target
)
529 class TXTRecord(dnsserver
.DNS_RPC_RECORD
):
531 def __init__(self
, slist
, serial
=1, ttl
=900, rank
=dnsp
.DNS_RANK_ZONE
,
533 super(TXTRecord
, self
).__init
__()
534 self
.wType
= dnsp
.DNS_TYPE_TXT
535 self
.dwFlags
= rank | node_flag
536 self
.dwSerial
= serial
537 self
.dwTtlSeconds
= ttl
540 self
._slist
.append(s
[:])
542 for s
in self
._slist
:
543 name
= dnsserver
.DNS_RPC_NAME()
547 txt
= dnsserver
.DNS_RPC_RECORD_STRING()
548 txt
.count
= len(slist
)
553 # Convert data into a dns record
554 def data_to_dns_record(record_type
, data
):
555 if record_type
== dnsp
.DNS_TYPE_A
:
557 elif record_type
== dnsp
.DNS_TYPE_AAAA
:
558 rec
= AAAARecord(data
)
559 elif record_type
== dnsp
.DNS_TYPE_PTR
:
560 rec
= PTRRecord(data
)
561 elif record_type
== dnsp
.DNS_TYPE_CNAME
:
562 rec
= CNameRecord(data
)
563 elif record_type
== dnsp
.DNS_TYPE_NS
:
565 elif record_type
== dnsp
.DNS_TYPE_MX
:
566 tmp
= data
.split(' ')
568 raise CommandError('Data requires 2 elements - mail_server, preference')
570 preference
= int(tmp
[1])
571 rec
= MXRecord(mail_server
, preference
)
572 elif record_type
== dnsp
.DNS_TYPE_SRV
:
573 tmp
= data
.split(' ')
575 raise CommandError('Data requires 4 elements - server, port, priority, weight')
578 priority
= int(tmp
[2])
580 rec
= SRVRecord(server
, port
, priority
=priority
, weight
=weight
)
581 elif record_type
== dnsp
.DNS_TYPE_SOA
:
582 tmp
= data
.split(' ')
584 raise CommandError('Data requires 7 elements - nameserver, email, serial, '
585 'refresh, retry, expire, minimumttl')
589 refresh
= int(tmp
[3])
592 minimum
= int(tmp
[6])
593 rec
= SOARecord(nameserver
, email
, serial
=serial
, refresh
=refresh
,
594 retry
=retry
, expire
=expire
, minimum
=minimum
)
595 elif record_type
== dnsp
.DNS_TYPE_TXT
:
596 slist
= shlex
.split(data
)
597 rec
= TXTRecord(slist
)
599 raise CommandError('Unsupported record type')
603 # Match dns name (of type DNS_RPC_NAME)
604 def dns_name_equal(n1
, n2
):
605 return n1
.str.rstrip('.').lower() == n2
.str.rstrip('.').lower()
608 # Match a dns record with specified data
609 def dns_record_match(dns_conn
, server
, zone
, name
, record_type
, data
):
610 urec
= data_to_dns_record(record_type
, data
)
612 select_flags
= dnsserver
.DNS_RPC_VIEW_AUTHORITY_DATA
615 buflen
, res
= dns_conn
.DnssrvEnumRecords2(
616 dnsserver
.DNS_CLIENT_VERSION_LONGHORN
, 0, server
, zone
, name
, None,
617 record_type
, select_flags
, None, None)
618 except RuntimeError, e
:
621 if not res
or res
.count
== 0:
625 for rec
in res
.rec
[0].records
:
626 if rec
.wType
!= record_type
:
630 if record_type
== dnsp
.DNS_TYPE_A
:
631 if rec
.data
== urec
.data
:
633 elif record_type
== dnsp
.DNS_TYPE_AAAA
:
634 if rec
.data
== urec
.data
:
636 elif record_type
== dnsp
.DNS_TYPE_PTR
:
637 if dns_name_equal(rec
.data
, urec
.data
):
639 elif record_type
== dnsp
.DNS_TYPE_CNAME
:
640 if dns_name_equal(rec
.data
, urec
.data
):
642 elif record_type
== dnsp
.DNS_TYPE_NS
:
643 if dns_name_equal(rec
.data
, urec
.data
):
645 elif record_type
== dnsp
.DNS_TYPE_MX
:
646 if dns_name_equal(rec
.data
.nameExchange
, urec
.data
.nameExchange
) and \
647 rec
.data
.wPreference
== urec
.data
.wPreference
:
649 elif record_type
== dnsp
.DNS_TYPE_SRV
:
650 if rec
.data
.wPriority
== urec
.data
.wPriority
and \
651 rec
.data
.wWeight
== urec
.data
.wWeight
and \
652 rec
.data
.wPort
== urec
.data
.wPort
and \
653 dns_name_equal(rec
.data
.nameTarget
, urec
.data
.nameTarget
):
655 elif record_type
== dnsp
.DNS_TYPE_SOA
:
656 if rec
.data
.dwSerialNo
== urec
.data
.dwSerialNo
and \
657 rec
.data
.dwRefresh
== urec
.data
.dwRefresh
and \
658 rec
.data
.dwRetry
== urec
.data
.dwRetry
and \
659 rec
.data
.dwExpire
== urec
.data
.dwExpire
and \
660 rec
.data
.dwMinimumTtl
== urec
.data
.dwMinimumTtl
and \
661 dns_name_equal(rec
.data
.NamePrimaryServer
,
662 urec
.data
.NamePrimaryServer
) and \
663 dns_name_equal(rec
.data
.ZoneAdministratorEmail
,
664 urec
.data
.ZoneAdministratorEmail
):
666 elif record_type
== dnsp
.DNS_TYPE_TXT
:
667 if rec
.data
.count
== urec
.data
.count
:
669 for i
in xrange(rec
.data
.count
):
671 (rec
.data
.str[i
].str == urec
.data
.str[i
].str)
680 class cmd_serverinfo(Command
):
681 """Query for Server information."""
683 synopsis
= '%prog <server> [options]'
685 takes_args
= [ 'server' ]
687 takes_optiongroups
= {
688 "sambaopts": options
.SambaOptions
,
689 "versionopts": options
.VersionOptions
,
690 "credopts": options
.CredentialsOptions
,
694 Option('--client-version', help='Client Version',
695 default
='longhorn', metavar
='w2k|dotnet|longhorn',
696 choices
=['w2k','dotnet','longhorn'], dest
='cli_ver'),
699 def run(self
, server
, cli_ver
, sambaopts
=None, credopts
=None,
701 self
.lp
= sambaopts
.get_loadparm()
702 self
.creds
= credopts
.get_credentials(self
.lp
)
703 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
705 client_version
= dns_client_version(cli_ver
)
707 typeid
, res
= dns_conn
.DnssrvQuery2(client_version
, 0, server
,
709 print_serverinfo(self
.outf
, typeid
, res
)
712 class cmd_zoneinfo(Command
):
713 """Query for zone information."""
715 synopsis
= '%prog <server> <zone> [options]'
717 takes_args
= [ 'server', 'zone' ]
719 takes_optiongroups
= {
720 "sambaopts": options
.SambaOptions
,
721 "versionopts": options
.VersionOptions
,
722 "credopts": options
.CredentialsOptions
,
726 Option('--client-version', help='Client Version',
727 default
='longhorn', metavar
='w2k|dotnet|longhorn',
728 choices
=['w2k','dotnet','longhorn'], dest
='cli_ver'),
731 def run(self
, server
, zone
, cli_ver
, sambaopts
=None, credopts
=None,
733 self
.lp
= sambaopts
.get_loadparm()
734 self
.creds
= credopts
.get_credentials(self
.lp
)
735 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
737 client_version
= dns_client_version(cli_ver
)
739 typeid
, res
= dns_conn
.DnssrvQuery2(client_version
, 0, server
, zone
,
741 print_zoneinfo(self
.outf
, typeid
, res
)
744 class cmd_zonelist(Command
):
745 """Query for zones."""
747 synopsis
= '%prog <server> [options]'
749 takes_args
= [ 'server' ]
751 takes_optiongroups
= {
752 "sambaopts": options
.SambaOptions
,
753 "versionopts": options
.VersionOptions
,
754 "credopts": options
.CredentialsOptions
,
758 Option('--client-version', help='Client Version',
759 default
='longhorn', metavar
='w2k|dotnet|longhorn',
760 choices
=['w2k','dotnet','longhorn'], dest
='cli_ver'),
761 Option('--primary', help='List primary zones (default)',
762 action
='store_true', dest
='primary'),
763 Option('--secondary', help='List secondary zones',
764 action
='store_true', dest
='secondary'),
765 Option('--cache', help='List cached zones',
766 action
='store_true', dest
='cache'),
767 Option('--auto', help='List automatically created zones',
768 action
='store_true', dest
='auto'),
769 Option('--forward', help='List forward zones',
770 action
='store_true', dest
='forward'),
771 Option('--reverse', help='List reverse zones',
772 action
='store_true', dest
='reverse'),
773 Option('--ds', help='List directory integrated zones',
774 action
='store_true', dest
='ds'),
775 Option('--non-ds', help='List non-directory zones',
776 action
='store_true', dest
='nonds')
779 def run(self
, server
, cli_ver
, primary
=False, secondary
=False, cache
=False,
780 auto
=False, forward
=False, reverse
=False, ds
=False, nonds
=False,
781 sambaopts
=None, credopts
=None, versionopts
=None):
785 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_PRIMARY
787 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_SECONDARY
789 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_CACHE
791 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_AUTO
793 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_FORWARD
795 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_REVERSE
797 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_DS
799 request_filter |
= dnsserver
.DNS_ZONE_REQUEST_NON_DS
801 if request_filter
== 0:
802 request_filter
= dnsserver
.DNS_ZONE_REQUEST_PRIMARY
804 self
.lp
= sambaopts
.get_loadparm()
805 self
.creds
= credopts
.get_credentials(self
.lp
)
806 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
808 client_version
= dns_client_version(cli_ver
)
810 typeid
, res
= dns_conn
.DnssrvComplexOperation2(client_version
,
813 dnsserver
.DNSSRV_TYPEID_DWORD
,
816 if client_version
== dnsserver
.DNS_CLIENT_VERSION_W2K
:
817 typeid
= dnsserver
.DNSSRV_TYPEID_ZONE_W2K
819 typeid
= dnsserver
.DNSSRV_TYPEID_ZONE
820 print_enumzones(self
.outf
, typeid
, res
)
823 class cmd_zonecreate(Command
):
826 synopsis
= '%prog <server> <zone> [options]'
828 takes_args
= [ 'server', 'zone' ]
830 takes_optiongroups
= {
831 "sambaopts": options
.SambaOptions
,
832 "versionopts": options
.VersionOptions
,
833 "credopts": options
.CredentialsOptions
,
837 Option('--client-version', help='Client Version',
838 default
='longhorn', metavar
='w2k|dotnet|longhorn',
839 choices
=['w2k','dotnet','longhorn'], dest
='cli_ver')
842 def run(self
, server
, zone
, cli_ver
, sambaopts
=None, credopts
=None,
845 self
.lp
= sambaopts
.get_loadparm()
846 self
.creds
= credopts
.get_credentials(self
.lp
)
847 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
851 client_version
= dns_client_version(cli_ver
)
852 if client_version
== dnsserver
.DNS_CLIENT_VERSION_W2K
:
853 typeid
= dnsserver
.DNSSRV_TYPEID_ZONE_CREATE_W2K
854 zone_create_info
= dnsserver
.DNS_RPC_ZONE_CREATE_INFO_W2K()
855 zone_create_info
.pszZoneName
= zone
856 zone_create_info
.dwZoneType
= dnsp
.DNS_ZONE_TYPE_PRIMARY
857 zone_create_info
.fAging
= 0
858 zone_create_info
.fDsIntegrated
= 1
859 zone_create_info
.fLoadExisting
= 1
860 elif client_version
== dnsserver
.DNS_CLIENT_VERSION_DOTNET
:
861 typeid
= dnsserver
.DNSSRV_TYPEID_ZONE_CREATE_DOTNET
862 zone_create_info
= dnsserver
.DNS_RPC_ZONE_CREATE_INFO_DOTNET()
863 zone_create_info
.pszZoneName
= zone
864 zone_create_info
.dwZoneType
= dnsp
.DNS_ZONE_TYPE_PRIMARY
865 zone_create_info
.fAging
= 0
866 zone_create_info
.fDsIntegrated
= 1
867 zone_create_info
.fLoadExisting
= 1
868 zone_create_info
.dwDpFlags
= dnsserver
.DNS_DP_DOMAIN_DEFAULT
870 typeid
= dnsserver
.DNSSRV_TYPEID_ZONE_CREATE
871 zone_create_info
= dnsserver
.DNS_RPC_ZONE_CREATE_INFO_LONGHORN()
872 zone_create_info
.pszZoneName
= zone
873 zone_create_info
.dwZoneType
= dnsp
.DNS_ZONE_TYPE_PRIMARY
874 zone_create_info
.fAging
= 0
875 zone_create_info
.fDsIntegrated
= 1
876 zone_create_info
.fLoadExisting
= 1
877 zone_create_info
.dwDpFlags
= dnsserver
.DNS_DP_DOMAIN_DEFAULT
879 res
= dns_conn
.DnssrvOperation2(client_version
, 0, server
, None,
880 0, 'ZoneCreate', typeid
,
883 typeid
= dnsserver
.DNSSRV_TYPEID_NAME_AND_PARAM
884 name_and_param
= dnsserver
.DNS_RPC_NAME_AND_PARAM()
885 name_and_param
.pszNodeName
= 'AllowUpdate'
886 name_and_param
.dwParam
= dnsp
.DNS_ZONE_UPDATE_SECURE
888 res
= dns_conn
.DnssrvOperation2(client_version
, 0, server
, zone
,
889 0, 'ResetDwordProperty', typeid
,
891 self
.outf
.write('Zone %s created successfully\n' % zone
)
894 class cmd_zonedelete(Command
):
897 synopsis
= '%prog <server> <zone> [options]'
899 takes_args
= [ 'server', 'zone' ]
901 takes_optiongroups
= {
902 "sambaopts": options
.SambaOptions
,
903 "versionopts": options
.VersionOptions
,
904 "credopts": options
.CredentialsOptions
,
907 def run(self
, server
, zone
, sambaopts
=None, credopts
=None,
910 self
.lp
= sambaopts
.get_loadparm()
911 self
.creds
= credopts
.get_credentials(self
.lp
)
912 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
915 res
= dns_conn
.DnssrvOperation2(dnsserver
.DNS_CLIENT_VERSION_LONGHORN
,
916 0, server
, zone
, 0, 'DeleteZoneFromDs',
917 dnsserver
.DNSSRV_TYPEID_NULL
,
919 self
.outf
.write('Zone %s delete successfully\n' % zone
)
922 class cmd_query(Command
):
925 synopsis
= '%prog <server> <zone> <name> <A|AAAA|CNAME|MX|NS|SOA|SRV|TXT|ALL> [options]'
927 takes_args
= [ 'server', 'zone', 'name', 'rtype' ]
929 takes_optiongroups
= {
930 "sambaopts": options
.SambaOptions
,
931 "versionopts": options
.VersionOptions
,
932 "credopts": options
.CredentialsOptions
,
936 Option('--authority', help='Search authoritative records (default)',
937 action
='store_true', dest
='authority'),
938 Option('--cache', help='Search cached records',
939 action
='store_true', dest
='cache'),
940 Option('--glue', help='Search glue records',
941 action
='store_true', dest
='glue'),
942 Option('--root', help='Search root hints',
943 action
='store_true', dest
='root'),
944 Option('--additional', help='List additional records',
945 action
='store_true', dest
='additional'),
946 Option('--no-children', help='Do not list children',
947 action
='store_true', dest
='no_children'),
948 Option('--only-children', help='List only children',
949 action
='store_true', dest
='only_children')
952 def run(self
, server
, zone
, name
, rtype
, authority
=False, cache
=False,
953 glue
=False, root
=False, additional
=False, no_children
=False,
954 only_children
=False, sambaopts
=None, credopts
=None,
956 record_type
= dns_type_flag(rtype
)
958 if name
.find('*') != -1:
959 raise CommandError('Wildcard searches not supported. To dump entire zone use "@"')
963 select_flags |
= dnsserver
.DNS_RPC_VIEW_AUTHORITY_DATA
965 select_flags |
= dnsserver
.DNS_RPC_VIEW_CACHE_DATA
967 select_flags |
= dnsserver
.DNS_RPC_VIEW_GLUE_DATA
969 select_flags |
= dnsserver
.DNS_RPC_VIEW_ROOT_HINT_DATA
971 select_flags |
= dnsserver
.DNS_RPC_VIEW_ADDITIONAL_DATA
973 select_flags |
= dnsserver
.DNS_RPC_VIEW_NO_CHILDREN
975 select_flags |
= dnsserver
.DNS_RPC_VIEW_ONLY_CHILDREN
977 if select_flags
== 0:
978 select_flags
= dnsserver
.DNS_RPC_VIEW_AUTHORITY_DATA
980 if select_flags
== dnsserver
.DNS_RPC_VIEW_ADDITIONAL_DATA
:
981 self
.outf
.write('Specify either --authority or --root along with --additional.\n')
982 self
.outf
.write('Assuming --authority.\n')
983 select_flags |
= dnsserver
.DNS_RPC_VIEW_AUTHORITY_DATA
985 self
.lp
= sambaopts
.get_loadparm()
986 self
.creds
= credopts
.get_credentials(self
.lp
)
987 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
989 buflen
, res
= dns_conn
.DnssrvEnumRecords2(
990 dnsserver
.DNS_CLIENT_VERSION_LONGHORN
, 0, server
, zone
, name
,
991 None, record_type
, select_flags
, None, None)
992 print_dnsrecords(self
.outf
, res
)
995 class cmd_roothints(Command
):
996 """Query root hints."""
998 synopsis
= '%prog <server> [<name>] [options]'
1000 takes_args
= [ 'server', 'name?' ]
1002 takes_optiongroups
= {
1003 "sambaopts": options
.SambaOptions
,
1004 "versionopts": options
.VersionOptions
,
1005 "credopts": options
.CredentialsOptions
,
1008 def run(self
, server
, name
='.', sambaopts
=None, credopts
=None,
1010 record_type
= dnsp
.DNS_TYPE_NS
1011 select_flags
= (dnsserver
.DNS_RPC_VIEW_ROOT_HINT_DATA |
1012 dnsserver
.DNS_RPC_VIEW_ADDITIONAL_DATA
)
1014 self
.lp
= sambaopts
.get_loadparm()
1015 self
.creds
= credopts
.get_credentials(self
.lp
)
1016 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
1018 buflen
, res
= dns_conn
.DnssrvEnumRecords2(
1019 dnsserver
.DNS_CLIENT_VERSION_LONGHORN
, 0, server
, '..RootHints',
1020 name
, None, record_type
, select_flags
, None, None)
1021 print_dnsrecords(self
.outf
, res
)
1024 class cmd_add_record(Command
):
1027 For each type data contents are as follows:
1028 A ipv4_address_string
1029 AAAA ipv6_address_string
1033 MX "fqdn_string preference"
1034 SRV "fqdn_string port priority weight"
1035 TXT "'string1' 'string2' ..."
1038 synopsis
= '%prog <server> <zone> <name> <A|AAAA|PTR|CNAME|NS|MX|SRV|TXT> <data>'
1040 takes_args
= [ 'server', 'zone', 'name', 'rtype', 'data' ]
1042 takes_optiongroups
= {
1043 "sambaopts": options
.SambaOptions
,
1044 "versionopts": options
.VersionOptions
,
1045 "credopts": options
.CredentialsOptions
,
1048 def run(self
, server
, zone
, name
, rtype
, data
, sambaopts
=None,
1049 credopts
=None, versionopts
=None):
1051 if rtype
.upper() not in ('A','AAAA','PTR','CNAME','NS','MX','SRV','TXT'):
1052 raise CommandError('Adding record of type %s is not supported' % rtype
)
1054 record_type
= dns_type_flag(rtype
)
1055 rec
= data_to_dns_record(record_type
, data
)
1057 self
.lp
= sambaopts
.get_loadparm()
1058 self
.creds
= credopts
.get_credentials(self
.lp
)
1059 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
1061 rec_match
= dns_record_match(dns_conn
, server
, zone
, name
, record_type
,
1063 if rec_match
is not None:
1064 raise CommandError('Record already exists')
1066 add_rec_buf
= dnsserver
.DNS_RPC_RECORD_BUF()
1067 add_rec_buf
.rec
= rec
1069 dns_conn
.DnssrvUpdateRecord2(dnsserver
.DNS_CLIENT_VERSION_LONGHORN
,
1070 0, server
, zone
, name
, add_rec_buf
, None)
1071 self
.outf
.write('Record added successfully\n')
1074 class cmd_update_record(Command
):
1075 """Update a DNS record
1077 For each type data contents are as follows:
1078 A ipv4_address_string
1079 AAAA ipv6_address_string
1083 MX "fqdn_string preference"
1084 SOA "fqdn_dns fqdn_email serial refresh retry expire minimumttl"
1085 SRV "fqdn_string port priority weight"
1086 TXT "'string1' 'string2' ..."
1089 synopsis
= '%prog <server> <zone> <name> <A|AAAA|PTR|CNAME|NS|MX|SOA|SRV|TXT> <olddata> <newdata>'
1091 takes_args
= [ 'server', 'zone', 'name', 'rtype', 'olddata', 'newdata' ]
1093 takes_optiongroups
= {
1094 "sambaopts": options
.SambaOptions
,
1095 "versionopts": options
.VersionOptions
,
1096 "credopts": options
.CredentialsOptions
,
1099 def run(self
, server
, zone
, name
, rtype
, olddata
, newdata
,
1100 sambaopts
=None, credopts
=None, versionopts
=None):
1102 if rtype
.upper() not in ('A','AAAA','PTR','CNAME','NS','MX','SOA','SRV','TXT'):
1103 raise CommandError('Updating record of type %s is not supported' % rtype
)
1105 record_type
= dns_type_flag(rtype
)
1106 rec
= data_to_dns_record(record_type
, newdata
)
1108 self
.lp
= sambaopts
.get_loadparm()
1109 self
.creds
= credopts
.get_credentials(self
.lp
)
1110 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
1112 rec_match
= dns_record_match(dns_conn
, server
, zone
, name
, record_type
,
1115 raise CommandError('Record does not exist')
1117 # Copy properties from existing record to new record
1118 rec
.dwFlags
= rec_match
.dwFlags
1119 rec
.dwSerial
= rec_match
.dwSerial
1120 rec
.dwTtlSeconds
= rec_match
.dwTtlSeconds
1121 rec
.dwTimeStamp
= rec_match
.dwTimeStamp
1123 add_rec_buf
= dnsserver
.DNS_RPC_RECORD_BUF()
1124 add_rec_buf
.rec
= rec
1126 del_rec_buf
= dnsserver
.DNS_RPC_RECORD_BUF()
1127 del_rec_buf
.rec
= rec_match
1129 dns_conn
.DnssrvUpdateRecord2(dnsserver
.DNS_CLIENT_VERSION_LONGHORN
,
1136 self
.outf
.write('Record updated successfully\n')
1139 class cmd_delete_record(Command
):
1140 """Delete a DNS record
1142 For each type data contents are as follows:
1143 A ipv4_address_string
1144 AAAA ipv6_address_string
1148 MX "fqdn_string preference"
1149 SRV "fqdn_string port priority weight"
1150 TXT "'string1' 'string2' ..."
1153 synopsis
= '%prog <server> <zone> <name> <A|AAAA|PTR|CNAME|NS|MX|SRV|TXT> <data>'
1155 takes_args
= [ 'server', 'zone', 'name', 'rtype', 'data' ]
1157 takes_optiongroups
= {
1158 "sambaopts": options
.SambaOptions
,
1159 "versionopts": options
.VersionOptions
,
1160 "credopts": options
.CredentialsOptions
,
1163 def run(self
, server
, zone
, name
, rtype
, data
, sambaopts
=None, credopts
=None, versionopts
=None):
1165 if rtype
.upper() not in ('A','AAAA','PTR','CNAME','NS','MX','SRV','TXT'):
1166 raise CommandError('Deleting record of type %s is not supported' % rtype
)
1168 record_type
= dns_type_flag(rtype
)
1170 self
.lp
= sambaopts
.get_loadparm()
1171 self
.creds
= credopts
.get_credentials(self
.lp
)
1172 dns_conn
= dns_connect(server
, self
.lp
, self
.creds
)
1174 rec_match
= dns_record_match(dns_conn
, server
, zone
, name
, record_type
, data
)
1176 raise CommandError('Record does not exist')
1178 del_rec_buf
= dnsserver
.DNS_RPC_RECORD_BUF()
1179 del_rec_buf
.rec
= rec_match
1181 dns_conn
.DnssrvUpdateRecord2(dnsserver
.DNS_CLIENT_VERSION_LONGHORN
,
1188 self
.outf
.write('Record deleted successfully\n')
1191 class cmd_dns(SuperCommand
):
1192 """Domain Name Service (DNS) management."""
1195 subcommands
['serverinfo'] = cmd_serverinfo()
1196 subcommands
['zoneinfo'] = cmd_zoneinfo()
1197 subcommands
['zonelist'] = cmd_zonelist()
1198 subcommands
['zonecreate'] = cmd_zonecreate()
1199 subcommands
['zonedelete'] = cmd_zonedelete()
1200 subcommands
['query'] = cmd_query()
1201 subcommands
['roothints'] = cmd_roothints()
1202 subcommands
['add'] = cmd_add_record()
1203 subcommands
['update'] = cmd_update_record()
1204 subcommands
['delete'] = cmd_delete_record()