package com.apple.dnssd;

abstract public class DNSSD

{

/** Flag indicates to a {@link BrowseListener} that another result is

public static final int MORE_COMING = ( 1 << 0 );

/** If flag is set in a {@link DomainListener} callback, indicates that the result is the default domain. */

public static final int DEFAULT = ( 1 << 2 );

/** If flag is set, a name conflict will trigger an exception when registering non-shared records.<P>

public static final int NO_AUTO_RENAME = ( 1 << 3 );

/** If flag is set, allow multiple records with this name on the network (e.g. PTR records)

public static final int SHARED = ( 1 << 4 );

/** If flag is set, records with this name must be unique on the network (e.g. SRV records). */

public static final int UNIQUE = ( 1 << 5 );

/** Set flag when calling enumerateDomains() to restrict results to domains recommended for browsing. */

public static final int BROWSE_DOMAINS = ( 1 << 6 );

/** Set flag when calling enumerateDomains() to restrict results to domains recommended for registration. */

public static final int REGISTRATION_DOMAINS = ( 1 << 7 );

/** Maximum length, in bytes, of a domain name represented as an escaped C-String. */

public static final int MAX_DOMAIN_NAME = 1005;

/** Pass for ifIndex to specify all available interfaces. */

public static final int ALL_INTERFACES = 0;

/** Pass for ifIndex to specify the localhost interface. */

public static final int LOCALHOST_ONLY = -1;

/** Browse for instances of a service.<P>

public static DNSSDService browse( int flags, int ifIndex, String regType, String domain, BrowseListener listener)

throws DNSSDException

{ return getInstance()._makeBrowser( flags, ifIndex, regType, domain, listener); }

/** Browse for instances of a service. Use default flags, ifIndex and domain.<P>

public static DNSSDService browse( String regType, BrowseListener listener)

throws DNSSDException

{ return browse( 0, 0, regType, "", listener); }

/** Resolve a service name discovered via browse() to a target host name, port number, and txt record.<P>

public static DNSSDService resolve( int flags, int ifIndex, String serviceName, String regType,

String domain, ResolveListener listener)

throws DNSSDException

{ return getInstance()._resolve( flags, ifIndex, serviceName, regType, domain, listener); }

/** Register a service, to be discovered via browse() and resolve() calls.<P>

public static DNSSDRegistration register( int flags, int ifIndex, String serviceName, String regType,

String domain, String host, int port, TXTRecord txtRecord, RegisterListener listener)

throws DNSSDException

{ return getInstance()._register( flags, ifIndex, serviceName, regType, domain, host, port, txtRecord, listener); }

/** Register a service, to be discovered via browse() and resolve() calls. Use default flags, ifIndex, domain, host and txtRecord.<P>

public static DNSSDRegistration register( String serviceName, String regType, int port, RegisterListener listener)

throws DNSSDException

{ return register( 0, 0, serviceName, regType, null, null, port, null, listener); }

/** Create a {@link DNSSDRecordRegistrar} allowing efficient registration of

public static DNSSDRecordRegistrar createRecordRegistrar( RegisterRecordListener listener)

throws DNSSDException

{ return getInstance()._createRecordRegistrar( listener); }

/** Query for an arbitrary DNS record.<P>

public static DNSSDService queryRecord( int flags, int ifIndex, String serviceName, int rrtype,

int rrclass, QueryListener listener)

throws DNSSDException

{ return getInstance()._queryRecord( flags, ifIndex, serviceName, rrtype, rrclass, listener); }

/** Asynchronously enumerate domains available for browsing and registration.<P>

public static DNSSDService enumerateDomains( int flags, int ifIndex, DomainListener listener)

throws DNSSDException

{ return getInstance()._enumerateDomains( flags, ifIndex, listener); }

/** Concatenate a three-part domain name (as provided to the listeners) into a

public static String constructFullName( String serviceName, String regType, String domain)

throws DNSSDException

{ return getInstance()._constructFullName( serviceName, regType, domain); }

/** Instruct the daemon to verify the validity of a resource record that appears to

public static void reconfirmRecord( int flags, int ifIndex, String fullName, int rrtype,

int rrclass, byte[] rdata)

{ getInstance()._reconfirmRecord( flags, ifIndex, fullName, rrtype, rrclass, rdata); }

/** Return the canonical name of a particular interface index.<P>

public static String getNameForIfIndex( int ifIndex)

{ return getInstance()._getNameForIfIndex( ifIndex); }

/** Return the index of a named interface.<P>

public static int getIfIndexForName( String ifName)

{ return getInstance()._getIfIndexForName( ifName); }

protected DNSSD() {} // prevent direct instantiation

/** Return the single instance of DNSSD. */

static protected final DNSSD getInstance()

{

SecurityManager sm = System.getSecurityManager();

if ( sm != null)

sm.checkPermission( new RuntimePermission( "getDNSSDInstance"));

return fInstance;

}

abstract protected DNSSDService _makeBrowser( int flags, int ifIndex, String regType, String domain, BrowseListener listener)

throws DNSSDException;

abstract protected DNSSDService _resolve( int flags, int ifIndex, String serviceName, String regType,

String domain, ResolveListener listener)

throws DNSSDException;

abstract protected DNSSDRegistration _register( int flags, int ifIndex, String serviceName, String regType,

String domain, String host, int port, TXTRecord txtRecord, RegisterListener listener)

throws DNSSDException;

abstract protected DNSSDRecordRegistrar _createRecordRegistrar( RegisterRecordListener listener)

throws DNSSDException;

abstract protected DNSSDService _queryRecord( int flags, int ifIndex, String serviceName, int rrtype,

int rrclass, QueryListener listener)

throws DNSSDException;

abstract protected DNSSDService _enumerateDomains( int flags, int ifIndex, DomainListener listener)

throws DNSSDException;

abstract protected String _constructFullName( String serviceName, String regType, String domain)

throws DNSSDException;

abstract protected void _reconfirmRecord( int flags, int ifIndex, String fullName, int rrtype,

int rrclass, byte[] rdata);

abstract protected String _getNameForIfIndex( int ifIndex);

abstract protected int _getIfIndexForName( String ifName);

protected static DNSSD fInstance;

static

{

try

{

String name = System.getProperty( "com.apple.dnssd.DNSSD" );

if( name == null )

name = "com.apple.dnssd.AppleDNSSD"; // Fall back to Apple-provided class.

fInstance = (DNSSD) Class.forName( name ).newInstance();

}

catch( Exception e )

{

throw new InternalError( "cannot instantiate DNSSD" + e );

}

}

}

class AppleDNSSDException extends DNSSDException

{

public AppleDNSSDException( int errorCode) { fErrorCode = errorCode; }

public int getErrorCode() { return fErrorCode; }

public String getMessage()

{

final String kMessages[] = { // should probably be put into a resource or something

"UNKNOWN",

"NO_SUCH_NAME",

"NO_MEMORY",

"BAD_PARAM",

"BAD_REFERENCE",

"BAD_STATE",

"BAD_FLAGS",

"UNSUPPORTED",

"NOT_INITIALIZED",

"NO_CACHE",

"ALREADY_REGISTERED",

"NAME_CONFLICT",

"INVALID",

"FIREWALL",

"INCOMPATIBLE",

"BAD_INTERFACE_INDEX",

"REFUSED",

"NOSUCHRECORD",

"NOAUTH",

"NOSUCHKEY",

"NATTRAVERSAL",

"DOUBLENAT",

"BADTIME",

"BADSIG",

"BADKEY",

"TRANSIENT"

};

if ( fErrorCode <= UNKNOWN && fErrorCode > ( UNKNOWN - kMessages.length))

{

return "DNS-SD Error " + String.valueOf( fErrorCode) + ": " + kMessages[ UNKNOWN - fErrorCode];

}

else

return super.getMessage() + "(" + String.valueOf( fErrorCode) + ")";

}

protected int fErrorCode;

}

class AppleDNSSD extends DNSSD

{

static

{

System.loadLibrary( "jdns_sd");

int libInitResult = InitLibrary( 1);

if ( libInitResult != DNSSDException.NO_ERROR)

throw new InternalError( "cannot instantiate DNSSD: " + new AppleDNSSDException( libInitResult).getMessage());

}

static public boolean hasAutoCallbacks; // Set by InitLibrary() to value of AUTO_CALLBACKS

protected DNSSDService _makeBrowser( int flags, int ifIndex, String regType, String domain, BrowseListener client)

throws DNSSDException

{

return new AppleBrowser( flags, ifIndex, regType, domain, client);

}

protected DNSSDService _resolve( int flags, int ifIndex, String serviceName, String regType,

String domain, ResolveListener client)

throws DNSSDException

{

return new AppleResolver( flags, ifIndex, serviceName, regType, domain, client);

}

protected DNSSDRegistration _register( int flags, int ifIndex, String serviceName, String regType,

String domain, String host, int port, TXTRecord txtRecord, RegisterListener client)

throws DNSSDException

{

return new AppleRegistration( flags, ifIndex, serviceName, regType, domain, host, port,

( txtRecord != null) ? txtRecord.getRawBytes() : null, client);

}

protected DNSSDRecordRegistrar _createRecordRegistrar( RegisterRecordListener listener)

throws DNSSDException

{

return new AppleRecordRegistrar( listener);

}

protected DNSSDService _queryRecord( int flags, int ifIndex, String serviceName, int rrtype,

int rrclass, QueryListener client)

throws DNSSDException

{

return new AppleQuery( flags, ifIndex, serviceName, rrtype, rrclass, client);

}

protected DNSSDService _enumerateDomains( int flags, int ifIndex, DomainListener listener)

throws DNSSDException

{

return new AppleDomainEnum( flags, ifIndex, listener);

}

protected String _constructFullName( String serviceName, String regType, String domain)

throws DNSSDException

{

String[] responseHolder = new String[1]; // lame maneuver to get around Java's lack of reference parameters

int rc = ConstructName( serviceName, regType, domain, responseHolder);

if ( rc != 0)

throw new AppleDNSSDException( rc);

return responseHolder[0];

}

protected void _reconfirmRecord( int flags, int ifIndex, String fullName, int rrtype,

int rrclass, byte[] rdata)

{

ReconfirmRecord( flags, ifIndex, fullName, rrtype, rrclass, rdata);

}

protected String _getNameForIfIndex( int ifIndex)

{

return GetNameForIfIndex( ifIndex);

}

protected int _getIfIndexForName( String ifName)

{

return GetIfIndexForName( ifName);

}

protected native int ConstructName( String serviceName, String regType, String domain, String[] pOut);

protected native void ReconfirmRecord( int flags, int ifIndex, String fullName, int rrtype,

int rrclass, byte[] rdata);

protected native String GetNameForIfIndex( int ifIndex);

protected native int GetIfIndexForName( String ifName);

protected static native int InitLibrary( int callerVersion);

}

class AppleService implements DNSSDService, Runnable

{

public AppleService(BaseListener listener) { fNativeContext = 0; fListener = listener; }

public void stop() { this.HaltOperation(); }

/* Block until data arrives, or one second passes. Returns 1 if data present, 0 otherwise. */

protected native int BlockForData();

/* Call ProcessResults when data appears on socket descriptor. */

protected native int ProcessResults();

protected synchronized native void HaltOperation();

protected void ThrowOnErr( int rc) throws DNSSDException

{

if ( rc != 0)

throw new AppleDNSSDException( rc);

}

protected long /* warning */ fNativeContext; // Private storage for native side

public void run()

{

while ( true )

{

// Note: We want to allow our DNS-SD operation to be stopped from other threads, so we have to

// block waiting for data *outside* the synchronized section. Because we're doing this unsynchronized

// we have to write some careful code. Suppose our DNS-SD operation is stopped from some other thread,

// and then immediately afterwards that thread (or some third, unrelated thread) starts a new DNS-SD

// operation. The Unix kernel always allocates the lowest available file descriptor to a new socket,

// so the same file descriptor is highly likely to be reused for the new operation, and if our old

// stale ServiceThread accidentally consumes bytes off that new socket we'll get really messed up.

// To guard against that, before calling ProcessResults we check to ensure that our

// fNativeContext has not been deleted, which is a telltale sign that our operation was stopped.

// After calling ProcessResults we check again, because it's extremely common for callback

// functions to stop their own operation and start others. For example, a resolveListener callback

// may well stop the resolve and then start a QueryRecord call to monitor the TXT record.

//

// The remaining risk is that between our checking fNativeContext and calling ProcessResults(),

// some other thread could stop the operation and start a new one using same file descriptor, and

// we wouldn't know. To prevent this, the AppleService object's HaltOperation() routine is declared

// synchronized and we perform our checks synchronized on the AppleService object, which ensures

// that HaltOperation() can't execute while we're doing it. Because Java locks are re-entrant this

// locking DOESN'T prevent the callback routine from stopping its own operation, but DOES prevent

// any other thread from stopping it until after the callback has completed and returned to us here.

int result = BlockForData();

synchronized (this)

{

if (fNativeContext == 0) break; // Some other thread stopped our DNSSD operation; time to terminate this thread

if (result == 0) continue; // If BlockForData() said there was no data, go back and block again

result = ProcessResults();

if (fNativeContext == 0) break; // Event listener stopped its own DNSSD operation; terminate this thread

if (result != 0) { fListener.operationFailed(this, result); break; } // If error, notify listener

}

}

}

protected BaseListener fListener;

}

class AppleBrowser extends AppleService

{

public AppleBrowser( int flags, int ifIndex, String regType, String domain, BrowseListener client)

throws DNSSDException

{

super(client);

this.ThrowOnErr( this.CreateBrowser( flags, ifIndex, regType, domain));

if ( !AppleDNSSD.hasAutoCallbacks)

new Thread(this).start();

}

// Sets fNativeContext. Returns non-zero on error.

protected native int CreateBrowser( int flags, int ifIndex, String regType, String domain);

}

class AppleResolver extends AppleService

{

public AppleResolver( int flags, int ifIndex, String serviceName, String regType,

String domain, ResolveListener client)

throws DNSSDException

{

super(client);

this.ThrowOnErr( this.CreateResolver( flags, ifIndex, serviceName, regType, domain));

if ( !AppleDNSSD.hasAutoCallbacks)

new Thread(this).start();

}

// Sets fNativeContext. Returns non-zero on error.

protected native int CreateResolver( int flags, int ifIndex, String serviceName, String regType,

String domain);

}

class AppleDNSRecord implements DNSRecord

{

public AppleDNSRecord( AppleService owner)

{

fOwner = owner;

fRecord = 0; // record always starts out empty

}

public void update( int flags, byte[] rData, int ttl)

throws DNSSDException

{

this.ThrowOnErr( this.Update( flags, rData, ttl));

}

public void remove()

throws DNSSDException

{

this.ThrowOnErr( this.Remove());

}

protected long fRecord; // Really a DNSRecord; sizeof(int) == sizeof(void*) ?

protected AppleService fOwner;

protected void ThrowOnErr( int rc) throws DNSSDException

{

if ( rc != 0)

throw new AppleDNSSDException( rc);

}

protected native int Update( int flags, byte[] rData, int ttl);

protected native int Remove();

}

class AppleRegistration extends AppleService implements DNSSDRegistration

{

public AppleRegistration( int flags, int ifIndex, String serviceName, String regType, String domain,

String host, int port, byte[] txtRecord, RegisterListener client)

throws DNSSDException

{

super(client);

this.ThrowOnErr( this.BeginRegister( ifIndex, flags, serviceName, regType, domain, host, port, txtRecord));

if ( !AppleDNSSD.hasAutoCallbacks)

new Thread(this).start();

}

public DNSRecord addRecord( int flags, int rrType, byte[] rData, int ttl)

throws DNSSDException

{

AppleDNSRecord newRecord = new AppleDNSRecord( this);

this.ThrowOnErr( this.AddRecord( flags, rrType, rData, ttl, newRecord));

return newRecord;

}

public DNSRecord getTXTRecord()

throws DNSSDException

{

return new AppleDNSRecord( this); // A record with ref 0 is understood to be primary TXT record

}

// Sets fNativeContext. Returns non-zero on error.

protected native int BeginRegister( int ifIndex, int flags, String serviceName, String regType,

String domain, String host, int port, byte[] txtRecord);

// Sets fNativeContext. Returns non-zero on error.

protected native int AddRecord( int flags, int rrType, byte[] rData, int ttl, AppleDNSRecord destObj);

}

class AppleRecordRegistrar extends AppleService implements DNSSDRecordRegistrar

{

public AppleRecordRegistrar( RegisterRecordListener listener)

throws DNSSDException

{

super(listener);

this.ThrowOnErr( this.CreateConnection());

if ( !AppleDNSSD.hasAutoCallbacks)

new Thread(this).start();

}

public DNSRecord registerRecord( int flags, int ifIndex, String fullname, int rrtype,

int rrclass, byte[] rdata, int ttl)

throws DNSSDException

{

AppleDNSRecord newRecord = new AppleDNSRecord( this);

this.ThrowOnErr( this.RegisterRecord( flags, ifIndex, fullname, rrtype, rrclass, rdata, ttl, newRecord));

return newRecord;

}

// Sets fNativeContext. Returns non-zero on error.

protected native int CreateConnection();

// Sets fNativeContext. Returns non-zero on error.

protected native int RegisterRecord( int flags, int ifIndex, String fullname, int rrtype,

int rrclass, byte[] rdata, int ttl, AppleDNSRecord destObj);

}

class AppleQuery extends AppleService

{

public AppleQuery( int flags, int ifIndex, String serviceName, int rrtype,

int rrclass, QueryListener client)

throws DNSSDException

{

super(client);

this.ThrowOnErr( this.CreateQuery( flags, ifIndex, serviceName, rrtype, rrclass));

if ( !AppleDNSSD.hasAutoCallbacks)

new Thread(this).start();

}

// Sets fNativeContext. Returns non-zero on error.

protected native int CreateQuery( int flags, int ifIndex, String serviceName, int rrtype, int rrclass);

}

class AppleDomainEnum extends AppleService

{

public AppleDomainEnum( int flags, int ifIndex, DomainListener client)

throws DNSSDException

{

super(client);

this.ThrowOnErr( this.BeginEnum( flags, ifIndex));

if ( !AppleDNSSD.hasAutoCallbacks)

new Thread(this).start();

}

// Sets fNativeContext. Returns non-zero on error.

protected native int BeginEnum( int flags, int ifIndex);

}