001/*
002 * Copyright 2015-2020 the original author or authors
003 *
004 * This software is licensed under the Apache License, Version 2.0,
005 * the GNU Lesser General Public License version 2 or later ("LGPL")
006 * and the WTFPL.
007 * You may choose either license to govern your use of this software only
008 * upon the condition that you accept all of the terms of either
009 * the Apache License 2.0, the LGPL 2.1+ or the WTFPL.
010 */
011package org.minidns.record;
012
013import java.io.ByteArrayOutputStream;
014import java.io.DataInputStream;
015import java.io.DataOutputStream;
016import java.io.IOException;
017import java.io.OutputStream;
018import java.util.ArrayList;
019import java.util.Collection;
020import java.util.HashMap;
021import java.util.List;
022import java.util.Map;
023
024import org.minidns.dnsmessage.DnsMessage;
025import org.minidns.dnsmessage.Question;
026import org.minidns.dnsname.DnsName;
027
028/**
029 * A generic DNS record.
030 */
031public final class Record<D extends Data> {
032
033    /**
034     * The resource record type.
035     * 
036     * @see <a href=
037     *      "http://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4">
038     *      IANA DNS Parameters - Resource Record (RR) TYPEs</a>
039     */
040    public enum TYPE {
041        UNKNOWN(-1),
042        A(1, A.class),
043        NS(2, NS.class),
044        MD(3),
045        MF(4),
046        CNAME(5, CNAME.class),
047        SOA(6, SOA.class),
048        MB(7),
049        MG(8),
050        MR(9),
051        NULL(10),
052        WKS(11),
053        PTR(12, PTR.class),
054        HINFO(13),
055        MINFO(14),
056        MX(15, MX.class),
057        TXT(16, TXT.class),
058        RP(17),
059        AFSDB(18),
060        X25(19),
061        ISDN(20),
062        RT(21),
063        NSAP(22),
064        NSAP_PTR(23),
065        SIG(24),
066        KEY(25),
067        PX(26),
068        GPOS(27),
069        AAAA(28, AAAA.class),
070        LOC(29),
071        NXT(30),
072        EID(31),
073        NIMLOC(32),
074        SRV(33, SRV.class),
075        ATMA(34),
076        NAPTR(35),
077        KX(36),
078        CERT(37),
079        A6(38),
080        DNAME(39, DNAME.class),
081        SINK(40),
082        OPT(41, OPT.class),
083        APL(42),
084        DS(43, DS.class),
085        SSHFP(44),
086        IPSECKEY(45),
087        RRSIG(46, RRSIG.class),
088        NSEC(47, NSEC.class),
089        DNSKEY(48, DNSKEY.class),
090        DHCID(49),
091        NSEC3(50, NSEC3.class),
092        NSEC3PARAM(51, NSEC3PARAM.class),
093        TLSA(52, TLSA.class),
094        HIP(55),
095        NINFO(56),
096        RKEY(57),
097        TALINK(58),
098        CDS(59),
099        CDNSKEY(60),
100        OPENPGPKEY(61, OPENPGPKEY.class),
101        CSYNC(62),
102        SPF(99),
103        UINFO(100),
104        UID(101),
105        GID(102),
106        UNSPEC(103),
107        NID(104),
108        L32(105),
109        L64(106),
110        LP(107),
111        EUI48(108),
112        EUI64(109),
113        TKEY(249),
114        TSIG(250),
115        IXFR(251),
116        AXFR(252),
117        MAILB(253),
118        MAILA(254),
119        ANY(255),
120        URI(256),
121        CAA(257),
122        TA(32768),
123        DLV(32769, DLV.class),
124        ;
125
126        /**
127         * The value of this DNS record type.
128         */
129        private final int value;
130
131        private final Class<?> dataClass;
132
133        /**
134         * Internal lookup table to map values to types.
135         */
136        private static final Map<Integer, TYPE> INVERSE_LUT = new HashMap<>();
137
138        private static final Map<Class<?>, TYPE> DATA_LUT = new HashMap<>();
139
140        static {
141            // Initialize the reverse lookup table.
142            for (TYPE t : TYPE.values()) {
143                INVERSE_LUT.put(t.getValue(), t);
144                if (t.dataClass != null) {
145                    DATA_LUT.put(t.dataClass, t);
146                }
147            }
148        }
149
150        /**
151         * Create a new record type.
152         * 
153         * @param value The binary value of this type.
154         */
155        TYPE(int value) {
156            this(value, null);
157        }
158
159        /**
160         * Create a new record type.
161         *
162         * @param <D> The class for this type.
163         * @param dataClass The class for this type.
164         * @param value The binary value of this type.
165         */
166        <D extends Data> TYPE(int value, Class<D> dataClass) {
167            this.value = value;
168            this.dataClass = dataClass;
169        }
170
171        /**
172         * Retrieve the binary value of this type.
173         * @return The binary value.
174         */
175        public int getValue() {
176            return value;
177        }
178
179        /**
180         * Get the {@link Data} class for this type.
181         *
182         * @param <D> The class for this type.
183         * @return the {@link Data} class for this type.
184         */
185        @SuppressWarnings("unchecked")
186        public <D extends Data> Class<D> getDataClass() {
187            return (Class<D>) dataClass;
188        }
189
190        /**
191         * Retrieve the symbolic type of the binary value.
192         * @param value The binary type value.
193         * @return The symbolic tpye.
194         */
195        public static TYPE getType(int value) {
196            TYPE type = INVERSE_LUT.get(value);
197            if (type == null) return UNKNOWN;
198            return type;
199        }
200
201        /**
202         * Retrieve the type for a given {@link Data} class.
203         *
204         * @param <D> The class for this type.
205         * @param dataClass the class to lookup the type for.
206         * @return the type for the given data class.
207         */
208        public static <D extends Data> TYPE getType(Class<D> dataClass) {
209            return DATA_LUT.get(dataClass);
210        }
211    }
212
213    /**
214     * The symbolic class of a DNS record (usually {@link CLASS#IN} for Internet).
215     *
216     * @see <a href="http://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-2">IANA Domain Name System (DNS) Parameters - DNS CLASSes</a>
217     */
218    public enum CLASS {
219
220        /**
221         * The Internet class. This is the most common class used by todays DNS systems.
222         */
223        IN(1),
224
225        /**
226         * The Chaos class.
227         */
228        CH(3),
229
230        /**
231         * The Hesiod class.
232         */
233        HS(4),
234        NONE(254),
235        ANY(255);
236
237        /**
238         * Internal reverse lookup table to map binary class values to symbolic
239         * names.
240         */
241        private static final HashMap<Integer, CLASS> INVERSE_LUT =
242                                            new HashMap<Integer, CLASS>();
243
244        static {
245            // Initialize the interal reverse lookup table.
246            for (CLASS c : CLASS.values()) {
247                INVERSE_LUT.put(c.getValue(), c);
248            }
249        }
250
251        /**
252         * The binary value of this dns class.
253         */
254        private final int value;
255
256        /**
257         * Create a new DNS class based on a binary value.
258         * @param value The binary value of this DNS class.
259         */
260        CLASS(int value) {
261            this.value = value;
262        }
263
264        /**
265         * Retrieve the binary value of this DNS class.
266         * @return The binary value of this DNS class.
267         */
268        public int getValue() {
269            return value;
270        }
271
272        /**
273         * Retrieve the symbolic DNS class for a binary class value.
274         * @param value The binary DNS class value.
275         * @return The symbolic class instance.
276         */
277        public static CLASS getClass(int value) {
278            return INVERSE_LUT.get(value);
279        }
280
281    }
282
283    /**
284     * The generic name of this record.
285     */
286    public final DnsName name;
287
288    /**
289     * The type (and payload type) of this record.
290     */
291    public final TYPE type;
292
293    /**
294     * The record class (usually CLASS.IN).
295     */
296    public final CLASS clazz;
297
298    /**
299     * The value of the class field of a RR.
300     * 
301     * According to RFC 2671 (OPT RR) this is not necessarily representable
302     * using clazz field and unicastQuery bit
303     */
304    public final int clazzValue;
305
306    /**
307     * The ttl of this record.
308     */
309    public final long ttl;
310
311    /**
312     * The payload object of this record.
313     */
314    public final D payloadData;
315
316    /**
317     * MDNS defines the highest bit of the class as the unicast query bit.
318     */
319    public final boolean unicastQuery;
320
321    /**
322     * Parse a given record based on the full message data and the current
323     * stream position.
324     *
325     * @param dis The DataInputStream positioned at the first record byte.
326     * @param data The full message data.
327     * @return the record which was parsed.
328     * @throws IOException In case of malformed replies.
329     */
330    public static Record<Data> parse(DataInputStream dis, byte[] data) throws IOException {
331        DnsName name = DnsName.parse(dis, data);
332        int typeValue = dis.readUnsignedShort();
333        TYPE type = TYPE.getType(typeValue);
334        int clazzValue = dis.readUnsignedShort();
335        CLASS clazz = CLASS.getClass(clazzValue & 0x7fff);
336        boolean unicastQuery = (clazzValue & 0x8000) > 0;
337        long ttl = (((long) dis.readUnsignedShort()) << 16) +
338                   dis.readUnsignedShort();
339        int payloadLength = dis.readUnsignedShort();
340        Data payloadData;
341        switch (type) {
342            case SOA:
343                payloadData = SOA.parse(dis, data);
344                break;
345            case SRV:
346                payloadData = SRV.parse(dis, data);
347                break;
348            case MX:
349                payloadData = MX.parse(dis, data);
350                break;
351            case AAAA:
352                payloadData = AAAA.parse(dis);
353                break;
354            case A:
355                payloadData = A.parse(dis);
356                break;
357            case NS:
358                payloadData = NS.parse(dis, data);
359                break;
360            case CNAME:
361                payloadData = CNAME.parse(dis, data);
362                break;
363            case DNAME:
364                payloadData = DNAME.parse(dis, data);
365                break;
366            case PTR:
367                payloadData = PTR.parse(dis, data);
368                break;
369            case TXT:
370                payloadData = TXT.parse(dis, payloadLength);
371                break;
372            case OPT:
373                payloadData = OPT.parse(dis, payloadLength);
374                break;
375            case DNSKEY:
376                payloadData = DNSKEY.parse(dis, payloadLength);
377                break;
378            case RRSIG:
379                payloadData = RRSIG.parse(dis, data, payloadLength);
380                break;
381            case DS:
382                payloadData = DS.parse(dis, payloadLength);
383                break;
384            case NSEC:
385                payloadData = NSEC.parse(dis, data, payloadLength);
386                break;
387            case NSEC3:
388                payloadData = NSEC3.parse(dis, payloadLength);
389                break;
390            case NSEC3PARAM:
391                payloadData = NSEC3PARAM.parse(dis);
392                break;
393            case TLSA:
394                payloadData = TLSA.parse(dis, payloadLength);
395                break;
396            case OPENPGPKEY:
397                payloadData = OPENPGPKEY.parse(dis, payloadLength);
398                break;
399            case DLV:
400                payloadData = DLV.parse(dis, payloadLength);
401                break;
402            case UNKNOWN:
403            default:
404                payloadData = UNKNOWN.parse(dis, payloadLength, type);
405                break;
406        }
407        return new Record<>(name, type, clazz, clazzValue, ttl, payloadData, unicastQuery);
408    }
409
410    public Record(DnsName name, TYPE type, CLASS clazz, long ttl, D payloadData, boolean unicastQuery) {
411        this(name, type, clazz, clazz.getValue() + (unicastQuery ? 0x8000 : 0), ttl, payloadData, unicastQuery);
412    }
413
414    public Record(String name, TYPE type, CLASS clazz, long ttl, D payloadData, boolean unicastQuery) {
415        this(DnsName.from(name), type, clazz, ttl, payloadData, unicastQuery);
416    }
417
418    public Record(String name, TYPE type, int clazzValue, long ttl, D payloadData) {
419        this(DnsName.from(name), type, CLASS.NONE, clazzValue, ttl, payloadData, false);
420    }
421
422    public Record(DnsName name, TYPE type, int clazzValue, long ttl, D payloadData) {
423        this(name, type, CLASS.NONE, clazzValue, ttl, payloadData, false);
424    }
425
426    private Record(DnsName name, TYPE type, CLASS clazz, int clazzValue, long ttl, D payloadData, boolean unicastQuery) {
427        this.name = name;
428        this.type = type;
429        this.clazz = clazz;
430        this.clazzValue = clazzValue;
431        this.ttl = ttl;
432        this.payloadData = payloadData;
433        this.unicastQuery = unicastQuery;
434    }
435
436    public void toOutputStream(OutputStream outputStream) throws IOException {
437        if (payloadData == null) {
438            throw new IllegalStateException("Empty Record has no byte representation");
439        }
440
441        DataOutputStream dos = new DataOutputStream(outputStream);
442
443        name.writeToStream(dos);
444        dos.writeShort(type.getValue());
445        dos.writeShort(clazzValue);
446        dos.writeInt((int) ttl);
447
448        dos.writeShort(payloadData.length());
449        payloadData.toOutputStream(dos);
450    }
451
452    private transient byte[] bytes;
453
454    public byte[] toByteArray() {
455        if (bytes == null) {
456            int totalSize = name.size()
457                    + 10 // 2 byte short type + 2 byte short classValue + 4 byte int ttl + 2 byte short payload length.
458                    + payloadData.length();
459            ByteArrayOutputStream baos = new ByteArrayOutputStream(totalSize);
460            DataOutputStream dos = new DataOutputStream(baos);
461            try {
462                toOutputStream(dos);
463            } catch (IOException e) {
464                // Should never happen.
465                throw new AssertionError(e);
466            }
467            bytes = baos.toByteArray();
468        }
469        return bytes.clone();
470    }
471
472    /**
473     * Retrieve a textual representation of this resource record.
474     * @return String
475     */
476    @Override
477    public String toString() {
478        return name.getRawAce() + ".\t" + ttl + '\t' + clazz + '\t' + type + '\t' + payloadData;
479    }
480
481    /**
482     * Check if this record answers a given query.
483     * @param q The query.
484     * @return True if this record is a valid answer.
485     */
486    public boolean isAnswer(Question q) {
487        return ((q.type == type) || (q.type == TYPE.ANY)) &&
488               ((q.clazz == clazz) || (q.clazz == CLASS.ANY)) &&
489               q.name.equals(name);
490    }
491
492    /**
493     * See if this query/response was a unicast query (highest class bit set).
494     * @return True if it is a unicast query/response record.
495     */
496    public boolean isUnicastQuery() {
497        return unicastQuery;
498    }
499
500    /**
501     * The payload data, usually a subclass of data (A, AAAA, CNAME, ...).
502     * @return The payload data.
503     */
504    public D getPayload() {
505        return payloadData;
506    }
507
508    /**
509     * Retrieve the record ttl.
510     * @return The record ttl.
511     */
512    public long getTtl() {
513        return ttl;
514    }
515
516    /**
517     * Get the question asking for this resource record. This will return <code>null</code> if the record is not retrievable, i.e.
518     * {@link TYPE#OPT}.
519     *
520     * @return the question for this resource record or <code>null</code>.
521     */
522    public Question getQuestion() {
523        switch (type) {
524        case OPT:
525            // OPT records are not retrievable.
526            return null;
527        case RRSIG:
528            RRSIG rrsig = (RRSIG) payloadData;
529            return new Question(name, rrsig.typeCovered, clazz);
530        default:
531            return new Question(name, type, clazz);
532        }
533    }
534
535    public DnsMessage.Builder getQuestionMessage() {
536        Question question = getQuestion();
537        if (question == null) {
538            return null;
539        }
540        return question.asMessageBuilder();
541    }
542
543    private transient Integer hashCodeCache;
544
545    @Override
546    public int hashCode() {
547        if (hashCodeCache == null) {
548            int hashCode = 1;
549            hashCode = 37 * hashCode + name.hashCode();
550            hashCode = 37 * hashCode + type.hashCode();
551            hashCode = 37 * hashCode + clazz.hashCode();
552            hashCode = 37 * hashCode + payloadData.hashCode();
553            hashCodeCache = hashCode;
554        }
555        return hashCodeCache;
556    }
557
558    @Override
559    public boolean equals(Object other) {
560        if (!(other instanceof Record)) {
561            return false;
562        }
563        if (other == this) {
564            return true;
565        }
566        Record<?> otherRecord = (Record<?>) other;
567        if (!name.equals(otherRecord.name)) return false;
568        if (type != otherRecord.type) return false;
569        if (clazz != otherRecord.clazz) return false;
570        // Note that we do not compare the TTL here, since we consider two Records with everything but the TTL equal to
571        // be equal too.
572        if (!payloadData.equals(otherRecord.payloadData)) return false;
573
574        return true;
575    }
576
577    /**
578     * Return the record if possible as record with the given {@link Data} class. If the record does not hold payload of
579     * the given data class type, then {@code null} will be returned.
580     *
581     * @param dataClass a class of the {@link Data} type.
582     * @param <E> a subtype of {@link Data}.
583     * @return the record with a specialized payload type or {@code null}.
584     * @see #as(Class)
585     */
586    @SuppressWarnings("unchecked")
587    public <E extends Data> Record<E> ifPossibleAs(Class<E> dataClass) {
588        if (type.dataClass == dataClass) {
589            return (Record<E>) this;
590        }
591        return null;
592    }
593
594    /**
595     * Return the record as record with the given {@link Data} class. If the record does not hold payload of
596     * the given data class type, then a {@link IllegalArgumentException} will be thrown.
597     *
598     * @param dataClass a class of the {@link Data} type.
599     * @param <E> a subtype of {@link Data}.
600     * @return the record with a specialized payload type.
601     * @see #ifPossibleAs(Class)
602     */
603    public <E extends Data> Record<E> as(Class<E> dataClass) {
604        Record<E> eRecord = ifPossibleAs(dataClass);
605        if (eRecord == null) {
606            throw new IllegalArgumentException("The instance " + this + " can not be cast to a Record with" + dataClass);
607        }
608        return eRecord;
609    }
610
611    public static <E extends Data> void filter(Collection<Record<E>> result, Class<E> dataClass,
612            Collection<Record<? extends Data>> input) {
613        for (Record<? extends Data> record : input) {
614            Record<E> filteredRecord = record.ifPossibleAs(dataClass);
615            if (filteredRecord == null)
616                continue;
617
618            result.add(filteredRecord);
619        }
620    }
621
622    public static <E extends Data> List<Record<E>> filter(Class<E> dataClass,
623            Collection<Record<? extends Data>> input) {
624        List<Record<E>> result = new ArrayList<>(input.size());
625        filter(result, dataClass, input);
626        return result;
627    }
628}