providers/bundles/org.eclipse.ecf.provider.jmdns/jmdns/javax/jmdns/impl/DNSRecord.java - ecf/org.eclipse.ecf - Git at Google

 //Copyright 2003-2005 Arthur van Hoff, Rick Blair
 //Licensed under Apache License version 2.0
 //Original license LGPL


 package javax.jmdns.impl;

 import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.net.Inet4Address;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.Iterator;
 //import java.util.logging.Level;
 //import java.util.logging.Logger;

 /**
  * DNS record
  *
  * @version %I%, %G%
  * @author	Arthur van Hoff, Rick Blair, Werner Randelshofer, Pierre Frisch
  */
 public abstract class DNSRecord extends DNSEntry
 {
 //    private static Logger logger = Logger.getLogger(DNSRecord.class.getName());
     private int ttl;
     private long created;

     /**
      * This source is mainly for debugging purposes, should be the address that
      * sent this record.
      */
     private InetAddress source;

     /**
      * Create a DNSRecord with a name, type, clazz, and ttl.
      */
     DNSRecord(String name, int type, int clazz, int ttl)
     {
         super(name, type, clazz);
         this.ttl = ttl;
         this.created = System.currentTimeMillis();
     }

     /**
      * True if this record is the same as some other record.
      */
     public boolean equals(Object other)
     {
         return (other instanceof DNSRecord) && sameAs((DNSRecord) other);
     }

     /**
      * True if this record is the same as some other record.
      */
     boolean sameAs(DNSRecord other)
     {
         return super.equals(other) && sameValue((DNSRecord) other);
     }

     /**
      * True if this record has the same value as some other record.
      */
     abstract boolean sameValue(DNSRecord other);

     /**
      * True if this record has the same type as some other record.
      */
     boolean sameType(DNSRecord other)
     {
         return type == other.type;
     }

     /**
      * Handles a query represented by this record.
      *
      * @return Returns true if a conflict with one of the services registered
      *         with JmDNS or with the hostname occured.
      */
     abstract boolean handleQuery(JmDNSImpl dns, long expirationTime);

     /**
      * Handles a responserepresented by this record.
      *
      * @return Returns true if a conflict with one of the services registered
      *         with JmDNS or with the hostname occured.
      */
     abstract boolean handleResponse(JmDNSImpl dns);

     /**
      * Adds this as an answer to the provided outgoing datagram.
      */
     abstract DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException;

     /**
      * True if this record is suppressed by the answers in a message.
      */
     boolean suppressedBy(DNSIncoming msg)
     {
         try
         {
             for (int i = msg.numAnswers; i-- > 0;)
             {
                 if (suppressedBy((DNSRecord) msg.answers.get(i)))
                 {
                     return true;
                 }
             }
             return false;
         }
         catch (ArrayIndexOutOfBoundsException e)
         {
 //            logger.log(Level.WARNING, "suppressedBy() message " + msg + " exception ", e);
             // msg.print(true);
             return false;
         }
     }

     /**
      * True if this record would be supressed by an answer.
      * This is the case if this record would not have a
      * significantly longer TTL.
      */
     boolean suppressedBy(DNSRecord other)
     {
         if (sameAs(other) && (other.ttl > ttl / 2))
         {
             return true;
         }
         return false;
     }

     /**
      * Get the expiration time of this record.
      */
     long getExpirationTime(int percent)
     {
         return created + (percent * ttl * 10L);
     }

     /**
      * Get the remaining TTL for this record.
      */
     int getRemainingTTL(long now)
     {
         return (int) Math.max(0, (getExpirationTime(100) - now) / 1000);
     }

     /**
      * Check if the record is expired.
      */
     public boolean isExpired(long now)
     {
         return getExpirationTime(100) <= now;
     }

     /**
      * Check if the record is stale, ie it has outlived
      * more than half of its TTL.
      */
     boolean isStale(long now)
     {
         return getExpirationTime(50) <= now;
     }

     /**
      * Reset the TTL of a record. This avoids having to
      * update the entire record in the cache.
      */
     void resetTTL(DNSRecord other)
     {
         created = other.created;
         ttl = other.ttl;
     }

     /**
      * Write this record into an outgoing message.
      */
     abstract void write(DNSOutgoing out) throws IOException;

     /**
      * Address record.
      */
     static class Address extends DNSRecord
     {
 //        private static Logger logger = Logger.getLogger(Address.class.getName());
         InetAddress addr;

         Address(String name, int type, int clazz, int ttl, InetAddress addr)
         {
             super(name, type, clazz, ttl);
             this.addr = addr;
         }

         Address(String name, int type, int clazz, int ttl, byte[] rawAddress)
         {
             super(name, type, clazz, ttl);
             try
             {
                 this.addr = InetAddress.getByAddress(rawAddress);
             }
             catch (UnknownHostException exception)
             {
 //                logger.log(Level.WARNING, "Address() exception ", exception);
             }
         }

         void write(DNSOutgoing out) throws IOException
         {
             if (addr != null)
             {
                 byte[] buffer = addr.getAddress();
                 if (DNSConstants.TYPE_A == type)
                 {
                     // If we have a type A records we should answer with a IPv4 address
                     if (addr instanceof Inet4Address)
                     {
                         // All is good
                     }
                     else
                     {
                         // Get the last four bytes
                         byte[] tempbuffer = buffer;
                         buffer = new byte[4];
                         System.arraycopy(tempbuffer, 12, buffer, 0, 4);
                     }
                 }
                 else
                 {
                     // If we have a type AAAA records we should answer with a IPv6 address
                     if (addr instanceof Inet4Address)
                     {
                         byte[] tempbuffer = buffer;
                         buffer = new byte[16];
                         for (int i = 0; i < 16; i++)
                         {
                             if (i < 11)
                             {
                                 buffer[i] = tempbuffer[i - 12];
                             }
                             else
                             {
                                 buffer[i] = 0;
                             }
                         }
                     }
                 }
                 int length = buffer.length;
                 out.writeBytes(buffer, 0, length);
             }
         }

         boolean same(DNSRecord other)
         {
             return ((sameName(other)) && ((sameValue(other))));
         }

         boolean sameName(DNSRecord other)
         {
             return name.equalsIgnoreCase(((Address) other).name);
         }

         boolean sameValue(DNSRecord other)
         {
             return addr.equals(((Address) other).getAddress());
         }

         InetAddress getAddress()
         {
             return addr;
         }

         /**
          * Creates a byte array representation of this record.
          * This is needed for tie-break tests according to
          * draft-cheshire-dnsext-multicastdns-04.txt chapter 9.2.
          */
         private byte[] toByteArray()
         {
             try
             {
                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
                 DataOutputStream dout = new DataOutputStream(bout);
                 dout.write(name.getBytes("UTF8"));
                 dout.writeShort(type);
                 dout.writeShort(clazz);
                 //dout.writeInt(len);
                 byte[] buffer = addr.getAddress();
                 for (int i = 0; i < buffer.length; i++)
                 {
                     dout.writeByte(buffer[i]);
                 }
                 dout.close();
                 return bout.toByteArray();
             }
             catch (IOException e)
             {
                 throw new InternalError();
             }
         }

         /**
          * Does a lexicographic comparison of the byte array representation
          * of this record and that record.
          * This is needed for tie-break tests according to
          * draft-cheshire-dnsext-multicastdns-04.txt chapter 9.2.
          */
         private int lexCompare(DNSRecord.Address that)
         {
             byte[] thisBytes = this.toByteArray();
             byte[] thatBytes = that.toByteArray();
             for (int i = 0, n = Math.min(thisBytes.length, thatBytes.length); i < n; i++)
             {
                 if (thisBytes[i] > thatBytes[i])
                 {
                     return 1;
                 }
                 else
                 {
                     if (thisBytes[i] < thatBytes[i])
                     {
                         return -1;
                     }
                 }
             }
             return thisBytes.length - thatBytes.length;
         }

         /**
          * Does the necessary actions, when this as a query.
          */
         boolean handleQuery(JmDNSImpl dns, long expirationTime)
         {
             DNSRecord.Address dnsAddress = dns.getLocalHost().getDNSAddressRecord(this);
             if (dnsAddress != null)
             {
                 if (dnsAddress.sameType(this) && dnsAddress.sameName(this) && (!dnsAddress.sameValue(this)))
                 {
 //                    logger.finer("handleQuery() Conflicting probe detected. dns state " + dns.getState() + " lex compare " + lexCompare(dnsAddress));
                     // Tie-breaker test
                     if (dns.getState().isProbing() && lexCompare(dnsAddress) >= 0)
                     {
                         // We lost the tie-break. We have to choose a different name.
                         dns.getLocalHost().incrementHostName();
                         dns.getCache().clear();
                         for (Iterator i = dns.getServices().values().iterator(); i.hasNext();)
                         {
                             ServiceInfoImpl info = (ServiceInfoImpl) i.next();
                             info.revertState();
                         }
                     }
                     dns.revertState();
                     return true;
                 }
             }
             return false;
         }

         /**
          * Does the necessary actions, when this as a response.
          */
         boolean handleResponse(JmDNSImpl dns)
         {
             DNSRecord.Address dnsAddress = dns.getLocalHost().getDNSAddressRecord(this);
             if (dnsAddress != null)
             {
                 if (dnsAddress.sameType(this) && dnsAddress.sameName(this) && (!dnsAddress.sameValue(this)))
                 {
 //                    logger.finer("handleResponse() Denial detected");

                     if (dns.getState().isProbing())
                     {
                         dns.getLocalHost().incrementHostName();
                         dns.getCache().clear();
                         for (Iterator i = dns.getServices().values().iterator(); i.hasNext();)
                         {
                             ServiceInfoImpl info = (ServiceInfoImpl) i.next();
                             info.revertState();
                         }
                     }
                     dns.revertState();
                     return true;
                 }
             }
             return false;
         }

         DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
         {
             return out;
         }

         public String toString()
         {
             return toString(" address '" + (addr != null ? addr.getHostAddress() : "null") + "'");
         }

     }

     /**
      * Pointer record.
      */
     public static class Pointer extends DNSRecord
     {
 //        private static Logger logger = Logger.getLogger(Pointer.class.getName());
         String alias;

         public Pointer(String name, int type, int clazz, int ttl, String alias)
         {
             super(name, type, clazz, ttl);
             this.alias = alias;
         }

         void write(DNSOutgoing out) throws IOException
         {
             out.writeName(alias);
         }

         boolean sameValue(DNSRecord other)
         {
             return alias.equals(((Pointer) other).alias);
         }

         boolean handleQuery(JmDNSImpl dns, long expirationTime)
         {
             // Nothing to do (?)
             // I think there is no possibility for conflicts for this record type?
             return false;
         }

         boolean handleResponse(JmDNSImpl dns)
         {
             // Nothing to do (?)
             // I think there is no possibility for conflicts for this record type?
             return false;
         }

         String getAlias()
         {
             return alias;
         }

         DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
         {
             return out;
         }

         public String toString()
         {
             return toString(alias);
         }
     }

     public static class Text extends DNSRecord
     {
 //        private static Logger logger = Logger.getLogger(Text.class.getName());
         byte text[];

         public Text(String name, int type, int clazz, int ttl, byte text[])
         {
             super(name, type, clazz, ttl);
             this.text = text;
         }

         void write(DNSOutgoing out) throws IOException
         {
             out.writeBytes(text, 0, text.length);
         }

         boolean sameValue(DNSRecord other)
         {
             Text txt = (Text) other;
             if (txt.text.length != text.length)
             {
                 return false;
             }
             for (int i = text.length; i-- > 0;)
             {
                 if (txt.text[i] != text[i])
                 {
                     return false;
                 }
             }
             return true;
         }

         boolean handleQuery(JmDNSImpl dns, long expirationTime)
         {
             // Nothing to do (?)
             // I think there is no possibility for conflicts for this record type?
             return false;
         }

         boolean handleResponse(JmDNSImpl dns)
         {
             // Nothing to do (?)
             // Shouldn't we care if we get a conflict at this level?
             /*
                          ServiceInfo info = (ServiceInfo) dns.services.get(name.toLowerCase());
                          if (info != null) {
                                  if (! Arrays.equals(text,info.text)) {
                                          info.revertState();
                                          return true;
                                  }
                          }*/
             return false;
         }

         DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
         {
             return out;
         }

         public String toString()
         {
             return toString((text.length > 10) ? new String(text, 0, 7) + "..." : new String(text));
         }
     }

     /**
      * Service record.
      */
     public static class Service extends DNSRecord
     {
 //        private static Logger logger = Logger.getLogger(Service.class.getName());
         int priority;
         int weight;
         int port;
         String server;

         public Service(String name, int type, int clazz, int ttl, int priority, int weight, int port, String server)
         {
             super(name, type, clazz, ttl);
             this.priority = priority;
             this.weight = weight;
             this.port = port;
             this.server = server;
         }

         void write(DNSOutgoing out) throws IOException
         {
             out.writeShort(priority);
             out.writeShort(weight);
             out.writeShort(port);
             if(DNSIncoming.USE_DOMAIN_NAME_FORMAT_FOR_SRV_TARGET){
                 out.writeName(server, false);
             } else {
                 out.writeUTF(server, 0, server.length());

                 // add a zero byte to the end just to be safe, this is the strange form
                 // used by the BonjourConformanceTest
                 out.writeByte(0);
             }
         }

         private byte[] toByteArray()
         {
             try
             {
                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
                 DataOutputStream dout = new DataOutputStream(bout);
                 dout.write(name.getBytes("UTF8"));
                 dout.writeShort(type);
                 dout.writeShort(clazz);
                 //dout.writeInt(len);
                 dout.writeShort(priority);
                 dout.writeShort(weight);
                 dout.writeShort(port);
                 dout.write(server.getBytes("UTF8"));
                 dout.close();
                 return bout.toByteArray();
             }
             catch (IOException e)
             {
                 throw new InternalError();
             }
         }

         private int lexCompare(DNSRecord.Service that)
         {
             byte[] thisBytes = this.toByteArray();
             byte[] thatBytes = that.toByteArray();
             for (int i = 0, n = Math.min(thisBytes.length, thatBytes.length); i < n; i++)
             {
                 if (thisBytes[i] > thatBytes[i])
                 {
                     return 1;
                 }
                 else
                 {
                     if (thisBytes[i] < thatBytes[i])
                     {
                         return -1;
                     }
                 }
             }
             return thisBytes.length - thatBytes.length;
         }

         boolean sameValue(DNSRecord other)
         {
             Service s = (Service) other;
             return (priority == s.priority) && (weight == s.weight) && (port == s.port) && server.equals(s.server);
         }

         boolean handleQuery(JmDNSImpl dns, long expirationTime)
         {
             ServiceInfoImpl info = (ServiceInfoImpl) dns.getServices().get(name.toLowerCase());
             if (info != null
                 && (port != info.port || !server.equalsIgnoreCase(dns.getLocalHost().getName())))
             {
 //                logger.finer("handleQuery() Conflicting probe detected from: " + getRecordSource());
                 DNSRecord.Service localService = new DNSRecord.Service(info.getQualifiedName(), DNSConstants.TYPE_SRV,
                         DNSConstants.CLASS_IN | DNSConstants.CLASS_UNIQUE,
                         DNSConstants.DNS_TTL, info.priority,
                         info.weight, info.port, dns.getLocalHost().getName());

                 // This block is useful for debugging race conditions when jmdns is respoding to
                 // itself.
                 try
                 {
                     if(dns.getInterface().equals(getRecordSource())){
 //                        logger.warning("Got conflicting probe from ourselves\n" +
 //                                "incoming: " +this.toString() + "\n" +
 //                                "local   : " + localService.toString());
                     }
                 }
                 catch (IOException e)
                 {
                     e.printStackTrace();
                 }

                 int comparison = lexCompare(localService);

                 if(comparison == 0){
                     // the 2 records are identical this probably means we are seeing our own record.
                     // With mutliple 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.
 //                    logger.finer("handleQuery() Ignoring a identical service query");
                     return false;
                 }

                 // Tie breaker test
                 if (info.getState().isProbing() && comparison > 0)
                 {
                     // We lost the tie break
                     String oldName = info.getQualifiedName().toLowerCase();
                     info.setName(dns.incrementName(info.getName()));
                     dns.getServices().remove(oldName);
                     dns.getServices().put(info.getQualifiedName().toLowerCase(), info);
 //                    logger.finer("handleQuery() Lost tie break: new unique name chosen:" + info.getName());

                     // We revert the state to start probing again with the new name
                     info.revertState();
                 }
                 else
                 {
                     // We won the tie break, so this conflicting probe should be ignored
                     // See paragraph 3 of section 9.2 in mdns draft spec
                     return false;
                 }

                 return true;

             }
             return false;
         }

         boolean handleResponse(JmDNSImpl dns)
         {
             ServiceInfoImpl info = (ServiceInfoImpl) dns.getServices().get(name.toLowerCase());
             if (info != null
                 && (port != info.port || !server.equalsIgnoreCase(dns.getLocalHost().getName())))
             {
 //                logger.finer("handleResponse() Denial detected");

                 if (info.getState().isProbing())
                 {
                     String oldName = info.getQualifiedName().toLowerCase();
                     info.setName(dns.incrementName(info.getName()));
                     dns.getServices().remove(oldName);
                     dns.getServices().put(info.getQualifiedName().toLowerCase(), info);
 //                    logger.finer("handleResponse() New unique name chose:" + info.getName());

                 }
                 info.revertState();
                 return true;
             }
             return false;
         }

         DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
         {
             ServiceInfoImpl info = (ServiceInfoImpl) dns.getServices().get(name.toLowerCase());
             if (info != null)
             {
                 if (this.port == info.port != server.equals(dns.getLocalHost().getName()))
                 {
                     return dns.addAnswer(in, addr, port, out,
                         new DNSRecord.Service(info.getQualifiedName(), DNSConstants.TYPE_SRV,
                             DNSConstants.CLASS_IN | DNSConstants.CLASS_UNIQUE,
                             DNSConstants.DNS_TTL, info.priority,
                             info.weight, info.port, dns.getLocalHost().getName()));
                 }
             }
             return out;
         }

         public String toString()
         {
             return toString(server + ":" + port);
         }
     }

     public void setRecordSource(InetAddress source)
     {
         this.source = source;
     }

     public InetAddress getRecordSource()
     {
         return source;
     }

     public String toString(String other)
     {
         return toString("record", ttl + "/" + getRemainingTTL(System.currentTimeMillis()) + "," + other);
     }

     public void setTtl(int ttl)
     {
         this.ttl = ttl;
     }

     public int getTtl()
     {
         return ttl;
     }
 }
	//Copyright 2003-2005 Arthur van Hoff, Rick Blair
	//Licensed under Apache License version 2.0
	//Original license LGPL


	package javax.jmdns.impl;

	import java.io.ByteArrayOutputStream;
	import java.io.DataOutputStream;
	import java.io.IOException;
	import java.net.Inet4Address;
	import java.net.InetAddress;
	import java.net.UnknownHostException;
	import java.util.Iterator;
	//import java.util.logging.Level;
	//import java.util.logging.Logger;

	/**
	* DNS record
	*
	* @version %I%, %G%
	* @author Arthur van Hoff, Rick Blair, Werner Randelshofer, Pierre Frisch
	*/
	public abstract class DNSRecord extends DNSEntry
	{
	// private static Logger logger = Logger.getLogger(DNSRecord.class.getName());
	private int ttl;
	private long created;

	/**
	* This source is mainly for debugging purposes, should be the address that
	* sent this record.
	*/
	private InetAddress source;

	/**
	* Create a DNSRecord with a name, type, clazz, and ttl.
	*/
	DNSRecord(String name, int type, int clazz, int ttl)
	{
	super(name, type, clazz);
	this.ttl = ttl;
	this.created = System.currentTimeMillis();
	}

	/**
	* True if this record is the same as some other record.
	*/
	public boolean equals(Object other)
	{
	return (other instanceof DNSRecord) && sameAs((DNSRecord) other);
	}

	/**
	* True if this record is the same as some other record.
	*/
	boolean sameAs(DNSRecord other)
	{
	return super.equals(other) && sameValue((DNSRecord) other);
	}

	/**
	* True if this record has the same value as some other record.
	*/
	abstract boolean sameValue(DNSRecord other);

	/**
	* True if this record has the same type as some other record.
	*/
	boolean sameType(DNSRecord other)
	{
	return type == other.type;
	}

	/**
	* Handles a query represented by this record.
	*
	* @return Returns true if a conflict with one of the services registered
	* with JmDNS or with the hostname occured.
	*/
	abstract boolean handleQuery(JmDNSImpl dns, long expirationTime);

	/**
	* Handles a responserepresented by this record.
	*
	* @return Returns true if a conflict with one of the services registered
	* with JmDNS or with the hostname occured.
	*/
	abstract boolean handleResponse(JmDNSImpl dns);

	/**
	* Adds this as an answer to the provided outgoing datagram.
	*/
	abstract DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException;

	/**
	* True if this record is suppressed by the answers in a message.
	*/
	boolean suppressedBy(DNSIncoming msg)
	{
	try
	{
	for (int i = msg.numAnswers; i-- > 0;)
	{
	if (suppressedBy((DNSRecord) msg.answers.get(i)))
	{
	return true;
	}
	}
	return false;
	}
	catch (ArrayIndexOutOfBoundsException e)
	{
	// logger.log(Level.WARNING, "suppressedBy() message " + msg + " exception ", e);
	// msg.print(true);
	return false;
	}
	}

	/**
	* True if this record would be supressed by an answer.
	* This is the case if this record would not have a
	* significantly longer TTL.
	*/
	boolean suppressedBy(DNSRecord other)
	{
	if (sameAs(other) && (other.ttl > ttl / 2))
	{
	return true;
	}
	return false;
	}

	/**
	* Get the expiration time of this record.
	*/
	long getExpirationTime(int percent)
	{
	return created + (percent * ttl * 10L);
	}

	/**
	* Get the remaining TTL for this record.
	*/
	int getRemainingTTL(long now)
	{
	return (int) Math.max(0, (getExpirationTime(100) - now) / 1000);
	}

	/**
	* Check if the record is expired.
	*/
	public boolean isExpired(long now)
	{
	return getExpirationTime(100) <= now;
	}

	/**
	* Check if the record is stale, ie it has outlived
	* more than half of its TTL.
	*/
	boolean isStale(long now)
	{
	return getExpirationTime(50) <= now;
	}

	/**
	* Reset the TTL of a record. This avoids having to
	* update the entire record in the cache.
	*/
	void resetTTL(DNSRecord other)
	{
	created = other.created;
	ttl = other.ttl;
	}

	/**
	* Write this record into an outgoing message.
	*/
	abstract void write(DNSOutgoing out) throws IOException;

	/**
	* Address record.
	*/
	static class Address extends DNSRecord
	{
	// private static Logger logger = Logger.getLogger(Address.class.getName());
	InetAddress addr;

	Address(String name, int type, int clazz, int ttl, InetAddress addr)
	{
	super(name, type, clazz, ttl);
	this.addr = addr;
	}

	Address(String name, int type, int clazz, int ttl, byte[] rawAddress)
	{
	super(name, type, clazz, ttl);
	try
	{
	this.addr = InetAddress.getByAddress(rawAddress);
	}
	catch (UnknownHostException exception)
	{
	// logger.log(Level.WARNING, "Address() exception ", exception);
	}
	}

	void write(DNSOutgoing out) throws IOException
	{
	if (addr != null)
	{
	byte[] buffer = addr.getAddress();
	if (DNSConstants.TYPE_A == type)
	{
	// If we have a type A records we should answer with a IPv4 address
	if (addr instanceof Inet4Address)
	{
	// All is good
	}
	else
	{
	// Get the last four bytes
	byte[] tempbuffer = buffer;
	buffer = new byte[4];
	System.arraycopy(tempbuffer, 12, buffer, 0, 4);
	}
	}
	else
	{
	// If we have a type AAAA records we should answer with a IPv6 address
	if (addr instanceof Inet4Address)
	{
	byte[] tempbuffer = buffer;
	buffer = new byte[16];
	for (int i = 0; i < 16; i++)
	{
	if (i < 11)
	{
	buffer[i] = tempbuffer[i - 12];
	}
	else
	{
	buffer[i] = 0;
	}
	}
	}
	}
	int length = buffer.length;
	out.writeBytes(buffer, 0, length);
	}
	}

	boolean same(DNSRecord other)
	{
	return ((sameName(other)) && ((sameValue(other))));
	}

	boolean sameName(DNSRecord other)
	{
	return name.equalsIgnoreCase(((Address) other).name);
	}

	boolean sameValue(DNSRecord other)
	{
	return addr.equals(((Address) other).getAddress());
	}

	InetAddress getAddress()
	{
	return addr;
	}

	/**
	* Creates a byte array representation of this record.
	* This is needed for tie-break tests according to
	* draft-cheshire-dnsext-multicastdns-04.txt chapter 9.2.
	*/
	private byte[] toByteArray()
	{
	try
	{
	ByteArrayOutputStream bout = new ByteArrayOutputStream();
	DataOutputStream dout = new DataOutputStream(bout);
	dout.write(name.getBytes("UTF8"));
	dout.writeShort(type);
	dout.writeShort(clazz);
	//dout.writeInt(len);
	byte[] buffer = addr.getAddress();
	for (int i = 0; i < buffer.length; i++)
	{
	dout.writeByte(buffer[i]);
	}
	dout.close();
	return bout.toByteArray();
	}
	catch (IOException e)
	{
	throw new InternalError();
	}
	}

	/**
	* Does a lexicographic comparison of the byte array representation
	* of this record and that record.
	* This is needed for tie-break tests according to
	* draft-cheshire-dnsext-multicastdns-04.txt chapter 9.2.
	*/
	private int lexCompare(DNSRecord.Address that)
	{
	byte[] thisBytes = this.toByteArray();
	byte[] thatBytes = that.toByteArray();
	for (int i = 0, n = Math.min(thisBytes.length, thatBytes.length); i < n; i++)
	{
	if (thisBytes[i] > thatBytes[i])
	{
	return 1;
	}
	else
	{
	if (thisBytes[i] < thatBytes[i])
	{
	return -1;
	}
	}
	}
	return thisBytes.length - thatBytes.length;
	}

	/**
	* Does the necessary actions, when this as a query.
	*/
	boolean handleQuery(JmDNSImpl dns, long expirationTime)
	{
	DNSRecord.Address dnsAddress = dns.getLocalHost().getDNSAddressRecord(this);
	if (dnsAddress != null)
	{
	if (dnsAddress.sameType(this) && dnsAddress.sameName(this) && (!dnsAddress.sameValue(this)))
	{
	// logger.finer("handleQuery() Conflicting probe detected. dns state " + dns.getState() + " lex compare " + lexCompare(dnsAddress));
	// Tie-breaker test
	if (dns.getState().isProbing() && lexCompare(dnsAddress) >= 0)
	{
	// We lost the tie-break. We have to choose a different name.
	dns.getLocalHost().incrementHostName();
	dns.getCache().clear();
	for (Iterator i = dns.getServices().values().iterator(); i.hasNext();)
	{
	ServiceInfoImpl info = (ServiceInfoImpl) i.next();
	info.revertState();
	}
	}
	dns.revertState();
	return true;
	}
	}
	return false;
	}

	/**
	* Does the necessary actions, when this as a response.
	*/
	boolean handleResponse(JmDNSImpl dns)
	{
	DNSRecord.Address dnsAddress = dns.getLocalHost().getDNSAddressRecord(this);
	if (dnsAddress != null)
	{
	if (dnsAddress.sameType(this) && dnsAddress.sameName(this) && (!dnsAddress.sameValue(this)))
	{
	// logger.finer("handleResponse() Denial detected");

	if (dns.getState().isProbing())
	{
	dns.getLocalHost().incrementHostName();
	dns.getCache().clear();
	for (Iterator i = dns.getServices().values().iterator(); i.hasNext();)
	{
	ServiceInfoImpl info = (ServiceInfoImpl) i.next();
	info.revertState();
	}
	}
	dns.revertState();
	return true;
	}
	}
	return false;
	}

	DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
	{
	return out;
	}

	public String toString()
	{
	return toString(" address '" + (addr != null ? addr.getHostAddress() : "null") + "'");
	}

	}

	/**
	* Pointer record.
	*/
	public static class Pointer extends DNSRecord
	{
	// private static Logger logger = Logger.getLogger(Pointer.class.getName());
	String alias;

	public Pointer(String name, int type, int clazz, int ttl, String alias)
	{
	super(name, type, clazz, ttl);
	this.alias = alias;
	}

	void write(DNSOutgoing out) throws IOException
	{
	out.writeName(alias);
	}

	boolean sameValue(DNSRecord other)
	{
	return alias.equals(((Pointer) other).alias);
	}

	boolean handleQuery(JmDNSImpl dns, long expirationTime)
	{
	// Nothing to do (?)
	// I think there is no possibility for conflicts for this record type?
	return false;
	}

	boolean handleResponse(JmDNSImpl dns)
	{
	// Nothing to do (?)
	// I think there is no possibility for conflicts for this record type?
	return false;
	}

	String getAlias()
	{
	return alias;
	}

	DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
	{
	return out;
	}

	public String toString()
	{
	return toString(alias);
	}
	}

	public static class Text extends DNSRecord
	{
	// private static Logger logger = Logger.getLogger(Text.class.getName());
	byte text[];

	public Text(String name, int type, int clazz, int ttl, byte text[])
	{
	super(name, type, clazz, ttl);
	this.text = text;
	}

	void write(DNSOutgoing out) throws IOException
	{
	out.writeBytes(text, 0, text.length);
	}

	boolean sameValue(DNSRecord other)
	{
	Text txt = (Text) other;
	if (txt.text.length != text.length)
	{
	return false;
	}
	for (int i = text.length; i-- > 0;)
	{
	if (txt.text[i] != text[i])
	{
	return false;
	}
	}
	return true;
	}

	boolean handleQuery(JmDNSImpl dns, long expirationTime)
	{
	// Nothing to do (?)
	// I think there is no possibility for conflicts for this record type?
	return false;
	}

	boolean handleResponse(JmDNSImpl dns)
	{
	// Nothing to do (?)
	// Shouldn't we care if we get a conflict at this level?
	/*
	ServiceInfo info = (ServiceInfo) dns.services.get(name.toLowerCase());
	if (info != null) {
	if (! Arrays.equals(text,info.text)) {
	info.revertState();
	return true;
	}
	}*/
	return false;
	}

	DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
	{
	return out;
	}

	public String toString()
	{
	return toString((text.length > 10) ? new String(text, 0, 7) + "..." : new String(text));
	}
	}

	/**
	* Service record.
	*/
	public static class Service extends DNSRecord
	{
	// private static Logger logger = Logger.getLogger(Service.class.getName());
	int priority;
	int weight;
	int port;
	String server;

	public Service(String name, int type, int clazz, int ttl, int priority, int weight, int port, String server)
	{
	super(name, type, clazz, ttl);
	this.priority = priority;
	this.weight = weight;
	this.port = port;
	this.server = server;
	}

	void write(DNSOutgoing out) throws IOException
	{
	out.writeShort(priority);
	out.writeShort(weight);
	out.writeShort(port);
	if(DNSIncoming.USE_DOMAIN_NAME_FORMAT_FOR_SRV_TARGET){
	out.writeName(server, false);
	} else {
	out.writeUTF(server, 0, server.length());

	// add a zero byte to the end just to be safe, this is the strange form
	// used by the BonjourConformanceTest
	out.writeByte(0);
	}
	}

	private byte[] toByteArray()
	{
	try
	{
	ByteArrayOutputStream bout = new ByteArrayOutputStream();
	DataOutputStream dout = new DataOutputStream(bout);
	dout.write(name.getBytes("UTF8"));
	dout.writeShort(type);
	dout.writeShort(clazz);
	//dout.writeInt(len);
	dout.writeShort(priority);
	dout.writeShort(weight);
	dout.writeShort(port);
	dout.write(server.getBytes("UTF8"));
	dout.close();
	return bout.toByteArray();
	}
	catch (IOException e)
	{
	throw new InternalError();
	}
	}

	private int lexCompare(DNSRecord.Service that)
	{
	byte[] thisBytes = this.toByteArray();
	byte[] thatBytes = that.toByteArray();
	for (int i = 0, n = Math.min(thisBytes.length, thatBytes.length); i < n; i++)
	{
	if (thisBytes[i] > thatBytes[i])
	{
	return 1;
	}
	else
	{
	if (thisBytes[i] < thatBytes[i])
	{
	return -1;
	}
	}
	}
	return thisBytes.length - thatBytes.length;
	}

	boolean sameValue(DNSRecord other)
	{
	Service s = (Service) other;
	return (priority == s.priority) && (weight == s.weight) && (port == s.port) && server.equals(s.server);
	}

	boolean handleQuery(JmDNSImpl dns, long expirationTime)
	{
	ServiceInfoImpl info = (ServiceInfoImpl) dns.getServices().get(name.toLowerCase());
	if (info != null
	&& (port != info.port \|\| !server.equalsIgnoreCase(dns.getLocalHost().getName())))
	{
	// logger.finer("handleQuery() Conflicting probe detected from: " + getRecordSource());
	DNSRecord.Service localService = new DNSRecord.Service(info.getQualifiedName(), DNSConstants.TYPE_SRV,
	DNSConstants.CLASS_IN \| DNSConstants.CLASS_UNIQUE,
	DNSConstants.DNS_TTL, info.priority,
	info.weight, info.port, dns.getLocalHost().getName());

	// This block is useful for debugging race conditions when jmdns is respoding to
	// itself.
	try
	{
	if(dns.getInterface().equals(getRecordSource())){
	// logger.warning("Got conflicting probe from ourselves\n" +
	// "incoming: " +this.toString() + "\n" +
	// "local : " + localService.toString());
	}
	}
	catch (IOException e)
	{
	e.printStackTrace();
	}

	int comparison = lexCompare(localService);

	if(comparison == 0){
	// the 2 records are identical this probably means we are seeing our own record.
	// With mutliple 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.
	// logger.finer("handleQuery() Ignoring a identical service query");
	return false;
	}

	// Tie breaker test
	if (info.getState().isProbing() && comparison > 0)
	{
	// We lost the tie break
	String oldName = info.getQualifiedName().toLowerCase();
	info.setName(dns.incrementName(info.getName()));
	dns.getServices().remove(oldName);
	dns.getServices().put(info.getQualifiedName().toLowerCase(), info);
	// logger.finer("handleQuery() Lost tie break: new unique name chosen:" + info.getName());

	// We revert the state to start probing again with the new name
	info.revertState();
	}
	else
	{
	// We won the tie break, so this conflicting probe should be ignored
	// See paragraph 3 of section 9.2 in mdns draft spec
	return false;
	}

	return true;

	}
	return false;
	}

	boolean handleResponse(JmDNSImpl dns)
	{
	ServiceInfoImpl info = (ServiceInfoImpl) dns.getServices().get(name.toLowerCase());
	if (info != null
	&& (port != info.port \|\| !server.equalsIgnoreCase(dns.getLocalHost().getName())))
	{
	// logger.finer("handleResponse() Denial detected");

	if (info.getState().isProbing())
	{
	String oldName = info.getQualifiedName().toLowerCase();
	info.setName(dns.incrementName(info.getName()));
	dns.getServices().remove(oldName);
	dns.getServices().put(info.getQualifiedName().toLowerCase(), info);
	// logger.finer("handleResponse() New unique name chose:" + info.getName());

	}
	info.revertState();
	return true;
	}
	return false;
	}

	DNSOutgoing addAnswer(JmDNSImpl dns, DNSIncoming in, InetAddress addr, int port, DNSOutgoing out) throws IOException
	{
	ServiceInfoImpl info = (ServiceInfoImpl) dns.getServices().get(name.toLowerCase());
	if (info != null)
	{
	if (this.port == info.port != server.equals(dns.getLocalHost().getName()))
	{
	return dns.addAnswer(in, addr, port, out,
	new DNSRecord.Service(info.getQualifiedName(), DNSConstants.TYPE_SRV,
	DNSConstants.CLASS_IN \| DNSConstants.CLASS_UNIQUE,
	DNSConstants.DNS_TTL, info.priority,
	info.weight, info.port, dns.getLocalHost().getName()));
	}
	}
	return out;
	}

	public String toString()
	{
	return toString(server + ":" + port);
	}
	}

	public void setRecordSource(InetAddress source)
	{
	this.source = source;
	}

	public InetAddress getRecordSource()
	{
	return source;
	}

	public String toString(String other)
	{
	return toString("record", ttl + "/" + getRemainingTTL(System.currentTimeMillis()) + "," + other);
	}

	public void setTtl(int ttl)
	{
	this.ttl = ttl;
	}

	public int getTtl()
	{
	return ttl;
	}
	}