1 /*
2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.jndi.dns;
27
28
29 import java.util.Enumeration;
30 import java.util.Hashtable;
31
32 import javax.naming.*;
33 import javax.naming.directory.*;
34 import javax.naming.spi.DirectoryManager;
35
36 import com.sun.jndi.toolkit.ctx.*;
37 import com.sun.jndi.toolkit.ctx.Continuation;
38
39
40 /**
41 * A DnsContext is a directory context representing a DNS node.
42 *
43 * @author Scott Seligman
44 */
45
46
47 public class DnsContext extends ComponentDirContext {
48
49 DnsName domain; // fully-qualified domain name of this context,
50 // with a root (empty) label at position 0
51 Hashtable<Object,Object> environment;
52 private boolean envShared; // true if environment is possibly shared
53 // and so must be copied on write
54 private boolean parentIsDns; // was this DnsContext created by
55 // another? see composeName()
56 private String[] servers;
57 private Resolver resolver;
58
59 private boolean authoritative; // must all responses be authoritative?
60 private boolean recursion; // request recursion on queries?
61 private int timeout; // initial timeout on UDP queries in ms
62 private int retries; // number of UDP retries
63
64 static final NameParser nameParser = new DnsNameParser();
65
66 // Timeouts for UDP queries use exponential backoff: each retry
67 // is for twice as long as the last. The following constants set
68 // the defaults for the initial timeout (in ms) and the number of
69 // retries, and name the environment properties used to override
70 // these defaults.
71 private static final int DEFAULT_INIT_TIMEOUT = 1000;
72 private static final int DEFAULT_RETRIES = 4;
73 private static final String INIT_TIMEOUT =
74 "com.sun.jndi.dns.timeout.initial";
75 private static final String RETRIES = "com.sun.jndi.dns.timeout.retries";
76
77 // The resource record type and class to use for lookups, and the
78 // property used to modify them
79 private CT lookupCT;
80 private static final String LOOKUP_ATTR = "com.sun.jndi.dns.lookup.attr";
81
82 // Property used to disallow recursion on queries
83 private static final String RECURSION = "com.sun.jndi.dns.recursion";
84
85 // ANY == ResourceRecord.QCLASS_STAR == ResourceRecord.QTYPE_STAR
86 private static final int ANY = ResourceRecord.QTYPE_STAR;
87
88 // The zone tree used for list operations
89 private static final ZoneNode zoneTree = new ZoneNode(null);
90
91
92 /**
93 * Returns a DNS context for a given domain and servers.
94 * Each server is of the form "server[:port]".
95 * IPv6 literal host names include delimiting brackets.
96 * There must be at least one server.
97 * The environment must not be null; it is cloned before being stored.
98 */
99 @SuppressWarnings("unchecked")
100 public DnsContext(String domain, String[] servers, Hashtable<?,?> environment)
101 throws NamingException {
102
103 this.domain = new DnsName(domain.endsWith(".")
104 ? domain
105 : domain + ".");
106 this.servers = (servers == null) ? null : servers.clone();
107 this.environment = (Hashtable<Object,Object>) environment.clone();
108 envShared = false;
109 parentIsDns = false;
110 resolver = null;
111
112 initFromEnvironment();
113 }
114
115 /*
116 * Returns a clone of a DNS context, just like DnsContext(DnsContext)
117 * but with a different domain name and with parentIsDns set to true.
118 */
119 DnsContext(DnsContext ctx, DnsName domain) {
120 this(ctx);
121 this.domain = domain;
122 parentIsDns = true;
123 }
124
125 /*
126 * Returns a clone of a DNS context. The context's modifiable
127 * private state is independent of the original's (so closing one
128 * context, for example, won't close the other). The two contexts
129 * share {@code environment}, but it's copy-on-write so there's
130 * no conflict.
131 */
132 private DnsContext(DnsContext ctx) {
133 environment = ctx.environment; // shared environment, copy-on-write
134 envShared = ctx.envShared = true;
135 parentIsDns = ctx.parentIsDns;
136 domain = ctx.domain;
137 servers = ctx.servers; // shared servers, no write operation
138 resolver = ctx.resolver;
139 authoritative = ctx.authoritative;
140 recursion = ctx.recursion;
141 timeout = ctx.timeout;
142 retries = ctx.retries;
143 lookupCT = ctx.lookupCT;
144 }
145
146 public void close() {
147 if (resolver != null) {
148 resolver.close();
149 resolver = null;
150 }
151 }
152
153
154 //---------- Environment operations
155
156 /*
157 * Override default with a noncloning version.
158 */
159 protected Hashtable<?,?> p_getEnvironment() {
160 return environment;
161 }
162
163 public Hashtable<?,?> getEnvironment() throws NamingException {
164 return (Hashtable<?,?>) environment.clone();
165 }
166
167 @SuppressWarnings("unchecked")
168 public Object addToEnvironment(String propName, Object propVal)
169 throws NamingException {
170
171 if (propName.equals(LOOKUP_ATTR)) {
172 lookupCT = getLookupCT((String) propVal);
173 } else if (propName.equals(Context.AUTHORITATIVE)) {
174 authoritative = "true".equalsIgnoreCase((String) propVal);
175 } else if (propName.equals(RECURSION)) {
176 recursion = "true".equalsIgnoreCase((String) propVal);
177 } else if (propName.equals(INIT_TIMEOUT)) {
178 int val = Integer.parseInt((String) propVal);
179 if (timeout != val) {
180 timeout = val;
181 resolver = null;
182 }
183 } else if (propName.equals(RETRIES)) {
184 int val = Integer.parseInt((String) propVal);
185 if (retries != val) {
186 retries = val;
187 resolver = null;
188 }
189 }
190
191 if (!envShared) {
192 return environment.put(propName, propVal);
193 } else if (environment.get(propName) != propVal) {
194 // copy on write
195 environment = (Hashtable<Object,Object>) environment.clone();
196 envShared = false;
197 return environment.put(propName, propVal);
198 } else {
199 return propVal;
200 }
201 }
202
203 @SuppressWarnings("unchecked")
204 public Object removeFromEnvironment(String propName)
205 throws NamingException {
206
207 if (propName.equals(LOOKUP_ATTR)) {
208 lookupCT = getLookupCT(null);
209 } else if (propName.equals(Context.AUTHORITATIVE)) {
210 authoritative = false;
211 } else if (propName.equals(RECURSION)) {
212 recursion = true;
213 } else if (propName.equals(INIT_TIMEOUT)) {
214 if (timeout != DEFAULT_INIT_TIMEOUT) {
215 timeout = DEFAULT_INIT_TIMEOUT;
216 resolver = null;
217 }
218 } else if (propName.equals(RETRIES)) {
219 if (retries != DEFAULT_RETRIES) {
220 retries = DEFAULT_RETRIES;
221 resolver = null;
222 }
223 }
224
225 if (!envShared) {
226 return environment.remove(propName);
227 } else if (environment.get(propName) != null) {
228 // copy-on-write
229 environment = (Hashtable<Object,Object>) environment.clone();
230 envShared = false;
231 return environment.remove(propName);
232 } else {
233 return null;
234 }
235 }
236
237 /*
238 * Update PROVIDER_URL property. Call this only when environment
239 * is not being shared.
240 */
241 void setProviderUrl(String url) {
242 // assert !envShared;
243 environment.put(Context.PROVIDER_URL, url);
244 }
245
246 /*
247 * Read environment properties and set parameters.
248 */
249 private void initFromEnvironment()
250 throws InvalidAttributeIdentifierException {
251
252 lookupCT = getLookupCT((String) environment.get(LOOKUP_ATTR));
253 authoritative = "true".equalsIgnoreCase((String)
254 environment.get(Context.AUTHORITATIVE));
255 String val = (String) environment.get(RECURSION);
256 recursion = ((val == null) ||
257 "true".equalsIgnoreCase(val));
258 val = (String) environment.get(INIT_TIMEOUT);
259 timeout = (val == null)
260 ? DEFAULT_INIT_TIMEOUT
261 : Integer.parseInt(val);
262 val = (String) environment.get(RETRIES);
263 retries = (val == null)
264 ? DEFAULT_RETRIES
265 : Integer.parseInt(val);
266 }
267
268 private CT getLookupCT(String attrId)
269 throws InvalidAttributeIdentifierException {
270 return (attrId == null)
271 ? new CT(ResourceRecord.CLASS_INTERNET, ResourceRecord.TYPE_TXT)
272 : fromAttrId(attrId);
273 }
274
275
276 //---------- Naming operations
277
278 public Object c_lookup(Name name, Continuation cont)
279 throws NamingException {
280
281 cont.setSuccess();
282 if (name.isEmpty()) {
283 DnsContext ctx = new DnsContext(this);
284 ctx.resolver = new Resolver(servers, timeout, retries);
285 // clone for parallelism
286 return ctx;
287 }
288 try {
289 DnsName fqdn = fullyQualify(name);
290 ResourceRecords rrs =
291 getResolver().query(fqdn, lookupCT.rrclass, lookupCT.rrtype,
292 recursion, authoritative);
293 Attributes attrs = rrsToAttrs(rrs, null);
294 DnsContext ctx = new DnsContext(this, fqdn);
295 return DirectoryManager.getObjectInstance(ctx, name, this,
296 environment, attrs);
297 } catch (NamingException e) {
298 cont.setError(this, name);
299 throw cont.fillInException(e);
300 } catch (Exception e) {
301 cont.setError(this, name);
302 NamingException ne = new NamingException(
303 "Problem generating object using object factory");
304 ne.setRootCause(e);
305 throw cont.fillInException(ne);
306 }
307 }
308
309 public Object c_lookupLink(Name name, Continuation cont)
310 throws NamingException {
311 return c_lookup(name, cont);
312 }
313
314 public NamingEnumeration<NameClassPair> c_list(Name name, Continuation cont)
315 throws NamingException {
316 cont.setSuccess();
317 try {
318 DnsName fqdn = fullyQualify(name);
319 NameNode nnode = getNameNode(fqdn);
320 DnsContext ctx = new DnsContext(this, fqdn);
321 return new NameClassPairEnumeration(ctx, nnode.getChildren());
322
323 } catch (NamingException e) {
324 cont.setError(this, name);
325 throw cont.fillInException(e);
326 }
327 }
328
329 public NamingEnumeration<Binding> c_listBindings(Name name, Continuation cont)
330 throws NamingException {
331 cont.setSuccess();
332 try {
333 DnsName fqdn = fullyQualify(name);
334 NameNode nnode = getNameNode(fqdn);
335 DnsContext ctx = new DnsContext(this, fqdn);
336 return new BindingEnumeration(ctx, nnode.getChildren());
337
338 } catch (NamingException e) {
339 cont.setError(this, name);
340 throw cont.fillInException(e);
341 }
342 }
343
344 public void c_bind(Name name, Object obj, Continuation cont)
345 throws NamingException {
346 cont.setError(this, name);
347 throw cont.fillInException(
348 new OperationNotSupportedException());
349 }
350
351 public void c_rebind(Name name, Object obj, Continuation cont)
352 throws NamingException {
353 cont.setError(this, name);
354 throw cont.fillInException(
355 new OperationNotSupportedException());
356 }
357
358 public void c_unbind(Name name, Continuation cont)
359 throws NamingException {
360 cont.setError(this, name);
361 throw cont.fillInException(
362 new OperationNotSupportedException());
363 }
364
365 public void c_rename(Name oldname, Name newname, Continuation cont)
366 throws NamingException {
367 cont.setError(this, oldname);
368 throw cont.fillInException(
369 new OperationNotSupportedException());
370 }
371
372 public Context c_createSubcontext(Name name, Continuation cont)
373 throws NamingException {
374 cont.setError(this, name);
375 throw cont.fillInException(
376 new OperationNotSupportedException());
377 }
378
379 public void c_destroySubcontext(Name name, Continuation cont)
380 throws NamingException {
381 cont.setError(this, name);
382 throw cont.fillInException(
383 new OperationNotSupportedException());
384 }
385
386 public NameParser c_getNameParser(Name name, Continuation cont)
387 throws NamingException {
388 cont.setSuccess();
389 return nameParser;
390 }
391
392
393 //---------- Directory operations
394
395 public void c_bind(Name name,
396 Object obj,
397 Attributes attrs,
398 Continuation cont)
399 throws NamingException {
400 cont.setError(this, name);
401 throw cont.fillInException(
402 new OperationNotSupportedException());
403 }
404
405 public void c_rebind(Name name,
406 Object obj,
407 Attributes attrs,
408 Continuation cont)
409 throws NamingException {
410 cont.setError(this, name);
411 throw cont.fillInException(
412 new OperationNotSupportedException());
413 }
414
415 public DirContext c_createSubcontext(Name name,
416 Attributes attrs,
417 Continuation cont)
418 throws NamingException {
419 cont.setError(this, name);
420 throw cont.fillInException(
421 new OperationNotSupportedException());
422 }
423
424 public Attributes c_getAttributes(Name name,
425 String[] attrIds,
426 Continuation cont)
427 throws NamingException {
428
429 cont.setSuccess();
430 try {
431 DnsName fqdn = fullyQualify(name);
432 CT[] cts = attrIdsToClassesAndTypes(attrIds);
433 CT ct = getClassAndTypeToQuery(cts);
434 ResourceRecords rrs =
435 getResolver().query(fqdn, ct.rrclass, ct.rrtype,
436 recursion, authoritative);
437 return rrsToAttrs(rrs, cts);
438
439 } catch (NamingException e) {
440 cont.setError(this, name);
441 throw cont.fillInException(e);
442 }
443 }
444
445 public void c_modifyAttributes(Name name,
446 int mod_op,
447 Attributes attrs,
448 Continuation cont)
449 throws NamingException {
450 cont.setError(this, name);
451 throw cont.fillInException(
452 new OperationNotSupportedException());
453 }
454
455 public void c_modifyAttributes(Name name,
456 ModificationItem[] mods,
457 Continuation cont)
458 throws NamingException {
459 cont.setError(this, name);
460 throw cont.fillInException(
461 new OperationNotSupportedException());
462 }
463
464 public NamingEnumeration<SearchResult> c_search(Name name,
465 Attributes matchingAttributes,
466 String[] attributesToReturn,
467 Continuation cont)
468 throws NamingException {
469 throw new OperationNotSupportedException();
470 }
471
472 public NamingEnumeration<SearchResult> c_search(Name name,
473 String filter,
474 SearchControls cons,
475 Continuation cont)
476 throws NamingException {
477 throw new OperationNotSupportedException();
478 }
479
480 public NamingEnumeration<SearchResult> c_search(Name name,
481 String filterExpr,
482 Object[] filterArgs,
483 SearchControls cons,
484 Continuation cont)
485 throws NamingException {
486 throw new OperationNotSupportedException();
487 }
488
489 public DirContext c_getSchema(Name name, Continuation cont)
490 throws NamingException {
491 cont.setError(this, name);
492 throw cont.fillInException(
493 new OperationNotSupportedException());
494 }
495
496 public DirContext c_getSchemaClassDefinition(Name name, Continuation cont)
497 throws NamingException {
498 cont.setError(this, name);
499 throw cont.fillInException(
500 new OperationNotSupportedException());
501 }
502
503
504 //---------- Name-related operations
505
506 public String getNameInNamespace() {
507 return domain.toString();
508 }
509
510 public Name composeName(Name name, Name prefix) throws NamingException {
511 Name result;
512
513 // Any name that's not a CompositeName is assumed to be a DNS
514 // compound name. Convert each to a DnsName for syntax checking.
515 if (!(prefix instanceof DnsName || prefix instanceof CompositeName)) {
516 prefix = (new DnsName()).addAll(prefix);
517 }
518 if (!(name instanceof DnsName || name instanceof CompositeName)) {
519 name = (new DnsName()).addAll(name);
520 }
521
522 // Each of prefix and name is now either a DnsName or a CompositeName.
523
524 // If we have two DnsNames, simply join them together.
525 if ((prefix instanceof DnsName) && (name instanceof DnsName)) {
526 result = (DnsName) (prefix.clone());
527 result.addAll(name);
528 return new CompositeName().add(result.toString());
529 }
530
531 // Wrap compound names in composite names.
532 Name prefixC = (prefix instanceof CompositeName)
533 ? prefix
534 : new CompositeName().add(prefix.toString());
535 Name nameC = (name instanceof CompositeName)
536 ? name
537 : new CompositeName().add(name.toString());
538 int prefixLast = prefixC.size() - 1;
539
540 // Let toolkit do the work at namespace boundaries.
541 if (nameC.isEmpty() || nameC.get(0).equals("") ||
542 prefixC.isEmpty() || prefixC.get(prefixLast).equals("")) {
543 return super.composeName(nameC, prefixC);
544 }
545
546 result = (prefix == prefixC)
547 ? (CompositeName) prefixC.clone()
548 : prefixC; // prefixC is already a clone
549 result.addAll(nameC);
550
551 if (parentIsDns) {
552 DnsName dnsComp = (prefix instanceof DnsName)
553 ? (DnsName) prefix.clone()
554 : new DnsName(prefixC.get(prefixLast));
555 dnsComp.addAll((name instanceof DnsName)
556 ? name
557 : new DnsName(nameC.get(0)));
558 result.remove(prefixLast + 1);
559 result.remove(prefixLast);
560 result.add(prefixLast, dnsComp.toString());
561 }
562 return result;
563 }
564
565
566 //---------- Helper methods
567
568 /*
569 * Resolver is not created until needed, to allow time for updates
570 * to the environment.
571 */
572 private synchronized Resolver getResolver() throws NamingException {
573 if (resolver == null) {
574 resolver = new Resolver(servers, timeout, retries);
575 }
576 return resolver;
577 }
578
579 /*
580 * Returns the fully-qualified domain name of a name given
581 * relative to this context. Result includes a root label (an
582 * empty component at position 0).
583 */
584 DnsName fullyQualify(Name name) throws NamingException {
585 if (name.isEmpty()) {
586 return domain;
587 }
588 DnsName dnsName = (name instanceof CompositeName)
589 ? new DnsName(name.get(0)) // parse name
590 : (DnsName) (new DnsName()).addAll(name); // clone & check syntax
591
592 if (dnsName.hasRootLabel()) {
593 // Be overly generous and allow root label if we're in root domain.
594 if (domain.size() == 1) {
595 return dnsName;
596 } else {
597 throw new InvalidNameException(
598 "DNS name " + dnsName + " not relative to " + domain);
599 }
600 }
601 return (DnsName) dnsName.addAll(0, domain);
602 }
603
604 /*
605 * Converts resource records to an attribute set. Only resource
606 * records in the answer section are used, and only those that
607 * match the classes and types in cts (see classAndTypeMatch()
608 * for matching rules).
609 */
610 private static Attributes rrsToAttrs(ResourceRecords rrs, CT[] cts) {
611
612 BasicAttributes attrs = new BasicAttributes(true);
613
614 for (int i = 0; i < rrs.answer.size(); i++) {
615 ResourceRecord rr = rrs.answer.elementAt(i);
616 int rrtype = rr.getType();
617 int rrclass = rr.getRrclass();
618
619 if (!classAndTypeMatch(rrclass, rrtype, cts)) {
620 continue;
621 }
622
623 String attrId = toAttrId(rrclass, rrtype);
624 Attribute attr = attrs.get(attrId);
625 if (attr == null) {
626 attr = new BasicAttribute(attrId);
627 attrs.put(attr);
628 }
629 attr.add(rr.getRdata());
630 }
631 return attrs;
632 }
633
634 /*
635 * Returns true if rrclass and rrtype match some element of cts.
636 * A match occurs if corresponding classes and types are equal,
637 * or if the array value is ANY. If cts is null, then any class
638 * and type match.
639 */
640 private static boolean classAndTypeMatch(int rrclass, int rrtype,
641 CT[] cts) {
642 if (cts == null) {
643 return true;
644 }
645 for (int i = 0; i < cts.length; i++) {
646 CT ct = cts[i];
647 boolean classMatch = (ct.rrclass == ANY) ||
648 (ct.rrclass == rrclass);
649 boolean typeMatch = (ct.rrtype == ANY) ||
650 (ct.rrtype == rrtype);
651 if (classMatch && typeMatch) {
652 return true;
653 }
654 }
655 return false;
656 }
657
658 /*
659 * Returns the attribute ID for a resource record given its class
660 * and type. If the record is in the internet class, the
661 * corresponding attribute ID is the record's type name (or the
662 * integer type value if the name is not known). If the record is
663 * not in the internet class, the class name (or integer class
664 * value) is prepended to the attribute ID, separated by a space.
665 *
666 * A class or type value of ANY represents an indeterminate class
667 * or type, and is represented within the attribute ID by "*".
668 * For example, the attribute ID "IN *" represents
669 * any type in the internet class, and "* NS" represents an NS
670 * record of any class.
671 */
672 private static String toAttrId(int rrclass, int rrtype) {
673 String attrId = ResourceRecord.getTypeName(rrtype);
674 if (rrclass != ResourceRecord.CLASS_INTERNET) {
675 attrId = ResourceRecord.getRrclassName(rrclass) + " " + attrId;
676 }
677 return attrId;
678 }
679
680 /*
681 * Returns the class and type values corresponding to an attribute
682 * ID. An indeterminate class or type is represented by ANY. See
683 * toAttrId() for the format of attribute IDs.
684 *
685 * @throws InvalidAttributeIdentifierException
686 * if class or type is unknown
687 */
688 private static CT fromAttrId(String attrId)
689 throws InvalidAttributeIdentifierException {
690
691 if (attrId.equals("")) {
692 throw new InvalidAttributeIdentifierException(
693 "Attribute ID cannot be empty");
694 }
695 int rrclass;
696 int rrtype;
697 int space = attrId.indexOf(' ');
698
699 // class
700 if (space < 0) {
701 rrclass = ResourceRecord.CLASS_INTERNET;
702 } else {
703 String className = attrId.substring(0, space);
704 rrclass = ResourceRecord.getRrclass(className);
705 if (rrclass < 0) {
706 throw new InvalidAttributeIdentifierException(
707 "Unknown resource record class '" + className + '\'');
708 }
709 }
710
711 // type
712 String typeName = attrId.substring(space + 1);
713 rrtype = ResourceRecord.getType(typeName);
714 if (rrtype < 0) {
715 throw new InvalidAttributeIdentifierException(
716 "Unknown resource record type '" + typeName + '\'');
717 }
718
719 return new CT(rrclass, rrtype);
720 }
721
722 /*
723 * Returns an array of the classes and types corresponding to a
724 * set of attribute IDs. See toAttrId() for the format of
725 * attribute IDs, and classAndTypeMatch() for the format of the
726 * array returned.
727 */
728 private static CT[] attrIdsToClassesAndTypes(String[] attrIds)
729 throws InvalidAttributeIdentifierException {
730 if (attrIds == null) {
731 return null;
732 }
733 CT[] cts = new CT[attrIds.length];
734
735 for (int i = 0; i < attrIds.length; i++) {
736 cts[i] = fromAttrId(attrIds[i]);
737 }
738 return cts;
739 }
740
741 /*
742 * Returns the most restrictive resource record class and type
743 * that may be used to query for records matching cts.
744 * See classAndTypeMatch() for matching rules.
745 */
746 private static CT getClassAndTypeToQuery(CT[] cts) {
747 int rrclass;
748 int rrtype;
749
750 if (cts == null) {
751 // Query all records.
752 rrclass = ANY;
753 rrtype = ANY;
754 } else if (cts.length == 0) {
755 // No records are requested, but we need to ask for something.
756 rrclass = ResourceRecord.CLASS_INTERNET;
757 rrtype = ANY;
758 } else {
759 rrclass = cts[0].rrclass;
760 rrtype = cts[0].rrtype;
761 for (int i = 1; i < cts.length; i++) {
762 if (rrclass != cts[i].rrclass) {
763 rrclass = ANY;
764 }
765 if (rrtype != cts[i].rrtype) {
766 rrtype = ANY;
767 }
768 }
769 }
770 return new CT(rrclass, rrtype);
771 }
772
773
774 //---------- Support for list operations
775
776 /*
777 * Synchronization notes:
778 *
779 * Any access to zoneTree that walks the tree, whether it modifies
780 * the tree or not, is synchronized on zoneTree.
781 * [%%% Note: a read/write lock would allow increased concurrency.]
782 * The depth of a ZoneNode can thereafter be accessed without
783 * further synchronization. Access to other fields and methods
784 * should be synchronized on the node itself.
785 *
786 * A zone's contents is a NameNode tree that, once created, is never
787 * modified. The only synchronization needed is to ensure that it
788 * gets flushed into shared memory after being created, which is
789 * accomplished by ZoneNode.populate(). The contents are accessed
790 * via a soft reference, so a ZoneNode may be seen to be populated
791 * one moment and unpopulated the next.
792 */
793
794 /*
795 * Returns the node in the zone tree corresponding to a
796 * fully-qualified domain name. If the desired portion of the
797 * tree has not yet been populated or has been outdated, a zone
798 * transfer is done to populate the tree.
799 */
800 private NameNode getNameNode(DnsName fqdn) throws NamingException {
801 dprint("getNameNode(" + fqdn + ")");
802
803 // Find deepest related zone in zone tree.
804 ZoneNode znode;
805 DnsName zone;
806 synchronized (zoneTree) {
807 znode = zoneTree.getDeepestPopulated(fqdn);
808 }
809 dprint("Deepest related zone in zone tree: " +
810 ((znode != null) ? znode.getLabel() : "[none]"));
811
812 NameNode topOfZone;
813 NameNode nnode;
814
815 if (znode != null) {
816 synchronized (znode) {
817 topOfZone = znode.getContents();
818 }
819 // If fqdn is in znode's zone, is not at a zone cut, and
820 // is current, we're done.
821 if (topOfZone != null) {
822 nnode = topOfZone.get(fqdn, znode.depth() + 1); // +1 for root
823
824 if ((nnode != null) && !nnode.isZoneCut()) {
825 dprint("Found node " + fqdn + " in zone tree");
826 zone = (DnsName)
827 fqdn.getPrefix(znode.depth() + 1); // +1 for root
828 boolean current = isZoneCurrent(znode, zone);
829 boolean restart = false;
830
831 synchronized (znode) {
832 if (topOfZone != znode.getContents()) {
833 // Zone was modified while we were examining it.
834 // All bets are off.
835 restart = true;
836 } else if (!current) {
837 znode.depopulate();
838 } else {
839 return nnode; // cache hit!
840 }
841 }
842 dprint("Zone not current; discarding node");
843 if (restart) {
844 return getNameNode(fqdn);
845 }
846 }
847 }
848 }
849
850 // Cache miss... do it the expensive way.
851 dprint("Adding node " + fqdn + " to zone tree");
852
853 // Find fqdn's zone and add it to the tree.
854 zone = getResolver().findZoneName(fqdn, ResourceRecord.CLASS_INTERNET,
855 recursion);
856 dprint("Node's zone is " + zone);
857 synchronized (zoneTree) {
858 znode = (ZoneNode) zoneTree.add(zone, 1); // "1" to skip root
859 }
860
861 // If znode is now populated we know -- because the first half of
862 // getNodeName() didn't find it -- that it was populated by another
863 // thread during this method call. Assume then that it's current.
864
865 synchronized (znode) {
866 topOfZone = znode.isPopulated()
867 ? znode.getContents()
868 : populateZone(znode, zone);
869 }
870 // Desired node should now be in znode's populated zone. Find it.
871 nnode = topOfZone.get(fqdn, zone.size());
872 if (nnode == null) {
873 throw new ConfigurationException(
874 "DNS error: node not found in its own zone");
875 }
876 dprint("Found node in newly-populated zone");
877 return nnode;
878 }
879
880 /*
881 * Does a zone transfer to [re]populate a zone in the zone tree.
882 * Returns the zone's new contents.
883 */
884 private NameNode populateZone(ZoneNode znode, DnsName zone)
885 throws NamingException {
886 dprint("Populating zone " + zone);
887 // assert Thread.holdsLock(znode);
888 ResourceRecords rrs =
889 getResolver().queryZone(zone,
890 ResourceRecord.CLASS_INTERNET, recursion);
891 dprint("zone xfer complete: " + rrs.answer.size() + " records");
892 return znode.populate(zone, rrs);
893 }
894
895 /*
896 * Determine if a ZoneNode's data is current.
897 * We base this on a comparison between the cached serial
898 * number and the latest SOA record.
899 *
900 * If there is no SOA record, znode is not (or is no longer) a zone:
901 * depopulate znode and return false.
902 *
903 * Since this method may perform a network operation, it is best
904 * to call it with znode unlocked. Caller must then note that the
905 * result may be outdated by the time this method returns.
906 */
907 private boolean isZoneCurrent(ZoneNode znode, DnsName zone)
908 throws NamingException {
909 // former version: return !znode.isExpired();
910
911 if (!znode.isPopulated()) {
912 return false;
913 }
914 ResourceRecord soa =
915 getResolver().findSoa(zone, ResourceRecord.CLASS_INTERNET,
916 recursion);
917 synchronized (znode) {
918 if (soa == null) {
919 znode.depopulate();
920 }
921 return (znode.isPopulated() &&
922 znode.compareSerialNumberTo(soa) >= 0);
923 }
924 }
925
926
927 //---------- Debugging
928
929 private static final boolean debug = false;
930
931 private static final void dprint(String msg) {
932 if (debug) {
933 System.err.println("** " + msg);
934 }
935 }
936 }
937
938
939 //----------
940
941 /*
942 * A pairing of a resource record class and a resource record type.
943 * A value of ANY in either field represents an indeterminate value.
944 */
945 class CT {
946 int rrclass;
947 int rrtype;
948
949 CT(int rrclass, int rrtype) {
950 this.rrclass = rrclass;
951 this.rrtype = rrtype;
952 }
953 }
954
955
956 //----------
957
958 /*
959 * Common base class for NameClassPairEnumeration and BindingEnumeration.
960 */
961 abstract class BaseNameClassPairEnumeration<T> implements NamingEnumeration<T> {
962
963 protected Enumeration<NameNode> nodes; // nodes to be enumerated, or null if none
964 protected DnsContext ctx; // context being enumerated
965
966 BaseNameClassPairEnumeration(DnsContext ctx, Hashtable<String,NameNode> nodes) {
967 this.ctx = ctx;
968 this.nodes = (nodes != null)
969 ? nodes.elements()
970 : null;
971 }
972
973 /*
974 * ctx will be set to null when no longer needed by the enumeration.
975 */
976 public final void close() {
977 nodes = null;
978 ctx = null;
979 }
980
981 public final boolean hasMore() {
982 boolean more = ((nodes != null) && nodes.hasMoreElements());
983 if (!more) {
984 close();
985 }
986 return more;
987 }
988
989 public final boolean hasMoreElements() {
990 return hasMore();
991 }
992
993 abstract public T next() throws NamingException;
994
995 public final T nextElement() {
996 try {
997 return next();
998 } catch (NamingException e) {
999 java.util.NoSuchElementException nsee =
1000 new java.util.NoSuchElementException();
1001 nsee.initCause(e);
1002 throw nsee;
1003 }
1004 }
1005 }
1006
1007 /*
1008 * An enumeration of name/classname pairs.
1009 *
1010 * Nodes that have children or that are zone cuts are returned with
1011 * classname DirContext. Other nodes are returned with classname
1012 * Object even though they are DirContexts as well, since this might
1013 * make the namespace easier to browse.
1014 */
1015 final class NameClassPairEnumeration
1016 extends BaseNameClassPairEnumeration<NameClassPair>
1017 implements NamingEnumeration<NameClassPair> {
1018
1019 NameClassPairEnumeration(DnsContext ctx, Hashtable<String,NameNode> nodes) {
1020 super(ctx, nodes);
1021 }
1022
1023 @Override
1024 public NameClassPair next() throws NamingException {
1025 if (!hasMore()) {
1026 throw new java.util.NoSuchElementException();
1027 }
1028 NameNode nnode = nodes.nextElement();
1029 String className = (nnode.isZoneCut() ||
1030 (nnode.getChildren() != null))
1031 ? "javax.naming.directory.DirContext"
1032 : "java.lang.Object";
1033
1034 String label = nnode.getLabel();
1035 Name compName = (new DnsName()).add(label);
1036 Name cname = (new CompositeName()).add(compName.toString());
1037
1038 NameClassPair ncp = new NameClassPair(cname.toString(), className);
1039 ncp.setNameInNamespace(ctx.fullyQualify(cname).toString());
1040 return ncp;
1041 }
1042 }
1043
1044 /*
1045 * An enumeration of Bindings.
1046 */
1047 final class BindingEnumeration extends BaseNameClassPairEnumeration<Binding>
1048 implements NamingEnumeration<Binding> {
1049
1050 BindingEnumeration(DnsContext ctx, Hashtable<String,NameNode> nodes) {
1051 super(ctx, nodes);
1052 }
1053
1054 // Finalizer not needed since it's safe to leave ctx unclosed.
1055 // protected void finalize() {
1056 // close();
1057 // }
1058
1059 @Override
1060 public Binding next() throws NamingException {
1061 if (!hasMore()) {
1062 throw (new java.util.NoSuchElementException());
1063 }
1064 NameNode nnode = nodes.nextElement();
1065
1066 String label = nnode.getLabel();
1067 Name compName = (new DnsName()).add(label);
1068 String compNameStr = compName.toString();
1069 Name cname = (new CompositeName()).add(compNameStr);
1070 String cnameStr = cname.toString();
1071
1072 DnsName fqdn = ctx.fullyQualify(compName);
1073
1074 // Clone ctx to create the child context.
1075 DnsContext child = new DnsContext(ctx, fqdn);
1076
1077 try {
1078 Object obj = DirectoryManager.getObjectInstance(
1079 child, cname, ctx, child.environment, null);
1080 Binding binding = new Binding(cnameStr, obj);
1081 binding.setNameInNamespace(ctx.fullyQualify(cname).toString());
1082 return binding;
1083 } catch (Exception e) {
1084 NamingException ne = new NamingException(
1085 "Problem generating object using object factory");
1086 ne.setRootCause(e);
1087 throw ne;
1088 }
1089 }
1090 }