/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
 *
 * 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.

    This file contains the platform support for DNSSD and related Java classes.
    It is used to shim through to the underlying <dns_sd.h> API.
 */

// AUTO_CALLBACKS should be set to 1 if the underlying mDNS implementation fires response
// callbacks automatically (as in the early Windows prototypes).
// AUTO_CALLBACKS should be set to 0 if the client must call DNSServiceProcessResult() to
// invoke response callbacks (as is true on Mac OS X, Posix, Windows, etc.).
// (Invoking callbacks automatically on a different thread sounds attractive, but while
// the client gains by not needing to add an event source to its main event loop, it loses
// by being forced to deal with concurrency and locking, which can be a bigger burden.)
#ifndef AUTO_CALLBACKS
#define AUTO_CALLBACKS  0
#endif

#if !AUTO_CALLBACKS
#ifdef _WIN32
#include <winsock2.h>
#else //_WIN32
#include <sys/types.h>
#include <sys/select.h>
#endif // _WIN32
#endif // AUTO_CALLBACKS

#include <dns_sd.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
#include <winsock2.h>
#include <iphlpapi.h>
static char *   win32_if_indextoname( DWORD ifIndex, char * nameBuff);
static DWORD    win32_if_nametoindex( const char * nameStr );
#define if_indextoname win32_if_indextoname
#define if_nametoindex win32_if_nametoindex
#define IF_NAMESIZE MAX_ADAPTER_NAME_LENGTH
#else // _WIN32
#include <sys/socket.h>
#include <net/if.h>
#endif // _WIN32

// When compiling with "-Wshadow" set, including jni.h produces the following error:
// /System/Library/Frameworks/JavaVM.framework/Versions/A/Headers/jni.h:609: warning: declaration of 'index' shadows a global declaration
// To work around this, we use the preprocessor to map the identifier 'index', which appears harmlessly in function prototype declarations,
// to something 'jni_index', which doesn't conflict
#define index jni_index
#include "DNSSD.java.h"
#undef index

//#include <syslog.h>

// convenience definition
#ifdef __GNUC__
#define _UNUSED __attribute__ ((unused))
#else
#define _UNUSED
#endif

enum {
    kInterfaceVersionOne = 1,
    kInterfaceVersionCurrent        // Must match version in .jar file
};

typedef struct OpContext OpContext;

struct  OpContext
{
    DNSServiceRef ServiceRef;
    JNIEnv          *Env;
    jobject JavaObj;
    jobject ClientObj;
    jmethodID Callback;
    jmethodID Callback2;
};

// For AUTO_CALLBACKS, we must attach the callback thread to the Java VM prior to upcall.
#if AUTO_CALLBACKS
JavaVM      *gJavaVM = NULL;
#endif


JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleDNSSD_InitLibrary( JNIEnv *pEnv, jclass cls,
                                                                    jint callerVersion)
{
    /* Ensure that caller & interface versions match. */
    if ( callerVersion != kInterfaceVersionCurrent)
        return kDNSServiceErr_Incompatible;

#if AUTO_CALLBACKS
    {
        jsize numVMs;

        if ( 0 != JNI_GetCreatedJavaVMs( &gJavaVM, 1, &numVMs))
            return kDNSServiceErr_BadState;
    }
#endif

    // Set AppleDNSSD.hasAutoCallbacks
    {
#if AUTO_CALLBACKS
        jboolean hasAutoC = JNI_TRUE;
#else
        jboolean hasAutoC = JNI_FALSE;
#endif
        jfieldID hasAutoCField = (*pEnv)->GetStaticFieldID( pEnv, cls, "hasAutoCallbacks", "Z");
        (*pEnv)->SetStaticBooleanField( pEnv, cls, hasAutoCField, hasAutoC);
    }

    return kDNSServiceErr_NoError;
}


static const char*  SafeGetUTFChars( JNIEnv *pEnv, jstring str)
// Wrapper for JNI GetStringUTFChars() that returns NULL for null str.
{
    return str != NULL ? (*pEnv)->GetStringUTFChars( pEnv, str, 0) : NULL;
}

static void         SafeReleaseUTFChars( JNIEnv *pEnv, jstring str, const char *buff)
// Wrapper for JNI GetStringUTFChars() that handles null str.
{
    if ( str != NULL)
        (*pEnv)->ReleaseStringUTFChars( pEnv, str, buff);
}


#if AUTO_CALLBACKS
static void SetupCallbackState( JNIEnv **ppEnv)
{
    (*gJavaVM)->AttachCurrentThread( gJavaVM, (void**) ppEnv, NULL);
}

static void TeardownCallbackState( void )
{
    (*gJavaVM)->DetachCurrentThread( gJavaVM);
}

#else   // AUTO_CALLBACKS

static void SetupCallbackState( JNIEnv **ppEnv _UNUSED)
{
    // No setup necessary if ProcessResults() has been called
}

static void TeardownCallbackState( void )
{
    // No teardown necessary if ProcessResults() has been called
}
#endif  // AUTO_CALLBACKS


static OpContext    *NewContext( JNIEnv *pEnv, jobject owner,
                                 const char *callbackName, const char *callbackSig)
// Create and initialize a new OpContext.
{
    OpContext               *pContext = (OpContext*) malloc( sizeof *pContext);

    if ( pContext != NULL)
    {
        jfieldID clientField = (*pEnv)->GetFieldID( pEnv, (*pEnv)->GetObjectClass( pEnv, owner),
                                                    "fListener", "Lcom/apple/dnssd/BaseListener;");

        pContext->JavaObj = (*pEnv)->NewWeakGlobalRef( pEnv, owner);    // must convert local ref to global to cache;
        pContext->ClientObj = (*pEnv)->GetObjectField( pEnv, owner, clientField);
        pContext->ClientObj = (*pEnv)->NewWeakGlobalRef( pEnv, pContext->ClientObj);    // must convert local ref to global to cache
        pContext->Callback = (*pEnv)->GetMethodID( pEnv,
                                                   (*pEnv)->GetObjectClass( pEnv, pContext->ClientObj),
                                                   callbackName, callbackSig);
        pContext->Callback2 = NULL;     // not always used
    }

    return pContext;
}


static void         ReportError( JNIEnv *pEnv, jobject target, jobject service, DNSServiceErrorType err)
// Invoke operationFailed() method on target with err.
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, target);
    jmethodID opFailed = (*pEnv)->GetMethodID( pEnv, cls, "operationFailed",
                                               "(Lcom/apple/dnssd/DNSSDService;I)V");

    (*pEnv)->CallVoidMethod( pEnv, target, opFailed, service, err);
}

JNIEXPORT void JNICALL Java_com_apple_dnssd_AppleService_HaltOperation( JNIEnv *pEnv, jobject pThis)
/* Deallocate the dns_sd service browser and set the Java object's fNativeContext field to 0. */
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");

    if ( contextField != 0)
    {
        OpContext   *pContext = (OpContext*) (long) (*pEnv)->GetLongField(pEnv, pThis, contextField);
        if ( pContext != NULL)
        {
            // MUST clear fNativeContext first, BEFORE calling DNSServiceRefDeallocate()
            (*pEnv)->SetLongField(pEnv, pThis, contextField, 0);
            if ( pContext->ServiceRef != NULL)
                DNSServiceRefDeallocate( pContext->ServiceRef);

            (*pEnv)->DeleteWeakGlobalRef( pEnv, pContext->JavaObj);
            (*pEnv)->DeleteWeakGlobalRef( pEnv, pContext->ClientObj);
            free( pContext);
        }
    }
}


JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleService_BlockForData( JNIEnv *pEnv, jobject pThis)
/* Block until data arrives, or one second passes. Returns 1 if data present, 0 otherwise. */
{
// BlockForData() not supported with AUTO_CALLBACKS
#if !AUTO_CALLBACKS
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");

    if ( contextField != 0)
    {
        OpContext   *pContext = (OpContext*) (long) (*pEnv)->GetLongField(pEnv, pThis, contextField);
        if ( pContext != NULL)
        {
            fd_set readFDs;
            int sd = DNSServiceRefSockFD( pContext->ServiceRef);
            struct timeval timeout = { 1, 0 };
            FD_ZERO( &readFDs);
            FD_SET( sd, &readFDs);

            // Q: Why do we poll here?
            // A: Because there's no other thread-safe way to do it.
            // Mac OS X terminates a select() call if you close one of the sockets it's listening on, but Linux does not,
            // and arguably Linux is correct (See <http://www.ussg.iu.edu/hypermail/linux/kernel/0405.1/0418.html>)
            // The problem is that the Mac OS X behaviour assumes that it's okay for one thread to close a socket while
            // some other thread is monitoring that socket in select(), but the difficulty is that there's no general way
            // to make that thread-safe, because there's no atomic way to enter select() and release a lock simultaneously.
            // If we try to do this without holding any lock, then right as we jump to the select() routine,
            // some other thread could stop our operation (thereby closing the socket),
            // and then that thread (or even some third, unrelated thread)
            // could do some other DNS-SD operation (or some other operation that opens a new file descriptor)
            // and then we'd blindly resume our fall into the select() call, now blocking on a file descriptor
            // that may coincidentally have the same numerical value, but is semantically unrelated
            // to the true file descriptor we thought we were blocking on.
            // We can't stop this race condition from happening, but at least if we wake up once a second we can detect
            // when fNativeContext has gone to zero, and thereby discover that we were blocking on the wrong fd.

            if (select( sd + 1, &readFDs, (fd_set*) NULL, (fd_set*) NULL, &timeout) == 1) return(1);
        }
    }
#endif // !AUTO_CALLBACKS
    return(0);
}


JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleService_ProcessResults( JNIEnv *pEnv, jobject pThis)
/* Call through to DNSServiceProcessResult() while data remains on socket. */
{
#if !AUTO_CALLBACKS // ProcessResults() not supported with AUTO_CALLBACKS

    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    OpContext       *pContext = (OpContext*) (long) (*pEnv)->GetLongField(pEnv, pThis, contextField);
    DNSServiceErrorType err = kDNSServiceErr_BadState;

    if ( pContext != NULL)
    {
        int sd = DNSServiceRefSockFD( pContext->ServiceRef);
        fd_set readFDs;
        struct timeval zeroTimeout = { 0, 0 };

        pContext->Env = pEnv;

        FD_ZERO( &readFDs);
        FD_SET( sd, &readFDs);

        err = kDNSServiceErr_NoError;
        if (0 < select(sd + 1, &readFDs, (fd_set*) NULL, (fd_set*) NULL, &zeroTimeout))
        {
            err = DNSServiceProcessResult(pContext->ServiceRef);
            // Use caution here!
            // We cannot touch any data structures associated with this operation!
            // The DNSServiceProcessResult() routine should have invoked our callback,
            // and our callback could have terminated the operation with op.stop();
            // and that means HaltOperation() will have been called, which frees pContext.
            // Basically, from here we just have to get out without touching any stale
            // data structures that could blow up on us! Particularly, any attempt
            // to loop here reading more results from the file descriptor is unsafe.
        }
    }
    return err;
#endif // AUTO_CALLBACKS
}


static void DNSSD_API   ServiceBrowseReply( DNSServiceRef sdRef _UNUSED, DNSServiceFlags flags, uint32_t interfaceIndex,
                                            DNSServiceErrorType errorCode, const char *serviceName, const char *regtype,
                                            const char *replyDomain, void *context)
{
    OpContext       *pContext = (OpContext*) context;

    SetupCallbackState( &pContext->Env);

    if ( pContext->ClientObj != NULL && pContext->Callback != NULL)
    {
        if ( errorCode == kDNSServiceErr_NoError)
        {
            (*pContext->Env)->CallVoidMethod( pContext->Env, pContext->ClientObj,
                                              ( flags & kDNSServiceFlagsAdd) != 0 ? pContext->Callback : pContext->Callback2,
                                              pContext->JavaObj, flags, interfaceIndex,
                                              (*pContext->Env)->NewStringUTF( pContext->Env, serviceName),
                                              (*pContext->Env)->NewStringUTF( pContext->Env, regtype),
                                              (*pContext->Env)->NewStringUTF( pContext->Env, replyDomain));
        }
        else
            ReportError( pContext->Env, pContext->ClientObj, pContext->JavaObj, errorCode);
    }

    TeardownCallbackState();
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleBrowser_CreateBrowser( JNIEnv *pEnv, jobject pThis,
                                                                        jint flags, jint ifIndex, jstring regType, jstring domain)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;

    if ( contextField != 0)
        pContext = NewContext( pEnv, pThis, "serviceFound",
                               "(Lcom/apple/dnssd/DNSSDService;IILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
    else
        err = kDNSServiceErr_BadParam;

    if ( pContext != NULL)
    {
        const char  *regStr = SafeGetUTFChars( pEnv, regType);
        const char  *domainStr = SafeGetUTFChars( pEnv, domain);

        pContext->Callback2 = (*pEnv)->GetMethodID( pEnv,
                                                    (*pEnv)->GetObjectClass( pEnv, pContext->ClientObj),
                                                    "serviceLost", "(Lcom/apple/dnssd/DNSSDService;IILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");

        err = DNSServiceBrowse( &pContext->ServiceRef, flags, ifIndex, regStr, domainStr, ServiceBrowseReply, pContext);
        if ( err == kDNSServiceErr_NoError)
        {
            (*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
        }

        SafeReleaseUTFChars( pEnv, regType, regStr);
        SafeReleaseUTFChars( pEnv, domain, domainStr);
    }
    else
        err = kDNSServiceErr_NoMemory;

    return err;
}


static void DNSSD_API   ServiceResolveReply( DNSServiceRef sdRef _UNUSED, DNSServiceFlags flags, uint32_t interfaceIndex,
                                             DNSServiceErrorType errorCode, const char *fullname, const char *hosttarget,
                                             uint16_t port, uint16_t txtLen, const unsigned char *txtRecord, void *context)
{
    OpContext       *pContext = (OpContext*) context;
    jclass txtCls;
    jmethodID txtCtor;
    jbyteArray txtBytes;
    jobject txtObj;
    jbyte           *pBytes;

    SetupCallbackState( &pContext->Env);

    txtCls = (*pContext->Env)->FindClass( pContext->Env, "com/apple/dnssd/TXTRecord");
    txtCtor = (*pContext->Env)->GetMethodID( pContext->Env, txtCls, "<init>", "([B)V");

    if ( pContext->ClientObj != NULL && pContext->Callback != NULL && txtCtor != NULL &&
         NULL != ( txtBytes = (*pContext->Env)->NewByteArray( pContext->Env, txtLen)))
    {
        if ( errorCode == kDNSServiceErr_NoError)
        {
            // Since Java ints are defined to be big-endian, we canonicalize 'port' from a 16-bit
            // pattern into a number here.
            port = ( ((unsigned char*) &port)[0] << 8) | ((unsigned char*) &port)[1];

            // Initialize txtBytes with contents of txtRecord
            pBytes = (*pContext->Env)->GetByteArrayElements( pContext->Env, txtBytes, NULL);
            memcpy( pBytes, txtRecord, txtLen);
            (*pContext->Env)->ReleaseByteArrayElements( pContext->Env, txtBytes, pBytes, JNI_COMMIT);

            // Construct txtObj with txtBytes
            txtObj = (*pContext->Env)->NewObject( pContext->Env, txtCls, txtCtor, txtBytes);
            (*pContext->Env)->DeleteLocalRef( pContext->Env, txtBytes);

            (*pContext->Env)->CallVoidMethod( pContext->Env, pContext->ClientObj, pContext->Callback,
                                              pContext->JavaObj, flags, interfaceIndex,
                                              (*pContext->Env)->NewStringUTF( pContext->Env, fullname),
                                              (*pContext->Env)->NewStringUTF( pContext->Env, hosttarget),
                                              port, txtObj);
        }
        else
            ReportError( pContext->Env, pContext->ClientObj, pContext->JavaObj, errorCode);
    }

    TeardownCallbackState();
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleResolver_CreateResolver( JNIEnv *pEnv, jobject pThis,
                                                                          jint flags, jint ifIndex, jstring serviceName, jstring regType, jstring domain)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;

    if ( contextField != 0)
        pContext = NewContext( pEnv, pThis, "serviceResolved",
                               "(Lcom/apple/dnssd/DNSSDService;IILjava/lang/String;Ljava/lang/String;ILcom/apple/dnssd/TXTRecord;)V");
    else
        err = kDNSServiceErr_BadParam;

    if ( pContext != NULL)
    {
        const char  *servStr = SafeGetUTFChars( pEnv, serviceName);
        const char  *regStr = SafeGetUTFChars( pEnv, regType);
        const char  *domainStr = SafeGetUTFChars( pEnv, domain);

        err = DNSServiceResolve( &pContext->ServiceRef, flags, ifIndex,
                                 servStr, regStr, domainStr, ServiceResolveReply, pContext);
        if ( err == kDNSServiceErr_NoError)
        {
            (*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
        }

        SafeReleaseUTFChars( pEnv, serviceName, servStr);
        SafeReleaseUTFChars( pEnv, regType, regStr);
        SafeReleaseUTFChars( pEnv, domain, domainStr);
    }
    else
        err = kDNSServiceErr_NoMemory;

    return err;
}


static void DNSSD_API   ServiceRegisterReply( DNSServiceRef sdRef _UNUSED, DNSServiceFlags flags,
                                              DNSServiceErrorType errorCode, const char *serviceName,
                                              const char *regType, const char *domain, void *context)
{
    OpContext       *pContext = (OpContext*) context;

    SetupCallbackState( &pContext->Env);

    if ( pContext->ClientObj != NULL && pContext->Callback != NULL)
    {
        if ( errorCode == kDNSServiceErr_NoError)
        {
            (*pContext->Env)->CallVoidMethod( pContext->Env, pContext->ClientObj, pContext->Callback,
                                              pContext->JavaObj, flags,
                                              (*pContext->Env)->NewStringUTF( pContext->Env, serviceName),
                                              (*pContext->Env)->NewStringUTF( pContext->Env, regType),
                                              (*pContext->Env)->NewStringUTF( pContext->Env, domain));
        }
        else
            ReportError( pContext->Env, pContext->ClientObj, pContext->JavaObj, errorCode);
    }
    TeardownCallbackState();
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleRegistration_BeginRegister( JNIEnv *pEnv, jobject pThis,
                                                                             jint ifIndex, jint flags, jstring serviceName, jstring regType,
                                                                             jstring domain, jstring host, jint port, jbyteArray txtRecord)
{
    //syslog(LOG_ERR, "BR");
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;
    jbyte                   *pBytes;
    jsize numBytes;

    //syslog(LOG_ERR, "BR: contextField %d", contextField);

    if ( contextField != 0)
        pContext = NewContext( pEnv, pThis, "serviceRegistered",
                               "(Lcom/apple/dnssd/DNSSDRegistration;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
    else
        err = kDNSServiceErr_BadParam;

    if ( pContext != NULL)
    {
        const char  *servStr = SafeGetUTFChars( pEnv, serviceName);
        const char  *regStr = SafeGetUTFChars( pEnv, regType);
        const char  *domainStr = SafeGetUTFChars( pEnv, domain);
        const char  *hostStr = SafeGetUTFChars( pEnv, host);

        //syslog(LOG_ERR, "BR: regStr %s", regStr);

        // Since Java ints are defined to be big-endian, we de-canonicalize 'port' from a
        // big-endian number into a 16-bit pattern here.
        uint16_t portBits = port;
        portBits = ( ((unsigned char*) &portBits)[0] << 8) | ((unsigned char*) &portBits)[1];

        pBytes = txtRecord ? (*pEnv)->GetByteArrayElements( pEnv, txtRecord, NULL) : NULL;
        numBytes = txtRecord ? (*pEnv)->GetArrayLength( pEnv, txtRecord) : 0;

        err = DNSServiceRegister( &pContext->ServiceRef, flags, ifIndex, servStr, regStr,
                                  domainStr, hostStr, portBits,
                                  numBytes, pBytes, ServiceRegisterReply, pContext);
        if ( err == kDNSServiceErr_NoError)
        {
            (*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
        }

        if ( pBytes != NULL)
            (*pEnv)->ReleaseByteArrayElements( pEnv, txtRecord, pBytes, 0);

        SafeReleaseUTFChars( pEnv, serviceName, servStr);
        SafeReleaseUTFChars( pEnv, regType, regStr);
        SafeReleaseUTFChars( pEnv, domain, domainStr);
        SafeReleaseUTFChars( pEnv, host, hostStr);
    }
    else
        err = kDNSServiceErr_NoMemory;

    return err;
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleRegistration_AddRecord( JNIEnv *pEnv, jobject pThis,
                                                                         jint flags, jint rrType, jbyteArray rData, jint ttl, jobject destObj)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    jclass destCls = (*pEnv)->GetObjectClass( pEnv, destObj);
    jfieldID recField = (*pEnv)->GetFieldID( pEnv, destCls, "fRecord", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;
    jbyte                   *pBytes;
    jsize numBytes;
    DNSRecordRef recRef;

    if ( contextField != 0)
        pContext = (OpContext*) (long) (*pEnv)->GetLongField(pEnv, pThis, contextField);
    if ( pContext == NULL || pContext->ServiceRef == NULL)
        return kDNSServiceErr_BadParam;

    pBytes = (*pEnv)->GetByteArrayElements( pEnv, rData, NULL);
    numBytes = (*pEnv)->GetArrayLength( pEnv, rData);

    err = DNSServiceAddRecord( pContext->ServiceRef, &recRef, flags, rrType, numBytes, pBytes, ttl);
    if ( err == kDNSServiceErr_NoError)
    {
        (*pEnv)->SetLongField(pEnv, destObj, recField, (long) recRef);
    }

    if ( pBytes != NULL)
        (*pEnv)->ReleaseByteArrayElements( pEnv, rData, pBytes, 0);

    return err;
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleDNSRecord_Update( JNIEnv *pEnv, jobject pThis,
                                                                   jint flags, jbyteArray rData, jint ttl)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID ownerField = (*pEnv)->GetFieldID( pEnv, cls, "fOwner", "Lcom/apple/dnssd/AppleService;");
    jfieldID recField = (*pEnv)->GetFieldID( pEnv, cls, "fRecord", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;
    jbyte                   *pBytes;
    jsize numBytes;
    DNSRecordRef recRef = NULL;

    if ( ownerField != 0)
    {
        jobject ownerObj = (*pEnv)->GetObjectField( pEnv, pThis, ownerField);
        jclass ownerClass = (*pEnv)->GetObjectClass( pEnv, ownerObj);
        jfieldID contextField = (*pEnv)->GetFieldID( pEnv, ownerClass, "fNativeContext", "J");
        if ( contextField != 0)
            pContext = (OpContext*) (long) (*pEnv)->GetLongField(pEnv, ownerObj, contextField);
    }
    if ( recField != 0)
        recRef = (DNSRecordRef) (long) (*pEnv)->GetLongField(pEnv, pThis, recField);
    if ( pContext == NULL || pContext->ServiceRef == NULL)
        return kDNSServiceErr_BadParam;

    pBytes = (*pEnv)->GetByteArrayElements( pEnv, rData, NULL);
    numBytes = (*pEnv)->GetArrayLength( pEnv, rData);

    err = DNSServiceUpdateRecord( pContext->ServiceRef, recRef, flags, numBytes, pBytes, ttl);

    if ( pBytes != NULL)
        (*pEnv)->ReleaseByteArrayElements( pEnv, rData, pBytes, 0);

    return err;
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleDNSRecord_Remove( JNIEnv *pEnv, jobject pThis)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID ownerField = (*pEnv)->GetFieldID( pEnv, cls, "fOwner", "Lcom/apple/dnssd/AppleService;");
    jfieldID recField = (*pEnv)->GetFieldID( pEnv, cls, "fRecord", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;
    DNSRecordRef recRef = NULL;

    if ( ownerField != 0)
    {
        jobject ownerObj = (*pEnv)->GetObjectField( pEnv, pThis, ownerField);
        jclass ownerClass = (*pEnv)->GetObjectClass( pEnv, ownerObj);
        jfieldID contextField = (*pEnv)->GetFieldID( pEnv, ownerClass, "fNativeContext", "J");
        if ( contextField != 0)
            pContext = (OpContext*) (long) (*pEnv)->GetLongField(pEnv, ownerObj, contextField);
    }
    if ( recField != 0)
        recRef = (DNSRecordRef) (long) (*pEnv)->GetLongField(pEnv, pThis, recField);
    if ( pContext == NULL || pContext->ServiceRef == NULL)
        return kDNSServiceErr_BadParam;

    err = DNSServiceRemoveRecord( pContext->ServiceRef, recRef, 0);

    return err;
}


JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleRecordRegistrar_CreateConnection( JNIEnv *pEnv, jobject pThis)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;

    if ( contextField != 0)
        pContext = NewContext( pEnv, pThis, "recordRegistered", "(Lcom/apple/dnssd/DNSRecord;I)V");
    else
        err = kDNSServiceErr_BadParam;

    if ( pContext != NULL)
    {
        err = DNSServiceCreateConnection( &pContext->ServiceRef);
        if ( err == kDNSServiceErr_NoError)
        {
            (*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
        }
    }
    else
        err = kDNSServiceErr_NoMemory;

    return err;
}

struct RecordRegistrationRef
{
    OpContext       *Context;
    jobject RecordObj;
};
typedef struct RecordRegistrationRef RecordRegistrationRef;

static void DNSSD_API   RegisterRecordReply( DNSServiceRef sdRef _UNUSED,
                                             DNSRecordRef recordRef _UNUSED, DNSServiceFlags flags,
                                             DNSServiceErrorType errorCode, void *context)
{
    RecordRegistrationRef   *regEnvelope = (RecordRegistrationRef*) context;
    OpContext       *pContext = regEnvelope->Context;

    SetupCallbackState( &pContext->Env);

    if ( pContext->ClientObj != NULL && pContext->Callback != NULL)
    {
        if ( errorCode == kDNSServiceErr_NoError)
        {
            (*pContext->Env)->CallVoidMethod( pContext->Env, pContext->ClientObj, pContext->Callback,
                                              regEnvelope->RecordObj, flags);
        }
        else
            ReportError( pContext->Env, pContext->ClientObj, pContext->JavaObj, errorCode);
    }

    (*pContext->Env)->DeleteWeakGlobalRef( pContext->Env, regEnvelope->RecordObj);
    free( regEnvelope);

    TeardownCallbackState();
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleRecordRegistrar_RegisterRecord( JNIEnv *pEnv, jobject pThis,
                                                                                 jint flags, jint ifIndex, jstring fullname, jint rrType, jint rrClass,
                                                                                 jbyteArray rData, jint ttl, jobject destObj)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    jclass destCls = (*pEnv)->GetObjectClass( pEnv, destObj);
    jfieldID recField = (*pEnv)->GetFieldID( pEnv, destCls, "fRecord", "J");
    const char              *nameStr = SafeGetUTFChars( pEnv, fullname);
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;
    jbyte                   *pBytes;
    jsize numBytes;
    DNSRecordRef recRef;
    RecordRegistrationRef   *regEnvelope;

    if ( contextField != 0)
        pContext = (OpContext*) (long) (*pEnv)->GetLongField(pEnv, pThis, contextField);
    if ( pContext == NULL || pContext->ServiceRef == NULL || nameStr == NULL)
        return kDNSServiceErr_BadParam;

    regEnvelope = calloc( 1, sizeof *regEnvelope);
    if ( regEnvelope == NULL)
        return kDNSServiceErr_NoMemory;
    regEnvelope->Context = pContext;
    regEnvelope->RecordObj = (*pEnv)->NewWeakGlobalRef( pEnv, destObj); // must convert local ref to global to cache

    pBytes = (*pEnv)->GetByteArrayElements( pEnv, rData, NULL);
    numBytes = (*pEnv)->GetArrayLength( pEnv, rData);

    err = DNSServiceRegisterRecord( pContext->ServiceRef, &recRef, flags, ifIndex,
                                    nameStr, rrType, rrClass, numBytes, pBytes, ttl,
                                    RegisterRecordReply, regEnvelope);

    if ( err == kDNSServiceErr_NoError)
    {
        (*pEnv)->SetLongField(pEnv, destObj, recField, (long) recRef);
    }
    else
    {
        if ( regEnvelope->RecordObj != NULL)
            (*pEnv)->DeleteWeakGlobalRef( pEnv, regEnvelope->RecordObj);
        free( regEnvelope);
    }

    if ( pBytes != NULL)
        (*pEnv)->ReleaseByteArrayElements( pEnv, rData, pBytes, 0);

    SafeReleaseUTFChars( pEnv, fullname, nameStr);

    return err;
}


static void DNSSD_API   ServiceQueryReply( DNSServiceRef sdRef _UNUSED, DNSServiceFlags flags, uint32_t interfaceIndex,
                                           DNSServiceErrorType errorCode, const char *serviceName,
                                           uint16_t rrtype, uint16_t rrclass, uint16_t rdlen,
                                           const void *rdata, uint32_t ttl, void *context)
{
    OpContext       *pContext = (OpContext*) context;
    jbyteArray rDataObj;
    jbyte           *pBytes;

    SetupCallbackState( &pContext->Env);

    if ( pContext->ClientObj != NULL && pContext->Callback != NULL &&
         NULL != ( rDataObj = (*pContext->Env)->NewByteArray( pContext->Env, rdlen)))
    {
        if ( errorCode == kDNSServiceErr_NoError)
        {
            // Initialize rDataObj with contents of rdata
            pBytes = (*pContext->Env)->GetByteArrayElements( pContext->Env, rDataObj, NULL);
            memcpy( pBytes, rdata, rdlen);
            (*pContext->Env)->ReleaseByteArrayElements( pContext->Env, rDataObj, pBytes, JNI_COMMIT);

            (*pContext->Env)->CallVoidMethod( pContext->Env, pContext->ClientObj, pContext->Callback,
                                              pContext->JavaObj, flags, interfaceIndex,
                                              (*pContext->Env)->NewStringUTF( pContext->Env, serviceName),
                                              rrtype, rrclass, rDataObj, ttl);
        }
        else
            ReportError( pContext->Env, pContext->ClientObj, pContext->JavaObj, errorCode);
    }
    TeardownCallbackState();
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleQuery_CreateQuery( JNIEnv *pEnv, jobject pThis,
                                                                    jint flags, jint ifIndex, jstring serviceName, jint rrtype, jint rrclass)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;

    if ( contextField != 0)
        pContext = NewContext( pEnv, pThis, "queryAnswered",
                               "(Lcom/apple/dnssd/DNSSDService;IILjava/lang/String;II[BI)V");
    else
        err = kDNSServiceErr_BadParam;

    if ( pContext != NULL)
    {
        const char  *servStr = SafeGetUTFChars( pEnv, serviceName);

        err = DNSServiceQueryRecord( &pContext->ServiceRef, flags, ifIndex, servStr,
                                     rrtype, rrclass, ServiceQueryReply, pContext);
        if ( err == kDNSServiceErr_NoError)
        {
            (*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
        }

        SafeReleaseUTFChars( pEnv, serviceName, servStr);
    }
    else
        err = kDNSServiceErr_NoMemory;

    return err;
}


static void DNSSD_API   DomainEnumReply( DNSServiceRef sdRef _UNUSED, DNSServiceFlags flags, uint32_t interfaceIndex,
                                         DNSServiceErrorType errorCode, const char *replyDomain, void *context)
{
    OpContext       *pContext = (OpContext*) context;

    SetupCallbackState( &pContext->Env);

    if ( pContext->ClientObj != NULL && pContext->Callback != NULL)
    {
        if ( errorCode == kDNSServiceErr_NoError)
        {
            (*pContext->Env)->CallVoidMethod( pContext->Env, pContext->ClientObj,
                                              ( flags & kDNSServiceFlagsAdd) != 0 ? pContext->Callback : pContext->Callback2,
                                              pContext->JavaObj, flags, interfaceIndex,
                                              (*pContext->Env)->NewStringUTF( pContext->Env, replyDomain));
        }
        else
            ReportError( pContext->Env, pContext->ClientObj, pContext->JavaObj, errorCode);
    }
    TeardownCallbackState();
}

JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleDomainEnum_BeginEnum( JNIEnv *pEnv, jobject pThis,
                                                                       jint flags, jint ifIndex)
{
    jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
    jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
    OpContext               *pContext = NULL;
    DNSServiceErrorType err = kDNSServiceErr_NoError;

    if ( contextField != 0)
        pContext = NewContext( pEnv, pThis, "domainFound",
                               "(Lcom/apple/dnssd/DNSSDService;IILjava/lang/String;)V");
    else
        err = kDNSServiceErr_BadParam;

    if ( pContext != NULL)
    {
        pContext->Callback2 = (*pEnv)->GetMethodID( pEnv,
                                                    (*pEnv)->GetObjectClass( pEnv, pContext->ClientObj),
                                                    "domainLost", "(Lcom/apple/dnssd/DNSSDService;IILjava/lang/String;)V");

        err = DNSServiceEnumerateDomains( &pContext->ServiceRef, flags, ifIndex,
                                          DomainEnumReply, pContext);
        if ( err == kDNSServiceErr_NoError)
        {
            (*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
        }
    }
    else
        err = kDNSServiceErr_NoMemory;

    return err;
}


JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleDNSSD_ConstructName( JNIEnv *pEnv, jobject pThis _UNUSED,
                                                                      jstring serviceName, jstring regtype, jstring domain, jobjectArray pOut)
{
    DNSServiceErrorType err = kDNSServiceErr_NoError;
    const char              *nameStr = SafeGetUTFChars( pEnv, serviceName);
    const char              *regStr = SafeGetUTFChars( pEnv, regtype);
    const char              *domStr = SafeGetUTFChars( pEnv, domain);
    char buff[ kDNSServiceMaxDomainName + 1];

    err = DNSServiceConstructFullName( buff, nameStr, regStr, domStr);

    if ( err == kDNSServiceErr_NoError)
    {
        // pOut is expected to be a String[1] array.
        (*pEnv)->SetObjectArrayElement( pEnv, pOut, 0, (*pEnv)->NewStringUTF( pEnv, buff));
    }

    SafeReleaseUTFChars( pEnv, serviceName, nameStr);
    SafeReleaseUTFChars( pEnv, regtype, regStr);
    SafeReleaseUTFChars( pEnv, domain, domStr);

    return err;
}

JNIEXPORT void JNICALL Java_com_apple_dnssd_AppleDNSSD_ReconfirmRecord( JNIEnv *pEnv, jobject pThis _UNUSED,
                                                                        jint flags, jint ifIndex, jstring fullName,
                                                                        jint rrtype, jint rrclass, jbyteArray rdata)
{
    jbyte                   *pBytes;
    jsize numBytes;
    const char              *nameStr = SafeGetUTFChars( pEnv, fullName);

    pBytes = (*pEnv)->GetByteArrayElements( pEnv, rdata, NULL);
    numBytes = (*pEnv)->GetArrayLength( pEnv, rdata);

    DNSServiceReconfirmRecord( flags, ifIndex, nameStr, rrtype, rrclass, numBytes, pBytes);

    if ( pBytes != NULL)
        (*pEnv)->ReleaseByteArrayElements( pEnv, rdata, pBytes, 0);

    SafeReleaseUTFChars( pEnv, fullName, nameStr);
}

#define LOCAL_ONLY_NAME "loo"
#define P2P_NAME "p2p"

JNIEXPORT jstring JNICALL Java_com_apple_dnssd_AppleDNSSD_GetNameForIfIndex( JNIEnv *pEnv, jobject pThis _UNUSED,
                                                                             jint ifIndex)
{
    char                    *p = LOCAL_ONLY_NAME, nameBuff[IF_NAMESIZE];

    if (ifIndex == (jint) kDNSServiceInterfaceIndexP2P)
        p = P2P_NAME;
    else if (ifIndex != (jint) kDNSServiceInterfaceIndexLocalOnly)
        p = if_indextoname( ifIndex, nameBuff );

    return (*pEnv)->NewStringUTF( pEnv, p);
}


JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleDNSSD_GetIfIndexForName( JNIEnv *pEnv, jobject pThis _UNUSED,
                                                                          jstring ifName)
{
    uint32_t ifIndex = kDNSServiceInterfaceIndexLocalOnly;
    const char              *nameStr = SafeGetUTFChars( pEnv, ifName);

    if (strcmp(nameStr, P2P_NAME) == 0)
        ifIndex = kDNSServiceInterfaceIndexP2P;
    else if (strcmp(nameStr, LOCAL_ONLY_NAME))
        ifIndex = if_nametoindex( nameStr);

    SafeReleaseUTFChars( pEnv, ifName, nameStr);

    return ifIndex;
}


#if defined(_WIN32)
static char*
win32_if_indextoname( DWORD ifIndex, char * nameBuff)
{
    PIP_ADAPTER_INFO pAdapterInfo = NULL;
    PIP_ADAPTER_INFO pAdapter = NULL;
    DWORD dwRetVal = 0;
    char            *   ifName = NULL;
    ULONG ulOutBufLen = 0;

    if (GetAdaptersInfo( NULL, &ulOutBufLen) != ERROR_BUFFER_OVERFLOW)
    {
        goto exit;
    }

    pAdapterInfo = (IP_ADAPTER_INFO *) malloc(ulOutBufLen);

    if (pAdapterInfo == NULL)
    {
        goto exit;
    }

    dwRetVal = GetAdaptersInfo( pAdapterInfo, &ulOutBufLen );

    if (dwRetVal != NO_ERROR)
    {
        goto exit;
    }

    pAdapter = pAdapterInfo;
    while (pAdapter)
    {
        if (pAdapter->Index == ifIndex)
        {
            // It would be better if we passed in the length of nameBuff to this
            // function, so we would have absolute certainty that no buffer
            // overflows would occur.  Buffer overflows *shouldn't* occur because
            // nameBuff is of size MAX_ADAPTER_NAME_LENGTH.
            strcpy( nameBuff, pAdapter->AdapterName );
            ifName = nameBuff;
            break;
        }

        pAdapter = pAdapter->Next;
    }

exit:

    if (pAdapterInfo != NULL)
    {
        free( pAdapterInfo );
        pAdapterInfo = NULL;
    }

    return ifName;
}


static DWORD
win32_if_nametoindex( const char * nameStr )
{
    PIP_ADAPTER_INFO pAdapterInfo = NULL;
    PIP_ADAPTER_INFO pAdapter = NULL;
    DWORD dwRetVal = 0;
    DWORD ifIndex = 0;
    ULONG ulOutBufLen = 0;

    if (GetAdaptersInfo( NULL, &ulOutBufLen) != ERROR_BUFFER_OVERFLOW)
    {
        goto exit;
    }

    pAdapterInfo = (IP_ADAPTER_INFO *) malloc(ulOutBufLen);

    if (pAdapterInfo == NULL)
    {
        goto exit;
    }

    dwRetVal = GetAdaptersInfo( pAdapterInfo, &ulOutBufLen );

    if (dwRetVal != NO_ERROR)
    {
        goto exit;
    }

    pAdapter = pAdapterInfo;
    while (pAdapter)
    {
        if (strcmp(pAdapter->AdapterName, nameStr) == 0)
        {
            ifIndex = pAdapter->Index;
            break;
        }

        pAdapter = pAdapter->Next;
    }

exit:

    if (pAdapterInfo != NULL)
    {
        free( pAdapterInfo );
        pAdapterInfo = NULL;
    }

    return ifIndex;
}
#endif


// Note: The C preprocessor stringify operator ('#') makes a string from its argument, without macro expansion
// e.g. If "version" is #define'd to be "4", then STRINGIFY_AWE(version) will return the string "version", not "4"
// To expand "version" to its value before making the string, use STRINGIFY(version) instead
#define STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) # s
#define STRINGIFY(s) STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s)

// NOT static -- otherwise the compiler may optimize it out
// The "@(#) " pattern is a special prefix the "what" command looks for
const char VersionString_SCCS[] = "@(#) libjdns_sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";