public Message send(Message query) {
int q, r;
Message best = null;
byte rcode;
for (q = 0; q < 20; q++) {
boolean ok = false;
for (r = 0; r < resolvers.length; r++) ok |= sendTo(query, r, q);
if (!ok) break;
Message m = null;
synchronized (queue) {
try {
queue.wait((quantum + 1) * 1000);
} catch (InterruptedException e) {
System.out.println("interrupted");
}
if (queue.size() == 0) continue;
m = (Message) queue.firstElement();
queue.removeElementAt(0);
Integer I = (Integer) queue.firstElement();
queue.removeElementAt(0);
r = I.intValue();
}
if (m == null) invalid[r] = true;
else {
rcode = m.getHeader().getRcode();
if (rcode == Rcode.NOERROR) return m;
else {
if (best == null) best = m;
invalid[r] = true;
}
}
}
return best;
}
private Message sendAXFR(Message query) throws IOException {
Name qname = query.getQuestion().getName();
ZoneTransferIn xfrin = ZoneTransferIn.newAXFR(qname, address, tsig);
xfrin.setTimeout((int) (getTimeout() / 1000));
xfrin.setLocalAddress(localAddress);
try {
xfrin.run();
} catch (ZoneTransferException e) {
throw new WireParseException(e.getMessage());
}
List records = xfrin.getAXFR();
Message response = new Message(query.getHeader().getID());
response.getHeader().setFlag(Flags.AA);
response.getHeader().setFlag(Flags.QR);
response.addRecord(query.getQuestion(), Section.QUESTION);
Iterator it = records.iterator();
while (it.hasNext()) response.addRecord((Record) it.next(), Section.ANSWER);
return response;
}
public static Record[] getRecords(String namestr, short type, short dclass, byte cred) {
Message query;
Message response;
Record question;
Record[] answers;
int answerCount = 0, i = 0;
Enumeration e;
Name name = new Name(namestr);
/*System.out.println("lookup of " + name + " " + Type.string(type));*/
if (!Type.isRR(type) && type != Type.ANY) return null;
if (res == null) {
try {
eres = new ExtendedResolver();
} catch (UnknownHostException uhe) {
System.out.println("Failed to initialize resolver");
System.exit(-1);
}
}
if (cache == null) cache = new Cache();
CacheResponse cached = cache.lookupRecords(name, type, dclass, cred);
/*System.out.println(cached);*/
if (cached.isSuccessful()) {
RRset rrset = cached.answer();
answerCount = rrset.size();
e = rrset.rrs();
} else if (cached.isNegative()) {
answerCount = 0;
e = null;
} else {
question = Record.newRecord(name, type, dclass);
query = Message.newQuery(question);
if (res != null) response = res.send(query);
else response = eres.send(query);
short rcode = response.getHeader().getRcode();
if (rcode == Rcode.NOERROR || rcode == Rcode.NXDOMAIN) cache.addMessage(response);
if (rcode != Rcode.NOERROR) return null;
e = response.getSection(Section.ANSWER);
while (e.hasMoreElements()) {
Record r = (Record) e.nextElement();
if (matchType(r.getType(), type)) answerCount++;
}
e = response.getSection(Section.ANSWER);
}
if (answerCount == 0) return null;
answers = new Record[answerCount];
while (e.hasMoreElements()) {
Record r = (Record) e.nextElement();
if (matchType(r.getType(), type)) answers[i++] = r;
}
return answers;
}
/**
* Sends a message to a single server and waits for a response. No checking is done to ensure that
* the response is associated with the query.
*
* @param query The query to send.
* @return The response.
* @throws IOException An error occurred while sending or receiving.
*/
public Message send(Message query) throws IOException {
if (Options.check("verbose"))
System.err.println(
"Sending to " + address.getAddress().getHostAddress() + ":" + address.getPort());
if (query.getHeader().getOpcode() == Opcode.QUERY) {
Record question = query.getQuestion();
if (question != null && question.getType() == Type.AXFR) return sendAXFR(query);
}
query = (Message) query.clone();
applyEDNS(query);
if (tsig != null) {
tsig.apply(query, null);
}
byte[] out = query.toWire(Message.MAXLENGTH);
int udpSize = maxUDPSize(query);
boolean tcp = false;
long endTime = System.currentTimeMillis() + timeoutValue;
do {
byte[] b_in;
if (useTCP || out.length > udpSize) {
tcp = true;
}
if (tcp) {
b_in = TCPClient.sendrecv(localAddress, address, out, endTime);
} else {
b_in = UDPClient.sendrecv(localAddress, address, out, udpSize, endTime);
}
/*
* Check that the response is long enough.
*/
if (b_in.length < Header.LENGTH) {
throw new WireParseException("invalid DNS header - " + "too short");
}
/*
* Check that the response ID matches the query ID. We want
* to check this before actually parsing the message, so that
* if there's a malformed response that's not ours, it
* doesn't confuse us.
*/
int id = ((b_in[0] & 0xFF) << 8) + (b_in[1] & 0xFF);
int qid = query.getHeader().getID();
if (id != qid) {
String error = "invalid message id: expected " + qid + "; got id " + id;
if (tcp) {
throw new WireParseException(error);
} else {
if (Options.check("verbose")) {
System.err.println(error);
}
continue;
}
}
Message response = parseMessage(b_in);
verifyTSIG(query, response, b_in, tsig);
if (!tcp && !ignoreTruncation && response.getHeader().getFlag(Flags.TC)) {
tcp = true;
continue;
}
return response;
} while (true);
}
