mDNSShared/dnssd_clientstub.c

   1 /* -*- Mode: C; tab-width: 4 -*-
   2  *
   3  * Copyright (c) 2003-2015 Apple Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of its
  14  *     contributors may be used to endorse or promote products derived from this
  15  *     software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  26  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <errno.h>
  30 #include <stdlib.h>
  31
  32 #include "dnssd_ipc.h"
  33
  34 #if APPLE_OSX_mDNSResponder
  35 #include <mach-o/dyld.h>
  36 #include <uuid/uuid.h>
  37 #include <TargetConditionals.h>
  38 #include "dns_sd_private.h"
  39 #endif
  40
  41 #if defined(_WIN32)
  42
  43     #define _SSIZE_T
  44     #include <CommonServices.h>
  45     #include <DebugServices.h>
  46     #include <winsock2.h>
  47     #include <ws2tcpip.h>
  48     #include <windows.h>
  49     #include <stdarg.h>
  50     #include <stdio.h>
  51
  52     #define sockaddr_mdns sockaddr_in
  53     #define AF_MDNS AF_INET
  54
  55 // Disable warning: "'type cast' : from data pointer 'void *' to function pointer"
  56     #pragma warning(disable:4055)
  57
  58 // Disable warning: "nonstandard extension, function/data pointer conversion in expression"
  59     #pragma warning(disable:4152)
  60
  61 extern BOOL IsSystemServiceDisabled();
  62
  63     #define sleep(X) Sleep((X) * 1000)
  64
  65 static int g_initWinsock = 0;
  66     #define LOG_WARNING kDebugLevelWarning
  67     #define LOG_INFO kDebugLevelInfo
  68 static void syslog( int priority, const char * message, ...)
  69 {
  70     va_list args;
  71     int len;
  72     char * buffer;
  73     DWORD err = WSAGetLastError();
  74     (void) priority;
  75     va_start( args, message );
  76     len = _vscprintf( message, args ) + 1;
  77     buffer = malloc( len * sizeof(char) );
  78     if ( buffer ) { vsnprintf( buffer, len, message, args ); OutputDebugString( buffer ); free( buffer ); }
  79     WSASetLastError( err );
  80 }
  81 #else
  82
  83     #include <sys/fcntl.h>      // For O_RDWR etc.
  84     #include <sys/time.h>
  85     #include <sys/socket.h>
  86     #include <syslog.h>
  87
  88     #define sockaddr_mdns sockaddr_un
  89     #define AF_MDNS AF_LOCAL
  90
  91 #endif
  92
  93 // <rdar://problem/4096913> Specifies how many times we'll try and connect to the server.
  94
  95 #define DNSSD_CLIENT_MAXTRIES 4
  96
  97 // Uncomment the line below to use the old error return mechanism of creating a temporary named socket (e.g. in /var/tmp)
  98 //#define USE_NAMED_ERROR_RETURN_SOCKET 1
  99
 100 // If the UDS client has not received a response from the daemon in 60 secs, it is unlikely to get one
 101 // Note: Timeout of 3 secs should be sufficient in normal scenarios, but 60 secs is chosen as a safeguard since
 102 // some clients may come up before mDNSResponder itself after a BOOT and on rare ocassions IOPM/Keychain/D2D calls
 103 // in mDNSResponder's INIT may take a much longer time to return
 104 #define DNSSD_CLIENT_TIMEOUT 60
 105
 106 #ifndef CTL_PATH_PREFIX
 107 #define CTL_PATH_PREFIX "/var/tmp/dnssd_result_socket."
 108 #endif
 109
 110 typedef struct
 111 {
 112     ipc_msg_hdr ipc_hdr;
 113     DNSServiceFlags cb_flags;
 114     uint32_t cb_interface;
 115     DNSServiceErrorType cb_err;
 116 } CallbackHeader;
 117
 118 typedef struct _DNSServiceRef_t DNSServiceOp;
 119 typedef struct _DNSRecordRef_t DNSRecord;
 120
 121 #if !defined(_WIN32)
 122 typedef struct
 123 {
 124     void             *AppCallback;      // Client callback function and context
 125     void             *AppContext;
 126 } SleepKAContext;
 127 #endif
 128
 129 // client stub callback to process message from server and deliver results to client application
 130 typedef void (*ProcessReplyFn)(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *msg, const char *const end);
 131
 132 #define ValidatorBits 0x12345678
 133 #define DNSServiceRefValid(X) (dnssd_SocketValid((X)->sockfd) && (((X)->sockfd ^ (X)->validator) == ValidatorBits))
 134
 135 // When using kDNSServiceFlagsShareConnection, there is one primary _DNSServiceOp_t, and zero or more subordinates
 136 // For the primary, the 'next' field points to the first subordinate, and its 'next' field points to the next, and so on.
 137 // For the primary, the 'primary' field is NULL; for subordinates the 'primary' field points back to the associated primary
 138 //
 139 // _DNS_SD_LIBDISPATCH is defined where libdispatch/GCD is available. This does not mean that the application will use the
 140 // DNSServiceSetDispatchQueue API. Hence any new code guarded with _DNS_SD_LIBDISPATCH should still be backwards compatible.
 141 struct _DNSServiceRef_t
 142 {
 143     DNSServiceOp     *next;             // For shared connection
 144     DNSServiceOp     *primary;          // For shared connection
 145     dnssd_sock_t sockfd;                // Connected socket between client and daemon
 146     dnssd_sock_t validator;             // Used to detect memory corruption, double disposals, etc.
 147     client_context_t uid;               // For shared connection requests, each subordinate DNSServiceRef has its own ID,
 148                                         // unique within the scope of the same shared parent DNSServiceRef
 149     uint32_t op;                        // request_op_t or reply_op_t
 150     uint32_t max_index;                 // Largest assigned record index - 0 if no additional records registered
 151     uint32_t logcounter;                // Counter used to control number of syslog messages we write
 152     int              *moreptr;          // Set while DNSServiceProcessResult working on this particular DNSServiceRef
 153     ProcessReplyFn ProcessReply;        // Function pointer to the code to handle received messages
 154     void             *AppCallback;      // Client callback function and context
 155     void             *AppContext;
 156     DNSRecord        *rec;
 157 #if _DNS_SD_LIBDISPATCH
 158     dispatch_source_t disp_source;
 159     dispatch_queue_t disp_queue;
 160 #endif
 161     void             *kacontext;
 162 };
 163
 164 struct _DNSRecordRef_t
 165 {
 166     DNSRecord       *recnext;
 167     void *AppContext;
 168     DNSServiceRegisterRecordReply AppCallback;
 169     DNSRecordRef recref;
 170     uint32_t record_index;  // index is unique to the ServiceDiscoveryRef
 171     client_context_t uid;  // For demultiplexing multiple DNSServiceRegisterRecord calls
 172     DNSServiceOp *sdr;
 173 };
 174
 175 #if !defined(USE_TCP_LOOPBACK)
 176 static void SetUDSPath(struct sockaddr_un *saddr, const char *path)
 177 {
 178     size_t pathLen;
 179
 180     pathLen = strlen(path);
 181     if (pathLen < sizeof(saddr->sun_path))
 182         memcpy(saddr->sun_path, path, pathLen + 1);
 183     else
 184         saddr->sun_path[0] = '\0';
 185 }
 186 #endif
 187
 188 // Write len bytes. Return 0 on success, -1 on error
 189 static int write_all(dnssd_sock_t sd, char *buf, size_t len)
 190 {
 191     // Don't use "MSG_WAITALL"; it returns "Invalid argument" on some Linux versions; use an explicit while() loop instead.
 192     //if (send(sd, buf, len, MSG_WAITALL) != len) return -1;
 193     while (len)
 194     {
 195         ssize_t num_written = send(sd, buf, (long)len, 0);
 196         if (num_written < 0 || (size_t)num_written > len)
 197         {
 198             // Should never happen. If it does, it indicates some OS bug,
 199             // or that the mDNSResponder daemon crashed (which should never happen).
 200             #if !defined(__ppc__) && defined(SO_ISDEFUNCT)
 201             int defunct = 0;
 202             socklen_t dlen = sizeof (defunct);
 203             if (getsockopt(sd, SOL_SOCKET, SO_ISDEFUNCT, &defunct, &dlen) < 0)
 204                 syslog(LOG_WARNING, "dnssd_clientstub write_all: SO_ISDEFUNCT failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
 205             if (!defunct)
 206                 syslog(LOG_WARNING, "dnssd_clientstub write_all(%d) failed %ld/%ld %d %s", sd,
 207                        (long)num_written, (long)len,
 208                        (num_written < 0) ? dnssd_errno                 : 0,
 209                        (num_written < 0) ? dnssd_strerror(dnssd_errno) : "");
 210             else
 211                 syslog(LOG_INFO, "dnssd_clientstub write_all(%d) DEFUNCT", sd);
 212             #else
 213             syslog(LOG_WARNING, "dnssd_clientstub write_all(%d) failed %ld/%ld %d %s", sd,
 214                    (long)num_written, (long)len,
 215                    (num_written < 0) ? dnssd_errno                 : 0,
 216                    (num_written < 0) ? dnssd_strerror(dnssd_errno) : "");
 217             #endif
 218             return -1;
 219         }
 220         buf += num_written;
 221         len -= num_written;
 222     }
 223     return 0;
 224 }
 225
 226 enum { read_all_success = 0, read_all_fail = -1, read_all_wouldblock = -2 };
 227
 228 // Read len bytes. Return 0 on success, read_all_fail on error, or read_all_wouldblock for
 229 static int read_all(dnssd_sock_t sd, char *buf, int len)
 230 {
 231     // Don't use "MSG_WAITALL"; it returns "Invalid argument" on some Linux versions; use an explicit while() loop instead.
 232     //if (recv(sd, buf, len, MSG_WAITALL) != len) return -1;
 233
 234     while (len)
 235     {
 236         ssize_t num_read = recv(sd, buf, len, 0);
 237         // It is valid to get an interrupted system call error e.g., somebody attaching
 238         // in a debugger, retry without failing
 239         if ((num_read < 0) && (errno == EINTR))
 240         {
 241             syslog(LOG_INFO, "dnssd_clientstub read_all: EINTR continue");
 242             continue;
 243         }
 244         if ((num_read == 0) || (num_read < 0) || (num_read > len))
 245         {
 246             int printWarn = 0;
 247             int defunct = 0;
 248             // Should never happen. If it does, it indicates some OS bug,
 249             // or that the mDNSResponder daemon crashed (which should never happen).
 250 #if defined(WIN32)
 251             // <rdar://problem/7481776> Suppress logs for "A non-blocking socket operation
 252             //                          could not be completed immediately"
 253             if (WSAGetLastError() != WSAEWOULDBLOCK)
 254                 printWarn = 1;
 255 #endif
 256 #if !defined(__ppc__) && defined(SO_ISDEFUNCT)
 257             {
 258                 socklen_t dlen = sizeof (defunct);
 259                 if (getsockopt(sd, SOL_SOCKET, SO_ISDEFUNCT, &defunct, &dlen) < 0)
 260                     syslog(LOG_WARNING, "dnssd_clientstub read_all: SO_ISDEFUNCT failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
 261             }
 262             if (!defunct)
 263                 printWarn = 1;
 264 #endif
 265             if (printWarn)
 266                 syslog(LOG_WARNING, "dnssd_clientstub read_all(%d) failed %ld/%ld %d %s", sd,
 267                        (long)num_read, (long)len,
 268                        (num_read < 0) ? dnssd_errno                 : 0,
 269                        (num_read < 0) ? dnssd_strerror(dnssd_errno) : "");
 270             else if (defunct)
 271                 syslog(LOG_INFO, "dnssd_clientstub read_all(%d) DEFUNCT", sd);
 272             return (num_read < 0 && dnssd_errno == dnssd_EWOULDBLOCK) ? read_all_wouldblock : read_all_fail;
 273         }
 274         buf += num_read;
 275         len -= num_read;
 276     }
 277     return read_all_success;
 278 }
 279
 280 // Returns 1 if more bytes remain to be read on socket descriptor sd, 0 otherwise
 281 static int more_bytes(dnssd_sock_t sd)
 282 {
 283     struct timeval tv = { 0, 0 };
 284     fd_set readfds;
 285     fd_set *fs;
 286     int ret;
 287
 288 #if defined(_WIN32)
 289     fs = &readfds;
 290     FD_ZERO(fs);
 291     FD_SET(sd, fs);
 292     ret = select((int)sd+1, fs, (fd_set*)NULL, (fd_set*)NULL, &tv);
 293 #else
 294     if (sd < FD_SETSIZE)
 295     {
 296         fs = &readfds;
 297         FD_ZERO(fs);
 298     }
 299     else
 300     {
 301         // Compute the number of integers needed for storing "sd". Internally fd_set is stored
 302         // as an array of ints with one bit for each fd and hence we need to compute
 303         // the number of ints needed rather than the number of bytes. If "sd" is 32, we need
 304         // two ints and not just one.
 305         int nfdbits = sizeof (int) * 8;
 306         int nints = (sd/nfdbits) + 1;
 307         fs = (fd_set *)calloc(nints, (size_t)sizeof(int));
 308         if (fs == NULL)
 309         {
 310             syslog(LOG_WARNING, "dnssd_clientstub more_bytes: malloc failed");
 311             return 0;
 312         }
 313     }
 314     FD_SET(sd, fs);
 315     ret = select((int)sd+1, fs, (fd_set*)NULL, (fd_set*)NULL, &tv);
 316     if (fs != &readfds)
 317         free(fs);
 318 #endif
 319     return (ret > 0);
 320 }
 321
 322 // set_waitlimit() implements a timeout using select. It is called from deliver_request() before recv() OR accept()
 323 // to ensure the UDS clients are not blocked in these system calls indefinitely.
 324 // Note: Ideally one should never be blocked here, because it indicates either mDNSResponder daemon is not yet up/hung/
 325 // superbusy/crashed or some other OS bug. For eg: On Windows which suffers from 3rd party software
 326 // (primarily 3rd party firewall software) interfering with proper functioning of the TCP protocol stack it is possible
 327 // the next operation on this socket(recv/accept) is blocked since we depend on TCP to communicate with the system service.
 328 static int set_waitlimit(dnssd_sock_t sock, int timeout)
 329 {
 330     int gDaemonErr = kDNSServiceErr_NoError;
 331
 332     // To prevent stack corruption since select does not work with timeout if fds > FD_SETSIZE(1024)
 333     if (!gDaemonErr && sock < FD_SETSIZE)
 334     {
 335         struct timeval tv;
 336         fd_set set;
 337
 338         FD_ZERO(&set);
 339         FD_SET(sock, &set);
 340         tv.tv_sec = timeout;
 341         tv.tv_usec = 0;
 342         if (!select((int)(sock + 1), &set, NULL, NULL, &tv))
 343         {
 344             // Ideally one should never hit this case: See comments before set_waitlimit()
 345             syslog(LOG_WARNING, "dnssd_clientstub set_waitlimit:_daemon timed out (%d secs) without any response: Socket %d", timeout, sock);
 346             gDaemonErr = kDNSServiceErr_Timeout;
 347         }
 348     }
 349     return gDaemonErr;
 350 }
 351
 352 /* create_hdr
 353  *
 354  * allocate and initialize an ipc message header. Value of len should initially be the
 355  * length of the data, and is set to the value of the data plus the header. data_start
 356  * is set to point to the beginning of the data section. SeparateReturnSocket should be
 357  * non-zero for calls that can't receive an immediate error return value on their primary
 358  * socket, and therefore require a separate return path for the error code result.
 359  * if zero, the path to a control socket is appended at the beginning of the message buffer.
 360  * data_start is set past this string.
 361  */
 362 static ipc_msg_hdr *create_hdr(uint32_t op, size_t *len, char **data_start, int SeparateReturnSocket, DNSServiceOp *ref)
 363 {
 364     char *msg = NULL;
 365     ipc_msg_hdr *hdr;
 366     int datalen;
 367 #if !defined(USE_TCP_LOOPBACK)
 368     char ctrl_path[64] = "";    // "/var/tmp/dnssd_result_socket.xxxxxxxxxx-xxx-xxxxxx"
 369 #endif
 370
 371     if (SeparateReturnSocket)
 372     {
 373 #if defined(USE_TCP_LOOPBACK)
 374         *len += 2;  // Allocate space for two-byte port number
 375 #elif defined(USE_NAMED_ERROR_RETURN_SOCKET)
 376         struct timeval tv;
 377         if (gettimeofday(&tv, NULL) < 0)
 378         { syslog(LOG_WARNING, "dnssd_clientstub create_hdr: gettimeofday failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno)); return NULL; }
 379         snprintf(ctrl_path, sizeof(ctrl_path), "%s%d-%.3lx-%.6lu", CTL_PATH_PREFIX, (int)getpid(),
 380                 (unsigned long)(tv.tv_sec & 0xFFF), (unsigned long)(tv.tv_usec));
 381         *len += strlen(ctrl_path) + 1;
 382 #else
 383         *len += 1;      // Allocate space for single zero byte (empty C string)
 384 #endif
 385     }
 386
 387     datalen = (int) *len;
 388     *len += sizeof(ipc_msg_hdr);
 389
 390     // Write message to buffer
 391     msg = malloc(*len);
 392     if (!msg) { syslog(LOG_WARNING, "dnssd_clientstub create_hdr: malloc failed"); return NULL; }
 393
 394     memset(msg, 0, *len);
 395     hdr = (ipc_msg_hdr *)msg;
 396     hdr->version                = VERSION;
 397     hdr->datalen                = datalen;
 398     hdr->ipc_flags              = 0;
 399     hdr->op                     = op;
 400     hdr->client_context         = ref->uid;
 401     hdr->reg_index              = 0;
 402     *data_start = msg + sizeof(ipc_msg_hdr);
 403 #if defined(USE_TCP_LOOPBACK)
 404     // Put dummy data in for the port, since we don't know what it is yet.
 405     // The data will get filled in before we send the message. This happens in deliver_request().
 406     if (SeparateReturnSocket) put_uint16(0, data_start);
 407 #else
 408     if (SeparateReturnSocket) put_string(ctrl_path, data_start);
 409 #endif
 410     return hdr;
 411 }
 412
 413 static void FreeDNSRecords(DNSServiceOp *sdRef)
 414 {
 415     DNSRecord *rec = sdRef->rec;
 416     while (rec)
 417     {
 418         DNSRecord *next = rec->recnext;
 419         free(rec);
 420         rec = next;
 421     }
 422 }
 423
 424 static void FreeDNSServiceOp(DNSServiceOp *x)
 425 {
 426     // We don't use our DNSServiceRefValid macro here because if we're cleaning up after a socket() call failed
 427     // then sockfd could legitimately contain a failing value (e.g. dnssd_InvalidSocket)
 428     if ((x->sockfd ^ x->validator) != ValidatorBits)
 429     {
 430         static DNSServiceOp *op_were_not_going_to_free_but_we_need_to_fool_the_analyzer;
 431         syslog(LOG_WARNING, "dnssd_clientstub attempt to dispose invalid DNSServiceRef %p %08X %08X", x, x->sockfd, x->validator);
 432         op_were_not_going_to_free_but_we_need_to_fool_the_analyzer = x;
 433     }
 434     else
 435     {
 436         x->next         = NULL;
 437         x->primary      = NULL;
 438         x->sockfd       = dnssd_InvalidSocket;
 439         x->validator    = 0xDDDDDDDD;
 440         x->op           = request_op_none;
 441         x->max_index    = 0;
 442         x->logcounter   = 0;
 443         x->moreptr      = NULL;
 444         x->ProcessReply = NULL;
 445         x->AppCallback  = NULL;
 446         x->AppContext   = NULL;
 447 #if _DNS_SD_LIBDISPATCH
 448         if (x->disp_source) dispatch_release(x->disp_source);
 449         x->disp_source  = NULL;
 450         x->disp_queue   = NULL;
 451 #endif
 452         // DNSRecords may have been added to subordinate sdRef e.g., DNSServiceRegister/DNSServiceAddRecord
 453         // or on the main sdRef e.g., DNSServiceCreateConnection/DNSServiveRegisterRecord. DNSRecords may have
 454         // been freed if the application called DNSRemoveRecord
 455         FreeDNSRecords(x);
 456         if (x->kacontext)
 457         {
 458             free(x->kacontext);
 459             x->kacontext = NULL;
 460         }
 461         free(x);
 462     }
 463 }
 464
 465 // Return a connected service ref (deallocate with DNSServiceRefDeallocate)
 466 static DNSServiceErrorType ConnectToServer(DNSServiceRef *ref, DNSServiceFlags flags, uint32_t op, ProcessReplyFn ProcessReply, void *AppCallback, void *AppContext)
 467 {
 468     int NumTries = 0;
 469
 470     dnssd_sockaddr_t saddr;
 471     DNSServiceOp *sdr;
 472
 473     if (!ref)
 474     {
 475         syslog(LOG_WARNING, "dnssd_clientstub DNSService operation with NULL DNSServiceRef");
 476         return kDNSServiceErr_BadParam;
 477     }
 478
 479     if (flags & kDNSServiceFlagsShareConnection)
 480     {
 481         if (!*ref)
 482         {
 483             syslog(LOG_WARNING, "dnssd_clientstub kDNSServiceFlagsShareConnection used with NULL DNSServiceRef");
 484             return kDNSServiceErr_BadParam;
 485         }
 486         if (!DNSServiceRefValid(*ref) || ((*ref)->op != connection_request && (*ref)->op != connection_delegate_request) || (*ref)->primary)
 487         {
 488             syslog(LOG_WARNING, "dnssd_clientstub kDNSServiceFlagsShareConnection used with invalid DNSServiceRef %p %08X %08X op %d",
 489                    (*ref), (*ref)->sockfd, (*ref)->validator, (*ref)->op);
 490             *ref = NULL;
 491             return kDNSServiceErr_BadReference;
 492         }
 493     }
 494
 495     #if defined(_WIN32)
 496     if (!g_initWinsock)
 497     {
 498         WSADATA wsaData;
 499         g_initWinsock = 1;
 500         if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) { *ref = NULL; return kDNSServiceErr_ServiceNotRunning; }
 501     }
 502     // <rdar://problem/4096913> If the system service is disabled, we only want to try to connect once
 503     if (IsSystemServiceDisabled())
 504         NumTries = DNSSD_CLIENT_MAXTRIES;
 505     #endif
 506
 507     sdr = malloc(sizeof(DNSServiceOp));
 508     if (!sdr)
 509     {
 510         syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: malloc failed");
 511         *ref = NULL;
 512         return kDNSServiceErr_NoMemory;
 513     }
 514     sdr->next          = NULL;
 515     sdr->primary       = NULL;
 516     sdr->sockfd        = dnssd_InvalidSocket;
 517     sdr->validator     = sdr->sockfd ^ ValidatorBits;
 518     sdr->op            = op;
 519     sdr->max_index     = 0;
 520     sdr->logcounter    = 0;
 521     sdr->moreptr       = NULL;
 522     sdr->uid.u32[0]    = 0;
 523     sdr->uid.u32[1]    = 0;
 524     sdr->ProcessReply  = ProcessReply;
 525     sdr->AppCallback   = AppCallback;
 526     sdr->AppContext    = AppContext;
 527     sdr->rec           = NULL;
 528 #if _DNS_SD_LIBDISPATCH
 529     sdr->disp_source   = NULL;
 530     sdr->disp_queue    = NULL;
 531 #endif
 532     sdr->kacontext     = NULL;
 533
 534     if (flags & kDNSServiceFlagsShareConnection)
 535     {
 536         DNSServiceOp **p = &(*ref)->next;       // Append ourselves to end of primary's list
 537         while (*p)
 538             p = &(*p)->next;
 539         *p = sdr;
 540         // Preincrement counter before we use it -- it helps with debugging if we know the all-zeroes ID should never appear
 541         if (++(*ref)->uid.u32[0] == 0)
 542             ++(*ref)->uid.u32[1];               // In parent DNSServiceOp increment UID counter
 543         sdr->primary    = *ref;                 // Set our primary pointer
 544         sdr->sockfd     = (*ref)->sockfd;       // Inherit primary's socket
 545         sdr->validator  = (*ref)->validator;
 546         sdr->uid        = (*ref)->uid;
 547         //printf("ConnectToServer sharing socket %d\n", sdr->sockfd);
 548     }
 549     else
 550     {
 551         #ifdef SO_NOSIGPIPE
 552         const unsigned long optval = 1;
 553         #endif
 554         #ifndef USE_TCP_LOOPBACK
 555         char* uds_serverpath = getenv(MDNS_UDS_SERVERPATH_ENVVAR);
 556         if (uds_serverpath == NULL)
 557             uds_serverpath = MDNS_UDS_SERVERPATH;
 558         else if (strlen(uds_serverpath) >= MAX_CTLPATH)
 559         {
 560             uds_serverpath = MDNS_UDS_SERVERPATH;
 561             syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: using default path since env len is invalid");
 562         }
 563         #endif
 564         *ref = NULL;
 565         sdr->sockfd    = socket(AF_DNSSD, SOCK_STREAM, 0);
 566         sdr->validator = sdr->sockfd ^ ValidatorBits;
 567         if (!dnssd_SocketValid(sdr->sockfd))
 568         {
 569             syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: socket failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
 570             FreeDNSServiceOp(sdr);
 571             return kDNSServiceErr_NoMemory;
 572         }
 573         #ifdef SO_NOSIGPIPE
 574         // Some environments (e.g. OS X) support turning off SIGPIPE for a socket
 575         if (setsockopt(sdr->sockfd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)) < 0)
 576             syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: SO_NOSIGPIPE failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
 577         #endif
 578         #if defined(USE_TCP_LOOPBACK)
 579         saddr.sin_family      = AF_INET;
 580         saddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
 581         saddr.sin_port        = htons(MDNS_TCP_SERVERPORT);
 582         #else
 583         saddr.sun_family      = AF_LOCAL;
 584         SetUDSPath(&saddr, uds_serverpath);
 585         #if !defined(__ppc__) && defined(SO_DEFUNCTOK)
 586         {
 587             int defunct = 1;
 588             if (setsockopt(sdr->sockfd, SOL_SOCKET, SO_DEFUNCTOK, &defunct, sizeof(defunct)) < 0)
 589                 syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: SO_DEFUNCTOK failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
 590         }
 591         #endif
 592         #endif
 593
 594         while (1)
 595         {
 596             int err = connect(sdr->sockfd, (struct sockaddr *) &saddr, sizeof(saddr));
 597             if (!err)
 598                 break; // If we succeeded, return sdr
 599             // If we failed, then it may be because the daemon is still launching.
 600             // This can happen for processes that launch early in the boot process, while the
 601             // daemon is still coming up. Rather than fail here, we wait 1 sec and try again.
 602             // If, after DNSSD_CLIENT_MAXTRIES, we still can't connect to the daemon,
 603             // then we give up and return a failure code.
 604             if (++NumTries < DNSSD_CLIENT_MAXTRIES)
 605             {
 606                 syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: connect()-> No of tries: %d", NumTries);
 607                 sleep(1); // Sleep a bit, then try again
 608             }
 609             else
 610             {
 611                 #if !defined(USE_TCP_LOOPBACK)
 612                 syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: connect() failed path:%s Socket:%d Err:%d Errno:%d %s",
 613                        uds_serverpath, sdr->sockfd, err, dnssd_errno, dnssd_strerror(dnssd_errno));
 614                 #endif
 615                 dnssd_close(sdr->sockfd);
 616                 FreeDNSServiceOp(sdr);
 617                 return kDNSServiceErr_ServiceNotRunning;
 618             }
 619         }
 620         //printf("ConnectToServer opened socket %d\n", sdr->sockfd);
 621     }
 622
 623     *ref = sdr;
 624     return kDNSServiceErr_NoError;
 625 }
 626
 627 #define deliver_request_bailout(MSG) \
 628     do { syslog(LOG_WARNING, "dnssd_clientstub deliver_request: %s failed %d (%s)", (MSG), dnssd_errno, dnssd_strerror(dnssd_errno)); goto cleanup; } while(0)
 629
 630 static DNSServiceErrorType deliver_request(ipc_msg_hdr *hdr, DNSServiceOp *sdr)
 631 {
 632     if (!hdr)
 633     {
 634         syslog(LOG_WARNING, "dnssd_clientstub deliver_request: !hdr");
 635         return kDNSServiceErr_Unknown;
 636     }
 637
 638     uint32_t datalen = hdr->datalen;    // We take a copy here because we're going to convert hdr->datalen to network byte order
 639     #if defined(USE_TCP_LOOPBACK) || defined(USE_NAMED_ERROR_RETURN_SOCKET)
 640     char *const data = (char *)hdr + sizeof(ipc_msg_hdr);
 641     #endif
 642     dnssd_sock_t listenfd = dnssd_InvalidSocket, errsd = dnssd_InvalidSocket;
 643     DNSServiceErrorType err = kDNSServiceErr_Unknown;   // Default for the "goto cleanup" cases
 644
 645     // Note: need to check hdr->op, not sdr->op.
 646     // hdr->op contains the code for the specific operation we're currently doing, whereas sdr->op
 647     // contains the original parent DNSServiceOp (e.g. for an add_record_request, hdr->op will be
 648     // add_record_request but the parent sdr->op will be connection_request or reg_service_request)
 649     const int MakeSeparateReturnSocket = (sdr->primary ||
 650         hdr->op == reg_record_request || hdr->op == add_record_request || hdr->op == update_record_request || hdr->op == remove_record_request);
 651
 652     if (!DNSServiceRefValid(sdr))
 653     {
 654         if (hdr)
 655             free(hdr);
 656         syslog(LOG_WARNING, "dnssd_clientstub deliver_request: invalid DNSServiceRef %p %08X %08X", sdr, sdr->sockfd, sdr->validator);
 657         return kDNSServiceErr_BadReference;
 658     }
 659
 660     if (MakeSeparateReturnSocket)
 661     {
 662         #if defined(USE_TCP_LOOPBACK)
 663         {
 664             union { uint16_t s; u_char b[2]; } port;
 665             dnssd_sockaddr_t caddr;
 666             dnssd_socklen_t len = (dnssd_socklen_t) sizeof(caddr);
 667             listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
 668             if (!dnssd_SocketValid(listenfd)) deliver_request_bailout("TCP socket");
 669
 670             caddr.sin_family      = AF_INET;
 671             caddr.sin_port        = 0;
 672             caddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
 673             if (bind(listenfd, (struct sockaddr*) &caddr, sizeof(caddr)) < 0) deliver_request_bailout("TCP bind");
 674             if (getsockname(listenfd, (struct sockaddr*) &caddr, &len)   < 0) deliver_request_bailout("TCP getsockname");
 675             if (listen(listenfd, 1)                                      < 0) deliver_request_bailout("TCP listen");
 676             port.s = caddr.sin_port;
 677             data[0] = port.b[0];  // don't switch the byte order, as the
 678             data[1] = port.b[1];  // daemon expects it in network byte order
 679         }
 680         #elif defined(USE_NAMED_ERROR_RETURN_SOCKET)
 681         {
 682             mode_t mask;
 683             int bindresult;
 684             dnssd_sockaddr_t caddr;
 685             listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
 686             if (!dnssd_SocketValid(listenfd)) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET socket");
 687
 688             caddr.sun_family = AF_LOCAL;
 689             // According to Stevens (section 3.2), there is no portable way to
 690             // determine whether sa_len is defined on a particular platform.
 691             #ifndef NOT_HAVE_SA_LEN
 692             caddr.sun_len = sizeof(struct sockaddr_un);
 693             #endif
 694             SetUDSPath(&caddr, data);
 695             mask = umask(0);
 696             bindresult = bind(listenfd, (struct sockaddr *)&caddr, sizeof(caddr));
 697             umask(mask);
 698             if (bindresult          < 0) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET bind");
 699             if (listen(listenfd, 1) < 0) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET listen");
 700         }
 701         #else
 702         {
 703             dnssd_sock_t sp[2];
 704             if (socketpair(AF_DNSSD, SOCK_STREAM, 0, sp) < 0) deliver_request_bailout("socketpair");
 705             else
 706             {
 707                 errsd    = sp[0];   // We'll read our four-byte error code from sp[0]
 708                 listenfd = sp[1];   // We'll send sp[1] to the daemon
 709                 #if !defined(__ppc__) && defined(SO_DEFUNCTOK)
 710                 {
 711                     int defunct = 1;
 712                     if (setsockopt(errsd, SOL_SOCKET, SO_DEFUNCTOK, &defunct, sizeof(defunct)) < 0)
 713                         syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: SO_DEFUNCTOK failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
 714                 }
 715                 #endif
 716             }
 717         }
 718         #endif
 719     }
 720
 721 #if !defined(USE_TCP_LOOPBACK) && !defined(USE_NAMED_ERROR_RETURN_SOCKET)
 722     // If we're going to make a separate error return socket, and pass it to the daemon
 723     // using sendmsg, then we'll hold back one data byte to go with it.
 724     // On some versions of Unix (including Leopard) sending a control message without
 725     // any associated data does not work reliably -- e.g. one particular issue we ran
 726     // into is that if the receiving program is in a kqueue loop waiting to be notified
 727     // of the received message, it doesn't get woken up when the control message arrives.
 728     if (MakeSeparateReturnSocket || sdr->op == send_bpf)
 729         datalen--;     // Okay to use sdr->op when checking for op == send_bpf
 730 #endif
 731
 732     // At this point, our listening socket is set up and waiting, if necessary, for the daemon to connect back to
 733     ConvertHeaderBytes(hdr);
 734     //syslog(LOG_WARNING, "dnssd_clientstub deliver_request writing %lu bytes", (unsigned long)(datalen + sizeof(ipc_msg_hdr)));
 735     //if (MakeSeparateReturnSocket) syslog(LOG_WARNING, "dnssd_clientstub deliver_request name is %s", data);
 736 #if TEST_SENDING_ONE_BYTE_AT_A_TIME
 737     unsigned int i;
 738     for (i=0; i<datalen + sizeof(ipc_msg_hdr); i++)
 739     {
 740         syslog(LOG_WARNING, "dnssd_clientstub deliver_request writing %d", i);
 741         if (write_all(sdr->sockfd, ((char *)hdr)+i, 1) < 0)
 742         { syslog(LOG_WARNING, "write_all (byte %u) failed", i); goto cleanup; }
 743         usleep(10000);
 744     }
 745 #else
 746     if (write_all(sdr->sockfd, (char *)hdr, datalen + sizeof(ipc_msg_hdr)) < 0)
 747     {
 748         // write_all already prints an error message if there is an error writing to
 749         // the socket except for DEFUNCT. Logging here is unnecessary and also wrong
 750         // in the case of DEFUNCT sockets
 751         syslog(LOG_INFO, "dnssd_clientstub deliver_request ERROR: write_all(%d, %lu bytes) failed",
 752                sdr->sockfd, (unsigned long)(datalen + sizeof(ipc_msg_hdr)));
 753         goto cleanup;
 754     }
 755 #endif
 756
 757     if (!MakeSeparateReturnSocket)
 758         errsd = sdr->sockfd;
 759     if (MakeSeparateReturnSocket || sdr->op == send_bpf)    // Okay to use sdr->op when checking for op == send_bpf
 760     {
 761 #if defined(USE_TCP_LOOPBACK) || defined(USE_NAMED_ERROR_RETURN_SOCKET)
 762         // At this point we may wait in accept for a few milliseconds waiting for the daemon to connect back to us,
 763         // but that's okay -- the daemon should not take more than a few milliseconds to respond.
 764         // set_waitlimit() ensures we do not block indefinitely just in case something is wrong
 765         dnssd_sockaddr_t daddr;
 766         dnssd_socklen_t len = sizeof(daddr);
 767         if ((err = set_waitlimit(listenfd, DNSSD_CLIENT_TIMEOUT)) != kDNSServiceErr_NoError)
 768             goto cleanup;
 769         errsd = accept(listenfd, (struct sockaddr *)&daddr, &len);
 770         if (!dnssd_SocketValid(errsd))
 771             deliver_request_bailout("accept");
 772 #else
 773
 774         struct iovec vec = { ((char *)hdr) + sizeof(ipc_msg_hdr) + datalen, 1 }; // Send the last byte along with the SCM_RIGHTS
 775         struct msghdr msg;
 776         struct cmsghdr *cmsg;
 777         char cbuf[CMSG_SPACE(4 * sizeof(dnssd_sock_t))];
 778
 779         msg.msg_name       = 0;
 780         msg.msg_namelen    = 0;
 781         msg.msg_iov        = &vec;
 782         msg.msg_iovlen     = 1;
 783         msg.msg_flags      = 0;
 784         if (MakeSeparateReturnSocket || sdr->op == send_bpf)    // Okay to use sdr->op when checking for op == send_bpf
 785         {
 786             if (sdr->op == send_bpf)
 787             {
 788                 int i;
 789                 char p[12];     // Room for "/dev/bpf999" with terminating null
 790                 for (i=0; i<100; i++)
 791                 {
 792                     snprintf(p, sizeof(p), "/dev/bpf%d", i);
 793                     listenfd = open(p, O_RDWR, 0);
 794                     //if (dnssd_SocketValid(listenfd)) syslog(LOG_WARNING, "Sending fd %d for %s", listenfd, p);
 795                     if (!dnssd_SocketValid(listenfd) && dnssd_errno != EBUSY)
 796                         syslog(LOG_WARNING, "Error opening %s %d (%s)", p, dnssd_errno, dnssd_strerror(dnssd_errno));
 797                     if (dnssd_SocketValid(listenfd) || dnssd_errno != EBUSY) break;
 798                 }
 799             }
 800             msg.msg_control    = cbuf;
 801             msg.msg_controllen = CMSG_LEN(sizeof(dnssd_sock_t));
 802
 803             cmsg = CMSG_FIRSTHDR(&msg);
 804             cmsg->cmsg_len     = CMSG_LEN(sizeof(dnssd_sock_t));
 805             cmsg->cmsg_level   = SOL_SOCKET;
 806             cmsg->cmsg_type    = SCM_RIGHTS;
 807             *((dnssd_sock_t *)CMSG_DATA(cmsg)) = listenfd;
 808         }
 809
 810 #if TEST_KQUEUE_CONTROL_MESSAGE_BUG
 811         sleep(1);
 812 #endif
 813
 814 #if DEBUG_64BIT_SCM_RIGHTS
 815         syslog(LOG_WARNING, "dnssd_clientstub sendmsg read sd=%d write sd=%d %ld %ld %ld/%ld/%ld/%ld",
 816                errsd, listenfd, sizeof(dnssd_sock_t), sizeof(void*),
 817                sizeof(struct cmsghdr) + sizeof(dnssd_sock_t),
 818                CMSG_LEN(sizeof(dnssd_sock_t)), (long)CMSG_SPACE(sizeof(dnssd_sock_t)),
 819                (long)((char*)CMSG_DATA(cmsg) + 4 - cbuf));
 820 #endif // DEBUG_64BIT_SCM_RIGHTS
 821
 822         if (sendmsg(sdr->sockfd, &msg, 0) < 0)
 823         {
 824             syslog(LOG_WARNING, "dnssd_clientstub deliver_request ERROR: sendmsg failed read sd=%d write sd=%d errno %d (%s)",
 825                    errsd, listenfd, dnssd_errno, dnssd_strerror(dnssd_errno));
 826             err = kDNSServiceErr_Incompatible;
 827             goto cleanup;
 828         }
 829
 830 #if DEBUG_64BIT_SCM_RIGHTS
 831         syslog(LOG_WARNING, "dnssd_clientstub sendmsg read sd=%d write sd=%d okay", errsd, listenfd);
 832 #endif // DEBUG_64BIT_SCM_RIGHTS
 833
 834 #endif
 835         // Close our end of the socketpair *before* calling read_all() to get the four-byte error code.
 836         // Otherwise, if the daemon closes our socket (or crashes), we will have to wait for a timeout
 837         // in read_all() because the socket is not closed (we still have an open reference to it)
 838         // Note: listenfd is overwritten in the case of send_bpf above and that will be closed here
 839         // for send_bpf operation.
 840         dnssd_close(listenfd);
 841         listenfd = dnssd_InvalidSocket; // Make sure we don't close it a second time in the cleanup handling below
 842     }
 843
 844     // At this point we may wait in read_all for a few milliseconds waiting for the daemon to send us the error code,
 845     // but that's okay -- the daemon should not take more than a few milliseconds to respond.
 846     // set_waitlimit() ensures we do not block indefinitely just in case something is wrong
 847     if (sdr->op == send_bpf)    // Okay to use sdr->op when checking for op == send_bpf
 848         err = kDNSServiceErr_NoError;
 849     else if ((err = set_waitlimit(errsd, DNSSD_CLIENT_TIMEOUT)) == kDNSServiceErr_NoError)
 850     {
 851         if (read_all(errsd, (char*)&err, (int)sizeof(err)) < 0)
 852             err = kDNSServiceErr_ServiceNotRunning; // On failure read_all will have written a message to syslog for us
 853         else
 854             err = ntohl(err);
 855     }
 856     //syslog(LOG_WARNING, "dnssd_clientstub deliver_request: retrieved error code %d", err);
 857
 858 cleanup:
 859     if (MakeSeparateReturnSocket)
 860     {
 861         if (dnssd_SocketValid(listenfd)) dnssd_close(listenfd);
 862         if (dnssd_SocketValid(errsd)) dnssd_close(errsd);
 863 #if defined(USE_NAMED_ERROR_RETURN_SOCKET)
 864         // syslog(LOG_WARNING, "dnssd_clientstub deliver_request: removing UDS: %s", data);
 865         if (unlink(data) != 0)
 866             syslog(LOG_WARNING, "dnssd_clientstub WARNING: unlink(\"%s\") failed errno %d (%s)", data, dnssd_errno, dnssd_strerror(dnssd_errno));
 867         // else syslog(LOG_WARNING, "dnssd_clientstub deliver_request: removed UDS: %s", data);
 868 #endif
 869     }
 870
 871     free(hdr);
 872     return err;
 873 }
 874
 875 dnssd_sock_t DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdRef)
 876 {
 877     if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD called with NULL DNSServiceRef"); return dnssd_InvalidSocket; }
 878
 879     if (!DNSServiceRefValid(sdRef))
 880     {
 881         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD called with invalid DNSServiceRef %p %08X %08X",
 882                sdRef, sdRef->sockfd, sdRef->validator);
 883         return dnssd_InvalidSocket;
 884     }
 885
 886     if (sdRef->primary)
 887     {
 888         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD undefined for kDNSServiceFlagsShareConnection subordinate DNSServiceRef %p", sdRef);
 889         return dnssd_InvalidSocket;
 890     }
 891
 892     return sdRef->sockfd;
 893 }
 894
 895 #if _DNS_SD_LIBDISPATCH
 896 static void CallbackWithError(DNSServiceRef sdRef, DNSServiceErrorType error)
 897 {
 898     DNSServiceOp *sdr = sdRef;
 899     DNSServiceOp *sdrNext;
 900     DNSRecord *rec;
 901     DNSRecord *recnext;
 902     int morebytes;
 903
 904     while (sdr)
 905     {
 906         // We can't touch the sdr after the callback as it can be deallocated in the callback
 907         sdrNext = sdr->next;
 908         morebytes = 1;
 909         sdr->moreptr = &morebytes;
 910         switch (sdr->op)
 911         {
 912         case resolve_request:
 913             if (sdr->AppCallback) ((DNSServiceResolveReply)    sdr->AppCallback)(sdr, 0, 0, error, NULL, 0, 0, 0, NULL,    sdr->AppContext);
 914             break;
 915         case query_request:
 916             if (sdr->AppCallback) ((DNSServiceQueryRecordReply)sdr->AppCallback)(sdr, 0, 0, error, NULL, 0, 0, 0, NULL, 0, sdr->AppContext);
 917             break;
 918         case addrinfo_request:
 919             if (sdr->AppCallback) ((DNSServiceGetAddrInfoReply)sdr->AppCallback)(sdr, 0, 0, error, NULL, NULL, 0,          sdr->AppContext);
 920             break;
 921         case browse_request:
 922             if (sdr->AppCallback) ((DNSServiceBrowseReply)     sdr->AppCallback)(sdr, 0, 0, error, NULL, 0, NULL,          sdr->AppContext);
 923             break;
 924         case reg_service_request:
 925             if (sdr->AppCallback) ((DNSServiceRegisterReply)   sdr->AppCallback)(sdr, 0,    error, NULL, 0, NULL,          sdr->AppContext);
 926             break;
 927         case enumeration_request:
 928             if (sdr->AppCallback) ((DNSServiceDomainEnumReply) sdr->AppCallback)(sdr, 0, 0, error, NULL,                   sdr->AppContext);
 929             break;
 930         case connection_request:
 931         case connection_delegate_request:
 932             // This means Register Record, walk the list of DNSRecords to do the callback
 933             rec = sdr->rec;
 934             while (rec)
 935             {
 936                 recnext = rec->recnext;
 937                 if (rec->AppCallback) ((DNSServiceRegisterRecordReply)rec->AppCallback)(sdr, 0, 0, error, rec->AppContext);
 938                 // The Callback can call DNSServiceRefDeallocate which in turn frees sdr and all the records.
 939                 // Detect that and return early
 940                 if (!morebytes) {syslog(LOG_WARNING, "dnssdclientstub:Record: CallbackwithError morebytes zero"); return;}
 941                 rec = recnext;
 942             }
 943             break;
 944         case port_mapping_request:
 945             if (sdr->AppCallback) ((DNSServiceNATPortMappingReply)sdr->AppCallback)(sdr, 0, 0, error, 0, 0, 0, 0, 0, sdr->AppContext);
 946             break;
 947         default:
 948             syslog(LOG_WARNING, "dnssd_clientstub CallbackWithError called with bad op %d", sdr->op);
 949         }
 950         // If DNSServiceRefDeallocate was called in the callback, morebytes will be zero. As the sdRef
 951         // (and its subordinates) have been freed, we should not proceed further. Note that when we
 952         // call the callback with a subordinate sdRef the application can call DNSServiceRefDeallocate
 953         // on the main sdRef and DNSServiceRefDeallocate handles this case by walking all the sdRefs and
 954         // clears the moreptr so that we can terminate here.
 955         //
 956         // If DNSServiceRefDeallocate was not called in the callback, then set moreptr to NULL so that
 957         // we don't access the stack variable after we return from this function.
 958         if (!morebytes) {syslog(LOG_WARNING, "dnssdclientstub:sdRef: CallbackwithError morebytes zero sdr %p", sdr); return;}
 959         else {sdr->moreptr = NULL;}
 960         sdr = sdrNext;
 961     }
 962 }
 963 #endif // _DNS_SD_LIBDISPATCH
 964
 965 // Handle reply from server, calling application client callback. If there is no reply
 966 // from the daemon on the socket contained in sdRef, the call will block.
 967 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdRef)
 968 {
 969     int morebytes = 0;
 970
 971     if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
 972
 973     if (!DNSServiceRefValid(sdRef))
 974     {
 975         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
 976         return kDNSServiceErr_BadReference;
 977     }
 978
 979     if (sdRef->primary)
 980     {
 981         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult undefined for kDNSServiceFlagsShareConnection subordinate DNSServiceRef %p", sdRef);
 982         return kDNSServiceErr_BadReference;
 983     }
 984
 985     if (!sdRef->ProcessReply)
 986     {
 987         static int num_logs = 0;
 988         if (num_logs < 10) syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with DNSServiceRef with no ProcessReply function");
 989         if (num_logs < 1000) num_logs++;else sleep(1);
 990         return kDNSServiceErr_BadReference;
 991     }
 992
 993     do
 994     {
 995         CallbackHeader cbh;
 996         char *data;
 997
 998         // return NoError on EWOULDBLOCK. This will handle the case
 999         // where a non-blocking socket is told there is data, but it was a false positive.
1000         // On error, read_all will write a message to syslog for us, so don't need to duplicate that here
1001         // Note: If we want to properly support using non-blocking sockets in the future
1002         int result = read_all(sdRef->sockfd, (void *)&cbh.ipc_hdr, sizeof(cbh.ipc_hdr));
1003         if (result == read_all_fail)
1004         {
1005             // Set the ProcessReply to NULL before callback as the sdRef can get deallocated
1006             // in the callback.
1007             sdRef->ProcessReply = NULL;
1008 #if _DNS_SD_LIBDISPATCH
1009             // Call the callbacks with an error if using the dispatch API, as DNSServiceProcessResult
1010             // is not called by the application and hence need to communicate the error. Cancel the
1011             // source so that we don't get any more events
1012             // Note: read_all fails if we could not read from the daemon which can happen if the
1013             // daemon dies or the file descriptor is disconnected (defunct).
1014             if (sdRef->disp_source)
1015             {
1016                 dispatch_source_cancel(sdRef->disp_source);
1017                 dispatch_release(sdRef->disp_source);
1018                 sdRef->disp_source = NULL;
1019                 CallbackWithError(sdRef, kDNSServiceErr_ServiceNotRunning);
1020             }
1021 #endif
1022             // Don't touch sdRef anymore as it might have been deallocated
1023             return kDNSServiceErr_ServiceNotRunning;
1024         }
1025         else if (result == read_all_wouldblock)
1026         {
1027             if (morebytes && sdRef->logcounter < 100)
1028             {
1029                 sdRef->logcounter++;
1030                 syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult error: select indicated data was waiting but read_all returned EWOULDBLOCK");
1031             }
1032             return kDNSServiceErr_NoError;
1033         }
1034
1035         ConvertHeaderBytes(&cbh.ipc_hdr);
1036         if (cbh.ipc_hdr.version != VERSION)
1037         {
1038             syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult daemon version %d does not match client version %d", cbh.ipc_hdr.version, VERSION);
1039             sdRef->ProcessReply = NULL;
1040             return kDNSServiceErr_Incompatible;
1041         }
1042
1043         data = malloc(cbh.ipc_hdr.datalen);
1044         if (!data) return kDNSServiceErr_NoMemory;
1045         if (read_all(sdRef->sockfd, data, cbh.ipc_hdr.datalen) < 0) // On error, read_all will write a message to syslog for us
1046         {
1047             // Set the ProcessReply to NULL before callback as the sdRef can get deallocated
1048             // in the callback.
1049             sdRef->ProcessReply = NULL;
1050 #if _DNS_SD_LIBDISPATCH
1051             // Call the callbacks with an error if using the dispatch API, as DNSServiceProcessResult
1052             // is not called by the application and hence need to communicate the error. Cancel the
1053             // source so that we don't get any more events
1054             if (sdRef->disp_source)
1055             {
1056                 dispatch_source_cancel(sdRef->disp_source);
1057                 dispatch_release(sdRef->disp_source);
1058                 sdRef->disp_source = NULL;
1059                 CallbackWithError(sdRef, kDNSServiceErr_ServiceNotRunning);
1060             }
1061 #endif
1062             // Don't touch sdRef anymore as it might have been deallocated
1063             free(data);
1064             return kDNSServiceErr_ServiceNotRunning;
1065         }
1066         else
1067         {
1068             const char *ptr = data;
1069             cbh.cb_flags     = get_flags     (&ptr, data + cbh.ipc_hdr.datalen);
1070             cbh.cb_interface = get_uint32    (&ptr, data + cbh.ipc_hdr.datalen);
1071             cbh.cb_err       = get_error_code(&ptr, data + cbh.ipc_hdr.datalen);
1072
1073             // CAUTION: We have to handle the case where the client calls DNSServiceRefDeallocate from within the callback function.
1074             // To do this we set moreptr to point to morebytes. If the client does call DNSServiceRefDeallocate(),
1075             // then that routine will clear morebytes for us, and cause us to exit our loop.
1076             morebytes = more_bytes(sdRef->sockfd);
1077             if (morebytes)
1078             {
1079                 cbh.cb_flags |= kDNSServiceFlagsMoreComing;
1080                 sdRef->moreptr = &morebytes;
1081             }
1082             if (ptr) sdRef->ProcessReply(sdRef, &cbh, ptr, data + cbh.ipc_hdr.datalen);
1083             // Careful code here:
1084             // If morebytes is non-zero, that means we set sdRef->moreptr above, and the operation was not
1085             // cancelled out from under us, so now we need to clear sdRef->moreptr so we don't leave a stray
1086             // dangling pointer pointing to a long-gone stack variable.
1087             // If morebytes is zero, then one of two thing happened:
1088             // (a) morebytes was 0 above, so we didn't set sdRef->moreptr, so we don't need to clear it
1089             // (b) morebytes was 1 above, and we set sdRef->moreptr, but the operation was cancelled (with DNSServiceRefDeallocate()),
1090             //     so we MUST NOT try to dereference our stale sdRef pointer.
1091             if (morebytes) sdRef->moreptr = NULL;
1092         }
1093         free(data);
1094     } while (morebytes);
1095
1096     return kDNSServiceErr_NoError;
1097 }
1098
1099 void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdRef)
1100 {
1101     if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefDeallocate called with NULL DNSServiceRef"); return; }
1102
1103     if (!DNSServiceRefValid(sdRef))     // Also verifies dnssd_SocketValid(sdRef->sockfd) for us too
1104     {
1105         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefDeallocate called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1106         return;
1107     }
1108
1109     // If we're in the middle of a DNSServiceProcessResult() invocation for this DNSServiceRef, clear its morebytes flag to break it out of its while loop
1110     if (sdRef->moreptr) *(sdRef->moreptr) = 0;
1111
1112     if (sdRef->primary)     // If this is a subordinate DNSServiceOp, just send a 'stop' command
1113     {
1114         DNSServiceOp **p = &sdRef->primary->next;
1115         while (*p && *p != sdRef) p = &(*p)->next;
1116         if (*p)
1117         {
1118             char *ptr;
1119             size_t len = 0;
1120             ipc_msg_hdr *hdr = create_hdr(cancel_request, &len, &ptr, 0, sdRef);
1121             if (hdr)
1122             {
1123                 ConvertHeaderBytes(hdr);
1124                 write_all(sdRef->sockfd, (char *)hdr, len);
1125                 free(hdr);
1126             }
1127             *p = sdRef->next;
1128             FreeDNSServiceOp(sdRef);
1129         }
1130     }
1131     else                    // else, make sure to terminate all subordinates as well
1132     {
1133 #if _DNS_SD_LIBDISPATCH
1134         // The cancel handler will close the fd if a dispatch source has been set
1135         if (sdRef->disp_source)
1136         {
1137             // By setting the ProcessReply to NULL, we make sure that we never call
1138             // the application callbacks ever, after returning from this function. We
1139             // assume that DNSServiceRefDeallocate is called from the serial queue
1140             // that was passed to DNSServiceSetDispatchQueue. Hence, dispatch_source_cancel
1141             // should cancel all the blocks on the queue and hence there should be no more
1142             // callbacks when we return from this function. Setting ProcessReply to NULL
1143             // provides extra protection.
1144             sdRef->ProcessReply = NULL;
1145             shutdown(sdRef->sockfd, SHUT_WR);
1146             dispatch_source_cancel(sdRef->disp_source);
1147             dispatch_release(sdRef->disp_source);
1148             sdRef->disp_source = NULL;
1149         }
1150         // if disp_queue is set, it means it used the DNSServiceSetDispatchQueue API. In that case,
1151         // when the source was cancelled, the fd was closed in the handler. Currently the source
1152         // is cancelled only when the mDNSResponder daemon dies
1153         else if (!sdRef->disp_queue) dnssd_close(sdRef->sockfd);
1154 #else
1155         dnssd_close(sdRef->sockfd);
1156 #endif
1157         // Free DNSRecords added in DNSRegisterRecord if they have not
1158         // been freed in DNSRemoveRecord
1159         while (sdRef)
1160         {
1161             DNSServiceOp *p = sdRef;
1162             sdRef = sdRef->next;
1163             // When there is an error reading from the daemon e.g., bad fd, CallbackWithError
1164             // is called which sets moreptr. It might set the moreptr on a subordinate sdRef
1165             // but the application might call DNSServiceRefDeallocate with the main sdRef from
1166             // the callback. Hence, when we loop through the subordinate sdRefs, we need
1167             // to clear the moreptr so that CallbackWithError can terminate itself instead of
1168             // walking through the freed sdRefs.
1169             if (p->moreptr) *(p->moreptr) = 0;
1170             FreeDNSServiceOp(p);
1171         }
1172     }
1173 }
1174
1175 DNSServiceErrorType DNSSD_API DNSServiceGetProperty(const char *property, void *result, uint32_t *size)
1176 {
1177     DNSServiceErrorType err;
1178     char *ptr;
1179     size_t len;
1180     ipc_msg_hdr *hdr;
1181     DNSServiceOp *tmp;
1182     uint32_t actualsize;
1183
1184     if (!property || !result || !size)
1185         return kDNSServiceErr_BadParam;
1186
1187     len = strlen(property) + 1;
1188     err = ConnectToServer(&tmp, 0, getproperty_request, NULL, NULL, NULL);
1189     if (err) return err;
1190
1191     hdr = create_hdr(getproperty_request, &len, &ptr, 0, tmp);
1192     if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
1193
1194     put_string(property, &ptr);
1195     err = deliver_request(hdr, tmp);        // Will free hdr for us
1196     if (err) { DNSServiceRefDeallocate(tmp); return err; }
1197
1198     if (read_all(tmp->sockfd, (char*)&actualsize, (int)sizeof(actualsize)) < 0)
1199     { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_ServiceNotRunning; }
1200
1201     actualsize = ntohl(actualsize);
1202     if (read_all(tmp->sockfd, (char*)result, actualsize < *size ? actualsize : *size) < 0)
1203     { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_ServiceNotRunning; }
1204     DNSServiceRefDeallocate(tmp);
1205
1206     // Swap version result back to local process byte order
1207     if (!strcmp(property, kDNSServiceProperty_DaemonVersion) && *size >= 4)
1208         *(uint32_t*)result = ntohl(*(uint32_t*)result);
1209
1210     *size = actualsize;
1211     return kDNSServiceErr_NoError;
1212 }
1213
1214 DNSServiceErrorType DNSSD_API DNSServiceGetPID(const uint16_t srcport, int32_t *pid)
1215 {
1216     char *ptr;
1217     ipc_msg_hdr *hdr;
1218     DNSServiceOp *tmp;
1219     size_t len = sizeof(int32_t);
1220
1221     DNSServiceErrorType err = ConnectToServer(&tmp, 0, getpid_request, NULL, NULL, NULL);
1222     if (err) return err;
1223
1224     hdr = create_hdr(getpid_request, &len, &ptr, 0, tmp);
1225     if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
1226
1227     put_uint16(srcport, &ptr);
1228     err = deliver_request(hdr, tmp);        // Will free hdr for us
1229     if (err) { DNSServiceRefDeallocate(tmp); return err; }
1230
1231     if (read_all(tmp->sockfd, (char*)pid, sizeof(int32_t)) < 0)
1232     { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_ServiceNotRunning; }
1233
1234     DNSServiceRefDeallocate(tmp);
1235     return kDNSServiceErr_NoError;
1236 }
1237
1238 static void handle_resolve_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *end)
1239 {
1240     char fullname[kDNSServiceMaxDomainName];
1241     char target[kDNSServiceMaxDomainName];
1242     uint16_t txtlen;
1243     union { uint16_t s; u_char b[2]; } port;
1244     unsigned char *txtrecord;
1245
1246     get_string(&data, end, fullname, kDNSServiceMaxDomainName);
1247     get_string(&data, end, target,   kDNSServiceMaxDomainName);
1248     if (!data || data + 2 > end) goto fail;
1249
1250     port.b[0] = *data++;
1251     port.b[1] = *data++;
1252     txtlen = get_uint16(&data, end);
1253     txtrecord = (unsigned char *)get_rdata(&data, end, txtlen);
1254
1255     if (!data) goto fail;
1256     ((DNSServiceResolveReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, fullname, target, port.s, txtlen, txtrecord, sdr->AppContext);
1257     return;
1258     // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1259 fail:
1260     syslog(LOG_WARNING, "dnssd_clientstub handle_resolve_response: error reading result from daemon");
1261 }
1262
1263 #if TARGET_OS_EMBEDDED
1264
1265 static int32_t libSystemVersion = 0;
1266
1267 // Return true if the iOS application linked against a version of libsystem where P2P
1268 // interfaces were included by default when using kDNSServiceInterfaceIndexAny.
1269 // Using 160.0.0 == 0xa00000 as the version threshold.
1270 static int includeP2PWithIndexAny()
1271 {
1272     if (libSystemVersion == 0)
1273         libSystemVersion = NSVersionOfLinkTimeLibrary("System");
1274
1275     if (libSystemVersion < 0xa00000)
1276         return 1;
1277     else
1278         return 0;
1279 }
1280
1281 #else   // TARGET_OS_EMBEDDED
1282
1283 // always return false for non iOS platforms
1284 static int includeP2PWithIndexAny()
1285 {
1286     return 0;
1287 }
1288
1289 #endif  // TARGET_OS_EMBEDDED
1290
1291 DNSServiceErrorType DNSSD_API DNSServiceResolve
1292 (
1293     DNSServiceRef                 *sdRef,
1294     DNSServiceFlags flags,
1295     uint32_t interfaceIndex,
1296     const char                    *name,
1297     const char                    *regtype,
1298     const char                    *domain,
1299     DNSServiceResolveReply callBack,
1300     void                          *context
1301 )
1302 {
1303     char *ptr;
1304     size_t len;
1305     ipc_msg_hdr *hdr;
1306     DNSServiceErrorType err;
1307
1308     if (!sdRef || !name || !regtype || !domain || !callBack) return kDNSServiceErr_BadParam;
1309
1310     // Need a real InterfaceID for WakeOnResolve
1311     if ((flags & kDNSServiceFlagsWakeOnResolve) != 0 &&
1312         ((interfaceIndex == kDNSServiceInterfaceIndexAny) ||
1313          (interfaceIndex == kDNSServiceInterfaceIndexLocalOnly) ||
1314          (interfaceIndex == kDNSServiceInterfaceIndexUnicast) ||
1315          (interfaceIndex == kDNSServiceInterfaceIndexP2P)))
1316     {
1317         return kDNSServiceErr_BadParam;
1318     }
1319
1320     if ((interfaceIndex == kDNSServiceInterfaceIndexAny) && includeP2PWithIndexAny())
1321         flags |= kDNSServiceFlagsIncludeP2P;
1322
1323     err = ConnectToServer(sdRef, flags, resolve_request, handle_resolve_response, callBack, context);
1324     if (err) return err;    // On error ConnectToServer leaves *sdRef set to NULL
1325
1326     // Calculate total message length
1327     len = sizeof(flags);
1328     len += sizeof(interfaceIndex);
1329     len += strlen(name) + 1;
1330     len += strlen(regtype) + 1;
1331     len += strlen(domain) + 1;
1332
1333     hdr = create_hdr(resolve_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1334     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1335
1336     put_flags(flags, &ptr);
1337     put_uint32(interfaceIndex, &ptr);
1338     put_string(name, &ptr);
1339     put_string(regtype, &ptr);
1340     put_string(domain, &ptr);
1341
1342     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1343     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1344     return err;
1345 }
1346
1347 static void handle_query_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1348 {
1349     uint32_t ttl;
1350     char name[kDNSServiceMaxDomainName];
1351     uint16_t rrtype, rrclass, rdlen;
1352     const char *rdata;
1353
1354     get_string(&data, end, name, kDNSServiceMaxDomainName);
1355     rrtype  = get_uint16(&data, end);
1356     rrclass = get_uint16(&data, end);
1357     rdlen   = get_uint16(&data, end);
1358     rdata   = get_rdata(&data, end, rdlen);
1359     ttl     = get_uint32(&data, end);
1360
1361     if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_query_response: error reading result from daemon");
1362     else ((DNSServiceQueryRecordReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, name, rrtype, rrclass, rdlen, rdata, ttl, sdr->AppContext);
1363     // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1364 }
1365
1366 DNSServiceErrorType DNSSD_API DNSServiceQueryRecord
1367 (
1368     DNSServiceRef              *sdRef,
1369     DNSServiceFlags flags,
1370     uint32_t interfaceIndex,
1371     const char                 *name,
1372     uint16_t rrtype,
1373     uint16_t rrclass,
1374     DNSServiceQueryRecordReply callBack,
1375     void                       *context
1376 )
1377 {
1378     char *ptr;
1379     size_t len;
1380     ipc_msg_hdr *hdr;
1381     DNSServiceErrorType err;
1382
1383     // NULL name handled below.
1384     if (!sdRef || !callBack) return kDNSServiceErr_BadParam;
1385
1386     if ((interfaceIndex == kDNSServiceInterfaceIndexAny) && includeP2PWithIndexAny())
1387         flags |= kDNSServiceFlagsIncludeP2P;
1388
1389     err = ConnectToServer(sdRef, flags, query_request, handle_query_response, callBack, context);
1390     if (err) return err;    // On error ConnectToServer leaves *sdRef set to NULL
1391
1392     if (!name) name = "\0";
1393
1394     // Calculate total message length
1395     len = sizeof(flags);
1396     len += sizeof(uint32_t);  // interfaceIndex
1397     len += strlen(name) + 1;
1398     len += 2 * sizeof(uint16_t);  // rrtype, rrclass
1399
1400     hdr = create_hdr(query_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1401     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1402
1403     put_flags(flags, &ptr);
1404     put_uint32(interfaceIndex, &ptr);
1405     put_string(name, &ptr);
1406     put_uint16(rrtype, &ptr);
1407     put_uint16(rrclass, &ptr);
1408
1409     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1410     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1411     return err;
1412 }
1413
1414 static void handle_addrinfo_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1415 {
1416     char hostname[kDNSServiceMaxDomainName];
1417     uint16_t rrtype, rrclass, rdlen;
1418     const char *rdata;
1419     uint32_t ttl;
1420
1421     get_string(&data, end, hostname, kDNSServiceMaxDomainName);
1422     rrtype  = get_uint16(&data, end);
1423     rrclass = get_uint16(&data, end);
1424     rdlen   = get_uint16(&data, end);
1425     rdata   = get_rdata (&data, end, rdlen);
1426     ttl     = get_uint32(&data, end);
1427     (void)rrclass; // Unused
1428
1429     // We only generate client callbacks for A and AAAA results (including NXDOMAIN results for
1430     // those types, if the client has requested those with the kDNSServiceFlagsReturnIntermediates).
1431     // Other result types, specifically CNAME referrals, are not communicated to the client, because
1432     // the DNSServiceGetAddrInfoReply interface doesn't have any meaningful way to communiate CNAME referrals.
1433     if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_addrinfo_response: error reading result from daemon");
1434     else if (rrtype == kDNSServiceType_A || rrtype == kDNSServiceType_AAAA)
1435     {
1436         struct sockaddr_in sa4;
1437         struct sockaddr_in6 sa6;
1438         const struct sockaddr *const sa = (rrtype == kDNSServiceType_A) ? (struct sockaddr*)&sa4 : (struct sockaddr*)&sa6;
1439         if (rrtype == kDNSServiceType_A)
1440         {
1441             memset(&sa4, 0, sizeof(sa4));
1442             #ifndef NOT_HAVE_SA_LEN
1443             sa4.sin_len = sizeof(struct sockaddr_in);
1444             #endif
1445             sa4.sin_family = AF_INET;
1446             //  sin_port   = 0;
1447             if (!cbh->cb_err) memcpy(&sa4.sin_addr, rdata, rdlen);
1448         }
1449         else
1450         {
1451             memset(&sa6, 0, sizeof(sa6));
1452             #ifndef NOT_HAVE_SA_LEN
1453             sa6.sin6_len = sizeof(struct sockaddr_in6);
1454             #endif
1455             sa6.sin6_family     = AF_INET6;
1456             //  sin6_port     = 0;
1457             //  sin6_flowinfo = 0;
1458             //  sin6_scope_id = 0;
1459             if (!cbh->cb_err)
1460             {
1461                 memcpy(&sa6.sin6_addr, rdata, rdlen);
1462                 if (IN6_IS_ADDR_LINKLOCAL(&sa6.sin6_addr)) sa6.sin6_scope_id = cbh->cb_interface;
1463             }
1464         }
1465         // Validation results are always delivered separately from the actual results of the
1466         // DNSServiceGetAddrInfo. Set the "addr" to NULL as per the documentation.
1467         //
1468         // Note: If we deliver validation results along with the "addr" in the future, we need
1469         // a way to differentiate the negative response from validation-only response as both
1470         // has zero address.
1471         if (!(cbh->cb_flags & kDNSServiceFlagsValidate))
1472             ((DNSServiceGetAddrInfoReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, hostname, sa, ttl, sdr->AppContext);
1473         else
1474             ((DNSServiceGetAddrInfoReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, hostname, NULL, 0, sdr->AppContext);
1475         // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1476     }
1477 }
1478
1479 DNSServiceErrorType DNSSD_API DNSServiceGetAddrInfo
1480 (
1481     DNSServiceRef                    *sdRef,
1482     DNSServiceFlags flags,
1483     uint32_t interfaceIndex,
1484     uint32_t protocol,
1485     const char                       *hostname,
1486     DNSServiceGetAddrInfoReply callBack,
1487     void                             *context          /* may be NULL */
1488 )
1489 {
1490     char *ptr;
1491     size_t len;
1492     ipc_msg_hdr *hdr;
1493     DNSServiceErrorType err;
1494
1495     if (!sdRef || !hostname || !callBack) return kDNSServiceErr_BadParam;
1496
1497     err = ConnectToServer(sdRef, flags, addrinfo_request, handle_addrinfo_response, callBack, context);
1498     if (err)
1499     {
1500          return err;    // On error ConnectToServer leaves *sdRef set to NULL
1501     }
1502
1503     // Calculate total message length
1504     len = sizeof(flags);
1505     len += sizeof(uint32_t);      // interfaceIndex
1506     len += sizeof(uint32_t);      // protocol
1507     len += strlen(hostname) + 1;
1508
1509     hdr = create_hdr(addrinfo_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1510     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1511
1512     put_flags(flags, &ptr);
1513     put_uint32(interfaceIndex, &ptr);
1514     put_uint32(protocol, &ptr);
1515     put_string(hostname, &ptr);
1516
1517     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1518     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1519     return err;
1520 }
1521
1522 static void handle_browse_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1523 {
1524     char replyName[256], replyType[kDNSServiceMaxDomainName], replyDomain[kDNSServiceMaxDomainName];
1525     get_string(&data, end, replyName, 256);
1526     get_string(&data, end, replyType, kDNSServiceMaxDomainName);
1527     get_string(&data, end, replyDomain, kDNSServiceMaxDomainName);
1528     if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_browse_response: error reading result from daemon");
1529     else ((DNSServiceBrowseReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, replyName, replyType, replyDomain, sdr->AppContext);
1530     // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1531 }
1532
1533 DNSServiceErrorType DNSSD_API DNSServiceBrowse
1534 (
1535     DNSServiceRef         *sdRef,
1536     DNSServiceFlags flags,
1537     uint32_t interfaceIndex,
1538     const char            *regtype,
1539     const char            *domain,
1540     DNSServiceBrowseReply callBack,
1541     void                  *context
1542 )
1543 {
1544     char *ptr;
1545     size_t len;
1546     ipc_msg_hdr *hdr;
1547     DNSServiceErrorType err;
1548
1549     // NULL domain handled below
1550     if (!sdRef || !regtype || !callBack) return kDNSServiceErr_BadParam;
1551
1552     if ((interfaceIndex == kDNSServiceInterfaceIndexAny) && includeP2PWithIndexAny())
1553         flags |= kDNSServiceFlagsIncludeP2P;
1554
1555     err = ConnectToServer(sdRef, flags, browse_request, handle_browse_response, callBack, context);
1556     if (err) return err;    // On error ConnectToServer leaves *sdRef set to NULL
1557
1558     if (!domain) domain = "";
1559     len = sizeof(flags);
1560     len += sizeof(interfaceIndex);
1561     len += strlen(regtype) + 1;
1562     len += strlen(domain) + 1;
1563
1564     hdr = create_hdr(browse_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1565     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1566
1567     put_flags(flags, &ptr);
1568     put_uint32(interfaceIndex, &ptr);
1569     put_string(regtype, &ptr);
1570     put_string(domain, &ptr);
1571
1572     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1573     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1574     return err;
1575 }
1576
1577 DNSServiceErrorType DNSSD_API DNSServiceSetDefaultDomainForUser(DNSServiceFlags flags, const char *domain);
1578 DNSServiceErrorType DNSSD_API DNSServiceSetDefaultDomainForUser(DNSServiceFlags flags, const char *domain)
1579 {
1580     DNSServiceErrorType err;
1581     DNSServiceOp *tmp;
1582     char *ptr;
1583     size_t len;
1584     ipc_msg_hdr *hdr;
1585
1586     if (!domain) return kDNSServiceErr_BadParam;
1587     len = sizeof(flags) + strlen(domain) + 1;
1588
1589     err = ConnectToServer(&tmp, 0, setdomain_request, NULL, NULL, NULL);
1590     if (err) return err;
1591
1592     hdr = create_hdr(setdomain_request, &len, &ptr, 0, tmp);
1593     if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
1594
1595     put_flags(flags, &ptr);
1596     put_string(domain, &ptr);
1597     err = deliver_request(hdr, tmp);        // Will free hdr for us
1598     DNSServiceRefDeallocate(tmp);
1599     return err;
1600 }
1601
1602 static void handle_regservice_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1603 {
1604     char name[256], regtype[kDNSServiceMaxDomainName], domain[kDNSServiceMaxDomainName];
1605     get_string(&data, end, name, 256);
1606     get_string(&data, end, regtype, kDNSServiceMaxDomainName);
1607     get_string(&data, end, domain,  kDNSServiceMaxDomainName);
1608     if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_regservice_response: error reading result from daemon");
1609     else ((DNSServiceRegisterReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_err, name, regtype, domain, sdr->AppContext);
1610     // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1611 }
1612
1613 DNSServiceErrorType DNSSD_API DNSServiceRegister
1614 (
1615     DNSServiceRef                       *sdRef,
1616     DNSServiceFlags flags,
1617     uint32_t interfaceIndex,
1618     const char                          *name,
1619     const char                          *regtype,
1620     const char                          *domain,
1621     const char                          *host,
1622     uint16_t PortInNetworkByteOrder,
1623     uint16_t txtLen,
1624     const void                          *txtRecord,
1625     DNSServiceRegisterReply callBack,
1626     void                                *context
1627 )
1628 {
1629     char *ptr;
1630     size_t len;
1631     ipc_msg_hdr *hdr;
1632     DNSServiceErrorType err;
1633     union { uint16_t s; u_char b[2]; } port = { PortInNetworkByteOrder };
1634
1635     if (!sdRef || !regtype) return kDNSServiceErr_BadParam;
1636     if (!name) name = "";
1637     if (!domain) domain = "";
1638     if (!host) host = "";
1639     if (!txtRecord) txtRecord = (void*)"";
1640
1641     // No callback must have auto-rename
1642     if (!callBack && (flags & kDNSServiceFlagsNoAutoRename)) return kDNSServiceErr_BadParam;
1643
1644     if ((interfaceIndex == kDNSServiceInterfaceIndexAny) && includeP2PWithIndexAny())
1645         flags |= kDNSServiceFlagsIncludeP2P;
1646
1647     err = ConnectToServer(sdRef, flags, reg_service_request, callBack ? handle_regservice_response : NULL, callBack, context);
1648     if (err) return err;    // On error ConnectToServer leaves *sdRef set to NULL
1649
1650     len = sizeof(DNSServiceFlags);
1651     len += sizeof(uint32_t);  // interfaceIndex
1652     len += strlen(name) + strlen(regtype) + strlen(domain) + strlen(host) + 4;
1653     len += 2 * sizeof(uint16_t);  // port, txtLen
1654     len += txtLen;
1655
1656     hdr = create_hdr(reg_service_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1657     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1658     if (!callBack) hdr->ipc_flags |= IPC_FLAGS_NOREPLY;
1659
1660     put_flags(flags, &ptr);
1661     put_uint32(interfaceIndex, &ptr);
1662     put_string(name, &ptr);
1663     put_string(regtype, &ptr);
1664     put_string(domain, &ptr);
1665     put_string(host, &ptr);
1666     *ptr++ = port.b[0];
1667     *ptr++ = port.b[1];
1668     put_uint16(txtLen, &ptr);
1669     put_rdata(txtLen, txtRecord, &ptr);
1670
1671     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1672     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1673     return err;
1674 }
1675
1676 static void handle_enumeration_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1677 {
1678     char domain[kDNSServiceMaxDomainName];
1679     get_string(&data, end, domain, kDNSServiceMaxDomainName);
1680     if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_enumeration_response: error reading result from daemon");
1681     else ((DNSServiceDomainEnumReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, domain, sdr->AppContext);
1682     // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1683 }
1684
1685 DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains
1686 (
1687     DNSServiceRef             *sdRef,
1688     DNSServiceFlags flags,
1689     uint32_t interfaceIndex,
1690     DNSServiceDomainEnumReply callBack,
1691     void                      *context
1692 )
1693 {
1694     char *ptr;
1695     size_t len;
1696     ipc_msg_hdr *hdr;
1697     DNSServiceErrorType err;
1698     int f1;
1699     int f2;
1700
1701     if (!sdRef || !callBack) return kDNSServiceErr_BadParam;
1702
1703     f1 = (flags & kDNSServiceFlagsBrowseDomains) != 0;
1704     f2 = (flags & kDNSServiceFlagsRegistrationDomains) != 0;
1705     if (f1 + f2 != 1) return kDNSServiceErr_BadParam;
1706
1707     err = ConnectToServer(sdRef, flags, enumeration_request, handle_enumeration_response, callBack, context);
1708     if (err) return err;    // On error ConnectToServer leaves *sdRef set to NULL
1709
1710     len = sizeof(DNSServiceFlags);
1711     len += sizeof(uint32_t);
1712
1713     hdr = create_hdr(enumeration_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1714     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1715
1716     put_flags(flags, &ptr);
1717     put_uint32(interfaceIndex, &ptr);
1718
1719     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1720     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1721     return err;
1722 }
1723
1724 static void ConnectionResponse(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *const data, const char *const end)
1725 {
1726     (void)data; // Unused
1727
1728     //printf("ConnectionResponse got %d\n", cbh->ipc_hdr.op);
1729     if (cbh->ipc_hdr.op != reg_record_reply_op)
1730     {
1731         // When using kDNSServiceFlagsShareConnection, need to search the list of associated DNSServiceOps
1732         // to find the one this response is intended for, and then call through to its ProcessReply handler.
1733         // We start with our first subordinate DNSServiceRef -- don't want to accidentally match the parent DNSServiceRef.
1734         DNSServiceOp *op = sdr->next;
1735         while (op && (op->uid.u32[0] != cbh->ipc_hdr.client_context.u32[0] || op->uid.u32[1] != cbh->ipc_hdr.client_context.u32[1]))
1736             op = op->next;
1737         // Note: We may sometimes not find a matching DNSServiceOp, in the case where the client has
1738         // cancelled the subordinate DNSServiceOp, but there are still messages in the pipeline from the daemon
1739         if (op && op->ProcessReply) op->ProcessReply(op, cbh, data, end);
1740         // WARNING: Don't touch op or sdr after this -- client may have called DNSServiceRefDeallocate
1741         return;
1742     }
1743     else
1744     {
1745         DNSRecordRef rec;
1746         for (rec = sdr->rec; rec; rec = rec->recnext)
1747         {
1748             if (rec->uid.u32[0] == cbh->ipc_hdr.client_context.u32[0] && rec->uid.u32[1] == cbh->ipc_hdr.client_context.u32[1])
1749                 break;
1750         }
1751         // The record might have been freed already and hence not an
1752         // error if the record is not found.
1753         if (!rec)
1754         {
1755             syslog(LOG_INFO, "ConnectionResponse: Record not found");
1756             return;
1757         }
1758         if (rec->sdr != sdr)
1759         {
1760             syslog(LOG_WARNING, "ConnectionResponse: Record sdr mismatch: rec %p sdr %p", rec->sdr, sdr);
1761             return;
1762         }
1763
1764         if (sdr->op == connection_request || sdr->op == connection_delegate_request)
1765         {
1766             rec->AppCallback(rec->sdr, rec, cbh->cb_flags, cbh->cb_err, rec->AppContext);
1767         }
1768         else
1769         {
1770             syslog(LOG_WARNING, "dnssd_clientstub ConnectionResponse: sdr->op != connection_request");
1771             rec->AppCallback(rec->sdr, rec, 0, kDNSServiceErr_Unknown, rec->AppContext);
1772         }
1773         // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1774     }
1775 }
1776
1777 DNSServiceErrorType DNSSD_API DNSServiceCreateConnection(DNSServiceRef *sdRef)
1778 {
1779     DNSServiceErrorType err;
1780     char *ptr;
1781     size_t len = 0;
1782     ipc_msg_hdr *hdr;
1783
1784     if (!sdRef) return kDNSServiceErr_BadParam;
1785     err = ConnectToServer(sdRef, 0, connection_request, ConnectionResponse, NULL, NULL);
1786     if (err) return err;    // On error ConnectToServer leaves *sdRef set to NULL
1787
1788     hdr = create_hdr(connection_request, &len, &ptr, 0, *sdRef);
1789     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1790
1791     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1792     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1793     return err;
1794 }
1795
1796 #if APPLE_OSX_mDNSResponder && !TARGET_IPHONE_SIMULATOR
1797 DNSServiceErrorType DNSSD_API DNSServiceCreateDelegateConnection(DNSServiceRef *sdRef, int32_t pid, uuid_t uuid)
1798 {
1799     char *ptr;
1800     size_t len = 0;
1801     ipc_msg_hdr *hdr;
1802
1803     if (!sdRef) return kDNSServiceErr_BadParam;
1804     DNSServiceErrorType err = ConnectToServer(sdRef, 0, connection_delegate_request, ConnectionResponse, NULL, NULL);
1805     if (err)
1806     {
1807          return err;    // On error ConnectToServer leaves *sdRef set to NULL
1808     }
1809
1810     // Only one of the two options can be set. If pid is zero, uuid is used.
1811     // If both are specified only pid will be used. We send across the pid
1812     // so that the daemon knows what to read from the socket.
1813
1814     len += sizeof(int32_t);
1815
1816     hdr = create_hdr(connection_delegate_request, &len, &ptr, 0, *sdRef);
1817     if (!hdr)
1818     {
1819         DNSServiceRefDeallocate(*sdRef);
1820         *sdRef = NULL;
1821         return kDNSServiceErr_NoMemory;
1822     }
1823
1824     if (pid && setsockopt((*sdRef)->sockfd, SOL_SOCKET, SO_DELEGATED, &pid, sizeof(pid)) == -1)
1825     {
1826         syslog(LOG_WARNING, "dnssdclientstub: Could not setsockopt() for PID[%d], no entitlements or process(pid) invalid errno:%d (%s)", pid, errno, strerror(errno));
1827         // Free the hdr in case we return before calling deliver_request()
1828         if (hdr)
1829             free(hdr);
1830         DNSServiceRefDeallocate(*sdRef);
1831         *sdRef = NULL;
1832         return kDNSServiceErr_NoAuth;
1833     }
1834
1835     if (!pid && setsockopt((*sdRef)->sockfd, SOL_SOCKET, SO_DELEGATED_UUID, uuid, sizeof(uuid_t)) == -1)
1836     {
1837         syslog(LOG_WARNING, "dnssdclientstub: Could not setsockopt() for UUID, no entitlements or process(uuid) invalid errno:%d (%s) ", errno, strerror(errno));
1838         // Free the hdr in case we return before calling deliver_request()
1839         if (hdr)
1840             free(hdr);
1841         DNSServiceRefDeallocate(*sdRef);
1842         *sdRef = NULL;
1843         return kDNSServiceErr_NoAuth;
1844     }
1845
1846     put_uint32(pid, &ptr);
1847
1848     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
1849     if (err)
1850     {
1851         DNSServiceRefDeallocate(*sdRef);
1852         *sdRef = NULL;
1853     }
1854     return err;
1855 }
1856 #elif TARGET_IPHONE_SIMULATOR // This hack is for Simulator platform only
1857 DNSServiceErrorType DNSSD_API DNSServiceCreateDelegateConnection(DNSServiceRef *sdRef, int32_t pid, uuid_t uuid)
1858 {
1859     (void) pid;
1860     (void) uuid;
1861     return DNSServiceCreateConnection(sdRef);
1862 }
1863 #endif
1864
1865 DNSServiceErrorType DNSSD_API DNSServiceRegisterRecord
1866 (
1867     DNSServiceRef sdRef,
1868     DNSRecordRef                  *RecordRef,
1869     DNSServiceFlags flags,
1870     uint32_t interfaceIndex,
1871     const char                    *fullname,
1872     uint16_t rrtype,
1873     uint16_t rrclass,
1874     uint16_t rdlen,
1875     const void                    *rdata,
1876     uint32_t ttl,
1877     DNSServiceRegisterRecordReply callBack,
1878     void                          *context
1879 )
1880 {
1881     char *ptr;
1882     size_t len;
1883     ipc_msg_hdr *hdr = NULL;
1884     DNSRecordRef rref = NULL;
1885     DNSRecord **p;
1886     int f1 = (flags & kDNSServiceFlagsShared) != 0;
1887     int f2 = (flags & kDNSServiceFlagsUnique) != 0;
1888     if (f1 + f2 != 1) return kDNSServiceErr_BadParam;
1889
1890     if ((interfaceIndex == kDNSServiceInterfaceIndexAny) && includeP2PWithIndexAny())
1891         flags |= kDNSServiceFlagsIncludeP2P;
1892
1893     if (!sdRef || !RecordRef || !fullname || (!rdata && rdlen) || !callBack)
1894     {
1895         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with NULL parameter");
1896         return kDNSServiceErr_BadParam;
1897     }
1898
1899     if (!DNSServiceRefValid(sdRef))
1900     {
1901         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1902         return kDNSServiceErr_BadReference;
1903     }
1904
1905     if (sdRef->op != connection_request && sdRef->op != connection_delegate_request)
1906     {
1907         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with non-DNSServiceCreateConnection DNSServiceRef %p %d", sdRef, sdRef->op);
1908         return kDNSServiceErr_BadReference;
1909     }
1910
1911     *RecordRef = NULL;
1912
1913     len = sizeof(DNSServiceFlags);
1914     len += 2 * sizeof(uint32_t);  // interfaceIndex, ttl
1915     len += 3 * sizeof(uint16_t);  // rrtype, rrclass, rdlen
1916     len += strlen(fullname) + 1;
1917     len += rdlen;
1918
1919     // Bump up the uid. Normally for shared operations (kDNSServiceFlagsShareConnection), this
1920     // is done in ConnectToServer. For DNSServiceRegisterRecord, ConnectToServer has already
1921     // been called. As multiple DNSServiceRegisterRecords can be multiplexed over a single
1922     // connection, we need a way to demultiplex the response so that the callback corresponding
1923     // to the right DNSServiceRegisterRecord instance can be called. Use the same mechanism that
1924     // is used by kDNSServiceFlagsShareConnection. create_hdr copies the uid value to ipc
1925     // hdr->client_context which will be returned in the ipc response.
1926     if (++sdRef->uid.u32[0] == 0)
1927         ++sdRef->uid.u32[1];
1928     hdr = create_hdr(reg_record_request, &len, &ptr, 1, sdRef);
1929     if (!hdr) return kDNSServiceErr_NoMemory;
1930
1931     put_flags(flags, &ptr);
1932     put_uint32(interfaceIndex, &ptr);
1933     put_string(fullname, &ptr);
1934     put_uint16(rrtype, &ptr);
1935     put_uint16(rrclass, &ptr);
1936     put_uint16(rdlen, &ptr);
1937     put_rdata(rdlen, rdata, &ptr);
1938     put_uint32(ttl, &ptr);
1939
1940     rref = malloc(sizeof(DNSRecord));
1941     if (!rref) { free(hdr); return kDNSServiceErr_NoMemory; }
1942     rref->AppContext = context;
1943     rref->AppCallback = callBack;
1944     rref->record_index = sdRef->max_index++;
1945     rref->sdr = sdRef;
1946     rref->recnext = NULL;
1947     *RecordRef = rref;
1948     // Remember the uid that we are sending across so that we can match
1949     // when the response comes back.
1950     rref->uid = sdRef->uid;
1951     hdr->reg_index = rref->record_index;
1952
1953     p = &(sdRef)->rec;
1954     while (*p) p = &(*p)->recnext;
1955     *p = rref;
1956
1957     return deliver_request(hdr, sdRef);     // Will free hdr for us
1958 }
1959
1960 // sdRef returned by DNSServiceRegister()
1961 DNSServiceErrorType DNSSD_API DNSServiceAddRecord
1962 (
1963     DNSServiceRef sdRef,
1964     DNSRecordRef    *RecordRef,
1965     DNSServiceFlags flags,
1966     uint16_t rrtype,
1967     uint16_t rdlen,
1968     const void      *rdata,
1969     uint32_t ttl
1970 )
1971 {
1972     ipc_msg_hdr *hdr;
1973     size_t len = 0;
1974     char *ptr;
1975     DNSRecordRef rref;
1976     DNSRecord **p;
1977
1978     if (!sdRef || !RecordRef || (!rdata && rdlen))
1979     {
1980         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with NULL parameter");
1981         return kDNSServiceErr_BadParam;
1982     }
1983     if (sdRef->op != reg_service_request)
1984     {
1985         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with non-DNSServiceRegister DNSServiceRef %p %d", sdRef, sdRef->op);
1986         return kDNSServiceErr_BadReference;
1987     }
1988
1989     if (!DNSServiceRefValid(sdRef))
1990     {
1991         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1992         return kDNSServiceErr_BadReference;
1993     }
1994
1995     *RecordRef = NULL;
1996
1997     len += 2 * sizeof(uint16_t);  // rrtype, rdlen
1998     len += rdlen;
1999     len += sizeof(uint32_t);
2000     len += sizeof(DNSServiceFlags);
2001
2002     hdr = create_hdr(add_record_request, &len, &ptr, 1, sdRef);
2003     if (!hdr) return kDNSServiceErr_NoMemory;
2004     put_flags(flags, &ptr);
2005     put_uint16(rrtype, &ptr);
2006     put_uint16(rdlen, &ptr);
2007     put_rdata(rdlen, rdata, &ptr);
2008     put_uint32(ttl, &ptr);
2009
2010     rref = malloc(sizeof(DNSRecord));
2011     if (!rref) { free(hdr); return kDNSServiceErr_NoMemory; }
2012     rref->AppContext = NULL;
2013     rref->AppCallback = NULL;
2014     rref->record_index = sdRef->max_index++;
2015     rref->sdr = sdRef;
2016     rref->recnext = NULL;
2017     *RecordRef = rref;
2018     hdr->reg_index = rref->record_index;
2019
2020     p = &(sdRef)->rec;
2021     while (*p) p = &(*p)->recnext;
2022     *p = rref;
2023
2024     return deliver_request(hdr, sdRef);     // Will free hdr for us
2025 }
2026
2027 // DNSRecordRef returned by DNSServiceRegisterRecord or DNSServiceAddRecord
2028 DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord
2029 (
2030     DNSServiceRef sdRef,
2031     DNSRecordRef RecordRef,
2032     DNSServiceFlags flags,
2033     uint16_t rdlen,
2034     const void      *rdata,
2035     uint32_t ttl
2036 )
2037 {
2038     ipc_msg_hdr *hdr;
2039     size_t len = 0;
2040     char *ptr;
2041
2042     if (!sdRef || (!rdata && rdlen))
2043     {
2044         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceUpdateRecord called with NULL parameter");
2045         return kDNSServiceErr_BadParam;
2046     }
2047
2048     if (!DNSServiceRefValid(sdRef))
2049     {
2050         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceUpdateRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
2051         return kDNSServiceErr_BadReference;
2052     }
2053
2054     // Note: RecordRef is allowed to be NULL
2055
2056     len += sizeof(uint16_t);
2057     len += rdlen;
2058     len += sizeof(uint32_t);
2059     len += sizeof(DNSServiceFlags);
2060
2061     hdr = create_hdr(update_record_request, &len, &ptr, 1, sdRef);
2062     if (!hdr) return kDNSServiceErr_NoMemory;
2063     hdr->reg_index = RecordRef ? RecordRef->record_index : TXT_RECORD_INDEX;
2064     put_flags(flags, &ptr);
2065     put_uint16(rdlen, &ptr);
2066     put_rdata(rdlen, rdata, &ptr);
2067     put_uint32(ttl, &ptr);
2068     return deliver_request(hdr, sdRef);     // Will free hdr for us
2069 }
2070
2071 DNSServiceErrorType DNSSD_API DNSServiceRemoveRecord
2072 (
2073     DNSServiceRef sdRef,
2074     DNSRecordRef RecordRef,
2075     DNSServiceFlags flags
2076 )
2077 {
2078     ipc_msg_hdr *hdr;
2079     size_t len = 0;
2080     char *ptr;
2081     DNSServiceErrorType err;
2082
2083     if (!sdRef)            { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
2084     if (!RecordRef)        { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with NULL DNSRecordRef");  return kDNSServiceErr_BadParam; }
2085     if (!sdRef->max_index) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with bad DNSServiceRef");  return kDNSServiceErr_BadReference; }
2086
2087     if (!DNSServiceRefValid(sdRef))
2088     {
2089         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
2090         return kDNSServiceErr_BadReference;
2091     }
2092
2093     len += sizeof(flags);
2094     hdr = create_hdr(remove_record_request, &len, &ptr, 1, sdRef);
2095     if (!hdr) return kDNSServiceErr_NoMemory;
2096     hdr->reg_index = RecordRef->record_index;
2097     put_flags(flags, &ptr);
2098     err = deliver_request(hdr, sdRef);      // Will free hdr for us
2099     if (!err)
2100     {
2101         // This RecordRef could have been allocated in DNSServiceRegisterRecord or DNSServiceAddRecord.
2102         // If so, delink from the list before freeing
2103         DNSRecord **p = &sdRef->rec;
2104         while (*p && *p != RecordRef) p = &(*p)->recnext;
2105         if (*p) *p = RecordRef->recnext;
2106         free(RecordRef);
2107     }
2108     return err;
2109 }
2110
2111 DNSServiceErrorType DNSSD_API DNSServiceReconfirmRecord
2112 (
2113     DNSServiceFlags flags,
2114     uint32_t interfaceIndex,
2115     const char      *fullname,
2116     uint16_t rrtype,
2117     uint16_t rrclass,
2118     uint16_t rdlen,
2119     const void      *rdata
2120 )
2121 {
2122     DNSServiceErrorType err;
2123     char *ptr;
2124     size_t len;
2125     ipc_msg_hdr *hdr;
2126     DNSServiceOp *tmp;
2127
2128     if (!fullname || (!rdata && rdlen)) return kDNSServiceErr_BadParam;
2129
2130     err = ConnectToServer(&tmp, flags, reconfirm_record_request, NULL, NULL, NULL);
2131     if (err) return err;
2132
2133     len = sizeof(DNSServiceFlags);
2134     len += sizeof(uint32_t);
2135     len += strlen(fullname) + 1;
2136     len += 3 * sizeof(uint16_t);
2137     len += rdlen;
2138     hdr = create_hdr(reconfirm_record_request, &len, &ptr, 0, tmp);
2139     if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
2140
2141     put_flags(flags, &ptr);
2142     put_uint32(interfaceIndex, &ptr);
2143     put_string(fullname, &ptr);
2144     put_uint16(rrtype, &ptr);
2145     put_uint16(rrclass, &ptr);
2146     put_uint16(rdlen, &ptr);
2147     put_rdata(rdlen, rdata, &ptr);
2148
2149     err = deliver_request(hdr, tmp);        // Will free hdr for us
2150     DNSServiceRefDeallocate(tmp);
2151     return err;
2152 }
2153
2154
2155 static void handle_port_mapping_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
2156 {
2157     union { uint32_t l; u_char b[4]; } addr;
2158     uint8_t protocol;
2159     union { uint16_t s; u_char b[2]; } internalPort;
2160     union { uint16_t s; u_char b[2]; } externalPort;
2161     uint32_t ttl;
2162
2163     if (!data || data + 13 > end) goto fail;
2164
2165     addr.b[0] = *data++;
2166     addr.b[1] = *data++;
2167     addr.b[2] = *data++;
2168     addr.b[3] = *data++;
2169     protocol          = *data++;
2170     internalPort.b[0] = *data++;
2171     internalPort.b[1] = *data++;
2172     externalPort.b[0] = *data++;
2173     externalPort.b[1] = *data++;
2174     ttl               = get_uint32(&data, end);
2175     if (!data) goto fail;
2176
2177     ((DNSServiceNATPortMappingReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, addr.l, protocol, internalPort.s, externalPort.s, ttl, sdr->AppContext);
2178     return;
2179     // MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
2180
2181     fail :
2182     syslog(LOG_WARNING, "dnssd_clientstub handle_port_mapping_response: error reading result from daemon");
2183 }
2184
2185 DNSServiceErrorType DNSSD_API DNSServiceNATPortMappingCreate
2186 (
2187     DNSServiceRef                       *sdRef,
2188     DNSServiceFlags flags,
2189     uint32_t interfaceIndex,
2190     uint32_t protocol,                                /* TCP and/or UDP */
2191     uint16_t internalPortInNetworkByteOrder,
2192     uint16_t externalPortInNetworkByteOrder,
2193     uint32_t ttl,                                     /* time to live in seconds */
2194     DNSServiceNATPortMappingReply callBack,
2195     void                                *context      /* may be NULL */
2196 )
2197 {
2198     char *ptr;
2199     size_t len;
2200     ipc_msg_hdr *hdr;
2201     union { uint16_t s; u_char b[2]; } internalPort = { internalPortInNetworkByteOrder };
2202     union { uint16_t s; u_char b[2]; } externalPort = { externalPortInNetworkByteOrder };
2203
2204     DNSServiceErrorType err = ConnectToServer(sdRef, flags, port_mapping_request, handle_port_mapping_response, callBack, context);
2205     if (err) return err;    // On error ConnectToServer leaves *sdRef set to NULL
2206
2207     len = sizeof(flags);
2208     len += sizeof(interfaceIndex);
2209     len += sizeof(protocol);
2210     len += sizeof(internalPort);
2211     len += sizeof(externalPort);
2212     len += sizeof(ttl);
2213
2214     hdr = create_hdr(port_mapping_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
2215     if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
2216
2217     put_flags(flags, &ptr);
2218     put_uint32(interfaceIndex, &ptr);
2219     put_uint32(protocol, &ptr);
2220     *ptr++ = internalPort.b[0];
2221     *ptr++ = internalPort.b[1];
2222     *ptr++ = externalPort.b[0];
2223     *ptr++ = externalPort.b[1];
2224     put_uint32(ttl, &ptr);
2225
2226     err = deliver_request(hdr, *sdRef);     // Will free hdr for us
2227     if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
2228     return err;
2229 }
2230
2231 #if _DNS_SD_LIBDISPATCH
2232 DNSServiceErrorType DNSSD_API DNSServiceSetDispatchQueue
2233 (
2234     DNSServiceRef service,
2235     dispatch_queue_t queue
2236 )
2237 {
2238     int dnssd_fd  = DNSServiceRefSockFD(service);
2239     if (dnssd_fd == dnssd_InvalidSocket) return kDNSServiceErr_BadParam;
2240     if (!queue)
2241     {
2242         syslog(LOG_WARNING, "dnssd_clientstub: DNSServiceSetDispatchQueue dispatch queue NULL");
2243         return kDNSServiceErr_BadParam;
2244     }
2245     if (service->disp_queue)
2246     {
2247         syslog(LOG_WARNING, "dnssd_clientstub DNSServiceSetDispatchQueue dispatch queue set already");
2248         return kDNSServiceErr_BadParam;
2249     }
2250     if (service->disp_source)
2251     {
2252         syslog(LOG_WARNING, "DNSServiceSetDispatchQueue dispatch source set already");
2253         return kDNSServiceErr_BadParam;
2254     }
2255     service->disp_source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, dnssd_fd, 0, queue);
2256     if (!service->disp_source)
2257     {
2258         syslog(LOG_WARNING, "DNSServiceSetDispatchQueue dispatch_source_create failed");
2259         return kDNSServiceErr_NoMemory;
2260     }
2261     service->disp_queue = queue;
2262     dispatch_source_set_event_handler(service->disp_source, ^{DNSServiceProcessResult(service);});
2263     dispatch_source_set_cancel_handler(service->disp_source, ^{dnssd_close(dnssd_fd);});
2264     dispatch_resume(service->disp_source);
2265     return kDNSServiceErr_NoError;
2266 }
2267 #endif // _DNS_SD_LIBDISPATCH
2268
2269 #if !defined(_WIN32)
2270
2271 static void DNSSD_API SleepKeepaliveCallback(DNSServiceRef sdRef, DNSRecordRef rec, const DNSServiceFlags flags,
2272                                              DNSServiceErrorType errorCode, void *context)
2273 {
2274     SleepKAContext *ka = (SleepKAContext *)context;
2275     (void)rec;      // Unused
2276     (void)flags;    // Unused
2277
2278     if (sdRef->kacontext != context)
2279         syslog(LOG_WARNING, "SleepKeepaliveCallback context mismatch");
2280
2281     if (ka->AppCallback)
2282         ((DNSServiceSleepKeepaliveReply)ka->AppCallback)(sdRef, errorCode, ka->AppContext);
2283 }
2284
2285 DNSServiceErrorType DNSSD_API DNSServiceSleepKeepalive
2286 (
2287     DNSServiceRef                       *sdRef,
2288     DNSServiceFlags flags,
2289     int fd,
2290     unsigned int timeout,
2291     DNSServiceSleepKeepaliveReply callBack,
2292     void                                *context
2293 )
2294 {
2295     char source_str[INET6_ADDRSTRLEN];
2296     char target_str[INET6_ADDRSTRLEN];
2297     struct sockaddr_storage lss;
2298     struct sockaddr_storage rss;
2299     socklen_t len1, len2;
2300     unsigned int len, proxyreclen;
2301     char buf[256];
2302     DNSServiceErrorType err;
2303     DNSRecordRef record = NULL;
2304     char name[10];
2305     char recname[128];
2306     SleepKAContext *ka;
2307     unsigned int i, unique;
2308
2309
2310     (void) flags; //unused
2311     if (!timeout) return kDNSServiceErr_BadParam;
2312
2313
2314     len1 = sizeof(lss);
2315     if (getsockname(fd, (struct sockaddr *)&lss, &len1) < 0)
2316     {
2317         syslog(LOG_WARNING, "DNSServiceSleepKeepalive: getsockname %d\n", errno);
2318         return kDNSServiceErr_BadParam;
2319     }
2320
2321     len2 = sizeof(rss);
2322     if (getpeername(fd, (struct sockaddr *)&rss, &len2) < 0)
2323     {
2324         syslog(LOG_WARNING, "DNSServiceSleepKeepalive: getpeername %d\n", errno);
2325         return kDNSServiceErr_BadParam;
2326     }
2327
2328     if (len1 != len2)
2329     {
2330         syslog(LOG_WARNING, "DNSServiceSleepKeepalive local/remote info not same");
2331         return kDNSServiceErr_Unknown;
2332     }
2333
2334     unique = 0;
2335     if (lss.ss_family == AF_INET)
2336     {
2337         struct sockaddr_in *sl = (struct sockaddr_in *)&lss;
2338         struct sockaddr_in *sr = (struct sockaddr_in *)&rss;
2339         unsigned char *ptr = (unsigned char *)&sl->sin_addr;
2340
2341         if (!inet_ntop(AF_INET, (const void *)&sr->sin_addr, target_str, sizeof (target_str)))
2342         {
2343             syslog(LOG_WARNING, "DNSServiceSleepKeepalive remote info failed %d", errno);
2344             return kDNSServiceErr_Unknown;
2345         }
2346         if (!inet_ntop(AF_INET, (const void *)&sl->sin_addr, source_str, sizeof (source_str)))
2347         {
2348             syslog(LOG_WARNING, "DNSServiceSleepKeepalive local info failed %d", errno);
2349             return kDNSServiceErr_Unknown;
2350         }
2351         // Sum of all bytes in the local address and port should result in a unique
2352         // number in the local network
2353         for (i = 0; i < sizeof(struct in_addr); i++)
2354             unique += ptr[i];
2355         unique += sl->sin_port;
2356         len = snprintf(buf+1, sizeof(buf) - 1, "t=%u h=%s d=%s l=%u r=%u", timeout, source_str, target_str, ntohs(sl->sin_port), ntohs(sr->sin_port));
2357     }
2358     else
2359     {
2360         struct sockaddr_in6 *sl6 = (struct sockaddr_in6 *)&lss;
2361         struct sockaddr_in6 *sr6 = (struct sockaddr_in6 *)&rss;
2362         unsigned char *ptr = (unsigned char *)&sl6->sin6_addr;
2363
2364         if (!inet_ntop(AF_INET6, (const void *)&sr6->sin6_addr, target_str, sizeof (target_str)))
2365         {
2366             syslog(LOG_WARNING, "DNSServiceSleepKeepalive remote6 info failed %d", errno);
2367             return kDNSServiceErr_Unknown;
2368         }
2369         if (!inet_ntop(AF_INET6, (const void *)&sl6->sin6_addr, source_str, sizeof (source_str)))
2370         {
2371             syslog(LOG_WARNING, "DNSServiceSleepKeepalive local6 info failed %d", errno);
2372             return kDNSServiceErr_Unknown;
2373         }
2374         for (i = 0; i < sizeof(struct in6_addr); i++)
2375             unique += ptr[i];
2376         unique += sl6->sin6_port;
2377         len = snprintf(buf+1, sizeof(buf) - 1, "t=%u H=%s D=%s l=%u r=%u", timeout, source_str, target_str, ntohs(sl6->sin6_port), ntohs(sr6->sin6_port));
2378     }
2379
2380     if (len >= (sizeof(buf) - 1))
2381     {
2382         syslog(LOG_WARNING, "DNSServiceSleepKeepalive could not fit local/remote info");
2383         return kDNSServiceErr_Unknown;
2384     }
2385     // Include the NULL byte also in the first byte. The total length of the record includes the
2386     // first byte also.
2387     buf[0] = len + 1;
2388     proxyreclen = len + 2;
2389
2390     len = snprintf(name, sizeof(name), "%u", unique);
2391     if (len >= sizeof(name))
2392     {
2393         syslog(LOG_WARNING, "DNSServiceSleepKeepalive could not fit unique");
2394         return kDNSServiceErr_Unknown;
2395     }
2396
2397     len = snprintf(recname, sizeof(recname), "%s.%s", name, "_keepalive._dns-sd._udp.local");
2398     if (len >= sizeof(recname))
2399     {
2400         syslog(LOG_WARNING, "DNSServiceSleepKeepalive could not fit name");
2401         return kDNSServiceErr_Unknown;
2402     }
2403
2404     ka = malloc(sizeof(SleepKAContext));
2405     if (!ka) return kDNSServiceErr_NoMemory;
2406     ka->AppCallback = callBack;
2407     ka->AppContext = context;
2408
2409     err = DNSServiceCreateConnection(sdRef);
2410     if (err)
2411     {
2412         syslog(LOG_WARNING, "DNSServiceSleepKeepalive cannot create connection");
2413         free(ka);
2414         return err;
2415     }
2416
2417     // we don't care about the "record". When sdRef gets deallocated later, it will be freed too
2418     err = DNSServiceRegisterRecord(*sdRef, &record, kDNSServiceFlagsUnique, 0, recname,
2419                                    kDNSServiceType_NULL,  kDNSServiceClass_IN, proxyreclen, buf,  kDNSServiceInterfaceIndexAny, SleepKeepaliveCallback, ka);
2420     if (err)
2421     {
2422         syslog(LOG_WARNING, "DNSServiceSleepKeepalive cannot create connection");
2423         free(ka);
2424         return err;
2425     }
2426     (*sdRef)->kacontext = ka;
2427     return kDNSServiceErr_NoError;
2428 }
2429 #endif