/*
|
* Copyright (C) 2019 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package android.net;
|
|
import android.annotation.NonNull;
|
import android.annotation.Nullable;
|
import android.text.TextUtils;
|
|
import com.android.internal.util.BitUtils;
|
|
import java.nio.BufferUnderflowException;
|
import java.nio.ByteBuffer;
|
import java.text.DecimalFormat;
|
import java.text.FieldPosition;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* Defines basic data for DNS protocol based on RFC 1035.
|
* Subclasses create the specific format used in DNS packet.
|
*
|
* @hide
|
*/
|
public abstract class DnsPacket {
|
public class DnsHeader {
|
private static final String TAG = "DnsHeader";
|
public final int id;
|
public final int flags;
|
public final int rcode;
|
private final int[] mRecordCount;
|
|
/**
|
* Create a new DnsHeader from a positioned ByteBuffer.
|
*
|
* The ByteBuffer must be in network byte order (which is the default).
|
* Reads the passed ByteBuffer from its current position and decodes a DNS header.
|
* When this constructor returns, the reading position of the ByteBuffer has been
|
* advanced to the end of the DNS header record.
|
* This is meant to chain with other methods reading a DNS response in sequence.
|
*/
|
DnsHeader(@NonNull ByteBuffer buf) throws BufferUnderflowException {
|
id = BitUtils.uint16(buf.getShort());
|
flags = BitUtils.uint16(buf.getShort());
|
rcode = flags & 0xF;
|
mRecordCount = new int[NUM_SECTIONS];
|
for (int i = 0; i < NUM_SECTIONS; ++i) {
|
mRecordCount[i] = BitUtils.uint16(buf.getShort());
|
}
|
}
|
|
/**
|
* Get record count by type.
|
*/
|
public int getRecordCount(int type) {
|
return mRecordCount[type];
|
}
|
}
|
|
/**
|
* Superclass for DNS questions and DNS resource records.
|
*
|
* DNS questions (No TTL/RDATA)
|
* DNS resource records (With TTL/RDATA)
|
*/
|
public class DnsRecord {
|
private static final int MAXNAMESIZE = 255;
|
private static final int MAXLABELSIZE = 63;
|
private static final int MAXLABELCOUNT = 128;
|
private static final int NAME_NORMAL = 0;
|
private static final int NAME_COMPRESSION = 0xC0;
|
private final DecimalFormat byteFormat = new DecimalFormat();
|
private final FieldPosition pos = new FieldPosition(0);
|
|
private static final String TAG = "DnsRecord";
|
|
public final String dName;
|
public final int nsType;
|
public final int nsClass;
|
public final long ttl;
|
private final byte[] mRdata;
|
|
/**
|
* Create a new DnsRecord from a positioned ByteBuffer.
|
*
|
* Reads the passed ByteBuffer from its current position and decodes a DNS record.
|
* When this constructor returns, the reading position of the ByteBuffer has been
|
* advanced to the end of the DNS header record.
|
* This is meant to chain with other methods reading a DNS response in sequence.
|
*
|
* @param ByteBuffer input of record, must be in network byte order
|
* (which is the default).
|
*/
|
DnsRecord(int recordType, @NonNull ByteBuffer buf)
|
throws BufferUnderflowException, ParseException {
|
dName = parseName(buf, 0 /* Parse depth */);
|
if (dName.length() > MAXNAMESIZE) {
|
throw new ParseException(
|
"Parse name fail, name size is too long: " + dName.length());
|
}
|
nsType = BitUtils.uint16(buf.getShort());
|
nsClass = BitUtils.uint16(buf.getShort());
|
|
if (recordType != QDSECTION) {
|
ttl = BitUtils.uint32(buf.getInt());
|
final int length = BitUtils.uint16(buf.getShort());
|
mRdata = new byte[length];
|
buf.get(mRdata);
|
} else {
|
ttl = 0;
|
mRdata = null;
|
}
|
}
|
|
/**
|
* Get a copy of rdata.
|
*/
|
@Nullable
|
public byte[] getRR() {
|
return (mRdata == null) ? null : mRdata.clone();
|
}
|
|
/**
|
* Convert label from {@code byte[]} to {@code String}
|
*
|
* Follows the same conversion rules of the native code (ns_name.c in libc)
|
*/
|
private String labelToString(@NonNull byte[] label) {
|
final StringBuffer sb = new StringBuffer();
|
for (int i = 0; i < label.length; ++i) {
|
int b = BitUtils.uint8(label[i]);
|
// Control characters and non-ASCII characters.
|
if (b <= 0x20 || b >= 0x7f) {
|
// Append the byte as an escaped decimal number, e.g., "\19" for 0x13.
|
sb.append('\\');
|
byteFormat.format(b, sb, pos);
|
} else if (b == '"' || b == '.' || b == ';' || b == '\\'
|
|| b == '(' || b == ')' || b == '@' || b == '$') {
|
// Append the byte as an escaped character, e.g., "\:" for 0x3a.
|
sb.append('\\');
|
sb.append((char) b);
|
} else {
|
// Append the byte as a character, e.g., "a" for 0x61.
|
sb.append((char) b);
|
}
|
}
|
return sb.toString();
|
}
|
|
private String parseName(@NonNull ByteBuffer buf, int depth) throws
|
BufferUnderflowException, ParseException {
|
if (depth > MAXLABELCOUNT) {
|
throw new ParseException("Failed to parse name, too many labels");
|
}
|
final int len = BitUtils.uint8(buf.get());
|
final int mask = len & NAME_COMPRESSION;
|
if (0 == len) {
|
return "";
|
} else if (mask != NAME_NORMAL && mask != NAME_COMPRESSION) {
|
throw new ParseException("Parse name fail, bad label type");
|
} else if (mask == NAME_COMPRESSION) {
|
// Name compression based on RFC 1035 - 4.1.4 Message compression
|
final int offset = ((len & ~NAME_COMPRESSION) << 8) + BitUtils.uint8(buf.get());
|
final int oldPos = buf.position();
|
if (offset >= oldPos - 2) {
|
throw new ParseException("Parse compression name fail, invalid compression");
|
}
|
buf.position(offset);
|
final String pointed = parseName(buf, depth + 1);
|
buf.position(oldPos);
|
return pointed;
|
} else {
|
final byte[] label = new byte[len];
|
buf.get(label);
|
final String head = labelToString(label);
|
if (head.length() > MAXLABELSIZE) {
|
throw new ParseException("Parse name fail, invalid label length");
|
}
|
final String tail = parseName(buf, depth + 1);
|
return TextUtils.isEmpty(tail) ? head : head + "." + tail;
|
}
|
}
|
}
|
|
public static final int QDSECTION = 0;
|
public static final int ANSECTION = 1;
|
public static final int NSSECTION = 2;
|
public static final int ARSECTION = 3;
|
private static final int NUM_SECTIONS = ARSECTION + 1;
|
|
private static final String TAG = DnsPacket.class.getSimpleName();
|
|
protected final DnsHeader mHeader;
|
protected final List<DnsRecord>[] mRecords;
|
|
protected DnsPacket(@NonNull byte[] data) throws ParseException {
|
if (null == data) throw new ParseException("Parse header failed, null input data");
|
final ByteBuffer buffer;
|
try {
|
buffer = ByteBuffer.wrap(data);
|
mHeader = new DnsHeader(buffer);
|
} catch (BufferUnderflowException e) {
|
throw new ParseException("Parse Header fail, bad input data", e);
|
}
|
|
mRecords = new ArrayList[NUM_SECTIONS];
|
|
for (int i = 0; i < NUM_SECTIONS; ++i) {
|
final int count = mHeader.getRecordCount(i);
|
if (count > 0) {
|
mRecords[i] = new ArrayList(count);
|
}
|
for (int j = 0; j < count; ++j) {
|
try {
|
mRecords[i].add(new DnsRecord(i, buffer));
|
} catch (BufferUnderflowException e) {
|
throw new ParseException("Parse record fail", e);
|
}
|
}
|
}
|
}
|
}
|
