mDNSMacOS9.c   [plain text]


/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2002-2003 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.
 */

#include <stdio.h>
#include <stdarg.h>                     // For va_list support

#include <LowMem.h>                     // For LMGetCurApName()
#include <TextUtils.h>                  // For smSystemScript
#include <UnicodeConverter.h>           // For ConvertFromPStringToUnicode()

#include "mDNSEmbeddedAPI.h"                // Defines the interface provided to the client layer above

#include "mDNSMacOS9.h"                 // Defines the specific types needed to run mDNS on this platform

// ***************************************************************************
// Constants

static const TSetBooleanOption kReusePortOption =
{ kOTBooleanOptionSize,          INET_IP, IP_REUSEPORT,      0, true };

// IP_RCVDSTADDR with TSetByteOption/kOTOneByteOptionSize works on OS 9, OS X Classic, and OS 9 Carbon,
// but gives error #-3151 (kOTBadOptionErr) on OS X Carbon.
// If we instead use TSetBooleanOption/kOTBooleanOptionSize then OTOptionManagement on OS X Carbon
// no longer returns -3151 but it still doesn't actually work -- no destination addresses
// are delivered by OTRcvUData. I think it's just a bug in OS X Carbon.
static const TSetByteOption kRcvDestAddrOption =
{ kOTOneByteOptionSize,          INET_IP, IP_RCVDSTADDR,     0, true };
//static const TSetBooleanOption kRcvDestAddrOption =
//	{ kOTBooleanOptionSize,          INET_IP, IP_RCVDSTADDR,     0, true };

static const TSetByteOption kSetUnicastTTLOption =
{ kOTOneByteOptionSize,          INET_IP, IP_TTL,            0, 255 };

static const TSetByteOption kSetMulticastTTLOption =
{ kOTOneByteOptionSize,          INET_IP, IP_MULTICAST_TTL,  0, 255 };

static const TIPAddMulticastOption kAddLinkMulticastOption  =
{ sizeof(TIPAddMulticastOption), INET_IP, IP_ADD_MEMBERSHIP, 0, { 224,  0,  0,251 }, { 0,0,0,0 } };

//static const TIPAddMulticastOption kAddAdminMulticastOption =
//	{ sizeof(TIPAddMulticastOption), INET_IP, IP_ADD_MEMBERSHIP, 0, { 239,255,255,251 }, { 0,0,0,0 } };

// Bind endpoint to port number. Don't specify any specific IP address --
// we want to receive unicasts on all interfaces, as well as multicasts.
typedef struct { OTAddressType fAddressType; mDNSIPPort fPort; mDNSv4Addr fHost; UInt8 fUnused[8]; } mDNSInetAddress;
//static const mDNSInetAddress mDNSPortInetAddress = { AF_INET, { 0,0 }, { 0,0,0,0 } };	// For testing legacy client support
#define MulticastDNSPortAsNumber 5353
static const mDNSInetAddress mDNSPortInetAddress = { AF_INET, { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF }, { 0,0,0,0 } };
static const TBind mDNSbindReq = { sizeof(mDNSPortInetAddress), sizeof(mDNSPortInetAddress), (UInt8*)&mDNSPortInetAddress, 0 };

static const TNetbuf zeroTNetbuf = { 0 };

// ***************************************************************************
// Functions

mDNSlocal void SafeDebugStr(unsigned char *buffer)
{
    int i;
    // Don't want semicolons in MacsBug messages -- they signify commands to execute
    for (i=1; i<= buffer[0]; i++) if (buffer[i] == ';') buffer[i] = '.';
    DebugStr(buffer);
}

#if MDNS_DEBUGMSGS
mDNSexport void debugf_(const char *format, ...)
{
    unsigned char buffer[256];
    va_list ptr;
    va_start(ptr,format);
    buffer[0] = (unsigned char)mDNS_vsnprintf((char*)buffer+1, 255, format, ptr);
    va_end(ptr);
#if MDNS_ONLYSYSTEMTASK
    buffer[1+buffer[0]] = 0;
    fprintf(stderr, "%s\n", buffer+1);
    fflush(stderr);
#else
    SafeDebugStr(buffer);
#endif
}
#endif

#if MDNS_BUILDINGSHAREDLIBRARY >= 2
// When building the non-debug version of the Extension, intended to go on end-user systems, we don't want
// MacsBug breaks for *anything*, not even for the serious LogMsg messages that on OS X would be written to syslog
mDNSexport void LogMsg(const char *format, ...) { (void)format; }
#else
mDNSexport void LogMsg(const char *format, ...)
{
    unsigned char buffer[256];
    va_list ptr;
    va_start(ptr,format);
    buffer[0] = (unsigned char)mDNS_vsnprintf((char*)buffer+1, 255, format, ptr);
    va_end(ptr);
#if MDNS_ONLYSYSTEMTASK
    buffer[1+buffer[0]] = 0;
    fprintf(stderr, "%s\n", buffer+1);
    fflush(stderr);
#else
    SafeDebugStr(buffer);
#endif
}
#endif

mDNSexport mStatus mDNSPlatformSendUDP(const mDNS *const m, const void *const msg, const mDNSu8 *const end,
                                       mDNSInterfaceID InterfaceID, const mDNSAddr *dst, mDNSIPPort dstPort)
{
    // Note: If we did multi-homing, we'd have to use the InterfaceID parameter to specify from which interface to send this response
    #pragma unused(InterfaceID)

    InetAddress InetDest;
    TUnitData senddata;

    if (dst->type != mDNSAddrType_IPv4) return(mStatus_NoError);

    InetDest.fAddressType = AF_INET;
    InetDest.fPort        = dstPort.NotAnInteger;
    InetDest.fHost        = dst->ip.v4.NotAnInteger;

    senddata.addr.maxlen = sizeof(InetDest);
    senddata.addr.len    = sizeof(InetDest);
    senddata.addr.buf    = (UInt8*)&InetDest;
    senddata.opt          = zeroTNetbuf;
    senddata.udata.maxlen = (UInt32)((UInt8*)end - (UInt8*)msg);
    senddata.udata.len    = (UInt32)((UInt8*)end - (UInt8*)msg);
    senddata.udata.buf    = (UInt8*)msg;

    return(OTSndUData(m->p->ep, &senddata));
}

mDNSlocal OSStatus readpacket(mDNS *m)
{
    mDNSAddr senderaddr, destaddr;
    mDNSInterfaceID interface;
    mDNSIPPort senderport;
    InetAddress sender;
    char options[256];
    DNSMessage packet;
    TUnitData recvdata;
    OTFlags flags = 0;
    OSStatus err;

    recvdata.addr.maxlen = sizeof(sender);
    recvdata.addr.len    = 0;
    recvdata.addr.buf    = (UInt8*)&sender;
    recvdata.opt.maxlen = sizeof(options);
    recvdata.opt.len    = 0;
    recvdata.opt.buf    = (UInt8*)&options;
    recvdata.udata.maxlen = sizeof(packet);
    recvdata.udata.len    = 0;
    recvdata.udata.buf    = (UInt8*)&packet;

    err = OTRcvUData(m->p->ep, &recvdata, &flags);
    if (err && err != kOTNoDataErr) debugf("OTRcvUData error %d", err);

    if (err) return(err);

    senderaddr.type = mDNSAddrType_IPv4;
    senderaddr.ip.v4.NotAnInteger = sender.fHost;
    senderport.NotAnInteger = sender.fPort;

    destaddr.type = mDNSAddrType_IPv4;
    destaddr.ip.v4  = zerov4Addr;

    #if OTCARBONAPPLICATION
    // IP_RCVDSTADDR is known to fail on OS X Carbon, so we'll just assume the packet was probably multicast
    destaddr.ip.v4  = AllDNSLinkGroup_v4.ip.v4;
    #endif

    if (recvdata.opt.len)
    {
        TOption *c = nil;
        while (1)
        {
            err = OTNextOption(recvdata.opt.buf, recvdata.opt.len, &c);
            if (err || !c) break;
            if (c->level == INET_IP && c->name == IP_RCVDSTADDR && c->len - kOTOptionHeaderSize == sizeof(destaddr.ip.v4))
                mDNSPlatformMemCopy(&destaddr.ip.v4, c->value, sizeof(destaddr.ip.v4));
        }
    }

    interface = m->HostInterfaces->InterfaceID;

    if      (flags & T_MORE) debugf("ERROR: OTRcvUData() buffer too small (T_MORE set)");
    else if (recvdata.addr.len < sizeof(InetAddress)) debugf("ERROR: recvdata.addr.len (%d) too short", recvdata.addr.len);
    else mDNSCoreReceive(m, &packet, recvdata.udata.buf + recvdata.udata.len, &senderaddr, senderport, &destaddr, MulticastDNSPort, interface);

    return(err);
}

mDNSexport TCPSocket *mDNSPlatformTCPSocket(mDNS * const m, TCPSocketFlags flags, mDNSIPPort * port)
{
    (void)m;            // Unused
    (void)flags;        // Unused
    (void)port;         // Unused
    return NULL;
}

mDNSexport TCPSocket *mDNSPlatformTCPAccept(TCPSocketFlags flags, int sd)
{
    (void)flags;        // Unused
    (void)sd;           // Unused
    return NULL;
}

mDNSexport int mDNSPlatformTCPGetFD(TCPSocket *sock)
{
    (void)sock;         // Unused
    return -1;
}

mDNSexport mStatus mDNSPlatformTCPConnect(TCPSocket *sock, const mDNSAddr * dst, mDNSOpaque16 dstport, mDNSInterfaceID InterfaceID,
                                          TCPConnectionCallback callback, void * context)
{
    (void)sock;         // Unused
    (void)dst;          // Unused
    (void)dstport;      // Unused
    (void)InterfaceID;  // Unused
    (void)callback;     // Unused
    (void)context;      // Unused
    return(mStatus_UnsupportedErr);
}

mDNSexport void mDNSPlatformTCPCloseConnection(TCPSocket *sd)
{
    (void)sd;           // Unused
}

mDNSexport long mDNSPlatformReadTCP(TCPSocket *sock, void *buf, unsigned long buflen, mDNSBool *closed)
{
    (void)sock;         // Unused
    (void)buf;          // Unused
    (void)buflen;       // Unused
    (void)closed;       // Unused
    return(0);
}

mDNSexport long mDNSPlatformWriteTCP(TCPSocket *sock, const char *msg, unsigned long len)
{
    (void)sock;         // Unused
    (void)msg;          // Unused
    (void)len;          // Unused
    return(0);
}

mDNSexport UDPSocket *mDNSPlatformUDPSocket(mDNS * const m, mDNSIPPort port)
{
    (void)m;            // Unused
    (void)port;         // Unused
    return NULL;
}

mDNSexport void           mDNSPlatformUDPClose(UDPSocket *sock)
{
    (void)sock;         // Unused
}

mDNSlocal void mDNSOptionManagement(mDNS *const m)
{
    OSStatus err;

    // Make sure the length in the TNetbuf agrees with the length in the TOptionHeader
    m->p->optReq.opt.len    = m->p->optBlock.h.len;
    m->p->optReq.opt.maxlen = m->p->optBlock.h.len;
    if (m->p->optReq.opt.maxlen < 4)
        m->p->optReq.opt.maxlen = 4;

    err = OTOptionManagement(m->p->ep, &m->p->optReq, NULL);
    if (err) LogMsg("OTOptionManagement failed %d", err);
}

mDNSlocal void mDNSinitComplete(mDNS *const m, mStatus result)
{
    m->mDNSPlatformStatus = result;
    mDNSCoreInitComplete(m, mStatus_NoError);
}

mDNSlocal pascal void mDNSNotifier(void *contextPtr, OTEventCode code, OTResult result, void *cookie)
{
    mDNS *const m = (mDNS *const)contextPtr;
    if (!m) debugf("mDNSNotifier FATAL ERROR! No context");
    switch (code)
    {
    case T_OPENCOMPLETE:
    {
        OSStatus err;
        InetInterfaceInfo interfaceinfo;
        if (result) { LogMsg("T_OPENCOMPLETE failed %d", result); mDNSinitComplete(m, result); return; }
        //debugf("T_OPENCOMPLETE");
        m->p->ep = (EndpointRef)cookie;
        //debugf("OTInetGetInterfaceInfo");
        // (In future may want to loop over all interfaces instead of just using kDefaultInetInterface)
        err = OTInetGetInterfaceInfo(&interfaceinfo, kDefaultInetInterface);
        if (err) { LogMsg("OTInetGetInterfaceInfo failed %d", err); mDNSinitComplete(m, err); return; }

        // Make our basic standard host resource records (address, PTR, etc.)
        m->p->interface.InterfaceID             = (mDNSInterfaceID)&m->p->interface;
        m->p->interface.ip.type               = mDNSAddrType_IPv4;
        m->p->interface.ip.ip.v4.NotAnInteger = interfaceinfo.fAddress;
        m->p->interface.mask.type               = mDNSAddrType_IPv4;
        m->p->interface.mask.ip.v4.NotAnInteger = interfaceinfo.fNetmask;
        m->p->interface.ifname[0]               = 0;
        m->p->interface.Advertise               = m->AdvertiseLocalAddresses;
        m->p->interface.McastTxRx               = mDNStrue;
    }

    case T_OPTMGMTCOMPLETE:
    case T_BINDCOMPLETE:
        // IP_RCVDSTADDR is known to fail on OS X Carbon, so we don't want to abort for that error
        // (see comment above at the definition of kRcvDestAddrOption)
            #if OTCARBONAPPLICATION
        if (result && m->p->mOTstate == mOT_RcvDestAddr)
            LogMsg("Carbon IP_RCVDSTADDR option failed %d; continuing anyway", result);
        else
            #endif
        if (result) { LogMsg("T_OPTMGMTCOMPLETE/T_BINDCOMPLETE %d failed %d", m->p->mOTstate, result); mDNSinitComplete(m, result); return; }
        //LogMsg("T_OPTMGMTCOMPLETE/T_BINDCOMPLETE %d", m->p->mOTstate);
        switch (++m->p->mOTstate)
        {
        case mOT_ReusePort:     m->p->optBlock.b = kReusePortOption;         mDNSOptionManagement(m); break;
        case mOT_RcvDestAddr:   m->p->optBlock.i = kRcvDestAddrOption;       mDNSOptionManagement(m); break;
        case mOT_SetUTTL:       m->p->optBlock.i = kSetUnicastTTLOption;     mDNSOptionManagement(m); break;
        case mOT_SetMTTL:       m->p->optBlock.i = kSetMulticastTTLOption;   mDNSOptionManagement(m); break;
        case mOT_LLScope:       m->p->optBlock.m = kAddLinkMulticastOption;  mDNSOptionManagement(m); break;
//				case mOT_AdminScope:	m->p->optBlock.m = kAddAdminMulticastOption; mDNSOptionManagement(m); break;
        case mOT_Bind:          OTBind(m->p->ep, (TBind*)&mDNSbindReq, NULL); break;
        case mOT_Ready:         mDNSinitComplete(m, mStatus_NoError);
            // Can't do mDNS_RegisterInterface until *after* mDNSinitComplete has set m->mDNSPlatformStatus to mStatus_NoError
            mDNS_RegisterInterface(m, &m->p->interface, mDNSfalse);
            break;
        default:                LogMsg("Unexpected m->p->mOTstate %d", m->p->mOTstate-1);
        }
        break;

    case T_DATA:
        //debugf("T_DATA");
        while (readpacket(m) == kOTNoError) continue;       // Read packets until we run out
        break;

    case kOTProviderWillClose: LogMsg("kOTProviderWillClose"); break;
    case kOTProviderIsClosed:           // Machine is going to sleep, shutting down, or reconfiguring IP
        LogMsg("kOTProviderIsClosed");
        if (m->p->mOTstate == mOT_Ready)
        {
            m->p->mOTstate = mOT_Closed;
            mDNS_DeregisterInterface(m, &m->p->interface, mDNSfalse);
        }
        if (m->p->ep) { OTCloseProvider(m->p->ep); m->p->ep = NULL; }
        break;                          // Do we need to do anything?

    default: debugf("mDNSNotifier: Unexpected OTEventCode %X", code);
        break;
    }
}

#if MDNS_ONLYSYSTEMTASK

static Boolean ONLYSYSTEMTASKevent;
static void       *ONLYSYSTEMTASKcontextPtr;
static OTEventCode ONLYSYSTEMTASKcode;
static OTResult ONLYSYSTEMTASKresult;
static void       *ONLYSYSTEMTASKcookie;

mDNSlocal pascal void CallmDNSNotifier(void *contextPtr, OTEventCode code, OTResult result, void *cookie)
{
    ONLYSYSTEMTASKcontextPtr = contextPtr;
    ONLYSYSTEMTASKcode       = code;
    ONLYSYSTEMTASKresult     = result;
    ONLYSYSTEMTASKcookie     = cookie;
}

#else

mDNSlocal pascal void CallmDNSNotifier(void *contextPtr, OTEventCode code, OTResult result, void *cookie)
{
    mDNS *const m = (mDNS *const)contextPtr;
    if (!m) debugf("mDNSNotifier FATAL ERROR! No context");
    if (m->p->nesting) LogMsg("CallmDNSNotifier ERROR! OTEnterNotifier is supposed to suppress notifier callbacks");
    mDNSNotifier(contextPtr, code, result, cookie);
}

#endif

static OTNotifyUPP CallmDNSNotifierUPP;

mDNSlocal OSStatus mDNSOpenEndpoint(const mDNS *const m)
{
    OSStatus err;
    // m->optReq is pre-set to point to the shared m->optBlock
    // m->optBlock is filled in by each OTOptionManagement call
    m->p->optReq.opt.maxlen = sizeof(m->p->optBlock);
    m->p->optReq.opt.len    = sizeof(m->p->optBlock);
    m->p->optReq.opt.buf    = (UInt8*)&m->p->optBlock;
    m->p->optReq.flags      = T_NEGOTIATE;

    // Open an endpoint and start answering queries
    //printf("Opening endpoint now...\n");
    m->p->ep = NULL;
    m->p->mOTstate = mOT_Start;
    err = OTAsyncOpenEndpoint(OTCreateConfiguration(kUDPName), 0, NULL, CallmDNSNotifierUPP, (void*)m);
    if (err) { LogMsg("ERROR: OTAsyncOpenEndpoint(UDP) failed with error <%d>", err); return(err); }
    return(kOTNoError);
}

// Define these here because they're not in older versions of OpenTransport.h
enum
{
    xOTStackIsLoading   = 0x27000001,   /* Sent before Open Transport attempts to load the TCP/IP protocol stack.*/
    xOTStackWasLoaded   = 0x27000002,   /* Sent after the TCP/IP stack has been successfully loaded.*/
    xOTStackIsUnloading = 0x27000003    /* Sent before Open Transport unloads the TCP/IP stack.*/
};

static mDNS *ClientNotifierContext;

mDNSlocal pascal void ClientNotifier(void *contextPtr, OTEventCode code, OTResult result, void *cookie)
{
    mDNS *const m = ClientNotifierContext;

    #pragma unused(contextPtr) // Usually zero (except one in the 'xOTStackIsLoading' case)
    #pragma unused(cookie) // Usually 'ipv4' (except for kOTPortNetworkChange)
    #pragma unused(result) // Usually zero

    switch (code)
    {
    case xOTStackIsLoading:     break;
    case xOTStackWasLoaded:     if (m->p->mOTstate == mOT_Closed)
        {
            LogMsg("kOTStackWasLoaded: Re-opening endpoint");
            if (m->p->ep)
                LogMsg("kOTStackWasLoaded: ERROR: m->p->ep already set");
            m->mDNSPlatformStatus = mStatus_Waiting;
            m->p->mOTstate = mOT_Reset;
                                        #if !MDNS_ONLYSYSTEMTASK
            mDNSOpenEndpoint(m);
                                        #endif
        }
        else
            LogMsg("kOTStackWasLoaded (no action)");
        break;
    case xOTStackIsUnloading:   break;
    case kOTPortNetworkChange:  break;
    default: debugf("ClientNotifier unknown code %X, %X, %d", contextPtr, code, result); break;
    }
}

#if TARGET_API_MAC_CARBON

mDNSlocal void GetUserSpecifiedComputerName(domainlabel *const namelabel)
{
    CFStringRef cfs = CSCopyMachineName();
    CFStringGetPascalString(cfs, namelabel->c, sizeof(*namelabel), kCFStringEncodingUTF8);
    CFRelease(cfs);
}

#else

mDNSlocal OSStatus ConvertStringHandleToUTF8(const StringHandle machineName, UInt8 *const utf8, ByteCount maxlen)
{
    OSStatus status;
    TextEncoding utf8TextEncoding, SystemTextEncoding;
    UnicodeMapping theMapping;
    TextToUnicodeInfo textToUnicodeInfo;
    ByteCount unicodelen = 0;

    if (maxlen > 255) maxlen = 255; // Can't put more than 255 in a Pascal String

    utf8TextEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault, kTextEncodingDefaultVariant, kUnicodeUTF8Format);
    UpgradeScriptInfoToTextEncoding(smSystemScript, kTextLanguageDontCare, kTextRegionDontCare, NULL, &SystemTextEncoding);
    theMapping.unicodeEncoding = utf8TextEncoding;
    theMapping.otherEncoding   = SystemTextEncoding;
    theMapping.mappingVersion  = kUnicodeUseLatestMapping;
    status = CreateTextToUnicodeInfo(&theMapping, &textToUnicodeInfo);
    if (status == noErr)
    {
        status = ConvertFromPStringToUnicode(textToUnicodeInfo, *machineName, maxlen, &unicodelen, (UniCharArrayPtr)&(utf8[1]));
        DisposeTextToUnicodeInfo(&textToUnicodeInfo);
    }
    utf8[0] = (UInt8)unicodelen;
    return(status);
}

mDNSlocal void GetUserSpecifiedComputerName(domainlabel *const namelabel)
{
    StringHandle machineName = GetString(-16413);   // Get machine name set in file sharing
    if (machineName)
    {
        char machineNameState = HGetState((Handle)machineName);
        HLock((Handle)machineName);
        ConvertStringHandleToUTF8(machineName, namelabel->c, MAX_DOMAIN_LABEL);
        HSetState((Handle)machineName, machineNameState);
    }
}

#endif

static pascal void mDNSTimerTask(void *arg)
{
#if MDNS_ONLYSYSTEMTASK
#pragma unused(arg)
    ONLYSYSTEMTASKevent = true;
#else
    mDNS *const m = (mDNS *const)arg;
    if (!m->p->ep) LogMsg("mDNSTimerTask NO endpoint");
    if (m->mDNS_busy) LogMsg("mDNS_busy");
    if (m->p->nesting) LogMsg("mDNSTimerTask ERROR! OTEnterNotifier is supposed to suppress timer callbacks too");

    // If our timer fires at a time when we have no endpoint, ignore it --
    // once we reopen our endpoint and get our T_BINDCOMPLETE message we'll call
    // mDNS_RegisterInterface(), which does a lock/unlock, which retriggers the timer.
    // Likewise, if m->mDNS_busy or m->p->nesting, we'll catch this on the unlock
    if (m->p->ep && m->mDNS_busy == 0 && m->p->nesting == 0) mDNS_Execute(m);
#endif
}

#if TEST_SLEEP
long sleep, wake, mode;
#endif

mDNSexport mStatus mDNSPlatformInit (mDNS *const m)
{
    OSStatus err = InitOpenTransport();

    ClientNotifierContext = m;
    // Note: OTRegisterAsClient returns kOTNotSupportedErr when running as Carbon code on OS X
    // -- but that's okay, we don't need a ClientNotifier when running as Carbon code on OS X
    OTRegisterAsClient(NULL, NewOTNotifyUPP(ClientNotifier));

    m->p->OTTimerTask = OTCreateTimerTask(NewOTProcessUPP(mDNSTimerTask), m);
    m->p->nesting     = 0;

#if TEST_SLEEP
    sleep = TickCount() + 600;
    wake = TickCount() + 1200;
    mode = 0;
#endif

    // Set up the nice label
    m->nicelabel.c[0] = 0;
    GetUserSpecifiedComputerName(&m->nicelabel);
//	m->nicelabel = *(domainlabel*)"\pStu";	// For conflict testing
    if (m->nicelabel.c[0] == 0) MakeDomainLabelFromLiteralString(&m->nicelabel, "Macintosh");

    // Set up the RFC 1034-compliant label
    m->hostlabel.c[0] = 0;
    ConvertUTF8PstringToRFC1034HostLabel(m->nicelabel.c, &m->hostlabel);
    if (m->hostlabel.c[0] == 0) MakeDomainLabelFromLiteralString(&m->hostlabel, "Macintosh");

    mDNS_SetFQDN(m);

    // When it's finished mDNSOpenEndpoint asynchronously calls mDNSinitComplete() and then mDNS_RegisterInterface()
    CallmDNSNotifierUPP = NewOTNotifyUPP(CallmDNSNotifier);
    err = mDNSOpenEndpoint(m);
    if (err)
    {
        LogMsg("mDNSOpenEndpoint failed %d", err);
        if (m->p->OTTimerTask) OTDestroyTimerTask(m->p->OTTimerTask);
        OTUnregisterAsClient();
        CloseOpenTransport();
    }
    return(err);
}

extern void mDNSPlatformClose (mDNS *const m)
{
    if (m->p->mOTstate == mOT_Ready)
    {
        m->p->mOTstate = mOT_Closed;
        mDNS_DeregisterInterface(m, &m->p->interface, mDNSfalse);
    }
    if (m->p->ep)          { OTCloseProvider   (m->p->ep);          m->p->ep          = NULL; }
    if (m->p->OTTimerTask) { OTDestroyTimerTask(m->p->OTTimerTask); m->p->OTTimerTask = 0;    }

    OTUnregisterAsClient();
    CloseOpenTransport();
}

#if MDNS_ONLYSYSTEMTASK
extern void mDNSPlatformIdle(mDNS *const m);
mDNSexport void mDNSPlatformIdle(mDNS *const m)
{
    while (ONLYSYSTEMTASKcontextPtr)
    {
        void *contextPtr = ONLYSYSTEMTASKcontextPtr;
        ONLYSYSTEMTASKcontextPtr = NULL;
        mDNSNotifier(contextPtr, ONLYSYSTEMTASKcode, ONLYSYSTEMTASKresult, ONLYSYSTEMTASKcookie);
    }
    if (ONLYSYSTEMTASKevent)
    {
        ONLYSYSTEMTASKevent = false;
        mDNS_Execute(m);
    }

    if (m->p->mOTstate == mOT_Reset)
    {
        printf("\n");
        printf("******************************************************************************\n");
        printf("\n");
        printf("Reopening endpoint\n");
        mDNSOpenEndpoint(m);
        m->ResourceRecords = NULL;
    }

#if TEST_SLEEP
    switch (mode)
    {
    case 0: if ((long)TickCount() - sleep >= 0) { mDNSCoreMachineSleep(m, 1); mode++; }
        break;
    case 1: if ((long)TickCount() - wake >= 0) { mDNSCoreMachineSleep(m, 0); mode++; }
        break;
    }
#endif
}
#endif

mDNSexport void    mDNSPlatformLock(const mDNS *const m)
{
    if (!m) { DebugStr("\pmDNSPlatformLock m NULL!"); return; }
    if (!m->p) { DebugStr("\pmDNSPlatformLock m->p NULL!"); return; }

    // If we try to call OTEnterNotifier and fail because we're already running at
    // Notifier context, then make sure we don't do the matching OTLeaveNotifier() on exit.
    // If we haven't even opened our endpoint yet, then just increment m->p->nesting for the same reason
    if (m->p->mOTstate == mOT_Ready && !m->p->ep) DebugStr("\pmDNSPlatformLock: m->p->mOTstate == mOT_Ready && !m->p->ep");
    if (!m->p->ep || m->p->nesting || OTEnterNotifier(m->p->ep) == false) m->p->nesting++;
}

mDNSlocal void ScheduleNextTimerCallback(const mDNS *const m)
{
    if (m->mDNSPlatformStatus == mStatus_NoError)
    {
        SInt32 interval = m->NextScheduledEvent - mDNS_TimeNow_NoLock(m);
        if      (interval < 1) interval = 1;
        else if (interval > 0x70000000 / 1000) interval = 0x70000000 / mDNSPlatformOneSecond;
        else interval = (interval * 1000 + mDNSPlatformOneSecond-1)/ mDNSPlatformOneSecond;
        OTScheduleTimerTask(m->p->OTTimerTask, (OTTimeout)interval);
    }
}

mDNSexport void    mDNSPlatformUnlock(const mDNS *const m)
{
    if (!m) { DebugStr("\pmDNSPlatformUnlock m NULL!"); return; }
    if (!m->p) { DebugStr("\pmDNSPlatformUnlock m->p NULL!"); return; }

    if (m->p->ep && m->mDNS_busy == 0) ScheduleNextTimerCallback(m);

    if (m->p->nesting) m->p->nesting--;
    else OTLeaveNotifier(m->p->ep);
}

mDNSexport void     mDNSPlatformStrCopy(      void *dst, const void *src)             { OTStrCopy((char*)dst, (char*)src); }
mDNSexport UInt32   mDNSPlatformStrLen (                 const void *src)             { return(OTStrLength((char*)src)); }
mDNSexport void     mDNSPlatformMemCopy(      void *dst, const void *src, UInt32 len) { OTMemcpy(dst, src, len); }
mDNSexport mDNSBool mDNSPlatformMemSame(const void *dst, const void *src, UInt32 len) { return(OTMemcmp(dst, src, len)); }
mDNSexport void     mDNSPlatformMemZero(      void *dst,                  UInt32 len) { OTMemzero(dst, len); }
mDNSexport void *   mDNSPlatformMemAllocate(mDNSu32 len)                              { return(OTAllocMem(len)); }
mDNSexport void     mDNSPlatformMemFree(void *mem)                                    { OTFreeMem(mem); }
mDNSexport mDNSu32  mDNSPlatformRandomSeed(void)                                      { return(TickCount()); }
mDNSexport mStatus  mDNSPlatformTimeInit(void)                                        { return(mStatus_NoError); }
mDNSexport SInt32   mDNSPlatformRawTime()                                             { return((SInt32)TickCount()); }
mDNSexport SInt32 mDNSPlatformOneSecond = 60;

mDNSexport mDNSs32  mDNSPlatformUTC(void)
{
    // Classic Mac OS since Midnight, 1st Jan 1904
    // Standard Unix counts from 1970
    // This value adjusts for the 66 years and 17 leap-days difference
    mDNSu32 SecsSince1904;
    MachineLocation ThisLocation;
    #define TIME_ADJUST (((1970 - 1904) * 365 + 17) * 24 * 60 * 60)
    #define ThisLocationGMTdelta ((ThisLocation.u.gmtDelta << 8) >> 8)
    GetDateTime(&SecsSince1904);
    ReadLocation(&ThisLocation);
    return((mDNSs32)(SecsSince1904 - ThisLocationGMTdelta - TIME_ADJUST));
}