import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
public void start(Timer timer) {
    long now = System.currentTimeMillis();
    if (now - this.getDns().getLastThrottleIncrement() < DNSConstants.PROBE_THROTTLE_COUNT_INTERVAL) {
        this.getDns().setThrottle(this.getDns().getThrottle() + 1);
    } else {
        this.getDns().setThrottle(1);
    }
    this.getDns().setLastThrottleIncrement(now);

    if (this.getDns().isAnnounced() && this.getDns().getThrottle() < DNSConstants.PROBE_THROTTLE_COUNT) {
        timer.schedule(this, JmDNSImpl.getRandom().nextInt(1 + DNSConstants.PROBE_WAIT_INTERVAL), DNSConstants.PROBE_WAIT_INTERVAL);
    } else if (!this.getDns().isCanceling() && !this.getDns().isCanceled()) {
        timer.schedule(this, DNSConstants.PROBE_CONFLICT_INTERVAL, DNSConstants.PROBE_CONFLICT_INTERVAL);
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void unregisterService(ServiceInfo infoAbstract) {
    final ServiceInfoImpl info = (ServiceInfoImpl) _services.get(infoAbstract.getKey());

    if (info != null) {
        info.cancelState();
        this.startCanceler();
        info.waitForCanceled(DNSConstants.CLOSE_TIMEOUT);

        _services.remove(info.getKey(), info);
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("unregisterService() JmDNS " + this.getName() + " unregistered service as " + info);
        }
    } else {
        logger.warning(this.getName() + " removing unregistered service info: " + infoAbstract.getKey());
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * Add an answer to a question. Deal with the case when the outgoing packet overflows
 *
 * @param in
 * @param addr
 * @param port
 * @param out
 * @param rec
 * @return outgoing answer
 * @exception IOException
 */
public DNSOutgoing addAnswer(DNSIncoming in, InetAddress addr, int port, DNSOutgoing out, DNSRecord rec) throws IOException {
    DNSOutgoing newOut = out;
    if (newOut == null) {
        newOut = new DNSOutgoing(DNSConstants.FLAGS_QR_RESPONSE | DNSConstants.FLAGS_AA, false, in.getSenderUDPPayload());
    }
    try {
        newOut.addAnswer(in, rec);
    } catch (final IOException e) {
        newOut.setFlags(newOut.getFlags() | DNSConstants.FLAGS_TC);
        newOut.setId(in.getId());
        send(newOut);

        newOut = new DNSOutgoing(DNSConstants.FLAGS_QR_RESPONSE | DNSConstants.FLAGS_AA, false, in.getSenderUDPPayload());
        newOut.addAnswer(in, rec);
    }
    return newOut;
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * Send an outgoing multicast DNS message.
 *
 * @param out
 * @exception IOException
 */
public void send(DNSOutgoing out) throws IOException {
    if (!out.isEmpty()) {
        byte[] message = out.data();
        final DatagramPacket packet = new DatagramPacket(message, message.length, _group, DNSConstants.MDNS_PORT);

        if (logger.isLoggable(Level.FINEST)) {
            try {
                final DNSIncoming msg = new DNSIncoming(packet);
                if (logger.isLoggable(Level.FINEST)) {
                    logger.finest("send(" + this.getName() + ") JmDNS out:" + msg.print(true));
                }
            } catch (final IOException e) {
                logger.throwing(getClass().toString(), "send(" + this.getName() + ") - JmDNS can not parse what it sends!!!", e);
            }
        }
        final MulticastSocket ms = _socket;
        if (ms != null && !ms.isClosed()) {
            ms.send(packet);
        }
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
public void addAnswers(JmDNSImpl jmDNSImpl, Set<DNSRecord> answers) {
    String loname = this.getName().toLowerCase();
    if (jmDNSImpl.getLocalHost().getName().equalsIgnoreCase(loname)) {
        // type = DNSConstants.TYPE_A;
        answers.addAll(jmDNSImpl.getLocalHost().answers(this.getRecordClass(), this.isUnique(), DNSConstants.DNS_TTL));
        return;
    }
    // Service type request
    if (jmDNSImpl.getServiceTypes().containsKey(loname)) {
        DNSQuestion question = new Pointer(this.getName(), DNSRecordType.TYPE_PTR, this.getRecordClass(), this.isUnique());
        question.addAnswers(jmDNSImpl, answers);
        return;
    }

    this.addAnswersForServiceInfo(jmDNSImpl, answers, (ServiceInfoImpl) jmDNSImpl.getServices().get(loname));
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
public void addAnswers(JmDNSImpl jmDNSImpl, Set<DNSRecord> answers)
{
    String name = this.getName().toLowerCase();
    if (jmDNSImpl.getLocalHost().getName().equalsIgnoreCase(name))
    {
        // type = DNSConstants.TYPE_A;
        answers.addAll(jmDNSImpl.getLocalHost().answers(this.isUnique(), DNSConstants.DNS_TTL));
        return;
    }
    // Service type request
    if (jmDNSImpl.getServiceTypes().containsKey(name))
    {
        DNSQuestion question = new Pointer(this.getName(), DNSRecordType.TYPE_PTR, this.getRecordClass(), this.isUnique());
        question.addAnswers(jmDNSImpl, answers);
        return;
    }

    this.addAnswersForServiceInfo(jmDNSImpl, answers, (ServiceInfoImpl) jmDNSImpl.getServices().get(name));
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void unregisterService(ServiceInfo infoAbstract) {
    final ServiceInfoImpl info = (ServiceInfoImpl) _services.get(infoAbstract.getKey());

    if (info != null) {
        info.cancelState();
        this.startCanceler();
        info.waitForCanceled(DNSConstants.CLOSE_TIMEOUT);

        _services.remove(info.getKey(), info);
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("unregisterService() JmDNS unregistered service as " + info);
        }
    } else {
        logger.warning("Removing unregistered service info: " + infoAbstract.getKey());
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
public void addAnswers(JmDNSImpl jmDNSImpl, Set<DNSRecord> answers) {
    String loname = this.getName().toLowerCase();
    if (jmDNSImpl.getLocalHost().getName().equalsIgnoreCase(loname)) {
        // type = DNSConstants.TYPE_A;
        answers.addAll(jmDNSImpl.getLocalHost().answers(this.isUnique(), DNSConstants.DNS_TTL));
        return;
    }
    // Service type request
    if (jmDNSImpl.getServiceTypes().containsKey(loname)) {
        DNSQuestion question = new Pointer(this.getName(), DNSRecordType.TYPE_PTR, this.getRecordClass(), this.isUnique());
        question.addAnswers(jmDNSImpl, answers);
        return;
    }

    this.addAnswersForServiceInfo(jmDNSImpl, answers, (ServiceInfoImpl) jmDNSImpl.getServices().get(loname));
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
public void start(Timer timer) {
    // According to draft-cheshire-dnsext-multicastdns.txt chapter "7 Responding":
    // We respond immediately if we know for sure, that we are the only one who can respond to the query.
    // In all other cases, we respond within 20-120 ms.
    //
    // According to draft-cheshire-dnsext-multicastdns.txt chapter "6.2 Multi-Packet Known Answer Suppression":
    // We respond after 20-120 ms if the query is truncated.

    boolean iAmTheOnlyOne = true;
    for (DNSQuestion question : _in.getQuestions()) {
        if (logger.isLoggable(Level.FINEST)) {
            logger.finest(this.getName() + "start() question=" + question);
        }
        iAmTheOnlyOne = question.iAmTheOnlyOne(this.getDns());
        if (!iAmTheOnlyOne) {
            break;
        }
    }
    int delay = (iAmTheOnlyOne && !_in.isTruncated()) ? 0 : DNSConstants.RESPONSE_MIN_WAIT_INTERVAL + JmDNSImpl.getRandom().nextInt(DNSConstants.RESPONSE_MAX_WAIT_INTERVAL - DNSConstants.RESPONSE_MIN_WAIT_INTERVAL + 1) - _in.elapseSinceArrival();
    if (delay < 0) {
        delay = 0;
    }
    if (logger.isLoggable(Level.FINEST)) {
        logger.finest(this.getName() + "start() Responder chosen delay=" + delay);
    }
    if (!this.getDns().isCanceling() && !this.getDns().isCanceled()) {
        timer.schedule(this, delay);
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
protected DNSOutgoing addAnswers(DNSOutgoing out) throws IOException {
    DNSOutgoing newOut = out;
    long now = System.currentTimeMillis();
    for (ServiceInfo info : this.getDns().getServices().values()) {
        newOut = this.addAnswer(newOut, new DNSRecord.Pointer(info.getType(), DNSRecordClass.CLASS_IN, DNSRecordClass.NOT_UNIQUE, DNSConstants.DNS_TTL, info.getQualifiedName()), now);
        // newOut = this.addAnswer(newOut, new DNSRecord.Service(info.getQualifiedName(), DNSRecordClass.CLASS_IN, DNSRecordClass.NOT_UNIQUE, DNSConstants.DNS_TTL, info.getPriority(), info.getWeight(), info.getPort(),
        // this.getDns().getLocalHost().getName()), now);
    }
    return newOut;
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
protected DNSOutgoing addAnswers(DNSOutgoing out) throws IOException {
    DNSOutgoing newOut = out;
    long now = System.currentTimeMillis();
    for (String type : this.getDns().getServiceTypes().keySet()) {
        ServiceTypeEntry typeEntry = this.getDns().getServiceTypes().get(type);
        newOut = this.addAnswer(newOut, new DNSRecord.Pointer("_services._dns-sd._udp.local.", DNSRecordClass.CLASS_IN, DNSRecordClass.NOT_UNIQUE, DNSConstants.DNS_TTL, typeEntry.getType()), now);
    }
    return newOut;
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
public void run() {
    try {
        if (this.getDns().isCanceling() || this.getDns().isCanceled()) {
            this.cancel();
        } else {
            if (_count++ < 3) {
                if (logger.isLoggable(Level.FINER)) {
                    logger.finer(this.getName() + ".run() JmDNS " + this.description());
                }
                DNSOutgoing out = new DNSOutgoing(DNSConstants.FLAGS_QR_QUERY);
                out = this.addQuestions(out);
                if (this.getDns().isAnnounced()) {
                    out = this.addAnswers(out);
                }
                if (!out.isEmpty()) {
                    this.getDns().send(out);
                }
            } else {
                // After three queries, we can quit.
                this.cancel();
            }
        }
    } catch (Throwable e) {
        logger.log(Level.WARNING, this.getName() + ".run() exception ", e);
        this.getDns().recover();
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
public boolean conflictWithRecord(DNSRecord.Address record) {
    DNSRecord.Address hostAddress = this.getDNSAddressRecord(record.getRecordType(), record.isUnique(), DNSConstants.DNS_TTL);
    if (hostAddress != null) {
        return hostAddress.sameType(record) && hostAddress.sameName(record) && (!hostAddress.sameValue(record));
    }
    return false;
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void registerService(ServiceInfo infoAbstract) throws IOException {
    if (this.isClosing() || this.isClosed()) {
        throw new IllegalStateException("This DNS is closed.");
    }
    final ServiceInfoImpl info = (ServiceInfoImpl) infoAbstract;

    if (info.getDns() != null) {
        if (info.getDns() != this) {
            throw new IllegalStateException("A service information can only be registered with a single instamce of JmDNS.");
        } else if (_services.get(info.getKey()) != null) {
            throw new IllegalStateException("A service information can only be registered once.");
        }
    }
    info.setDns(this);

    this.registerServiceType(info.getTypeWithSubtype());

    // bind the service to this address
    info.recoverState();
    info.setServer(_localHost.getName());
    info.addAddress(_localHost.getInet4Address());
    info.addAddress(_localHost.getInet6Address());

    this.waitForAnnounced(DNSConstants.SERVICE_INFO_TIMEOUT);

    this.makeServiceNameUnique(info);
    while (_services.putIfAbsent(info.getKey(), info) != null) {
        this.makeServiceNameUnique(info);
    }

    this.startProber();
    info.waitForAnnounced(DNSConstants.SERVICE_INFO_TIMEOUT);

    if (logger.isLoggable(Level.FINE)) {
        logger.fine("registerService() JmDNS registered service as " + info);
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * Does the necessary actions, when this as a query.
 */
@Override
boolean handleQuery(JmDNSImpl dns, long expirationTime) {
    if (dns.getLocalHost().conflictWithRecord(this)) {
        DNSRecord.Address localAddress = dns.getLocalHost().getDNSAddressRecord(this.getRecordType(), this.isUnique(), DNSConstants.DNS_TTL);
        int comparison = this.compareTo(localAddress);

        if (comparison == 0) {
            // the 2 records are identical this probably means we are seeing our own record.
            // With multiple interfaces on a single computer it is possible to see our
            // own records come in on different interfaces than the ones they were sent on.
            // see section "10. Conflict Resolution" of mdns draft spec.
            logger1.finer("handleQuery() Ignoring an identical address query");
            return false;
        }

        logger1.finer("handleQuery() Conflicting query detected.");
        // Tie breaker test
        if (dns.isProbing() && comparison > 0) {
            // We lost the tie-break. We have to choose a different name.
            dns.getLocalHost().incrementHostName();
            dns.getCache().clear();
            for (ServiceInfo serviceInfo : dns.getServices().values()) {
                ServiceInfoImpl info = (ServiceInfoImpl) serviceInfo;
                info.revertState();
            }
        }
        dns.revertState();
        return true;
    }
    return false;
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
@Override
DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException {
    ServiceInfoImpl info = (ServiceInfoImpl) dns.getServices().get(this.getKey());
    if (info != null) {
        if (this._port == info.getPort() != _server.equals(dns.getLocalHost().getName())) {
            return dns.addAnswer(in, addr, port, out, new DNSRecord.Service(info.getQualifiedName(), DNSRecordClass.CLASS_IN, DNSRecordClass.UNIQUE, DNSConstants.DNS_TTL, info.getPriority(), info.getWeight(), info.getPort(), dns
                    .getLocalHost().getName()));
        }
    }
    return out;
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * Create an outgoing query or response.
 *
 * @param flags
 * @param multicast
 * @param senderUDPPayload
 *            The sender's UDP payload size is the number of bytes of the largest UDP payload that can be reassembled and delivered in the sender's network stack.
 */
public DNSOutgoing(int flags, boolean multicast, int senderUDPPayload) {
    super(flags, 0, multicast);
    _names = new HashMap<String, Integer>();
    _maxUDPPayload = (senderUDPPayload > 0 ? senderUDPPayload : DNSConstants.MAX_MSG_TYPICAL);
    _questionsBytes = new MessageOutputStream(senderUDPPayload, this);
    _answersBytes = new MessageOutputStream(senderUDPPayload, this);
    _authoritativeAnswersBytes = new MessageOutputStream(senderUDPPayload, this);
    _additionalsAnswersBytes = new MessageOutputStream(senderUDPPayload, this);
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
protected void addAnswersForServiceInfo(JmDNSImpl jmDNSImpl, Set<DNSRecord> answers, ServiceInfoImpl info) {
    if ((info != null) && info.isAnnounced()) {
        if (this.getName().equalsIgnoreCase(info.getQualifiedName()) || this.getName().equalsIgnoreCase(info.getType()) || this.getName().equalsIgnoreCase(info.getTypeWithSubtype())) {
            answers.addAll(jmDNSImpl.getLocalHost().answers(this.getRecordClass(), DNSRecordClass.UNIQUE, DNSConstants.DNS_TTL));
            answers.addAll(info.answers(this.getRecordClass(), DNSRecordClass.UNIQUE, DNSConstants.DNS_TTL, jmDNSImpl.getLocalHost()));
        }
        if (logger.isLoggable(Level.FINER)) {
            logger.finer(jmDNSImpl.getName() + " DNSQuestion(" + this.getName() + ").addAnswersForServiceInfo(): info: " + info + "\n" + answers);
        }
    }
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * Create an outgoing query or response.
 *
 * @param flags
 * @param multicast
 * @param senderUDPPayload
 *            The sender's UDP payload size is the number of bytes of the largest UDP payload that can be reassembled and delivered in the sender's network stack.
 */
public DNSOutgoing(int flags, boolean multicast, int senderUDPPayload)
{
    super(flags, 0, multicast);
    _names = new HashMap<String, Integer>();
    _maxUDPPayload = (senderUDPPayload > 0 ? senderUDPPayload : DNSConstants.MAX_MSG_TYPICAL);
    _questionsBytes = new MessageOutputStream(senderUDPPayload, this);
    _answersBytes = new MessageOutputStream(senderUDPPayload, this);
    _authoritativeAnswersBytes = new MessageOutputStream(senderUDPPayload, this);
    _additionalsAnswersBytes = new MessageOutputStream(senderUDPPayload, this);
}
 

import javax.jmdns.impl.constants.DNSConstants; //导入依赖的package包/类
/**
 * Create an outgoing query or response.
 * 
 * @param flags
 * @param multicast
 * @param senderUDPPayload
 *            The sender's UDP payload size is the number of bytes of the largest UDP payload that can be reassembled and delivered in the sender's network stack.
 */
public DNSOutgoing(int flags, boolean multicast, int senderUDPPayload) {
    super(flags, 0, multicast);
    _names = new HashMap<String, Integer>();
    _maxUDPPayload = (senderUDPPayload > 0 ? senderUDPPayload : DNSConstants.MAX_MSG_TYPICAL);
    _questionsBytes = new MessageOutputStream(senderUDPPayload, this);
    _answersBytes = new MessageOutputStream(senderUDPPayload, this);
    _authoritativeAnswersBytes = new MessageOutputStream(senderUDPPayload, this);
    _additionalsAnswersBytes = new MessageOutputStream(senderUDPPayload, this);
}