#pragma ident "%Z%%M% %I% %E% SMI"

#if defined(_WIN32)

#include <process.h>

#define MDNS_LAZY_REGISTER_SEARCH_DOMAINS

#define dnssd_strerror(X) win32_strerror(X)

#define usleep(X) Sleep(((X)+999)/1000)

static char * win32_strerror(int inErrorCode);

#else

#include <fcntl.h>

#include <errno.h>

#include <sys/ioctl.h>

#include <sys/types.h>

#include <sys/time.h>

#include <sys/resource.h>

#define dnssd_strerror(X) strerror(X)

#endif

#include <stdlib.h>

#include <stdio.h>

#include "mDNSEmbeddedAPI.h"

#include "DNSCommon.h"

#include "uds_daemon.h"

#include "dns_sd.h"

#include "dnssd_ipc.h"

#ifdef __MACOSX__

#include <sys/ucred.h>

#ifndef LOCAL_PEERCRED

#define LOCAL_PEERCRED 0x001 /* retrieve peer credentials */

#endif // LOCAL_PEERCRED

#endif //__MACOSX__

#if defined(MDNS_LAZY_REGISTER_SEARCH_DOMAINS)

extern mStatus dDNS_RegisterSearchDomains( mDNS * const m );

#endif

typedef enum

{

t_uninitialized,

t_morecoming,

t_complete,

t_error,

t_terminated

} transfer_state;

typedef void (*req_termination_fn)(void *);

typedef struct registered_record_entry

{

uint32_t key;

AuthRecord *rr;

struct registered_record_entry *next;

client_context_t client_context;

struct request_state *rstate;

} registered_record_entry;

typedef struct service_instance

{

struct service_instance *next;

mDNSBool autoname; // Set if this name is tied to the Computer Name

mDNSBool autorename; // Set if this client wants us to automatically rename on conflict

mDNSBool allowremotequery; // Respond to unicast queries from outside the local link?

mDNSBool rename_on_memfree; // Set on config change when we deregister original name

domainlabel name;

domainname domain;

mDNSBool default_local; // is this the "local." from an empty-string registration?

struct request_state *request;

dnssd_sock_t sd;

AuthRecord *subtypes;

ServiceRecordSet srs; // note - must be last field in struct

} service_instance;

typedef struct

{

uint16_t txtlen;

void *txtdata;

mDNSIPPort port;

domainlabel name;

char type_as_string[MAX_ESCAPED_DOMAIN_NAME];

domainname type;

mDNSBool default_domain;

domainname host;

mDNSBool autoname; // Set if this name is tied to the Computer Name

mDNSBool autorename; // Set if this client wants us to automatically rename on conflict

mDNSBool allowremotequery; // Respond to unicast queries from outside the local link?

int num_subtypes;

mDNSInterfaceID InterfaceID;

service_instance *instances;

struct request_state *request;

} service_info;

typedef struct browser_t

{

DNSQuestion q;

domainname domain;

struct browser_t *next;

} browser_t;

typedef struct

{

mDNSBool default_domain;

mDNSBool ForceMCast;

domainname regtype;

mDNSInterfaceID interface_id;

struct request_state *rstate;

browser_t *browsers;

} browser_info_t;

typedef struct

{

mStatus err; // Note: This field is in NETWORK byte order

int nwritten;

dnssd_sock_t sd;

} undelivered_error_t;

typedef struct request_state

{

// connection structures

dnssd_sock_t sd;

// state of read (in case message is read over several recv() calls)

transfer_state ts;

uint32_t hdr_bytes; // bytes of header already read

ipc_msg_hdr hdr;

uint32_t data_bytes; // bytes of message data already read

char *msgbuf; // pointer to data storage to pass to free()

char *msgdata; // pointer to data to be read from (may be modified)

int bufsize; // size of data storage

// reply, termination, error, and client context info

int no_reply; // don't send asynchronous replies to client

int time_blocked; // record time of a blocked client

void *client_context; // don't touch this - pointer only valid in client's addr space

struct reply_state *replies; // corresponding (active) reply list

undelivered_error_t *u_err;

void *termination_context;

req_termination_fn terminate;

//!!!KRS toss these pointers in a union

// registration context associated with this request (null if not applicable)

registered_record_entry *reg_recs; // muliple registrations for a connection-oriented request

service_info *service_registration;

browser_info_t *browser_info;

struct request_state *next;

} request_state;

typedef struct

{

DNSServiceFlags flags; // Note: This field is in NETWORK byte order

uint32_t ifi; // Note: This field is in NETWORK byte order

DNSServiceErrorType error; // Note: This field is in NETWORK byte order

} reply_hdr;

typedef struct reply_state

{

// state of the transmission

dnssd_sock_t sd;

transfer_state ts;

uint32_t nwriten;

uint32_t len;

// context of the reply

struct request_state *request; // the request that this answers

struct reply_state *next; // if there are multiple unsent replies

// pointer into message buffer - allows fields to be changed after message is formatted

ipc_msg_hdr *mhdr;

reply_hdr *rhdr;

char *sdata; // pointer to start of call-specific data

// pointer to malloc'd buffer

char *msgbuf;

} reply_state;

typedef struct

{

DNSQuestion question;

mDNS_DomainType type;

request_state *rstate;

} domain_enum_t;

typedef struct

{

domain_enum_t *all;

domain_enum_t *def;

request_state *rstate;

} enum_termination_t;

typedef struct

{

request_state *rstate;

DNSQuestion qtxt;

DNSQuestion qsrv;

// const ResourceRecord *txt;

// const ResourceRecord *srv;

mDNSBool srv;

mDNSBool txt;

rdataSRV srvdata;

mDNSu16 txtlen;

mDNSu8 txtdata[AbsoluteMaxDNSMessageData];

} resolve_termination_t;

#ifdef _HAVE_SETDOMAIN_SUPPORT_

typedef struct default_browse_list_t

{

struct default_browse_list_t *next;

uid_t uid;

AuthRecord ptr_rec;

} default_browse_list_t;

static default_browse_list_t *default_browse_list = NULL;

#endif // _HAVE_SETDOMAIN_SUPPORT_

mDNSexport mDNS mDNSStorage;

#define gmDNS (&mDNSStorage)

static dnssd_sock_t listenfd = dnssd_InvalidSocket;

static request_state * all_requests = NULL;

#define MAX_TIME_BLOCKED 60 * mDNSPlatformOneSecond // try to send data to a blocked client for 60 seconds before

// terminating connection

#define MSG_PAD_BYTES 5 // pad message buffer (read from client) with n zero'd bytes to guarantee

// n get_string() calls w/o buffer overrun

mDNSlocal void connect_callback(void *info);

mDNSlocal int read_msg(request_state *rs);

mDNSlocal int send_msg(reply_state *rs);

mDNSlocal void abort_request(request_state *rs);

mDNSlocal void request_callback(void *info);

mDNSlocal void handle_resolve_request(request_state *rstate);

mDNSlocal void question_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord);

mDNSlocal void question_termination_callback(void *context);

mDNSlocal void handle_browse_request(request_state *request);

mDNSlocal void browse_termination_callback(void *context);

mDNSlocal void handle_regservice_request(request_state *request);

mDNSlocal void regservice_termination_callback(void *context);

mDNSlocal void regservice_callback(mDNS *const m, ServiceRecordSet *const srs, mStatus result);

mDNSlocal mStatus handle_add_request(request_state *rstate);

mDNSlocal mStatus handle_update_request(request_state *rstate);

mDNSlocal void append_reply(request_state *req, reply_state *rep);

mDNSlocal int build_domainname_from_strings(domainname *srv, char *name, char *regtype, char *domain);

mDNSlocal void enum_termination_callback(void *context);

mDNSlocal void enum_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord);

mDNSlocal void handle_query_request(request_state *rstate);

mDNSlocal reply_state *format_enumeration_reply(request_state *rstate, const char *domain, DNSServiceFlags flags, uint32_t ifi, DNSServiceErrorType err);

mDNSlocal void handle_enum_request(request_state *rstate);

mDNSlocal mStatus handle_regrecord_request(request_state *rstate);

mDNSlocal void regrecord_callback(mDNS *const m, AuthRecord * rr, mStatus result);

mDNSlocal void connected_registration_termination(void *context);

mDNSlocal void handle_reconfirm_request(request_state *rstate);

mDNSlocal AuthRecord *read_rr_from_ipc_msg(char *msgbuf, int ttl, int validate_flags);

mDNSlocal mStatus handle_removerecord_request(request_state *rstate);

mDNSlocal void reset_connected_rstate(request_state *rstate);

mDNSlocal int deliver_error(request_state *rstate, mStatus err);

mDNSlocal int deliver_async_error(request_state *rs, reply_op_t op, mStatus err);

mDNSlocal transfer_state send_undelivered_error(request_state *rs);

mDNSlocal reply_state *create_reply(reply_op_t op, size_t datalen, request_state *request);

mDNSlocal void update_callback(mDNS *const m, AuthRecord *const rr, RData *oldrd);

mDNSlocal void my_perror(char *errmsg);

mDNSlocal void unlink_request(request_state *rs);

mDNSlocal void resolve_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord);

mDNSlocal void resolve_termination_callback(void *context);

mDNSlocal int validate_message(request_state *rstate);

mDNSlocal mStatus remove_extra(request_state *rstate, service_instance *serv);

mDNSlocal mStatus remove_record(request_state *rstate);

mDNSlocal void free_service_instance(service_instance *srv);

mDNSlocal uint32_t dnssd_htonl(uint32_t l);

mDNSlocal void handle_setdomain_request(request_state *rstate);

#ifndef PID_FILE

#define PID_FILE "/var/run/mDNSResponder.pid"

#endif

mDNSlocal void LogClientInfo(request_state *req)

{

void *t = req->termination_context;

if (t)

{

if (req->terminate == regservice_termination_callback)

{

service_instance *ptr;

for (ptr = ((service_info *)t)->instances; ptr; ptr = ptr->next)

LogMsgNoIdent("%3d: DNSServiceRegister %##s %u", req->sd, ptr->srs.RR_SRV.resrec.name->c, SRS_PORT(&ptr->srs));

}

else if (req->terminate == browse_termination_callback)

{

browser_t *blist;

for (blist = req->browser_info->browsers; blist; blist = blist->next)

LogMsgNoIdent("%3d: DNSServiceBrowse %##s", req->sd, blist->q.qname.c);

}

else if (req->terminate == resolve_termination_callback)

LogMsgNoIdent("%3d: DNSServiceResolve %##s", req->sd, ((resolve_termination_t *)t)->qsrv.qname.c);

else if (req->terminate == question_termination_callback)

LogMsgNoIdent("%3d: DNSServiceQueryRecord %##s", req->sd, ((DNSQuestion *) t)->qname.c);

else if (req->terminate == enum_termination_callback)

LogMsgNoIdent("%3d: DNSServiceEnumerateDomains %##s", req->sd, ((enum_termination_t *) t)->all->question.qname.c);

}

}

mDNSlocal void FatalError(char *errmsg)

{

LogMsg("%s: %s", errmsg, dnssd_strerror(dnssd_errno()));

*(long*)0 = 0; // On OS X abort() doesn't generate a crash log, but writing to zero does

abort(); // On platforms where writing to zero doesn't generate an exception, abort instead

}

int udsserver_init(void)

{

dnssd_sockaddr_t laddr;

int ret;

#if defined(_WIN32)

u_long opt = 1;

#endif

// If a particular platform wants to opt out of having a PID file, define PID_FILE to be ""

if (PID_FILE[0])

{

FILE *fp = fopen(PID_FILE, "w");

if (fp != NULL)

{

fprintf(fp, "%d\n", getpid());

fclose(fp);

}

}

if ((listenfd = socket(AF_DNSSD, SOCK_STREAM, 0)) == dnssd_InvalidSocket)

{

my_perror("ERROR: socket(AF_DNSSD, SOCK_STREAM, 0); failed");

goto error;

}

bzero(&laddr, sizeof(laddr));

#if defined(USE_TCP_LOOPBACK)

{

laddr.sin_family = AF_INET;

laddr.sin_port = htons(MDNS_TCP_SERVERPORT);

laddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);

ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));

if (ret < 0)

{

my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");

goto error;

}

}

#else

{

mode_t mask = umask(0);

unlink(MDNS_UDS_SERVERPATH); //OK if this fails

laddr.sun_family = AF_LOCAL;

#ifndef NOT_HAVE_SA_LEN

// According to Stevens (section 3.2), there is no portable way to

// determine whether sa_len is defined on a particular platform.

laddr.sun_len = sizeof(struct sockaddr_un);

#endif

strcpy(laddr.sun_path, MDNS_UDS_SERVERPATH);

ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));

umask(mask);

if (ret < 0)

{

my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");

goto error;

}

}

#endif

#if defined(_WIN32)

//

// SEH: do we even need to do this on windows? this socket

// will be given to WSAEventSelect which will automatically

// set it to non-blocking

//

if (ioctlsocket(listenfd, FIONBIO, &opt) != 0)

#else

if (fcntl(listenfd, F_SETFL, O_NONBLOCK) != 0)

#endif

{

my_perror("ERROR: could not set listen socket to non-blocking mode");

goto error;

}

if (listen(listenfd, LISTENQ) != 0)

{

my_perror("ERROR: could not listen on listen socket");

goto error;

}

if (mStatus_NoError != udsSupportAddFDToEventLoop(listenfd, connect_callback, (void *) NULL))

{

my_perror("ERROR: could not add listen socket to event loop");

goto error;

}

#if !defined(PLATFORM_NO_RLIMIT)

{

// Set maximum number of open file descriptors

#define MIN_OPENFILES 10240

struct rlimit maxfds, newfds;

// Due to bugs in OS X (<rdar://problem/2941095>, <rdar://problem/3342704>, <rdar://problem/3839173>)

// you have to get and set rlimits once before getrlimit will return sensible values

if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }

if (setrlimit(RLIMIT_NOFILE, &maxfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");

if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }

newfds.rlim_max = (maxfds.rlim_max > MIN_OPENFILES) ? maxfds.rlim_max : MIN_OPENFILES;

newfds.rlim_cur = (maxfds.rlim_cur > MIN_OPENFILES) ? maxfds.rlim_cur : MIN_OPENFILES;

if (newfds.rlim_max != maxfds.rlim_max || newfds.rlim_cur != maxfds.rlim_cur)

if (setrlimit(RLIMIT_NOFILE, &newfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");

if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }

debugf("maxfds.rlim_max %d", (long)maxfds.rlim_max);

debugf("maxfds.rlim_cur %d", (long)maxfds.rlim_cur);

}

#endif

return 0;

error:

my_perror("ERROR: udsserver_init");

return -1;

}

int udsserver_exit(void)

{

dnssd_close(listenfd);

#if !defined(USE_TCP_LOOPBACK)

// Currently, we're unable to remove /var/run/mdnsd because we've changed to userid "nobody"

// to give up unnecessary privilege, but we need to be root to remove this Unix Domain Socket.

// It would be nice if we could find a solution to this problem

if (unlink(MDNS_UDS_SERVERPATH))

debugf("Unable to remove %s", MDNS_UDS_SERVERPATH);

#endif

if (PID_FILE[0]) unlink(PID_FILE);

return 0;

}

mDNSs32 udsserver_idle(mDNSs32 nextevent)

{

request_state *req = all_requests, *tmp, *prev = NULL;

reply_state *fptr;

transfer_state result;

mDNSs32 now = mDNS_TimeNow(&mDNSStorage);

while(req)

{

result = t_uninitialized;

if (req->u_err)

result = send_undelivered_error(req);

if (result != t_error && result != t_morecoming && // don't try to send msg if send_error failed

(req->ts == t_complete || req->ts == t_morecoming))

{

while(req->replies)

{

if (req->replies->next) req->replies->rhdr->flags |= dnssd_htonl(kDNSServiceFlagsMoreComing);

result = send_msg(req->replies);

if (result == t_complete)

{

fptr = req->replies;

req->replies = req->replies->next;

freeL("udsserver_idle", fptr);

req->time_blocked = 0; // reset failure counter after successful send

}

else if (result == t_terminated || result == t_error)

{

abort_request(req);

break;

}

else if (result == t_morecoming) break; // client's queues are full, move to next

}

}

if (result == t_morecoming)

{

if (!req->time_blocked) req->time_blocked = now;

debugf("udsserver_idle: client has been blocked for %ld seconds", (now - req->time_blocked) / mDNSPlatformOneSecond);

if (now - req->time_blocked >= MAX_TIME_BLOCKED)

{

LogMsg("Could not write data to client %d after %ld seconds - aborting connection", req->sd, MAX_TIME_BLOCKED / mDNSPlatformOneSecond);

LogClientInfo(req);

abort_request(req);

result = t_terminated;

}

else if (nextevent - now > mDNSPlatformOneSecond) nextevent = now + mDNSPlatformOneSecond; // try again in a second

}

if (result == t_terminated || result == t_error)

//since we're already doing a list traversal, we unlink the request manually instead of calling unlink_request()

{

tmp = req;

if (prev) prev->next = req->next;

if (req == all_requests) all_requests = all_requests->next;

req = req->next;

freeL("udsserver_idle", tmp);

}

else

{

prev = req;

req = req->next;

}

}

return nextevent;

}

mDNSexport void udsserver_info(mDNS *const m)

{

mDNSs32 now = mDNS_TimeNow(m);

mDNSu32 CacheUsed = 0, CacheActive = 0;

mDNSu32 slot;

CacheGroup *cg;

CacheRecord *rr;

request_state *req;

LogMsgNoIdent("Timenow 0x%08lX (%ld)", (mDNSu32)now, now);

LogMsgNoIdent("Slt Q TTL U Type if len rdata");

for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)

for(cg = m->rrcache_hash[slot]; cg; cg=cg->next)

{

CacheUsed++; // Count one cache entity for the CacheGroup object

for (rr = cg->members; rr; rr=rr->next)

{

mDNSs32 remain = rr->resrec.rroriginalttl - (now - rr->TimeRcvd) / mDNSPlatformOneSecond;

CacheUsed++;

if (rr->CRActiveQuestion) CacheActive++;

LogMsgNoIdent("%3d %s%6ld %s %-6s%-6s%s",

slot,

rr->CRActiveQuestion ? "*" : " ",

remain,

(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ? "-" : " ",

DNSTypeName(rr->resrec.rrtype),

((NetworkInterfaceInfo *)rr->resrec.InterfaceID)->ifname,

CRDisplayString(m, rr));

usleep(1000); // Limit rate a little so we don't flood syslog too fast

}

}

if (m->rrcache_totalused != CacheUsed)

LogMsgNoIdent("Cache use mismatch: rrcache_totalused is %lu, true count %lu", m->rrcache_totalused, CacheUsed);

if (m->rrcache_active != CacheActive)

LogMsgNoIdent("Cache use mismatch: rrcache_active is %lu, true count %lu", m->rrcache_active, CacheActive);

LogMsgNoIdent("Cache currently contains %lu records; %lu referenced by active questions", CacheUsed, CacheActive);

for (req = all_requests; req; req=req->next)

LogClientInfo(req);

now = mDNS_TimeNow(m);

LogMsgNoIdent("Timenow 0x%08lX (%ld)", (mDNSu32)now, now);

}

#if __MACOSX__ && MACOSX_MDNS_MALLOC_DEBUGGING

mDNSexport void uds_validatelists(void)

{

request_state *req;

for (req = all_requests; req; req=req->next)

if (req->sd < 0 && req->sd != -2)

LogMemCorruption("UDS request list: %p is garbage (%X)", req, req->sd);

}

#endif

mDNSlocal void rename_service(service_instance *srv)

{

if (srv->autoname && !SameDomainLabel(srv->name.c, gmDNS->nicelabel.c))

{

srv->rename_on_memfree = 1;

if (mDNS_DeregisterService(gmDNS, &srv->srs)) // If service deregistered already, we can re-register immediately

regservice_callback(gmDNS, &srv->srs, mStatus_MemFree);

}

}

mDNSexport void udsserver_handle_configchange(void)

{

request_state *req;

for (req = all_requests; req; req = req->next)

{

if (req->service_registration)

{

service_instance *ptr;

for (ptr = req->service_registration->instances; ptr; ptr = ptr->next)

rename_service(ptr);

}

}

}

mDNSlocal void connect_callback(void *info)

{

dnssd_sock_t sd;

dnssd_socklen_t len;

unsigned long optval;

dnssd_sockaddr_t cliaddr;

request_state *rstate;

(void)info; // Unused

len = (dnssd_socklen_t) sizeof(cliaddr);

sd = accept(listenfd, (struct sockaddr*) &cliaddr, &len);

if (sd == dnssd_InvalidSocket)

{

if (dnssd_errno() == dnssd_EWOULDBLOCK) return;

my_perror("ERROR: accept");

return;

}

optval = 1;

#ifdef SO_NOSIGPIPE

// Some environments (e.g. OS X) support turning off SIGPIPE for a socket

if (setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)) < 0)

{

my_perror("ERROR: setsockopt - SO_NOSIGPIPE - aborting client");

dnssd_close(sd);

return;

}

#endif

#if defined(_WIN32)

if (ioctlsocket(sd, FIONBIO, &optval) != 0)

#else

if (fcntl(sd, F_SETFL, O_NONBLOCK) != 0)

#endif

{

my_perror("ERROR: fcntl(sd, F_SETFL, O_NONBLOCK) - aborting client");

dnssd_close(sd);

return;

}

// allocate a request_state struct that will live with the socket

rstate = mallocL("connect_callback", sizeof(request_state));

if (!rstate) FatalError("ERROR: malloc");

bzero(rstate, sizeof(request_state));

rstate->ts = t_morecoming;

rstate->sd = sd;

LogOperation("%3d: Adding FD", rstate->sd);

if ( mStatus_NoError != udsSupportAddFDToEventLoop( sd, request_callback, rstate))

return;

rstate->next = all_requests;

all_requests = rstate;

}

mDNSlocal void request_callback(void *info)

{

request_state *rstate = info;

transfer_state result;

dnssd_sockaddr_t cliaddr;

int dedicated_error_socket;

#if defined(_WIN32)

u_long opt = 1;

#endif

result = read_msg(rstate);

if (result == t_morecoming)

{

return;

}

if (result == t_terminated)

{

abort_request(rstate);

unlink_request(rstate);

return;

}

if (result == t_error)

{

abort_request(rstate);

unlink_request(rstate);

return;

}

if (rstate->hdr.version != VERSION)

{

LogMsg("ERROR: client incompatible with daemon (client version = %d, "

"daemon version = %d)\n", rstate->hdr.version, VERSION);

abort_request(rstate);

unlink_request(rstate);

return;

}

if (validate_message(rstate) < 0)

{

// note that we cannot deliver an error message if validation fails, since the path to the error socket

// may be contained in the (invalid) message body for some message types

abort_request(rstate);

unlink_request(rstate);

LogMsg("Invalid message sent by client - may indicate a malicious program running on this machine!");

return;

}

// check if client wants silent operation

if (rstate->hdr.flags & IPC_FLAGS_NOREPLY) rstate->no_reply = 1;

dedicated_error_socket = (rstate->hdr.op == reg_record_request || rstate->hdr.op == add_record_request ||

rstate->hdr.op == update_record_request || rstate->hdr.op == remove_record_request);

if (((rstate->hdr.flags & IPC_FLAGS_REUSE_SOCKET) == 0) != dedicated_error_socket)

LogMsg("WARNING: client request %d with incorrect flags setting 0x%X", rstate->hdr.op, rstate->hdr.flags);

// check if primary socket is to be used for synchronous errors, else open new socket

if (dedicated_error_socket)

{

mStatus err = 0;

int nwritten;

dnssd_sock_t errfd = socket(AF_DNSSD, SOCK_STREAM, 0);

if (errfd == dnssd_InvalidSocket)

{

my_perror("ERROR: socket");

abort_request(rstate);

unlink_request(rstate);

return;

}

//LogOperation("request_callback: Opened dedicated errfd %d", errfd);

#if defined(USE_TCP_LOOPBACK)

{

mDNSOpaque16 port;

port.b[0] = rstate->msgdata[0];

port.b[1] = rstate->msgdata[1];

rstate->msgdata += 2;

cliaddr.sin_family = AF_INET;

cliaddr.sin_port = port.NotAnInteger;

cliaddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);

}

#else

{

char ctrl_path[MAX_CTLPATH];

get_string(&rstate->msgdata, ctrl_path, 256); // path is first element in message buffer

bzero(&cliaddr, sizeof(cliaddr));

cliaddr.sun_family = AF_LOCAL;

strcpy(cliaddr.sun_path, ctrl_path);

}

#endif

//LogOperation("request_callback: Connecting to “%s”", cliaddr.sun_path);

if (connect(errfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) < 0)

{

//LogOperation("request_callback: Couldn't connect to “%s”", cliaddr.sun_path);

my_perror("ERROR: connect");

abort_request(rstate);

unlink_request(rstate);

return;

}

#if defined(_WIN32)

if (ioctlsocket(errfd, FIONBIO, &opt) != 0)

#else

if (fcntl(errfd, F_SETFL, O_NONBLOCK) != 0)

#endif

{

my_perror("ERROR: could not set control socket to non-blocking mode");

abort_request(rstate);

unlink_request(rstate);

return;

}

switch(rstate->hdr.op)

{

case reg_record_request: err = handle_regrecord_request (rstate); break;

case add_record_request: err = handle_add_request (rstate); break;

case update_record_request: err = handle_update_request (rstate); break;

case remove_record_request: err = handle_removerecord_request(rstate); break;

default: LogMsg("%3d: ERROR: udsserver_recv_request - unsupported request type: %d", rstate->sd, rstate->hdr.op);

}

//LogOperation("request_callback: Returning error code %d on socket %d", err, errfd);

err = dnssd_htonl(err);

nwritten = send(errfd, (dnssd_sockbuf_t) &err, sizeof(err), 0);

// On a freshly-created Unix Domain Socket, the kernel should *never* fail to buffer a four-byte write for us.

// If not, we don't attempt to handle this failure, but we do log it.

if (nwritten < (int)sizeof(err))

LogMsg("ERROR: failed to write error response back to caller: %d %d %s",

nwritten, dnssd_errno(), dnssd_strerror(dnssd_errno()));

//else LogOperation("request_callback: Returned error code %d on socket %d", err, errfd);

dnssd_close(errfd);

//LogOperation("request_callback: Closed errfd %d", errfd);

reset_connected_rstate(rstate); // Reset ready to accept the next request on this pipe

}

else

{

switch(rstate->hdr.op)

{

case resolve_request: handle_resolve_request (rstate); break;

case query_request: handle_query_request (rstate); break;

case browse_request: handle_browse_request (rstate); break;

case reg_service_request: handle_regservice_request(rstate); break;

case enumeration_request: handle_enum_request (rstate); break;

case reconfirm_record_request: handle_reconfirm_request (rstate); break;

case setdomain_request: handle_setdomain_request (rstate); break;

default: LogMsg("%3d: ERROR: udsserver_recv_request - unsupported request type: %d", rstate->sd, rstate->hdr.op);

}

}

}

mDNSlocal void handle_query_request(request_state *rstate)

{

DNSServiceFlags flags;

uint32_t ifi;

char name[256];

uint16_t rrtype, rrclass;

char *ptr;

mStatus result;

mDNSInterfaceID InterfaceID;

DNSQuestion *q;

if (rstate->ts != t_complete)

{

LogMsg("ERROR: handle_query_request - transfer state != t_complete");

goto error;

}

ptr = rstate->msgdata;

if (!ptr)

{

LogMsg("ERROR: handle_query_request - NULL msgdata");

goto error;

}

flags = get_flags(&ptr);

ifi = get_long(&ptr);

if (get_string(&ptr, name, 256) < 0) goto bad_param;

rrtype = get_short(&ptr);

rrclass = get_short(&ptr);

InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(gmDNS, ifi);

if (ifi && !InterfaceID) goto bad_param;

q = mallocL("DNSQuestion", sizeof(DNSQuestion));

if (!q) FatalError("ERROR: handle_query - malloc");

bzero(q, sizeof(DNSQuestion));

q->InterfaceID = InterfaceID;

q->Target = zeroAddr;

if (!MakeDomainNameFromDNSNameString(&q->qname, name)) { freeL("DNSQuestion", q); goto bad_param; }

q->qtype = rrtype;

q->qclass = rrclass;

q->LongLived = (flags & kDNSServiceFlagsLongLivedQuery) != 0;

q->ExpectUnique = mDNSfalse;

q->ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;

q->ReturnCNAME = (flags & kDNSServiceFlagsReturnCNAME) != 0;

q->QuestionCallback = question_result_callback;

q->QuestionContext = rstate;

rstate->termination_context = q;

rstate->terminate = question_termination_callback;

LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) START", rstate->sd, q->qname.c, DNSTypeName(q->qtype));

result = mDNS_StartQuery(gmDNS, q);

if (result != mStatus_NoError) LogMsg("ERROR: mDNS_StartQuery: %d", (int)result);

if (result) rstate->terminate = NULL;

if (deliver_error(rstate, result) < 0) goto error;

return;

bad_param:

deliver_error(rstate, mStatus_BadParamErr);

rstate->terminate = NULL; // don't try to terminate insuccessful Core calls

error:

abort_request(rstate);

unlink_request(rstate);

return;

}

mDNSlocal void handle_resolve_request(request_state *rstate)

{

DNSServiceFlags flags;

uint32_t interfaceIndex;

mDNSInterfaceID InterfaceID;

char name[256], regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];

char *ptr; // message data pointer

domainname fqdn;

resolve_termination_t *term;

mStatus err;

if (rstate->ts != t_complete)

{

LogMsg("ERROR: handle_resolve_request - transfer state != t_complete");

abort_request(rstate);

unlink_request(rstate);

return;

}

// extract the data from the message

ptr = rstate->msgdata;

if (!ptr)

{

LogMsg("ERROR: handle_resolve_request - NULL msgdata");

abort_request(rstate);

unlink_request(rstate);

return;

}

flags = get_flags(&ptr);

interfaceIndex = get_long(&ptr);

InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(gmDNS, interfaceIndex);

if (interfaceIndex && !InterfaceID)

{ LogMsg("ERROR: handle_resolve_request - Couldn't find InterfaceID for interfaceIndex %d", interfaceIndex); goto bad_param; }

if (get_string(&ptr, name, 256) < 0 ||

get_string(&ptr, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||

get_string(&ptr, domain, MAX_ESCAPED_DOMAIN_NAME) < 0)

{ LogMsg("ERROR: handle_resolve_request - Couldn't read name/regtype/domain"); goto bad_param; }

// free memory in rstate since we don't need it anymore

freeL("handle_resolve_request", rstate->msgbuf);

rstate->msgbuf = NULL;

if (build_domainname_from_strings(&fqdn, name, regtype, domain) < 0)

{ LogMsg("ERROR: handle_resolve_request - Couldn't build_domainname_from_strings “%s” “%s” “%s”", name, regtype, domain); goto bad_param; }

// set up termination info

term = mallocL("handle_resolve_request", sizeof(resolve_termination_t));

bzero(term, sizeof(*term));

if (!term) FatalError("ERROR: malloc");

// format questions

term->qsrv.InterfaceID = InterfaceID;

term->qsrv.Target = zeroAddr;

memcpy(&term->qsrv.qname, &fqdn, MAX_DOMAIN_NAME);

term->qsrv.qtype = kDNSType_SRV;

term->qsrv.qclass = kDNSClass_IN;

term->qsrv.LongLived = mDNSfalse;

term->qsrv.ExpectUnique = mDNStrue;

term->qsrv.ForceMCast = mDNSfalse;

term->qsrv.QuestionCallback = resolve_result_callback;

term->qsrv.QuestionContext = rstate;

term->qtxt.InterfaceID = InterfaceID;

term->qtxt.Target = zeroAddr;

memcpy(&term->qtxt.qname, &fqdn, MAX_DOMAIN_NAME);

term->qtxt.qtype = kDNSType_TXT;

term->qtxt.qclass = kDNSClass_IN;

term->qtxt.LongLived = mDNSfalse;

term->qtxt.ExpectUnique = mDNStrue;

term->qtxt.ForceMCast = mDNSfalse;

term->qtxt.QuestionCallback = resolve_result_callback;

term->qtxt.QuestionContext = rstate;

term->rstate = rstate;

rstate->termination_context = term;

rstate->terminate = resolve_termination_callback;

// ask the questions

LogOperation("%3d: DNSServiceResolve(%##s) START", rstate->sd, term->qsrv.qname.c);

err = mDNS_StartQuery(gmDNS, &term->qsrv);

if (!err) err = mDNS_StartQuery(gmDNS, &term->qtxt);

if (err)

{

freeL("handle_resolve_request", term);

rstate->terminate = NULL; // prevent abort_request() from invoking termination callback

}

if (deliver_error(rstate, err) < 0 || err)

{

abort_request(rstate);

unlink_request(rstate);

}

return;

bad_param:

deliver_error(rstate, mStatus_BadParamErr);

abort_request(rstate);

unlink_request(rstate);

}

mDNSlocal void resolve_termination_callback(void *context)

{

resolve_termination_t *term = context;

request_state *rs;

if (!term)

{

LogMsg("ERROR: resolve_termination_callback: double termination");

return;

}

rs = term->rstate;

LogOperation("%3d: DNSServiceResolve(%##s) STOP", rs->sd, term->qtxt.qname.c);

mDNS_StopQuery(gmDNS, &term->qtxt);

mDNS_StopQuery(gmDNS, &term->qsrv);

freeL("resolve_termination_callback", term);

rs->termination_context = NULL;

}

mDNSlocal void resolve_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)

{

size_t len = 0;

char fullname[MAX_ESCAPED_DOMAIN_NAME], target[MAX_ESCAPED_DOMAIN_NAME];

char *data;

transfer_state result;

reply_state *rep;

request_state *rs = question->QuestionContext;

resolve_termination_t *res = rs->termination_context;

(void)m; // Unused

LogOperation("%3d: DNSServiceResolve(%##s, %s) %s %s",

rs->sd, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "ADD" : "RMV", RRDisplayString(m, answer));

// This code used to do this trick of just keeping a copy of the pointer to

// the answer record in the cache, but the unicast query code doesn't currently

// put its answer records in the cache, so for now we can't do this.

if (!AddRecord)

{

// After unicast query code is updated to store its records in the common cache, use this...

// if (answer->rrtype == kDNSType_SRV && res->srv == answer) res->srv = mDNSNULL;

// if (answer->rrtype == kDNSType_TXT && res->txt == answer) res->txt = mDNSNULL;

// intead of this...

if (answer->rrtype == kDNSType_SRV && res->srv && SameRDataBody(answer, (RDataBody *)&res->srvdata))

res->srv = mDNSfalse;

if (answer->rrtype == kDNSType_TXT && res->txt && answer->rdlength == res->txtlen && SameRDataBody(answer, (RDataBody *)&res->txtdata))

res->txt = mDNSfalse;

return;

}

// After unicast query code is updated to store its records in the common cache, use this...

// if (answer->rrtype == kDNSType_SRV) res->srv = answer;

// if (answer->rrtype == kDNSType_TXT) res->txt = answer;

// intead of this...

if (answer->rrtype == kDNSType_SRV)

{

res->srvdata = answer->rdata->u.srv;

res->srv = mDNStrue;

}

if (answer->rrtype == kDNSType_TXT)

{

if (answer->rdlength > AbsoluteMaxDNSMessageData) return;

res->txtlen = answer->rdlength;

mDNSPlatformMemCopy(answer->rdata->u.data, res->txtdata, res->txtlen);

res->txt = mDNStrue;

}

if (!res->txt || !res->srv) return; // only deliver result to client if we have both answers

ConvertDomainNameToCString(answer->name, fullname);

ConvertDomainNameToCString(&res->srvdata.target, target);

// calculate reply length

len += sizeof(DNSServiceFlags);

len += sizeof(uint32_t); // interface index

len += sizeof(DNSServiceErrorType);

len += strlen(fullname) + 1;

len += strlen(target) + 1;

len += 2 * sizeof(uint16_t); // port, txtLen

len += res->txtlen;

// allocate/init reply header

rep = create_reply(resolve_reply_op, len, rs);

rep->rhdr->flags = dnssd_htonl(0);

rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(gmDNS, answer->InterfaceID));

rep->rhdr->error = dnssd_htonl(kDNSServiceErr_NoError);

data = rep->sdata;

// write reply data to message

put_string(fullname, &data);

put_string(target, &data);

*data++ = res->srvdata.port.b[0];

*data++ = res->srvdata.port.b[1];

put_short(res->txtlen, &data);

put_rdata(res->txtlen, res->txtdata, &data);

result = send_msg(rep);

if (result == t_error || result == t_terminated)

{

abort_request(rs);

unlink_request(rs);

freeL("resolve_result_callback", rep);

}

else if (result == t_complete) freeL("resolve_result_callback", rep);

else append_reply(rs, rep);

}

mDNSlocal void question_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)

{

char *data;

char name[MAX_ESCAPED_DOMAIN_NAME];

request_state *req = question->QuestionContext;

reply_state *rep;

size_t len;

(void)m; // Unused

LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) RESULT %s", req->sd, question->qname.c, DNSTypeName(question->qtype), RRDisplayString(m, answer));

//mDNS_StopQuery(m, question);

if (answer->rdlength == 0)

{

deliver_async_error(req, query_reply_op, kDNSServiceErr_NoSuchRecord);

return;

}

// calculate reply data length

len = sizeof(DNSServiceFlags);

len += 2 * sizeof(uint32_t); // if index + ttl

len += sizeof(DNSServiceErrorType);

len += 3 * sizeof(uint16_t); // type, class, rdlen

len += answer->rdlength;

ConvertDomainNameToCString(answer->name, name);

len += strlen(name) + 1;

rep = create_reply(query_reply_op, len, req);

rep->rhdr->flags = dnssd_htonl(AddRecord ? kDNSServiceFlagsAdd : 0);

rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(gmDNS, answer->InterfaceID));

rep->rhdr->error = dnssd_htonl(kDNSServiceErr_NoError);

data = rep->sdata;

put_string(name, &data);

put_short(answer->rrtype, &data);

put_short(answer->rrclass, &data);

put_short(answer->rdlength, &data);

put_rdata(answer->rdlength, answer->rdata->u.data, &data);

put_long(AddRecord ? answer->rroriginalttl : 0, &data);

append_reply(req, rep);

return;

}

mDNSlocal void question_termination_callback(void *context)

{

DNSQuestion *q = context;

LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) STOP", ((request_state *)q->QuestionContext)->sd, q->qname.c, DNSTypeName(q->qtype));

mDNS_StopQuery(gmDNS, q); // no need to error check

freeL("question_termination_callback", q);

}

mDNSlocal char *FindFirstSubType(char *p)

{

while (*p)

{

if (p[0] == '\\' && p[1]) p += 2;

else if (p[0] == ',' && p[1]) { *p++ = 0; return(p); }

else p++;

}

return(p);

}

mDNSlocal char *FindNextSubType(char *p)

{

while (*p)

{

if (p[0] == '\\' && p[1]) // If escape character

p += 2; // ignore following character

else if (p[0] == ',') // If we found a comma

{

if (p[1]) *p++ = 0;

return(p);

}

else if (p[0] == '.')

return(mDNSNULL);

else p++;

}

return(p);

}

mDNSexport mDNSs32 ChopSubTypes(char *regtype)

{

mDNSs32 NumSubTypes = 0;

char *stp = FindFirstSubType(regtype);

while (stp && *stp) // If we found a comma...

{

if (*stp == ',') return(-1);

NumSubTypes++;

stp = FindNextSubType(stp);

}

if (!stp) return(-1);

return(NumSubTypes);

}

mDNSexport AuthRecord *AllocateSubTypes(mDNSs32 NumSubTypes, char *p)

{

AuthRecord *st = mDNSNULL;

if (NumSubTypes)

{

mDNSs32 i;

st = mallocL("ServiceSubTypes", NumSubTypes * sizeof(AuthRecord));

if (!st) return(mDNSNULL);

for (i = 0; i < NumSubTypes; i++)

{

mDNS_SetupResourceRecord(&st[i], mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, mDNSNULL, mDNSNULL);

while (*p) p++;

p++;

if (!MakeDomainNameFromDNSNameString(st[i].resrec.name, p))

{ freeL("ServiceSubTypes", st); return(mDNSNULL); }

}

}

return(st);

}

#ifdef _HAVE_SETDOMAIN_SUPPORT_

mDNSlocal void free_defdomain(mDNS *const m, AuthRecord *const rr, mStatus result)

{

(void)m; // unused

if (result == mStatus_MemFree) free(rr->RecordContext); // context is the enclosing list structure

}

#endif

mDNSlocal void handle_setdomain_request(request_state *request)

{

mStatus err = mStatus_NoError;

char *ptr;

char domainstr[MAX_ESCAPED_DOMAIN_NAME];

domainname domain;

DNSServiceFlags flags;

#ifdef _HAVE_SETDOMAIN_SUPPORT_

struct xucred xuc;

socklen_t xuclen;

#endif

if (request->ts != t_complete)

{

LogMsg("ERROR: handle_setdomain_request - transfer state != t_complete");

abort_request(request);

unlink_request(request);

return;

}

// extract flags/domain from message

ptr = request->msgdata;

flags = get_flags(&ptr);

if (get_string(&ptr, domainstr, MAX_ESCAPED_DOMAIN_NAME) < 0 ||

!MakeDomainNameFromDNSNameString(&domain, domainstr))

{ err = mStatus_BadParamErr; goto end; }

freeL("handle_setdomain_request", request->msgbuf);

request->msgbuf = NULL;

debugf("%3d: DNSServiceSetDefaultDomainForUser(%##s)", request->sd, domain.c);

#ifdef _HAVE_SETDOMAIN_SUPPORT_

// this functionality currently only used for Apple-specific configuration, so we don't burned other platforms by mandating

// the existence of this socket option

xuclen = sizeof(xuc);

if (getsockopt(request->sd, 0, LOCAL_PEERCRED, &xuc, &xuclen))

{ my_perror("ERROR: getsockopt, LOCAL_PEERCRED"); err = mStatus_UnknownErr; goto end; }

if (xuc.cr_version != XUCRED_VERSION) { LogMsg("getsockopt, LOCAL_PEERCRED - bad version"); err = mStatus_UnknownErr; goto end; }

LogMsg("Default domain %s %s for UID %d", domainstr, flags & kDNSServiceFlagsAdd ? "set" : "removed", xuc.cr_uid);

if (flags & kDNSServiceFlagsAdd)

{

// register a local-only PRT record

default_browse_list_t *newelem = malloc(sizeof(default_browse_list_t));

if (!newelem) { LogMsg("ERROR: malloc"); err = mStatus_NoMemoryErr; goto end; }

mDNS_SetupResourceRecord(&newelem->ptr_rec, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, 7200, kDNSRecordTypeShared, free_defdomain, newelem);

MakeDomainNameFromDNSNameString(&newelem->ptr_rec.resrec.name, mDNS_DomainTypeNames[mDNS_DomainTypeBrowseDefault]);

AppendDNSNameString (&newelem->ptr_rec.resrec.name, "local");

AssignDomainName(&newelem->ptr_rec.resrec.rdata->u.name, &domain);

newelem->uid = xuc.cr_uid;

err = mDNS_Register(gmDNS, &newelem->ptr_rec);

if (err) free(newelem);

else

{

// link into list

newelem->next = default_browse_list;

default_browse_list = newelem;

}

}

else

{

// remove - find in list, deregister

default_browse_list_t *ptr = default_browse_list, *prev = NULL;

while (ptr)

{

if (SameDomainName(&ptr->ptr_rec.resrec.rdata->u.name, &domain))

{

if (prev) prev->next = ptr->next;

else default_browse_list = ptr->next;

err = mDNS_Deregister(gmDNS, &ptr->ptr_rec);

break;

}

prev = ptr;

ptr = ptr->next;

}

if (!ptr) { LogMsg("Attempt to remove nonexistent domain %s for UID %d", domainstr, xuc.cr_uid); err = mStatus_Invalid; }

}

#else

err = mStatus_NoError;

#endif // _HAVE_SETDOMAIN_SUPPORT_

end:

deliver_error(request, err);

abort_request(request);

unlink_request(request);

}

mDNSlocal mStatus GenerateNTDResponse(domainname *servicename, mDNSInterfaceID id, request_state *request, reply_state **rep)

{

domainlabel name;

domainname type, dom;

*rep = NULL;

if (!DeconstructServiceName(servicename, &name, &type, &dom))

return kDNSServiceErr_Invalid;

else

{

char namestr[MAX_DOMAIN_LABEL+1];

char typestr[MAX_ESCAPED_DOMAIN_NAME];

char domstr [MAX_ESCAPED_DOMAIN_NAME];

int len;

char *data;

ConvertDomainLabelToCString_unescaped(&name, namestr);

ConvertDomainNameToCString(&type, typestr);

ConvertDomainNameToCString(&dom, domstr);

// Calculate reply data length

len = sizeof(DNSServiceFlags);

len += sizeof(uint32_t); // if index

len += sizeof(DNSServiceErrorType);

len += (int) (strlen(namestr) + 1);

len += (int) (strlen(typestr) + 1);

len += (int) (strlen(domstr) + 1);

// Build reply header

*rep = create_reply(query_reply_op, len, request);

(*rep)->rhdr->flags = dnssd_htonl(0);

(*rep)->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(gmDNS, id));

(*rep)->rhdr->error = dnssd_htonl(kDNSServiceErr_NoError);

// Build reply body

data = (*rep)->sdata;

put_string(namestr, &data);

put_string(typestr, &data);

put_string(domstr, &data);

return mStatus_NoError;

}

}

mDNSlocal void FoundInstance(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)

{

request_state *req = question->QuestionContext;

reply_state *rep;

(void)m; // Unused

if (answer->rrtype != kDNSType_PTR)

{ LogMsg("%3d: FoundInstance: Should not be called with rrtype %d (not a PTR record)", req->sd, answer->rrtype); return; }

if (GenerateNTDResponse(&answer->rdata->u.name, answer->InterfaceID, req, &rep) != mStatus_NoError)

{

LogMsg("%3d: FoundInstance: %##s PTR %##s received from network is not valid DNS-SD service pointer",

req->sd, answer->name->c, answer->rdata->u.name.c);

return;

}

LogOperation("%3d: DNSServiceBrowse(%##s, %s) RESULT %s %s",

req->sd, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "Add" : "Rmv", RRDisplayString(m, answer));

if (AddRecord) rep->rhdr->flags |= dnssd_htonl(kDNSServiceFlagsAdd);

append_reply(req, rep);

}

mDNSlocal mStatus add_domain_to_browser(browser_info_t *info, const domainname *d)

{

browser_t *b, *p;

mStatus err;

for (p = info->browsers; p; p = p->next)

{

if (SameDomainName(&p->domain, d))

{ debugf("add_domain_to_browser - attempt to add domain %##d already in list", d->c); return mStatus_AlreadyRegistered; }

}

b = mallocL("browser_t", sizeof(*b));

if (!b) return mStatus_NoMemoryErr;

AssignDomainName(&b->domain, d);

err = mDNS_StartBrowse(gmDNS, &b->q, &info->regtype, d, info->interface_id, info->ForceMCast, FoundInstance, info->rstate);

if (err)

{

LogMsg("mDNS_StartBrowse returned %d for type %##s domain %##s", err, info->regtype.c, d->c);

freeL("browser_t", b);

}

else

{

b->next = info->browsers;

info->browsers = b;

}

return err;

}

mDNSlocal void handle_browse_request(request_state *request)

{

DNSServiceFlags flags;

uint32_t interfaceIndex;

mDNSInterfaceID InterfaceID;

char regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];

domainname typedn, d, temp;

mDNSs32 NumSubTypes;

char *ptr;

mStatus err = mStatus_NoError;

DNameListElem *search_domain_list, *sdom;

browser_info_t *info = NULL;

if (request->ts != t_complete)

{

LogMsg("ERROR: handle_browse_request - transfer state != t_complete");

abort_request(request);

unlink_request(request);

return;

}

// extract data from message

ptr = request->msgdata;

flags = get_flags(&ptr);

interfaceIndex = get_long(&ptr);

if (get_string(&ptr, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||

get_string(&ptr, domain, MAX_ESCAPED_DOMAIN_NAME) < 0)

{ err = mStatus_BadParamErr; goto error; }

freeL("handle_browse_request", request->msgbuf);

request->msgbuf = NULL;

InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(gmDNS, interfaceIndex);

if (interfaceIndex && !InterfaceID) { err = mStatus_BadParamErr; goto error; }

#if defined(MDNS_LAZY_REGISTER_SEARCH_DOMAINS)

if ( !domain || ( domain[0] == '\0' ) )

{

dDNS_RegisterSearchDomains( gmDNS );

}

#endif

typedn.c[0] = 0;

NumSubTypes = ChopSubTypes(regtype); // Note: Modifies regtype string to remove trailing subtypes

if (NumSubTypes < 0 || NumSubTypes > 1) { err = mStatus_BadParamErr; goto error; }

if (NumSubTypes == 1 && !AppendDNSNameString(&typedn, regtype + strlen(regtype) + 1))

{ err = mStatus_BadParamErr; goto error; }

if (!regtype[0] || !AppendDNSNameString(&typedn, regtype)) { err = mStatus_BadParamErr; goto error; }

if (!MakeDomainNameFromDNSNameString(&temp, regtype)) { err = mStatus_BadParamErr; goto error; }

if (temp.c[0] > 15 && domain[0] == 0) strcpy(domain, "local."); // For over-long service types, we only allow domain "local"

// allocate and set up browser info

info = mallocL("browser_info_t", sizeof(*info));

if (!info) { err = mStatus_NoMemoryErr; goto error; }

request->browser_info = info;

info->ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;

info->interface_id = InterfaceID;

AssignDomainName(&info->regtype, &typedn);

info->rstate = request;

info->default_domain = !domain[0];

info->browsers = NULL;

// setup termination context

request->termination_context = info;

request->terminate = browse_termination_callback;

LogOperation("%3d: DNSServiceBrowse(\"%##s\", \"%s\") START", request->sd, info->regtype.c, domain);

if (domain[0])

{

if (!MakeDomainNameFromDNSNameString(&d, domain)) { err = mStatus_BadParamErr; goto error; }

err = add_domain_to_browser(info, &d);

}

else

{

search_domain_list = mDNSPlatformGetSearchDomainList();

for (sdom = search_domain_list; sdom; sdom = sdom->next)

{

err = add_domain_to_browser(info, &sdom->name);

if (err)

{

if (SameDomainName(&sdom->name, &localdomain)) break;

else err = mStatus_NoError; // suppress errors for non-local "default" domains

}

}

mDNS_FreeDNameList(search_domain_list);

}

deliver_error(request, err);

return;

error:

if (info) freeL("browser_info_t", info);

if (request->termination_context) request->termination_context = NULL;

deliver_error(request, err);

abort_request(request);

unlink_request(request);

}

mDNSlocal void browse_termination_callback(void *context)

{

browser_info_t *info = context;

browser_t *ptr;

if (!info) return;

while(info->browsers)

{

ptr = info->browsers;

info->browsers = ptr->next;

LogOperation("%3d: DNSServiceBrowse(%##s) STOP", info->rstate->sd, ptr->q.qname.c);

mDNS_StopBrowse(gmDNS, &ptr->q); // no need to error-check result

freeL("browse_termination_callback", ptr);

}

info->rstate->termination_context = NULL;

freeL("browser_info", info);

}

mDNSexport void udsserver_default_browse_domain_changed(const domainname *d, mDNSBool add)

{

request_state *r;

for (r = all_requests; r; r = r->next)

{

browser_info_t *info = r->browser_info;

if (!info || !info->default_domain) continue;

if (add) add_domain_to_browser(info, d);

else

{

browser_t **ptr = &info->browsers;

while (*ptr)

{

if (SameDomainName(&(*ptr)->domain, d))

{

browser_t *remove = *ptr;

*ptr = (*ptr)->next;

if (remove->q.LongLived)

{

// Give goodbyes for known answers.

// Note that this a special case where we know that the QuestionCallback function is our own

// code (it's FoundInstance), and that callback routine doesn't ever cancel its operation, so we

// don't need to guard against the question being cancelled mid-loop the way the mDNSCore routines do.

CacheRecord *ka = remove->q.uDNS_info.knownAnswers;

while (ka) { remove->q.QuestionCallback(gmDNS, &remove->q, &ka->resrec, mDNSfalse); ka = ka->next; }

}

mDNS_StopBrowse(gmDNS, &remove->q);

freeL("browser_t", remove);

return;

}

ptr = &(*ptr)->next;

}

LogMsg("Requested removal of default domain %##s not in list for sd %d", d->c, r->sd);

}

}

}

mDNSexport int CountPeerRegistrations(mDNS *const m, ServiceRecordSet *const srs)

{

int count = 0;

ResourceRecord *r = &srs->RR_SRV.resrec;

AuthRecord *rr;

ServiceRecordSet *s;

for (rr = m->ResourceRecords; rr; rr=rr->next)

if (rr->resrec.rrtype == kDNSType_SRV && SameDomainName(rr->resrec.name, r->name) && !SameRData(&rr->resrec, r))

count++;

for (rr = m->uDNS_info.RecordRegistrations; rr; rr=rr->next)

if (rr->uDNS_info.state != regState_Unregistered && rr->resrec.rrtype == kDNSType_SRV && SameDomainName(rr->resrec.name, r->name) && !SameRData(&rr->resrec, r))

count++;

for (s = m->uDNS_info.ServiceRegistrations; s; s = s->next)

if (s->uDNS_info.state != regState_Unregistered && SameDomainName(s->RR_SRV.resrec.name, r->name) && !SameRData(&s->RR_SRV.resrec, r))

count++;

verbosedebugf("%d peer registrations for %##s", count, r->name->c);

return(count);

}

mDNSexport int CountExistingRegistrations(domainname *srv, mDNSIPPort port)

{

int count = 0;

AuthRecord *rr;

for (rr = gmDNS->ResourceRecords; rr; rr=rr->next)

if (rr->resrec.rrtype == kDNSType_SRV &&

rr->resrec.rdata->u.srv.port.NotAnInteger == port.NotAnInteger &&

SameDomainName(rr->resrec.name, srv))

count++;

return(count);

}

mDNSlocal mStatus register_service_instance(request_state *request, const domainname *domain)

{

service_info *info = request->service_registration;

service_instance *ptr, *instance;

int instance_size;

mStatus result;

for (ptr = info->instances; ptr; ptr = ptr->next)

{

if (SameDomainName(&ptr->domain, domain))

{ LogMsg("register_service_instance: domain %##s already registered", domain->c); return mStatus_AlreadyRegistered; }

}

instance_size = sizeof(*instance);

if (info->txtlen > sizeof(RDataBody)) instance_size += (info->txtlen - sizeof(RDataBody));

instance = mallocL("service_instance", instance_size);

if (!instance) { my_perror("ERROR: malloc"); return mStatus_NoMemoryErr; }

instance->subtypes = AllocateSubTypes(info->num_subtypes, info->type_as_string);

if (info->num_subtypes && !instance->subtypes)

{ free_service_instance(instance); instance = NULL; FatalError("ERROR: malloc"); }

instance->request = request;

instance->sd = request->sd;

instance->autoname = info->autoname;

instance->autorename = info->autorename;

instance->allowremotequery = info->allowremotequery;

instance->rename_on_memfree = 0;

instance->name = info->name;

AssignDomainName(&instance->domain, domain);

instance->default_local = (info->default_domain && SameDomainName(domain, &localdomain));

result = mDNS_RegisterService(gmDNS, &instance->srs, &instance->name, &info->type, domain, info->host.c[0] ? &info->host : NULL, info->port,

info->txtdata, info->txtlen, instance->subtypes, info->num_subtypes, info->InterfaceID, regservice_callback, instance);

if (result) free_service_instance(instance);

else

{

instance->next = info->instances;

info->instances = instance;

}

return result;

}

mDNSexport void udsserver_default_reg_domain_changed(const domainname *d, mDNSBool add)

{

request_state *rstate;

service_info *info;

LogMsg("%s registration domain %##s", add ? "Adding" : "Removing", d->c);

for (rstate = all_requests; rstate; rstate = rstate->next)

{

if (rstate->terminate != regservice_termination_callback) continue;

info = rstate->service_registration;

if (!info) { LogMsg("udsserver_default_reg_domain_changed - NULL service info"); continue; } // this should never happen

if (!info->default_domain) continue;

// valid default registration

if (add) register_service_instance(rstate, d);

else

{

// find the instance to remove

service_instance *si = rstate->service_registration->instances, *prev = NULL;

while (si)

{

if (SameDomainName(&si->domain, d))

{

mStatus err;

if (prev) prev->next = si->next;

else info->instances = si->next;

err = mDNS_DeregisterService(gmDNS, &si->srs);

if (err)

{

LogMsg("udsserver_default_reg_domain_changed - mDNS_DeregisterService err %d", err);

free_service_instance(si);

}

break;

}

prev = si;

si = si->next;

}

if (!si) debugf("udsserver_default_reg_domain_changed - domain %##s not registered", d->c); // normal if registration failed

}

}

}

mDNSlocal void handle_regservice_request(request_state *request)

{

DNSServiceFlags flags;

uint32_t ifi;

char name[1024]; // Lots of spare space for extra-long names that we'll auto-truncate down to 63 bytes

char domain[MAX_ESCAPED_DOMAIN_NAME], host[MAX_ESCAPED_DOMAIN_NAME];

char *ptr;

domainname d, srv;

mStatus result;

service_info *service = NULL;

if (request->ts != t_complete)

{

LogMsg("ERROR: handle_regservice_request - transfer state != t_complete");

abort_request(request);

unlink_request(request);

return;

}

service = mallocL("service_info", sizeof(*service));

if (!service) { my_perror("ERROR: malloc"); result = mStatus_NoMemoryErr; goto finish; }

service->instances = NULL;

service->request = request;

service->txtlen = 0;

service->txtdata = NULL;

request->service_registration = service;

request->termination_context = request->service_registration;

request->terminate = regservice_termination_callback;

// extract data from message

ptr = request->msgdata;

flags = get_flags(&ptr);

ifi = get_long(&ptr);

service->InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(gmDNS, ifi);

if (ifi && !service->InterfaceID)

{ LogMsg("ERROR: handle_regservice_request - Couldn't find InterfaceID for interfaceIndex %d", ifi); goto bad_param; }

if (get_string(&ptr, name, sizeof(name)) < 0 ||

get_string(&ptr, service->type_as_string, MAX_ESCAPED_DOMAIN_NAME) < 0 ||

get_string(&ptr, domain, MAX_ESCAPED_DOMAIN_NAME) < 0 ||

get_string(&ptr, host, MAX_ESCAPED_DOMAIN_NAME) < 0)

{ LogMsg("ERROR: handle_regservice_request - Couldn't read name/regtype/domain"); goto bad_param; }

service->port.b[0] = *ptr++;

service->port.b[1] = *ptr++;

service->txtlen = get_short(&ptr);

if (service->txtlen)

{

service->txtdata = mallocL("txtdata", service->txtlen);

if (!service->txtdata) { my_perror("ERROR: malloc"); result = mStatus_NoMemoryErr; goto finish; }

memcpy(service->txtdata, get_rdata(&ptr, service->txtlen), service->txtlen);

}

else service->txtdata = NULL;

// Check for sub-types after the service type

service->num_subtypes = ChopSubTypes(service->type_as_string); // Note: Modifies regtype string to remove trailing subtypes

if (service->num_subtypes < 0)

{ LogMsg("ERROR: handle_regservice_request - ChopSubTypes failed %s", service->type_as_string); goto bad_param; }

// Don't try to construct "domainname t" until *after* ChopSubTypes has worked its magic

if (!*service->type_as_string || !MakeDomainNameFromDNSNameString(&service->type, service->type_as_string))

{ LogMsg("ERROR: handle_regservice_request - service->type_as_string bad %s", service->type_as_string); goto bad_param; }

if (!name[0])

{

service->name = (gmDNS)->nicelabel;

service->autoname = mDNStrue;

}

else

{

// If the client is allowing AutoRename, then truncate name to legal length before converting it to a DomainLabel

if ((flags & kDNSServiceFlagsNoAutoRename) == 0)

{

int newlen = TruncateUTF8ToLength((mDNSu8*)name, mDNSPlatformStrLen(name), MAX_DOMAIN_LABEL);

name[newlen] = 0;

}

if (!MakeDomainLabelFromLiteralString(&service->name, name))

{ LogMsg("ERROR: handle_regservice_request - name bad %s", name); goto bad_param; }

service->autoname = mDNSfalse;

}

if (*domain)

{

service->default_domain = mDNSfalse;

if (!MakeDomainNameFromDNSNameString(&d, domain))

{ LogMsg("ERROR: handle_regservice_request - domain bad %s", domain); goto bad_param; }

}

else

{

service->default_domain = mDNStrue;

MakeDomainNameFromDNSNameString(&d, "local.");

}

if (!ConstructServiceName(&srv, &service->name, &service->type, &d))

{ LogMsg("ERROR: handle_regservice_request - Couldn't ConstructServiceName from, “%#s” “%##s” “%##s”", service->name.c, service->type.c, d.c); goto bad_param; }

if (!MakeDomainNameFromDNSNameString(&service->host, host))

{ LogMsg("ERROR: handle_regservice_request - host bad %s", host); goto bad_param; }

service->autorename = (flags & kDNSServiceFlagsNoAutoRename ) == 0;

service->allowremotequery = (flags & kDNSServiceFlagsAllowRemoteQuery) != 0;

// Some clients use mDNS for lightweight copy protection, registering a pseudo-service with

// a port number of zero. When two instances of the protected client are allowed to run on one

// machine, we don't want to see misleading "Bogus client" messages in syslog and the console.

if (service->port.NotAnInteger)

{

int count = CountExistingRegistrations(&srv, service->port);

if (count)

LogMsg("Client application registered %d identical instances of service %##s port %u.",

count+1, srv.c, mDNSVal16(service->port));

}

LogOperation("%3d: DNSServiceRegister(\"%s\", \"%s\", \"%s\", \"%s\", %u) START",

request->sd, name, service->type_as_string, domain, host, mDNSVal16(service->port));

result = register_service_instance(request, &d);

if (!result && !*domain)

{

DNameListElem *ptr, *def_domains = mDNSPlatformGetRegDomainList();

for (ptr = def_domains; ptr; ptr = ptr->next)

register_service_instance(request, &ptr->name);

// note that we don't report errors for non-local, non-explicit domains

mDNS_FreeDNameList(def_domains);

}

finish:

deliver_error(request, result);

if (result != mStatus_NoError)

{

abort_request(request);

unlink_request(request);

}

else

reset_connected_rstate(request); // prepare to receive add/remove messages

return;

bad_param:

//if (service) freeL("service_info", service); Don't think we should do this -- abort_request will free it a second time and crash

deliver_error(request, mStatus_BadParamErr);

abort_request(request);

unlink_request(request);

}

mDNSlocal void regservice_callback(mDNS *const m, ServiceRecordSet *const srs, mStatus result)

{

mStatus err;

mDNSBool SuppressError = mDNSfalse;

service_instance *instance = srs->ServiceContext;

(void)m; // Unused

if (!srs) { LogMsg("regservice_callback: srs is NULL %d", result); return; }

if (!instance) { LogMsg("regservice_callback: srs->ServiceContext is NULL %d", result); return; }

if (instance->request && instance->request->service_registration)

{

service_info *info = instance->request->service_registration;

if (info->default_domain && !instance->default_local) SuppressError = mDNStrue;

// don't send errors up to client for wide-area, empty-string registrations

}

if (result == mStatus_NoError)

LogOperation("%3d: DNSServiceRegister(%##s, %u) REGISTERED ", instance->sd, srs->RR_SRV.resrec.name->c, mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port));

else if (result == mStatus_MemFree)

LogOperation("%3d: DNSServiceRegister(%##s, %u) DEREGISTERED", instance->sd, srs->RR_SRV.resrec.name->c, mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port));

else if (result == mStatus_NameConflict)

LogOperation("%3d: DNSServiceRegister(%##s, %u) NAME CONFLICT", instance->sd, srs->RR_SRV.resrec.name->c, mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port));

else

LogOperation("%3d: DNSServiceRegister(%##s, %u) CALLBACK %d", instance->sd, srs->RR_SRV.resrec.name->c, mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port), result);

if (result == mStatus_NoError)

{

request_state *req = instance->request;

if (instance->allowremotequery)

{

ExtraResourceRecord *e;

srs->RR_ADV.AllowRemoteQuery = mDNStrue;

srs->RR_PTR.AllowRemoteQuery = mDNStrue;