#if defined(_WIN32)
#include <process.h>
#define dnssd_strerror(X) win32_strerror(X)
#define usleep(X) Sleep(((X)+999)/1000)
mDNSlocal char *win32_strerror(int inErrorCode)
{
static char buffer[1024];
DWORD n;
memset(buffer, 0, sizeof(buffer));
n = FormatMessageA(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
(DWORD) inErrorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
buffer,
sizeof(buffer),
NULL);
if (n > 0)
{
while ((n > 0) && isspace(((unsigned char *) buffer)[n - 1]))
buffer[--n] = '\0';
}
return buffer;
}
#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 "uDNS.h"
#include "uds_daemon.h"
#if APPLE_OSX_mDNSResponder
#include <sys/ucred.h>
#ifndef PID_FILE
#define PID_FILE ""
#endif
#endif
#define SystemUID(X) ((X) <= 500)
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Types and Data Structures
#endif
typedef enum
{
t_uninitialized,
t_morecoming,
t_complete,
t_error,
t_terminated
} transfer_state;
typedef struct request_state request_state;
typedef void (*req_termination_fn)(request_state *request);
typedef struct registered_record_entry
{
struct registered_record_entry *next;
mDNSu32 key;
AuthRecord *rr; client_context_t client_context;
request_state *request;
} registered_record_entry;
typedef struct service_instance
{
struct service_instance *next;
request_state *request;
dnssd_sock_t sd;
AuthRecord *subtypes;
mDNSBool renameonmemfree; mDNSBool clientnotified; mDNSBool default_local; domainname domain;
ServiceRecordSet srs; } service_instance;
typedef struct browser_t
{
struct browser_t *next;
domainname domain;
DNSQuestion q;
} browser_t;
struct request_state
{
request_state *next;
request_state *primary; dnssd_sock_t sd;
dnssd_sock_t errsd;
mDNSu32 uid;
transfer_state ts;
mDNSu32 hdr_bytes; ipc_msg_hdr hdr;
mDNSu32 data_bytes; char *msgbuf; char *msgptr; char *msgend;
int no_reply; int time_blocked; struct reply_state *replies; req_termination_fn terminate;
union
{
registered_record_entry *reg_recs; struct
{
mDNSInterfaceID interface_id;
mDNSBool default_domain;
mDNSBool ForceMCast;
domainname regtype;
browser_t *browsers;
} browser;
struct
{
mDNSInterfaceID InterfaceID;
mDNSu16 txtlen;
void *txtdata;
mDNSIPPort port;
domainlabel name;
char type_as_string[MAX_ESCAPED_DOMAIN_NAME];
domainname type;
mDNSBool default_domain;
domainname host;
mDNSBool autoname; mDNSBool autorename; mDNSBool allowremotequery; int num_subtypes;
service_instance *instances;
} servicereg;
struct
{
mDNSInterfaceID interface_id;
mDNSu32 flags;
mDNSu32 protocol;
DNSQuestion q4;
DNSQuestion q6;
} addrinfo;
struct
{
mDNSIPPort ReqExt; NATTraversalInfo NATinfo;
} pm;
struct
{
DNSQuestion q_all;
DNSQuestion q_default;
} enumeration;
struct
{
DNSQuestion q;
} queryrecord;
struct
{
DNSQuestion qtxt;
DNSQuestion qsrv;
const ResourceRecord *txt;
const ResourceRecord *srv;
mDNSs32 ReportTime;
} resolve;
;
} u;
};
typedef struct
{
DNSServiceFlags flags; mDNSu32 ifi; DNSServiceErrorType error; } reply_hdr;
typedef struct reply_state
{
dnssd_sock_t sd;
transfer_state ts;
mDNSu32 nwriten;
mDNSu32 len;
request_state *request; struct reply_state *next; char *msgbuf; ipc_msg_hdr *mhdr; reply_hdr *rhdr;
char *sdata; } reply_state;
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Globals
#endif
mDNSexport mDNS mDNSStorage;
mDNSexport const char ProgramName[] = "mDNSResponder";
static dnssd_sock_t listenfd = dnssd_InvalidSocket;
static request_state *all_requests = NULL;
static DNameListElem *SCPrefBrowseDomains; static ARListElem *LocalDomainEnumRecords; mDNSexport DNameListElem *AutoBrowseDomains;
mDNSexport DNameListElem *AutoRegistrationDomains;
#define MSG_PAD_BYTES 5 // pad message buffer (read from client) with n zero'd bytes to guarantee
#ifndef PID_FILE
#define PID_FILE "/var/run/mDNSResponder.pid"
#endif
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - General Utility Functions
#endif
mDNSlocal void FatalError(char *errmsg)
{
LogMsg("%s: %s", errmsg, dnssd_strerror(dnssd_errno()));
*(long*)0 = 0; abort(); }
mDNSlocal mDNSu32 dnssd_htonl(mDNSu32 l)
{
mDNSu32 ret;
char *data = (char*) &ret;
put_uint32(l, &data);
return ret;
}
mDNSlocal void my_perror(char *errmsg)
{
LogMsg("%s: %s", errmsg, dnssd_strerror(dnssd_errno()));
}
mDNSlocal void abort_request(request_state *req)
{
if (req->terminate) req->terminate(req);
if (!req->primary)
{
if (req->errsd != req->sd) LogOperation("%3d: Removing FD and closing errsd %d", req->sd, req->errsd);
else LogOperation("%3d: Removing FD", req->sd);
udsSupportRemoveFDFromEventLoop(req->sd); if (req->errsd != req->sd) { dnssd_close(req->errsd); req->errsd = req->sd; }
while (req->replies) {
reply_state *ptr = req->replies;
req->replies = req->replies->next;
if (ptr->msgbuf) freeL("reply_state msgbuf (abort)", ptr->msgbuf);
freeL("reply_state (abort)", ptr);
}
}
#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
req->sd = -2;
#else
req->sd = dnssd_InvalidSocket;
#endif
}
mDNSlocal void AbortUnlinkAndFree(request_state *req)
{
request_state **p = &all_requests;
abort_request(req);
while (*p && *p != req) p=&(*p)->next;
if (*p) { *p = req->next; freeL("request_state/AbortUnlinkAndFree", req); }
}
mDNSlocal reply_state *create_reply(const reply_op_t op, const size_t datalen, request_state *const request)
{
reply_state *reply;
int totallen = (int) (datalen + sizeof(ipc_msg_hdr));
if ((unsigned)datalen < sizeof(reply_hdr))
{
LogMsg("ERROR: create_reply - data length less than lenght of required fields");
return NULL;
}
reply = mallocL("reply_state", sizeof(reply_state));
if (!reply) FatalError("ERROR: malloc");
mDNSPlatformMemZero(reply, sizeof(reply_state));
reply->ts = t_morecoming;
reply->sd = request->sd;
reply->request = request;
reply->len = totallen;
reply->msgbuf = mallocL("reply_state msgbuf", totallen);
if (!reply->msgbuf) FatalError("ERROR: malloc");
mDNSPlatformMemZero(reply->msgbuf, totallen);
reply->mhdr = (ipc_msg_hdr *)reply->msgbuf;
reply->rhdr = (reply_hdr *)(reply->msgbuf + sizeof(ipc_msg_hdr));
reply->sdata = reply->msgbuf + sizeof(ipc_msg_hdr) + sizeof(reply_hdr);
reply->mhdr->version = VERSION;
reply->mhdr->datalen = datalen;
reply->mhdr->ipc_flags = 0;
reply->mhdr->op = op;
reply->mhdr->client_context = request->hdr.client_context;
reply->mhdr->reg_index = 0;
return reply;
}
mDNSlocal void append_reply(request_state *req, reply_state *rep)
{
request_state *r = req->primary ? req->primary : req;
reply_state **ptr = &r->replies;
while (*ptr) ptr = &(*ptr)->next;
*ptr = rep;
rep->next = NULL;
}
mDNSlocal mStatus GenerateNTDResponse(const domainname *const servicename, const mDNSInterfaceID id,
request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
{
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);
len = sizeof(DNSServiceFlags);
len += sizeof(mDNSu32); len += sizeof(DNSServiceErrorType);
len += (int) (strlen(namestr) + 1);
len += (int) (strlen(typestr) + 1);
len += (int) (strlen(domstr) + 1);
*rep = create_reply(op, len, request);
(*rep)->rhdr->flags = dnssd_htonl(flags);
(*rep)->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, id));
(*rep)->rhdr->error = dnssd_htonl(err);
data = (*rep)->sdata;
put_string(namestr, &data);
put_string(typestr, &data);
put_string(domstr, &data);
return mStatus_NoError;
}
}
mDNSlocal AuthRecord *read_rr_from_ipc_msg(request_state *request, int GetTTL, int validate_flags)
{
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
char name[256];
int str_err = get_string(&request->msgptr, request->msgend, name, sizeof(name));
mDNSu16 type = get_uint16(&request->msgptr, request->msgend);
mDNSu16 class = get_uint16(&request->msgptr, request->msgend);
mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
char *rdata = get_rdata(&request->msgptr, request->msgend, rdlen);
mDNSu32 ttl = GetTTL ? get_uint32(&request->msgptr, request->msgend) : 0;
int storage_size = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
AuthRecord *rr;
if (str_err) { LogMsg("ERROR: read_rr_from_ipc_msg - get_string"); return NULL; }
if (!request->msgptr) { LogMsg("Error reading Resource Record from client"); return NULL; }
if (validate_flags &&
!((flags & kDNSServiceFlagsShared) == kDNSServiceFlagsShared) &&
!((flags & kDNSServiceFlagsUnique) == kDNSServiceFlagsUnique))
{
LogMsg("ERROR: Bad resource record flags (must be kDNSServiceFlagsShared or kDNSServiceFlagsUnique)");
return NULL;
}
rr = mallocL("AuthRecord/read_rr_from_ipc_msg", sizeof(AuthRecord) - sizeof(RDataBody) + storage_size);
if (!rr) FatalError("ERROR: malloc");
mDNS_SetupResourceRecord(rr, mDNSNULL, mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex),
type, 0, (mDNSu8) ((flags & kDNSServiceFlagsShared) ? kDNSRecordTypeShared : kDNSRecordTypeUnique), mDNSNULL, mDNSNULL);
if (!MakeDomainNameFromDNSNameString(&rr->namestorage, name))
{
LogMsg("ERROR: bad name: %s", name);
freeL("AuthRecord/read_rr_from_ipc_msg", rr);
return NULL;
}
if (flags & kDNSServiceFlagsAllowRemoteQuery) rr->AllowRemoteQuery = mDNStrue;
rr->resrec.rrclass = class;
rr->resrec.rdlength = rdlen;
rr->resrec.rdata->MaxRDLength = rdlen;
mDNSPlatformMemCopy(rr->resrec.rdata->u.data, rdata, rdlen);
if (GetTTL) rr->resrec.rroriginalttl = ttl;
rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
SetNewRData(&rr->resrec, mDNSNULL, 0); return rr;
}
mDNSlocal int build_domainname_from_strings(domainname *srv, char *name, char *regtype, char *domain)
{
domainlabel n;
domainname d, t;
if (!MakeDomainLabelFromLiteralString(&n, name)) return -1;
if (!MakeDomainNameFromDNSNameString(&t, regtype)) return -1;
if (!MakeDomainNameFromDNSNameString(&d, domain)) return -1;
if (!ConstructServiceName(srv, &n, &t, &d)) return -1;
return 0;
}
mDNSlocal void send_all(dnssd_sock_t s, const char *ptr, int len)
{
int n = send(s, ptr, len, 0);
if (n < len)
LogMsg("ERROR: send_all(%d) wrote %d of %d errno %d %s",
s, n, len, dnssd_errno(), dnssd_strerror(dnssd_errno()));
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceRegister
#endif
mDNSexport void FreeExtraRR(mDNS *const m, AuthRecord *const rr, mStatus result)
{
ExtraResourceRecord *extra = (ExtraResourceRecord *)rr->RecordContext;
(void)m;
if (result != mStatus_MemFree) { LogMsg("Error: FreeExtraRR invoked with unexpected error %d", result); return; }
LogOperation(" FreeExtraRR %s", RRDisplayString(m, &rr->resrec));
if (rr->resrec.rdata != &rr->rdatastorage)
freeL("Extra RData", rr->resrec.rdata);
freeL("ExtraResourceRecord/FreeExtraRR", extra);
}
mDNSlocal void unlink_and_free_service_instance(service_instance *srv)
{
ExtraResourceRecord *e = srv->srs.Extras, *tmp;
if (srv->request)
{
service_instance **p = &srv->request->u.servicereg.instances;
while (*p)
{
if (*p == srv) { *p = (*p)->next; break; }
p = &(*p)->next;
}
}
while (e)
{
e->r.RecordContext = e;
tmp = e;
e = e->next;
FreeExtraRR(&mDNSStorage, &tmp->r, mStatus_MemFree);
}
if (srv->srs.RR_TXT.resrec.rdata != &srv->srs.RR_TXT.rdatastorage)
freeL("TXT RData", srv->srs.RR_TXT.resrec.rdata);
if (srv->subtypes) { freeL("ServiceSubTypes", srv->subtypes); srv->subtypes = NULL; }
freeL("service_instance", srv);
}
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 (s = m->ServiceRegistrations; s; s = s->uDNS_next)
if (s->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 = mDNSStorage.ResourceRecords; rr; rr=rr->next)
if (rr->resrec.rrtype == kDNSType_SRV &&
mDNSSameIPPort(rr->resrec.rdata->u.srv.port, port) &&
SameDomainName(rr->resrec.name, srv))
count++;
return(count);
}
mDNSlocal void SendServiceRemovalNotification(ServiceRecordSet *const srs)
{
reply_state *rep;
service_instance *instance = srs->ServiceContext;
if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, 0, mStatus_NoError) != mStatus_NoError)
LogMsg("%3d: SendServiceRemovalNotification: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
else { append_reply(instance->request, rep); instance->clientnotified = mDNSfalse; }
}
mDNSlocal void regservice_callback(mDNS *const m, ServiceRecordSet *const srs, mStatus result)
{
mStatus err;
mDNSBool SuppressError = mDNSfalse;
service_instance *instance = srs->ServiceContext;
reply_state *rep;
#if LogAllOperations || MDNS_DEBUGMSGS
char *fmt = (result == mStatus_NoError) ? "%3d: DNSServiceRegister(%##s, %u) REGISTERED" :
(result == mStatus_MemFree) ? "%3d: DNSServiceRegister(%##s, %u) DEREGISTERED" :
(result == mStatus_NameConflict) ? "%3d: DNSServiceRegister(%##s, %u) NAME CONFLICT" :
"%3d: DNSServiceRegister(%##s, %u) %s %d";
#endif
(void)m; 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->u.servicereg.default_domain &&
!instance->default_local)
SuppressError = mDNStrue;
LogOperation(fmt, instance->sd, srs->RR_SRV.resrec.name->c, mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port), SuppressError ? "suppressed error" : "CALLBACK", result);
if (!instance->request && result != mStatus_MemFree) { LogMsg("regservice_callback: instance->request is NULL %d", result); return; }
if (result == mStatus_NoError)
{
if (instance->request->u.servicereg.allowremotequery)
{
ExtraResourceRecord *e;
srs->RR_ADV.AllowRemoteQuery = mDNStrue;
srs->RR_PTR.AllowRemoteQuery = mDNStrue;
srs->RR_SRV.AllowRemoteQuery = mDNStrue;
srs->RR_TXT.AllowRemoteQuery = mDNStrue;
for (e = instance->srs.Extras; e; e = e->next) e->r.AllowRemoteQuery = mDNStrue;
}
if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
RecordUpdatedNiceLabel(m, 0); }
else if (result == mStatus_MemFree)
{
if (instance->request && instance->renameonmemfree)
{
instance->renameonmemfree = 0;
err = mDNS_RenameAndReregisterService(m, srs, &instance->request->u.servicereg.name);
if (err) LogMsg("ERROR: regservice_callback - RenameAndReregisterService returned %ld", err);
}
else
unlink_and_free_service_instance(instance);
}
else if (result == mStatus_NameConflict)
{
if (instance->request->u.servicereg.autorename)
{
if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
{
IncrementLabelSuffix(&m->nicelabel, mDNStrue);
m->MainCallback(m, mStatus_ConfigChanged); }
else {
if (instance->clientnotified) SendServiceRemovalNotification(srs);
mDNS_RenameAndReregisterService(m, srs, mDNSNULL);
}
}
else
{
if (!SuppressError)
{
if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
}
unlink_and_free_service_instance(instance);
}
}
else
{
if (!SuppressError)
{
if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
}
}
}
mDNSlocal void regrecord_callback(mDNS *const m, AuthRecord *rr, mStatus result)
{
(void)m; if (!rr->RecordContext) {
if (result == mStatus_NoError)
LogMsg("Error: regrecord_callback: successful registration of orphaned record");
else
{
if (result != mStatus_MemFree) LogMsg("regrecord_callback: error %d received after parent termination", result);
freeL("AuthRecord/regrecord_callback", rr);
}
}
else
{
registered_record_entry *re = rr->RecordContext;
request_state *request = re->request;
int len = sizeof(DNSServiceFlags) + sizeof(mDNSu32) + sizeof(DNSServiceErrorType);
reply_state *reply = create_reply(reg_record_reply_op, len, request);
reply->mhdr->client_context = re->client_context;
reply->rhdr->flags = dnssd_htonl(0);
reply->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, rr->resrec.InterfaceID));
reply->rhdr->error = dnssd_htonl(result);
LogOperation("%3d: DNSServiceRegisterRecord(%u) result %d", request->sd, request->hdr.reg_index, result);
if (result)
{
registered_record_entry **ptr = &request->u.reg_recs;
while (*ptr && (*ptr) != re) ptr = &(*ptr)->next;
if (!*ptr) { LogMsg("regrecord_callback - record not in list!"); return; }
*ptr = (*ptr)->next;
freeL("registered_record_entry AuthRecord regrecord_callback", re->rr);
freeL("registered_record_entry regrecord_callback", re);
}
append_reply(request, reply);
}
}
mDNSlocal void connection_termination(request_state *request)
{
request_state **req = &all_requests;
while (*req)
{
if ((*req)->primary == request)
{
request_state *tmp = *req;
abort_request(tmp);
*req = tmp->next;
freeL("request_state/connection_termination", tmp);
}
else
req = &(*req)->next;
}
while (request->u.reg_recs)
{
registered_record_entry *ptr = request->u.reg_recs;
request->u.reg_recs = request->u.reg_recs->next;
ptr->rr->RecordContext = NULL;
mDNS_Deregister(&mDNSStorage, ptr->rr); freeL("registered_record_entry/connection_termination", ptr);
}
}
mDNSlocal void handle_cancel_request(request_state *request)
{
request_state **req = &all_requests;
LogOperation("%3d: Cancel %X%08X", request->sd, request->hdr.client_context.u32[1], request->hdr.client_context.u32[0]);
while (*req)
{
if ((*req)->primary == request &&
(*req)->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
(*req)->hdr.client_context.u32[1] == request->hdr.client_context.u32[1])
{
request_state *tmp = *req;
abort_request(tmp);
*req = tmp->next;
freeL("request_state/handle_cancel_request", tmp);
}
else
req = &(*req)->next;
}
}
mDNSlocal mStatus handle_regrecord_request(request_state *request)
{
mStatus err = mStatus_BadParamErr;
AuthRecord *rr = read_rr_from_ipc_msg(request, 1, 1);
if (rr)
{
registered_record_entry *re = mallocL("registered_record_entry", sizeof(registered_record_entry));
if (!re) FatalError("ERROR: malloc");
re->key = request->hdr.reg_index;
re->rr = rr;
re->request = request;
re->client_context = request->hdr.client_context;
rr->RecordContext = re;
rr->RecordCallback = regrecord_callback;
re->next = request->u.reg_recs;
request->u.reg_recs = re;
if (rr->resrec.rroriginalttl == 0)
rr->resrec.rroriginalttl = DefaultTTLforRRType(rr->resrec.rrtype);
LogOperation("%3d: DNSServiceRegisterRecord(%u %s)", request->sd, request->hdr.reg_index, RRDisplayString(&mDNSStorage, &rr->resrec));
err = mDNS_Register(&mDNSStorage, rr);
}
return(err);
}
mDNSlocal mStatus add_record_to_service(request_state *request, service_instance *instance, mDNSu16 rrtype, mDNSu16 rdlen, char *rdata, mDNSu32 ttl)
{
ServiceRecordSet *srs = &instance->srs;
mStatus result;
int size = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
ExtraResourceRecord *extra = mallocL("ExtraResourceRecord", sizeof(*extra) - sizeof(RDataBody) + size);
if (!extra) { my_perror("ERROR: malloc"); return mStatus_NoMemoryErr; }
mDNSPlatformMemZero(extra, sizeof(ExtraResourceRecord)); extra->r.resrec.rrtype = rrtype;
extra->r.rdatastorage.MaxRDLength = (mDNSu16) size;
extra->r.resrec.rdlength = rdlen;
mDNSPlatformMemCopy(&extra->r.rdatastorage.u.data, rdata, rdlen);
result = mDNS_AddRecordToService(&mDNSStorage, srs, extra, &extra->r.rdatastorage, ttl);
if (result) { freeL("ExtraResourceRecord/add_record_to_service", extra); return result; }
extra->ClientID = request->hdr.reg_index;
return result;
}
mDNSlocal mStatus handle_add_request(request_state *request)
{
service_instance *i;
mStatus result = mStatus_UnknownErr;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu16 rrtype = get_uint16(&request->msgptr, request->msgend);
mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
char *rdata = get_rdata(&request->msgptr, request->msgend, rdlen);
mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
if (!ttl) ttl = DefaultTTLforRRType(rrtype);
(void)flags;
if (!request->msgptr) { LogMsg("%3d: DNSServiceAddRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
LogOperation("%3d: DNSServiceAddRecord(%##s, %s, %d)", request->sd,
(request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL, DNSTypeName(rrtype), rdlen);
for (i = request->u.servicereg.instances; i; i = i->next)
{
result = add_record_to_service(request, i, rrtype, rdlen, rdata, ttl);
if (result && i->default_local) break;
else result = mStatus_NoError; }
return(result);
}
mDNSlocal void update_callback(mDNS *const m, AuthRecord *const rr, RData *oldrd)
{
(void)m; if (oldrd != &rr->rdatastorage) freeL("RData/update_callback", oldrd);
}
mDNSlocal mStatus update_record(AuthRecord *rr, mDNSu16 rdlen, char *rdata, mDNSu32 ttl)
{
int rdsize;
RData *newrd;
mStatus result;
if (rdlen > sizeof(RDataBody)) rdsize = rdlen;
else rdsize = sizeof(RDataBody);
newrd = mallocL("RData/update_record", sizeof(RData) - sizeof(RDataBody) + rdsize);
if (!newrd) FatalError("ERROR: malloc");
newrd->MaxRDLength = (mDNSu16) rdsize;
mDNSPlatformMemCopy(&newrd->u, rdata, rdlen);
if (rr->resrec.rrtype == kDNSType_TXT && rdlen == 0) { rdlen = 1; newrd->u.txt.c[0] = 0; }
result = mDNS_Update(&mDNSStorage, rr, ttl, rdlen, newrd, update_callback);
if (result) { LogMsg("ERROR: mDNS_Update - %ld", result); freeL("RData/update_record", newrd); }
return result;
}
mDNSlocal mStatus handle_update_request(request_state *request)
{
mStatus result = mStatus_BadReferenceErr;
service_instance *i;
AuthRecord *rr = NULL;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend); mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
char *rdata = get_rdata(&request->msgptr, request->msgend, rdlen);
mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
(void)flags;
if (!request->msgptr) { LogMsg("%3d: DNSServiceUpdateRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
if (request->terminate == connection_termination)
{
registered_record_entry *reptr;
for (reptr = request->u.reg_recs; reptr; reptr = reptr->next)
{
if (reptr->key == request->hdr.reg_index)
{
result = update_record(reptr->rr, rdlen, rdata, ttl);
goto end;
}
}
result = mStatus_BadReferenceErr;
goto end;
}
for (i = request->u.servicereg.instances; i; i = i->next)
{
if (request->hdr.reg_index == TXT_RECORD_INDEX) rr = &i->srs.RR_TXT;
else
{
ExtraResourceRecord *e;
for (e = i->srs.Extras; e; e = e->next)
if (e->ClientID == request->hdr.reg_index) { rr = &e->r; break; }
}
if (!rr) { result = mStatus_BadReferenceErr; goto end; }
result = update_record(rr, rdlen, rdata, ttl);
if (result && i->default_local) goto end;
else result = mStatus_NoError; }
end:
LogOperation("%3d: DNSServiceUpdateRecord(%##s, %s)", request->sd,
(request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
rr ? DNSTypeName(rr->resrec.rrtype) : "<NONE>");
return(result);
}
mDNSlocal mStatus remove_record(request_state *request)
{
mStatus err = mStatus_UnknownErr;
registered_record_entry *e, **ptr = &request->u.reg_recs;
while (*ptr && (*ptr)->key != request->hdr.reg_index) ptr = &(*ptr)->next;
if (!*ptr) { LogMsg("%3d: DNSServiceRemoveRecord(%u) not found", request->sd, request->hdr.reg_index); return mStatus_BadReferenceErr; }
e = *ptr;
*ptr = e->next;
LogOperation("%3d: DNSServiceRemoveRecord(%u %s)", request->sd, request->hdr.reg_index, RRDisplayString(&mDNSStorage, &e->rr->resrec));
e->rr->RecordContext = NULL;
err = mDNS_Deregister(&mDNSStorage, e->rr);
if (err)
{
LogMsg("ERROR: remove_record, mDNS_Deregister: %ld", err);
freeL("registered_record_entry AuthRecord remove_record", e->rr);
}
freeL("registered_record_entry remove_record", e);
return err;
}
mDNSlocal mStatus remove_extra(const request_state *const request, service_instance *const serv, mDNSu16 *const rrtype)
{
mStatus err = mStatus_BadReferenceErr;
ExtraResourceRecord *ptr;
for (ptr = serv->srs.Extras; ptr; ptr = ptr->next)
{
if (ptr->ClientID == request->hdr.reg_index) {
*rrtype = ptr->r.resrec.rrtype;
return mDNS_RemoveRecordFromService(&mDNSStorage, &serv->srs, ptr, FreeExtraRR, ptr);
}
}
return err;
}
mDNSlocal mStatus handle_removerecord_request(request_state *request)
{
mStatus err = mStatus_BadReferenceErr;
get_flags(&request->msgptr, request->msgend);
if (!request->msgptr) { LogMsg("%3d: DNSServiceRemoveRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
if (request->terminate == connection_termination)
err = remove_record(request); else
{
service_instance *i;
mDNSu16 rrtype = 0;
LogOperation("%3d: DNSServiceRemoveRecord(%##s, %s)", request->sd,
(request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
rrtype ? DNSTypeName(rrtype) : "<NONE>");
for (i = request->u.servicereg.instances; i; i = i->next)
{
err = remove_extra(request, i, &rrtype);
if (err && i->default_local) break;
else err = mStatus_NoError; }
}
return(err);
}
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]) p += 2; else if (p[0] == ',') {
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 (*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].namestorage, p))
{ freeL("ServiceSubTypes", st); return(mDNSNULL); }
}
}
return(st);
}
mDNSlocal mStatus register_service_instance(request_state *request, const domainname *domain)
{
service_instance **ptr, *instance;
int instance_size;
mStatus result;
for (ptr = &request->u.servicereg.instances; *ptr; ptr = &(*ptr)->next)
{
if (SameDomainName(&(*ptr)->domain, domain))
{ LogMsg("register_service_instance: domain %##s already registered", domain->c); return mStatus_AlreadyRegistered; }
}
if (SameDomainName(&request->u.servicereg.type, (const domainname *) "\x4" "_smb" "\x4" "_tcp"))
{
DomainAuthInfo *AuthInfo = GetAuthInfoForName(&mDNSStorage, domain);
if (AuthInfo && AuthInfo->AutoTunnel) return(kDNSServiceErr_Unsupported);
}
instance_size = sizeof(*instance);
if (request->u.servicereg.txtlen > sizeof(RDataBody)) instance_size += (request->u.servicereg.txtlen - sizeof(RDataBody));
instance = mallocL("service_instance", instance_size);
if (!instance) { my_perror("ERROR: malloc"); return mStatus_NoMemoryErr; }
instance->next = mDNSNULL;
instance->request = request;
instance->sd = request->sd;
instance->subtypes = AllocateSubTypes(request->u.servicereg.num_subtypes, request->u.servicereg.type_as_string);
instance->renameonmemfree = 0;
instance->clientnotified = mDNSfalse;
instance->default_local = (request->u.servicereg.default_domain && SameDomainName(domain, &localdomain));
AssignDomainName(&instance->domain, domain);
if (request->u.servicereg.num_subtypes && !instance->subtypes)
{ unlink_and_free_service_instance(instance); instance = NULL; FatalError("ERROR: malloc"); }
LogOperation("%3d: DNSServiceRegister(%#s.%##s%##s, %u) ADDING",
instance->sd, &request->u.servicereg.name, &request->u.servicereg.type, domain->c, mDNSVal16(request->u.servicereg.port));
result = mDNS_RegisterService(&mDNSStorage, &instance->srs,
&request->u.servicereg.name, &request->u.servicereg.type, domain,
request->u.servicereg.host.c[0] ? &request->u.servicereg.host : NULL,
request->u.servicereg.port,
request->u.servicereg.txtdata, request->u.servicereg.txtlen,
instance->subtypes, request->u.servicereg.num_subtypes,
request->u.servicereg.InterfaceID, regservice_callback, instance);
if (!result) *ptr = instance; else
{
LogMsg("register_service_instance %#s.%##s%##s error %d",
&request->u.servicereg.name, &request->u.servicereg.type, domain->c, result);
unlink_and_free_service_instance(instance);
}
return result;
}
mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m);
mDNSlocal void regservice_termination_callback(request_state *request)
{
if (!request) { LogMsg("regservice_termination_callback context is NULL"); return; }
while (request->u.servicereg.instances)
{
service_instance *p = request->u.servicereg.instances;
request->u.servicereg.instances = request->u.servicereg.instances->next;
LogOperation("%3d: DNSServiceRegister(%##s, %u) STOP",
request->sd, p->srs.RR_SRV.resrec.name->c, mDNSVal16(p->srs.RR_SRV.resrec.rdata->u.srv.port));
p->request = NULL;
if (mDNS_DeregisterService(&mDNSStorage, &p->srs)) unlink_and_free_service_instance(p);
}
if (request->u.servicereg.txtdata)
{ freeL("service_info txtdata", request->u.servicereg.txtdata); request->u.servicereg.txtdata = NULL; }
if (request->u.servicereg.autoname) UpdateDeviceInfoRecord(&mDNSStorage);
}
mDNSlocal void udsserver_default_reg_domain_changed(const DNameListElem *const d, const mDNSBool add)
{
request_state *request;
#if APPLE_OSX_mDNSResponder
machserver_automatic_registration_domain_changed(&d->name, add);
#endif // APPLE_OSX_mDNSResponder
LogMsg("%s registration domain %##s", add ? "Adding" : "Removing", d->name.c);
for (request = all_requests; request; request = request->next)
{
if (request->terminate != regservice_termination_callback) continue;
if (!request->u.servicereg.default_domain) continue;
if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
{
service_instance **ptr = &request->u.servicereg.instances;
while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
if (add)
{
if (!*ptr) register_service_instance(request, &d->name);
else debugf("udsserver_default_reg_domain_changed %##s already in list, not re-adding", &d->name);
}
else
{
if (!*ptr)
LogMsg("udsserver_default_reg_domain_changed domain %##s not found for service %#s type %s",
&d->name, request->u.servicereg.name.c, request->u.servicereg.type_as_string);
else
{
DNameListElem *p;
for (p = AutoRegistrationDomains; p; p=p->next)
if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
if (SameDomainName(&d->name, &p->name)) break;
if (p) debugf("udsserver_default_reg_domain_changed %##s still in list, not removing", &d->name);
else
{
mStatus err;
service_instance *si = *ptr;
*ptr = si->next;
if (si->clientnotified) SendServiceRemovalNotification(&si->srs); si->request = NULL;
err = mDNS_DeregisterService(&mDNSStorage, &si->srs);
if (err) { LogMsg("udsserver_default_reg_domain_changed err %d", err); unlink_and_free_service_instance(si); }
}
}
}
}
}
}
mDNSlocal mStatus handle_regservice_request(request_state *request)
{
char name[256]; char domain[MAX_ESCAPED_DOMAIN_NAME], host[MAX_ESCAPED_DOMAIN_NAME];
char type_as_string[MAX_ESCAPED_DOMAIN_NAME];
domainname d, srv;
mStatus err;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
if (interfaceIndex && !InterfaceID)
{ LogMsg("ERROR: handle_regservice_request - Couldn't find interfaceIndex %d", interfaceIndex); return(mStatus_BadParamErr); }
if (get_string(&request->msgptr, request->msgend, name, sizeof(name)) < 0 ||
get_string(&request->msgptr, request->msgend, type_as_string, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
get_string(&request->msgptr, request->msgend, host, MAX_ESCAPED_DOMAIN_NAME) < 0)
{ LogMsg("ERROR: handle_regservice_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
request->u.servicereg.InterfaceID = InterfaceID;
request->u.servicereg.instances = NULL;
request->u.servicereg.txtlen = 0;
request->u.servicereg.txtdata = NULL;
mDNSPlatformStrCopy(request->u.servicereg.type_as_string, type_as_string);
if (request->msgptr + 2 > request->msgend) request->msgptr = NULL;
else
{
request->u.servicereg.port.b[0] = *request->msgptr++;
request->u.servicereg.port.b[1] = *request->msgptr++;
}
request->u.servicereg.txtlen = get_uint16(&request->msgptr, request->msgend);
if (request->u.servicereg.txtlen)
{
request->u.servicereg.txtdata = mallocL("service_info txtdata", request->u.servicereg.txtlen);
if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_regservice_request - malloc");
mDNSPlatformMemCopy(request->u.servicereg.txtdata, get_rdata(&request->msgptr, request->msgend, request->u.servicereg.txtlen), request->u.servicereg.txtlen);
}
else request->u.servicereg.txtdata = NULL;
if (!request->msgptr) { LogMsg("%3d: DNSServiceRegister(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
request->u.servicereg.num_subtypes = ChopSubTypes(request->u.servicereg.type_as_string); if (request->u.servicereg.num_subtypes < 0)
{ LogMsg("ERROR: handle_regservice_request - ChopSubTypes failed %s", request->u.servicereg.type_as_string); return(mStatus_BadParamErr); }
if (!*request->u.servicereg.type_as_string || !MakeDomainNameFromDNSNameString(&request->u.servicereg.type, request->u.servicereg.type_as_string))
{ LogMsg("ERROR: handle_regservice_request - type_as_string bad %s", request->u.servicereg.type_as_string); return(mStatus_BadParamErr); }
if (!name[0])
{
request->u.servicereg.name = mDNSStorage.nicelabel;
request->u.servicereg.autoname = mDNStrue;
}
else
{
if ((flags & kDNSServiceFlagsNoAutoRename) == 0)
{
int newlen = TruncateUTF8ToLength((mDNSu8*)name, mDNSPlatformStrLen(name), MAX_DOMAIN_LABEL);
name[newlen] = 0;
}
if (!MakeDomainLabelFromLiteralString(&request->u.servicereg.name, name))
{ LogMsg("ERROR: handle_regservice_request - name bad %s", name); return(mStatus_BadParamErr); }
request->u.servicereg.autoname = mDNSfalse;
}
if (*domain)
{
request->u.servicereg.default_domain = mDNSfalse;
if (!MakeDomainNameFromDNSNameString(&d, domain))
{ LogMsg("ERROR: handle_regservice_request - domain bad %s", domain); return(mStatus_BadParamErr); }
}
else
{
request->u.servicereg.default_domain = mDNStrue;
MakeDomainNameFromDNSNameString(&d, "local.");
}
if (!ConstructServiceName(&srv, &request->u.servicereg.name, &request->u.servicereg.type, &d))
{
LogMsg("ERROR: handle_regservice_request - Couldn't ConstructServiceName from, “%#s” “%##s” “%##s”",
request->u.servicereg.name.c, request->u.servicereg.type.c, d.c); return(mStatus_BadParamErr);
}
if (!MakeDomainNameFromDNSNameString(&request->u.servicereg.host, host))
{ LogMsg("ERROR: handle_regservice_request - host bad %s", host); return(mStatus_BadParamErr); }
request->u.servicereg.autorename = (flags & kDNSServiceFlagsNoAutoRename ) == 0;
request->u.servicereg.allowremotequery = (flags & kDNSServiceFlagsAllowRemoteQuery) != 0;
if (!mDNSIPPortIsZero(request->u.servicereg.port))
{
int count = CountExistingRegistrations(&srv, request->u.servicereg.port);
if (count)
LogMsg("Client application registered %d identical instances of service %##s port %u.",
count+1, srv.c, mDNSVal16(request->u.servicereg.port));
}
LogOperation("%3d: DNSServiceRegister(\"%s\", \"%s\", \"%s\", \"%s\", %u) START",
request->sd, name, request->u.servicereg.type_as_string, domain, host, mDNSVal16(request->u.servicereg.port));
err = register_service_instance(request, &d);
if (!err)
{
request->terminate = regservice_termination_callback;
if (request->u.servicereg.autoname) UpdateDeviceInfoRecord(&mDNSStorage);
}
if (!err && !*domain)
{
DNameListElem *ptr;
for (ptr = AutoRegistrationDomains; ptr; ptr = ptr->next)
if (!ptr->uid || SystemUID(request->uid) || request->uid == ptr->uid)
register_service_instance(request, &ptr->name);
}
return(err);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceBrowse
#endif
mDNSlocal void FoundInstance(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
const DNSServiceFlags flags = AddRecord ? kDNSServiceFlagsAdd : 0;
request_state *req = question->QuestionContext;
reply_state *rep;
(void)m;
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, browse_reply_op, flags, mStatus_NoError) != 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 %d: %s",
req->sd, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "Add" : "Rmv",
mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID), RRDisplayString(m, answer));
append_reply(req, rep);
}
mDNSlocal mStatus add_domain_to_browser(request_state *info, const domainname *d)
{
browser_t *b, *p;
mStatus err;
for (p = info->u.browser.browsers; p; p = p->next)
{
if (SameDomainName(&p->domain, d))
{ debugf("add_domain_to_browser %##s 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(&mDNSStorage, &b->q,
&info->u.browser.regtype, d, info->u.browser.interface_id, info->u.browser.ForceMCast, FoundInstance, info);
if (err)
{
LogMsg("mDNS_StartBrowse returned %d for type %##s domain %##s", err, info->u.browser.regtype.c, d->c);
freeL("browser_t/add_domain_to_browser", b);
}
else
{
b->next = info->u.browser.browsers;
info->u.browser.browsers = b;
}
return err;
}
mDNSlocal void browse_termination_callback(request_state *info)
{
while (info->u.browser.browsers)
{
browser_t *ptr = info->u.browser.browsers;
info->u.browser.browsers = ptr->next;
LogOperation("%3d: DNSServiceBrowse(%##s) STOP", info->sd, ptr->q.qname.c);
mDNS_StopBrowse(&mDNSStorage, &ptr->q); freeL("browser_t/browse_termination_callback", ptr);
}
}
mDNSlocal void udsserver_automatic_browse_domain_changed(const DNameListElem *const d, const mDNSBool add)
{
request_state *request;
debugf("udsserver_automatic_browse_domain_changed: %s default browse domain %##s", add ? "Adding" : "Removing", d->name.c);
#if APPLE_OSX_mDNSResponder
machserver_automatic_browse_domain_changed(&d->name, add);
#endif // APPLE_OSX_mDNSResponder
for (request = all_requests; request; request = request->next)
{
if (request->terminate != browse_termination_callback) continue; if (!request->u.browser.default_domain) continue; if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
{
browser_t **ptr = &request->u.browser.browsers;
while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
if (add)
{
if (!*ptr) add_domain_to_browser(request, &d->name);
else debugf("udsserver_automatic_browse_domain_changed %##s already in list, not re-adding", &d->name);
}
else
{
if (!*ptr) LogMsg("udsserver_automatic_browse_domain_changed ERROR %##s not found", &d->name);
else
{
DNameListElem *p;
for (p = AutoBrowseDomains; p; p=p->next)
if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
if (SameDomainName(&d->name, &p->name)) break;
if (p) debugf("udsserver_automatic_browse_domain_changed %##s still in list, not removing", &d->name);
else
{
browser_t *rem = *ptr;
*ptr = (*ptr)->next;
mDNS_StopQueryWithRemoves(&mDNSStorage, &rem->q);
freeL("browser_t/udsserver_automatic_browse_domain_changed", rem);
}
}
}
}
}
}
mDNSlocal void FreeARElemCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
(void)m; if (result == mStatus_MemFree)
{
ARListElem **ptr = &LocalDomainEnumRecords;
while (*ptr && &(*ptr)->ar != rr) ptr = &(*ptr)->next;
if (*ptr) *ptr = (*ptr)->next;
mDNSPlatformMemFree(rr->RecordContext);
}
}
mDNSlocal void RegisterLocalOnlyDomainEnumPTR(mDNS *m, const domainname *d, int type)
{
mStatus err;
ARListElem *ptr = mDNSPlatformMemAllocate(sizeof(*ptr));
LogOperation("Incrementing %s refcount for %##s",
(type == mDNS_DomainTypeBrowse ) ? "browse domain " :
(type == mDNS_DomainTypeRegistration ) ? "registration dom" :
(type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
mDNS_SetupResourceRecord(&ptr->ar, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, 7200, kDNSRecordTypeShared, FreeARElemCallback, ptr);
MakeDomainNameFromDNSNameString(&ptr->ar.namestorage, mDNS_DomainTypeNames[type]);
AppendDNSNameString (&ptr->ar.namestorage, "local");
AssignDomainName(&ptr->ar.resrec.rdata->u.name, d);
err = mDNS_Register(m, &ptr->ar);
if (err)
{
LogMsg("SetSCPrefsBrowseDomain: mDNS_Register returned error %d", err);
mDNSPlatformMemFree(ptr);
}
else
{
ptr->next = LocalDomainEnumRecords;
LocalDomainEnumRecords = ptr;
}
}
mDNSlocal void DeregisterLocalOnlyDomainEnumPTR(mDNS *m, const domainname *d, int type)
{
ARListElem **ptr = &LocalDomainEnumRecords;
domainname lhs;
LogOperation("Decrementing %s refcount for %##s",
(type == mDNS_DomainTypeBrowse ) ? "browse domain " :
(type == mDNS_DomainTypeRegistration ) ? "registration dom" :
(type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
MakeDomainNameFromDNSNameString(&lhs, mDNS_DomainTypeNames[type]);
AppendDNSNameString (&lhs, "local");
while (*ptr)
{
if (SameDomainName(&(*ptr)->ar.resrec.rdata->u.name, d) && SameDomainName((*ptr)->ar.resrec.name, &lhs))
{
ARListElem *rem = *ptr;
*ptr = (*ptr)->next;
mDNS_Deregister(m, &rem->ar);
return;
}
else ptr = &(*ptr)->next;
}
}
mDNSlocal void AddAutoBrowseDomain(const mDNSu32 uid, const domainname *const name)
{
DNameListElem *new = mDNSPlatformMemAllocate(sizeof(DNameListElem));
if (!new) { LogMsg("ERROR: malloc"); return; }
AssignDomainName(&new->name, name);
new->uid = uid;
new->next = AutoBrowseDomains;
AutoBrowseDomains = new;
udsserver_automatic_browse_domain_changed(new, mDNStrue);
}
mDNSlocal void RmvAutoBrowseDomain(const mDNSu32 uid, const domainname *const name)
{
DNameListElem **p = &AutoBrowseDomains;
while (*p && (!SameDomainName(&(*p)->name, name) || (*p)->uid != uid)) p = &(*p)->next;
if (!*p) LogMsg("RmvAutoBrowseDomain: Got remove event for domain %##s not in list", name->c);
else
{
DNameListElem *ptr = *p;
*p = ptr->next;
udsserver_automatic_browse_domain_changed(ptr, mDNSfalse);
mDNSPlatformMemFree(ptr);
}
}
mDNSlocal void SetPrefsBrowseDomains(mDNS *m, DNameListElem *browseDomains, mDNSBool add)
{
DNameListElem *d;
for (d = browseDomains; d; d = d->next)
{
if (add)
{
RegisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
AddAutoBrowseDomain(d->uid, &d->name);
}
else
{
DeregisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
RmvAutoBrowseDomain(d->uid, &d->name);
}
}
}
mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m)
{
int num_autoname = 0;
request_state *req;
for (req = all_requests; req; req = req->next)
if (req->terminate == regservice_termination_callback && req->u.servicereg.autoname)
num_autoname++;
if (m->DeviceInfo.resrec.RecordType != kDNSRecordTypeUnregistered)
if (num_autoname == 0 || !SameDomainLabelCS(m->DeviceInfo.resrec.name->c, m->nicelabel.c))
{
LogOperation("UpdateDeviceInfoRecord Deregister %##s", m->DeviceInfo.resrec.name);
mDNS_Deregister(m, &m->DeviceInfo);
}
if (m->DeviceInfo.resrec.RecordType == kDNSRecordTypeUnregistered)
if (num_autoname > 0)
{
mDNSu8 len = m->HIHardware.c[0] < 255 - 6 ? m->HIHardware.c[0] : 255 - 6;
mDNS_SetupResourceRecord(&m->DeviceInfo, mDNSNULL, mDNSNULL, kDNSType_TXT, kStandardTTL, kDNSRecordTypeAdvisory, mDNSNULL, mDNSNULL);
ConstructServiceName(&m->DeviceInfo.namestorage, &m->nicelabel, &DeviceInfoName, &localdomain);
mDNSPlatformMemCopy(m->DeviceInfo.resrec.rdata->u.data + 1, "model=", 6);
mDNSPlatformMemCopy(m->DeviceInfo.resrec.rdata->u.data + 7, m->HIHardware.c + 1, len);
m->DeviceInfo.resrec.rdata->u.data[0] = 6 + len; m->DeviceInfo.resrec.rdlength = 7 + len; LogOperation("UpdateDeviceInfoRecord Register %##s", m->DeviceInfo.resrec.name);
mDNS_Register(m, &m->DeviceInfo);
}
}
mDNSexport void udsserver_handle_configchange(mDNS *const m)
{
request_state *req;
service_instance *ptr;
DNameListElem *RegDomains;
DNameListElem *BrowseDomains;
DNameListElem *p;
UpdateDeviceInfoRecord(m);
for (req = all_requests; req; req = req->next)
if (req->terminate == regservice_termination_callback)
if (req->u.servicereg.autoname && !SameDomainLabelCS(req->u.servicereg.name.c, m->nicelabel.c))
{
req->u.servicereg.name = m->nicelabel;
for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
{
ptr->renameonmemfree = 1;
if (ptr->clientnotified) SendServiceRemovalNotification(&ptr->srs);
if (mDNS_DeregisterService(m, &ptr->srs)) regservice_callback(m, &ptr->srs, mStatus_MemFree); }
}
mDNS_Lock(m);
mDNSPlatformSetDNSConfig(m, mDNSfalse, mDNSfalse, mDNSNULL, &RegDomains, &BrowseDomains);
mDNS_Unlock(m);
if (RegDomains) SetPrefsBrowseDomains(m, RegDomains, mDNStrue); if (AutoRegistrationDomains) SetPrefsBrowseDomains(m, AutoRegistrationDomains, mDNSfalse);
for (p=RegDomains; p; p=p->next)
{
DNameListElem **pp = &AutoRegistrationDomains;
while (*pp && ((*pp)->uid != p->uid || !SameDomainName(&(*pp)->name, &p->name))) pp = &(*pp)->next;
if (!*pp) {
RegisterLocalOnlyDomainEnumPTR(m, &p->name, mDNS_DomainTypeRegistration);
udsserver_default_reg_domain_changed(p, mDNStrue);
}
else {
DNameListElem *del = *pp;
*pp = (*pp)->next;
mDNSPlatformMemFree(del);
}
}
while (AutoRegistrationDomains)
{
DNameListElem *del = AutoRegistrationDomains;
AutoRegistrationDomains = AutoRegistrationDomains->next; DeregisterLocalOnlyDomainEnumPTR(m, &del->name, mDNS_DomainTypeRegistration);
udsserver_default_reg_domain_changed(del, mDNSfalse); mDNSPlatformMemFree(del);
}
AutoRegistrationDomains = RegDomains;
if (BrowseDomains) SetPrefsBrowseDomains(m, BrowseDomains, mDNStrue);
if (SCPrefBrowseDomains)
{
SetPrefsBrowseDomains(m, SCPrefBrowseDomains, mDNSfalse);
while (SCPrefBrowseDomains)
{
DNameListElem *fptr = SCPrefBrowseDomains;
SCPrefBrowseDomains = SCPrefBrowseDomains->next;
mDNSPlatformMemFree(fptr);
}
}
SCPrefBrowseDomains = BrowseDomains;
}
mDNSlocal void AutomaticBrowseDomainChange(mDNS *const m, DNSQuestion *q, const ResourceRecord *const answer, QC_result AddRecord)
{
(void)m; (void)q;
LogOperation("AutomaticBrowseDomainChange: %s automatic browse domain %##s",
AddRecord ? "Adding" : "Removing", answer->rdata->u.name.c);
if (AddRecord) AddAutoBrowseDomain(0, &answer->rdata->u.name);
else RmvAutoBrowseDomain(0, &answer->rdata->u.name);
}
mDNSlocal mStatus handle_browse_request(request_state *request)
{
char regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
domainname typedn, d, temp;
mDNSs32 NumSubTypes;
mStatus err = mStatus_NoError;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
if (get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0) return(mStatus_BadParamErr);
if (!request->msgptr) { LogMsg("%3d: DNSServiceBrowse(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
if (domain[0] == '\0') uDNS_RegisterSearchDomains(&mDNSStorage);
typedn.c[0] = 0;
NumSubTypes = ChopSubTypes(regtype); if (NumSubTypes < 0 || NumSubTypes > 1) return(mStatus_BadParamErr);
if (NumSubTypes == 1 && !AppendDNSNameString(&typedn, regtype + strlen(regtype) + 1)) return(mStatus_BadParamErr);
if (!regtype[0] || !AppendDNSNameString(&typedn, regtype)) return(mStatus_BadParamErr);
if (!MakeDomainNameFromDNSNameString(&temp, regtype)) return(mStatus_BadParamErr);
if (temp.c[0] > 15 && domain[0] == 0) mDNSPlatformStrCopy(domain, "local.");
request->u.browser.ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;
request->u.browser.interface_id = InterfaceID;
AssignDomainName(&request->u.browser.regtype, &typedn);
request->u.browser.default_domain = !domain[0];
request->u.browser.browsers = NULL;
LogOperation("%3d: DNSServiceBrowse(\"%##s\", \"%s\") START", request->sd, request->u.browser.regtype.c, domain);
if (domain[0])
{
if (!MakeDomainNameFromDNSNameString(&d, domain)) return(mStatus_BadParamErr);
err = add_domain_to_browser(request, &d);
}
else
{
DNameListElem *sdom;
for (sdom = AutoBrowseDomains; sdom; sdom = sdom->next)
if (!sdom->uid || SystemUID(request->uid) || request->uid == sdom->uid)
{
err = add_domain_to_browser(request, &sdom->name);
if (err)
{
if (SameDomainName(&sdom->name, &localdomain)) break;
else err = mStatus_NoError; }
}
}
if (!err) request->terminate = browse_termination_callback;
return(err);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceResolve
#endif
mDNSlocal void resolve_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
size_t len = 0;
char fullname[MAX_ESCAPED_DOMAIN_NAME], target[MAX_ESCAPED_DOMAIN_NAME];
char *data;
reply_state *rep;
request_state *req = question->QuestionContext;
(void)m;
LogOperation("%3d: DNSServiceResolve(%##s, %s) %s %s",
req->sd, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "ADD" : "RMV", RRDisplayString(m, answer));
if (!AddRecord)
{
if (answer->rrtype == kDNSType_SRV && req->u.resolve.srv == answer) req->u.resolve.srv = mDNSNULL;
if (answer->rrtype == kDNSType_TXT && req->u.resolve.txt == answer) req->u.resolve.txt = mDNSNULL;
return;
}
if (answer->rrtype == kDNSType_SRV) req->u.resolve.srv = answer;
if (answer->rrtype == kDNSType_TXT) req->u.resolve.txt = answer;
if (!req->u.resolve.txt || !req->u.resolve.srv) return;
ConvertDomainNameToCString(answer->name, fullname);
ConvertDomainNameToCString(&req->u.resolve.srv->rdata->u.srv.target, target);
len += sizeof(DNSServiceFlags);
len += sizeof(mDNSu32); len += sizeof(DNSServiceErrorType);
len += strlen(fullname) + 1;
len += strlen(target) + 1;
len += 2 * sizeof(mDNSu16); len += req->u.resolve.txt->rdlength;
rep = create_reply(resolve_reply_op, len, req);
rep->rhdr->flags = dnssd_htonl(0);
rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID));
rep->rhdr->error = dnssd_htonl(kDNSServiceErr_NoError);
data = rep->sdata;
put_string(fullname, &data);
put_string(target, &data);
*data++ = req->u.resolve.srv->rdata->u.srv.port.b[0];
*data++ = req->u.resolve.srv->rdata->u.srv.port.b[1];
put_uint16(req->u.resolve.txt->rdlength, &data);
put_rdata(req->u.resolve.txt->rdlength, req->u.resolve.txt->rdata->u.data, &data);
append_reply(req, rep);
}
mDNSlocal void resolve_termination_callback(request_state *request)
{
LogOperation("%3d: DNSServiceResolve(%##s) STOP", request->sd, request->u.resolve.qtxt.qname.c);
mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qtxt);
mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
}
mDNSlocal mStatus handle_resolve_request(request_state *request)
{
char name[256], regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
domainname fqdn;
mStatus err;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
if (interfaceIndex && !InterfaceID)
{ LogMsg("ERROR: handle_resolve_request bad interfaceIndex %d", interfaceIndex); return(mStatus_BadParamErr); }
if (get_string(&request->msgptr, request->msgend, name, 256) < 0 ||
get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0)
{ LogMsg("ERROR: handle_resolve_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
if (!request->msgptr) { LogMsg("%3d: DNSServiceResolve(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
if (build_domainname_from_strings(&fqdn, name, regtype, domain) < 0)
{ LogMsg("ERROR: handle_resolve_request bad “%s” “%s” “%s”", name, regtype, domain); return(mStatus_BadParamErr); }
mDNSPlatformMemZero(&request->u.resolve, sizeof(request->u.resolve));
request->u.resolve.qsrv.InterfaceID = InterfaceID;
request->u.resolve.qsrv.Target = zeroAddr;
AssignDomainName(&request->u.resolve.qsrv.qname, &fqdn);
request->u.resolve.qsrv.qtype = kDNSType_SRV;
request->u.resolve.qsrv.qclass = kDNSClass_IN;
request->u.resolve.qsrv.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
request->u.resolve.qsrv.ExpectUnique = mDNStrue;
request->u.resolve.qsrv.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
request->u.resolve.qsrv.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
request->u.resolve.qsrv.QuestionCallback = resolve_result_callback;
request->u.resolve.qsrv.QuestionContext = request;
request->u.resolve.qtxt.InterfaceID = InterfaceID;
request->u.resolve.qtxt.Target = zeroAddr;
AssignDomainName(&request->u.resolve.qtxt.qname, &fqdn);
request->u.resolve.qtxt.qtype = kDNSType_TXT;
request->u.resolve.qtxt.qclass = kDNSClass_IN;
request->u.resolve.qtxt.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
request->u.resolve.qtxt.ExpectUnique = mDNStrue;
request->u.resolve.qtxt.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
request->u.resolve.qtxt.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
request->u.resolve.qtxt.QuestionCallback = resolve_result_callback;
request->u.resolve.qtxt.QuestionContext = request;
request->u.resolve.ReportTime = NonZeroTime(mDNS_TimeNow(&mDNSStorage) + 130 * mDNSPlatformOneSecond);
LogOperation("%3d: DNSServiceResolve(%##s) START", request->sd, request->u.resolve.qsrv.qname.c);
err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qsrv);
if (!err)
{
err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qtxt);
if (err) mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
}
if (!err) request->terminate = resolve_termination_callback;
return(err);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceQueryRecord
#endif
mDNSlocal void queryrecord_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
char name[MAX_ESCAPED_DOMAIN_NAME];
request_state *req = question->QuestionContext;
reply_state *rep;
char *data;
size_t len;
DNSServiceErrorType error = kDNSServiceErr_NoError;
(void)m;
LogOperation("%3d: %s(%##s, %s) %s %s", req->sd,
req->hdr.op == query_request ? "DNSServiceQueryRecord" : "DNSServiceGetAddrInfo",
question->qname.c, DNSTypeName(question->qtype), AddRecord ? "ADD" : "RMV", RRDisplayString(m, answer));
if (answer->RecordType == kDNSRecordTypePacketNegative)
{
error = kDNSServiceErr_NoSuchRecord;
ConvertDomainNameToCString(&question->qname, name);
AddRecord = mDNStrue;
}
else
ConvertDomainNameToCString(answer->name, name);
len = sizeof(DNSServiceFlags); len += sizeof(mDNSu32); len += sizeof(DNSServiceErrorType);
len += strlen(name) + 1;
len += 3 * sizeof(mDNSu16); len += answer->rdlength;
len += sizeof(mDNSu32);
rep = create_reply(req->hdr.op == query_request ? query_reply_op : addrinfo_reply_op, len, req);
rep->rhdr->flags = dnssd_htonl(AddRecord ? kDNSServiceFlagsAdd : 0);
rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID));
rep->rhdr->error = dnssd_htonl(error);
data = rep->sdata;
put_string(name, &data);
if (answer->RecordType == kDNSRecordTypePacketNegative)
{
put_uint16(question->qtype, &data);
put_uint16(question->qclass, &data);
put_uint16(0, &data);
put_rdata(0, mDNSNULL, &data);
put_uint32(0, &data);
}
else
{
put_uint16(answer->rrtype, &data);
put_uint16(answer->rrclass, &data);
put_uint16(answer->rdlength, &data);
if (!putRData(mDNSNULL, (mDNSu8 *)data, (mDNSu8 *)rep->rhdr + len, answer))
LogMsg("queryrecord_result_callback putRData failed %d", (mDNSu8 *)rep->rhdr + len - (mDNSu8 *)data);
data += answer->rdlength;
put_uint32(AddRecord ? answer->rroriginalttl : 0, &data);
}
append_reply(req, rep);
}
mDNSlocal void queryrecord_termination_callback(request_state *request)
{
LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) STOP",
request->sd, request->u.queryrecord.q.qname.c, DNSTypeName(request->u.queryrecord.q.qtype));
mDNS_StopQuery(&mDNSStorage, &request->u.queryrecord.q); }
mDNSlocal mStatus handle_queryrecord_request(request_state *request)
{
char name[256];
mDNSu16 rrtype, rrclass;
mStatus err;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
if (get_string(&request->msgptr, request->msgend, name, 256) < 0) return(mStatus_BadParamErr);
rrtype = get_uint16(&request->msgptr, request->msgend);
rrclass = get_uint16(&request->msgptr, request->msgend);
if (!request->msgptr)
{ LogMsg("%3d: DNSServiceQueryRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
mDNSPlatformMemZero(&request->u.queryrecord.q, sizeof(&request->u.queryrecord.q));
request->u.queryrecord.q.InterfaceID = InterfaceID;
request->u.queryrecord.q.Target = zeroAddr;
if (!MakeDomainNameFromDNSNameString(&request->u.queryrecord.q.qname, name)) return(mStatus_BadParamErr);
request->u.queryrecord.q.qtype = rrtype;
request->u.queryrecord.q.qclass = rrclass;
request->u.queryrecord.q.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
request->u.queryrecord.q.ExpectUnique = mDNSfalse;
request->u.queryrecord.q.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
request->u.queryrecord.q.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
request->u.queryrecord.q.QuestionCallback = queryrecord_result_callback;
request->u.queryrecord.q.QuestionContext = request;
LogOperation("%3d: DNSServiceQueryRecord(%##s, %s, %X) START",
request->sd, request->u.queryrecord.q.qname.c, DNSTypeName(request->u.queryrecord.q.qtype), flags);
err = mDNS_StartQuery(&mDNSStorage, &request->u.queryrecord.q);
if (err) LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
if (!err) request->terminate = queryrecord_termination_callback;
return(err);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceEnumerateDomains
#endif
mDNSlocal reply_state *format_enumeration_reply(request_state *request,
const char *domain, DNSServiceFlags flags, mDNSu32 ifi, DNSServiceErrorType err)
{
size_t len;
reply_state *reply;
char *data;
len = sizeof(DNSServiceFlags);
len += sizeof(mDNSu32);
len += sizeof(DNSServiceErrorType);
len += strlen(domain) + 1;
reply = create_reply(enumeration_reply_op, len, request);
reply->rhdr->flags = dnssd_htonl(flags);
reply->rhdr->ifi = dnssd_htonl(ifi);
reply->rhdr->error = dnssd_htonl(err);
data = reply->sdata;
put_string(domain, &data);
return reply;
}
mDNSlocal void enum_termination_callback(request_state *request)
{
mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_default);
}
mDNSlocal void enum_result_callback(mDNS *const m,
DNSQuestion *const question, const ResourceRecord *const answer, QC_result AddRecord)
{
char domain[MAX_ESCAPED_DOMAIN_NAME];
request_state *request = question->QuestionContext;
DNSServiceFlags flags = 0;
reply_state *reply;
(void)m;
if (answer->rrtype != kDNSType_PTR) return;
if (question == &request->u.enumeration.q_default && !AddRecord) return;
if (AddRecord)
{
flags |= kDNSServiceFlagsAdd;
if (question == &request->u.enumeration.q_default) flags |= kDNSServiceFlagsDefault;
}
ConvertDomainNameToCString(&answer->rdata->u.name, domain);
reply = format_enumeration_reply(request, domain, flags, kDNSServiceInterfaceIndexAny, kDNSServiceErr_NoError);
if (!reply) { LogMsg("ERROR: enum_result_callback, format_enumeration_reply"); return; }
append_reply(request, reply);
}
mDNSlocal mStatus handle_enum_request(request_state *request)
{
mStatus err;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
DNSServiceFlags reg = flags & kDNSServiceFlagsRegistrationDomains;
mDNS_DomainType t_all = reg ? mDNS_DomainTypeRegistration : mDNS_DomainTypeBrowse;
mDNS_DomainType t_default = reg ? mDNS_DomainTypeRegistrationDefault : mDNS_DomainTypeBrowseDefault;
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
if (!request->msgptr)
{ LogMsg("%3d: DNSServiceEnumerateDomains(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
uDNS_RegisterSearchDomains(&mDNSStorage);
request->u.enumeration.q_all .QuestionContext = request;
request->u.enumeration.q_default.QuestionContext = request;
if (!InterfaceID) InterfaceID = mDNSInterface_LocalOnly;
LogOperation("%3d: DNSServiceEnumerateDomains(%X=%s)", request->sd, flags,
(flags & kDNSServiceFlagsBrowseDomains ) ? "kDNSServiceFlagsBrowseDomains" :
(flags & kDNSServiceFlagsRegistrationDomains) ? "kDNSServiceFlagsRegistrationDomains" : "<<Unknown>>");
err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_all, t_all, NULL, InterfaceID, enum_result_callback, request);
if (!err)
{
err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_default, t_default, NULL, InterfaceID, enum_result_callback, request);
if (err) mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
}
if (!err) request->terminate = enum_termination_callback;
return(err);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceReconfirmRecord & Misc
#endif
mDNSlocal mStatus handle_reconfirm_request(request_state *request)
{
mStatus status = mStatus_BadParamErr;
AuthRecord *rr = read_rr_from_ipc_msg(request, 0, 0);
if (rr)
{
status = mDNS_ReconfirmByValue(&mDNSStorage, &rr->resrec);
LogOperation(
(status == mStatus_NoError) ?
"%3d: DNSServiceReconfirmRecord(%s) interface %d initiated" :
"%3d: DNSServiceReconfirmRecord(%s) interface %d failed: %d",
request->sd, RRDisplayString(&mDNSStorage, &rr->resrec),
mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, rr->resrec.InterfaceID), status);
freeL("AuthRecord/handle_reconfirm_request", rr);
}
return(status);
}
mDNSlocal mStatus handle_setdomain_request(request_state *request)
{
char domainstr[MAX_ESCAPED_DOMAIN_NAME];
domainname domain;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
(void)flags; if (get_string(&request->msgptr, request->msgend, domainstr, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
!MakeDomainNameFromDNSNameString(&domain, domainstr))
{ LogMsg("%3d: DNSServiceSetDefaultDomainForUser(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
LogOperation("%3d: DNSServiceSetDefaultDomainForUser(%##s)", request->sd, domain.c);
return(mStatus_NoError);
}
typedef packedstruct
{
mStatus err;
mDNSu32 len;
mDNSu32 vers;
} DaemonVersionReply;
mDNSlocal void handle_getproperty_request(request_state *request)
{
const mStatus BadParamErr = dnssd_htonl(mStatus_BadParamErr);
char prop[256];
if (get_string(&request->msgptr, request->msgend, prop, sizeof(prop)) >= 0)
{
LogOperation("%3d: DNSServiceGetProperty(%s)", request->sd, prop);
if (!strcmp(prop, kDNSServiceProperty_DaemonVersion))
{
DaemonVersionReply x = { 0, dnssd_htonl(4), dnssd_htonl(_DNS_SD_H) };
send_all(request->sd, (const char *)&x, sizeof(x));
return;
}
}
send_all(request->sd, (const char *)&BadParamErr, sizeof(BadParamErr));
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceNATPortMappingCreate
#endif
#define DNSServiceProtocol(X) ((X) == NATOp_AddrRequest ? 0 : (X) == NATOp_MapUDP ? kDNSServiceProtocol_UDP : kDNSServiceProtocol_TCP)
mDNSlocal void port_mapping_termination_callback(request_state *request)
{
LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) STOP", request->sd,
DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease);
mDNS_StopNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
}
mDNSlocal void port_mapping_create_request_callback(mDNS *m, NATTraversalInfo *n)
{
request_state *request = (request_state *)n->clientContext;
reply_state *rep;
int replyLen;
char *data;
if (!request) { LogMsg("port_mapping_create_request_callback called with unknown request_state object"); return; }
replyLen = sizeof(DNSServiceFlags);
replyLen += 3 * sizeof(mDNSu32); replyLen += sizeof(DNSServiceErrorType);
replyLen += 2 * sizeof(mDNSu16); replyLen += sizeof(mDNSu8);
rep = create_reply(port_mapping_reply_op, replyLen, request);
rep->rhdr->flags = dnssd_htonl(0);
rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, n->InterfaceID));
rep->rhdr->error = dnssd_htonl(n->Result);
data = rep->sdata;
*data++ = request->u.pm.NATinfo.ExternalAddress.b[0];
*data++ = request->u.pm.NATinfo.ExternalAddress.b[1];
*data++ = request->u.pm.NATinfo.ExternalAddress.b[2];
*data++ = request->u.pm.NATinfo.ExternalAddress.b[3];
*data++ = DNSServiceProtocol(request->u.pm.NATinfo.Protocol);
*data++ = request->u.pm.NATinfo.IntPort.b[0];
*data++ = request->u.pm.NATinfo.IntPort.b[1];
*data++ = request->u.pm.NATinfo.ExternalPort.b[0];
*data++ = request->u.pm.NATinfo.ExternalPort.b[1];
put_uint32(request->u.pm.NATinfo.Lifetime, &data);
LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) RESULT %.4a:%u TTL %u", request->sd,
DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
&request->u.pm.NATinfo.ExternalAddress, mDNSVal16(request->u.pm.NATinfo.ExternalPort), request->u.pm.NATinfo.Lifetime);
append_reply(request, rep);
}
mDNSlocal mStatus handle_port_mapping_request(request_state *request)
{
mDNSu32 ttl = 0;
mStatus err = mStatus_NoError;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
mDNSu8 protocol = get_uint32(&request->msgptr, request->msgend);
(void)flags; if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
if (request->msgptr + 8 > request->msgend) request->msgptr = NULL;
else
{
request->u.pm.NATinfo.IntPort.b[0] = *request->msgptr++;
request->u.pm.NATinfo.IntPort.b[1] = *request->msgptr++;
request->u.pm.ReqExt.b[0] = *request->msgptr++;
request->u.pm.ReqExt.b[1] = *request->msgptr++;
ttl = get_uint32(&request->msgptr, request->msgend);
}
if (!request->msgptr)
{ LogMsg("%3d: DNSServiceNATPortMappingCreate(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
if (protocol == 0) {
if (!mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort) || !mDNSIPPortIsZero(request->u.pm.ReqExt) || ttl) return(mStatus_BadParamErr);
}
else
{
if (mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort)) return(mStatus_BadParamErr);
if (!(protocol & (kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP))) return(mStatus_BadParamErr);
}
request->u.pm.NATinfo.Protocol = !protocol ? NATOp_AddrRequest : (protocol == kDNSServiceProtocol_UDP) ? NATOp_MapUDP : NATOp_MapTCP;
request->u.pm.NATinfo.RequestedPort = request->u.pm.ReqExt;
request->u.pm.NATinfo.NATLease = ttl;
request->u.pm.NATinfo.clientCallback = port_mapping_create_request_callback;
request->u.pm.NATinfo.clientContext = request;
LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) START", request->sd,
protocol, mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease);
err = mDNS_StartNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
if (!err) request->terminate = port_mapping_termination_callback;
return(err);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNSServiceGetAddrInfo
#endif
mDNSlocal void addrinfo_termination_callback(request_state *request)
{
if (request->u.addrinfo.q4.QuestionContext)
{
mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q4);
request->u.addrinfo.q4.QuestionContext = mDNSNULL;
}
if (request->u.addrinfo.q6.QuestionContext)
{
mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q6);
request->u.addrinfo.q6.QuestionContext = mDNSNULL;
}
}
mDNSlocal mStatus handle_addrinfo_request(request_state *request)
{
char hostname[256];
domainname d;
mStatus err = 0;
DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
request->u.addrinfo.interface_id = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
if (interfaceIndex && !request->u.addrinfo.interface_id) return(mStatus_BadParamErr);
request->u.addrinfo.flags = flags;
request->u.addrinfo.protocol = get_uint32(&request->msgptr, request->msgend);
if (request->u.addrinfo.protocol > (kDNSServiceProtocol_IPv4|kDNSServiceProtocol_IPv6))
return(mStatus_BadParamErr);
if (get_string(&request->msgptr, request->msgend, hostname, 256) < 0) return(mStatus_BadParamErr);
if (!request->msgptr) { LogMsg("%3d: DNSServiceGetAddrInfo(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
if (!MakeDomainNameFromDNSNameString(&d, hostname))
{ LogMsg("ERROR: handle_addrinfo_request: bad hostname: %s", hostname); return(mStatus_BadParamErr); }
if (!request->u.addrinfo.protocol)
{
NetworkInterfaceInfo *i;
if (IsLocalDomain(&d))
{
for (i = mDNSStorage.HostInterfaces; i; i = i->next)
{
if ((i->ip.type == mDNSAddrType_IPv4) && !mDNSIPv4AddressIsZero(i->ip.ip.v4)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv4;
else if ((i->ip.type == mDNSAddrType_IPv6) && !mDNSIPv6AddressIsZero(i->ip.ip.v6)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv6;
}
}
else
{
for (i = mDNSStorage.HostInterfaces; i; i = i->next)
{
if ((i->ip.type == mDNSAddrType_IPv4) && !mDNSv4AddressIsLinkLocal(&i->ip.ip.v4)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv4;
else if ((i->ip.type == mDNSAddrType_IPv6) && !mDNSv4AddressIsLinkLocal(&i->ip.ip.v6)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv6;
}
}
}
if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv4)
{
request->u.addrinfo.q4.InterfaceID = request->u.addrinfo.interface_id;
request->u.addrinfo.q4.Target = zeroAddr;
request->u.addrinfo.q4.qname = d;
request->u.addrinfo.q4.qtype = kDNSServiceType_A;
request->u.addrinfo.q4.qclass = kDNSServiceClass_IN;
request->u.addrinfo.q4.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
request->u.addrinfo.q4.ExpectUnique = mDNSfalse;
request->u.addrinfo.q4.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
request->u.addrinfo.q4.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
request->u.addrinfo.q4.QuestionCallback = queryrecord_result_callback;
request->u.addrinfo.q4.QuestionContext = request;
err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q4);
if (err != mStatus_NoError)
{
LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
request->u.addrinfo.q4.QuestionContext = mDNSNULL;
}
}
if (!err && (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv6))
{
request->u.addrinfo.q6.InterfaceID = request->u.addrinfo.interface_id;
request->u.addrinfo.q6.Target = zeroAddr;
request->u.addrinfo.q6.qname = d;
request->u.addrinfo.q6.qtype = kDNSServiceType_AAAA;
request->u.addrinfo.q6.qclass = kDNSServiceClass_IN;
request->u.addrinfo.q6.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
request->u.addrinfo.q6.ExpectUnique = mDNSfalse;
request->u.addrinfo.q6.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
request->u.addrinfo.q6.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
request->u.addrinfo.q6.QuestionCallback = queryrecord_result_callback;
request->u.addrinfo.q6.QuestionContext = request;
err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q6);
if (err != mStatus_NoError)
{
LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
request->u.addrinfo.q6.QuestionContext = mDNSNULL;
}
}
LogOperation("%3d: DNSServiceGetAddrInfo(%##s) START", request->sd, d.c);
if (!err) request->terminate = addrinfo_termination_callback;
return(err);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Main Request Handler etc.
#endif
mDNSlocal request_state *NewRequest(void)
{
request_state **p = &all_requests;
while (*p) p=&(*p)->next;
*p = mallocL("request_state", sizeof(request_state));
if (!*p) FatalError("ERROR: malloc");
mDNSPlatformMemZero(*p, sizeof(request_state));
return(*p);
}
mDNSlocal void read_msg(request_state *req)
{
if (req->ts == t_terminated || req->ts == t_error)
{ LogMsg("%3d: ERROR: read_msg called with transfer state terminated or error", req->sd); req->ts = t_error; return; }
if (req->ts == t_complete) {
char buf[4]; int nread = recv(req->sd, buf, 4, 0);
if (!nread) { req->ts = t_terminated; return; }
if (nread < 0) goto rerror;
LogMsg("%3d: ERROR: read data from a completed request", req->sd);
req->ts = t_error;
return;
}
if (req->ts != t_morecoming)
{ LogMsg("%3d: ERROR: read_msg called with invalid transfer state (%d)", req->sd, req->ts); req->ts = t_error; return; }
if (req->hdr_bytes < sizeof(ipc_msg_hdr))
{
mDNSu32 nleft = sizeof(ipc_msg_hdr) - req->hdr_bytes;
int nread = recv(req->sd, (char *)&req->hdr + req->hdr_bytes, nleft, 0);
if (nread == 0) { req->ts = t_terminated; return; }
if (nread < 0) goto rerror;
req->hdr_bytes += nread;
if (req->hdr_bytes > sizeof(ipc_msg_hdr))
{ LogMsg("%3d: ERROR: read_msg - read too many header bytes", req->sd); req->ts = t_error; return; }
if (req->hdr_bytes == sizeof(ipc_msg_hdr))
{
ConvertHeaderBytes(&req->hdr);
if (req->hdr.version != VERSION)
{ LogMsg("%3d: ERROR: client version 0x%08X daemon version 0x%08X", req->sd, req->hdr.version, VERSION); req->ts = t_error; return; }
if (req->hdr.datalen > 70000)
{ LogMsg("%3d: ERROR: read_msg - hdr.datalen %lu (%X) > 70000", req->sd, req->hdr.datalen, req->hdr.datalen); req->ts = t_error; return; }
req->msgbuf = mallocL("request_state msgbuf", req->hdr.datalen + MSG_PAD_BYTES);
if (!req->msgbuf) { my_perror("ERROR: malloc"); req->ts = t_error; return; }
req->msgptr = req->msgbuf;
req->msgend = req->msgbuf + req->hdr.datalen;
mDNSPlatformMemZero(req->msgbuf, req->hdr.datalen + MSG_PAD_BYTES);
}
}
if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes < req->hdr.datalen)
{
mDNSu32 nleft = req->hdr.datalen - req->data_bytes;
int nread;
struct iovec vec = { req->msgbuf + req->data_bytes, nleft }; struct msghdr msg;
struct cmsghdr *cmsg;
char cbuf[CMSG_SPACE(sizeof(dnssd_sock_t))];
msg.msg_name = 0;
msg.msg_namelen = 0;
msg.msg_iov = &vec;
msg.msg_iovlen = 1;
msg.msg_control = cbuf;
msg.msg_controllen = sizeof(cbuf);
msg.msg_flags = 0;
nread = recvmsg(req->sd, &msg, 0);
if (nread == 0) { req->ts = t_terminated; return; }
if (nread < 0) goto rerror;
req->data_bytes += nread;
if (req->data_bytes > req->hdr.datalen)
{ LogMsg("%3d: ERROR: read_msg - read too many data bytes", req->sd); req->ts = t_error; return; }
cmsg = CMSG_FIRSTHDR(&msg);
#if DEBUG_64BIT_SCM_RIGHTS
LogMsg("%3d: Expecting %d %d %d %d", req->sd, sizeof(cbuf), sizeof(cbuf), SOL_SOCKET, SCM_RIGHTS);
LogMsg("%3d: Got %d %d %d %d", req->sd, msg.msg_controllen, cmsg->cmsg_len, cmsg->cmsg_level, cmsg->cmsg_type);
#endif DEBUG_64BIT_SCM_RIGHTS
if (msg.msg_controllen == sizeof(cbuf) &&
cmsg->cmsg_len == sizeof(cbuf) &&
cmsg->cmsg_level == SOL_SOCKET &&
cmsg->cmsg_type == SCM_RIGHTS)
{
req->errsd = *(dnssd_sock_t *)CMSG_DATA(cmsg);
#if DEBUG_64BIT_SCM_RIGHTS
LogMsg("%3d: read req->errsd %d", req->sd, req->errsd);
#endif DEBUG_64BIT_SCM_RIGHTS
if (req->data_bytes < req->hdr.datalen)
{
LogMsg("%3d: Client sent error socket %d via SCM_RIGHTS with req->data_bytes %d < req->hdr.datalen %d",
req->sd, req->errsd, req->data_bytes, req->hdr.datalen);
req->ts = t_error;
return;
}
}
}
if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes == req->hdr.datalen)
{
if (req->terminate && req->hdr.op != cancel_request)
{
dnssd_sockaddr_t cliaddr;
#if defined(USE_TCP_LOOPBACK)
mDNSOpaque16 port;
port.b[0] = req->msgptr[0];
port.b[1] = req->msgptr[1];
req->msgptr += 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(&req->msgptr, req->msgend, ctrl_path, MAX_CTLPATH); mDNSPlatformMemZero(&cliaddr, sizeof(cliaddr));
cliaddr.sun_family = AF_LOCAL;
mDNSPlatformStrCopy(cliaddr.sun_path, ctrl_path);
if (ctrl_path[0] == 0)
{
if (req->errsd == req->sd)
{ LogMsg("%3d: read_msg: ERROR failed to get errsd via SCM_RIGHTS", req->sd); req->ts = t_error; return; }
goto got_errfd;
}
#endif
req->errsd = socket(AF_DNSSD, SOCK_STREAM, 0);
if (!dnssd_SocketValid(req->errsd)) { my_perror("ERROR: socket"); req->ts = t_error; return; }
if (connect(req->errsd, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) < 0)
{
#if !defined(USE_TCP_LOOPBACK)
struct stat sb;
LogMsg("%3d: read_msg: Couldn't connect to error return path socket “%s” errno %d %s",
req->sd, cliaddr.sun_path, dnssd_errno(), dnssd_strerror(dnssd_errno()));
if (stat(cliaddr.sun_path, &sb) < 0)
LogMsg("%3d: read_msg: stat failed “%s” errno %d %s", req->sd, cliaddr.sun_path, dnssd_errno(), dnssd_strerror(dnssd_errno()));
else
LogMsg("%3d: read_msg: file “%s” mode %o (octal) uid %d gid %d", req->sd, cliaddr.sun_path, sb.st_mode, sb.st_uid, sb.st_gid);
#endif
req->ts = t_error;
return;
}
got_errfd:
LogOperation("%3d: Using separate error socket %d", req->sd, req->errsd);
#if defined(_WIN32)
if (ioctlsocket(req->errsd, FIONBIO, &opt) != 0)
#else
if (fcntl(req->errsd, F_SETFL, fcntl(req->errsd, F_GETFL, 0) | O_NONBLOCK) != 0)
#endif
{
LogMsg("%3d: ERROR: could not set control socket to non-blocking mode errno %d %s",
req->sd, dnssd_errno(), dnssd_strerror(dnssd_errno()));
req->ts = t_error;
return;
}
}
req->ts = t_complete;
}
return;
rerror:
if (dnssd_errno() == dnssd_EWOULDBLOCK || dnssd_errno() == dnssd_EINTR) return;
LogMsg("%3d: ERROR: read_msg errno %d %s", req->sd, dnssd_errno(), dnssd_strerror(dnssd_errno()));
req->ts = t_error;
}
#define RecordOrientedOp(X) \
((X) == reg_record_request || (X) == add_record_request || (X) == update_record_request || (X) == remove_record_request)
#define LightweightOp(X) (RecordOrientedOp(X) || (X) == cancel_request)
mDNSlocal void request_callback(int fd, short filter, void *info)
{
mStatus err = 0;
request_state *req = info;
#if defined(_WIN32)
u_long opt = 1;
#endif
mDNSs32 min_size = sizeof(DNSServiceFlags);
(void)fd; (void)filter;
read_msg(req);
if (req->ts == t_morecoming) return;
if (req->ts == t_terminated || req->ts == t_error) { AbortUnlinkAndFree(req); return; }
if (req->hdr.version != VERSION)
{
LogMsg("ERROR: client version %d incompatible with daemon version %d", req->hdr.version, VERSION);
AbortUnlinkAndFree(req);
return;
}
switch(req->hdr.op) {
case connection_request: min_size = 0; break;
case reg_service_request: min_size += sizeof(mDNSu32) + 4 + 4 ; break;
case add_record_request: min_size += 4 + 4 ; break;
case update_record_request: min_size += 2 + 4 ; break;
case remove_record_request: break;
case browse_request: min_size += sizeof(mDNSu32) + 2 ; break;
case resolve_request: min_size += sizeof(mDNSu32) + 3 ; break;
case query_request: min_size += sizeof(mDNSu32) + 1 + 4 ; break;
case enumeration_request: min_size += sizeof(mDNSu32); break;
case reg_record_request: min_size += sizeof(mDNSu32) + 1 + 6 + 4 ; break;
case reconfirm_record_request: min_size += sizeof(mDNSu32) + 1 + 6 ; break;
case setdomain_request: min_size += 1 ; break;
case getproperty_request: min_size = 2; break;
case port_mapping_request: min_size += sizeof(mDNSu32) + 4 + 4 + 4 ; break;
case addrinfo_request: min_size += sizeof(mDNSu32) + 4 + 1 ; break;
case cancel_request: min_size = 0; break;
default: LogMsg("ERROR: validate_message - unsupported req type: %d", req->hdr.op); min_size = -1; break;
}
if ((mDNSs32)req->data_bytes < min_size)
{ LogMsg("Invalid message %d bytes; min for %d is %d", req->data_bytes, req->hdr.op, min_size); AbortUnlinkAndFree(req); return; }
if (LightweightOp(req->hdr.op) && !req->terminate)
{ LogMsg("Reg/Add/Update/Remove %d require existing connection", req->hdr.op); AbortUnlinkAndFree(req); return; }
if (req->hdr.ipc_flags & IPC_FLAGS_NOREPLY) req->no_reply = 1;
if (req->terminate && !LightweightOp(req->hdr.op))
{
request_state *newreq = NewRequest();
newreq->primary = req;
newreq->sd = req->sd;
newreq->errsd = req->errsd;
newreq->uid = req->uid;
newreq->hdr = req->hdr;
newreq->msgbuf = req->msgbuf;
newreq->msgptr = req->msgptr;
newreq->msgend = req->msgend;
req = newreq;
}
if (mDNSStorage.ShutdownTime && req->hdr.op != cancel_request && req->hdr.op != getproperty_request)
{
err = mStatus_ServiceNotRunning;
}
else switch(req->hdr.op)
{
case connection_request:
LogOperation("%3d: DNSServiceCreateConnection START", req->sd);
req->terminate = connection_termination;
break;
case resolve_request: err = handle_resolve_request (req); break;
case query_request: err = handle_queryrecord_request (req); break;
case browse_request: err = handle_browse_request (req); break;
case reg_service_request: err = handle_regservice_request (req); break;
case enumeration_request: err = handle_enum_request (req); break;
case reconfirm_record_request: err = handle_reconfirm_request (req); break;
case setdomain_request: err = handle_setdomain_request (req); break;
case getproperty_request: handle_getproperty_request (req); break;
case port_mapping_request: err = handle_port_mapping_request(req); break;
case addrinfo_request: err = handle_addrinfo_request (req); break;
case reg_record_request: err = handle_regrecord_request (req); break;
case add_record_request: err = handle_add_request (req); break;
case update_record_request: err = handle_update_request (req); break;
case remove_record_request: err = handle_removerecord_request(req); break;
case cancel_request: handle_cancel_request (req); break;
default: LogMsg("%3d: ERROR: Unsupported UDS req: %d", req->sd, req->hdr.op);
}
if (req->msgbuf) freeL("request_state msgbuf", req->msgbuf);
if (req->hdr.op != cancel_request && req->hdr.op != getproperty_request)
{
err = dnssd_htonl(err);
send_all(req->errsd, (const char *)&err, sizeof(err));
if (req->errsd != req->sd)
{
LogOperation("%3d: Closing error socket %d", req->sd, req->errsd);
dnssd_close(req->errsd);
req->errsd = req->sd;
if (req->primary) req->primary->errsd = req->primary->sd;
}
}
if (req->primary) req = req->primary;
req->ts = t_morecoming;
req->hdr_bytes = 0;
req->data_bytes = 0;
req->msgbuf = mDNSNULL;
req->msgptr = mDNSNULL;
req->msgend = 0;
}
mDNSlocal void connect_callback(int fd, short filter, void *info)
{
dnssd_sockaddr_t cliaddr;
dnssd_socklen_t len = (dnssd_socklen_t) sizeof(cliaddr);
dnssd_sock_t sd = accept(listenfd, (struct sockaddr*) &cliaddr, &len);
const unsigned long optval = 1;
(void)fd; (void)filter; (void)info;
if (!dnssd_SocketValid(sd))
{
if (dnssd_errno() != dnssd_EWOULDBLOCK) my_perror("ERROR: accept");
return;
}
#ifdef SO_NOSIGPIPE
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, fcntl(sd, F_GETFL, 0) | O_NONBLOCK) != 0)
#endif
{
my_perror("ERROR: fcntl(sd, F_SETFL, O_NONBLOCK) - aborting client");
dnssd_close(sd);
return;
}
else
{
request_state *request = NewRequest();
request->ts = t_morecoming;
request->sd = sd;
request->errsd = sd;
#if APPLE_OSX_mDNSResponder
struct xucred x;
socklen_t xucredlen = sizeof(x);
if (getsockopt(sd, 0, LOCAL_PEERCRED, &x, &xucredlen) >= 0 && x.cr_version == XUCRED_VERSION) request->uid = x.cr_uid;
else my_perror("ERROR: getsockopt, LOCAL_PEERCRED");
debugf("LOCAL_PEERCRED %d %u %u %d", xucredlen, x.cr_version, x.cr_uid, x.cr_ngroups);
#endif APPLE_OSX_mDNSResponder
LogOperation("%3d: Adding FD for uid %u", request->sd, request->uid);
udsSupportAddFDToEventLoop(sd, request_callback, request);
}
}
mDNSexport int udsserver_init(dnssd_sock_t skt)
{
dnssd_sockaddr_t laddr;
int ret;
#if defined(_WIN32)
u_long opt = 1;
#endif
LogOperation("udsserver_init");
if (PID_FILE[0])
{
FILE *fp = fopen(PID_FILE, "w");
if (fp != NULL)
{
fprintf(fp, "%d\n", getpid());
fclose(fp);
}
}
if (dnssd_SocketValid(skt))
listenfd = skt;
else
{
listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
if (!dnssd_SocketValid(listenfd))
{
my_perror("ERROR: socket(AF_DNSSD, SOCK_STREAM, 0); failed");
goto error;
}
mDNSPlatformMemZero(&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); laddr.sun_family = AF_LOCAL;
#ifndef NOT_HAVE_SA_LEN
laddr.sun_len = sizeof(struct sockaddr_un);
#endif
mDNSPlatformStrCopy(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)
if (ioctlsocket(listenfd, FIONBIO, &opt) != 0)
#else
if (fcntl(listenfd, F_SETFL, fcntl(listenfd, F_GETFL, 0) | 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;
}
else LogOperation("%3d: Listening for incoming Unix Domain Socket client requests", listenfd);
#if !defined(PLATFORM_NO_RLIMIT)
{
#define MIN_OPENFILES 10240
struct rlimit maxfds, newfds;
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
mDNS_GetDomains(&mDNSStorage, &mDNSStorage.AutomaticBrowseDomainQ, mDNS_DomainTypeBrowseAutomatic,
mDNSNULL, mDNSInterface_LocalOnly, AutomaticBrowseDomainChange, mDNSNULL);
RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeRegistration);
RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeBrowse);
AddAutoBrowseDomain(0, &localdomain);
udsserver_handle_configchange(&mDNSStorage);
return 0;
error:
my_perror("ERROR: udsserver_init");
return -1;
}
mDNSexport int udsserver_exit(dnssd_sock_t skt)
{
if (!dnssd_SocketValid(skt))
{
dnssd_close(listenfd);
#if !defined(USE_TCP_LOOPBACK)
if (unlink(MDNS_UDS_SERVERPATH))
debugf("Unable to remove %s", MDNS_UDS_SERVERPATH);
#endif
}
if (PID_FILE[0]) unlink(PID_FILE);
return 0;
}
mDNSlocal void LogClientInfo(mDNS *const m, request_state *req)
{
if (!req->terminate)
LogMsgNoIdent("%3d: No operation yet on this socket", req->sd);
else if (req->terminate == connection_termination)
{
registered_record_entry *p;
LogMsgNoIdent("%3d: DNSServiceCreateConnection", req->sd);
for (p = req->u.reg_recs; p; p=p->next)
LogMsgNoIdent(" -> DNSServiceRegisterRecord %3d %s", p->key, ARDisplayString(m, p->rr));
}
else if (req->terminate == regservice_termination_callback)
{
service_instance *ptr;
for (ptr = req->u.servicereg.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->u.browser.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, req->u.resolve.qsrv.qname.c);
else if (req->terminate == queryrecord_termination_callback)
LogMsgNoIdent("%3d: DNSServiceQueryRecord %##s (%s)", req->sd, req->u.queryrecord.q.qname.c, DNSTypeName(req->u.queryrecord.q.qtype));
else if (req->terminate == enum_termination_callback)
LogMsgNoIdent("%3d: DNSServiceEnumerateDomains %##s", req->sd, req->u.enumeration.q_all.qname.c);
else if (req->terminate == port_mapping_termination_callback)
LogMsgNoIdent("%3d: DNSServiceNATPortMapping %.4a %s%s Int %d Req %d Ext %d Req TTL %d Granted TTL %d",
req->sd,
&req->u.pm.NATinfo.ExternalAddress,
req->u.pm.NATinfo.Protocol & NATOp_MapTCP ? "TCP" : " ",
req->u.pm.NATinfo.Protocol & NATOp_MapUDP ? "UDP" : " ",
mDNSVal16(req->u.pm.NATinfo.IntPort),
mDNSVal16(req->u.pm.ReqExt),
mDNSVal16(req->u.pm.NATinfo.ExternalPort),
req->u.pm.NATinfo.NATLease,
req->u.pm.NATinfo.Lifetime);
else if (req->terminate == addrinfo_termination_callback)
LogMsgNoIdent("%3d: DNSServiceGetAddrInfo %s%s %##s", req->sd,
req->u.addrinfo.protocol & kDNSServiceProtocol_IPv4 ? "v4" : " ",
req->u.addrinfo.protocol & kDNSServiceProtocol_IPv6 ? "v6" : " ",
req->u.addrinfo.q4.qname.c);
else
LogMsgNoIdent("%3d: Unrecognized operation %p", req->sd, req->terminate);
}
mDNSexport void udsserver_info(mDNS *const m)
{
mDNSs32 now = mDNS_TimeNow(m);
mDNSu32 CacheUsed = 0, CacheActive = 0;
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *cr;
LogMsgNoIdent("Timenow 0x%08lX (%ld)", (mDNSu32)now, now);
LogMsgNoIdent("------------ Cache -------------");
LogMsgNoIdent("Slt Q TTL if U Type rdlen");
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)
{
CacheUsed++; for (cr = cg->members; cr; cr=cr->next)
{
mDNSs32 remain = cr->resrec.rroriginalttl - (now - cr->TimeRcvd) / mDNSPlatformOneSecond;
NetworkInterfaceInfo *info = (NetworkInterfaceInfo *)cr->resrec.InterfaceID;
CacheUsed++;
if (cr->CRActiveQuestion) CacheActive++;
LogMsgNoIdent("%3d %s%8ld %-6s%s %-6s%s",
slot,
cr->CRActiveQuestion ? "*" : " ",
remain,
info ? info->ifname : "-U-",
(cr->resrec.RecordType == kDNSRecordTypePacketNegative) ? "-" :
(cr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ? " " : "+",
DNSTypeName(cr->resrec.rrtype),
CRDisplayString(m, cr));
usleep(1000); }
}
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 entities; %lu referenced by active questions", CacheUsed, CacheActive);
LogMsgNoIdent("--------- Auth Records ---------");
if (!m->ResourceRecords) LogMsgNoIdent("<None>");
else
{
AuthRecord *ar;
LogMsgNoIdent(" Int Next Expire State");
for (ar = m->ResourceRecords; ar; ar=ar->next)
if (AuthRecord_uDNS(ar))
LogMsgNoIdent("%7d %7d %7d %7d %s",
ar->ThisAPInterval / mDNSPlatformOneSecond,
(ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond,
ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0,
ar->state, ARDisplayString(m, ar));
else if (ar->resrec.InterfaceID != mDNSInterface_LocalOnly)
LogMsgNoIdent("%7d %7d M %s",
ar->ThisAPInterval / mDNSPlatformOneSecond,
ar->AnnounceCount ? (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond : 0,
ARDisplayString(m, ar));
else
LogMsgNoIdent(" LO %s", ARDisplayString(m, ar));
}
LogMsgNoIdent("----- ServiceRegistrations -----");
if (!m->ServiceRegistrations) LogMsgNoIdent("<None>");
else
{
ServiceRecordSet *s;
LogMsgNoIdent(" Int Next Expire State");
for (s = m->ServiceRegistrations; s; s = s->uDNS_next)
LogMsgNoIdent("%7d %7d %7d %7d %s",
s->RR_SRV.ThisAPInterval / mDNSPlatformOneSecond,
(s->RR_SRV.LastAPTime + s->RR_SRV.ThisAPInterval - now) / mDNSPlatformOneSecond,
s->RR_SRV.expire ? (s->RR_SRV.expire - now) / mDNSPlatformOneSecond : 0,
s->state, ARDisplayString(m, &s->RR_SRV));
}
LogMsgNoIdent("---------- Questions -----------");
if (!m->Questions) LogMsgNoIdent("<None>");
else
{
DNSQuestion *q;
CacheUsed = 0;
CacheActive = 0;
LogMsgNoIdent(" Int Next if T NumAns Type Name");
for (q = m->Questions; q; q=q->next)
{
mDNSs32 i = q->ThisQInterval / mDNSPlatformOneSecond;
mDNSs32 n = (q->LastQTime + q->ThisQInterval - now) / mDNSPlatformOneSecond;
NetworkInterfaceInfo *info = (NetworkInterfaceInfo *)q->InterfaceID;
CacheUsed++;
if (q->ThisQInterval) CacheActive++;
LogMsgNoIdent("%6d%6d %-6s%s%s %5d %-6s%##s%s",
i, n,
info ? info->ifname : mDNSOpaque16IsZero(q->TargetQID) ? "" : "-U-",
mDNSOpaque16IsZero(q->TargetQID) ? " " : q->LongLived ? "L" : "O", q->AuthInfo ? "P" : " ",
q->CurrentAnswers,
DNSTypeName(q->qtype), q->qname.c, q->DuplicateOf ? " (dup)" : "");
usleep(1000); }
LogMsgNoIdent("%lu question%s; %lu active", CacheUsed, CacheUsed > 1 ? "s" : "", CacheActive);
}
LogMsgNoIdent("---- Active Client Requests ----");
if (!all_requests) LogMsgNoIdent("<None>");
else
{
request_state *req;
for (req = all_requests; req; req=req->next)
LogClientInfo(m, req);
}
LogMsgNoIdent("-------- NAT Traversals --------");
if (!m->NATTraversals) LogMsgNoIdent("<None>");
else
{
NATTraversalInfo *nat;
for (nat = m->NATTraversals; nat; nat=nat->next)
{
if (nat->Protocol)
LogMsgNoIdent("%p %s Int %5d Ext %5d Err %d Retry %d Interval %d Expire %d",
nat, nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP",
mDNSVal16(nat->IntPort), mDNSVal16(nat->ExternalPort), nat->Result,
nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0,
nat->retryInterval / mDNSPlatformOneSecond,
nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0);
else
LogMsgNoIdent("%p Address Request Retry %d Interval %d", nat,
(m->retryGetAddr - now) / mDNSPlatformOneSecond,
m->retryIntervalGetAddr / mDNSPlatformOneSecond);
}
}
LogMsgNoIdent("--------- AuthInfoList ---------");
if (!m->AuthInfoList) LogMsgNoIdent("<None>");
else
{
DomainAuthInfo *a;
for (a = m->AuthInfoList; a; a = a->next)
LogMsgNoIdent("%##s %##s%s", a->domain.c, a->keyname.c, a->AutoTunnel ? " AutoTunnel" : "");
}
#if APPLE_OSX_mDNSResponder
LogMsgNoIdent("--------- TunnelClients ---------");
if (!m->TunnelClients) LogMsgNoIdent("<None>");
else
{
ClientTunnel *c;
for (c = m->TunnelClients; c; c = c->next)
LogMsgNoIdent("%##s local %.16a %.4a remote %.16a %.4a %5d interval %d",
c->dstname.c, &c->loc_inner, &c->loc_outer, &c->rmt_inner, &c->rmt_outer, mDNSVal16(c->rmt_outer_port), c->q.ThisQInterval);
}
#endif
}
#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
mDNSexport void uds_validatelists(void)
{
request_state *req;
for (req = all_requests; req; req=req->next)
{
if (req->next == (request_state *)~0 || (req->sd < 0 && req->sd != -2))
LogMemCorruption("UDS request list: %p is garbage (%d)", req, req->sd);
reply_state *rep;
for (rep = req->replies; rep; rep=rep->next)
if (rep->next == (reply_state *)~0)
LogMemCorruption("UDS req->replies: %p is garbage", rep);
if (req->terminate == connection_termination)
{
registered_record_entry *p;
for (p = req->u.reg_recs; p; p=p->next)
if (p->next == (registered_record_entry *)~0)
LogMemCorruption("UDS req->u.reg_recs: %p is garbage", p);
}
else if (req->terminate == regservice_termination_callback)
{
service_instance *p;
for (p = req->u.servicereg.instances; p; p=p->next)
if (p->next == (service_instance *)~0)
LogMemCorruption("UDS req->u.servicereg.instances: %p is garbage", p);
}
else if (req->terminate == browse_termination_callback)
{
browser_t *p;
for (p = req->u.browser.browsers; p; p=p->next)
if (p->next == (browser_t *)~0)
LogMemCorruption("UDS req->u.browser.browsers: %p is garbage", p);
}
}
DNameListElem *d;
for (d = SCPrefBrowseDomains; d; d=d->next)
if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
LogMemCorruption("SCPrefBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
ARListElem *b;
for (b = LocalDomainEnumRecords; b; b=b->next)
if (b->next == (ARListElem *)~0 || b->ar.resrec.name->c[0] > 63)
LogMemCorruption("LocalDomainEnumRecords: %p is garbage (%d)", b, b->ar.resrec.name->c[0]);
for (d = AutoBrowseDomains; d; d=d->next)
if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
LogMemCorruption("AutoBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
for (d = AutoRegistrationDomains; d; d=d->next)
if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
LogMemCorruption("AutoRegistrationDomains: %p is garbage (%d)", d, d->name.c[0]);
}
#endif
mDNSlocal int send_msg(reply_state *rep)
{
ssize_t nwriten;
if (!rep->msgbuf) { LogMsg("ERROR: send_msg called with NULL message buffer"); return(rep->ts = t_error); }
if (rep->request->no_reply) { freeL("reply_state msgbuf (no_reply)", rep->msgbuf); return(rep->ts = t_complete); }
ConvertHeaderBytes(rep->mhdr);
nwriten = send(rep->sd, rep->msgbuf + rep->nwriten, rep->len - rep->nwriten, 0);
ConvertHeaderBytes(rep->mhdr);
if (nwriten < 0)
{
if (dnssd_errno() == dnssd_EINTR || dnssd_errno() == dnssd_EWOULDBLOCK) nwriten = 0;
else
{
#if !defined(PLATFORM_NO_EPIPE)
if (dnssd_errno() == EPIPE)
return(rep->request->ts = rep->ts = t_terminated);
else
#endif
{
LogMsg("send_msg ERROR: failed to write %d bytes to fd %d errno %d %s",
rep->len - rep->nwriten, rep->sd, dnssd_errno(), dnssd_strerror(dnssd_errno()));
return(rep->ts = t_error);
}
}
}
rep->nwriten += nwriten;
if (rep->nwriten == rep->len) { freeL("reply_state msgbuf (t_complete)", rep->msgbuf); rep->ts = t_complete; }
return rep->ts;
}
mDNSexport mDNSs32 udsserver_idle(mDNSs32 nextevent)
{
mDNSs32 now = mDNS_TimeNow(&mDNSStorage);
request_state **req = &all_requests;
while (*req)
{
if ((*req)->terminate == resolve_termination_callback)
if ((*req)->u.resolve.ReportTime && now - (*req)->u.resolve.ReportTime >= 0)
{
(*req)->u.resolve.ReportTime = 0;
LogMsgNoIdent("Client application bug: DNSServiceResolve(%##s) active for over two minutes. "
"This places considerable burden on the network.", (*req)->u.resolve.qsrv.qname.c);
}
while ((*req)->replies) {
transfer_state result;
if ((*req)->replies->next) (*req)->replies->rhdr->flags |= dnssd_htonl(kDNSServiceFlagsMoreComing);
result = send_msg((*req)->replies); if (result == t_complete)
{
reply_state *fptr = (*req)->replies;
(*req)->replies = (*req)->replies->next;
freeL("reply_state/udsserver_idle", fptr);
(*req)->time_blocked = 0; continue;
}
else if (result == t_terminated || result == t_error) abort_request(*req);
break;
}
if ((*req)->replies) {
if (!(*req)->time_blocked) (*req)->time_blocked = NonZeroTime(now);
if (now - (*req)->time_blocked >= 60 * mDNSPlatformOneSecond)
{
LogMsg("Could not write data to client %d after %ld seconds - aborting connection",
(*req)->sd, (now - (*req)->time_blocked) / mDNSPlatformOneSecond);
LogClientInfo(&mDNSStorage, *req);
abort_request(*req);
}
else if (nextevent - now > mDNSPlatformOneSecond) nextevent = now + mDNSPlatformOneSecond;
}
if (!dnssd_SocketValid((*req)->sd)) {
request_state *tmp = *req;
*req = tmp->next;
freeL("request_state/udsserver_idle", tmp);
}
else
req = &(*req)->next;
}
return nextevent;
}
struct CompileTimeAssertionChecks_uds_daemon
{
char sizecheck_request_state [(sizeof(request_state) <= 1800) ? 1 : -1];
char sizecheck_registered_record_entry[(sizeof(registered_record_entry) <= 30) ? 1 : -1];
char sizecheck_service_instance [(sizeof(service_instance) <= 6000) ? 1 : -1];
char sizecheck_browser_t [(sizeof(browser_t) <= 1000) ? 1 : -1];
char sizecheck_reply_hdr [(sizeof(reply_hdr) <= 20) ? 1 : -1];
char sizecheck_reply_state [(sizeof(reply_state) <= 40) ? 1 : -1];
};