1*472cd20dSToomas Soome /*
2*472cd20dSToomas Soome * Copyright (c) 2003-2020 Apple Inc. All rights reserved.
34b22b933Srs *
44b22b933Srs * Licensed under the Apache License, Version 2.0 (the "License");
54b22b933Srs * you may not use this file except in compliance with the License.
64b22b933Srs * You may obtain a copy of the License at
75ffb0c9bSToomas Soome *
84b22b933Srs * http://www.apache.org/licenses/LICENSE-2.0
95ffb0c9bSToomas Soome *
104b22b933Srs * Unless required by applicable law or agreed to in writing, software
114b22b933Srs * distributed under the License is distributed on an "AS IS" BASIS,
124b22b933Srs * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
134b22b933Srs * See the License for the specific language governing permissions and
144b22b933Srs * limitations under the License.
155ffb0c9bSToomas Soome */
164b22b933Srs
175ffb0c9bSToomas Soome #if defined(_WIN32)
185ffb0c9bSToomas Soome #include <process.h>
195ffb0c9bSToomas Soome #define usleep(X) Sleep(((X)+999)/1000)
205ffb0c9bSToomas Soome #else
215ffb0c9bSToomas Soome #include <fcntl.h>
225ffb0c9bSToomas Soome #include <errno.h>
235ffb0c9bSToomas Soome #include <sys/ioctl.h>
245ffb0c9bSToomas Soome #include <sys/types.h>
255ffb0c9bSToomas Soome #include <sys/time.h>
265ffb0c9bSToomas Soome #include <sys/resource.h>
275ffb0c9bSToomas Soome #endif
284b22b933Srs
295ffb0c9bSToomas Soome #include <stdlib.h>
305ffb0c9bSToomas Soome #include <stdio.h>
314b22b933Srs
325ffb0c9bSToomas Soome #include "mDNSEmbeddedAPI.h"
335ffb0c9bSToomas Soome #include "DNSCommon.h"
345ffb0c9bSToomas Soome #include "uDNS.h"
355ffb0c9bSToomas Soome #include "uds_daemon.h"
36c65ebfc7SToomas Soome #include "dns_sd_internal.h"
374b22b933Srs
385ffb0c9bSToomas Soome // Apple-specific functionality, not required for other platforms
395ffb0c9bSToomas Soome #if APPLE_OSX_mDNSResponder
40*472cd20dSToomas Soome #include <os/log.h>
415ffb0c9bSToomas Soome #include <sys/ucred.h>
425ffb0c9bSToomas Soome #ifndef PID_FILE
43*472cd20dSToomas Soome #define NO_PID_FILE // We need to signal that this platform has no PID file, and not just that we are taking the default
445ffb0c9bSToomas Soome #endif
455ffb0c9bSToomas Soome #endif
464b22b933Srs
47c65ebfc7SToomas Soome #ifdef LOCAL_PEEREPID
48c65ebfc7SToomas Soome #include <sys/un.h> // for LOCAL_PEEREPID
495ffb0c9bSToomas Soome #include <sys/socket.h> // for getsockopt
505ffb0c9bSToomas Soome #include <sys/proc_info.h> // for struct proc_bsdshortinfo
515ffb0c9bSToomas Soome #include <libproc.h> // for proc_pidinfo()
52c65ebfc7SToomas Soome #endif //LOCAL_PEEREPID
53c65ebfc7SToomas Soome
54*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
55*472cd20dSToomas Soome #include "D2D.h"
56c65ebfc7SToomas Soome #endif
574b22b933Srs
585ffb0c9bSToomas Soome #if APPLE_OSX_mDNSResponder
59c65ebfc7SToomas Soome #include "BLE.h"
60*472cd20dSToomas Soome #endif
61*472cd20dSToomas Soome
62*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
63*472cd20dSToomas Soome #include "mDNSMacOSX.h"
64*472cd20dSToomas Soome #include <os/feature_private.h>
65*472cd20dSToomas Soome #endif
66*472cd20dSToomas Soome
67*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, AUDIT_TOKEN)
68*472cd20dSToomas Soome #include <bsm/libbsm.h>
69*472cd20dSToomas Soome #endif
704b22b933Srs
71*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
72*472cd20dSToomas Soome #include "QuerierSupport.h"
73*472cd20dSToomas Soome #endif
744b22b933Srs
75*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER) && MDNSRESPONDER_SUPPORTS(APPLE, IPC_TLV)
76*472cd20dSToomas Soome #include "mdns_tlv.h"
77*472cd20dSToomas Soome #endif
784b22b933Srs
79*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, DNSSECv2)
80*472cd20dSToomas Soome #include "dnssec_v2.h"
81*472cd20dSToomas Soome #endif
824b22b933Srs
83*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, DNSSD_XPC_SERVICE)
84*472cd20dSToomas Soome #include "dnssd_server.h"
85*472cd20dSToomas Soome #endif
864b22b933Srs
875ffb0c9bSToomas Soome // User IDs 0-500 are system-wide processes, not actual users in the usual sense
885ffb0c9bSToomas Soome // User IDs for real user accounts start at 501 and count up from there
895ffb0c9bSToomas Soome #define SystemUID(X) ((X) <= 500)
904b22b933Srs
915ffb0c9bSToomas Soome // ***************************************************************************
925ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
935ffb0c9bSToomas Soome #pragma mark -
945ffb0c9bSToomas Soome #pragma mark - Globals
955ffb0c9bSToomas Soome #endif
964b22b933Srs
975ffb0c9bSToomas Soome // globals
985ffb0c9bSToomas Soome mDNSexport mDNS mDNSStorage;
995ffb0c9bSToomas Soome mDNSexport const char ProgramName[] = "mDNSResponder";
1005ffb0c9bSToomas Soome
101c65ebfc7SToomas Soome #if defined(USE_TCP_LOOPBACK)
102c65ebfc7SToomas Soome static char* boundPath = NULL;
103c65ebfc7SToomas Soome #else
104c65ebfc7SToomas Soome static char* boundPath = MDNS_UDS_SERVERPATH;
105c65ebfc7SToomas Soome #endif
106c65ebfc7SToomas Soome #if DEBUG
107c65ebfc7SToomas Soome #define MDNS_UDS_SERVERPATH_DEBUG "/var/tmp/mDNSResponder"
108c65ebfc7SToomas Soome #endif
1095ffb0c9bSToomas Soome static dnssd_sock_t listenfd = dnssd_InvalidSocket;
1105ffb0c9bSToomas Soome static request_state *all_requests = NULL;
111c65ebfc7SToomas Soome #ifdef LOCAL_PEEREPID
1125ffb0c9bSToomas Soome struct proc_bsdshortinfo proc;
113c65ebfc7SToomas Soome #endif //LOCAL_PEEREPID
1145ffb0c9bSToomas Soome mDNSlocal void set_peer_pid(request_state *request);
1155ffb0c9bSToomas Soome mDNSlocal void LogMcastClientInfo(request_state *req);
1165ffb0c9bSToomas Soome mDNSlocal void GetMcastClients(request_state *req);
1175ffb0c9bSToomas Soome static mDNSu32 mcount; // tracks the current active mcast operations for McastLogging
1185ffb0c9bSToomas Soome static mDNSu32 i_mcount; // sets mcount when McastLogging is enabled(PROF signal is sent)
1195ffb0c9bSToomas Soome static mDNSu32 n_mrecords; // tracks the current active mcast records for McastLogging
1205ffb0c9bSToomas Soome static mDNSu32 n_mquests; // tracks the current active mcast questions for McastLogging
1215ffb0c9bSToomas Soome
122c65ebfc7SToomas Soome
123*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, METRICS)
124c65ebfc7SToomas Soome mDNSu32 curr_num_regservices = 0;
125c65ebfc7SToomas Soome mDNSu32 max_num_regservices = 0;
126c65ebfc7SToomas Soome #endif
127c65ebfc7SToomas Soome
1285ffb0c9bSToomas Soome // Note asymmetry here between registration and browsing.
1295ffb0c9bSToomas Soome // For service registrations we only automatically register in domains that explicitly appear in local configuration data
1305ffb0c9bSToomas Soome // (so AutoRegistrationDomains could equally well be called SCPrefRegDomains)
1315ffb0c9bSToomas Soome // For service browsing we also learn automatic browsing domains from the network, so for that case we have:
1325ffb0c9bSToomas Soome // 1. SCPrefBrowseDomains (local configuration data)
1335ffb0c9bSToomas Soome // 2. LocalDomainEnumRecords (locally-generated local-only PTR records -- equivalent to slElem->AuthRecs in uDNS.c)
1345ffb0c9bSToomas Soome // 3. AutoBrowseDomains, which is populated by tracking add/rmv events in AutomaticBrowseDomainChange, the callback function for our mDNS_GetDomains call.
1355ffb0c9bSToomas Soome // By creating and removing our own LocalDomainEnumRecords, we trigger AutomaticBrowseDomainChange callbacks just like domains learned from the network would.
1365ffb0c9bSToomas Soome
1375ffb0c9bSToomas Soome mDNSexport DNameListElem *AutoRegistrationDomains; // Domains where we automatically register for empty-string registrations
1385ffb0c9bSToomas Soome
1395ffb0c9bSToomas Soome static DNameListElem *SCPrefBrowseDomains; // List of automatic browsing domains read from SCPreferences for "empty string" browsing
1405ffb0c9bSToomas Soome static ARListElem *LocalDomainEnumRecords; // List of locally-generated PTR records to augment those we learn from the network
1415ffb0c9bSToomas Soome mDNSexport DNameListElem *AutoBrowseDomains; // List created from those local-only PTR records plus records we get from the network
1425ffb0c9bSToomas Soome
1435ffb0c9bSToomas Soome #define MSG_PAD_BYTES 5 // pad message buffer (read from client) with n zero'd bytes to guarantee
1445ffb0c9bSToomas Soome // n get_string() calls w/o buffer overrun
1455ffb0c9bSToomas Soome // initialization, setup/teardown functions
1464b22b933Srs
1475ffb0c9bSToomas Soome // If a platform specifies its own PID file name, we use that
1485ffb0c9bSToomas Soome #ifndef PID_FILE
1495ffb0c9bSToomas Soome #define PID_FILE "/var/run/mDNSResponder.pid"
1505ffb0c9bSToomas Soome #endif
1514b22b933Srs
1525ffb0c9bSToomas Soome // ***************************************************************************
1535ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
1545ffb0c9bSToomas Soome #pragma mark -
1555ffb0c9bSToomas Soome #pragma mark - General Utility Functions
1565ffb0c9bSToomas Soome #endif
1574b22b933Srs
GetNewRequestID(void)158*472cd20dSToomas Soome mDNSlocal mDNSu32 GetNewRequestID(void)
159*472cd20dSToomas Soome {
160*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, DNSSD_XPC_SERVICE)
161*472cd20dSToomas Soome return dnssd_server_get_new_request_id();
162*472cd20dSToomas Soome #else
163*472cd20dSToomas Soome static mDNSu32 s_last_id = 0;
164*472cd20dSToomas Soome return ++s_last_id;
165*472cd20dSToomas Soome #endif
166*472cd20dSToomas Soome }
167*472cd20dSToomas Soome
FatalError(char * errmsg)1685ffb0c9bSToomas Soome mDNSlocal void FatalError(char *errmsg)
1695ffb0c9bSToomas Soome {
1705ffb0c9bSToomas Soome LogMsg("%s: %s", errmsg, dnssd_strerror(dnssd_errno));
171cda73f64SToomas Soome abort();
1725ffb0c9bSToomas Soome }
1735ffb0c9bSToomas Soome
dnssd_htonl(mDNSu32 l)1745ffb0c9bSToomas Soome mDNSlocal mDNSu32 dnssd_htonl(mDNSu32 l)
1755ffb0c9bSToomas Soome {
1765ffb0c9bSToomas Soome mDNSu32 ret;
1775ffb0c9bSToomas Soome char *data = (char*) &ret;
1785ffb0c9bSToomas Soome put_uint32(l, &data);
1795ffb0c9bSToomas Soome return ret;
1805ffb0c9bSToomas Soome }
1815ffb0c9bSToomas Soome
1825ffb0c9bSToomas Soome // hack to search-replace perror's to LogMsg's
my_perror(char * errmsg)1835ffb0c9bSToomas Soome mDNSlocal void my_perror(char *errmsg)
1845ffb0c9bSToomas Soome {
1855ffb0c9bSToomas Soome LogMsg("%s: %d (%s)", errmsg, dnssd_errno, dnssd_strerror(dnssd_errno));
1865ffb0c9bSToomas Soome }
1875ffb0c9bSToomas Soome
1885ffb0c9bSToomas Soome // Throttled version of my_perror: Logs once every 250 msgs
my_throttled_perror(char * err_msg)1895ffb0c9bSToomas Soome mDNSlocal void my_throttled_perror(char *err_msg)
1905ffb0c9bSToomas Soome {
1915ffb0c9bSToomas Soome static int uds_throttle_count = 0;
192c65ebfc7SToomas Soome if ((uds_throttle_count++ % 250) == 0)
1935ffb0c9bSToomas Soome my_perror(err_msg);
194c65ebfc7SToomas Soome }
1955ffb0c9bSToomas Soome
1965ffb0c9bSToomas Soome // LogMcastQuestion/LogMcastQ should be called after the DNSQuestion struct is initialized(especially for q->TargetQID)
1975ffb0c9bSToomas Soome // Hence all calls are made after mDNS_StartQuery()/mDNS_StopQuery()/mDNS_StopBrowse() is called.
LogMcastQuestion(const DNSQuestion * const q,request_state * req,q_state status)198c65ebfc7SToomas Soome mDNSlocal void LogMcastQuestion(const DNSQuestion *const q, request_state *req, q_state status)
1995ffb0c9bSToomas Soome {
2005ffb0c9bSToomas Soome if (mDNSOpaque16IsZero(q->TargetQID)) // Check for Mcast Query
2015ffb0c9bSToomas Soome {
2025ffb0c9bSToomas Soome mDNSBool mflag = mDNSfalse;
2035ffb0c9bSToomas Soome if (status == q_start)
2045ffb0c9bSToomas Soome {
2055ffb0c9bSToomas Soome if (++mcount == 1)
2065ffb0c9bSToomas Soome mflag = mDNStrue;
2075ffb0c9bSToomas Soome }
2085ffb0c9bSToomas Soome else
2095ffb0c9bSToomas Soome {
2105ffb0c9bSToomas Soome mcount--;
2115ffb0c9bSToomas Soome }
212c65ebfc7SToomas Soome LogMcast("%s: %##s (%s) (%s) Client(%d)[%s]", status ? "+Question" : "-Question", q->qname.c, DNSTypeName(q->qtype),
213c65ebfc7SToomas Soome q->InterfaceID == mDNSInterface_LocalOnly ? "lo" :
214c65ebfc7SToomas Soome q->InterfaceID == mDNSInterface_P2P ? "p2p" :
215c65ebfc7SToomas Soome q->InterfaceID == mDNSInterface_BLE ? "BLE" :
216c65ebfc7SToomas Soome q->InterfaceID == mDNSInterface_Any ? "any" : InterfaceNameForID(&mDNSStorage, q->InterfaceID),
2175ffb0c9bSToomas Soome req->process_id, req->pid_name);
218c65ebfc7SToomas Soome LogMcastStateInfo(mflag, mDNSfalse, mDNSfalse);
2195ffb0c9bSToomas Soome }
2205ffb0c9bSToomas Soome return;
2215ffb0c9bSToomas Soome }
2224b22b933Srs
2235ffb0c9bSToomas Soome // LogMcastService/LogMcastS should be called after the AuthRecord struct is initialized
2245ffb0c9bSToomas Soome // Hence all calls are made after mDNS_Register()/ just before mDNS_Deregister()
LogMcastService(const AuthRecord * const ar,request_state * req,reg_state status)225c65ebfc7SToomas Soome mDNSlocal void LogMcastService(const AuthRecord *const ar, request_state *req, reg_state status)
2265ffb0c9bSToomas Soome {
2275ffb0c9bSToomas Soome if (!AuthRecord_uDNS(ar)) // Check for Mcast Service
2285ffb0c9bSToomas Soome {
2295ffb0c9bSToomas Soome mDNSBool mflag = mDNSfalse;
2305ffb0c9bSToomas Soome if (status == reg_start)
2315ffb0c9bSToomas Soome {
2325ffb0c9bSToomas Soome if (++mcount == 1)
2335ffb0c9bSToomas Soome mflag = mDNStrue;
2345ffb0c9bSToomas Soome }
2355ffb0c9bSToomas Soome else
2365ffb0c9bSToomas Soome {
2375ffb0c9bSToomas Soome mcount--;
2385ffb0c9bSToomas Soome }
2395ffb0c9bSToomas Soome LogMcast("%s: %##s (%s) (%s) Client(%d)[%s]", status ? "+Service" : "-Service", ar->resrec.name->c, DNSTypeName(ar->resrec.rrtype),
240c65ebfc7SToomas Soome ar->resrec.InterfaceID == mDNSInterface_LocalOnly ? "lo" :
241c65ebfc7SToomas Soome ar->resrec.InterfaceID == mDNSInterface_P2P ? "p2p" :
242c65ebfc7SToomas Soome ar->resrec.InterfaceID == mDNSInterface_BLE ? "BLE" :
243c65ebfc7SToomas Soome ar->resrec.InterfaceID == mDNSInterface_Any ? "all" : InterfaceNameForID(&mDNSStorage, ar->resrec.InterfaceID),
2445ffb0c9bSToomas Soome req->process_id, req->pid_name);
245c65ebfc7SToomas Soome LogMcastStateInfo(mflag, mDNSfalse, mDNSfalse);
2465ffb0c9bSToomas Soome }
2475ffb0c9bSToomas Soome return;
2485ffb0c9bSToomas Soome }
2494b22b933Srs
2505ffb0c9bSToomas Soome // For complete Mcast State Log, pass mDNStrue to mstatelog in LogMcastStateInfo()
LogMcastStateInfo(mDNSBool mflag,mDNSBool start,mDNSBool mstatelog)251c65ebfc7SToomas Soome mDNSexport void LogMcastStateInfo(mDNSBool mflag, mDNSBool start, mDNSBool mstatelog)
2525ffb0c9bSToomas Soome {
253c65ebfc7SToomas Soome mDNS *const m = &mDNSStorage;
2545ffb0c9bSToomas Soome if (!mstatelog)
2555ffb0c9bSToomas Soome {
2565ffb0c9bSToomas Soome if (!all_requests)
2575ffb0c9bSToomas Soome {
2585ffb0c9bSToomas Soome LogMcastNoIdent("<None>");
2595ffb0c9bSToomas Soome }
2605ffb0c9bSToomas Soome else
2615ffb0c9bSToomas Soome {
2625ffb0c9bSToomas Soome request_state *req, *r;
2635ffb0c9bSToomas Soome for (req = all_requests; req; req=req->next)
264c65ebfc7SToomas Soome {
2655ffb0c9bSToomas Soome if (req->primary) // If this is a subbordinate operation, check that the parent is in the list
266c65ebfc7SToomas Soome {
267c65ebfc7SToomas Soome for (r = all_requests; r && r != req; r=r->next)
268c65ebfc7SToomas Soome if (r == req->primary)
2695ffb0c9bSToomas Soome goto foundpar;
270c65ebfc7SToomas Soome }
2715ffb0c9bSToomas Soome // For non-subbordinate operations, and subbordinate operations that have lost their parent, write out their info
2725ffb0c9bSToomas Soome GetMcastClients(req);
2735ffb0c9bSToomas Soome foundpar:;
2745ffb0c9bSToomas Soome }
2755ffb0c9bSToomas Soome LogMcastNoIdent("--- MCAST RECORDS COUNT[%d] MCAST QUESTIONS COUNT[%d] ---", n_mrecords, n_mquests);
2765ffb0c9bSToomas Soome n_mrecords = n_mquests = 0; // Reset the values
2775ffb0c9bSToomas Soome }
2785ffb0c9bSToomas Soome }
2795ffb0c9bSToomas Soome else
2805ffb0c9bSToomas Soome {
2815ffb0c9bSToomas Soome static mDNSu32 i_mpktnum;
2825ffb0c9bSToomas Soome i_mcount = 0;
2835ffb0c9bSToomas Soome if (start)
2845ffb0c9bSToomas Soome mcount = 0;
2855ffb0c9bSToomas Soome // mcount is initialized to 0 when the PROF signal is sent since mcount could have
2865ffb0c9bSToomas Soome // wrong value if MulticastLogging is disabled and then re-enabled
2875ffb0c9bSToomas Soome LogMcastNoIdent("--- START MCAST STATE LOG ---");
2885ffb0c9bSToomas Soome if (!all_requests)
289c65ebfc7SToomas Soome {
2905ffb0c9bSToomas Soome mcount = 0;
2915ffb0c9bSToomas Soome LogMcastNoIdent("<None>");
292c65ebfc7SToomas Soome }
293c65ebfc7SToomas Soome else
294c65ebfc7SToomas Soome {
2955ffb0c9bSToomas Soome request_state *req, *r;
2965ffb0c9bSToomas Soome for (req = all_requests; req; req=req->next)
297c65ebfc7SToomas Soome {
2985ffb0c9bSToomas Soome if (req->primary) // If this is a subbordinate operation, check that the parent is in the list
299c65ebfc7SToomas Soome {
300c65ebfc7SToomas Soome for (r = all_requests; r && r != req; r=r->next)
301c65ebfc7SToomas Soome if (r == req->primary)
3025ffb0c9bSToomas Soome goto foundparent;
3035ffb0c9bSToomas Soome LogMcastNoIdent("%3d: Orphan operation; parent not found in request list", req->sd);
304c65ebfc7SToomas Soome }
3055ffb0c9bSToomas Soome // For non-subbordinate operations, and subbordinate operations that have lost their parent, write out their info
3065ffb0c9bSToomas Soome LogMcastClientInfo(req);
3075ffb0c9bSToomas Soome foundparent:;
3085ffb0c9bSToomas Soome }
3095ffb0c9bSToomas Soome if(!mcount) // To initially set mcount
310c65ebfc7SToomas Soome mcount = i_mcount;
3115ffb0c9bSToomas Soome }
3125ffb0c9bSToomas Soome if (mcount == 0)
3135ffb0c9bSToomas Soome {
3145ffb0c9bSToomas Soome i_mpktnum = m->MPktNum;
3155ffb0c9bSToomas Soome LogMcastNoIdent("--- MCOUNT[%d]: IMPKTNUM[%d] ---", mcount, i_mpktnum);
3165ffb0c9bSToomas Soome }
3175ffb0c9bSToomas Soome if (mflag)
318c65ebfc7SToomas Soome LogMcastNoIdent("--- MCOUNT[%d]: CMPKTNUM[%d] - IMPKTNUM[%d] = [%d]PKTS ---", mcount, m->MPktNum, i_mpktnum, (m->MPktNum - i_mpktnum));
3195ffb0c9bSToomas Soome LogMcastNoIdent("--- END MCAST STATE LOG ---");
3205ffb0c9bSToomas Soome }
3215ffb0c9bSToomas Soome }
3224b22b933Srs
abort_request(request_state * req)3235ffb0c9bSToomas Soome mDNSlocal void abort_request(request_state *req)
3245ffb0c9bSToomas Soome {
3255ffb0c9bSToomas Soome if (req->terminate == (req_termination_fn) ~0)
326*472cd20dSToomas Soome {
327*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
328*472cd20dSToomas Soome "[R%d] abort_request: ERROR: Attempt to abort operation %p with req->terminate %p", req->request_id, req, req->terminate);
329*472cd20dSToomas Soome return;
330*472cd20dSToomas Soome }
3314b22b933Srs
3325ffb0c9bSToomas Soome // First stop whatever mDNSCore operation we were doing
3335ffb0c9bSToomas Soome // If this is actually a shared connection operation, then its req->terminate function will scan
3345ffb0c9bSToomas Soome // the all_requests list and terminate any subbordinate operations sharing this file descriptor
3355ffb0c9bSToomas Soome if (req->terminate) req->terminate(req);
336*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
337*472cd20dSToomas Soome if (req->custom_service_id != 0)
338*472cd20dSToomas Soome {
339*472cd20dSToomas Soome Querier_DeregisterCustomDNSService(req->custom_service_id);
340*472cd20dSToomas Soome req->custom_service_id = 0;
341*472cd20dSToomas Soome }
342*472cd20dSToomas Soome #endif
3434b22b933Srs
3445ffb0c9bSToomas Soome if (!dnssd_SocketValid(req->sd))
345*472cd20dSToomas Soome {
346*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
347*472cd20dSToomas Soome "[R%d] abort_request: ERROR: Attempt to abort operation %p with invalid fd %d", req->request_id, req, req->sd);
348*472cd20dSToomas Soome return;
349*472cd20dSToomas Soome }
3504b22b933Srs
3515ffb0c9bSToomas Soome // Now, if this request_state is not subordinate to some other primary, close file descriptor and discard replies
3525ffb0c9bSToomas Soome if (!req->primary)
3535ffb0c9bSToomas Soome {
354*472cd20dSToomas Soome if (req->errsd != req->sd)
355*472cd20dSToomas Soome {
356*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEBUG,
357*472cd20dSToomas Soome "[R%d] Removing FD %d and closing errsd %d", req->request_id, req->sd, req->errsd);
358*472cd20dSToomas Soome }
359*472cd20dSToomas Soome else
360*472cd20dSToomas Soome {
361*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEBUG,
362*472cd20dSToomas Soome "[R%d] Removing FD %d", req->request_id, req->sd);
363*472cd20dSToomas Soome }
3645ffb0c9bSToomas Soome udsSupportRemoveFDFromEventLoop(req->sd, req->platform_data); // Note: This also closes file descriptor req->sd for us
3655ffb0c9bSToomas Soome if (req->errsd != req->sd) { dnssd_close(req->errsd); req->errsd = req->sd; }
3664b22b933Srs
3675ffb0c9bSToomas Soome while (req->replies) // free pending replies
3685ffb0c9bSToomas Soome {
3695ffb0c9bSToomas Soome reply_state *ptr = req->replies;
3705ffb0c9bSToomas Soome req->replies = req->replies->next;
3715ffb0c9bSToomas Soome freeL("reply_state (abort)", ptr);
3725ffb0c9bSToomas Soome }
3735ffb0c9bSToomas Soome }
3744b22b933Srs
3755ffb0c9bSToomas Soome // Set req->sd to something invalid, so that udsserver_idle knows to unlink and free this structure
376*472cd20dSToomas Soome #if MDNS_MALLOC_DEBUGGING
377*472cd20dSToomas Soome // Don't use dnssd_InvalidSocket (-1) because that's the sentinel value MDNS_MALLOC_DEBUGGING uses
3785ffb0c9bSToomas Soome // for detecting when the memory for an object is inadvertently freed while the object is still on some list
379*472cd20dSToomas Soome #ifdef WIN32
380*472cd20dSToomas Soome #error This will not work on Windows, look at IsValidSocket in mDNSShared/CommonServices.h to see why
381*472cd20dSToomas Soome #endif
3825ffb0c9bSToomas Soome req->sd = req->errsd = -2;
3835ffb0c9bSToomas Soome #else
3845ffb0c9bSToomas Soome req->sd = req->errsd = dnssd_InvalidSocket;
3855ffb0c9bSToomas Soome #endif
3865ffb0c9bSToomas Soome // We also set req->terminate to a bogus value so we know if abort_request() gets called again for this request
3875ffb0c9bSToomas Soome req->terminate = (req_termination_fn) ~0;
3885ffb0c9bSToomas Soome }
3895ffb0c9bSToomas Soome
390c65ebfc7SToomas Soome #if DEBUG
SetDebugBoundPath(void)391c65ebfc7SToomas Soome mDNSexport void SetDebugBoundPath(void)
392c65ebfc7SToomas Soome {
393c65ebfc7SToomas Soome #if !defined(USE_TCP_LOOPBACK)
394c65ebfc7SToomas Soome boundPath = MDNS_UDS_SERVERPATH_DEBUG;
395c65ebfc7SToomas Soome #endif
396c65ebfc7SToomas Soome }
397c65ebfc7SToomas Soome
IsDebugSocketInUse(void)398c65ebfc7SToomas Soome mDNSexport int IsDebugSocketInUse(void)
399c65ebfc7SToomas Soome {
400c65ebfc7SToomas Soome #if !defined(USE_TCP_LOOPBACK)
401c65ebfc7SToomas Soome return !strcmp(boundPath, MDNS_UDS_SERVERPATH_DEBUG);
402c65ebfc7SToomas Soome #else
403c65ebfc7SToomas Soome return mDNSfalse;
404c65ebfc7SToomas Soome #endif
405c65ebfc7SToomas Soome }
406c65ebfc7SToomas Soome #endif
407c65ebfc7SToomas Soome
AbortUnlinkAndFree(request_state * req)4085ffb0c9bSToomas Soome mDNSlocal void AbortUnlinkAndFree(request_state *req)
4095ffb0c9bSToomas Soome {
4105ffb0c9bSToomas Soome request_state **p = &all_requests;
4115ffb0c9bSToomas Soome abort_request(req);
4125ffb0c9bSToomas Soome while (*p && *p != req) p=&(*p)->next;
413*472cd20dSToomas Soome if (*p)
414*472cd20dSToomas Soome {
415*472cd20dSToomas Soome *p = req->next;
416*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
417*472cd20dSToomas Soome if (req->trust)
418*472cd20dSToomas Soome {
419*472cd20dSToomas Soome void * context = mdns_trust_get_context(req->trust);
420*472cd20dSToomas Soome mdns_trust_set_context(req->trust, NULL);
421*472cd20dSToomas Soome if (context) freeL("context/AbortUnlinkAndFree", context);
422*472cd20dSToomas Soome mdns_trust_forget(&req->trust);
423*472cd20dSToomas Soome }
424*472cd20dSToomas Soome #endif
425*472cd20dSToomas Soome freeL("request_state/AbortUnlinkAndFree", req);
426*472cd20dSToomas Soome }
4275ffb0c9bSToomas Soome else LogMsg("AbortUnlinkAndFree: ERROR: Attempt to abort operation %p not in list", req);
4285ffb0c9bSToomas Soome }
4295ffb0c9bSToomas Soome
create_reply(const reply_op_t op,const size_t datalen,request_state * const request)4305ffb0c9bSToomas Soome mDNSlocal reply_state *create_reply(const reply_op_t op, const size_t datalen, request_state *const request)
4315ffb0c9bSToomas Soome {
4325ffb0c9bSToomas Soome reply_state *reply;
4334b22b933Srs
4345ffb0c9bSToomas Soome if ((unsigned)datalen < sizeof(reply_hdr))
4355ffb0c9bSToomas Soome {
4365ffb0c9bSToomas Soome LogMsg("ERROR: create_reply - data length less than length of required fields");
4375ffb0c9bSToomas Soome return NULL;
4385ffb0c9bSToomas Soome }
4394b22b933Srs
440*472cd20dSToomas Soome reply = (reply_state *) callocL("reply_state", sizeof(reply_state) + datalen - sizeof(reply_hdr));
441*472cd20dSToomas Soome if (!reply) FatalError("ERROR: calloc");
4424b22b933Srs
4435ffb0c9bSToomas Soome reply->next = mDNSNULL;
4445ffb0c9bSToomas Soome reply->totallen = (mDNSu32)datalen + sizeof(ipc_msg_hdr);
4455ffb0c9bSToomas Soome reply->nwriten = 0;
4464b22b933Srs
4475ffb0c9bSToomas Soome reply->mhdr->version = VERSION;
4485ffb0c9bSToomas Soome reply->mhdr->datalen = (mDNSu32)datalen;
4495ffb0c9bSToomas Soome reply->mhdr->ipc_flags = 0;
4505ffb0c9bSToomas Soome reply->mhdr->op = op;
4515ffb0c9bSToomas Soome reply->mhdr->client_context = request->hdr.client_context;
4525ffb0c9bSToomas Soome reply->mhdr->reg_index = 0;
4534b22b933Srs
4545ffb0c9bSToomas Soome return reply;
4555ffb0c9bSToomas Soome }
4564b22b933Srs
4575ffb0c9bSToomas Soome // Append a reply to the list in a request object
4585ffb0c9bSToomas Soome // If our request is sharing a connection, then we append our reply_state onto the primary's list
459cda73f64SToomas Soome // If the request does not want asynchronous replies, then the reply is freed instead of being appended to any list.
append_reply(request_state * req,reply_state * rep)4605ffb0c9bSToomas Soome mDNSlocal void append_reply(request_state *req, reply_state *rep)
4615ffb0c9bSToomas Soome {
462cda73f64SToomas Soome request_state *r;
463cda73f64SToomas Soome reply_state **ptr;
464cda73f64SToomas Soome
465cda73f64SToomas Soome if (req->no_reply)
466cda73f64SToomas Soome {
467cda73f64SToomas Soome freeL("reply_state/append_reply", rep);
468cda73f64SToomas Soome return;
469cda73f64SToomas Soome }
470cda73f64SToomas Soome
471cda73f64SToomas Soome r = req->primary ? req->primary : req;
472cda73f64SToomas Soome ptr = &r->replies;
4735ffb0c9bSToomas Soome while (*ptr) ptr = &(*ptr)->next;
4745ffb0c9bSToomas Soome *ptr = rep;
4755ffb0c9bSToomas Soome rep->next = NULL;
4765ffb0c9bSToomas Soome }
4774b22b933Srs
4785ffb0c9bSToomas Soome // Generates a response message giving name, type, domain, plus interface index,
4795ffb0c9bSToomas Soome // suitable for a browse result or service registration result.
4805ffb0c9bSToomas Soome // On successful completion rep is set to point to a malloc'd reply_state struct
GenerateNTDResponse(const domainname * const servicename,const mDNSInterfaceID id,request_state * const request,reply_state ** const rep,reply_op_t op,DNSServiceFlags flags,mStatus err)4815ffb0c9bSToomas Soome mDNSlocal mStatus GenerateNTDResponse(const domainname *const servicename, const mDNSInterfaceID id,
4825ffb0c9bSToomas Soome request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
4835ffb0c9bSToomas Soome {
4845ffb0c9bSToomas Soome domainlabel name;
4855ffb0c9bSToomas Soome domainname type, dom;
4865ffb0c9bSToomas Soome *rep = NULL;
487*472cd20dSToomas Soome if (servicename && !DeconstructServiceName(servicename, &name, &type, &dom))
4885ffb0c9bSToomas Soome return kDNSServiceErr_Invalid;
4895ffb0c9bSToomas Soome else
4905ffb0c9bSToomas Soome {
4915ffb0c9bSToomas Soome char namestr[MAX_DOMAIN_LABEL+1];
4925ffb0c9bSToomas Soome char typestr[MAX_ESCAPED_DOMAIN_NAME];
4935ffb0c9bSToomas Soome char domstr [MAX_ESCAPED_DOMAIN_NAME];
4945ffb0c9bSToomas Soome int len;
4955ffb0c9bSToomas Soome char *data;
4965ffb0c9bSToomas Soome
497*472cd20dSToomas Soome if (servicename)
498*472cd20dSToomas Soome {
499*472cd20dSToomas Soome ConvertDomainLabelToCString_unescaped(&name, namestr);
500*472cd20dSToomas Soome ConvertDomainNameToCString(&type, typestr);
501*472cd20dSToomas Soome ConvertDomainNameToCString(&dom, domstr);
502*472cd20dSToomas Soome }
503*472cd20dSToomas Soome else
504*472cd20dSToomas Soome {
505*472cd20dSToomas Soome namestr[0] = 0;
506*472cd20dSToomas Soome typestr[0] = 0;
507*472cd20dSToomas Soome domstr[0] = 0;
508*472cd20dSToomas Soome }
5095ffb0c9bSToomas Soome
5105ffb0c9bSToomas Soome // Calculate reply data length
5115ffb0c9bSToomas Soome len = sizeof(DNSServiceFlags);
5125ffb0c9bSToomas Soome len += sizeof(mDNSu32); // if index
5135ffb0c9bSToomas Soome len += sizeof(DNSServiceErrorType);
5145ffb0c9bSToomas Soome len += (int) (strlen(namestr) + 1);
5155ffb0c9bSToomas Soome len += (int) (strlen(typestr) + 1);
5165ffb0c9bSToomas Soome len += (int) (strlen(domstr) + 1);
5175ffb0c9bSToomas Soome
5185ffb0c9bSToomas Soome // Build reply header
5195ffb0c9bSToomas Soome *rep = create_reply(op, len, request);
5205ffb0c9bSToomas Soome (*rep)->rhdr->flags = dnssd_htonl(flags);
5215ffb0c9bSToomas Soome (*rep)->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, id, mDNSfalse));
5225ffb0c9bSToomas Soome (*rep)->rhdr->error = dnssd_htonl(err);
5235ffb0c9bSToomas Soome
5245ffb0c9bSToomas Soome // Build reply body
5255ffb0c9bSToomas Soome data = (char *)&(*rep)->rhdr[1];
5265ffb0c9bSToomas Soome put_string(namestr, &data);
5275ffb0c9bSToomas Soome put_string(typestr, &data);
5285ffb0c9bSToomas Soome put_string(domstr, &data);
5295ffb0c9bSToomas Soome
5305ffb0c9bSToomas Soome return mStatus_NoError;
5315ffb0c9bSToomas Soome }
5325ffb0c9bSToomas Soome }
5335ffb0c9bSToomas Soome
GenerateBrowseReply(const domainname * const servicename,const mDNSInterfaceID id,request_state * const request,reply_state ** const rep,reply_op_t op,DNSServiceFlags flags,mStatus err)534c65ebfc7SToomas Soome mDNSlocal void GenerateBrowseReply(const domainname *const servicename, const mDNSInterfaceID id,
5355ffb0c9bSToomas Soome request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
5365ffb0c9bSToomas Soome {
5375ffb0c9bSToomas Soome char namestr[MAX_DOMAIN_LABEL+1];
5385ffb0c9bSToomas Soome char typestr[MAX_ESCAPED_DOMAIN_NAME];
5395ffb0c9bSToomas Soome static const char domstr[] = ".";
5405ffb0c9bSToomas Soome int len;
5415ffb0c9bSToomas Soome char *data;
5424b22b933Srs
5435ffb0c9bSToomas Soome *rep = NULL;
5444b22b933Srs
545*472cd20dSToomas Soome if (servicename)
546*472cd20dSToomas Soome {
547*472cd20dSToomas Soome // 1. Put first label in namestr
548*472cd20dSToomas Soome ConvertDomainLabelToCString_unescaped((const domainlabel *)servicename, namestr);
5494b22b933Srs
550*472cd20dSToomas Soome // 2. Put second label and "local" into typestr
551*472cd20dSToomas Soome mDNS_snprintf(typestr, sizeof(typestr), "%#s.local.", SecondLabel(servicename));
552*472cd20dSToomas Soome }
553*472cd20dSToomas Soome else
554*472cd20dSToomas Soome {
555*472cd20dSToomas Soome namestr[0] = 0;
556*472cd20dSToomas Soome typestr[0] = 0;
557*472cd20dSToomas Soome }
5584b22b933Srs
5595ffb0c9bSToomas Soome // Calculate reply data length
5605ffb0c9bSToomas Soome len = sizeof(DNSServiceFlags);
5615ffb0c9bSToomas Soome len += sizeof(mDNSu32); // if index
5625ffb0c9bSToomas Soome len += sizeof(DNSServiceErrorType);
5635ffb0c9bSToomas Soome len += (int) (strlen(namestr) + 1);
5645ffb0c9bSToomas Soome len += (int) (strlen(typestr) + 1);
5655ffb0c9bSToomas Soome len += (int) (strlen(domstr) + 1);
5665ffb0c9bSToomas Soome
5675ffb0c9bSToomas Soome // Build reply header
5685ffb0c9bSToomas Soome *rep = create_reply(op, len, request);
5695ffb0c9bSToomas Soome (*rep)->rhdr->flags = dnssd_htonl(flags);
5705ffb0c9bSToomas Soome (*rep)->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, id, mDNSfalse));
5715ffb0c9bSToomas Soome (*rep)->rhdr->error = dnssd_htonl(err);
5725ffb0c9bSToomas Soome
5735ffb0c9bSToomas Soome // Build reply body
5745ffb0c9bSToomas Soome data = (char *)&(*rep)->rhdr[1];
5755ffb0c9bSToomas Soome put_string(namestr, &data);
5765ffb0c9bSToomas Soome put_string(typestr, &data);
5775ffb0c9bSToomas Soome put_string(domstr, &data);
5785ffb0c9bSToomas Soome }
5795ffb0c9bSToomas Soome
5805ffb0c9bSToomas Soome // Returns a resource record (allocated w/ malloc) containing the data found in an IPC message
5815ffb0c9bSToomas Soome // Data must be in the following format: flags, interfaceIndex, name, rrtype, rrclass, rdlen, rdata, (optional) ttl
5825ffb0c9bSToomas Soome // (ttl only extracted/set if ttl argument is non-zero). Returns NULL for a bad-parameter error
read_rr_from_ipc_msg(request_state * request,int GetTTL,int validate_flags)5835ffb0c9bSToomas Soome mDNSlocal AuthRecord *read_rr_from_ipc_msg(request_state *request, int GetTTL, int validate_flags)
5845ffb0c9bSToomas Soome {
5855ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
5865ffb0c9bSToomas Soome mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
587*472cd20dSToomas Soome char name[MAX_ESCAPED_DOMAIN_NAME];
5885ffb0c9bSToomas Soome int str_err = get_string(&request->msgptr, request->msgend, name, sizeof(name));
5895ffb0c9bSToomas Soome mDNSu16 type = get_uint16(&request->msgptr, request->msgend);
5905ffb0c9bSToomas Soome mDNSu16 class = get_uint16(&request->msgptr, request->msgend);
5915ffb0c9bSToomas Soome mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
592*472cd20dSToomas Soome const mDNSu8 *const rdata = (const mDNSu8 *)get_rdata (&request->msgptr, request->msgend, rdlen);
5935ffb0c9bSToomas Soome mDNSu32 ttl = GetTTL ? get_uint32(&request->msgptr, request->msgend) : 0;
594*472cd20dSToomas Soome size_t rdcapacity;
5955ffb0c9bSToomas Soome AuthRecord *rr;
5965ffb0c9bSToomas Soome mDNSInterfaceID InterfaceID;
5975ffb0c9bSToomas Soome AuthRecType artype;
598*472cd20dSToomas Soome mDNSu8 recordType;
5994b22b933Srs
6005ffb0c9bSToomas Soome request->flags = flags;
601cda73f64SToomas Soome request->interfaceIndex = interfaceIndex;
6024b22b933Srs
6035ffb0c9bSToomas Soome if (str_err) { LogMsg("ERROR: read_rr_from_ipc_msg - get_string"); return NULL; }
6044b22b933Srs
6055ffb0c9bSToomas Soome if (!request->msgptr) { LogMsg("Error reading Resource Record from client"); return NULL; }
6064b22b933Srs
6075ffb0c9bSToomas Soome if (validate_flags &&
6085ffb0c9bSToomas Soome !((flags & kDNSServiceFlagsShared) == kDNSServiceFlagsShared) &&
609*472cd20dSToomas Soome !((flags & kDNSServiceFlagsUnique) == kDNSServiceFlagsUnique) &&
610*472cd20dSToomas Soome !((flags & kDNSServiceFlagsKnownUnique) == kDNSServiceFlagsKnownUnique))
6115ffb0c9bSToomas Soome {
612*472cd20dSToomas Soome LogMsg("ERROR: Bad resource record flags (must be one of either kDNSServiceFlagsShared, kDNSServiceFlagsUnique or kDNSServiceFlagsKnownUnique)");
6135ffb0c9bSToomas Soome return NULL;
6145ffb0c9bSToomas Soome }
615*472cd20dSToomas Soome InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
6164b22b933Srs
617*472cd20dSToomas Soome // The registration is scoped to a specific interface index, but the interface is not currently on our list.
618*472cd20dSToomas Soome if ((InterfaceID == mDNSInterface_Any) && (interfaceIndex != kDNSServiceInterfaceIndexAny))
619*472cd20dSToomas Soome {
620*472cd20dSToomas Soome // On Apple platforms, an interface's mDNSInterfaceID is equal to its index. Using an interface index that isn't
621*472cd20dSToomas Soome // currently valid will cause the registration to take place as soon as it becomes valid. On other platforms,
622*472cd20dSToomas Soome // mDNSInterfaceID is actually a pointer to a platform-specific interface object, but we don't know what the pointer
623*472cd20dSToomas Soome // for the interface index will be ahead of time. For now, just return NULL to indicate an error condition since the
624*472cd20dSToomas Soome // interface index is invalid. Otherwise, the registration would be performed on all interfaces.
625*472cd20dSToomas Soome #if APPLE_OSX_mDNSResponder
626*472cd20dSToomas Soome InterfaceID = (mDNSInterfaceID)(uintptr_t)interfaceIndex;
627*472cd20dSToomas Soome #else
628*472cd20dSToomas Soome return NULL;
629*472cd20dSToomas Soome #endif
630*472cd20dSToomas Soome }
631*472cd20dSToomas Soome rdcapacity = (rdlen > sizeof(RDataBody2)) ? rdlen : sizeof(RDataBody2);
632*472cd20dSToomas Soome rr = (AuthRecord *) callocL("AuthRecord/read_rr_from_ipc_msg", sizeof(*rr) - sizeof(RDataBody) + rdcapacity);
633*472cd20dSToomas Soome if (!rr) FatalError("ERROR: calloc");
6344b22b933Srs
6355ffb0c9bSToomas Soome if (InterfaceID == mDNSInterface_LocalOnly)
6365ffb0c9bSToomas Soome artype = AuthRecordLocalOnly;
637c65ebfc7SToomas Soome else if (InterfaceID == mDNSInterface_P2P || InterfaceID == mDNSInterface_BLE)
6385ffb0c9bSToomas Soome artype = AuthRecordP2P;
6395ffb0c9bSToomas Soome else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P)
6405ffb0c9bSToomas Soome && (flags & kDNSServiceFlagsIncludeAWDL))
6415ffb0c9bSToomas Soome artype = AuthRecordAnyIncludeAWDLandP2P;
6425ffb0c9bSToomas Soome else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P))
6435ffb0c9bSToomas Soome artype = AuthRecordAnyIncludeP2P;
6445ffb0c9bSToomas Soome else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeAWDL))
6455ffb0c9bSToomas Soome artype = AuthRecordAnyIncludeAWDL;
6465ffb0c9bSToomas Soome else
6475ffb0c9bSToomas Soome artype = AuthRecordAny;
6484b22b933Srs
649*472cd20dSToomas Soome if (flags & kDNSServiceFlagsShared)
650*472cd20dSToomas Soome recordType = (mDNSu8) kDNSRecordTypeShared;
651*472cd20dSToomas Soome else if (flags & kDNSServiceFlagsKnownUnique)
652*472cd20dSToomas Soome recordType = (mDNSu8) kDNSRecordTypeKnownUnique;
653*472cd20dSToomas Soome else
654*472cd20dSToomas Soome recordType = (mDNSu8) kDNSRecordTypeUnique;
655*472cd20dSToomas Soome
656*472cd20dSToomas Soome mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, type, 0, recordType, artype, mDNSNULL, mDNSNULL);
6574b22b933Srs
6585ffb0c9bSToomas Soome if (!MakeDomainNameFromDNSNameString(&rr->namestorage, name))
6595ffb0c9bSToomas Soome {
6605ffb0c9bSToomas Soome LogMsg("ERROR: bad name: %s", name);
6615ffb0c9bSToomas Soome freeL("AuthRecord/read_rr_from_ipc_msg", rr);
6625ffb0c9bSToomas Soome return NULL;
6635ffb0c9bSToomas Soome }
6644b22b933Srs
6655ffb0c9bSToomas Soome if (flags & kDNSServiceFlagsAllowRemoteQuery) rr->AllowRemoteQuery = mDNStrue;
6665ffb0c9bSToomas Soome rr->resrec.rrclass = class;
6675ffb0c9bSToomas Soome rr->resrec.rdlength = rdlen;
668*472cd20dSToomas Soome rr->resrec.rdata->MaxRDLength = (mDNSu16)rdcapacity;
669*472cd20dSToomas Soome if (!SetRData(mDNSNULL, rdata, rdata + rdlen, &rr->resrec, rdlen))
670*472cd20dSToomas Soome {
671*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
672*472cd20dSToomas Soome "[R%u] read_rr_from_ipc_msg: SetRData failed for " PRI_DM_NAME " (" PUB_S ")",
673*472cd20dSToomas Soome request->request_id, DM_NAME_PARAM(rr->resrec.name), DNSTypeName(type));
674*472cd20dSToomas Soome freeL("AuthRecord/read_rr_from_ipc_msg", rr);
675*472cd20dSToomas Soome return NULL;
676*472cd20dSToomas Soome }
6775ffb0c9bSToomas Soome if (GetTTL) rr->resrec.rroriginalttl = ttl;
6785ffb0c9bSToomas Soome rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
6795ffb0c9bSToomas Soome SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rr->rdatahash for us
6805ffb0c9bSToomas Soome return rr;
6815ffb0c9bSToomas Soome }
6824b22b933Srs
build_domainname_from_strings(domainname * srv,char * name,char * regtype,char * domain)6835ffb0c9bSToomas Soome mDNSlocal int build_domainname_from_strings(domainname *srv, char *name, char *regtype, char *domain)
6845ffb0c9bSToomas Soome {
6855ffb0c9bSToomas Soome domainlabel n;
6865ffb0c9bSToomas Soome domainname d, t;
6874b22b933Srs
6885ffb0c9bSToomas Soome if (!MakeDomainLabelFromLiteralString(&n, name)) return -1;
6895ffb0c9bSToomas Soome if (!MakeDomainNameFromDNSNameString(&t, regtype)) return -1;
6905ffb0c9bSToomas Soome if (!MakeDomainNameFromDNSNameString(&d, domain)) return -1;
6915ffb0c9bSToomas Soome if (!ConstructServiceName(srv, &n, &t, &d)) return -1;
6925ffb0c9bSToomas Soome return 0;
6935ffb0c9bSToomas Soome }
6945ffb0c9bSToomas Soome
send_all(dnssd_sock_t s,const char * ptr,int len)6955ffb0c9bSToomas Soome mDNSlocal void send_all(dnssd_sock_t s, const char *ptr, int len)
6965ffb0c9bSToomas Soome {
697*472cd20dSToomas Soome const ssize_t n = send(s, ptr, len, 0);
6985ffb0c9bSToomas Soome // On a freshly-created Unix Domain Socket, the kernel should *never* fail to buffer a small write for us
6995ffb0c9bSToomas Soome // (four bytes for a typical error code return, 12 bytes for DNSServiceGetProperty(DaemonVersion)).
7005ffb0c9bSToomas Soome // If it does fail, we don't attempt to handle this failure, but we do log it so we know something is wrong.
7015ffb0c9bSToomas Soome if (n < len)
702*472cd20dSToomas Soome {
703*472cd20dSToomas Soome LogMsg("ERROR: send_all(%d) wrote %ld of %d errno %d (%s)",
704*472cd20dSToomas Soome s, (long)n, len, dnssd_errno, dnssd_strerror(dnssd_errno));
705*472cd20dSToomas Soome }
7065ffb0c9bSToomas Soome }
7075ffb0c9bSToomas Soome
7085ffb0c9bSToomas Soome #if 0
7095ffb0c9bSToomas Soome mDNSlocal mDNSBool AuthorizedDomain(const request_state * const request, const domainname * const d, const DNameListElem * const doms)
7105ffb0c9bSToomas Soome {
7115ffb0c9bSToomas Soome const DNameListElem *delem = mDNSNULL;
7125ffb0c9bSToomas Soome int bestDelta = -1; // the delta of the best match, lower is better
7135ffb0c9bSToomas Soome int dLabels = 0;
7145ffb0c9bSToomas Soome mDNSBool allow = mDNSfalse;
7155ffb0c9bSToomas Soome
7165ffb0c9bSToomas Soome if (SystemUID(request->uid)) return mDNStrue;
7175ffb0c9bSToomas Soome
7185ffb0c9bSToomas Soome dLabels = CountLabels(d);
7195ffb0c9bSToomas Soome for (delem = doms; delem; delem = delem->next)
7205ffb0c9bSToomas Soome {
7215ffb0c9bSToomas Soome if (delem->uid)
7225ffb0c9bSToomas Soome {
7235ffb0c9bSToomas Soome int delemLabels = CountLabels(&delem->name);
7245ffb0c9bSToomas Soome int delta = dLabels - delemLabels;
7255ffb0c9bSToomas Soome if ((bestDelta == -1 || delta <= bestDelta) && SameDomainName(&delem->name, SkipLeadingLabels(d, delta)))
7265ffb0c9bSToomas Soome {
7275ffb0c9bSToomas Soome bestDelta = delta;
7285ffb0c9bSToomas Soome allow = (allow || (delem->uid == request->uid));
7295ffb0c9bSToomas Soome }
7305ffb0c9bSToomas Soome }
7315ffb0c9bSToomas Soome }
7324b22b933Srs
7335ffb0c9bSToomas Soome return bestDelta == -1 ? mDNStrue : allow;
7345ffb0c9bSToomas Soome }
7355ffb0c9bSToomas Soome #endif
7364b22b933Srs
737*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, AUDIT_TOKEN)
SetupAuditTokenForRequest(request_state * request)738*472cd20dSToomas Soome mDNSlocal void SetupAuditTokenForRequest(request_state *request)
7395ffb0c9bSToomas Soome {
7404b22b933Srs
741*472cd20dSToomas Soome pid_t audit_pid = audit_token_to_pid(request->audit_token);
742*472cd20dSToomas Soome if (audit_pid == 0)
7435ffb0c9bSToomas Soome {
744*472cd20dSToomas Soome #if !defined(LOCAL_PEERTOKEN)
745*472cd20dSToomas Soome #define LOCAL_PEERTOKEN 0x006 /* retrieve peer audit token */
746*472cd20dSToomas Soome #endif
747*472cd20dSToomas Soome socklen_t len = sizeof(audit_token_t);
748*472cd20dSToomas Soome int ret = getsockopt(request->sd, SOL_LOCAL, LOCAL_PEERTOKEN, &request->audit_token, &len);
749*472cd20dSToomas Soome if (ret != 0)
750*472cd20dSToomas Soome {
751*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
752*472cd20dSToomas Soome "SetupAuditTokenForRequest: No audit_token using LOCAL_PEERTOKEN (%s PID %d) for op %d ret(%d)",
753*472cd20dSToomas Soome request->pid_name, request->process_id, request->hdr.op, ret);
754*472cd20dSToomas Soome }
7555ffb0c9bSToomas Soome }
7565ffb0c9bSToomas Soome }
757*472cd20dSToomas Soome #endif
758*472cd20dSToomas Soome
759*472cd20dSToomas Soome // ***************************************************************************
760*472cd20dSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
761*472cd20dSToomas Soome #pragma mark -
762*472cd20dSToomas Soome #pragma mark - external helpers
763*472cd20dSToomas Soome #endif
7644b22b933Srs
765*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
external_start_advertising_helper(service_instance * const instance)7665ffb0c9bSToomas Soome mDNSlocal void external_start_advertising_helper(service_instance *const instance)
7675ffb0c9bSToomas Soome {
7685ffb0c9bSToomas Soome AuthRecord *st = instance->subtypes;
7695ffb0c9bSToomas Soome ExtraResourceRecord *e;
7705ffb0c9bSToomas Soome int i;
771*472cd20dSToomas Soome const pid_t requestPID = instance->request->process_id;
7724b22b933Srs
7735ffb0c9bSToomas Soome if (mDNSIPPortIsZero(instance->request->u.servicereg.port))
7745ffb0c9bSToomas Soome {
7755ffb0c9bSToomas Soome LogInfo("external_start_advertising_helper: Not registering service with port number zero");
7765ffb0c9bSToomas Soome return;
7775ffb0c9bSToomas Soome }
7784b22b933Srs
7795ffb0c9bSToomas Soome if (instance->external_advertise) LogMsg("external_start_advertising_helper: external_advertise already set!");
7804b22b933Srs
7815ffb0c9bSToomas Soome for ( i = 0; i < instance->request->u.servicereg.num_subtypes; i++)
782*472cd20dSToomas Soome external_start_advertising_service(&st[i].resrec, instance->request->flags, requestPID);
783c65ebfc7SToomas Soome
784*472cd20dSToomas Soome external_start_advertising_service(&instance->srs.RR_PTR.resrec, instance->request->flags, requestPID);
785*472cd20dSToomas Soome external_start_advertising_service(&instance->srs.RR_SRV.resrec, instance->request->flags, requestPID);
786*472cd20dSToomas Soome external_start_advertising_service(&instance->srs.RR_TXT.resrec, instance->request->flags, requestPID);
7874b22b933Srs
7885ffb0c9bSToomas Soome for (e = instance->srs.Extras; e; e = e->next)
789*472cd20dSToomas Soome external_start_advertising_service(&e->r.resrec, instance->request->flags, requestPID);
7904b22b933Srs
7915ffb0c9bSToomas Soome instance->external_advertise = mDNStrue;
7925ffb0c9bSToomas Soome }
7934b22b933Srs
external_stop_advertising_helper(service_instance * const instance)7945ffb0c9bSToomas Soome mDNSlocal void external_stop_advertising_helper(service_instance *const instance)
7955ffb0c9bSToomas Soome {
7965ffb0c9bSToomas Soome AuthRecord *st = instance->subtypes;
7975ffb0c9bSToomas Soome ExtraResourceRecord *e;
7985ffb0c9bSToomas Soome int i;
7994b22b933Srs
8005ffb0c9bSToomas Soome if (!instance->external_advertise) return;
8014b22b933Srs
8025ffb0c9bSToomas Soome LogInfo("external_stop_advertising_helper: calling external_stop_advertising_service");
8034b22b933Srs
804*472cd20dSToomas Soome if (instance->request)
805*472cd20dSToomas Soome {
806*472cd20dSToomas Soome const pid_t requestPID = instance->request->process_id;
807*472cd20dSToomas Soome for (i = 0; i < instance->request->u.servicereg.num_subtypes; i++)
808*472cd20dSToomas Soome {
809*472cd20dSToomas Soome external_stop_advertising_service(&st[i].resrec, instance->request->flags, requestPID);
810*472cd20dSToomas Soome }
8114b22b933Srs
812*472cd20dSToomas Soome external_stop_advertising_service(&instance->srs.RR_PTR.resrec, instance->request->flags, requestPID);
813*472cd20dSToomas Soome external_stop_advertising_service(&instance->srs.RR_SRV.resrec, instance->request->flags, requestPID);
814*472cd20dSToomas Soome external_stop_advertising_service(&instance->srs.RR_TXT.resrec, instance->request->flags, requestPID);
8154b22b933Srs
816*472cd20dSToomas Soome for (e = instance->srs.Extras; e; e = e->next)
817*472cd20dSToomas Soome {
818*472cd20dSToomas Soome external_stop_advertising_service(&e->r.resrec, instance->request->flags, requestPID);
819*472cd20dSToomas Soome }
820*472cd20dSToomas Soome }
8214b22b933Srs
8225ffb0c9bSToomas Soome instance->external_advertise = mDNSfalse;
8235ffb0c9bSToomas Soome }
824*472cd20dSToomas Soome #endif // MDNSRESPONDER_SUPPORTS(APPLE, D2D)
825*472cd20dSToomas Soome
826*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
_get_trust_results_dispatch_queue(void)827*472cd20dSToomas Soome mDNSlocal dispatch_queue_t _get_trust_results_dispatch_queue(void)
828*472cd20dSToomas Soome {
829*472cd20dSToomas Soome static dispatch_once_t once = 0;
830*472cd20dSToomas Soome static dispatch_queue_t queue = NULL;
831*472cd20dSToomas Soome
832*472cd20dSToomas Soome dispatch_once(&once, ^{
833*472cd20dSToomas Soome dispatch_queue_attr_t const attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_UTILITY, 0);
834*472cd20dSToomas Soome queue = dispatch_queue_create("com.apple.mDNSResponder.trust_results-queue", attr);
835*472cd20dSToomas Soome });
836*472cd20dSToomas Soome return queue;
837*472cd20dSToomas Soome }
838*472cd20dSToomas Soome #endif
8394b22b933Srs
8405ffb0c9bSToomas Soome // ***************************************************************************
8415ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
8425ffb0c9bSToomas Soome #pragma mark -
8435ffb0c9bSToomas Soome #pragma mark - DNSServiceRegister
8445ffb0c9bSToomas Soome #endif
8454b22b933Srs
FreeExtraRR(mDNS * const m,AuthRecord * const rr,mStatus result)8465ffb0c9bSToomas Soome mDNSexport void FreeExtraRR(mDNS *const m, AuthRecord *const rr, mStatus result)
8475ffb0c9bSToomas Soome {
8485ffb0c9bSToomas Soome ExtraResourceRecord *extra = (ExtraResourceRecord *)rr->RecordContext;
8495ffb0c9bSToomas Soome (void)m; // Unused
8504b22b933Srs
8515ffb0c9bSToomas Soome if (result != mStatus_MemFree) { LogMsg("Error: FreeExtraRR invoked with unexpected error %d", result); return; }
8524b22b933Srs
8535ffb0c9bSToomas Soome LogInfo(" FreeExtraRR %s", RRDisplayString(m, &rr->resrec));
8544b22b933Srs
8555ffb0c9bSToomas Soome if (rr->resrec.rdata != &rr->rdatastorage)
8565ffb0c9bSToomas Soome freeL("Extra RData", rr->resrec.rdata);
8575ffb0c9bSToomas Soome freeL("ExtraResourceRecord/FreeExtraRR", extra);
8585ffb0c9bSToomas Soome }
8594b22b933Srs
unlink_and_free_service_instance(service_instance * srv)8605ffb0c9bSToomas Soome mDNSlocal void unlink_and_free_service_instance(service_instance *srv)
8615ffb0c9bSToomas Soome {
8625ffb0c9bSToomas Soome ExtraResourceRecord *e = srv->srs.Extras, *tmp;
8634b22b933Srs
864*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
8655ffb0c9bSToomas Soome external_stop_advertising_helper(srv);
866*472cd20dSToomas Soome #endif
8674b22b933Srs
8685ffb0c9bSToomas Soome // clear pointers from parent struct
8695ffb0c9bSToomas Soome if (srv->request)
8705ffb0c9bSToomas Soome {
8715ffb0c9bSToomas Soome service_instance **p = &srv->request->u.servicereg.instances;
8725ffb0c9bSToomas Soome while (*p)
8735ffb0c9bSToomas Soome {
8745ffb0c9bSToomas Soome if (*p == srv) { *p = (*p)->next; break; }
8755ffb0c9bSToomas Soome p = &(*p)->next;
8765ffb0c9bSToomas Soome }
8775ffb0c9bSToomas Soome }
8784b22b933Srs
8795ffb0c9bSToomas Soome while (e)
8805ffb0c9bSToomas Soome {
8815ffb0c9bSToomas Soome e->r.RecordContext = e;
8825ffb0c9bSToomas Soome tmp = e;
8835ffb0c9bSToomas Soome e = e->next;
8845ffb0c9bSToomas Soome FreeExtraRR(&mDNSStorage, &tmp->r, mStatus_MemFree);
8855ffb0c9bSToomas Soome }
8864b22b933Srs
8875ffb0c9bSToomas Soome if (srv->srs.RR_TXT.resrec.rdata != &srv->srs.RR_TXT.rdatastorage)
8885ffb0c9bSToomas Soome freeL("TXT RData", srv->srs.RR_TXT.resrec.rdata);
8894b22b933Srs
8905ffb0c9bSToomas Soome if (srv->subtypes)
8915ffb0c9bSToomas Soome {
8925ffb0c9bSToomas Soome freeL("ServiceSubTypes", srv->subtypes);
8935ffb0c9bSToomas Soome srv->subtypes = NULL;
8945ffb0c9bSToomas Soome }
8955ffb0c9bSToomas Soome freeL("service_instance", srv);
8965ffb0c9bSToomas Soome }
8974b22b933Srs
8985ffb0c9bSToomas Soome // Count how many other service records we have locally with the same name, but different rdata.
8995ffb0c9bSToomas Soome // For auto-named services, we can have at most one per machine -- if we allowed two auto-named services of
9005ffb0c9bSToomas Soome // the same type on the same machine, we'd get into an infinite autoimmune-response loop of continuous renaming.
CountPeerRegistrations(ServiceRecordSet * const srs)901c65ebfc7SToomas Soome mDNSexport int CountPeerRegistrations(ServiceRecordSet *const srs)
9025ffb0c9bSToomas Soome {
9035ffb0c9bSToomas Soome int count = 0;
9045ffb0c9bSToomas Soome ResourceRecord *r = &srs->RR_SRV.resrec;
9055ffb0c9bSToomas Soome AuthRecord *rr;
9064b22b933Srs
907c65ebfc7SToomas Soome for (rr = mDNSStorage.ResourceRecords; rr; rr=rr->next)
9085ffb0c9bSToomas Soome if (rr->resrec.rrtype == kDNSType_SRV && SameDomainName(rr->resrec.name, r->name) && !IdenticalSameNameRecord(&rr->resrec, r))
9095ffb0c9bSToomas Soome count++;
9104b22b933Srs
9115ffb0c9bSToomas Soome verbosedebugf("%d peer registrations for %##s", count, r->name->c);
9125ffb0c9bSToomas Soome return(count);
9135ffb0c9bSToomas Soome }
9144b22b933Srs
CountExistingRegistrations(domainname * srv,mDNSIPPort port)9155ffb0c9bSToomas Soome mDNSexport int CountExistingRegistrations(domainname *srv, mDNSIPPort port)
9165ffb0c9bSToomas Soome {
9175ffb0c9bSToomas Soome int count = 0;
9185ffb0c9bSToomas Soome AuthRecord *rr;
9195ffb0c9bSToomas Soome for (rr = mDNSStorage.ResourceRecords; rr; rr=rr->next)
9205ffb0c9bSToomas Soome if (rr->resrec.rrtype == kDNSType_SRV &&
9215ffb0c9bSToomas Soome mDNSSameIPPort(rr->resrec.rdata->u.srv.port, port) &&
9225ffb0c9bSToomas Soome SameDomainName(rr->resrec.name, srv))
9235ffb0c9bSToomas Soome count++;
9245ffb0c9bSToomas Soome return(count);
9255ffb0c9bSToomas Soome }
9265ffb0c9bSToomas Soome
SendServiceRemovalNotification(ServiceRecordSet * const srs)9275ffb0c9bSToomas Soome mDNSlocal void SendServiceRemovalNotification(ServiceRecordSet *const srs)
9285ffb0c9bSToomas Soome {
9295ffb0c9bSToomas Soome reply_state *rep;
9305ffb0c9bSToomas Soome service_instance *instance = srs->ServiceContext;
9315ffb0c9bSToomas Soome if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, 0, mStatus_NoError) != mStatus_NoError)
9325ffb0c9bSToomas Soome LogMsg("%3d: SendServiceRemovalNotification: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
9335ffb0c9bSToomas Soome else { append_reply(instance->request, rep); instance->clientnotified = mDNSfalse; }
9345ffb0c9bSToomas Soome }
9354b22b933Srs
9365ffb0c9bSToomas Soome // service registration callback performs three duties - frees memory for deregistered services,
9375ffb0c9bSToomas Soome // handles name conflicts, and delivers completed registration information to the client
regservice_callback(mDNS * const m,ServiceRecordSet * const srs,mStatus result)9385ffb0c9bSToomas Soome mDNSlocal void regservice_callback(mDNS *const m, ServiceRecordSet *const srs, mStatus result)
9395ffb0c9bSToomas Soome {
9405ffb0c9bSToomas Soome mStatus err;
9415ffb0c9bSToomas Soome mDNSBool SuppressError = mDNSfalse;
9425ffb0c9bSToomas Soome service_instance *instance;
9435ffb0c9bSToomas Soome reply_state *rep;
9445ffb0c9bSToomas Soome (void)m; // Unused
9454b22b933Srs
946*472cd20dSToomas Soome if (!srs)
947*472cd20dSToomas Soome {
948*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "regservice_callback: srs is NULL %d", result);
949*472cd20dSToomas Soome return;
950*472cd20dSToomas Soome }
9514b22b933Srs
9525ffb0c9bSToomas Soome instance = srs->ServiceContext;
953*472cd20dSToomas Soome if (!instance)
954*472cd20dSToomas Soome {
955*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "regservice_callback: srs->ServiceContext is NULL %d", result);
956*472cd20dSToomas Soome return;
957*472cd20dSToomas Soome }
9584b22b933Srs
9595ffb0c9bSToomas Soome // don't send errors up to client for wide-area, empty-string registrations
9605ffb0c9bSToomas Soome if (instance->request &&
9615ffb0c9bSToomas Soome instance->request->u.servicereg.default_domain &&
9625ffb0c9bSToomas Soome !instance->default_local)
9635ffb0c9bSToomas Soome SuppressError = mDNStrue;
9644b22b933Srs
9655ffb0c9bSToomas Soome if (mDNS_LoggingEnabled)
9665ffb0c9bSToomas Soome {
967*472cd20dSToomas Soome const char *result_description;
968*472cd20dSToomas Soome char description[32]; // 32-byte is enough for holding "suppressed error -2147483648\0"
969*472cd20dSToomas Soome mDNSu32 request_id = instance->request ? instance->request->request_id : 0;
970*472cd20dSToomas Soome switch (result) {
971*472cd20dSToomas Soome case mStatus_NoError:
972*472cd20dSToomas Soome result_description = "REGISTERED";
973*472cd20dSToomas Soome break;
974*472cd20dSToomas Soome case mStatus_MemFree:
975*472cd20dSToomas Soome result_description = "DEREGISTERED";
976*472cd20dSToomas Soome break;
977*472cd20dSToomas Soome case mStatus_NameConflict:
978*472cd20dSToomas Soome result_description = "NAME CONFLICT";
979*472cd20dSToomas Soome break;
980*472cd20dSToomas Soome default:
981*472cd20dSToomas Soome mDNS_snprintf(description, sizeof(description), "%s %d", SuppressError ? "suppressed error" : "CALLBACK", result);
982*472cd20dSToomas Soome result_description = description;
983*472cd20dSToomas Soome break;
984*472cd20dSToomas Soome }
985*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%u] DNSServiceRegister(" PRI_DM_NAME ", %u) %s",
986*472cd20dSToomas Soome request_id, DM_NAME_PARAM(srs->RR_SRV.resrec.name), mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port), result_description);
9875ffb0c9bSToomas Soome }
9884b22b933Srs
989*472cd20dSToomas Soome if (!instance->request && result != mStatus_MemFree)
990*472cd20dSToomas Soome {
991*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "regservice_callback: instance->request is NULL %d", result);
992*472cd20dSToomas Soome return;
993*472cd20dSToomas Soome }
9944b22b933Srs
9955ffb0c9bSToomas Soome if (result == mStatus_NoError)
9965ffb0c9bSToomas Soome {
9975ffb0c9bSToomas Soome if (instance->request->u.servicereg.allowremotequery)
9985ffb0c9bSToomas Soome {
9995ffb0c9bSToomas Soome ExtraResourceRecord *e;
10005ffb0c9bSToomas Soome srs->RR_ADV.AllowRemoteQuery = mDNStrue;
10015ffb0c9bSToomas Soome srs->RR_PTR.AllowRemoteQuery = mDNStrue;
10025ffb0c9bSToomas Soome srs->RR_SRV.AllowRemoteQuery = mDNStrue;
10035ffb0c9bSToomas Soome srs->RR_TXT.AllowRemoteQuery = mDNStrue;
10045ffb0c9bSToomas Soome for (e = instance->srs.Extras; e; e = e->next) e->r.AllowRemoteQuery = mDNStrue;
10055ffb0c9bSToomas Soome }
10064b22b933Srs
10075ffb0c9bSToomas Soome if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
1008*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] regservice_callback: " PRI_DM_NAME " is not valid DNS-SD SRV name", instance->request->request_id, DM_NAME_PARAM(srs->RR_SRV.resrec.name));
10095ffb0c9bSToomas Soome else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
10104b22b933Srs
1011*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
10125ffb0c9bSToomas Soome if (callExternalHelpers(instance->request->u.servicereg.InterfaceID, &instance->domain, instance->request->flags))
10135ffb0c9bSToomas Soome {
1014*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%u] regservice_callback: calling external_start_advertising_helper()", instance->request->request_id);
10155ffb0c9bSToomas Soome external_start_advertising_helper(instance);
10165ffb0c9bSToomas Soome }
1017*472cd20dSToomas Soome #endif
1018c65ebfc7SToomas Soome if (instance->request->u.servicereg.autoname && CountPeerRegistrations(srs) == 0)
1019c65ebfc7SToomas Soome RecordUpdatedNiceLabel(0); // Successfully got new name, tell user immediately
10205ffb0c9bSToomas Soome }
10215ffb0c9bSToomas Soome else if (result == mStatus_MemFree)
10225ffb0c9bSToomas Soome {
1023*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, METRICS)
1024c65ebfc7SToomas Soome curr_num_regservices--;
1025c65ebfc7SToomas Soome #endif
10265ffb0c9bSToomas Soome if (instance->request && instance->renameonmemfree)
10275ffb0c9bSToomas Soome {
1028*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
10295ffb0c9bSToomas Soome external_stop_advertising_helper(instance);
1030*472cd20dSToomas Soome #endif
10315ffb0c9bSToomas Soome instance->renameonmemfree = 0;
10325ffb0c9bSToomas Soome err = mDNS_RenameAndReregisterService(m, srs, &instance->request->u.servicereg.name);
1033*472cd20dSToomas Soome if (err)
1034*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] ERROR: regservice_callback - RenameAndReregisterService returned %d", instance->request->request_id, err);
10355ffb0c9bSToomas Soome // error should never happen - safest to log and continue
10365ffb0c9bSToomas Soome }
10375ffb0c9bSToomas Soome else
10385ffb0c9bSToomas Soome unlink_and_free_service_instance(instance);
10395ffb0c9bSToomas Soome }
10405ffb0c9bSToomas Soome else if (result == mStatus_NameConflict)
10415ffb0c9bSToomas Soome {
10425ffb0c9bSToomas Soome if (instance->request->u.servicereg.autorename)
10435ffb0c9bSToomas Soome {
1044*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
10455ffb0c9bSToomas Soome external_stop_advertising_helper(instance);
1046*472cd20dSToomas Soome #endif
1047c65ebfc7SToomas Soome if (instance->request->u.servicereg.autoname && CountPeerRegistrations(srs) == 0)
10485ffb0c9bSToomas Soome {
10495ffb0c9bSToomas Soome // On conflict for an autoname service, rename and reregister *all* autoname services
10505ffb0c9bSToomas Soome IncrementLabelSuffix(&m->nicelabel, mDNStrue);
10515ffb0c9bSToomas Soome mDNS_ConfigChanged(m); // Will call back into udsserver_handle_configchange()
10525ffb0c9bSToomas Soome }
10535ffb0c9bSToomas Soome else // On conflict for a non-autoname service, rename and reregister just that one service
10545ffb0c9bSToomas Soome {
10555ffb0c9bSToomas Soome if (instance->clientnotified) SendServiceRemovalNotification(srs);
10565ffb0c9bSToomas Soome mDNS_RenameAndReregisterService(m, srs, mDNSNULL);
10575ffb0c9bSToomas Soome }
10585ffb0c9bSToomas Soome }
10595ffb0c9bSToomas Soome else
10605ffb0c9bSToomas Soome {
10615ffb0c9bSToomas Soome if (!SuppressError)
10625ffb0c9bSToomas Soome {
10635ffb0c9bSToomas Soome if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
1064*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] regservice_callback: " PRI_DM_NAME " is not valid DNS-SD SRV name", instance->request->request_id, DM_NAME_PARAM(srs->RR_SRV.resrec.name));
10655ffb0c9bSToomas Soome else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
10665ffb0c9bSToomas Soome }
10675ffb0c9bSToomas Soome unlink_and_free_service_instance(instance);
10685ffb0c9bSToomas Soome }
10695ffb0c9bSToomas Soome }
10705ffb0c9bSToomas Soome else // Not mStatus_NoError, mStatus_MemFree, or mStatus_NameConflict
10715ffb0c9bSToomas Soome {
10725ffb0c9bSToomas Soome if (!SuppressError)
10735ffb0c9bSToomas Soome {
10745ffb0c9bSToomas Soome if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
1075*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] regservice_callback: " PRI_DM_NAME " is not valid DNS-SD SRV name", instance->request->request_id, DM_NAME_PARAM(srs->RR_SRV.resrec.name));
10765ffb0c9bSToomas Soome else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
10775ffb0c9bSToomas Soome }
10785ffb0c9bSToomas Soome }
10795ffb0c9bSToomas Soome }
10804b22b933Srs
regrecord_callback(mDNS * const m,AuthRecord * rr,mStatus result)10815ffb0c9bSToomas Soome mDNSlocal void regrecord_callback(mDNS *const m, AuthRecord *rr, mStatus result)
10825ffb0c9bSToomas Soome {
10835ffb0c9bSToomas Soome (void)m; // Unused
10845ffb0c9bSToomas Soome if (!rr->RecordContext) // parent struct already freed by termination callback
10855ffb0c9bSToomas Soome {
10865ffb0c9bSToomas Soome if (result == mStatus_NoError)
1087*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "Error: regrecord_callback: successful registration of orphaned record " PRI_S, ARDisplayString(m, rr));
10885ffb0c9bSToomas Soome else
10895ffb0c9bSToomas Soome {
1090*472cd20dSToomas Soome if (result != mStatus_MemFree)
1091*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "regrecord_callback: error %d received after parent termination", result);
10925ffb0c9bSToomas Soome
10935ffb0c9bSToomas Soome // We come here when the record is being deregistered either from DNSServiceRemoveRecord or connection_termination.
1094cda73f64SToomas Soome // If the record has been updated, we need to free the rdata. Every time we call mDNS_Update, it calls update_callback
10955ffb0c9bSToomas Soome // with the old rdata (so that we can free it) and stores the new rdata in "rr->resrec.rdata". This means, we need
10965ffb0c9bSToomas Soome // to free the latest rdata for which the update_callback was never called with.
10975ffb0c9bSToomas Soome if (rr->resrec.rdata != &rr->rdatastorage) freeL("RData/regrecord_callback", rr->resrec.rdata);
10985ffb0c9bSToomas Soome freeL("AuthRecord/regrecord_callback", rr);
10995ffb0c9bSToomas Soome }
11005ffb0c9bSToomas Soome }
11015ffb0c9bSToomas Soome else
11025ffb0c9bSToomas Soome {
11035ffb0c9bSToomas Soome registered_record_entry *re = rr->RecordContext;
11045ffb0c9bSToomas Soome request_state *request = re->request;
11054b22b933Srs
11065ffb0c9bSToomas Soome if (mDNS_LoggingEnabled)
11075ffb0c9bSToomas Soome {
1108*472cd20dSToomas Soome const char *result_description;
1109*472cd20dSToomas Soome char description[16]; // 16-byte is enough for holding -2147483648\0
1110*472cd20dSToomas Soome switch (result) {
1111*472cd20dSToomas Soome case mStatus_NoError:
1112*472cd20dSToomas Soome result_description = "REGISTERED";
1113*472cd20dSToomas Soome break;
1114*472cd20dSToomas Soome case mStatus_MemFree:
1115*472cd20dSToomas Soome result_description = "DEREGISTERED";
1116*472cd20dSToomas Soome break;
1117*472cd20dSToomas Soome case mStatus_NameConflict:
1118*472cd20dSToomas Soome result_description = "NAME CONFLICT";
1119*472cd20dSToomas Soome break;
1120*472cd20dSToomas Soome default:
1121*472cd20dSToomas Soome mDNS_snprintf(description, sizeof(description), "%d", result);
1122*472cd20dSToomas Soome result_description = description;
1123*472cd20dSToomas Soome break;
1124*472cd20dSToomas Soome }
1125*472cd20dSToomas Soome
1126*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%u] DNSServiceRegisterRecord(%u " PRI_S ")" PUB_S,
1127*472cd20dSToomas Soome request->request_id, re->key, RRDisplayString(m, &rr->resrec), result_description);
11285ffb0c9bSToomas Soome }
11294b22b933Srs
11305ffb0c9bSToomas Soome if (result != mStatus_MemFree)
11315ffb0c9bSToomas Soome {
11325ffb0c9bSToomas Soome int len = sizeof(DNSServiceFlags) + sizeof(mDNSu32) + sizeof(DNSServiceErrorType);
11335ffb0c9bSToomas Soome reply_state *reply = create_reply(reg_record_reply_op, len, request);
11345ffb0c9bSToomas Soome reply->mhdr->client_context = re->regrec_client_context;
11355ffb0c9bSToomas Soome reply->rhdr->flags = dnssd_htonl(0);
11365ffb0c9bSToomas Soome reply->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, rr->resrec.InterfaceID, mDNSfalse));
11375ffb0c9bSToomas Soome reply->rhdr->error = dnssd_htonl(result);
11385ffb0c9bSToomas Soome append_reply(request, reply);
11395ffb0c9bSToomas Soome }
11404b22b933Srs
11415ffb0c9bSToomas Soome if (result)
11425ffb0c9bSToomas Soome {
11435ffb0c9bSToomas Soome // If this is a callback to a keepalive record, do not free it.
11445ffb0c9bSToomas Soome if (result == mStatus_BadStateErr)
11455ffb0c9bSToomas Soome {
1146*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
1147*472cd20dSToomas Soome "[R%u] regrecord_callback: Callback with error code mStatus_BadStateErr - not freeing the record.", request->request_id);
11485ffb0c9bSToomas Soome }
11495ffb0c9bSToomas Soome else
11505ffb0c9bSToomas Soome {
11515ffb0c9bSToomas Soome // unlink from list, free memory
11525ffb0c9bSToomas Soome registered_record_entry **ptr = &request->u.reg_recs;
11535ffb0c9bSToomas Soome while (*ptr && (*ptr) != re) ptr = &(*ptr)->next;
1154*472cd20dSToomas Soome if (!*ptr)
1155*472cd20dSToomas Soome {
1156*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1157*472cd20dSToomas Soome "[R%u] regrecord_callback - record not in list!", request->request_id);
1158*472cd20dSToomas Soome return;
1159*472cd20dSToomas Soome }
11605ffb0c9bSToomas Soome *ptr = (*ptr)->next;
11615ffb0c9bSToomas Soome freeL("registered_record_entry AuthRecord regrecord_callback", re->rr);
11625ffb0c9bSToomas Soome freeL("registered_record_entry regrecord_callback", re);
11635ffb0c9bSToomas Soome }
11645ffb0c9bSToomas Soome }
11655ffb0c9bSToomas Soome else
11665ffb0c9bSToomas Soome {
1167*472cd20dSToomas Soome if (re->external_advertise)
1168*472cd20dSToomas Soome {
1169*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1170*472cd20dSToomas Soome "[R%u] regrecord_callback: external_advertise already set!", request->request_id);
1171*472cd20dSToomas Soome }
11724b22b933Srs
1173*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
11745ffb0c9bSToomas Soome if (callExternalHelpers(re->origInterfaceID, &rr->namestorage, request->flags))
11755ffb0c9bSToomas Soome {
1176*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
1177*472cd20dSToomas Soome "[R%u] regrecord_callback: calling external_start_advertising_service", request->request_id);
1178*472cd20dSToomas Soome external_start_advertising_service(&rr->resrec, request->flags, request->process_id);
11795ffb0c9bSToomas Soome re->external_advertise = mDNStrue;
11805ffb0c9bSToomas Soome }
1181*472cd20dSToomas Soome #endif
11825ffb0c9bSToomas Soome }
11835ffb0c9bSToomas Soome }
11845ffb0c9bSToomas Soome }
11854b22b933Srs
11865ffb0c9bSToomas Soome // set_peer_pid() is called after mem is allocated for each new request in NewRequest()
11875ffb0c9bSToomas Soome // This accounts for 2 places (connect_callback, request_callback)
set_peer_pid(request_state * request)11885ffb0c9bSToomas Soome mDNSlocal void set_peer_pid(request_state *request)
11895ffb0c9bSToomas Soome {
11905ffb0c9bSToomas Soome request->pid_name[0] = '\0';
11915ffb0c9bSToomas Soome request->process_id = -1;
1192c65ebfc7SToomas Soome #ifdef LOCAL_PEEREPID
1193*472cd20dSToomas Soome pid_t p = (pid_t) -1;
1194*472cd20dSToomas Soome socklen_t len = sizeof(p);
1195c65ebfc7SToomas Soome if (request->sd < 0)
11965ffb0c9bSToomas Soome return;
1197c65ebfc7SToomas Soome // to extract the effective pid value
1198c65ebfc7SToomas Soome if (getsockopt(request->sd, SOL_LOCAL, LOCAL_PEEREPID, &p, &len) != 0)
11995ffb0c9bSToomas Soome return;
12005ffb0c9bSToomas Soome // to extract the process name from the pid value
12015ffb0c9bSToomas Soome if (proc_pidinfo(p, PROC_PIDT_SHORTBSDINFO, 1, &proc, PROC_PIDT_SHORTBSDINFO_SIZE) == 0)
12025ffb0c9bSToomas Soome return;
1203c65ebfc7SToomas Soome mDNSPlatformStrLCopy(request->pid_name, proc.pbsi_comm, sizeof(request->pid_name));
12045ffb0c9bSToomas Soome request->process_id = p;
1205c65ebfc7SToomas Soome debugf("set_peer_pid: Client PEEREPID is %d %s", p, request->pid_name);
1206c65ebfc7SToomas Soome #else // !LOCAL_PEEREPID
1207cda73f64SToomas Soome LogInfo("set_peer_pid: Not Supported on this version of OS");
12085ffb0c9bSToomas Soome if (request->sd < 0)
12095ffb0c9bSToomas Soome return;
1210c65ebfc7SToomas Soome #endif // LOCAL_PEEREPID
12115ffb0c9bSToomas Soome }
12124b22b933Srs
connection_termination(request_state * request)12135ffb0c9bSToomas Soome mDNSlocal void connection_termination(request_state *request)
12145ffb0c9bSToomas Soome {
12155ffb0c9bSToomas Soome // When terminating a shared connection, we need to scan the all_requests list
12165ffb0c9bSToomas Soome // and terminate any subbordinate operations sharing this file descriptor
12175ffb0c9bSToomas Soome request_state **req = &all_requests;
12184b22b933Srs
1219*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
1220*472cd20dSToomas Soome "[R%d] DNSServiceCreateConnection STOP PID[%d](" PUB_S ")",
1221*472cd20dSToomas Soome request->request_id, request->process_id, request->pid_name);
12224b22b933Srs
12235ffb0c9bSToomas Soome while (*req)
12245ffb0c9bSToomas Soome {
12255ffb0c9bSToomas Soome if ((*req)->primary == request)
12265ffb0c9bSToomas Soome {
12275ffb0c9bSToomas Soome // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
12285ffb0c9bSToomas Soome request_state *tmp = *req;
12295ffb0c9bSToomas Soome if (tmp->primary == tmp) LogMsg("connection_termination ERROR (*req)->primary == *req for %p %d", tmp, tmp->sd);
12305ffb0c9bSToomas Soome if (tmp->replies) LogMsg("connection_termination ERROR How can subordinate req %p %d have replies queued?", tmp, tmp->sd);
12315ffb0c9bSToomas Soome abort_request(tmp);
12325ffb0c9bSToomas Soome *req = tmp->next;
1233*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
1234*472cd20dSToomas Soome if (tmp->trust)
1235*472cd20dSToomas Soome {
1236*472cd20dSToomas Soome void * context = mdns_trust_get_context(tmp->trust);
1237*472cd20dSToomas Soome mdns_trust_set_context(tmp->trust, NULL);
1238*472cd20dSToomas Soome if (context) freeL("context/connection_termination", context);
1239*472cd20dSToomas Soome mdns_trust_forget(&tmp->trust);
1240*472cd20dSToomas Soome }
1241*472cd20dSToomas Soome #endif
12425ffb0c9bSToomas Soome freeL("request_state/connection_termination", tmp);
12435ffb0c9bSToomas Soome }
12445ffb0c9bSToomas Soome else
12455ffb0c9bSToomas Soome req = &(*req)->next;
12465ffb0c9bSToomas Soome }
12474b22b933Srs
12485ffb0c9bSToomas Soome while (request->u.reg_recs)
12495ffb0c9bSToomas Soome {
12505ffb0c9bSToomas Soome registered_record_entry *ptr = request->u.reg_recs;
1251*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
1252*472cd20dSToomas Soome "[R%d] DNSServiceRegisterRecord(0x%X, %d, " PRI_S ") STOP PID[%d](" PUB_S ")",
1253*472cd20dSToomas Soome request->request_id, request->flags, request->interfaceIndex, RRDisplayString(&mDNSStorage, &ptr->rr->resrec), request->process_id,
1254*472cd20dSToomas Soome request->pid_name);
1255c65ebfc7SToomas Soome request->u.reg_recs = request->u.reg_recs->next;
12565ffb0c9bSToomas Soome ptr->rr->RecordContext = NULL;
12575ffb0c9bSToomas Soome if (ptr->external_advertise)
12585ffb0c9bSToomas Soome {
12595ffb0c9bSToomas Soome ptr->external_advertise = mDNSfalse;
1260*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
1261*472cd20dSToomas Soome external_stop_advertising_service(&ptr->rr->resrec, request->flags, request->process_id);
1262*472cd20dSToomas Soome #endif
12635ffb0c9bSToomas Soome }
1264c65ebfc7SToomas Soome LogMcastS(ptr->rr, request, reg_stop);
12655ffb0c9bSToomas Soome mDNS_Deregister(&mDNSStorage, ptr->rr); // Will free ptr->rr for us
12665ffb0c9bSToomas Soome freeL("registered_record_entry/connection_termination", ptr);
12675ffb0c9bSToomas Soome }
12685ffb0c9bSToomas Soome }
12694b22b933Srs
handle_cancel_request(request_state * request)12705ffb0c9bSToomas Soome mDNSlocal void handle_cancel_request(request_state *request)
12715ffb0c9bSToomas Soome {
12725ffb0c9bSToomas Soome request_state **req = &all_requests;
1273*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEBUG, "[R%d] Cancel %08X %08X",
1274*472cd20dSToomas Soome request->request_id, request->hdr.client_context.u32[1], request->hdr.client_context.u32[0]);
12755ffb0c9bSToomas Soome while (*req)
12765ffb0c9bSToomas Soome {
12775ffb0c9bSToomas Soome if ((*req)->primary == request &&
12785ffb0c9bSToomas Soome (*req)->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
12795ffb0c9bSToomas Soome (*req)->hdr.client_context.u32[1] == request->hdr.client_context.u32[1])
12805ffb0c9bSToomas Soome {
12815ffb0c9bSToomas Soome // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
12825ffb0c9bSToomas Soome request_state *tmp = *req;
12835ffb0c9bSToomas Soome abort_request(tmp);
12845ffb0c9bSToomas Soome *req = tmp->next;
1285*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
1286*472cd20dSToomas Soome if (tmp->trust)
1287*472cd20dSToomas Soome {
1288*472cd20dSToomas Soome void * context = mdns_trust_get_context(tmp->trust);
1289*472cd20dSToomas Soome mdns_trust_set_context(tmp->trust, NULL);
1290*472cd20dSToomas Soome if (context) freeL("context/handle_cancel_request", context);
1291*472cd20dSToomas Soome mdns_trust_forget(&tmp->trust);
1292*472cd20dSToomas Soome }
1293*472cd20dSToomas Soome #endif
12945ffb0c9bSToomas Soome freeL("request_state/handle_cancel_request", tmp);
12955ffb0c9bSToomas Soome }
12965ffb0c9bSToomas Soome else
12975ffb0c9bSToomas Soome req = &(*req)->next;
12985ffb0c9bSToomas Soome }
12995ffb0c9bSToomas Soome }
13004b22b933Srs
_handle_regrecord_request_start(request_state * request,AuthRecord * rr)1301*472cd20dSToomas Soome mDNSlocal mStatus _handle_regrecord_request_start(request_state *request, AuthRecord * rr)
1302*472cd20dSToomas Soome {
1303*472cd20dSToomas Soome mStatus err;
1304*472cd20dSToomas Soome registered_record_entry *re;
1305*472cd20dSToomas Soome // Don't allow non-local domains to be regsitered as LocalOnly. Allowing this would permit
1306*472cd20dSToomas Soome // clients to register records such as www.bigbank.com A w.x.y.z to redirect Safari.
1307*472cd20dSToomas Soome if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly && !IsLocalDomain(rr->resrec.name) &&
1308*472cd20dSToomas Soome rr->resrec.rrclass == kDNSClass_IN && (rr->resrec.rrtype == kDNSType_A || rr->resrec.rrtype == kDNSType_AAAA ||
1309*472cd20dSToomas Soome rr->resrec.rrtype == kDNSType_CNAME))
1310*472cd20dSToomas Soome {
1311*472cd20dSToomas Soome freeL("AuthRecord/handle_regrecord_request", rr);
1312*472cd20dSToomas Soome return (mStatus_BadParamErr);
1313*472cd20dSToomas Soome }
1314*472cd20dSToomas Soome // allocate registration entry, link into list
1315*472cd20dSToomas Soome re = (registered_record_entry *) callocL("registered_record_entry", sizeof(*re));
1316*472cd20dSToomas Soome if (!re) FatalError("ERROR: calloc");
1317*472cd20dSToomas Soome re->key = request->hdr.reg_index;
1318*472cd20dSToomas Soome re->rr = rr;
1319*472cd20dSToomas Soome re->regrec_client_context = request->hdr.client_context;
1320*472cd20dSToomas Soome re->request = request;
1321*472cd20dSToomas Soome re->external_advertise = mDNSfalse;
1322*472cd20dSToomas Soome rr->RecordContext = re;
1323*472cd20dSToomas Soome rr->RecordCallback = regrecord_callback;
1324*472cd20dSToomas Soome
1325*472cd20dSToomas Soome re->origInterfaceID = rr->resrec.InterfaceID;
1326*472cd20dSToomas Soome if (rr->resrec.InterfaceID == mDNSInterface_P2P)
1327*472cd20dSToomas Soome rr->resrec.InterfaceID = mDNSInterface_Any;
1328*472cd20dSToomas Soome #if 0
1329*472cd20dSToomas Soome if (!AuthorizedDomain(request, rr->resrec.name, AutoRegistrationDomains)) return (mStatus_NoError);
1330*472cd20dSToomas Soome #endif
1331*472cd20dSToomas Soome if (rr->resrec.rroriginalttl == 0)
1332*472cd20dSToomas Soome rr->resrec.rroriginalttl = DefaultTTLforRRType(rr->resrec.rrtype);
1333*472cd20dSToomas Soome
1334*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
1335*472cd20dSToomas Soome "[R%d] DNSServiceRegisterRecord(0x%X, %d, " PRI_S ") START PID[%d](" PUB_S ")",
1336*472cd20dSToomas Soome request->request_id, request->flags, request->interfaceIndex, RRDisplayString(&mDNSStorage, &rr->resrec), request->process_id,
1337*472cd20dSToomas Soome request->pid_name);
1338*472cd20dSToomas Soome
1339*472cd20dSToomas Soome err = mDNS_Register(&mDNSStorage, rr);
1340*472cd20dSToomas Soome if (err)
1341*472cd20dSToomas Soome {
1342*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
1343*472cd20dSToomas Soome "[R%d] DNSServiceRegisterRecord(0x%X, %d," PRI_S ") ERROR (%d)",
1344*472cd20dSToomas Soome request->request_id, request->flags, request->interfaceIndex, RRDisplayString(&mDNSStorage, &rr->resrec), err);
1345*472cd20dSToomas Soome freeL("registered_record_entry", re);
1346*472cd20dSToomas Soome freeL("registered_record_entry/AuthRecord", rr);
1347*472cd20dSToomas Soome }
1348*472cd20dSToomas Soome else
1349*472cd20dSToomas Soome {
1350*472cd20dSToomas Soome LogMcastS(rr, request, reg_start);
1351*472cd20dSToomas Soome re->next = request->u.reg_recs;
1352*472cd20dSToomas Soome request->u.reg_recs = re;
1353*472cd20dSToomas Soome }
1354*472cd20dSToomas Soome return err;
1355*472cd20dSToomas Soome }
1356*472cd20dSToomas Soome
1357*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
1358*472cd20dSToomas Soome
_return_regrecord_request_error(request_state * request,mStatus error)1359*472cd20dSToomas Soome mDNSlocal void _return_regrecord_request_error(request_state *request, mStatus error)
1360*472cd20dSToomas Soome {
1361*472cd20dSToomas Soome reply_state *rep;
1362*472cd20dSToomas Soome if (GenerateNTDResponse(NULL, 0, request, &rep, reg_record_reply_op, 0, error) != mStatus_NoError)
1363*472cd20dSToomas Soome {
1364*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] DNSServiceRegisterRecord _return_regrecord_request_error: error(%d)", request->request_id, error);
1365*472cd20dSToomas Soome }
1366*472cd20dSToomas Soome else
1367*472cd20dSToomas Soome {
1368*472cd20dSToomas Soome append_reply(request, rep);
1369*472cd20dSToomas Soome }
1370*472cd20dSToomas Soome }
1371*472cd20dSToomas Soome
_handle_regrecord_request_with_trust(request_state * request,AuthRecord * rr)1372*472cd20dSToomas Soome mDNSlocal mStatus _handle_regrecord_request_with_trust(request_state *request, AuthRecord * rr)
1373*472cd20dSToomas Soome {
1374*472cd20dSToomas Soome mStatus err;
1375*472cd20dSToomas Soome if (audit_token_to_pid(request->audit_token) == 0)
1376*472cd20dSToomas Soome {
1377*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_regrecord_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
1378*472cd20dSToomas Soome err = _handle_regrecord_request_start(request, rr);
1379*472cd20dSToomas Soome }
1380*472cd20dSToomas Soome else
1381*472cd20dSToomas Soome {
1382*472cd20dSToomas Soome const char *service_ptr = NULL;
1383*472cd20dSToomas Soome char type_str[MAX_ESCAPED_DOMAIN_NAME] = "";
1384*472cd20dSToomas Soome domainlabel name;
1385*472cd20dSToomas Soome domainname type, domain;
1386*472cd20dSToomas Soome bool good = DeconstructServiceName(rr->resrec.name, &name, &type, &domain);
1387*472cd20dSToomas Soome if (good)
1388*472cd20dSToomas Soome {
1389*472cd20dSToomas Soome ConvertDomainNameToCString(&type, type_str);
1390*472cd20dSToomas Soome service_ptr = type_str;
1391*472cd20dSToomas Soome }
1392*472cd20dSToomas Soome
1393*472cd20dSToomas Soome mdns_trust_flags_t flags = mdns_trust_flags_none;
1394*472cd20dSToomas Soome mdns_trust_status_t status = mdns_trust_check_bonjour(request->audit_token, service_ptr, &flags);
1395*472cd20dSToomas Soome switch (status)
1396*472cd20dSToomas Soome {
1397*472cd20dSToomas Soome case mdns_trust_status_denied:
1398*472cd20dSToomas Soome case mdns_trust_status_pending:
1399*472cd20dSToomas Soome {
1400*472cd20dSToomas Soome mdns_trust_t trust = mdns_trust_create(request->audit_token, service_ptr, flags);
1401*472cd20dSToomas Soome if (!trust)
1402*472cd20dSToomas Soome {
1403*472cd20dSToomas Soome freeL("AuthRecord/_handle_regrecord_request_with_trust", rr);
1404*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
1405*472cd20dSToomas Soome goto exit;
1406*472cd20dSToomas Soome }
1407*472cd20dSToomas Soome mdns_trust_set_context(trust, rr);
1408*472cd20dSToomas Soome mdns_trust_set_queue(trust, _get_trust_results_dispatch_queue());
1409*472cd20dSToomas Soome mdns_trust_set_event_handler(trust, ^(mdns_trust_event_t event, mdns_trust_status_t update)
1410*472cd20dSToomas Soome {
1411*472cd20dSToomas Soome if (event == mdns_trust_event_result)
1412*472cd20dSToomas Soome {
1413*472cd20dSToomas Soome mStatus error = (update != mdns_trust_status_granted) ? mStatus_PolicyDenied : mStatus_NoError;
1414*472cd20dSToomas Soome KQueueLock();
1415*472cd20dSToomas Soome AuthRecord * _rr = mdns_trust_get_context(trust);
1416*472cd20dSToomas Soome if (_rr)
1417*472cd20dSToomas Soome {
1418*472cd20dSToomas Soome if (!error)
1419*472cd20dSToomas Soome {
1420*472cd20dSToomas Soome mdns_trust_set_context(trust, NULL); // _handle_regrecord_request_start handles free
1421*472cd20dSToomas Soome error = _handle_regrecord_request_start(request, _rr);
1422*472cd20dSToomas Soome // No context means the request was canceled before we got here
1423*472cd20dSToomas Soome }
1424*472cd20dSToomas Soome if (error) // (not else if) Always check for error result
1425*472cd20dSToomas Soome {
1426*472cd20dSToomas Soome _return_regrecord_request_error(request, error);
1427*472cd20dSToomas Soome }
1428*472cd20dSToomas Soome }
1429*472cd20dSToomas Soome KQueueUnlock("_handle_regrecord_request_with_trust");
1430*472cd20dSToomas Soome }
1431*472cd20dSToomas Soome });
1432*472cd20dSToomas Soome request->trust = trust;
1433*472cd20dSToomas Soome mdns_trust_activate(trust);
1434*472cd20dSToomas Soome err = mStatus_NoError;
1435*472cd20dSToomas Soome break;
1436*472cd20dSToomas Soome }
1437*472cd20dSToomas Soome
1438*472cd20dSToomas Soome case mdns_trust_status_no_entitlement:
1439*472cd20dSToomas Soome err = mStatus_NoAuth;
1440*472cd20dSToomas Soome break;
1441*472cd20dSToomas Soome
1442*472cd20dSToomas Soome case mdns_trust_status_granted:
1443*472cd20dSToomas Soome err = _handle_regrecord_request_start(request, rr);
1444*472cd20dSToomas Soome break;
1445*472cd20dSToomas Soome
1446*472cd20dSToomas Soome default:
1447*472cd20dSToomas Soome err = mStatus_UnknownErr;
1448*472cd20dSToomas Soome break;
1449*472cd20dSToomas Soome }
1450*472cd20dSToomas Soome }
1451*472cd20dSToomas Soome exit:
1452*472cd20dSToomas Soome return err;
1453*472cd20dSToomas Soome }
1454*472cd20dSToomas Soome #endif // TRUST_ENFORCEMENT
1455*472cd20dSToomas Soome
handle_regrecord_request(request_state * request)14565ffb0c9bSToomas Soome mDNSlocal mStatus handle_regrecord_request(request_state *request)
14575ffb0c9bSToomas Soome {
14585ffb0c9bSToomas Soome mStatus err = mStatus_BadParamErr;
1459c65ebfc7SToomas Soome AuthRecord *rr;
1460c65ebfc7SToomas Soome
1461c65ebfc7SToomas Soome if (request->terminate != connection_termination)
1462c65ebfc7SToomas Soome { LogMsg("%3d: DNSServiceRegisterRecord(not a shared connection ref)", request->sd); return(err); }
1463c65ebfc7SToomas Soome
1464c65ebfc7SToomas Soome rr = read_rr_from_ipc_msg(request, 1, 1);
14655ffb0c9bSToomas Soome if (rr)
14665ffb0c9bSToomas Soome {
1467*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
1468*472cd20dSToomas Soome if (os_feature_enabled(mDNSResponder, bonjour_privacy) &&
1469*472cd20dSToomas Soome IsLocalDomain(rr->resrec.name))
14705ffb0c9bSToomas Soome {
1471*472cd20dSToomas Soome err = _handle_regrecord_request_with_trust(request, rr);
14725ffb0c9bSToomas Soome }
14735ffb0c9bSToomas Soome else
14745ffb0c9bSToomas Soome {
1475*472cd20dSToomas Soome err = _handle_regrecord_request_start(request, rr);
14765ffb0c9bSToomas Soome }
1477*472cd20dSToomas Soome #else
1478*472cd20dSToomas Soome err = _handle_regrecord_request_start(request, rr);
1479*472cd20dSToomas Soome #endif
14805ffb0c9bSToomas Soome }
14815ffb0c9bSToomas Soome return(err);
14825ffb0c9bSToomas Soome }
14834b22b933Srs
14845ffb0c9bSToomas Soome mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m);
14854b22b933Srs
regservice_termination_callback(request_state * request)14865ffb0c9bSToomas Soome mDNSlocal void regservice_termination_callback(request_state *request)
14875ffb0c9bSToomas Soome {
1488c65ebfc7SToomas Soome if (!request)
1489c65ebfc7SToomas Soome {
1490c65ebfc7SToomas Soome LogMsg("regservice_termination_callback context is NULL");
1491c65ebfc7SToomas Soome return;
14925ffb0c9bSToomas Soome }
14935ffb0c9bSToomas Soome while (request->u.servicereg.instances)
14945ffb0c9bSToomas Soome {
14955ffb0c9bSToomas Soome service_instance *p = request->u.servicereg.instances;
14965ffb0c9bSToomas Soome request->u.servicereg.instances = request->u.servicereg.instances->next;
14975ffb0c9bSToomas Soome // only safe to free memory if registration is not valid, i.e. deregister fails (which invalidates p)
1498*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%d] DNSServiceRegister(" PRI_DM_NAME ", %u) STOP PID[%d](" PUB_S ")",
1499*472cd20dSToomas Soome request->request_id, DM_NAME_PARAM(p->srs.RR_SRV.resrec.name),
1500*472cd20dSToomas Soome mDNSVal16(p->srs.RR_SRV.resrec.rdata->u.srv.port), request->process_id, request->pid_name);
15015ffb0c9bSToomas Soome
1502*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
15035ffb0c9bSToomas Soome external_stop_advertising_helper(p);
1504*472cd20dSToomas Soome #endif
15055ffb0c9bSToomas Soome
15065ffb0c9bSToomas Soome // Clear backpointer *before* calling mDNS_DeregisterService/unlink_and_free_service_instance
15075ffb0c9bSToomas Soome // We don't need unlink_and_free_service_instance to cut its element from the list, because we're already advancing
15085ffb0c9bSToomas Soome // request->u.servicereg.instances as we work our way through the list, implicitly cutting one element at a time
15095ffb0c9bSToomas Soome // We can't clear p->request *after* the calling mDNS_DeregisterService/unlink_and_free_service_instance
15105ffb0c9bSToomas Soome // because by then we might have already freed p
15115ffb0c9bSToomas Soome p->request = NULL;
1512c65ebfc7SToomas Soome LogMcastS(&p->srs.RR_SRV, request, reg_stop);
15135ffb0c9bSToomas Soome if (mDNS_DeregisterService(&mDNSStorage, &p->srs))
15145ffb0c9bSToomas Soome {
15155ffb0c9bSToomas Soome unlink_and_free_service_instance(p);
15165ffb0c9bSToomas Soome // Don't touch service_instance *p after this -- it's likely to have been freed already
15175ffb0c9bSToomas Soome }
15185ffb0c9bSToomas Soome }
15195ffb0c9bSToomas Soome if (request->u.servicereg.txtdata)
1520c65ebfc7SToomas Soome {
1521c65ebfc7SToomas Soome freeL("service_info txtdata", request->u.servicereg.txtdata);
1522c65ebfc7SToomas Soome request->u.servicereg.txtdata = NULL;
15235ffb0c9bSToomas Soome }
15245ffb0c9bSToomas Soome if (request->u.servicereg.autoname)
15255ffb0c9bSToomas Soome {
15265ffb0c9bSToomas Soome // Clear autoname before calling UpdateDeviceInfoRecord() so it doesn't mistakenly include this in its count of active autoname registrations
15275ffb0c9bSToomas Soome request->u.servicereg.autoname = mDNSfalse;
15285ffb0c9bSToomas Soome UpdateDeviceInfoRecord(&mDNSStorage);
15295ffb0c9bSToomas Soome }
15305ffb0c9bSToomas Soome }
15314b22b933Srs
LocateSubordinateRequest(request_state * request)15325ffb0c9bSToomas Soome mDNSlocal request_state *LocateSubordinateRequest(request_state *request)
15335ffb0c9bSToomas Soome {
15345ffb0c9bSToomas Soome request_state *req;
15355ffb0c9bSToomas Soome for (req = all_requests; req; req = req->next)
15365ffb0c9bSToomas Soome if (req->primary == request &&
15375ffb0c9bSToomas Soome req->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
15385ffb0c9bSToomas Soome req->hdr.client_context.u32[1] == request->hdr.client_context.u32[1]) return(req);
15395ffb0c9bSToomas Soome return(request);
15405ffb0c9bSToomas Soome }
15415ffb0c9bSToomas Soome
add_record_to_service(request_state * request,service_instance * instance,mDNSu16 rrtype,mDNSu16 rdlen,const mDNSu8 * const rdata,mDNSu32 ttl)1542*472cd20dSToomas Soome mDNSlocal mStatus add_record_to_service(request_state *request, service_instance *instance, mDNSu16 rrtype, mDNSu16 rdlen,
1543*472cd20dSToomas Soome const mDNSu8 *const rdata, mDNSu32 ttl)
15445ffb0c9bSToomas Soome {
15455ffb0c9bSToomas Soome ServiceRecordSet *srs = &instance->srs;
15465ffb0c9bSToomas Soome mStatus result;
1547*472cd20dSToomas Soome const size_t rdcapacity = (rdlen > sizeof(RDataBody2)) ? rdlen : sizeof(RDataBody2);
1548*472cd20dSToomas Soome ExtraResourceRecord *extra = (ExtraResourceRecord *)callocL("ExtraResourceRecord", sizeof(*extra) - sizeof(RDataBody) + rdcapacity);
1549*472cd20dSToomas Soome if (!extra) { my_perror("ERROR: calloc"); return mStatus_NoMemoryErr; }
15504b22b933Srs
15515ffb0c9bSToomas Soome extra->r.resrec.rrtype = rrtype;
1552*472cd20dSToomas Soome extra->r.resrec.rdata = &extra->r.rdatastorage;
1553*472cd20dSToomas Soome extra->r.resrec.rdata->MaxRDLength = (mDNSu16)rdcapacity;
15545ffb0c9bSToomas Soome extra->r.resrec.rdlength = rdlen;
1555*472cd20dSToomas Soome if (!SetRData(mDNSNULL, rdata, rdata + rdlen, &extra->r.resrec, rdlen))
1556*472cd20dSToomas Soome {
1557*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
1558*472cd20dSToomas Soome "[R%u] read_rr_from_ipc_msg: SetRData failed for " PRI_DM_NAME " (" PUB_S ")",
1559*472cd20dSToomas Soome request->request_id, DM_NAME_PARAM(request->u.servicereg.instances ?
1560*472cd20dSToomas Soome request->u.servicereg.instances->srs.RR_SRV.resrec.name : mDNSNULL), DNSTypeName(rrtype));
1561*472cd20dSToomas Soome freeL("ExtraResourceRecord/add_record_to_service", extra);
1562*472cd20dSToomas Soome return mStatus_BadParamErr;
1563*472cd20dSToomas Soome }
1564*472cd20dSToomas Soome SetNewRData(&extra->r.resrec, mDNSNULL, 0); // Sets rr->rdatahash for us
15655ffb0c9bSToomas Soome // use InterfaceID value from DNSServiceRegister() call that created the original service
15665ffb0c9bSToomas Soome extra->r.resrec.InterfaceID = request->u.servicereg.InterfaceID;
15675ffb0c9bSToomas Soome
1568c65ebfc7SToomas Soome result = mDNS_AddRecordToService(&mDNSStorage, srs, extra, &extra->r.rdatastorage, ttl, request->flags);
1569c65ebfc7SToomas Soome if (result)
1570c65ebfc7SToomas Soome {
1571c65ebfc7SToomas Soome freeL("ExtraResourceRecord/add_record_to_service", extra);
1572c65ebfc7SToomas Soome return result;
1573c65ebfc7SToomas Soome }
1574c65ebfc7SToomas Soome LogMcastS(&srs->RR_PTR, request, reg_start);
1575c65ebfc7SToomas Soome
15765ffb0c9bSToomas Soome extra->ClientID = request->hdr.reg_index;
1577*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
15785ffb0c9bSToomas Soome if ( instance->external_advertise
15795ffb0c9bSToomas Soome && callExternalHelpers(request->u.servicereg.InterfaceID, &instance->domain, request->flags))
15805ffb0c9bSToomas Soome {
15815ffb0c9bSToomas Soome LogInfo("add_record_to_service: calling external_start_advertising_service");
1582*472cd20dSToomas Soome external_start_advertising_service(&extra->r.resrec, request->flags, request->process_id);
15835ffb0c9bSToomas Soome }
1584*472cd20dSToomas Soome #endif
15855ffb0c9bSToomas Soome return result;
15865ffb0c9bSToomas Soome }
15874b22b933Srs
handle_add_request(request_state * request)15885ffb0c9bSToomas Soome mDNSlocal mStatus handle_add_request(request_state *request)
15895ffb0c9bSToomas Soome {
15905ffb0c9bSToomas Soome service_instance *i;
15915ffb0c9bSToomas Soome mStatus result = mStatus_UnknownErr;
15925ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend);
15935ffb0c9bSToomas Soome mDNSu16 rrtype = get_uint16(&request->msgptr, request->msgend);
15945ffb0c9bSToomas Soome mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
1595*472cd20dSToomas Soome const mDNSu8 *const rdata = (const mDNSu8 *)get_rdata(&request->msgptr, request->msgend, rdlen);
15965ffb0c9bSToomas Soome mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
15975ffb0c9bSToomas Soome if (!ttl) ttl = DefaultTTLforRRType(rrtype);
15985ffb0c9bSToomas Soome (void)flags; // Unused
15994b22b933Srs
1600*472cd20dSToomas Soome if (!request->msgptr)
1601*472cd20dSToomas Soome {
1602*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1603*472cd20dSToomas Soome "[R%d] DNSServiceAddRecord(unreadable parameters)", request->request_id);
1604*472cd20dSToomas Soome return(mStatus_BadParamErr);
1605*472cd20dSToomas Soome }
16064b22b933Srs
16075ffb0c9bSToomas Soome // If this is a shared connection, check if the operation actually applies to a subordinate request_state object
16085ffb0c9bSToomas Soome if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
16094b22b933Srs
16105ffb0c9bSToomas Soome if (request->terminate != regservice_termination_callback)
1611*472cd20dSToomas Soome {
1612*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1613*472cd20dSToomas Soome "[R%d] DNSServiceAddRecord(not a registered service ref)", request->request_id);
1614*472cd20dSToomas Soome return(mStatus_BadParamErr);
1615*472cd20dSToomas Soome }
16164b22b933Srs
16175ffb0c9bSToomas Soome // For a service registered with zero port, don't allow adding records. This mostly happens due to a bug
16185ffb0c9bSToomas Soome // in the application. See radar://9165807.
16195ffb0c9bSToomas Soome if (mDNSIPPortIsZero(request->u.servicereg.port))
1620*472cd20dSToomas Soome {
1621*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1622*472cd20dSToomas Soome "[R%d] DNSServiceAddRecord: adding record to a service registered with zero port", request->request_id);
1623*472cd20dSToomas Soome return(mStatus_BadParamErr);
1624*472cd20dSToomas Soome }
1625*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
1626*472cd20dSToomas Soome "[R%d] DNSServiceAddRecord(%X, " PRI_DM_NAME ", " PUB_S ", %d) PID[%d](" PUB_S ")",
1627*472cd20dSToomas Soome request->request_id, flags,
1628*472cd20dSToomas Soome DM_NAME_PARAM((request->u.servicereg.instances) ? (request->u.servicereg.instances->srs.RR_SRV.resrec.name) : mDNSNULL),
1629*472cd20dSToomas Soome DNSTypeName(rrtype), rdlen, request->process_id, request->pid_name);
16304b22b933Srs
16315ffb0c9bSToomas Soome for (i = request->u.servicereg.instances; i; i = i->next)
16325ffb0c9bSToomas Soome {
16335ffb0c9bSToomas Soome result = add_record_to_service(request, i, rrtype, rdlen, rdata, ttl);
16345ffb0c9bSToomas Soome if (result && i->default_local) break;
16355ffb0c9bSToomas Soome else result = mStatus_NoError; // suppress non-local default errors
16365ffb0c9bSToomas Soome }
16374b22b933Srs
16385ffb0c9bSToomas Soome return(result);
16395ffb0c9bSToomas Soome }
16404b22b933Srs
update_callback(mDNS * const m,AuthRecord * const rr,RData * oldrd,mDNSu16 oldrdlen)16415ffb0c9bSToomas Soome mDNSlocal void update_callback(mDNS *const m, AuthRecord *const rr, RData *oldrd, mDNSu16 oldrdlen)
16425ffb0c9bSToomas Soome {
16435ffb0c9bSToomas Soome mDNSBool external_advertise = (rr->UpdateContext) ? *((mDNSBool *)rr->UpdateContext) : mDNSfalse;
16445ffb0c9bSToomas Soome (void)m; // Unused
16454b22b933Srs
16465ffb0c9bSToomas Soome // There are three cases.
16475ffb0c9bSToomas Soome //
16485ffb0c9bSToomas Soome // 1. We have updated the primary TXT record of the service
16495ffb0c9bSToomas Soome // 2. We have updated the TXT record that was added to the service using DNSServiceAddRecord
16505ffb0c9bSToomas Soome // 3. We have updated the TXT record that was registered using DNSServiceRegisterRecord
16515ffb0c9bSToomas Soome //
16525ffb0c9bSToomas Soome // external_advertise is set if we have advertised at least once during the initial addition
16535ffb0c9bSToomas Soome // of the record in all of the three cases above. We should have checked for InterfaceID/LocalDomain
16545ffb0c9bSToomas Soome // checks during the first time and hence we don't do any checks here
16555ffb0c9bSToomas Soome if (external_advertise)
16565ffb0c9bSToomas Soome {
16575ffb0c9bSToomas Soome ResourceRecord ext = rr->resrec;
1658*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
1659c65ebfc7SToomas Soome DNSServiceFlags flags = deriveD2DFlagsFromAuthRecType(rr->ARType);
1660*472cd20dSToomas Soome #endif
16615ffb0c9bSToomas Soome
16625ffb0c9bSToomas Soome if (ext.rdlength == oldrdlen && mDNSPlatformMemSame(&ext.rdata->u, &oldrd->u, oldrdlen)) goto exit;
16635ffb0c9bSToomas Soome SetNewRData(&ext, oldrd, oldrdlen);
1664*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
1665*472cd20dSToomas Soome external_stop_advertising_service(&ext, flags, 0);
16665ffb0c9bSToomas Soome LogInfo("update_callback: calling external_start_advertising_service");
1667*472cd20dSToomas Soome external_start_advertising_service(&rr->resrec, flags, 0);
1668*472cd20dSToomas Soome #endif
16695ffb0c9bSToomas Soome }
16705ffb0c9bSToomas Soome exit:
16715ffb0c9bSToomas Soome if (oldrd != &rr->rdatastorage) freeL("RData/update_callback", oldrd);
16725ffb0c9bSToomas Soome }
16734b22b933Srs
update_record(AuthRecord * ar,mDNSu16 rdlen,const mDNSu8 * const rdata,mDNSu32 ttl,const mDNSBool * const external_advertise,const mDNSu32 request_id)1674*472cd20dSToomas Soome mDNSlocal mStatus update_record(AuthRecord *ar, mDNSu16 rdlen, const mDNSu8 *const rdata, mDNSu32 ttl,
1675*472cd20dSToomas Soome const mDNSBool *const external_advertise, const mDNSu32 request_id)
16765ffb0c9bSToomas Soome {
1677*472cd20dSToomas Soome ResourceRecord rr;
16785ffb0c9bSToomas Soome mStatus result;
1679*472cd20dSToomas Soome const size_t rdcapacity = (rdlen > sizeof(RDataBody2)) ? rdlen : sizeof(RDataBody2);
1680*472cd20dSToomas Soome RData *newrd = (RData *) callocL("RData/update_record", sizeof(*newrd) - sizeof(RDataBody) + rdcapacity);
1681*472cd20dSToomas Soome if (!newrd) FatalError("ERROR: calloc");
1682*472cd20dSToomas Soome mDNSPlatformMemZero(&rr, (mDNSu32)sizeof(rr));
1683*472cd20dSToomas Soome rr.name = ar->resrec.name;
1684*472cd20dSToomas Soome rr.rrtype = ar->resrec.rrtype;
1685*472cd20dSToomas Soome rr.rrclass = ar->resrec.rrclass;
1686*472cd20dSToomas Soome rr.rdata = newrd;
1687*472cd20dSToomas Soome rr.rdata->MaxRDLength = (mDNSu16)rdcapacity;
1688*472cd20dSToomas Soome rr.rdlength = rdlen;
1689*472cd20dSToomas Soome if (!SetRData(mDNSNULL, rdata, rdata + rdlen, &rr, rdlen))
1690*472cd20dSToomas Soome {
1691*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
1692*472cd20dSToomas Soome "[R%u] update_record: SetRData failed for " PRI_DM_NAME " (" PUB_S ")",
1693*472cd20dSToomas Soome request_id, DM_NAME_PARAM(rr.name), DNSTypeName(rr.rrtype));
1694*472cd20dSToomas Soome freeL("RData/update_record", newrd);
1695*472cd20dSToomas Soome return mStatus_BadParamErr;
1696*472cd20dSToomas Soome }
1697*472cd20dSToomas Soome rdlen = GetRDLength(&rr, mDNSfalse);
16985ffb0c9bSToomas Soome // BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct,
16995ffb0c9bSToomas Soome // since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s".
17005ffb0c9bSToomas Soome // Since some legacy apps try to create zero-length TXT records, we'll silently correct it here.
1701*472cd20dSToomas Soome if (ar->resrec.rrtype == kDNSType_TXT && rdlen == 0) { rdlen = 1; newrd->u.txt.c[0] = 0; }
17024b22b933Srs
1703*472cd20dSToomas Soome if (external_advertise) ar->UpdateContext = (void *)external_advertise;
17044b22b933Srs
1705*472cd20dSToomas Soome result = mDNS_Update(&mDNSStorage, ar, ttl, rdlen, newrd, update_callback);
1706*472cd20dSToomas Soome if (result) { LogMsg("update_record: Error %d for %s", (int)result, ARDisplayString(&mDNSStorage, ar)); freeL("RData/update_record", newrd); }
17075ffb0c9bSToomas Soome return result;
17085ffb0c9bSToomas Soome }
17094b22b933Srs
handle_update_request(request_state * request)17105ffb0c9bSToomas Soome mDNSlocal mStatus handle_update_request(request_state *request)
17115ffb0c9bSToomas Soome {
17125ffb0c9bSToomas Soome const ipc_msg_hdr *const hdr = &request->hdr;
17135ffb0c9bSToomas Soome mStatus result = mStatus_BadReferenceErr;
17145ffb0c9bSToomas Soome service_instance *i;
17155ffb0c9bSToomas Soome AuthRecord *rr = NULL;
17164b22b933Srs
17175ffb0c9bSToomas Soome // get the message data
17185ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend); // flags unused
17195ffb0c9bSToomas Soome mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
1720*472cd20dSToomas Soome const mDNSu8 *const rdata = (const mDNSu8 *)get_rdata(&request->msgptr, request->msgend, rdlen);
17215ffb0c9bSToomas Soome mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
17225ffb0c9bSToomas Soome (void)flags; // Unused
17234b22b933Srs
1724*472cd20dSToomas Soome if (!request->msgptr)
1725*472cd20dSToomas Soome {
1726*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1727*472cd20dSToomas Soome "[R%d] DNSServiceUpdateRecord(unreadable parameters)", request->request_id);
1728*472cd20dSToomas Soome return(mStatus_BadParamErr);
1729*472cd20dSToomas Soome }
17304b22b933Srs
17315ffb0c9bSToomas Soome // If this is a shared connection, check if the operation actually applies to a subordinate request_state object
17325ffb0c9bSToomas Soome if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
17334b22b933Srs
17345ffb0c9bSToomas Soome if (request->terminate == connection_termination)
17355ffb0c9bSToomas Soome {
17365ffb0c9bSToomas Soome // update an individually registered record
17375ffb0c9bSToomas Soome registered_record_entry *reptr;
17385ffb0c9bSToomas Soome for (reptr = request->u.reg_recs; reptr; reptr = reptr->next)
17395ffb0c9bSToomas Soome {
17405ffb0c9bSToomas Soome if (reptr->key == hdr->reg_index)
17415ffb0c9bSToomas Soome {
1742*472cd20dSToomas Soome result = update_record(reptr->rr, rdlen, rdata, ttl, &reptr->external_advertise, request->request_id);
1743*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1744*472cd20dSToomas Soome "[R%d] DNSServiceUpdateRecord(" PRI_DM_NAME ", " PUB_S ") PID[%d](" PUB_S ")",
1745*472cd20dSToomas Soome request->request_id, DM_NAME_PARAM(reptr->rr->resrec.name),
1746*472cd20dSToomas Soome reptr->rr ? DNSTypeName(reptr->rr->resrec.rrtype) : "<NONE>",
1747*472cd20dSToomas Soome request->process_id, request->pid_name);
17485ffb0c9bSToomas Soome goto end;
17495ffb0c9bSToomas Soome }
17505ffb0c9bSToomas Soome }
17515ffb0c9bSToomas Soome result = mStatus_BadReferenceErr;
17525ffb0c9bSToomas Soome goto end;
17535ffb0c9bSToomas Soome }
17544b22b933Srs
17555ffb0c9bSToomas Soome if (request->terminate != regservice_termination_callback)
1756*472cd20dSToomas Soome {
1757*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1758*472cd20dSToomas Soome "[R%d] DNSServiceUpdateRecord(not a registered service ref)", request->request_id);
1759*472cd20dSToomas Soome return(mStatus_BadParamErr);
1760*472cd20dSToomas Soome }
17614b22b933Srs
17625ffb0c9bSToomas Soome // For a service registered with zero port, only SRV record is initialized. Don't allow any updates.
17635ffb0c9bSToomas Soome if (mDNSIPPortIsZero(request->u.servicereg.port))
1764*472cd20dSToomas Soome {
1765*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1766*472cd20dSToomas Soome "[R%d] DNSServiceUpdateRecord: updating the record of a service registered with zero port", request->request_id);
1767*472cd20dSToomas Soome return(mStatus_BadParamErr);
1768*472cd20dSToomas Soome }
17694b22b933Srs
17705ffb0c9bSToomas Soome // update the saved off TXT data for the service
17715ffb0c9bSToomas Soome if (hdr->reg_index == TXT_RECORD_INDEX)
17725ffb0c9bSToomas Soome {
17735ffb0c9bSToomas Soome if (request->u.servicereg.txtdata)
17745ffb0c9bSToomas Soome { freeL("service_info txtdata", request->u.servicereg.txtdata); request->u.servicereg.txtdata = NULL; }
17755ffb0c9bSToomas Soome if (rdlen > 0)
17765ffb0c9bSToomas Soome {
17775ffb0c9bSToomas Soome request->u.servicereg.txtdata = mallocL("service_info txtdata", rdlen);
17785ffb0c9bSToomas Soome if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_update_request - malloc");
17795ffb0c9bSToomas Soome mDNSPlatformMemCopy(request->u.servicereg.txtdata, rdata, rdlen);
17805ffb0c9bSToomas Soome }
17815ffb0c9bSToomas Soome request->u.servicereg.txtlen = rdlen;
17825ffb0c9bSToomas Soome }
17834b22b933Srs
17845ffb0c9bSToomas Soome // update a record from a service record set
17855ffb0c9bSToomas Soome for (i = request->u.servicereg.instances; i; i = i->next)
17865ffb0c9bSToomas Soome {
17875ffb0c9bSToomas Soome if (hdr->reg_index == TXT_RECORD_INDEX) rr = &i->srs.RR_TXT;
17885ffb0c9bSToomas Soome else
17895ffb0c9bSToomas Soome {
17905ffb0c9bSToomas Soome ExtraResourceRecord *e;
17915ffb0c9bSToomas Soome for (e = i->srs.Extras; e; e = e->next)
17925ffb0c9bSToomas Soome if (e->ClientID == hdr->reg_index) { rr = &e->r; break; }
17935ffb0c9bSToomas Soome }
17944b22b933Srs
17955ffb0c9bSToomas Soome if (!rr) { result = mStatus_BadReferenceErr; goto end; }
1796*472cd20dSToomas Soome result = update_record(rr, rdlen, rdata, ttl, &i->external_advertise, request->request_id);
17975ffb0c9bSToomas Soome if (result && i->default_local) goto end;
17985ffb0c9bSToomas Soome else result = mStatus_NoError; // suppress non-local default errors
17995ffb0c9bSToomas Soome }
18004b22b933Srs
18015ffb0c9bSToomas Soome end:
18025ffb0c9bSToomas Soome if (request->terminate == regservice_termination_callback)
1803c65ebfc7SToomas Soome LogOperation("%3d: DNSServiceUpdateRecord(%##s, %s) PID[%d](%s)", request->sd,
18045ffb0c9bSToomas Soome (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
1805c65ebfc7SToomas Soome rr ? DNSTypeName(rr->resrec.rrtype) : "<NONE>",
1806c65ebfc7SToomas Soome request->process_id, request->pid_name);
18074b22b933Srs
18085ffb0c9bSToomas Soome return(result);
18095ffb0c9bSToomas Soome }
18104b22b933Srs
18115ffb0c9bSToomas Soome // remove a resource record registered via DNSServiceRegisterRecord()
remove_record(request_state * request)18125ffb0c9bSToomas Soome mDNSlocal mStatus remove_record(request_state *request)
18135ffb0c9bSToomas Soome {
18145ffb0c9bSToomas Soome mStatus err = mStatus_UnknownErr;
18155ffb0c9bSToomas Soome registered_record_entry *e, **ptr = &request->u.reg_recs;
18164b22b933Srs
18175ffb0c9bSToomas Soome while (*ptr && (*ptr)->key != request->hdr.reg_index) ptr = &(*ptr)->next;
18185ffb0c9bSToomas Soome if (!*ptr) { LogMsg("%3d: DNSServiceRemoveRecord(%u) not found", request->sd, request->hdr.reg_index); return mStatus_BadReferenceErr; }
18195ffb0c9bSToomas Soome e = *ptr;
18205ffb0c9bSToomas Soome *ptr = e->next; // unlink
18214b22b933Srs
1822c65ebfc7SToomas Soome LogOperation("%3d: DNSServiceRemoveRecord(%u %s) PID[%d](%s)",
1823c65ebfc7SToomas Soome request->sd, e->key, RRDisplayString(&mDNSStorage, &e->rr->resrec), request->process_id, request->pid_name);
18245ffb0c9bSToomas Soome e->rr->RecordContext = NULL;
18255ffb0c9bSToomas Soome if (e->external_advertise)
18265ffb0c9bSToomas Soome {
1827*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
1828*472cd20dSToomas Soome external_stop_advertising_service(&e->rr->resrec, request->flags, request->process_id);
1829*472cd20dSToomas Soome #endif
18305ffb0c9bSToomas Soome e->external_advertise = mDNSfalse;
18315ffb0c9bSToomas Soome }
1832c65ebfc7SToomas Soome LogMcastS(e->rr, request, reg_stop);
18335ffb0c9bSToomas Soome err = mDNS_Deregister(&mDNSStorage, e->rr); // Will free e->rr for us; we're responsible for freeing e
18345ffb0c9bSToomas Soome if (err)
18355ffb0c9bSToomas Soome {
18365ffb0c9bSToomas Soome LogMsg("ERROR: remove_record, mDNS_Deregister: %d", err);
18375ffb0c9bSToomas Soome freeL("registered_record_entry AuthRecord remove_record", e->rr);
18385ffb0c9bSToomas Soome }
18395ffb0c9bSToomas Soome freeL("registered_record_entry remove_record", e);
18405ffb0c9bSToomas Soome return err;
18415ffb0c9bSToomas Soome }
18424b22b933Srs
remove_extra(const request_state * const request,service_instance * const serv,mDNSu16 * const rrtype)18435ffb0c9bSToomas Soome mDNSlocal mStatus remove_extra(const request_state *const request, service_instance *const serv, mDNSu16 *const rrtype)
18445ffb0c9bSToomas Soome {
18455ffb0c9bSToomas Soome mStatus err = mStatus_BadReferenceErr;
18465ffb0c9bSToomas Soome ExtraResourceRecord *ptr;
18474b22b933Srs
18485ffb0c9bSToomas Soome for (ptr = serv->srs.Extras; ptr; ptr = ptr->next)
18495ffb0c9bSToomas Soome {
18505ffb0c9bSToomas Soome if (ptr->ClientID == request->hdr.reg_index) // found match
18515ffb0c9bSToomas Soome {
18525ffb0c9bSToomas Soome *rrtype = ptr->r.resrec.rrtype;
1853*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
1854*472cd20dSToomas Soome if (serv->external_advertise)
1855*472cd20dSToomas Soome {
1856*472cd20dSToomas Soome external_stop_advertising_service(&ptr->r.resrec, request->flags, request->process_id);
1857*472cd20dSToomas Soome }
1858*472cd20dSToomas Soome #endif
18595ffb0c9bSToomas Soome err = mDNS_RemoveRecordFromService(&mDNSStorage, &serv->srs, ptr, FreeExtraRR, ptr);
18605ffb0c9bSToomas Soome break;
18615ffb0c9bSToomas Soome }
18625ffb0c9bSToomas Soome }
18635ffb0c9bSToomas Soome return err;
18645ffb0c9bSToomas Soome }
18654b22b933Srs
handle_removerecord_request(request_state * request)18665ffb0c9bSToomas Soome mDNSlocal mStatus handle_removerecord_request(request_state *request)
18675ffb0c9bSToomas Soome {
18685ffb0c9bSToomas Soome mStatus err = mStatus_BadReferenceErr;
18695ffb0c9bSToomas Soome get_flags(&request->msgptr, request->msgend); // flags unused
18704b22b933Srs
1871*472cd20dSToomas Soome if (!request->msgptr)
1872*472cd20dSToomas Soome {
1873*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1874*472cd20dSToomas Soome "[R%d] DNSServiceRemoveRecord(unreadable parameters)", request->request_id);
1875*472cd20dSToomas Soome return(mStatus_BadParamErr);
1876*472cd20dSToomas Soome }
18774b22b933Srs
18785ffb0c9bSToomas Soome // If this is a shared connection, check if the operation actually applies to a subordinate request_state object
18795ffb0c9bSToomas Soome if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
18804b22b933Srs
18815ffb0c9bSToomas Soome if (request->terminate == connection_termination)
18825ffb0c9bSToomas Soome err = remove_record(request); // remove individually registered record
18835ffb0c9bSToomas Soome else if (request->terminate != regservice_termination_callback)
1884*472cd20dSToomas Soome {
1885*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
1886*472cd20dSToomas Soome "[R%d] DNSServiceRemoveRecord(not a registered service ref)", request->request_id);
1887*472cd20dSToomas Soome return(mStatus_BadParamErr);
1888*472cd20dSToomas Soome }
18895ffb0c9bSToomas Soome else
18905ffb0c9bSToomas Soome {
18915ffb0c9bSToomas Soome service_instance *i;
18925ffb0c9bSToomas Soome mDNSu16 rrtype = 0;
1893*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%d] DNSServiceRemoveRecord(" PRI_DM_NAME ", " PUB_S ") PID[%d](" PUB_S ")",
1894*472cd20dSToomas Soome request->request_id,
1895*472cd20dSToomas Soome DM_NAME_PARAM((request->u.servicereg.instances) ? (request->u.servicereg.instances->srs.RR_SRV.resrec.name) : mDNSNULL),
1896*472cd20dSToomas Soome rrtype ? DNSTypeName(rrtype) : "<NONE>", request->process_id, request->pid_name);
18975ffb0c9bSToomas Soome for (i = request->u.servicereg.instances; i; i = i->next)
18985ffb0c9bSToomas Soome {
18995ffb0c9bSToomas Soome err = remove_extra(request, i, &rrtype);
19005ffb0c9bSToomas Soome if (err && i->default_local) break;
19015ffb0c9bSToomas Soome else err = mStatus_NoError; // suppress non-local default errors
19025ffb0c9bSToomas Soome }
19035ffb0c9bSToomas Soome }
19044b22b933Srs
19055ffb0c9bSToomas Soome return(err);
19065ffb0c9bSToomas Soome }
19074b22b933Srs
19085ffb0c9bSToomas Soome // If there's a comma followed by another character,
19095ffb0c9bSToomas Soome // FindFirstSubType overwrites the comma with a nul and returns the pointer to the next character.
19105ffb0c9bSToomas Soome // Otherwise, it returns a pointer to the final nul at the end of the string
FindFirstSubType(char * p)1911*472cd20dSToomas Soome mDNSlocal char *FindFirstSubType(char *p)
19125ffb0c9bSToomas Soome {
19135ffb0c9bSToomas Soome while (*p)
19145ffb0c9bSToomas Soome {
19155ffb0c9bSToomas Soome if (p[0] == '\\' && p[1])
19165ffb0c9bSToomas Soome {
19175ffb0c9bSToomas Soome p += 2;
19185ffb0c9bSToomas Soome }
19195ffb0c9bSToomas Soome else if (p[0] == ',' && p[1])
19205ffb0c9bSToomas Soome {
19215ffb0c9bSToomas Soome *p++ = 0;
19225ffb0c9bSToomas Soome return(p);
19235ffb0c9bSToomas Soome }
19245ffb0c9bSToomas Soome else
19255ffb0c9bSToomas Soome {
19265ffb0c9bSToomas Soome p++;
19275ffb0c9bSToomas Soome }
19285ffb0c9bSToomas Soome }
19295ffb0c9bSToomas Soome return(p);
19305ffb0c9bSToomas Soome }
19314b22b933Srs
19325ffb0c9bSToomas Soome // If there's a comma followed by another character,
19335ffb0c9bSToomas Soome // FindNextSubType overwrites the comma with a nul and returns the pointer to the next character.
19345ffb0c9bSToomas Soome // If it finds an illegal unescaped dot in the subtype name, it returns mDNSNULL
19355ffb0c9bSToomas Soome // Otherwise, it returns a pointer to the final nul at the end of the string
FindNextSubType(char * p)19365ffb0c9bSToomas Soome mDNSlocal char *FindNextSubType(char *p)
19375ffb0c9bSToomas Soome {
19385ffb0c9bSToomas Soome while (*p)
19395ffb0c9bSToomas Soome {
19405ffb0c9bSToomas Soome if (p[0] == '\\' && p[1]) // If escape character
19415ffb0c9bSToomas Soome p += 2; // ignore following character
19425ffb0c9bSToomas Soome else if (p[0] == ',') // If we found a comma
19435ffb0c9bSToomas Soome {
19445ffb0c9bSToomas Soome if (p[1]) *p++ = 0;
19455ffb0c9bSToomas Soome return(p);
19465ffb0c9bSToomas Soome }
19475ffb0c9bSToomas Soome else if (p[0] == '.')
19485ffb0c9bSToomas Soome return(mDNSNULL);
19495ffb0c9bSToomas Soome else p++;
19505ffb0c9bSToomas Soome }
19515ffb0c9bSToomas Soome return(p);
19525ffb0c9bSToomas Soome }
19534b22b933Srs
19545ffb0c9bSToomas Soome // Returns -1 if illegal subtype found
ChopSubTypes(char * regtype)1955*472cd20dSToomas Soome mDNSlocal mDNSs32 ChopSubTypes(char *regtype)
19565ffb0c9bSToomas Soome {
19575ffb0c9bSToomas Soome mDNSs32 NumSubTypes = 0;
1958*472cd20dSToomas Soome char *stp = FindFirstSubType(regtype);
19595ffb0c9bSToomas Soome while (stp && *stp) // If we found a comma...
19605ffb0c9bSToomas Soome {
19615ffb0c9bSToomas Soome if (*stp == ',') return(-1);
19625ffb0c9bSToomas Soome NumSubTypes++;
19635ffb0c9bSToomas Soome stp = FindNextSubType(stp);
19645ffb0c9bSToomas Soome }
19655ffb0c9bSToomas Soome if (!stp) return(-1);
19665ffb0c9bSToomas Soome return(NumSubTypes);
19675ffb0c9bSToomas Soome }
19685ffb0c9bSToomas Soome
AllocateSubTypes(mDNSs32 NumSubTypes,char * p)1969*472cd20dSToomas Soome mDNSlocal AuthRecord *AllocateSubTypes(mDNSs32 NumSubTypes, char *p)
19705ffb0c9bSToomas Soome {
19715ffb0c9bSToomas Soome AuthRecord *st = mDNSNULL;
19725ffb0c9bSToomas Soome if (NumSubTypes)
19735ffb0c9bSToomas Soome {
19745ffb0c9bSToomas Soome mDNSs32 i;
1975*472cd20dSToomas Soome st = (AuthRecord *) callocL("ServiceSubTypes", NumSubTypes * sizeof(AuthRecord));
19765ffb0c9bSToomas Soome if (!st) return(mDNSNULL);
19775ffb0c9bSToomas Soome for (i = 0; i < NumSubTypes; i++)
19785ffb0c9bSToomas Soome {
19795ffb0c9bSToomas Soome mDNS_SetupResourceRecord(&st[i], mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, AuthRecordAny, mDNSNULL, mDNSNULL);
19805ffb0c9bSToomas Soome while (*p) p++;
19815ffb0c9bSToomas Soome p++;
19825ffb0c9bSToomas Soome if (!MakeDomainNameFromDNSNameString(&st[i].namestorage, p))
19835ffb0c9bSToomas Soome {
19845ffb0c9bSToomas Soome freeL("ServiceSubTypes", st);
19855ffb0c9bSToomas Soome return(mDNSNULL);
19865ffb0c9bSToomas Soome }
19875ffb0c9bSToomas Soome }
19885ffb0c9bSToomas Soome }
19895ffb0c9bSToomas Soome return(st);
19905ffb0c9bSToomas Soome }
19914b22b933Srs
register_service_instance(request_state * request,const domainname * domain)19925ffb0c9bSToomas Soome mDNSlocal mStatus register_service_instance(request_state *request, const domainname *domain)
19935ffb0c9bSToomas Soome {
19945ffb0c9bSToomas Soome service_instance **ptr, *instance;
1995c65ebfc7SToomas Soome size_t extra_size = (request->u.servicereg.txtlen > sizeof(RDataBody)) ? (request->u.servicereg.txtlen - sizeof(RDataBody)) : 0;
19965ffb0c9bSToomas Soome const mDNSBool DomainIsLocal = SameDomainName(domain, &localdomain);
19975ffb0c9bSToomas Soome mStatus result;
19985ffb0c9bSToomas Soome mDNSInterfaceID interfaceID = request->u.servicereg.InterfaceID;
19995ffb0c9bSToomas Soome
20005ffb0c9bSToomas Soome // If the client specified an interface, but no domain, then we honor the specified interface for the "local" (mDNS)
20015ffb0c9bSToomas Soome // registration but for the wide-area registrations we don't (currently) have any concept of a wide-area unicast
20025ffb0c9bSToomas Soome // registrations scoped to a specific interface, so for the automatic domains we add we must *not* specify an interface.
20035ffb0c9bSToomas Soome // (Specifying an interface with an apparently wide-area domain (i.e. something other than "local")
20045ffb0c9bSToomas Soome // currently forces the registration to use mDNS multicast despite the apparently wide-area domain.)
20055ffb0c9bSToomas Soome if (request->u.servicereg.default_domain && !DomainIsLocal) interfaceID = mDNSInterface_Any;
20065ffb0c9bSToomas Soome
20075ffb0c9bSToomas Soome for (ptr = &request->u.servicereg.instances; *ptr; ptr = &(*ptr)->next)
20085ffb0c9bSToomas Soome {
20095ffb0c9bSToomas Soome if (SameDomainName(&(*ptr)->domain, domain))
20105ffb0c9bSToomas Soome {
20115ffb0c9bSToomas Soome LogMsg("register_service_instance: domain %##s already registered for %#s.%##s",
20125ffb0c9bSToomas Soome domain->c, &request->u.servicereg.name, &request->u.servicereg.type);
20135ffb0c9bSToomas Soome return mStatus_AlreadyRegistered;
20145ffb0c9bSToomas Soome }
20155ffb0c9bSToomas Soome }
20164b22b933Srs
2017*472cd20dSToomas Soome instance = (service_instance *) callocL("service_instance", sizeof(*instance) + extra_size);
2018*472cd20dSToomas Soome if (!instance) { my_perror("ERROR: calloc"); return mStatus_NoMemoryErr; }
20194b22b933Srs
20205ffb0c9bSToomas Soome instance->next = mDNSNULL;
20215ffb0c9bSToomas Soome instance->request = request;
20225ffb0c9bSToomas Soome instance->renameonmemfree = 0;
20235ffb0c9bSToomas Soome instance->clientnotified = mDNSfalse;
20245ffb0c9bSToomas Soome instance->default_local = (request->u.servicereg.default_domain && DomainIsLocal);
20255ffb0c9bSToomas Soome instance->external_advertise = mDNSfalse;
20265ffb0c9bSToomas Soome AssignDomainName(&instance->domain, domain);
20274b22b933Srs
2028*472cd20dSToomas Soome instance->subtypes = AllocateSubTypes(request->u.servicereg.num_subtypes, request->u.servicereg.type_as_string);
20294b22b933Srs
20305ffb0c9bSToomas Soome if (request->u.servicereg.num_subtypes && !instance->subtypes)
2031c65ebfc7SToomas Soome {
2032c65ebfc7SToomas Soome unlink_and_free_service_instance(instance);
2033c65ebfc7SToomas Soome instance = NULL;
2034c65ebfc7SToomas Soome FatalError("ERROR: malloc");
20355ffb0c9bSToomas Soome }
20364b22b933Srs
20375ffb0c9bSToomas Soome result = mDNS_RegisterService(&mDNSStorage, &instance->srs,
20385ffb0c9bSToomas Soome &request->u.servicereg.name, &request->u.servicereg.type, domain,
20395ffb0c9bSToomas Soome request->u.servicereg.host.c[0] ? &request->u.servicereg.host : NULL,
20405ffb0c9bSToomas Soome request->u.servicereg.port,
20413b436d06SToomas Soome mDNSNULL, request->u.servicereg.txtdata, request->u.servicereg.txtlen,
20425ffb0c9bSToomas Soome instance->subtypes, request->u.servicereg.num_subtypes,
2043c65ebfc7SToomas Soome interfaceID, regservice_callback, instance, request->flags);
20444b22b933Srs
20455ffb0c9bSToomas Soome if (!result)
20465ffb0c9bSToomas Soome {
20475ffb0c9bSToomas Soome *ptr = instance; // Append this to the end of our request->u.servicereg.instances list
2048c65ebfc7SToomas Soome LogOperation("%3d: DNSServiceRegister(%##s, %u) ADDED", instance->request->sd,
20495ffb0c9bSToomas Soome instance->srs.RR_SRV.resrec.name->c, mDNSVal16(request->u.servicereg.port));
2050c65ebfc7SToomas Soome LogMcastS(&instance->srs.RR_SRV, request, reg_start);
20515ffb0c9bSToomas Soome }
20525ffb0c9bSToomas Soome else
20535ffb0c9bSToomas Soome {
20545ffb0c9bSToomas Soome LogMsg("register_service_instance %#s.%##s%##s error %d",
20555ffb0c9bSToomas Soome &request->u.servicereg.name, &request->u.servicereg.type, domain->c, result);
20565ffb0c9bSToomas Soome unlink_and_free_service_instance(instance);
20575ffb0c9bSToomas Soome }
20584b22b933Srs
20595ffb0c9bSToomas Soome return result;
20605ffb0c9bSToomas Soome }
20614b22b933Srs
udsserver_default_reg_domain_changed(const DNameListElem * const d,const mDNSBool add)20625ffb0c9bSToomas Soome mDNSlocal void udsserver_default_reg_domain_changed(const DNameListElem *const d, const mDNSBool add)
20635ffb0c9bSToomas Soome {
20645ffb0c9bSToomas Soome request_state *request;
20654b22b933Srs
20665ffb0c9bSToomas Soome LogMsg("%s registration domain %##s", add ? "Adding" : "Removing", d->name.c);
20675ffb0c9bSToomas Soome for (request = all_requests; request; request = request->next)
20685ffb0c9bSToomas Soome {
20695ffb0c9bSToomas Soome if (request->terminate != regservice_termination_callback) continue;
20705ffb0c9bSToomas Soome if (!request->u.servicereg.default_domain) continue;
20715ffb0c9bSToomas Soome if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
20725ffb0c9bSToomas Soome {
20735ffb0c9bSToomas Soome service_instance **ptr = &request->u.servicereg.instances;
20745ffb0c9bSToomas Soome while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
20755ffb0c9bSToomas Soome if (add)
20765ffb0c9bSToomas Soome {
20775ffb0c9bSToomas Soome // If we don't already have this domain in our list for this registration, add it now
20785ffb0c9bSToomas Soome if (!*ptr) register_service_instance(request, &d->name);
20795ffb0c9bSToomas Soome else debugf("udsserver_default_reg_domain_changed %##s already in list, not re-adding", &d->name);
20805ffb0c9bSToomas Soome }
20815ffb0c9bSToomas Soome else
20825ffb0c9bSToomas Soome {
20835ffb0c9bSToomas Soome // Normally we should not fail to find the specified instance
20845ffb0c9bSToomas Soome // One case where this can happen is if a uDNS update fails for some reason,
20855ffb0c9bSToomas Soome // and regservice_callback then calls unlink_and_free_service_instance and disposes of that instance.
20865ffb0c9bSToomas Soome if (!*ptr)
20875ffb0c9bSToomas Soome LogMsg("udsserver_default_reg_domain_changed domain %##s not found for service %#s type %s",
20885ffb0c9bSToomas Soome &d->name, request->u.servicereg.name.c, request->u.servicereg.type_as_string);
20895ffb0c9bSToomas Soome else
20905ffb0c9bSToomas Soome {
20915ffb0c9bSToomas Soome DNameListElem *p;
20925ffb0c9bSToomas Soome for (p = AutoRegistrationDomains; p; p=p->next)
20935ffb0c9bSToomas Soome if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
20945ffb0c9bSToomas Soome if (SameDomainName(&d->name, &p->name)) break;
20955ffb0c9bSToomas Soome if (p) debugf("udsserver_default_reg_domain_changed %##s still in list, not removing", &d->name);
20965ffb0c9bSToomas Soome else
20975ffb0c9bSToomas Soome {
20985ffb0c9bSToomas Soome mStatus err;
20995ffb0c9bSToomas Soome service_instance *si = *ptr;
21005ffb0c9bSToomas Soome *ptr = si->next;
21015ffb0c9bSToomas Soome if (si->clientnotified) SendServiceRemovalNotification(&si->srs); // Do this *before* clearing si->request backpointer
21025ffb0c9bSToomas Soome // Now that we've cut this service_instance from the list, we MUST clear the si->request backpointer.
21035ffb0c9bSToomas Soome // Otherwise what can happen is this: While our mDNS_DeregisterService is in the
21045ffb0c9bSToomas Soome // process of completing asynchronously, the client cancels the entire operation, so
21055ffb0c9bSToomas Soome // regservice_termination_callback then runs through the whole list deregistering each
21065ffb0c9bSToomas Soome // instance, clearing the backpointers, and then disposing the parent request_state object.
21075ffb0c9bSToomas Soome // However, because this service_instance isn't in the list any more, regservice_termination_callback
21085ffb0c9bSToomas Soome // has no way to find it and clear its backpointer, and then when our mDNS_DeregisterService finally
21095ffb0c9bSToomas Soome // completes later with a mStatus_MemFree message, it calls unlink_and_free_service_instance() with
21105ffb0c9bSToomas Soome // a service_instance with a stale si->request backpointer pointing to memory that's already been freed.
21115ffb0c9bSToomas Soome si->request = NULL;
21125ffb0c9bSToomas Soome err = mDNS_DeregisterService(&mDNSStorage, &si->srs);
21135ffb0c9bSToomas Soome if (err) { LogMsg("udsserver_default_reg_domain_changed err %d", err); unlink_and_free_service_instance(si); }
21145ffb0c9bSToomas Soome }
21155ffb0c9bSToomas Soome }
21165ffb0c9bSToomas Soome }
21175ffb0c9bSToomas Soome }
21185ffb0c9bSToomas Soome }
21195ffb0c9bSToomas Soome }
21204b22b933Srs
2121*472cd20dSToomas Soome // Returns true if the interfaceIndex value matches one of the pre-defined
2122*472cd20dSToomas Soome // special values listed in the switch statement below.
PreDefinedInterfaceIndex(mDNSu32 interfaceIndex)2123*472cd20dSToomas Soome mDNSlocal mDNSBool PreDefinedInterfaceIndex(mDNSu32 interfaceIndex)
21245ffb0c9bSToomas Soome {
2125*472cd20dSToomas Soome switch(interfaceIndex)
21265ffb0c9bSToomas Soome {
2127*472cd20dSToomas Soome case kDNSServiceInterfaceIndexAny:
2128*472cd20dSToomas Soome case kDNSServiceInterfaceIndexLocalOnly:
2129*472cd20dSToomas Soome case kDNSServiceInterfaceIndexUnicast:
2130*472cd20dSToomas Soome case kDNSServiceInterfaceIndexP2P:
2131*472cd20dSToomas Soome case kDNSServiceInterfaceIndexBLE:
2132*472cd20dSToomas Soome return mDNStrue;
2133*472cd20dSToomas Soome default:
2134*472cd20dSToomas Soome return mDNSfalse;
21355ffb0c9bSToomas Soome }
2136*472cd20dSToomas Soome }
21374b22b933Srs
_handle_regservice_request_start(request_state * request,const domainname * const d)2138*472cd20dSToomas Soome mDNSlocal mStatus _handle_regservice_request_start(request_state *request, const domainname * const d)
2139*472cd20dSToomas Soome {
2140*472cd20dSToomas Soome mStatus err;
2141*472cd20dSToomas Soome
2142*472cd20dSToomas Soome request->terminate = regservice_termination_callback;
2143*472cd20dSToomas Soome err = register_service_instance(request, d);
2144*472cd20dSToomas Soome
2145*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, METRICS)
2146*472cd20dSToomas Soome ++curr_num_regservices;
2147*472cd20dSToomas Soome if (curr_num_regservices > max_num_regservices)
2148*472cd20dSToomas Soome max_num_regservices = curr_num_regservices;
2149*472cd20dSToomas Soome #endif
2150*472cd20dSToomas Soome
2151*472cd20dSToomas Soome #if 0
2152*472cd20dSToomas Soome err = AuthorizedDomain(request, d, AutoRegistrationDomains) ? register_service_instance(request, d) : mStatus_NoError;
2153*472cd20dSToomas Soome #endif
2154*472cd20dSToomas Soome if (!err)
21555ffb0c9bSToomas Soome {
2156*472cd20dSToomas Soome if (request->u.servicereg.autoname) UpdateDeviceInfoRecord(&mDNSStorage);
21574b22b933Srs
2158*472cd20dSToomas Soome if (request->u.servicereg.default_domain)
21595ffb0c9bSToomas Soome {
2160*472cd20dSToomas Soome DNameListElem *ptr;
2161*472cd20dSToomas Soome // Note that we don't report errors for non-local, non-explicit domains
2162*472cd20dSToomas Soome for (ptr = AutoRegistrationDomains; ptr; ptr = ptr->next)
2163*472cd20dSToomas Soome if (!ptr->uid || SystemUID(request->uid) || request->uid == ptr->uid)
2164*472cd20dSToomas Soome register_service_instance(request, &ptr->name);
2165*472cd20dSToomas Soome }
2166*472cd20dSToomas Soome }
2167*472cd20dSToomas Soome return err;
2168*472cd20dSToomas Soome }
2169*472cd20dSToomas Soome
2170*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
2171*472cd20dSToomas Soome
_return_regservice_request_error(request_state * request,mStatus error)2172*472cd20dSToomas Soome mDNSlocal void _return_regservice_request_error(request_state *request, mStatus error)
2173*472cd20dSToomas Soome {
2174*472cd20dSToomas Soome if (request->u.servicereg.txtdata)
2175*472cd20dSToomas Soome {
2176*472cd20dSToomas Soome freeL("service_info txtdata", request->u.servicereg.txtdata);
2177*472cd20dSToomas Soome request->u.servicereg.txtdata = NULL;
2178*472cd20dSToomas Soome }
2179*472cd20dSToomas Soome
2180*472cd20dSToomas Soome reply_state *rep;
2181*472cd20dSToomas Soome if (GenerateNTDResponse(NULL, 0, request, &rep, reg_service_reply_op, 0, error) != mStatus_NoError)
2182*472cd20dSToomas Soome {
2183*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] DNSServiceRegister _return_regservice_request_error: error(%d)", request->request_id, error);
2184*472cd20dSToomas Soome }
2185*472cd20dSToomas Soome else
2186*472cd20dSToomas Soome {
2187*472cd20dSToomas Soome append_reply(request, rep);
2188*472cd20dSToomas Soome }
2189*472cd20dSToomas Soome }
21904b22b933Srs
_handle_regservice_request_with_trust(request_state * request,const domainname * const d)2191*472cd20dSToomas Soome mDNSlocal mStatus _handle_regservice_request_with_trust(request_state *request, const domainname * const d)
2192*472cd20dSToomas Soome {
2193*472cd20dSToomas Soome mStatus err;
2194*472cd20dSToomas Soome if (audit_token_to_pid(request->audit_token) == 0)
2195*472cd20dSToomas Soome {
2196*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_regservice_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
2197*472cd20dSToomas Soome err = _handle_regservice_request_start(request, d);
2198*472cd20dSToomas Soome }
2199*472cd20dSToomas Soome else
2200*472cd20dSToomas Soome {
2201*472cd20dSToomas Soome mdns_trust_flags_t flags = mdns_trust_flags_none;
2202*472cd20dSToomas Soome mdns_trust_status_t status = mdns_trust_check_register_service(request->audit_token, request->u.servicereg.type_as_string, &flags);
2203*472cd20dSToomas Soome switch (status) {
2204*472cd20dSToomas Soome case mdns_trust_status_denied:
2205*472cd20dSToomas Soome case mdns_trust_status_pending:
22065ffb0c9bSToomas Soome {
2207*472cd20dSToomas Soome mdns_trust_t trust = mdns_trust_create(request->audit_token, request->u.servicereg.type_as_string, flags);
2208*472cd20dSToomas Soome if (!trust)
22095ffb0c9bSToomas Soome {
2210*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
2211*472cd20dSToomas Soome goto exit;
22125ffb0c9bSToomas Soome }
2213*472cd20dSToomas Soome void * context = mallocL("context/_handle_regservice_request_with_trust", sizeof(domainname));
2214*472cd20dSToomas Soome if (!context)
22155ffb0c9bSToomas Soome {
2216*472cd20dSToomas Soome my_perror("ERROR: mallocL context/_handle_regservice_request_with_trust");
2217*472cd20dSToomas Soome mdns_release(trust);
2218*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
2219*472cd20dSToomas Soome goto exit;
22205ffb0c9bSToomas Soome }
2221*472cd20dSToomas Soome memcpy(context, d, sizeof(domainname));
2222*472cd20dSToomas Soome mdns_trust_set_context(trust, context);
2223*472cd20dSToomas Soome
2224*472cd20dSToomas Soome mdns_trust_set_queue(trust, _get_trust_results_dispatch_queue());
2225*472cd20dSToomas Soome mdns_trust_set_event_handler(trust, ^(mdns_trust_event_t event, mdns_trust_status_t update)
2226*472cd20dSToomas Soome {
2227*472cd20dSToomas Soome if (event == mdns_trust_event_result)
2228*472cd20dSToomas Soome {
2229*472cd20dSToomas Soome mStatus error = (update != mdns_trust_status_granted) ? mStatus_PolicyDenied : mStatus_NoError;
2230*472cd20dSToomas Soome KQueueLock();
2231*472cd20dSToomas Soome const domainname * _d = mdns_trust_get_context(trust);
2232*472cd20dSToomas Soome if (_d)
2233*472cd20dSToomas Soome {
2234*472cd20dSToomas Soome if (!error)
2235*472cd20dSToomas Soome {
2236*472cd20dSToomas Soome error = _handle_regservice_request_start(request, _d);
2237*472cd20dSToomas Soome // No context means the request was canceled before we got here
2238*472cd20dSToomas Soome }
2239*472cd20dSToomas Soome if (error) // (not else if) Always check for error result
2240*472cd20dSToomas Soome {
2241*472cd20dSToomas Soome _return_regservice_request_error(request, error);
2242*472cd20dSToomas Soome }
2243*472cd20dSToomas Soome }
2244*472cd20dSToomas Soome KQueueUnlock("_register_service_instance_with_trust");
2245*472cd20dSToomas Soome }
2246*472cd20dSToomas Soome });
2247*472cd20dSToomas Soome request->trust = trust;
2248*472cd20dSToomas Soome mdns_trust_activate(trust);
2249*472cd20dSToomas Soome err = mStatus_NoError;
2250*472cd20dSToomas Soome break;
22515ffb0c9bSToomas Soome }
22525ffb0c9bSToomas Soome
2253*472cd20dSToomas Soome case mdns_trust_status_no_entitlement:
2254*472cd20dSToomas Soome err = mStatus_NoAuth;
2255*472cd20dSToomas Soome break;
2256*472cd20dSToomas Soome
2257*472cd20dSToomas Soome case mdns_trust_status_granted:
2258*472cd20dSToomas Soome err = _handle_regservice_request_start(request, d);
2259*472cd20dSToomas Soome break;
2260*472cd20dSToomas Soome
2261*472cd20dSToomas Soome default:
2262*472cd20dSToomas Soome err = mStatus_UnknownErr;
2263*472cd20dSToomas Soome break;
2264*472cd20dSToomas Soome }
22655ffb0c9bSToomas Soome }
2266*472cd20dSToomas Soome exit:
2267*472cd20dSToomas Soome return err;
22685ffb0c9bSToomas Soome }
2269*472cd20dSToomas Soome #endif // TRUST_ENFORCEMENT
22704b22b933Srs
handle_regservice_request(request_state * request)22715ffb0c9bSToomas Soome mDNSlocal mStatus handle_regservice_request(request_state *request)
22725ffb0c9bSToomas Soome {
22735ffb0c9bSToomas Soome char name[256]; // Lots of spare space for extra-long names that we'll auto-truncate down to 63 bytes
22745ffb0c9bSToomas Soome char domain[MAX_ESCAPED_DOMAIN_NAME], host[MAX_ESCAPED_DOMAIN_NAME];
2275*472cd20dSToomas Soome char type_as_string[MAX_ESCAPED_DOMAIN_NAME]; // Note that this service type may include a trailing list of subtypes
22765ffb0c9bSToomas Soome domainname d, srv;
22775ffb0c9bSToomas Soome mStatus err;
2278cda73f64SToomas Soome const char *msgTXTData;
22794b22b933Srs
22805ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
22815ffb0c9bSToomas Soome mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
22825ffb0c9bSToomas Soome mDNSInterfaceID InterfaceID;
22834b22b933Srs
2284c65ebfc7SToomas Soome // Map kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny with the
22855ffb0c9bSToomas Soome // kDNSServiceFlagsIncludeP2P flag set.
22865ffb0c9bSToomas Soome if (interfaceIndex == kDNSServiceInterfaceIndexP2P)
22875ffb0c9bSToomas Soome {
22885ffb0c9bSToomas Soome LogOperation("handle_regservice_request: mapping kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny + kDNSServiceFlagsIncludeP2P");
22895ffb0c9bSToomas Soome flags |= kDNSServiceFlagsIncludeP2P;
22905ffb0c9bSToomas Soome interfaceIndex = kDNSServiceInterfaceIndexAny;
22915ffb0c9bSToomas Soome }
22924b22b933Srs
22935ffb0c9bSToomas Soome InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
22944b22b933Srs
2295c65ebfc7SToomas Soome // The registration is scoped to a specific interface index, but the
22965ffb0c9bSToomas Soome // interface is not currently in our list.
22975ffb0c9bSToomas Soome if (interfaceIndex && !InterfaceID)
22985ffb0c9bSToomas Soome {
22995ffb0c9bSToomas Soome // If it's one of the specially defined inteface index values, just return an error.
23005ffb0c9bSToomas Soome if (PreDefinedInterfaceIndex(interfaceIndex))
23015ffb0c9bSToomas Soome {
2302cda73f64SToomas Soome LogInfo("handle_regservice_request: bad interfaceIndex %d", interfaceIndex);
23035ffb0c9bSToomas Soome return(mStatus_BadParamErr);
23045ffb0c9bSToomas Soome }
23054b22b933Srs
23065ffb0c9bSToomas Soome // Otherwise, use the specified interface index value and the registration will
23075ffb0c9bSToomas Soome // be applied to that interface when it comes up.
23085ffb0c9bSToomas Soome InterfaceID = (mDNSInterfaceID)(uintptr_t)interfaceIndex;
23095ffb0c9bSToomas Soome LogInfo("handle_regservice_request: registration pending for interface index %d", interfaceIndex);
23105ffb0c9bSToomas Soome }
23114b22b933Srs
2312*472cd20dSToomas Soome if (get_string(&request->msgptr, request->msgend, name, sizeof(name )) < 0 ||
2313*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, type_as_string, sizeof(type_as_string)) < 0 ||
2314*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, domain, sizeof(domain )) < 0 ||
2315*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, host, sizeof(host )) < 0)
23165ffb0c9bSToomas Soome { LogMsg("ERROR: handle_regservice_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
23174b22b933Srs
23185ffb0c9bSToomas Soome request->flags = flags;
2319cda73f64SToomas Soome request->interfaceIndex = interfaceIndex;
23205ffb0c9bSToomas Soome request->u.servicereg.InterfaceID = InterfaceID;
23215ffb0c9bSToomas Soome request->u.servicereg.instances = NULL;
23225ffb0c9bSToomas Soome request->u.servicereg.txtlen = 0;
23235ffb0c9bSToomas Soome request->u.servicereg.txtdata = NULL;
2324c65ebfc7SToomas Soome mDNSPlatformStrLCopy(request->u.servicereg.type_as_string, type_as_string, sizeof(request->u.servicereg.type_as_string));
23254b22b933Srs
23265ffb0c9bSToomas Soome if (request->msgptr + 2 > request->msgend) request->msgptr = NULL;
23275ffb0c9bSToomas Soome else
23285ffb0c9bSToomas Soome {
23295ffb0c9bSToomas Soome request->u.servicereg.port.b[0] = *request->msgptr++;
23305ffb0c9bSToomas Soome request->u.servicereg.port.b[1] = *request->msgptr++;
23315ffb0c9bSToomas Soome }
23324b22b933Srs
23335ffb0c9bSToomas Soome request->u.servicereg.txtlen = get_uint16(&request->msgptr, request->msgend);
2334cda73f64SToomas Soome msgTXTData = get_rdata(&request->msgptr, request->msgend, request->u.servicereg.txtlen);
2335cda73f64SToomas Soome
2336cda73f64SToomas Soome if (!request->msgptr) { LogMsg("%3d: DNSServiceRegister(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
2337cda73f64SToomas Soome
23385ffb0c9bSToomas Soome if (request->u.servicereg.txtlen)
23395ffb0c9bSToomas Soome {
23405ffb0c9bSToomas Soome request->u.servicereg.txtdata = mallocL("service_info txtdata", request->u.servicereg.txtlen);
23415ffb0c9bSToomas Soome if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_regservice_request - malloc");
2342cda73f64SToomas Soome mDNSPlatformMemCopy(request->u.servicereg.txtdata, msgTXTData, request->u.servicereg.txtlen);
23435ffb0c9bSToomas Soome }
23444b22b933Srs
23455ffb0c9bSToomas Soome // Check for sub-types after the service type
2346*472cd20dSToomas Soome request->u.servicereg.num_subtypes = ChopSubTypes(request->u.servicereg.type_as_string); // Note: Modifies regtype string to remove trailing subtypes
23475ffb0c9bSToomas Soome if (request->u.servicereg.num_subtypes < 0)
23485ffb0c9bSToomas Soome {
23495ffb0c9bSToomas Soome LogMsg("ERROR: handle_regservice_request - ChopSubTypes failed %s", request->u.servicereg.type_as_string);
2350cda73f64SToomas Soome goto bad_param;
23515ffb0c9bSToomas Soome }
23524b22b933Srs
23535ffb0c9bSToomas Soome // Don't try to construct "domainname t" until *after* ChopSubTypes has worked its magic
23545ffb0c9bSToomas Soome if (!*request->u.servicereg.type_as_string || !MakeDomainNameFromDNSNameString(&request->u.servicereg.type, request->u.servicereg.type_as_string))
2355cda73f64SToomas Soome { LogMsg("ERROR: handle_regservice_request - type_as_string bad %s", request->u.servicereg.type_as_string); goto bad_param; }
23564b22b933Srs
23575ffb0c9bSToomas Soome if (!name[0])
23585ffb0c9bSToomas Soome {
23595ffb0c9bSToomas Soome request->u.servicereg.name = mDNSStorage.nicelabel;
23605ffb0c9bSToomas Soome request->u.servicereg.autoname = mDNStrue;
23615ffb0c9bSToomas Soome }
23625ffb0c9bSToomas Soome else
23635ffb0c9bSToomas Soome {
23645ffb0c9bSToomas Soome // If the client is allowing AutoRename, then truncate name to legal length before converting it to a DomainLabel
23655ffb0c9bSToomas Soome if ((flags & kDNSServiceFlagsNoAutoRename) == 0)
23665ffb0c9bSToomas Soome {
23675ffb0c9bSToomas Soome int newlen = TruncateUTF8ToLength((mDNSu8*)name, mDNSPlatformStrLen(name), MAX_DOMAIN_LABEL);
23685ffb0c9bSToomas Soome name[newlen] = 0;
23695ffb0c9bSToomas Soome }
23705ffb0c9bSToomas Soome if (!MakeDomainLabelFromLiteralString(&request->u.servicereg.name, name))
2371cda73f64SToomas Soome { LogMsg("ERROR: handle_regservice_request - name bad %s", name); goto bad_param; }
23725ffb0c9bSToomas Soome request->u.servicereg.autoname = mDNSfalse;
23735ffb0c9bSToomas Soome }
23744b22b933Srs
23755ffb0c9bSToomas Soome if (*domain)
23764b22b933Srs {
23775ffb0c9bSToomas Soome request->u.servicereg.default_domain = mDNSfalse;
23785ffb0c9bSToomas Soome if (!MakeDomainNameFromDNSNameString(&d, domain))
2379cda73f64SToomas Soome { LogMsg("ERROR: handle_regservice_request - domain bad %s", domain); goto bad_param; }
23805ffb0c9bSToomas Soome }
23815ffb0c9bSToomas Soome else
23825ffb0c9bSToomas Soome {
23835ffb0c9bSToomas Soome request->u.servicereg.default_domain = mDNStrue;
23845ffb0c9bSToomas Soome MakeDomainNameFromDNSNameString(&d, "local.");
23855ffb0c9bSToomas Soome }
23864b22b933Srs
23875ffb0c9bSToomas Soome if (!ConstructServiceName(&srv, &request->u.servicereg.name, &request->u.servicereg.type, &d))
23884b22b933Srs {
23895ffb0c9bSToomas Soome LogMsg("ERROR: handle_regservice_request - Couldn't ConstructServiceName from, “%#s” “%##s” “%##s”",
2390cda73f64SToomas Soome request->u.servicereg.name.c, request->u.servicereg.type.c, d.c); goto bad_param;
23915ffb0c9bSToomas Soome }
23924b22b933Srs
23935ffb0c9bSToomas Soome if (!MakeDomainNameFromDNSNameString(&request->u.servicereg.host, host))
2394cda73f64SToomas Soome { LogMsg("ERROR: handle_regservice_request - host bad %s", host); goto bad_param; }
23955ffb0c9bSToomas Soome request->u.servicereg.autorename = (flags & kDNSServiceFlagsNoAutoRename ) == 0;
23965ffb0c9bSToomas Soome request->u.servicereg.allowremotequery = (flags & kDNSServiceFlagsAllowRemoteQuery) != 0;
23975ffb0c9bSToomas Soome
23985ffb0c9bSToomas Soome // Some clients use mDNS for lightweight copy protection, registering a pseudo-service with
23995ffb0c9bSToomas Soome // a port number of zero. When two instances of the protected client are allowed to run on one
24005ffb0c9bSToomas Soome // machine, we don't want to see misleading "Bogus client" messages in syslog and the console.
24015ffb0c9bSToomas Soome if (!mDNSIPPortIsZero(request->u.servicereg.port))
24024b22b933Srs {
24035ffb0c9bSToomas Soome int count = CountExistingRegistrations(&srv, request->u.servicereg.port);
24045ffb0c9bSToomas Soome if (count)
24055ffb0c9bSToomas Soome LogMsg("Client application[%d](%s) registered %d identical instances of service %##s port %u.", request->process_id,
24065ffb0c9bSToomas Soome request->pid_name, count+1, srv.c, mDNSVal16(request->u.servicereg.port));
24075ffb0c9bSToomas Soome }
24084b22b933Srs
2409c65ebfc7SToomas Soome #if APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
2410c65ebfc7SToomas Soome // Determine if this request should be promoted to use BLE triggered feature.
2411c65ebfc7SToomas Soome if (shouldUseBLE(InterfaceID, 0, &request->u.servicereg.type, &d))
2412c65ebfc7SToomas Soome {
2413c65ebfc7SToomas Soome request->flags |= (kDNSServiceFlagsAutoTrigger | kDNSServiceFlagsIncludeAWDL);
2414c65ebfc7SToomas Soome LogInfo("handle_regservice_request: registration promoted to use kDNSServiceFlagsAutoTrigger");
2415c65ebfc7SToomas Soome }
2416c65ebfc7SToomas Soome #endif // APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
2417c65ebfc7SToomas Soome
2418*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
2419*472cd20dSToomas Soome "[R%d] DNSServiceRegister(%X, %d, \"" PRI_S "\", \"" PRI_S "\", \"" PRI_S "\", \"" PRI_S "\", %u) START PID[%d](" PUB_S ")",
2420*472cd20dSToomas Soome request->request_id, request->flags, interfaceIndex, name, request->u.servicereg.type_as_string, domain, host,
2421*472cd20dSToomas Soome mDNSVal16(request->u.servicereg.port), request->process_id, request->pid_name);
24224b22b933Srs
24235ffb0c9bSToomas Soome // We need to unconditionally set request->terminate, because even if we didn't successfully
24245ffb0c9bSToomas Soome // start any registrations right now, subsequent configuration changes may cause successful
24255ffb0c9bSToomas Soome // registrations to be added, and we'll need to cancel them before freeing this memory.
24265ffb0c9bSToomas Soome // We also need to set request->terminate first, before adding additional service instances,
2427*472cd20dSToomas Soome // because the udsserver_validatelists uses the request->terminate function pointer to determine
24285ffb0c9bSToomas Soome // what kind of request this is, and therefore what kind of list validation is required.
2429*472cd20dSToomas Soome request->terminate = NULL;
2430c65ebfc7SToomas Soome
2431*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
2432*472cd20dSToomas Soome if (os_feature_enabled(mDNSResponder, bonjour_privacy) &&
2433*472cd20dSToomas Soome (request->u.servicereg.default_domain || IsLocalDomain(&d)))
24344b22b933Srs {
2435*472cd20dSToomas Soome err = _handle_regservice_request_with_trust(request, &d);
2436*472cd20dSToomas Soome if (err == mStatus_NoAuth && request->u.servicereg.txtdata)
24375ffb0c9bSToomas Soome {
2438*472cd20dSToomas Soome freeL("service_info txtdata", request->u.servicereg.txtdata);
2439*472cd20dSToomas Soome request->u.servicereg.txtdata = NULL;
24405ffb0c9bSToomas Soome }
24415ffb0c9bSToomas Soome }
2442*472cd20dSToomas Soome else
2443*472cd20dSToomas Soome {
2444*472cd20dSToomas Soome err = _handle_regservice_request_start(request, &d);
2445*472cd20dSToomas Soome }
2446*472cd20dSToomas Soome #else
2447*472cd20dSToomas Soome err = _handle_regservice_request_start(request, &d);
2448*472cd20dSToomas Soome #endif
24494b22b933Srs
24505ffb0c9bSToomas Soome return(err);
2451cda73f64SToomas Soome
2452cda73f64SToomas Soome bad_param:
2453cda73f64SToomas Soome freeL("handle_regservice_request (txtdata)", request->u.servicereg.txtdata);
2454cda73f64SToomas Soome request->u.servicereg.txtdata = NULL;
2455cda73f64SToomas Soome return mStatus_BadParamErr;
24565ffb0c9bSToomas Soome }
24574b22b933Srs
24585ffb0c9bSToomas Soome // ***************************************************************************
24595ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
24605ffb0c9bSToomas Soome #pragma mark -
24615ffb0c9bSToomas Soome #pragma mark - DNSServiceBrowse
24625ffb0c9bSToomas Soome #endif
24634b22b933Srs
FoundInstance(mDNS * const m,DNSQuestion * question,const ResourceRecord * const answer,QC_result AddRecord)24645ffb0c9bSToomas Soome mDNSlocal void FoundInstance(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
24655ffb0c9bSToomas Soome {
24665ffb0c9bSToomas Soome DNSServiceFlags flags = AddRecord ? kDNSServiceFlagsAdd : 0;
24675ffb0c9bSToomas Soome request_state *req = question->QuestionContext;
24685ffb0c9bSToomas Soome reply_state *rep;
24695ffb0c9bSToomas Soome (void)m; // Unused
24704b22b933Srs
24715ffb0c9bSToomas Soome if (answer->rrtype != kDNSType_PTR)
24725ffb0c9bSToomas Soome { LogMsg("%3d: FoundInstance: Should not be called with rrtype %d (not a PTR record)", req->sd, answer->rrtype); return; }
24734b22b933Srs
24745ffb0c9bSToomas Soome if (mDNSOpaque16IsZero(question->TargetQID) && (question->BrowseThreshold > 0) && (question->CurrentAnswers >= question->BrowseThreshold))
24754b22b933Srs {
24765ffb0c9bSToomas Soome flags |= kDNSServiceFlagsThresholdReached;
24775ffb0c9bSToomas Soome }
24784b22b933Srs
2479c65ebfc7SToomas Soome // if returning a negative answer, then use question's name in reply
2480c65ebfc7SToomas Soome if (answer->RecordType == kDNSRecordTypePacketNegative)
2481c65ebfc7SToomas Soome {
2482c65ebfc7SToomas Soome GenerateBrowseReply(&question->qname, answer->InterfaceID, req, &rep, browse_reply_op, flags, kDNSServiceErr_NoSuchRecord);
2483c65ebfc7SToomas Soome goto validReply;
2484c65ebfc7SToomas Soome }
2485c65ebfc7SToomas Soome
24865ffb0c9bSToomas Soome if (GenerateNTDResponse(&answer->rdata->u.name, answer->InterfaceID, req, &rep, browse_reply_op, flags, mStatus_NoError) != mStatus_NoError)
24874b22b933Srs {
24885ffb0c9bSToomas Soome if (SameDomainName(&req->u.browser.regtype, (const domainname*)"\x09_services\x07_dns-sd\x04_udp"))
24895ffb0c9bSToomas Soome {
24905ffb0c9bSToomas Soome // Special support to enable the DNSServiceBrowse call made by Bonjour Browser
24915ffb0c9bSToomas Soome // Remove after Bonjour Browser is updated to use DNSServiceQueryRecord instead of DNSServiceBrowse
2492c65ebfc7SToomas Soome GenerateBrowseReply(&answer->rdata->u.name, answer->InterfaceID, req, &rep, browse_reply_op, flags, mStatus_NoError);
2493c65ebfc7SToomas Soome goto validReply;
24945ffb0c9bSToomas Soome }
24954b22b933Srs
24965ffb0c9bSToomas Soome LogMsg("%3d: FoundInstance: %##s PTR %##s received from network is not valid DNS-SD service pointer",
24975ffb0c9bSToomas Soome req->sd, answer->name->c, answer->rdata->u.name.c);
24985ffb0c9bSToomas Soome return;
24995ffb0c9bSToomas Soome }
25004b22b933Srs
2501c65ebfc7SToomas Soome validReply:
25024b22b933Srs
2503*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
2504*472cd20dSToomas Soome "[R%d->Q%d] DNSServiceBrowse(" PRI_DM_NAME ", " PUB_S ") RESULT " PUB_S " interface %d: " PRI_S,
2505*472cd20dSToomas Soome req->request_id, mDNSVal16(question->TargetQID), DM_NAME_PARAM(&question->qname), DNSTypeName(question->qtype),
2506*472cd20dSToomas Soome AddRecord ? "ADD" : "RMV", mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNSfalse),
2507*472cd20dSToomas Soome RRDisplayString(m, answer));
25084b22b933Srs
25095ffb0c9bSToomas Soome append_reply(req, rep);
25105ffb0c9bSToomas Soome }
25114b22b933Srs
SetQuestionPolicy(DNSQuestion * q,request_state * req)2512c65ebfc7SToomas Soome mDNSlocal void SetQuestionPolicy(DNSQuestion *q, request_state *req)
2513c65ebfc7SToomas Soome {
2514c65ebfc7SToomas Soome q->euid = req->uid;
2515c65ebfc7SToomas Soome // The policy is either based on pid or UUID. Pass a zero pid
2516c65ebfc7SToomas Soome // to the "core" if the UUID is valid. If we always pass the pid,
2517c65ebfc7SToomas Soome // then the "core" needs to determine whether the uuid is valid
2518c65ebfc7SToomas Soome // by examining all the 16 bytes at the time of the policy
2519c65ebfc7SToomas Soome // check and also when setting the delegate socket option. Also, it
2520c65ebfc7SToomas Soome // requires that we zero out the uuid wherever the question is
2521c65ebfc7SToomas Soome // initialized to make sure that it is not interpreted as valid.
2522c65ebfc7SToomas Soome // To prevent these intrusive changes, just pass a zero pid to indicate
2523c65ebfc7SToomas Soome // that pid is not valid when uuid is valid. In future if we need the
2524c65ebfc7SToomas Soome // pid in the question, we will reevaluate this strategy.
2525c65ebfc7SToomas Soome if (req->validUUID)
2526c65ebfc7SToomas Soome {
2527c65ebfc7SToomas Soome mDNSPlatformMemCopy(q->uuid, req->uuid, UUID_SIZE);
2528c65ebfc7SToomas Soome q->pid = 0;
2529c65ebfc7SToomas Soome }
2530c65ebfc7SToomas Soome else
2531c65ebfc7SToomas Soome {
2532c65ebfc7SToomas Soome q->pid = req->process_id;
2533c65ebfc7SToomas Soome }
2534c65ebfc7SToomas Soome
2535c65ebfc7SToomas Soome //debugf("SetQuestionPolicy: q->euid[%d] q->pid[%d] uuid is valid : %s", q->euid, q->pid, req->validUUID ? "true" : "false");
2536c65ebfc7SToomas Soome }
2537c65ebfc7SToomas Soome
add_domain_to_browser(request_state * info,const domainname * d)25385ffb0c9bSToomas Soome mDNSlocal mStatus add_domain_to_browser(request_state *info, const domainname *d)
25395ffb0c9bSToomas Soome {
25405ffb0c9bSToomas Soome browser_t *b, *p;
25415ffb0c9bSToomas Soome mStatus err;
25424b22b933Srs
25435ffb0c9bSToomas Soome for (p = info->u.browser.browsers; p; p = p->next)
25445ffb0c9bSToomas Soome {
25455ffb0c9bSToomas Soome if (SameDomainName(&p->domain, d))
25465ffb0c9bSToomas Soome { debugf("add_domain_to_browser %##s already in list", d->c); return mStatus_AlreadyRegistered; }
25475ffb0c9bSToomas Soome }
25484b22b933Srs
2549*472cd20dSToomas Soome b = (browser_t *) callocL("browser_t", sizeof(*b));
25505ffb0c9bSToomas Soome if (!b) return mStatus_NoMemoryErr;
25515ffb0c9bSToomas Soome AssignDomainName(&b->domain, d);
2552c65ebfc7SToomas Soome SetQuestionPolicy(&b->q, info);
2553*472cd20dSToomas Soome err = mDNS_StartBrowse(&mDNSStorage, &b->q, &info->u.browser.regtype, d, info->u.browser.interface_id, info->flags,
25545ffb0c9bSToomas Soome info->u.browser.ForceMCast, (info->flags & kDNSServiceFlagsBackgroundTrafficClass) != 0, FoundInstance, info);
25555ffb0c9bSToomas Soome if (err)
25565ffb0c9bSToomas Soome {
25575ffb0c9bSToomas Soome LogMsg("mDNS_StartBrowse returned %d for type %##s domain %##s", err, info->u.browser.regtype.c, d->c);
25585ffb0c9bSToomas Soome freeL("browser_t/add_domain_to_browser", b);
25595ffb0c9bSToomas Soome }
25605ffb0c9bSToomas Soome else
25615ffb0c9bSToomas Soome {
25625ffb0c9bSToomas Soome b->next = info->u.browser.browsers;
25635ffb0c9bSToomas Soome info->u.browser.browsers = b;
2564c65ebfc7SToomas Soome
2565c65ebfc7SToomas Soome #if APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
2566c65ebfc7SToomas Soome // Determine if this request should be promoted to use BLE triggered discovery.
2567c65ebfc7SToomas Soome if (shouldUseBLE(info->u.browser.interface_id, 0, &info->u.browser.regtype, (domainname *) d))
2568c65ebfc7SToomas Soome {
2569c65ebfc7SToomas Soome info->flags |= (kDNSServiceFlagsAutoTrigger | kDNSServiceFlagsIncludeAWDL);
2570c65ebfc7SToomas Soome b->q.flags |= (kDNSServiceFlagsAutoTrigger | kDNSServiceFlagsIncludeAWDL);
2571c65ebfc7SToomas Soome LogInfo("add_domain_to_browser: request promoted to use kDNSServiceFlagsAutoTrigger");
2572c65ebfc7SToomas Soome }
2573c65ebfc7SToomas Soome #endif // APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
2574c65ebfc7SToomas Soome
2575c65ebfc7SToomas Soome LogMcastQ(&b->q, info, q_start);
2576*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
25775ffb0c9bSToomas Soome if (callExternalHelpers(info->u.browser.interface_id, &b->domain, info->flags))
25784b22b933Srs {
25795ffb0c9bSToomas Soome domainname tmp;
25805ffb0c9bSToomas Soome ConstructServiceName(&tmp, NULL, &info->u.browser.regtype, &b->domain);
25813b436d06SToomas Soome LogDebug("add_domain_to_browser: calling external_start_browsing_for_service()");
2582*472cd20dSToomas Soome external_start_browsing_for_service(info->u.browser.interface_id, &tmp, kDNSType_PTR, info->flags, info->process_id);
25834b22b933Srs }
2584*472cd20dSToomas Soome #endif
25854b22b933Srs }
25865ffb0c9bSToomas Soome return err;
25875ffb0c9bSToomas Soome }
25884b22b933Srs
browse_termination_callback(request_state * info)25895ffb0c9bSToomas Soome mDNSlocal void browse_termination_callback(request_state *info)
25905ffb0c9bSToomas Soome {
25915ffb0c9bSToomas Soome if (info->u.browser.default_domain)
25924b22b933Srs {
25935ffb0c9bSToomas Soome // Stop the domain enumeration queries to discover the WAB legacy browse domains
25945ffb0c9bSToomas Soome LogInfo("%3d: DNSServiceBrowse Cancel WAB PID[%d](%s)", info->sd, info->process_id, info->pid_name);
25955ffb0c9bSToomas Soome uDNS_StopWABQueries(&mDNSStorage, UDNS_WAB_LBROWSE_QUERY);
25965ffb0c9bSToomas Soome }
25975ffb0c9bSToomas Soome while (info->u.browser.browsers)
25985ffb0c9bSToomas Soome {
25995ffb0c9bSToomas Soome browser_t *ptr = info->u.browser.browsers;
26004b22b933Srs
2601*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
2602c65ebfc7SToomas Soome if (callExternalHelpers(ptr->q.InterfaceID, &ptr->domain, ptr->q.flags))
26035ffb0c9bSToomas Soome {
26045ffb0c9bSToomas Soome domainname tmp;
26055ffb0c9bSToomas Soome ConstructServiceName(&tmp, NULL, &info->u.browser.regtype, &ptr->domain);
26065ffb0c9bSToomas Soome LogInfo("browse_termination_callback: calling external_stop_browsing_for_service()");
2607*472cd20dSToomas Soome external_stop_browsing_for_service(ptr->q.InterfaceID, &tmp, kDNSType_PTR, ptr->q.flags, info->process_id);
26085ffb0c9bSToomas Soome }
2609*472cd20dSToomas Soome #endif
2610*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
2611*472cd20dSToomas Soome "[R%d] DNSServiceBrowse(%X, %d, \"" PRI_DM_NAME "\") STOP PID[%d](" PUB_S ")",
2612*472cd20dSToomas Soome info->request_id, info->flags, info->interfaceIndex, DM_NAME_PARAM(&ptr->q.qname),
2613*472cd20dSToomas Soome info->process_id, info->pid_name);
2614c65ebfc7SToomas Soome
26155ffb0c9bSToomas Soome info->u.browser.browsers = ptr->next;
26165ffb0c9bSToomas Soome mDNS_StopBrowse(&mDNSStorage, &ptr->q); // no need to error-check result
2617c65ebfc7SToomas Soome LogMcastQ(&ptr->q, info, q_stop);
26185ffb0c9bSToomas Soome freeL("browser_t/browse_termination_callback", ptr);
26194b22b933Srs }
26205ffb0c9bSToomas Soome }
26214b22b933Srs
udsserver_automatic_browse_domain_changed(const DNameListElem * const d,const mDNSBool add)26225ffb0c9bSToomas Soome mDNSlocal void udsserver_automatic_browse_domain_changed(const DNameListElem *const d, const mDNSBool add)
26235ffb0c9bSToomas Soome {
26245ffb0c9bSToomas Soome request_state *request;
26255ffb0c9bSToomas Soome debugf("udsserver_automatic_browse_domain_changed: %s default browse domain %##s", add ? "Adding" : "Removing", d->name.c);
26264b22b933Srs
26275ffb0c9bSToomas Soome for (request = all_requests; request; request = request->next)
26285ffb0c9bSToomas Soome {
26295ffb0c9bSToomas Soome if (request->terminate != browse_termination_callback) continue; // Not a browse operation
26305ffb0c9bSToomas Soome if (!request->u.browser.default_domain) continue; // Not an auto-browse operation
26315ffb0c9bSToomas Soome if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
26324b22b933Srs {
26335ffb0c9bSToomas Soome browser_t **ptr = &request->u.browser.browsers;
26345ffb0c9bSToomas Soome while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
26355ffb0c9bSToomas Soome if (add)
26364b22b933Srs {
26375ffb0c9bSToomas Soome // If we don't already have this domain in our list for this browse operation, add it now
26385ffb0c9bSToomas Soome if (!*ptr) add_domain_to_browser(request, &d->name);
26395ffb0c9bSToomas Soome else debugf("udsserver_automatic_browse_domain_changed %##s already in list, not re-adding", &d->name);
26405ffb0c9bSToomas Soome }
26415ffb0c9bSToomas Soome else
26425ffb0c9bSToomas Soome {
26435ffb0c9bSToomas Soome if (!*ptr) LogMsg("udsserver_automatic_browse_domain_changed ERROR %##s not found", &d->name);
26445ffb0c9bSToomas Soome else
26454b22b933Srs {
26465ffb0c9bSToomas Soome DNameListElem *p;
26475ffb0c9bSToomas Soome for (p = AutoBrowseDomains; p; p=p->next)
26485ffb0c9bSToomas Soome if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
26495ffb0c9bSToomas Soome if (SameDomainName(&d->name, &p->name)) break;
26505ffb0c9bSToomas Soome if (p) debugf("udsserver_automatic_browse_domain_changed %##s still in list, not removing", &d->name);
26515ffb0c9bSToomas Soome else
26524b22b933Srs {
26535ffb0c9bSToomas Soome browser_t *rem = *ptr;
26545ffb0c9bSToomas Soome *ptr = (*ptr)->next;
26555ffb0c9bSToomas Soome mDNS_StopQueryWithRemoves(&mDNSStorage, &rem->q);
26565ffb0c9bSToomas Soome freeL("browser_t/udsserver_automatic_browse_domain_changed", rem);
26574b22b933Srs }
26584b22b933Srs }
26594b22b933Srs }
26604b22b933Srs }
26614b22b933Srs }
26625ffb0c9bSToomas Soome }
26634b22b933Srs
FreeARElemCallback(mDNS * const m,AuthRecord * const rr,mStatus result)26645ffb0c9bSToomas Soome mDNSlocal void FreeARElemCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
26655ffb0c9bSToomas Soome {
26665ffb0c9bSToomas Soome (void)m; // unused
26675ffb0c9bSToomas Soome if (result == mStatus_MemFree)
26684b22b933Srs {
26695ffb0c9bSToomas Soome // On shutdown, mDNS_Close automatically deregisters all records
26705ffb0c9bSToomas Soome // Since in this case no one has called DeregisterLocalOnlyDomainEnumPTR to cut the record
26715ffb0c9bSToomas Soome // from the LocalDomainEnumRecords list, we do this here before we free the memory.
26725ffb0c9bSToomas Soome // (This should actually no longer be necessary, now that we do the proper cleanup in
26735ffb0c9bSToomas Soome // udsserver_exit. To confirm this, we'll log an error message if we do find a record that
26745ffb0c9bSToomas Soome // hasn't been cut from the list yet. If these messages don't appear, we can delete this code.)
26755ffb0c9bSToomas Soome ARListElem **ptr = &LocalDomainEnumRecords;
26765ffb0c9bSToomas Soome while (*ptr && &(*ptr)->ar != rr) ptr = &(*ptr)->next;
26775ffb0c9bSToomas Soome if (*ptr) { *ptr = (*ptr)->next; LogMsg("FreeARElemCallback: Have to cut %s", ARDisplayString(m, rr)); }
26785ffb0c9bSToomas Soome mDNSPlatformMemFree(rr->RecordContext);
26795ffb0c9bSToomas Soome }
26805ffb0c9bSToomas Soome }
26814b22b933Srs
26825ffb0c9bSToomas Soome // RegisterLocalOnlyDomainEnumPTR and DeregisterLocalOnlyDomainEnumPTR largely duplicate code in
26835ffb0c9bSToomas Soome // "FoundDomain" in uDNS.c for creating and destroying these special mDNSInterface_LocalOnly records.
26845ffb0c9bSToomas Soome // We may want to turn the common code into a subroutine.
26854b22b933Srs
RegisterLocalOnlyDomainEnumPTR(mDNS * m,const domainname * d,int type)26865ffb0c9bSToomas Soome mDNSlocal void RegisterLocalOnlyDomainEnumPTR(mDNS *m, const domainname *d, int type)
26875ffb0c9bSToomas Soome {
26885ffb0c9bSToomas Soome // allocate/register legacy and non-legacy _browse PTR record
26895ffb0c9bSToomas Soome mStatus err;
2690*472cd20dSToomas Soome ARListElem *ptr = (ARListElem *) mDNSPlatformMemAllocateClear(sizeof(*ptr));
26915ffb0c9bSToomas Soome
26925ffb0c9bSToomas Soome debugf("Incrementing %s refcount for %##s",
26935ffb0c9bSToomas Soome (type == mDNS_DomainTypeBrowse ) ? "browse domain " :
26945ffb0c9bSToomas Soome (type == mDNS_DomainTypeRegistration ) ? "registration dom" :
26955ffb0c9bSToomas Soome (type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
26965ffb0c9bSToomas Soome
26975ffb0c9bSToomas Soome mDNS_SetupResourceRecord(&ptr->ar, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, 7200, kDNSRecordTypeShared, AuthRecordLocalOnly, FreeARElemCallback, ptr);
26985ffb0c9bSToomas Soome MakeDomainNameFromDNSNameString(&ptr->ar.namestorage, mDNS_DomainTypeNames[type]);
26995ffb0c9bSToomas Soome AppendDNSNameString (&ptr->ar.namestorage, "local");
27005ffb0c9bSToomas Soome AssignDomainName(&ptr->ar.resrec.rdata->u.name, d);
27015ffb0c9bSToomas Soome err = mDNS_Register(m, &ptr->ar);
27025ffb0c9bSToomas Soome if (err)
27035ffb0c9bSToomas Soome {
27045ffb0c9bSToomas Soome LogMsg("SetSCPrefsBrowseDomain: mDNS_Register returned error %d", err);
27055ffb0c9bSToomas Soome mDNSPlatformMemFree(ptr);
27064b22b933Srs }
27075ffb0c9bSToomas Soome else
27085ffb0c9bSToomas Soome {
27095ffb0c9bSToomas Soome ptr->next = LocalDomainEnumRecords;
27105ffb0c9bSToomas Soome LocalDomainEnumRecords = ptr;
27115ffb0c9bSToomas Soome }
27125ffb0c9bSToomas Soome }
27134b22b933Srs
DeregisterLocalOnlyDomainEnumPTR(mDNS * m,const domainname * d,int type)27145ffb0c9bSToomas Soome mDNSlocal void DeregisterLocalOnlyDomainEnumPTR(mDNS *m, const domainname *d, int type)
27155ffb0c9bSToomas Soome {
27165ffb0c9bSToomas Soome ARListElem **ptr = &LocalDomainEnumRecords;
27175ffb0c9bSToomas Soome domainname lhs; // left-hand side of PTR, for comparison
27184b22b933Srs
27195ffb0c9bSToomas Soome debugf("Decrementing %s refcount for %##s",
27205ffb0c9bSToomas Soome (type == mDNS_DomainTypeBrowse ) ? "browse domain " :
27215ffb0c9bSToomas Soome (type == mDNS_DomainTypeRegistration ) ? "registration dom" :
27225ffb0c9bSToomas Soome (type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
27234b22b933Srs
27245ffb0c9bSToomas Soome MakeDomainNameFromDNSNameString(&lhs, mDNS_DomainTypeNames[type]);
27255ffb0c9bSToomas Soome AppendDNSNameString (&lhs, "local");
27264b22b933Srs
27275ffb0c9bSToomas Soome while (*ptr)
27285ffb0c9bSToomas Soome {
27295ffb0c9bSToomas Soome if (SameDomainName(&(*ptr)->ar.resrec.rdata->u.name, d) && SameDomainName((*ptr)->ar.resrec.name, &lhs))
27304b22b933Srs {
27315ffb0c9bSToomas Soome ARListElem *rem = *ptr;
27325ffb0c9bSToomas Soome *ptr = (*ptr)->next;
27335ffb0c9bSToomas Soome mDNS_Deregister(m, &rem->ar);
27345ffb0c9bSToomas Soome return;
27355ffb0c9bSToomas Soome }
27365ffb0c9bSToomas Soome else ptr = &(*ptr)->next;
27374b22b933Srs }
27385ffb0c9bSToomas Soome }
27395ffb0c9bSToomas Soome
AddAutoBrowseDomain(const mDNSu32 uid,const domainname * const name)27405ffb0c9bSToomas Soome mDNSlocal void AddAutoBrowseDomain(const mDNSu32 uid, const domainname *const name)
27415ffb0c9bSToomas Soome {
2742*472cd20dSToomas Soome DNameListElem *new = (DNameListElem *) mDNSPlatformMemAllocateClear(sizeof(*new));
27435ffb0c9bSToomas Soome if (!new) { LogMsg("ERROR: malloc"); return; }
27445ffb0c9bSToomas Soome AssignDomainName(&new->name, name);
27455ffb0c9bSToomas Soome new->uid = uid;
27465ffb0c9bSToomas Soome new->next = AutoBrowseDomains;
27475ffb0c9bSToomas Soome AutoBrowseDomains = new;
27485ffb0c9bSToomas Soome udsserver_automatic_browse_domain_changed(new, mDNStrue);
27495ffb0c9bSToomas Soome }
27505ffb0c9bSToomas Soome
RmvAutoBrowseDomain(const mDNSu32 uid,const domainname * const name)27515ffb0c9bSToomas Soome mDNSlocal void RmvAutoBrowseDomain(const mDNSu32 uid, const domainname *const name)
27525ffb0c9bSToomas Soome {
27535ffb0c9bSToomas Soome DNameListElem **p = &AutoBrowseDomains;
27545ffb0c9bSToomas Soome while (*p && (!SameDomainName(&(*p)->name, name) || (*p)->uid != uid)) p = &(*p)->next;
27555ffb0c9bSToomas Soome if (!*p) LogMsg("RmvAutoBrowseDomain: Got remove event for domain %##s not in list", name->c);
27565ffb0c9bSToomas Soome else
27574b22b933Srs {
27585ffb0c9bSToomas Soome DNameListElem *ptr = *p;
27595ffb0c9bSToomas Soome *p = ptr->next;
27605ffb0c9bSToomas Soome udsserver_automatic_browse_domain_changed(ptr, mDNSfalse);
27615ffb0c9bSToomas Soome mDNSPlatformMemFree(ptr);
27625ffb0c9bSToomas Soome }
27635ffb0c9bSToomas Soome }
27644b22b933Srs
SetPrefsBrowseDomains(mDNS * m,DNameListElem * browseDomains,mDNSBool add)27655ffb0c9bSToomas Soome mDNSlocal void SetPrefsBrowseDomains(mDNS *m, DNameListElem *browseDomains, mDNSBool add)
27665ffb0c9bSToomas Soome {
27675ffb0c9bSToomas Soome DNameListElem *d;
27685ffb0c9bSToomas Soome for (d = browseDomains; d; d = d->next)
27695ffb0c9bSToomas Soome {
27705ffb0c9bSToomas Soome if (add)
27714b22b933Srs {
27725ffb0c9bSToomas Soome RegisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
27735ffb0c9bSToomas Soome AddAutoBrowseDomain(d->uid, &d->name);
27745ffb0c9bSToomas Soome }
27755ffb0c9bSToomas Soome else
27764b22b933Srs {
27775ffb0c9bSToomas Soome DeregisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
27785ffb0c9bSToomas Soome RmvAutoBrowseDomain(d->uid, &d->name);
27795ffb0c9bSToomas Soome }
27804b22b933Srs }
27815ffb0c9bSToomas Soome }
27824b22b933Srs
27835ffb0c9bSToomas Soome #if APPLE_OSX_mDNSResponder
27844b22b933Srs
UpdateDeviceInfoRecord(mDNS * const m)27855ffb0c9bSToomas Soome mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m)
27865ffb0c9bSToomas Soome {
27875ffb0c9bSToomas Soome int num_autoname = 0;
27885ffb0c9bSToomas Soome request_state *req;
2789cda73f64SToomas Soome
2790cda73f64SToomas Soome // Don't need to register the device info record for kDNSServiceInterfaceIndexLocalOnly registrations.
27915ffb0c9bSToomas Soome for (req = all_requests; req; req = req->next)
2792cda73f64SToomas Soome {
2793cda73f64SToomas Soome if (req->terminate == regservice_termination_callback && req->u.servicereg.autoname && req->interfaceIndex != kDNSServiceInterfaceIndexLocalOnly)
27945ffb0c9bSToomas Soome num_autoname++;
2795cda73f64SToomas Soome }
27964b22b933Srs
27975ffb0c9bSToomas Soome // If DeviceInfo record is currently registered, see if we need to deregister it
27985ffb0c9bSToomas Soome if (m->DeviceInfo.resrec.RecordType != kDNSRecordTypeUnregistered)
27995ffb0c9bSToomas Soome if (num_autoname == 0 || !SameDomainLabelCS(m->DeviceInfo.resrec.name->c, m->nicelabel.c))
28004b22b933Srs {
28015ffb0c9bSToomas Soome LogOperation("UpdateDeviceInfoRecord Deregister %##s", m->DeviceInfo.resrec.name);
28025ffb0c9bSToomas Soome mDNS_Deregister(m, &m->DeviceInfo);
28034b22b933Srs }
28045ffb0c9bSToomas Soome
28055ffb0c9bSToomas Soome // If DeviceInfo record is not currently registered, see if we need to register it
28065ffb0c9bSToomas Soome if (m->DeviceInfo.resrec.RecordType == kDNSRecordTypeUnregistered)
28075ffb0c9bSToomas Soome if (num_autoname > 0)
28084b22b933Srs {
28095ffb0c9bSToomas Soome mDNS_SetupResourceRecord(&m->DeviceInfo, mDNSNULL, mDNSNULL, kDNSType_TXT, kStandardTTL, kDNSRecordTypeAdvisory, AuthRecordAny, mDNSNULL, mDNSNULL);
28105ffb0c9bSToomas Soome ConstructServiceName(&m->DeviceInfo.namestorage, &m->nicelabel, &DeviceInfoName, &localdomain);
28115ffb0c9bSToomas Soome m->DeviceInfo.resrec.rdlength = initializeDeviceInfoTXT(m, m->DeviceInfo.resrec.rdata->u.data);
28125ffb0c9bSToomas Soome LogOperation("UpdateDeviceInfoRecord Register %##s", m->DeviceInfo.resrec.name);
28135ffb0c9bSToomas Soome mDNS_Register(m, &m->DeviceInfo);
28144b22b933Srs }
28155ffb0c9bSToomas Soome }
28165ffb0c9bSToomas Soome #else // APPLE_OSX_mDNSResponder
UpdateDeviceInfoRecord(mDNS * const m)28175ffb0c9bSToomas Soome mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m)
28185ffb0c9bSToomas Soome {
28195ffb0c9bSToomas Soome (void)m; // unused
28205ffb0c9bSToomas Soome }
28215ffb0c9bSToomas Soome #endif // APPLE_OSX_mDNSResponder
28225ffb0c9bSToomas Soome
udsserver_handle_configchange(mDNS * const m)28235ffb0c9bSToomas Soome mDNSexport void udsserver_handle_configchange(mDNS *const m)
28245ffb0c9bSToomas Soome {
28255ffb0c9bSToomas Soome request_state *req;
28265ffb0c9bSToomas Soome service_instance *ptr;
28275ffb0c9bSToomas Soome DNameListElem *RegDomains = NULL;
28285ffb0c9bSToomas Soome DNameListElem *BrowseDomains = NULL;
28295ffb0c9bSToomas Soome DNameListElem *p;
28304b22b933Srs
28315ffb0c9bSToomas Soome UpdateDeviceInfoRecord(m);
28324b22b933Srs
28335ffb0c9bSToomas Soome // For autoname services, see if the default service name has changed, necessitating an automatic update
28345ffb0c9bSToomas Soome for (req = all_requests; req; req = req->next)
28355ffb0c9bSToomas Soome if (req->terminate == regservice_termination_callback)
28365ffb0c9bSToomas Soome if (req->u.servicereg.autoname && !SameDomainLabelCS(req->u.servicereg.name.c, m->nicelabel.c))
28375ffb0c9bSToomas Soome {
28385ffb0c9bSToomas Soome req->u.servicereg.name = m->nicelabel;
28395ffb0c9bSToomas Soome for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
28405ffb0c9bSToomas Soome {
28415ffb0c9bSToomas Soome ptr->renameonmemfree = 1;
28425ffb0c9bSToomas Soome if (ptr->clientnotified) SendServiceRemovalNotification(&ptr->srs);
28435ffb0c9bSToomas Soome LogInfo("udsserver_handle_configchange: Calling deregister for Service %##s", ptr->srs.RR_PTR.resrec.name->c);
28445ffb0c9bSToomas Soome if (mDNS_DeregisterService_drt(m, &ptr->srs, mDNS_Dereg_rapid))
28455ffb0c9bSToomas Soome regservice_callback(m, &ptr->srs, mStatus_MemFree); // If service deregistered already, we can re-register immediately
28465ffb0c9bSToomas Soome }
28475ffb0c9bSToomas Soome }
28484b22b933Srs
28495ffb0c9bSToomas Soome // Let the platform layer get the current DNS information
28505ffb0c9bSToomas Soome mDNS_Lock(m);
2851c65ebfc7SToomas Soome mDNSPlatformSetDNSConfig(mDNSfalse, mDNSfalse, mDNSNULL, &RegDomains, &BrowseDomains, mDNSfalse);
28525ffb0c9bSToomas Soome mDNS_Unlock(m);
28535ffb0c9bSToomas Soome
28545ffb0c9bSToomas Soome // Any automatic registration domains are also implicitly automatic browsing domains
28555ffb0c9bSToomas Soome if (RegDomains) SetPrefsBrowseDomains(m, RegDomains, mDNStrue); // Add the new list first
28565ffb0c9bSToomas Soome if (AutoRegistrationDomains) SetPrefsBrowseDomains(m, AutoRegistrationDomains, mDNSfalse); // Then clear the old list
28575ffb0c9bSToomas Soome
28585ffb0c9bSToomas Soome // Add any new domains not already in our AutoRegistrationDomains list
28595ffb0c9bSToomas Soome for (p=RegDomains; p; p=p->next)
28604b22b933Srs {
28615ffb0c9bSToomas Soome DNameListElem **pp = &AutoRegistrationDomains;
28625ffb0c9bSToomas Soome while (*pp && ((*pp)->uid != p->uid || !SameDomainName(&(*pp)->name, &p->name))) pp = &(*pp)->next;
28635ffb0c9bSToomas Soome if (!*pp) // If not found in our existing list, this is a new default registration domain
28644b22b933Srs {
28655ffb0c9bSToomas Soome RegisterLocalOnlyDomainEnumPTR(m, &p->name, mDNS_DomainTypeRegistration);
28665ffb0c9bSToomas Soome udsserver_default_reg_domain_changed(p, mDNStrue);
28674b22b933Srs }
28685ffb0c9bSToomas Soome else // else found same domainname in both old and new lists, so no change, just delete old copy
28694b22b933Srs {
28705ffb0c9bSToomas Soome DNameListElem *del = *pp;
28715ffb0c9bSToomas Soome *pp = (*pp)->next;
28725ffb0c9bSToomas Soome mDNSPlatformMemFree(del);
28734b22b933Srs }
28745ffb0c9bSToomas Soome }
28754b22b933Srs
28765ffb0c9bSToomas Soome // Delete any domains in our old AutoRegistrationDomains list that are now gone
28775ffb0c9bSToomas Soome while (AutoRegistrationDomains)
28785ffb0c9bSToomas Soome {
28795ffb0c9bSToomas Soome DNameListElem *del = AutoRegistrationDomains;
28805ffb0c9bSToomas Soome AutoRegistrationDomains = AutoRegistrationDomains->next; // Cut record from list FIRST,
28815ffb0c9bSToomas Soome DeregisterLocalOnlyDomainEnumPTR(m, &del->name, mDNS_DomainTypeRegistration);
28825ffb0c9bSToomas Soome udsserver_default_reg_domain_changed(del, mDNSfalse); // before calling udsserver_default_reg_domain_changed()
28835ffb0c9bSToomas Soome mDNSPlatformMemFree(del);
28845ffb0c9bSToomas Soome }
28854b22b933Srs
28865ffb0c9bSToomas Soome // Now we have our new updated automatic registration domain list
28875ffb0c9bSToomas Soome AutoRegistrationDomains = RegDomains;
28884b22b933Srs
28895ffb0c9bSToomas Soome // Add new browse domains to internal list
28905ffb0c9bSToomas Soome if (BrowseDomains) SetPrefsBrowseDomains(m, BrowseDomains, mDNStrue);
28914b22b933Srs
28925ffb0c9bSToomas Soome // Remove old browse domains from internal list
28935ffb0c9bSToomas Soome if (SCPrefBrowseDomains)
28945ffb0c9bSToomas Soome {
28955ffb0c9bSToomas Soome SetPrefsBrowseDomains(m, SCPrefBrowseDomains, mDNSfalse);
28965ffb0c9bSToomas Soome while (SCPrefBrowseDomains)
28974b22b933Srs {
28985ffb0c9bSToomas Soome DNameListElem *fptr = SCPrefBrowseDomains;
28995ffb0c9bSToomas Soome SCPrefBrowseDomains = SCPrefBrowseDomains->next;
29005ffb0c9bSToomas Soome mDNSPlatformMemFree(fptr);
29014b22b933Srs }
29025ffb0c9bSToomas Soome }
29035ffb0c9bSToomas Soome
29045ffb0c9bSToomas Soome // Replace the old browse domains array with the new array
29055ffb0c9bSToomas Soome SCPrefBrowseDomains = BrowseDomains;
29065ffb0c9bSToomas Soome }
29075ffb0c9bSToomas Soome
AutomaticBrowseDomainChange(mDNS * const m,DNSQuestion * q,const ResourceRecord * const answer,QC_result AddRecord)29085ffb0c9bSToomas Soome mDNSlocal void AutomaticBrowseDomainChange(mDNS *const m, DNSQuestion *q, const ResourceRecord *const answer, QC_result AddRecord)
29095ffb0c9bSToomas Soome {
29105ffb0c9bSToomas Soome (void)m; // unused;
29115ffb0c9bSToomas Soome (void)q; // unused
29125ffb0c9bSToomas Soome
29135ffb0c9bSToomas Soome LogOperation("AutomaticBrowseDomainChange: %s automatic browse domain %##s",
29145ffb0c9bSToomas Soome AddRecord ? "Adding" : "Removing", answer->rdata->u.name.c);
29155ffb0c9bSToomas Soome
29165ffb0c9bSToomas Soome if (AddRecord) AddAutoBrowseDomain(0, &answer->rdata->u.name);
29175ffb0c9bSToomas Soome else RmvAutoBrowseDomain(0, &answer->rdata->u.name);
29185ffb0c9bSToomas Soome }
29195ffb0c9bSToomas Soome
_handle_browse_request_start(request_state * request,const char * domain)2920*472cd20dSToomas Soome mDNSlocal mStatus _handle_browse_request_start(request_state *request, const char * domain)
2921*472cd20dSToomas Soome {
2922*472cd20dSToomas Soome domainname d;
2923*472cd20dSToomas Soome mStatus err = mStatus_NoError;
2924*472cd20dSToomas Soome
2925*472cd20dSToomas Soome request->terminate = browse_termination_callback;
2926*472cd20dSToomas Soome
2927*472cd20dSToomas Soome if (domain[0])
2928*472cd20dSToomas Soome {
2929*472cd20dSToomas Soome if (!MakeDomainNameFromDNSNameString(&d, domain)) return(mStatus_BadParamErr);
2930*472cd20dSToomas Soome err = add_domain_to_browser(request, &d);
2931*472cd20dSToomas Soome }
2932*472cd20dSToomas Soome else
2933*472cd20dSToomas Soome {
2934*472cd20dSToomas Soome DNameListElem *sdom;
2935*472cd20dSToomas Soome for (sdom = AutoBrowseDomains; sdom; sdom = sdom->next)
2936*472cd20dSToomas Soome if (!sdom->uid || SystemUID(request->uid) || request->uid == sdom->uid)
2937*472cd20dSToomas Soome {
2938*472cd20dSToomas Soome err = add_domain_to_browser(request, &sdom->name);
2939*472cd20dSToomas Soome if (err)
2940*472cd20dSToomas Soome {
2941*472cd20dSToomas Soome if (SameDomainName(&sdom->name, &localdomain)) break;
2942*472cd20dSToomas Soome else err = mStatus_NoError; // suppress errors for non-local "default" domains
2943*472cd20dSToomas Soome }
2944*472cd20dSToomas Soome }
2945*472cd20dSToomas Soome }
2946*472cd20dSToomas Soome
2947*472cd20dSToomas Soome return(err);
2948*472cd20dSToomas Soome }
2949*472cd20dSToomas Soome
2950*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
2951*472cd20dSToomas Soome
_return_browse_request_error(request_state * request,mStatus error)2952*472cd20dSToomas Soome mDNSlocal void _return_browse_request_error(request_state *request, mStatus error)
2953*472cd20dSToomas Soome {
2954*472cd20dSToomas Soome reply_state *rep;
2955*472cd20dSToomas Soome
2956*472cd20dSToomas Soome GenerateBrowseReply(NULL, 0, request, &rep, browse_reply_op, 0, error);
2957*472cd20dSToomas Soome
2958*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
2959*472cd20dSToomas Soome "[R%d] DNSServiceBrowse _return_browse_request_error: error (%d)", request->request_id, error);
2960*472cd20dSToomas Soome
2961*472cd20dSToomas Soome append_reply(request, rep);
2962*472cd20dSToomas Soome }
2963*472cd20dSToomas Soome
_handle_browse_request_with_trust(request_state * request,const char * domain)2964*472cd20dSToomas Soome mDNSlocal mStatus _handle_browse_request_with_trust(request_state *request, const char * domain)
2965*472cd20dSToomas Soome {
2966*472cd20dSToomas Soome mStatus err;
2967*472cd20dSToomas Soome if (audit_token_to_pid(request->audit_token) == 0)
2968*472cd20dSToomas Soome {
2969*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_browse_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
2970*472cd20dSToomas Soome err = _handle_browse_request_start(request, domain);
2971*472cd20dSToomas Soome }
2972*472cd20dSToomas Soome else
2973*472cd20dSToomas Soome {
2974*472cd20dSToomas Soome char typestr[MAX_ESCAPED_DOMAIN_NAME];
2975*472cd20dSToomas Soome typestr[0] = 0;
2976*472cd20dSToomas Soome (void)ConvertDomainNameToCString(&request->u.browser.regtype, typestr);
2977*472cd20dSToomas Soome mdns_trust_flags_t flags = mdns_trust_flags_none;
2978*472cd20dSToomas Soome mdns_trust_status_t status = mdns_trust_check_bonjour(request->audit_token, typestr, &flags);
2979*472cd20dSToomas Soome switch (status)
2980*472cd20dSToomas Soome {
2981*472cd20dSToomas Soome case mdns_trust_status_denied:
2982*472cd20dSToomas Soome case mdns_trust_status_pending:
2983*472cd20dSToomas Soome {
2984*472cd20dSToomas Soome mdns_trust_t trust = mdns_trust_create(request->audit_token, typestr, flags);
2985*472cd20dSToomas Soome if (!trust )
2986*472cd20dSToomas Soome {
2987*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
2988*472cd20dSToomas Soome goto exit;
2989*472cd20dSToomas Soome }
2990*472cd20dSToomas Soome
2991*472cd20dSToomas Soome size_t len = strlen(domain) + 1;
2992*472cd20dSToomas Soome void * context = mallocL("context/_handle_browse_request_with_trust", len);
2993*472cd20dSToomas Soome if (!context)
2994*472cd20dSToomas Soome {
2995*472cd20dSToomas Soome my_perror("ERROR: mallocL context/_handle_browse_request_with_trust");
2996*472cd20dSToomas Soome mdns_release(trust);
2997*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
2998*472cd20dSToomas Soome goto exit;
2999*472cd20dSToomas Soome }
3000*472cd20dSToomas Soome memcpy(context, domain, len);
3001*472cd20dSToomas Soome mdns_trust_set_context(trust, context);
3002*472cd20dSToomas Soome
3003*472cd20dSToomas Soome mdns_trust_set_queue(trust, _get_trust_results_dispatch_queue());
3004*472cd20dSToomas Soome mdns_trust_set_event_handler(trust, ^(mdns_trust_event_t event, mdns_trust_status_t update)
3005*472cd20dSToomas Soome {
3006*472cd20dSToomas Soome if (event == mdns_trust_event_result)
3007*472cd20dSToomas Soome {
3008*472cd20dSToomas Soome mStatus error = (update != mdns_trust_status_granted) ? mStatus_PolicyDenied : mStatus_NoError;
3009*472cd20dSToomas Soome KQueueLock();
3010*472cd20dSToomas Soome const char * _domain = mdns_trust_get_context(trust);
3011*472cd20dSToomas Soome if (_domain)
3012*472cd20dSToomas Soome {
3013*472cd20dSToomas Soome if (!error)
3014*472cd20dSToomas Soome {
3015*472cd20dSToomas Soome error = _handle_browse_request_start(request, _domain);
3016*472cd20dSToomas Soome // No context means the request was canceled before we got here
3017*472cd20dSToomas Soome }
3018*472cd20dSToomas Soome if (error) // (not else if) Always check for error result
3019*472cd20dSToomas Soome {
3020*472cd20dSToomas Soome _return_browse_request_error(request, error);
3021*472cd20dSToomas Soome }
3022*472cd20dSToomas Soome }
3023*472cd20dSToomas Soome KQueueUnlock("_handle_browse_request_with_trust");
3024*472cd20dSToomas Soome }
3025*472cd20dSToomas Soome });
3026*472cd20dSToomas Soome request->trust = trust;
3027*472cd20dSToomas Soome mdns_trust_activate(trust);
3028*472cd20dSToomas Soome err = mStatus_NoError;
3029*472cd20dSToomas Soome break;
3030*472cd20dSToomas Soome }
3031*472cd20dSToomas Soome
3032*472cd20dSToomas Soome case mdns_trust_status_no_entitlement:
3033*472cd20dSToomas Soome err = mStatus_NoAuth;
3034*472cd20dSToomas Soome break;
3035*472cd20dSToomas Soome
3036*472cd20dSToomas Soome case mdns_trust_status_granted:
3037*472cd20dSToomas Soome err = _handle_browse_request_start(request, domain);
3038*472cd20dSToomas Soome break;
3039*472cd20dSToomas Soome
3040*472cd20dSToomas Soome default:
3041*472cd20dSToomas Soome err = mStatus_UnknownErr;
3042*472cd20dSToomas Soome break;
3043*472cd20dSToomas Soome }
3044*472cd20dSToomas Soome }
3045*472cd20dSToomas Soome exit:
3046*472cd20dSToomas Soome return err;
3047*472cd20dSToomas Soome }
3048*472cd20dSToomas Soome #endif // TRUST_ENFORCEMENT
3049*472cd20dSToomas Soome
handle_browse_request(request_state * request)30505ffb0c9bSToomas Soome mDNSlocal mStatus handle_browse_request(request_state *request)
30515ffb0c9bSToomas Soome {
3052*472cd20dSToomas Soome // Note that regtype may include a trailing subtype
30535ffb0c9bSToomas Soome char regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
3054*472cd20dSToomas Soome domainname typedn, temp;
30555ffb0c9bSToomas Soome mDNSs32 NumSubTypes;
30565ffb0c9bSToomas Soome mStatus err = mStatus_NoError;
30575ffb0c9bSToomas Soome
30585ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
30595ffb0c9bSToomas Soome mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
30605ffb0c9bSToomas Soome mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
30615ffb0c9bSToomas Soome
3062c65ebfc7SToomas Soome // The browse is scoped to a specific interface index, but the
30635ffb0c9bSToomas Soome // interface is not currently in our list.
30645ffb0c9bSToomas Soome if (interfaceIndex && !InterfaceID)
30655ffb0c9bSToomas Soome {
30665ffb0c9bSToomas Soome // If it's one of the specially defined inteface index values, just return an error.
30675ffb0c9bSToomas Soome if (PreDefinedInterfaceIndex(interfaceIndex))
30684b22b933Srs {
3069cda73f64SToomas Soome LogInfo("handle_browse_request: bad interfaceIndex %d", interfaceIndex);
30705ffb0c9bSToomas Soome return(mStatus_BadParamErr);
30714b22b933Srs }
30724b22b933Srs
30735ffb0c9bSToomas Soome // Otherwise, use the specified interface index value and the browse will
30745ffb0c9bSToomas Soome // be applied to that interface when it comes up.
30755ffb0c9bSToomas Soome InterfaceID = (mDNSInterfaceID)(uintptr_t)interfaceIndex;
30765ffb0c9bSToomas Soome LogInfo("handle_browse_request: browse pending for interface index %d", interfaceIndex);
30774b22b933Srs }
30785ffb0c9bSToomas Soome
3079*472cd20dSToomas Soome if (get_string(&request->msgptr, request->msgend, regtype, sizeof(regtype)) < 0 ||
3080*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, domain, sizeof(domain )) < 0) return(mStatus_BadParamErr);
30815ffb0c9bSToomas Soome
30825ffb0c9bSToomas Soome if (!request->msgptr) { LogMsg("%3d: DNSServiceBrowse(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
30835ffb0c9bSToomas Soome
30845ffb0c9bSToomas Soome request->flags = flags;
3085cda73f64SToomas Soome request->interfaceIndex = interfaceIndex;
30865ffb0c9bSToomas Soome typedn.c[0] = 0;
3087*472cd20dSToomas Soome NumSubTypes = ChopSubTypes(regtype); // Note: Modifies regtype string to remove trailing subtypes
30885ffb0c9bSToomas Soome if (NumSubTypes < 0 || NumSubTypes > 1)
30895ffb0c9bSToomas Soome return(mStatus_BadParamErr);
30905ffb0c9bSToomas Soome if (NumSubTypes == 1)
30915ffb0c9bSToomas Soome {
3092*472cd20dSToomas Soome if (!AppendDNSNameString(&typedn, regtype + strlen(regtype) + 1))
30935ffb0c9bSToomas Soome return(mStatus_BadParamErr);
30945ffb0c9bSToomas Soome }
30955ffb0c9bSToomas Soome
30965ffb0c9bSToomas Soome if (!regtype[0] || !AppendDNSNameString(&typedn, regtype)) return(mStatus_BadParamErr);
30975ffb0c9bSToomas Soome
30985ffb0c9bSToomas Soome if (!MakeDomainNameFromDNSNameString(&temp, regtype)) return(mStatus_BadParamErr);
30995ffb0c9bSToomas Soome // For over-long service types, we only allow domain "local"
3100c65ebfc7SToomas Soome if (temp.c[0] > 15 && domain[0] == 0) mDNSPlatformStrLCopy(domain, "local.", sizeof(domain));
31015ffb0c9bSToomas Soome
31025ffb0c9bSToomas Soome // Set up browser info
31035ffb0c9bSToomas Soome request->u.browser.ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;
31045ffb0c9bSToomas Soome request->u.browser.interface_id = InterfaceID;
31055ffb0c9bSToomas Soome AssignDomainName(&request->u.browser.regtype, &typedn);
31065ffb0c9bSToomas Soome request->u.browser.default_domain = !domain[0];
31075ffb0c9bSToomas Soome request->u.browser.browsers = NULL;
31085ffb0c9bSToomas Soome
3109*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%d] DNSServiceBrowse(%X, %d, \"" PRI_DM_NAME "\", \"" PRI_S "\") START PID[%d](" PUB_S ")",
3110*472cd20dSToomas Soome request->request_id, request->flags, interfaceIndex, DM_NAME_PARAM(&request->u.browser.regtype), domain,
3111*472cd20dSToomas Soome request->process_id, request->pid_name);
31125ffb0c9bSToomas Soome
31135ffb0c9bSToomas Soome if (request->u.browser.default_domain)
31145ffb0c9bSToomas Soome {
31155ffb0c9bSToomas Soome // Start the domain enumeration queries to discover the WAB browse domains
3116*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3117*472cd20dSToomas Soome "[R%d] DNSServiceBrowse Start WAB PID[%d](" PUB_S ")",
3118*472cd20dSToomas Soome request->request_id, request->process_id, request->pid_name);
31195ffb0c9bSToomas Soome uDNS_StartWABQueries(&mDNSStorage, UDNS_WAB_LBROWSE_QUERY);
31205ffb0c9bSToomas Soome }
31215ffb0c9bSToomas Soome // We need to unconditionally set request->terminate, because even if we didn't successfully
31225ffb0c9bSToomas Soome // start any browses right now, subsequent configuration changes may cause successful
31235ffb0c9bSToomas Soome // browses to be added, and we'll need to cancel them before freeing this memory.
3124*472cd20dSToomas Soome request->terminate = NULL;
31255ffb0c9bSToomas Soome
3126*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
3127*472cd20dSToomas Soome domainname d;
3128*472cd20dSToomas Soome if (!MakeDomainNameFromDNSNameString(&d, domain)) return(mStatus_BadParamErr);
3129*472cd20dSToomas Soome
3130*472cd20dSToomas Soome if (os_feature_enabled(mDNSResponder, bonjour_privacy) &&
3131*472cd20dSToomas Soome (request->u.browser.default_domain || IsLocalDomain(&d) || request->u.browser.ForceMCast))
31325ffb0c9bSToomas Soome {
3133*472cd20dSToomas Soome err = _handle_browse_request_with_trust(request, domain);
31345ffb0c9bSToomas Soome }
31355ffb0c9bSToomas Soome else
31365ffb0c9bSToomas Soome {
3137*472cd20dSToomas Soome err = _handle_browse_request_start(request, domain);
31384b22b933Srs }
3139*472cd20dSToomas Soome #else
3140*472cd20dSToomas Soome err = _handle_browse_request_start(request, domain);
3141*472cd20dSToomas Soome #endif
31424b22b933Srs
31435ffb0c9bSToomas Soome return(err);
31445ffb0c9bSToomas Soome }
31455ffb0c9bSToomas Soome
31465ffb0c9bSToomas Soome // ***************************************************************************
31475ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
31485ffb0c9bSToomas Soome #pragma mark -
31495ffb0c9bSToomas Soome #pragma mark - DNSServiceResolve
31505ffb0c9bSToomas Soome #endif
31515ffb0c9bSToomas Soome
resolve_termination_callback(request_state * request)3152*472cd20dSToomas Soome mDNSlocal void resolve_termination_callback(request_state *request)
3153*472cd20dSToomas Soome {
3154*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3155*472cd20dSToomas Soome "[R%d] DNSServiceResolve(%X, %d, \"" PRI_DM_NAME "\") STOP PID[%d](" PUB_S ")",
3156*472cd20dSToomas Soome request->request_id, request->flags, request->interfaceIndex, DM_NAME_PARAM(&request->u.resolve.qtxt.qname),
3157*472cd20dSToomas Soome request->process_id, request->pid_name);
3158*472cd20dSToomas Soome mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qtxt);
3159*472cd20dSToomas Soome mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
3160*472cd20dSToomas Soome LogMcastQ(&request->u.resolve.qsrv, request, q_stop);
3161*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
3162*472cd20dSToomas Soome if (request->u.resolve.external_advertise)
3163*472cd20dSToomas Soome {
3164*472cd20dSToomas Soome external_stop_resolving_service(request->u.resolve.qsrv.InterfaceID, &request->u.resolve.qsrv.qname, request->flags, request->process_id);
3165*472cd20dSToomas Soome }
3166*472cd20dSToomas Soome #endif
3167*472cd20dSToomas Soome }
3168*472cd20dSToomas Soome
3169*472cd20dSToomas Soome typedef struct {
3170*472cd20dSToomas Soome char regtype[MAX_ESCAPED_DOMAIN_NAME];
3171*472cd20dSToomas Soome domainname fqdn;
3172*472cd20dSToomas Soome mDNSInterfaceID InterfaceID;
3173*472cd20dSToomas Soome } _resolve_start_params_t;
3174*472cd20dSToomas Soome
_handle_resolve_request_start(request_state * request,const _resolve_start_params_t * const params)3175*472cd20dSToomas Soome mDNSlocal mStatus _handle_resolve_request_start(request_state *request, const _resolve_start_params_t * const params)
3176*472cd20dSToomas Soome {
3177*472cd20dSToomas Soome mStatus err;
3178*472cd20dSToomas Soome
3179*472cd20dSToomas Soome err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qsrv);
3180*472cd20dSToomas Soome
3181*472cd20dSToomas Soome if (!err)
3182*472cd20dSToomas Soome {
3183*472cd20dSToomas Soome err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qtxt);
3184*472cd20dSToomas Soome if (err)
3185*472cd20dSToomas Soome {
3186*472cd20dSToomas Soome mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
3187*472cd20dSToomas Soome }
3188*472cd20dSToomas Soome else
3189*472cd20dSToomas Soome {
3190*472cd20dSToomas Soome request->terminate = resolve_termination_callback;
3191*472cd20dSToomas Soome LogMcastQ(&request->u.resolve.qsrv, request, q_start);
3192*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
3193*472cd20dSToomas Soome if (callExternalHelpers(params->InterfaceID, ¶ms->fqdn, request->flags))
3194*472cd20dSToomas Soome {
3195*472cd20dSToomas Soome request->u.resolve.external_advertise = mDNStrue;
3196*472cd20dSToomas Soome LogInfo("handle_resolve_request: calling external_start_resolving_service()");
3197*472cd20dSToomas Soome external_start_resolving_service(params->InterfaceID, ¶ms->fqdn, request->flags, request->process_id);
3198*472cd20dSToomas Soome }
3199*472cd20dSToomas Soome #else
3200*472cd20dSToomas Soome (void)params;
3201*472cd20dSToomas Soome #endif
3202*472cd20dSToomas Soome }
3203*472cd20dSToomas Soome }
3204*472cd20dSToomas Soome return err;
3205*472cd20dSToomas Soome }
3206*472cd20dSToomas Soome
resolve_result_callback(mDNS * const m,DNSQuestion * question,const ResourceRecord * const answer,QC_result AddRecord)32075ffb0c9bSToomas Soome mDNSlocal void resolve_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
32085ffb0c9bSToomas Soome {
32094b22b933Srs size_t len = 0;
3210c65ebfc7SToomas Soome char fullname[MAX_ESCAPED_DOMAIN_NAME], target[MAX_ESCAPED_DOMAIN_NAME] = "0";
32114b22b933Srs char *data;
32124b22b933Srs reply_state *rep;
32135ffb0c9bSToomas Soome request_state *req = question->QuestionContext;
3214c65ebfc7SToomas Soome const DNSServiceErrorType error =
3215c65ebfc7SToomas Soome (answer->RecordType == kDNSRecordTypePacketNegative) ? kDNSServiceErr_NoSuchRecord : kDNSServiceErr_NoError;
32164b22b933Srs (void)m; // Unused
32174b22b933Srs
3218c65ebfc7SToomas Soome LogOperation("%3d: DNSServiceResolve(%##s) %s interface %d: %s",
3219c65ebfc7SToomas Soome req->sd, question->qname.c, AddRecord ? "ADD" : "RMV",
3220c65ebfc7SToomas Soome mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNSfalse), RRDisplayString(m, answer));
32214b22b933Srs
32225ffb0c9bSToomas Soome if (!AddRecord)
32235ffb0c9bSToomas Soome {
32245ffb0c9bSToomas Soome if (req->u.resolve.srv == answer) req->u.resolve.srv = mDNSNULL;
32255ffb0c9bSToomas Soome if (req->u.resolve.txt == answer) req->u.resolve.txt = mDNSNULL;
32265ffb0c9bSToomas Soome return;
32275ffb0c9bSToomas Soome }
32285ffb0c9bSToomas Soome
32295ffb0c9bSToomas Soome if (answer->rrtype == kDNSType_SRV) req->u.resolve.srv = answer;
32305ffb0c9bSToomas Soome if (answer->rrtype == kDNSType_TXT) req->u.resolve.txt = answer;
32315ffb0c9bSToomas Soome
32325ffb0c9bSToomas Soome if (!req->u.resolve.txt || !req->u.resolve.srv) return; // only deliver result to client if we have both answers
32335ffb0c9bSToomas Soome
32345ffb0c9bSToomas Soome ConvertDomainNameToCString(answer->name, fullname);
3235c65ebfc7SToomas Soome
3236c65ebfc7SToomas Soome if (answer->RecordType != kDNSRecordTypePacketNegative)
3237c65ebfc7SToomas Soome ConvertDomainNameToCString(&req->u.resolve.srv->rdata->u.srv.target, target);
32385ffb0c9bSToomas Soome
32395ffb0c9bSToomas Soome // calculate reply length
32404b22b933Srs len += sizeof(DNSServiceFlags);
32415ffb0c9bSToomas Soome len += sizeof(mDNSu32); // interface index
32424b22b933Srs len += sizeof(DNSServiceErrorType);
32434b22b933Srs len += strlen(fullname) + 1;
32444b22b933Srs len += strlen(target) + 1;
32455ffb0c9bSToomas Soome len += 2 * sizeof(mDNSu16); // port, txtLen
32465ffb0c9bSToomas Soome len += req->u.resolve.txt->rdlength;
32475ffb0c9bSToomas Soome
32484b22b933Srs // allocate/init reply header
32495ffb0c9bSToomas Soome rep = create_reply(resolve_reply_op, len, req);
32504b22b933Srs rep->rhdr->flags = dnssd_htonl(0);
32515ffb0c9bSToomas Soome rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNSfalse));
3252c65ebfc7SToomas Soome rep->rhdr->error = dnssd_htonl(error);
32534b22b933Srs
32545ffb0c9bSToomas Soome data = (char *)&rep->rhdr[1];
32555ffb0c9bSToomas Soome
32564b22b933Srs // write reply data to message
32574b22b933Srs put_string(fullname, &data);
32584b22b933Srs put_string(target, &data);
32595ffb0c9bSToomas Soome *data++ = req->u.resolve.srv->rdata->u.srv.port.b[0];
32605ffb0c9bSToomas Soome *data++ = req->u.resolve.srv->rdata->u.srv.port.b[1];
32615ffb0c9bSToomas Soome put_uint16(req->u.resolve.txt->rdlength, &data);
32625ffb0c9bSToomas Soome put_rdata (req->u.resolve.txt->rdlength, req->u.resolve.txt->rdata->u.data, &data);
32634b22b933Srs
3264*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%d->Q%d] DNSServiceResolve(" PRI_S ") RESULT " PRI_S ":%d",
3265*472cd20dSToomas Soome req->request_id, mDNSVal16(question->TargetQID), fullname, target,
3266*472cd20dSToomas Soome mDNSVal16(req->u.resolve.srv->rdata->u.srv.port));
32675ffb0c9bSToomas Soome append_reply(req, rep);
32685ffb0c9bSToomas Soome }
32695ffb0c9bSToomas Soome
3270*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
3271*472cd20dSToomas Soome
_return_resolve_request_error(request_state * request,mStatus error)3272*472cd20dSToomas Soome mDNSlocal void _return_resolve_request_error(request_state * request, mStatus error)
32735ffb0c9bSToomas Soome {
3274*472cd20dSToomas Soome size_t len;
3275*472cd20dSToomas Soome char * emptystr = "\0";
3276*472cd20dSToomas Soome char * data;
3277*472cd20dSToomas Soome reply_state *rep;
3278*472cd20dSToomas Soome
3279*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3280*472cd20dSToomas Soome "[R%u] DNSServiceResolve _return_resolve_request_error: error(%d)", request->request_id, error);
3281*472cd20dSToomas Soome
3282*472cd20dSToomas Soome // calculate reply length
3283*472cd20dSToomas Soome len = sizeof(DNSServiceFlags);
3284*472cd20dSToomas Soome len += sizeof(mDNSu32); // interface index
3285*472cd20dSToomas Soome len += sizeof(DNSServiceErrorType);
3286*472cd20dSToomas Soome len += 2; // name, target
3287*472cd20dSToomas Soome len += 2 * sizeof(mDNSu16); // port, txtLen
3288*472cd20dSToomas Soome len += 0; //req->u.resolve.txt->rdlength;
3289*472cd20dSToomas Soome
3290*472cd20dSToomas Soome rep = create_reply(resolve_reply_op, len, request);
3291*472cd20dSToomas Soome
3292*472cd20dSToomas Soome rep->rhdr->flags = 0;
3293*472cd20dSToomas Soome rep->rhdr->ifi = 0;
3294*472cd20dSToomas Soome rep->rhdr->error = dnssd_htonl(error);
3295*472cd20dSToomas Soome
3296*472cd20dSToomas Soome data = (char *)&rep->rhdr[1];
3297*472cd20dSToomas Soome
3298*472cd20dSToomas Soome // write reply data to message
3299*472cd20dSToomas Soome put_string(emptystr, &data); // name
3300*472cd20dSToomas Soome put_string(emptystr, &data); // target
3301*472cd20dSToomas Soome put_uint16(0, &data); // port
3302*472cd20dSToomas Soome put_uint16(0, &data); // txtLen
3303*472cd20dSToomas Soome
3304*472cd20dSToomas Soome append_reply(request, rep);
33055ffb0c9bSToomas Soome }
33065ffb0c9bSToomas Soome
_handle_resolve_request_with_trust(request_state * request,const _resolve_start_params_t * const params)3307*472cd20dSToomas Soome mDNSlocal mStatus _handle_resolve_request_with_trust(request_state *request, const _resolve_start_params_t * const params)
3308*472cd20dSToomas Soome {
3309*472cd20dSToomas Soome mStatus err;
3310*472cd20dSToomas Soome if (audit_token_to_pid(request->audit_token) == 0)
3311*472cd20dSToomas Soome {
3312*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_resolve_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
3313*472cd20dSToomas Soome err = _handle_resolve_request_start(request, params);
3314*472cd20dSToomas Soome }
3315*472cd20dSToomas Soome else
3316*472cd20dSToomas Soome {
3317*472cd20dSToomas Soome mdns_trust_flags_t flags = mdns_trust_flags_none;
3318*472cd20dSToomas Soome mdns_trust_status_t status = mdns_trust_check_bonjour(request->audit_token, params->regtype, &flags);
3319*472cd20dSToomas Soome switch (status)
3320*472cd20dSToomas Soome {
3321*472cd20dSToomas Soome case mdns_trust_status_denied:
3322*472cd20dSToomas Soome case mdns_trust_status_pending:
3323*472cd20dSToomas Soome {
3324*472cd20dSToomas Soome mdns_trust_t trust = mdns_trust_create(request->audit_token, params->regtype, flags);
3325*472cd20dSToomas Soome if (!trust )
3326*472cd20dSToomas Soome {
3327*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
3328*472cd20dSToomas Soome goto exit;
3329*472cd20dSToomas Soome }
3330*472cd20dSToomas Soome
3331*472cd20dSToomas Soome void * context = mallocL("context/_handle_resolve_request_with_trust", sizeof(_resolve_start_params_t));
3332*472cd20dSToomas Soome if (!context)
3333*472cd20dSToomas Soome {
3334*472cd20dSToomas Soome my_perror("ERROR: mallocL context/_handle_resolve_request_with_trust");
3335*472cd20dSToomas Soome mdns_release(trust);
3336*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
3337*472cd20dSToomas Soome goto exit;
3338*472cd20dSToomas Soome }
3339*472cd20dSToomas Soome memcpy(context, params, sizeof(_resolve_start_params_t));
3340*472cd20dSToomas Soome mdns_trust_set_context(trust, context);
3341*472cd20dSToomas Soome mdns_trust_set_queue(trust, _get_trust_results_dispatch_queue());
3342*472cd20dSToomas Soome mdns_trust_set_event_handler(trust, ^(mdns_trust_event_t event, mdns_trust_status_t update)
3343*472cd20dSToomas Soome {
3344*472cd20dSToomas Soome if (event == mdns_trust_event_result)
3345*472cd20dSToomas Soome {
3346*472cd20dSToomas Soome mStatus error = (update != mdns_trust_status_granted) ? mStatus_PolicyDenied : mStatus_NoError;
3347*472cd20dSToomas Soome KQueueLock();
3348*472cd20dSToomas Soome _resolve_start_params_t * _params = mdns_trust_get_context(trust);
3349*472cd20dSToomas Soome if (_params)
3350*472cd20dSToomas Soome {
3351*472cd20dSToomas Soome if (!error)
3352*472cd20dSToomas Soome {
3353*472cd20dSToomas Soome error = _handle_resolve_request_start(request, _params);
3354*472cd20dSToomas Soome // No context means the request was canceled before we got here
3355*472cd20dSToomas Soome }
3356*472cd20dSToomas Soome if (error) // (not else if) Always check for error result
3357*472cd20dSToomas Soome {
3358*472cd20dSToomas Soome _return_resolve_request_error(request, error);
3359*472cd20dSToomas Soome }
3360*472cd20dSToomas Soome }
3361*472cd20dSToomas Soome KQueueUnlock("_handle_resolve_request_with_trust");
3362*472cd20dSToomas Soome }
3363*472cd20dSToomas Soome });
3364*472cd20dSToomas Soome request->trust = trust;
3365*472cd20dSToomas Soome mdns_trust_activate(trust);
3366*472cd20dSToomas Soome err = mStatus_NoError;
3367*472cd20dSToomas Soome break;
3368*472cd20dSToomas Soome }
3369*472cd20dSToomas Soome
3370*472cd20dSToomas Soome case mdns_trust_status_no_entitlement:
3371*472cd20dSToomas Soome err = mStatus_NoAuth;
3372*472cd20dSToomas Soome break;
3373*472cd20dSToomas Soome
3374*472cd20dSToomas Soome case mdns_trust_status_granted:
3375*472cd20dSToomas Soome err = _handle_resolve_request_start(request, params);
3376*472cd20dSToomas Soome break;
3377*472cd20dSToomas Soome
3378*472cd20dSToomas Soome default:
3379*472cd20dSToomas Soome err = mStatus_UnknownErr;
3380*472cd20dSToomas Soome break;
3381*472cd20dSToomas Soome }
3382*472cd20dSToomas Soome }
3383*472cd20dSToomas Soome exit:
3384*472cd20dSToomas Soome return err;
3385*472cd20dSToomas Soome }
3386*472cd20dSToomas Soome #endif // TRUST_ENFORCEMENT
3387*472cd20dSToomas Soome
handle_resolve_request(request_state * request)33885ffb0c9bSToomas Soome mDNSlocal mStatus handle_resolve_request(request_state *request)
33895ffb0c9bSToomas Soome {
3390*472cd20dSToomas Soome char name[256], domain[MAX_ESCAPED_DOMAIN_NAME];
3391*472cd20dSToomas Soome _resolve_start_params_t params;
33925ffb0c9bSToomas Soome mStatus err;
33934b22b933Srs
33945ffb0c9bSToomas Soome // extract the data from the message
33955ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
33965ffb0c9bSToomas Soome mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
33974b22b933Srs
33985ffb0c9bSToomas Soome // Map kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny with the kDNSServiceFlagsIncludeP2P
33995ffb0c9bSToomas Soome // flag set so that the resolve will run over P2P interfaces that are not yet created.
34005ffb0c9bSToomas Soome if (interfaceIndex == kDNSServiceInterfaceIndexP2P)
34015ffb0c9bSToomas Soome {
34025ffb0c9bSToomas Soome LogOperation("handle_resolve_request: mapping kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny + kDNSServiceFlagsIncludeP2P");
34035ffb0c9bSToomas Soome flags |= kDNSServiceFlagsIncludeP2P;
34045ffb0c9bSToomas Soome interfaceIndex = kDNSServiceInterfaceIndexAny;
34054b22b933Srs }
34064b22b933Srs
3407*472cd20dSToomas Soome params.InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
34085ffb0c9bSToomas Soome
3409c65ebfc7SToomas Soome // The operation is scoped to a specific interface index, but the
34105ffb0c9bSToomas Soome // interface is not currently in our list.
3411*472cd20dSToomas Soome if (interfaceIndex && !params.InterfaceID)
34124b22b933Srs {
34135ffb0c9bSToomas Soome // If it's one of the specially defined inteface index values, just return an error.
34145ffb0c9bSToomas Soome if (PreDefinedInterfaceIndex(interfaceIndex))
34155ffb0c9bSToomas Soome {
3416cda73f64SToomas Soome LogInfo("handle_resolve_request: bad interfaceIndex %d", interfaceIndex);
34175ffb0c9bSToomas Soome return(mStatus_BadParamErr);
34185ffb0c9bSToomas Soome }
34195ffb0c9bSToomas Soome
34205ffb0c9bSToomas Soome // Otherwise, use the specified interface index value and the operation will
34215ffb0c9bSToomas Soome // be applied to that interface when it comes up.
3422*472cd20dSToomas Soome params.InterfaceID = (mDNSInterfaceID)(uintptr_t)interfaceIndex;
34235ffb0c9bSToomas Soome LogInfo("handle_resolve_request: resolve pending for interface index %d", interfaceIndex);
34244b22b933Srs }
34254b22b933Srs
3426*472cd20dSToomas Soome if (get_string(&request->msgptr, request->msgend, name, sizeof(name )) < 0 ||
3427*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, params.regtype, sizeof(params.regtype)) < 0 ||
3428*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, domain, sizeof(domain )) < 0)
34295ffb0c9bSToomas Soome { LogMsg("ERROR: handle_resolve_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
34304b22b933Srs
34315ffb0c9bSToomas Soome if (!request->msgptr) { LogMsg("%3d: DNSServiceResolve(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
34324b22b933Srs
3433*472cd20dSToomas Soome if (build_domainname_from_strings(¶ms.fqdn, name, params.regtype, domain) < 0)
3434*472cd20dSToomas Soome { LogMsg("ERROR: handle_resolve_request bad “%s” “%s” “%s”", name, params.regtype, domain); return(mStatus_BadParamErr); }
34355ffb0c9bSToomas Soome
34365ffb0c9bSToomas Soome mDNSPlatformMemZero(&request->u.resolve, sizeof(request->u.resolve));
34375ffb0c9bSToomas Soome
3438c65ebfc7SToomas Soome #if APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
3439c65ebfc7SToomas Soome // Determine if this request should be promoted to use BLE triggered discovery.
3440c65ebfc7SToomas Soome if (shouldUseBLE(InterfaceID, 0, (domainname *)SkipLeadingLabels(&fqdn, 1), &fqdn))
3441c65ebfc7SToomas Soome {
3442c65ebfc7SToomas Soome flags |= (kDNSServiceFlagsAutoTrigger | kDNSServiceFlagsIncludeAWDL);
3443c65ebfc7SToomas Soome LogInfo("handle_resolve_request: request promoted to use kDNSServiceFlagsAutoTrigger");
3444c65ebfc7SToomas Soome }
3445c65ebfc7SToomas Soome #endif // APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
3446c65ebfc7SToomas Soome
34475ffb0c9bSToomas Soome request->flags = flags;
3448cda73f64SToomas Soome request->interfaceIndex = interfaceIndex;
34494b22b933Srs
34505ffb0c9bSToomas Soome // format questions
3451*472cd20dSToomas Soome request->u.resolve.qsrv.InterfaceID = params.InterfaceID;
34525ffb0c9bSToomas Soome request->u.resolve.qsrv.flags = flags;
3453*472cd20dSToomas Soome AssignDomainName(&request->u.resolve.qsrv.qname, ¶ms.fqdn);
34545ffb0c9bSToomas Soome request->u.resolve.qsrv.qtype = kDNSType_SRV;
34555ffb0c9bSToomas Soome request->u.resolve.qsrv.qclass = kDNSClass_IN;
34565ffb0c9bSToomas Soome request->u.resolve.qsrv.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
34575ffb0c9bSToomas Soome request->u.resolve.qsrv.ExpectUnique = mDNStrue;
34585ffb0c9bSToomas Soome request->u.resolve.qsrv.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
34595ffb0c9bSToomas Soome request->u.resolve.qsrv.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
34605ffb0c9bSToomas Soome request->u.resolve.qsrv.SuppressUnusable = mDNSfalse;
34615ffb0c9bSToomas Soome request->u.resolve.qsrv.AppendSearchDomains = 0;
34625ffb0c9bSToomas Soome request->u.resolve.qsrv.TimeoutQuestion = 0;
34635ffb0c9bSToomas Soome request->u.resolve.qsrv.WakeOnResolve = (flags & kDNSServiceFlagsWakeOnResolve) != 0;
3464*472cd20dSToomas Soome request->u.resolve.qsrv.UseBackgroundTraffic = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
34655ffb0c9bSToomas Soome request->u.resolve.qsrv.ProxyQuestion = 0;
34665ffb0c9bSToomas Soome request->u.resolve.qsrv.pid = request->process_id;
3467cda73f64SToomas Soome request->u.resolve.qsrv.euid = request->uid;
34685ffb0c9bSToomas Soome request->u.resolve.qsrv.QuestionCallback = resolve_result_callback;
34695ffb0c9bSToomas Soome request->u.resolve.qsrv.QuestionContext = request;
34705ffb0c9bSToomas Soome
3471*472cd20dSToomas Soome request->u.resolve.qtxt.InterfaceID = params.InterfaceID;
34725ffb0c9bSToomas Soome request->u.resolve.qtxt.flags = flags;
3473*472cd20dSToomas Soome AssignDomainName(&request->u.resolve.qtxt.qname, ¶ms.fqdn);
34745ffb0c9bSToomas Soome request->u.resolve.qtxt.qtype = kDNSType_TXT;
34755ffb0c9bSToomas Soome request->u.resolve.qtxt.qclass = kDNSClass_IN;
34765ffb0c9bSToomas Soome request->u.resolve.qtxt.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
34775ffb0c9bSToomas Soome request->u.resolve.qtxt.ExpectUnique = mDNStrue;
34785ffb0c9bSToomas Soome request->u.resolve.qtxt.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
34795ffb0c9bSToomas Soome request->u.resolve.qtxt.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
34805ffb0c9bSToomas Soome request->u.resolve.qtxt.SuppressUnusable = mDNSfalse;
34815ffb0c9bSToomas Soome request->u.resolve.qtxt.AppendSearchDomains = 0;
34825ffb0c9bSToomas Soome request->u.resolve.qtxt.TimeoutQuestion = 0;
34835ffb0c9bSToomas Soome request->u.resolve.qtxt.WakeOnResolve = 0;
3484*472cd20dSToomas Soome request->u.resolve.qtxt.UseBackgroundTraffic = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
34855ffb0c9bSToomas Soome request->u.resolve.qtxt.ProxyQuestion = 0;
34865ffb0c9bSToomas Soome request->u.resolve.qtxt.pid = request->process_id;
3487cda73f64SToomas Soome request->u.resolve.qtxt.euid = request->uid;
34885ffb0c9bSToomas Soome request->u.resolve.qtxt.QuestionCallback = resolve_result_callback;
34895ffb0c9bSToomas Soome request->u.resolve.qtxt.QuestionContext = request;
34905ffb0c9bSToomas Soome
34915ffb0c9bSToomas Soome request->u.resolve.ReportTime = NonZeroTime(mDNS_TimeNow(&mDNSStorage) + 130 * mDNSPlatformOneSecond);
34925ffb0c9bSToomas Soome
34935ffb0c9bSToomas Soome request->u.resolve.external_advertise = mDNSfalse;
34945ffb0c9bSToomas Soome
34955ffb0c9bSToomas Soome #if 0
34965ffb0c9bSToomas Soome if (!AuthorizedDomain(request, &fqdn, AutoBrowseDomains)) return(mStatus_NoError);
34974b22b933Srs #endif
34985ffb0c9bSToomas Soome
34995ffb0c9bSToomas Soome // ask the questions
3500*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3501*472cd20dSToomas Soome "[R%d] DNSServiceResolve(%X, %d, \"" PRI_DM_NAME "\") START PID[%d](" PUB_S ")",
3502*472cd20dSToomas Soome request->request_id, flags, interfaceIndex, DM_NAME_PARAM(&request->u.resolve.qsrv.qname),
3503*472cd20dSToomas Soome request->process_id, request->pid_name);
3504c65ebfc7SToomas Soome
3505*472cd20dSToomas Soome request->terminate = NULL;
3506*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
3507*472cd20dSToomas Soome domainname d;
3508*472cd20dSToomas Soome if (!MakeDomainNameFromDNSNameString(&d, domain)) return(mStatus_BadParamErr);
3509c65ebfc7SToomas Soome
3510*472cd20dSToomas Soome if (os_feature_enabled(mDNSResponder, bonjour_privacy) &&
3511*472cd20dSToomas Soome (IsLocalDomain(&d) || request->u.resolve.qsrv.ForceMCast))
35125ffb0c9bSToomas Soome {
3513*472cd20dSToomas Soome err = _handle_resolve_request_with_trust(request, ¶ms);
35144b22b933Srs }
3515*472cd20dSToomas Soome else
3516*472cd20dSToomas Soome {
3517*472cd20dSToomas Soome err = _handle_resolve_request_start(request, ¶ms);
3518*472cd20dSToomas Soome }
3519*472cd20dSToomas Soome #else
3520*472cd20dSToomas Soome err = _handle_resolve_request_start(request, ¶ms);
3521*472cd20dSToomas Soome #endif
35224b22b933Srs
35235ffb0c9bSToomas Soome return(err);
35245ffb0c9bSToomas Soome }
35254b22b933Srs
35265ffb0c9bSToomas Soome // ***************************************************************************
35275ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
35285ffb0c9bSToomas Soome #pragma mark -
35295ffb0c9bSToomas Soome #pragma mark - DNSServiceQueryRecord
35304b22b933Srs #endif
35314b22b933Srs
queryrecord_result_reply(mDNS * const m,DNSQuestion * question,const ResourceRecord * const answer,QC_result AddRecord,DNSServiceErrorType error,void * context)3532*472cd20dSToomas Soome mDNSlocal void queryrecord_result_reply(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord, DNSServiceErrorType error, void *context)
35335ffb0c9bSToomas Soome {
3534*472cd20dSToomas Soome char name[MAX_ESCAPED_DOMAIN_NAME];
3535*472cd20dSToomas Soome size_t len;
3536*472cd20dSToomas Soome DNSServiceFlags flags = 0;
3537*472cd20dSToomas Soome reply_state *rep;
3538*472cd20dSToomas Soome char *data;
3539*472cd20dSToomas Soome request_state *req = (request_state *)context;
3540*472cd20dSToomas Soome const char *dnssec_result_description = "";
35415ffb0c9bSToomas Soome
3542*472cd20dSToomas Soome ConvertDomainNameToCString(answer->name, name);
35435ffb0c9bSToomas Soome
3544*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, DNSSECv2)
3545*472cd20dSToomas Soome if (question->DNSSECStatus.enable_dnssec) {
3546*472cd20dSToomas Soome if (answer->dnssec_result == dnssec_secure)
35474b22b933Srs {
3548*472cd20dSToomas Soome flags |= kDNSServiceFlagsSecure;
3549*472cd20dSToomas Soome dnssec_result_description = ", DNSSEC_Secure";
35504b22b933Srs }
3551*472cd20dSToomas Soome else if (answer->dnssec_result == dnssec_insecure)
35525ffb0c9bSToomas Soome {
3553*472cd20dSToomas Soome flags |= kDNSServiceFlagsInsecure;
3554*472cd20dSToomas Soome dnssec_result_description = ", DNSSEC_Insecure";
35555ffb0c9bSToomas Soome }
3556*472cd20dSToomas Soome else if (answer->dnssec_result == dnssec_bogus)
35574b22b933Srs {
3558*472cd20dSToomas Soome flags |= kDNSServiceFlagsBogus;
3559*472cd20dSToomas Soome dnssec_result_description = ", DNSSEC_Bogus";
35604b22b933Srs }
3561*472cd20dSToomas Soome else if (answer->dnssec_result == dnssec_indeterminate)
3562*472cd20dSToomas Soome {
3563*472cd20dSToomas Soome flags |= kDNSServiceFlagsIndeterminate;
3564*472cd20dSToomas Soome dnssec_result_description = ", DNSSEC_Indeterminate";
3565*472cd20dSToomas Soome }
3566*472cd20dSToomas Soome } else if (question->DNSSECStatus.tried_dnssec_but_unsigned) {
3567*472cd20dSToomas Soome // handle the case where we restart the question without the DNSSEC while the user requires DNSSEC result, for
3568*472cd20dSToomas Soome // some reason we failed to get DNSSEC records. In which case, even if we go back to normal query, we should pass
3569*472cd20dSToomas Soome // the DNSSEC result
3570*472cd20dSToomas Soome flags |= kDNSServiceFlagsInsecure;
3571*472cd20dSToomas Soome dnssec_result_description = ", DNSSEC_Insecure";
35724b22b933Srs }
3573*472cd20dSToomas Soome #endif // MDNSRESPONDER_SUPPORTS(APPLE, DNSSECv2)
35744b22b933Srs
3575*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3576*472cd20dSToomas Soome "[R%u->Q%u] DNSService" PUB_S "(" PRI_DM_NAME ", " PUB_S ") RESULT " PUB_S " interface %d: (" PUB_S PUB_S ")" PRI_S,
3577*472cd20dSToomas Soome req->request_id, mDNSVal16(question->TargetQID), req->hdr.op == query_request ? "QueryRecord" : "GetAddrInfo",
3578*472cd20dSToomas Soome DM_NAME_PARAM(&question->qname), DNSTypeName(question->qtype), AddRecord ? "ADD" : "RMV",
3579*472cd20dSToomas Soome mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNSfalse),
3580*472cd20dSToomas Soome MortalityDisplayString(answer->mortality), dnssec_result_description, RRDisplayString(m, answer));
35814b22b933Srs
35825ffb0c9bSToomas Soome len = sizeof(DNSServiceFlags); // calculate reply data length
35835ffb0c9bSToomas Soome len += sizeof(mDNSu32); // interface index
35845ffb0c9bSToomas Soome len += sizeof(DNSServiceErrorType);
35855ffb0c9bSToomas Soome len += strlen(name) + 1;
35865ffb0c9bSToomas Soome len += 3 * sizeof(mDNSu16); // type, class, rdlen
35875ffb0c9bSToomas Soome len += answer->rdlength;
35885ffb0c9bSToomas Soome len += sizeof(mDNSu32); // TTL
35894b22b933Srs
35905ffb0c9bSToomas Soome rep = create_reply(req->hdr.op == query_request ? query_reply_op : addrinfo_reply_op, len, req);
35914b22b933Srs
35925ffb0c9bSToomas Soome if (AddRecord)
3593c65ebfc7SToomas Soome flags |= kDNSServiceFlagsAdd;
35943b436d06SToomas Soome if (answer->mortality == Mortality_Ghost)
35953b436d06SToomas Soome flags |= kDNSServiceFlagsExpiredAnswer;
3596*472cd20dSToomas Soome if (!question->InitialCacheMiss)
3597*472cd20dSToomas Soome flags |= kDNSServiceFlagAnsweredFromCache;
3598c65ebfc7SToomas Soome
35995ffb0c9bSToomas Soome rep->rhdr->flags = dnssd_htonl(flags);
36005ffb0c9bSToomas Soome // Call mDNSPlatformInterfaceIndexfromInterfaceID, but suppressNetworkChange (last argument). Otherwise, if the
36015ffb0c9bSToomas Soome // InterfaceID is not valid, then it simulates a "NetworkChanged" which in turn makes questions
36025ffb0c9bSToomas Soome // to be stopped and started including *this* one. Normally the InterfaceID is valid. But when we
36035ffb0c9bSToomas Soome // are using the /etc/hosts entries to answer a question, the InterfaceID may not be known to the
36045ffb0c9bSToomas Soome // mDNS core . Eventually, we should remove the calls to "NetworkChanged" in
36055ffb0c9bSToomas Soome // mDNSPlatformInterfaceIndexfromInterfaceID when it can't find InterfaceID as ResourceRecords
36065ffb0c9bSToomas Soome // should not have existed to answer this question if the corresponding interface is not valid.
36075ffb0c9bSToomas Soome rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNStrue));
36085ffb0c9bSToomas Soome rep->rhdr->error = dnssd_htonl(error);
36095ffb0c9bSToomas Soome
36105ffb0c9bSToomas Soome data = (char *)&rep->rhdr[1];
36115ffb0c9bSToomas Soome
36125ffb0c9bSToomas Soome put_string(name, &data);
36135ffb0c9bSToomas Soome put_uint16(answer->rrtype, &data);
36145ffb0c9bSToomas Soome put_uint16(answer->rrclass, &data);
36155ffb0c9bSToomas Soome put_uint16(answer->rdlength, &data);
36165ffb0c9bSToomas Soome // We need to use putRData here instead of the crude put_rdata function, because the crude put_rdata
36175ffb0c9bSToomas Soome // function just does a blind memory copy without regard to structures that may have holes in them.
36185ffb0c9bSToomas Soome if (answer->rdlength)
36195ffb0c9bSToomas Soome if (!putRData(mDNSNULL, (mDNSu8 *)data, (mDNSu8 *)rep->rhdr + len, answer))
36205ffb0c9bSToomas Soome LogMsg("queryrecord_result_reply putRData failed %d", (mDNSu8 *)rep->rhdr + len - (mDNSu8 *)data);
36215ffb0c9bSToomas Soome data += answer->rdlength;
36225ffb0c9bSToomas Soome put_uint32(AddRecord ? answer->rroriginalttl : 0, &data);
36234b22b933Srs
36245ffb0c9bSToomas Soome append_reply(req, rep);
3625*472cd20dSToomas Soome }
3626*472cd20dSToomas Soome
queryrecord_termination_callback(request_state * request)3627*472cd20dSToomas Soome mDNSlocal void queryrecord_termination_callback(request_state *request)
3628*472cd20dSToomas Soome {
3629*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3630*472cd20dSToomas Soome "[R%u] DNSServiceQueryRecord(%X, %d, " PRI_DM_NAME ", " PUB_S ") STOP PID[%d](" PUB_S ")",
3631*472cd20dSToomas Soome request->request_id, request->flags, request->interfaceIndex,
3632*472cd20dSToomas Soome DM_NAME_PARAM(QueryRecordClientRequestGetQName(&request->u.queryrecord)),
3633*472cd20dSToomas Soome DNSTypeName(QueryRecordClientRequestGetType(&request->u.queryrecord)), request->process_id, request->pid_name);
3634*472cd20dSToomas Soome
3635*472cd20dSToomas Soome QueryRecordClientRequestStop(&request->u.queryrecord);
3636*472cd20dSToomas Soome }
3637*472cd20dSToomas Soome
3638*472cd20dSToomas Soome typedef struct {
3639*472cd20dSToomas Soome char qname[MAX_ESCAPED_DOMAIN_NAME];
3640*472cd20dSToomas Soome mDNSu32 interfaceIndex;
3641*472cd20dSToomas Soome DNSServiceFlags flags;
3642*472cd20dSToomas Soome mDNSu16 qtype;
3643*472cd20dSToomas Soome mDNSu16 qclass;
3644*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
3645*472cd20dSToomas Soome mDNSBool require_privacy;
3646*472cd20dSToomas Soome #endif
3647*472cd20dSToomas Soome } _queryrecord_start_params_t;
3648*472cd20dSToomas Soome
3649*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER) && MDNSRESPONDER_SUPPORTS(APPLE, IPC_TLV)
ipc_tlv_get_resolver_config_plist_data(const mDNSu8 * const start,const mDNSu8 * const end,size_t * outLen)3650*472cd20dSToomas Soome mDNSlocal const mDNSu8 * ipc_tlv_get_resolver_config_plist_data(const mDNSu8 *const start, const mDNSu8 *const end,
3651*472cd20dSToomas Soome size_t *outLen)
3652*472cd20dSToomas Soome {
3653*472cd20dSToomas Soome size_t len = 0;
3654*472cd20dSToomas Soome const mDNSu8 *value = NULL;
3655*472cd20dSToomas Soome mdns_tlv16_get_value(start, end, IPC_TLV_TYPE_RESOLVER_CONFIG_PLIST_DATA, &len, &value, NULL);
3656*472cd20dSToomas Soome if (outLen)
36575ffb0c9bSToomas Soome {
3658*472cd20dSToomas Soome *outLen = len;
36595ffb0c9bSToomas Soome }
3660*472cd20dSToomas Soome return value;
3661*472cd20dSToomas Soome }
36624b22b933Srs
ipc_tlv_get_require_privacy(const mDNSu8 * const start,const mDNSu8 * const end)3663*472cd20dSToomas Soome mDNSlocal mDNSBool ipc_tlv_get_require_privacy(const mDNSu8 *const start, const mDNSu8 *const end)
3664*472cd20dSToomas Soome {
3665*472cd20dSToomas Soome size_t len = 0;
3666*472cd20dSToomas Soome const mDNSu8 *value = NULL;
3667*472cd20dSToomas Soome mdns_tlv16_get_value(start, end, IPC_TLV_TYPE_REQUIRE_PRIVACY, &len, &value, NULL);
3668*472cd20dSToomas Soome return ((len == 1) && (*value != 0)) ? mDNStrue : mDNSfalse;
3669*472cd20dSToomas Soome }
3670*472cd20dSToomas Soome #endif
36714b22b933Srs
_handle_queryrecord_request_start(request_state * request,const _queryrecord_start_params_t * const params)3672*472cd20dSToomas Soome mDNSlocal mStatus _handle_queryrecord_request_start(request_state *request, const _queryrecord_start_params_t * const params)
3673*472cd20dSToomas Soome {
3674*472cd20dSToomas Soome mStatus err;
3675*472cd20dSToomas Soome
3676*472cd20dSToomas Soome request->terminate = queryrecord_termination_callback;
3677*472cd20dSToomas Soome
3678*472cd20dSToomas Soome QueryRecordClientRequestParams queryParams;
3679*472cd20dSToomas Soome QueryRecordClientRequestParamsInit(&queryParams);
3680*472cd20dSToomas Soome queryParams.requestID = request->request_id;
3681*472cd20dSToomas Soome queryParams.qnameStr = params->qname;
3682*472cd20dSToomas Soome queryParams.interfaceIndex = params->interfaceIndex;
3683*472cd20dSToomas Soome queryParams.flags = params->flags;
3684*472cd20dSToomas Soome queryParams.qtype = params->qtype;
3685*472cd20dSToomas Soome queryParams.qclass = params->qclass;
3686*472cd20dSToomas Soome queryParams.effectivePID = request->validUUID ? 0 : request->process_id;
3687*472cd20dSToomas Soome queryParams.effectiveUUID = request->validUUID ? request->uuid : mDNSNULL;
3688*472cd20dSToomas Soome queryParams.peerUID = request->uid;
3689*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
3690*472cd20dSToomas Soome queryParams.needEncryption = params->require_privacy ? mDNStrue : mDNSfalse;
3691*472cd20dSToomas Soome queryParams.customID = request->custom_service_id;
36925ffb0c9bSToomas Soome #endif
3693*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, AUDIT_TOKEN)
3694*472cd20dSToomas Soome queryParams.peerAuditToken = &request->audit_token;
36955ffb0c9bSToomas Soome #endif
3696*472cd20dSToomas Soome err = QueryRecordClientRequestStart(&request->u.queryrecord, &queryParams, queryrecord_result_reply, request);
3697*472cd20dSToomas Soome return err;
36985ffb0c9bSToomas Soome }
36995ffb0c9bSToomas Soome
3700*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
3701*472cd20dSToomas Soome
_return_queryrecord_request_error(request_state * request,mStatus error)3702*472cd20dSToomas Soome mDNSlocal void _return_queryrecord_request_error(request_state * request, mStatus error)
37035ffb0c9bSToomas Soome {
3704*472cd20dSToomas Soome size_t len;
3705*472cd20dSToomas Soome char * emptystr = "\0";
3706*472cd20dSToomas Soome char * data;
3707*472cd20dSToomas Soome reply_state *rep;
37085ffb0c9bSToomas Soome
3709*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3710*472cd20dSToomas Soome "[R%u] DNSService" PUB_S " _return_queryrecord_request_error: error(%d)",
3711*472cd20dSToomas Soome request->request_id, request->hdr.op == query_request ? "QueryRecord" : "GetAddrInfo", error);
37125ffb0c9bSToomas Soome
3713*472cd20dSToomas Soome len = sizeof(DNSServiceFlags); // calculate reply data length
3714*472cd20dSToomas Soome len += sizeof(mDNSu32); // interface index
3715*472cd20dSToomas Soome len += sizeof(DNSServiceErrorType);
3716*472cd20dSToomas Soome len += strlen(emptystr) + 1;
3717*472cd20dSToomas Soome len += 3 * sizeof(mDNSu16); // type, class, rdlen
3718*472cd20dSToomas Soome len += 0;//answer->rdlength;
3719*472cd20dSToomas Soome len += sizeof(mDNSu32); // TTL
37205ffb0c9bSToomas Soome
3721*472cd20dSToomas Soome rep = create_reply(request->hdr.op == query_request ? query_reply_op : addrinfo_reply_op, len, request);
37225ffb0c9bSToomas Soome
3723*472cd20dSToomas Soome rep->rhdr->flags = 0;
3724*472cd20dSToomas Soome rep->rhdr->ifi = 0;
3725*472cd20dSToomas Soome rep->rhdr->error = dnssd_htonl(error);
3726*472cd20dSToomas Soome
3727*472cd20dSToomas Soome data = (char *)&rep->rhdr[1];
3728*472cd20dSToomas Soome
3729*472cd20dSToomas Soome put_string(emptystr, &data);
3730*472cd20dSToomas Soome put_uint16(0, &data);
3731*472cd20dSToomas Soome put_uint16(0, &data);
3732*472cd20dSToomas Soome put_uint16(0, &data);
3733*472cd20dSToomas Soome data += 0;
3734*472cd20dSToomas Soome put_uint32(0, &data);
3735*472cd20dSToomas Soome
3736*472cd20dSToomas Soome append_reply(request, rep);
3737*472cd20dSToomas Soome }
3738*472cd20dSToomas Soome
_handle_queryrecord_request_with_trust(request_state * request,const _queryrecord_start_params_t * const params)3739*472cd20dSToomas Soome mDNSlocal mStatus _handle_queryrecord_request_with_trust(request_state *request, const _queryrecord_start_params_t * const params)
3740*472cd20dSToomas Soome {
3741*472cd20dSToomas Soome mStatus err;
3742*472cd20dSToomas Soome if (audit_token_to_pid(request->audit_token) == 0)
37435ffb0c9bSToomas Soome {
3744*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_queryrecord_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
3745*472cd20dSToomas Soome err = _handle_queryrecord_request_start(request, params);
37465ffb0c9bSToomas Soome }
3747*472cd20dSToomas Soome else
37485ffb0c9bSToomas Soome {
3749*472cd20dSToomas Soome const char *service_ptr = NULL;
3750*472cd20dSToomas Soome char type_str[MAX_ESCAPED_DOMAIN_NAME] = "";
3751*472cd20dSToomas Soome domainname query_name;
3752*472cd20dSToomas Soome if (MakeDomainNameFromDNSNameString(&query_name, params->qname))
37535ffb0c9bSToomas Soome {
3754*472cd20dSToomas Soome domainlabel name;
3755*472cd20dSToomas Soome domainname type, domain;
3756*472cd20dSToomas Soome bool good = DeconstructServiceName(&query_name, &name, &type, &domain);
3757*472cd20dSToomas Soome if (good)
37585ffb0c9bSToomas Soome {
3759*472cd20dSToomas Soome ConvertDomainNameToCString(&type, type_str);
3760*472cd20dSToomas Soome service_ptr = type_str;
37615ffb0c9bSToomas Soome }
37625ffb0c9bSToomas Soome }
3763*472cd20dSToomas Soome
3764*472cd20dSToomas Soome mdns_trust_flags_t flags = mdns_trust_flags_none;
3765*472cd20dSToomas Soome mdns_trust_status_t status = mdns_trust_check_query(request->audit_token, params->qname, service_ptr, params->qtype, (params->flags & kDNSServiceFlagsForceMulticast) != 0, &flags);
3766*472cd20dSToomas Soome switch (status)
37675ffb0c9bSToomas Soome {
3768*472cd20dSToomas Soome case mdns_trust_status_denied:
3769*472cd20dSToomas Soome case mdns_trust_status_pending:
37705ffb0c9bSToomas Soome {
3771*472cd20dSToomas Soome mdns_trust_t trust = mdns_trust_create(request->audit_token, service_ptr, flags);
3772*472cd20dSToomas Soome if (!trust )
37735ffb0c9bSToomas Soome {
3774*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
3775*472cd20dSToomas Soome goto exit;
37765ffb0c9bSToomas Soome }
3777*472cd20dSToomas Soome
3778*472cd20dSToomas Soome void * context = mallocL("context/_handle_queryrecord_request_with_trust", sizeof(_queryrecord_start_params_t));
3779*472cd20dSToomas Soome if (!context)
37805ffb0c9bSToomas Soome {
3781*472cd20dSToomas Soome my_perror("ERROR: mallocL context/_handle_queryrecord_request_with_trust");
3782*472cd20dSToomas Soome mdns_release(trust);
3783*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
3784*472cd20dSToomas Soome goto exit;
37855ffb0c9bSToomas Soome }
3786*472cd20dSToomas Soome memcpy(context, params, sizeof(_queryrecord_start_params_t));
3787*472cd20dSToomas Soome mdns_trust_set_context(trust, context);
3788*472cd20dSToomas Soome mdns_trust_set_queue(trust, _get_trust_results_dispatch_queue());
3789*472cd20dSToomas Soome mdns_trust_set_event_handler(trust, ^(mdns_trust_event_t event, mdns_trust_status_t update)
3790*472cd20dSToomas Soome {
3791*472cd20dSToomas Soome if (event == mdns_trust_event_result)
3792*472cd20dSToomas Soome {
3793*472cd20dSToomas Soome mStatus error = (update != mdns_trust_status_granted) ? mStatus_PolicyDenied : mStatus_NoError;
3794*472cd20dSToomas Soome KQueueLock();
3795*472cd20dSToomas Soome _queryrecord_start_params_t * _params = mdns_trust_get_context(trust);
3796*472cd20dSToomas Soome if (_params)
3797*472cd20dSToomas Soome {
3798*472cd20dSToomas Soome if (!error)
3799*472cd20dSToomas Soome {
3800*472cd20dSToomas Soome error = _handle_queryrecord_request_start(request, _params);
3801*472cd20dSToomas Soome // No context means the request was canceled before we got here
3802*472cd20dSToomas Soome }
3803*472cd20dSToomas Soome if (error) // (not else if) Always check for error result
3804*472cd20dSToomas Soome {
3805*472cd20dSToomas Soome _return_queryrecord_request_error(request, error);
3806*472cd20dSToomas Soome }
3807*472cd20dSToomas Soome }
3808*472cd20dSToomas Soome KQueueUnlock("_handle_queryrecord_request_with_trust");
3809*472cd20dSToomas Soome }
3810*472cd20dSToomas Soome });
3811*472cd20dSToomas Soome request->trust = trust;
3812*472cd20dSToomas Soome mdns_trust_activate(trust);
3813*472cd20dSToomas Soome err = mStatus_NoError;
3814*472cd20dSToomas Soome break;
38155ffb0c9bSToomas Soome }
38165ffb0c9bSToomas Soome
3817*472cd20dSToomas Soome case mdns_trust_status_no_entitlement:
3818*472cd20dSToomas Soome err = mStatus_NoAuth;
3819*472cd20dSToomas Soome break;
38205ffb0c9bSToomas Soome
3821*472cd20dSToomas Soome case mdns_trust_status_granted:
3822*472cd20dSToomas Soome err = _handle_queryrecord_request_start(request, params);
3823*472cd20dSToomas Soome break;
38245ffb0c9bSToomas Soome
3825*472cd20dSToomas Soome default:
3826*472cd20dSToomas Soome err = mStatus_UnknownErr;
3827*472cd20dSToomas Soome break;
38285ffb0c9bSToomas Soome }
38295ffb0c9bSToomas Soome }
3830*472cd20dSToomas Soome exit:
3831*472cd20dSToomas Soome return err;
38325ffb0c9bSToomas Soome }
3833*472cd20dSToomas Soome #endif // TRUST_ENFORCEMENT
38345ffb0c9bSToomas Soome
handle_queryrecord_request(request_state * request)38355ffb0c9bSToomas Soome mDNSlocal mStatus handle_queryrecord_request(request_state *request)
38365ffb0c9bSToomas Soome {
38375ffb0c9bSToomas Soome mStatus err;
3838*472cd20dSToomas Soome _queryrecord_start_params_t params;
38395ffb0c9bSToomas Soome
3840*472cd20dSToomas Soome params.flags = get_flags(&request->msgptr, request->msgend);
3841*472cd20dSToomas Soome params.interfaceIndex = get_uint32(&request->msgptr, request->msgend);
3842*472cd20dSToomas Soome if (get_string(&request->msgptr, request->msgend, params.qname, sizeof(params.qname)) < 0)
38435ffb0c9bSToomas Soome {
3844*472cd20dSToomas Soome err = mStatus_BadParamErr;
3845*472cd20dSToomas Soome goto exit;
38465ffb0c9bSToomas Soome }
3847*472cd20dSToomas Soome params.qtype = get_uint16(&request->msgptr, request->msgend);
3848*472cd20dSToomas Soome params.qclass = get_uint16(&request->msgptr, request->msgend);
38495ffb0c9bSToomas Soome
38505ffb0c9bSToomas Soome if (!request->msgptr)
38515ffb0c9bSToomas Soome {
3852*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
3853*472cd20dSToomas Soome "[R%d] DNSServiceQueryRecord(unreadable parameters)", request->request_id);
3854*472cd20dSToomas Soome err = mStatus_BadParamErr;
3855*472cd20dSToomas Soome goto exit;
38565ffb0c9bSToomas Soome }
3857*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
3858*472cd20dSToomas Soome params.require_privacy = mDNSfalse;
3859*472cd20dSToomas Soome #endif
3860*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER) && MDNSRESPONDER_SUPPORTS(APPLE, IPC_TLV)
3861*472cd20dSToomas Soome if (request->msgptr && (request->hdr.ipc_flags & IPC_FLAGS_TRAILING_TLVS))
38625ffb0c9bSToomas Soome {
3863*472cd20dSToomas Soome size_t len;
3864*472cd20dSToomas Soome const mDNSu8 *const start = (const mDNSu8 *)request->msgptr;
3865*472cd20dSToomas Soome const mDNSu8 *const end = (const mDNSu8 *)request->msgend;
3866*472cd20dSToomas Soome const mDNSu8 *const data = ipc_tlv_get_resolver_config_plist_data(start, end, &len);
3867*472cd20dSToomas Soome if (data)
3868*472cd20dSToomas Soome {
3869*472cd20dSToomas Soome request->custom_service_id = Querier_RegisterCustomDNSServiceWithPListData(data, len);
3870*472cd20dSToomas Soome }
3871*472cd20dSToomas Soome params.require_privacy = ipc_tlv_get_require_privacy(start, end);
38725ffb0c9bSToomas Soome }
3873*472cd20dSToomas Soome #endif
3874*472cd20dSToomas Soome request->flags = params.flags;
3875*472cd20dSToomas Soome request->interfaceIndex = params.interfaceIndex;
38765ffb0c9bSToomas Soome
3877*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3878*472cd20dSToomas Soome "[R%d] DNSServiceQueryRecord(%X, %d, " PRI_S ", " PUB_S ") START PID[%d](" PUB_S ")",
3879*472cd20dSToomas Soome request->request_id, request->flags, request->interfaceIndex, params.qname, DNSTypeName(params.qtype), request->process_id,
3880*472cd20dSToomas Soome request->pid_name);
38815ffb0c9bSToomas Soome
3882*472cd20dSToomas Soome mDNSPlatformMemZero(&request->u.queryrecord, (mDNSu32)sizeof(request->u.queryrecord));
3883*472cd20dSToomas Soome request->terminate = NULL;
3884c65ebfc7SToomas Soome
3885*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
3886*472cd20dSToomas Soome if (os_feature_enabled(mDNSResponder, bonjour_privacy))
3887cda73f64SToomas Soome {
3888*472cd20dSToomas Soome err = _handle_queryrecord_request_with_trust(request, ¶ms);
3889cda73f64SToomas Soome }
38905ffb0c9bSToomas Soome else
38915ffb0c9bSToomas Soome {
3892*472cd20dSToomas Soome err = _handle_queryrecord_request_start(request, ¶ms);
38935ffb0c9bSToomas Soome }
3894*472cd20dSToomas Soome #else
3895*472cd20dSToomas Soome err = _handle_queryrecord_request_start(request, ¶ms);
3896*472cd20dSToomas Soome #endif
38975ffb0c9bSToomas Soome
3898*472cd20dSToomas Soome exit:
38995ffb0c9bSToomas Soome return(err);
39005ffb0c9bSToomas Soome }
39015ffb0c9bSToomas Soome
39025ffb0c9bSToomas Soome // ***************************************************************************
39035ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
39045ffb0c9bSToomas Soome #pragma mark -
39055ffb0c9bSToomas Soome #pragma mark - DNSServiceEnumerateDomains
39065ffb0c9bSToomas Soome #endif
39075ffb0c9bSToomas Soome
format_enumeration_reply(request_state * request,const char * domain,DNSServiceFlags flags,mDNSu32 ifi,DNSServiceErrorType err)39085ffb0c9bSToomas Soome mDNSlocal reply_state *format_enumeration_reply(request_state *request,
39095ffb0c9bSToomas Soome const char *domain, DNSServiceFlags flags, mDNSu32 ifi, DNSServiceErrorType err)
39105ffb0c9bSToomas Soome {
39115ffb0c9bSToomas Soome size_t len;
39125ffb0c9bSToomas Soome reply_state *reply;
39135ffb0c9bSToomas Soome char *data;
39145ffb0c9bSToomas Soome
39155ffb0c9bSToomas Soome len = sizeof(DNSServiceFlags);
39165ffb0c9bSToomas Soome len += sizeof(mDNSu32);
39175ffb0c9bSToomas Soome len += sizeof(DNSServiceErrorType);
39185ffb0c9bSToomas Soome len += strlen(domain) + 1;
39195ffb0c9bSToomas Soome
39205ffb0c9bSToomas Soome reply = create_reply(enumeration_reply_op, len, request);
39215ffb0c9bSToomas Soome reply->rhdr->flags = dnssd_htonl(flags);
39225ffb0c9bSToomas Soome reply->rhdr->ifi = dnssd_htonl(ifi);
39235ffb0c9bSToomas Soome reply->rhdr->error = dnssd_htonl(err);
39245ffb0c9bSToomas Soome data = (char *)&reply->rhdr[1];
39255ffb0c9bSToomas Soome put_string(domain, &data);
39265ffb0c9bSToomas Soome return reply;
39275ffb0c9bSToomas Soome }
39285ffb0c9bSToomas Soome
enum_termination_callback(request_state * request)39295ffb0c9bSToomas Soome mDNSlocal void enum_termination_callback(request_state *request)
39305ffb0c9bSToomas Soome {
39315ffb0c9bSToomas Soome // Stop the domain enumeration queries to discover the WAB Browse/Registration domains
39325ffb0c9bSToomas Soome if (request->u.enumeration.flags & kDNSServiceFlagsRegistrationDomains)
39335ffb0c9bSToomas Soome {
39345ffb0c9bSToomas Soome LogInfo("%3d: DNSServiceEnumeration Cancel WAB Registration PID[%d](%s)", request->sd, request->process_id, request->pid_name);
39355ffb0c9bSToomas Soome uDNS_StopWABQueries(&mDNSStorage, UDNS_WAB_REG_QUERY);
39365ffb0c9bSToomas Soome }
39375ffb0c9bSToomas Soome else
39385ffb0c9bSToomas Soome {
39395ffb0c9bSToomas Soome LogInfo("%3d: DNSServiceEnumeration Cancel WAB Browse PID[%d](%s)", request->sd, request->process_id, request->pid_name);
3940c65ebfc7SToomas Soome uDNS_StopWABQueries(&mDNSStorage, UDNS_WAB_BROWSE_QUERY | UDNS_WAB_LBROWSE_QUERY);
3941c65ebfc7SToomas Soome mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_autoall);
39425ffb0c9bSToomas Soome }
39435ffb0c9bSToomas Soome mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
39445ffb0c9bSToomas Soome mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_default);
39455ffb0c9bSToomas Soome }
39465ffb0c9bSToomas Soome
enum_result_callback(mDNS * const m,DNSQuestion * const question,const ResourceRecord * const answer,QC_result AddRecord)39475ffb0c9bSToomas Soome mDNSlocal void enum_result_callback(mDNS *const m,
39485ffb0c9bSToomas Soome DNSQuestion *const question, const ResourceRecord *const answer, QC_result AddRecord)
39495ffb0c9bSToomas Soome {
39505ffb0c9bSToomas Soome char domain[MAX_ESCAPED_DOMAIN_NAME];
39515ffb0c9bSToomas Soome request_state *request = question->QuestionContext;
39525ffb0c9bSToomas Soome DNSServiceFlags flags = 0;
39535ffb0c9bSToomas Soome reply_state *reply;
39545ffb0c9bSToomas Soome (void)m; // Unused
39555ffb0c9bSToomas Soome
39565ffb0c9bSToomas Soome if (answer->rrtype != kDNSType_PTR) return;
39575ffb0c9bSToomas Soome
39585ffb0c9bSToomas Soome #if 0
39595ffb0c9bSToomas Soome if (!AuthorizedDomain(request, &answer->rdata->u.name, request->u.enumeration.flags ? AutoRegistrationDomains : AutoBrowseDomains)) return;
39605ffb0c9bSToomas Soome #endif
39615ffb0c9bSToomas Soome
39625ffb0c9bSToomas Soome // We only return add/remove events for the browse and registration lists
39635ffb0c9bSToomas Soome // For the default browse and registration answers, we only give an "ADD" event
39645ffb0c9bSToomas Soome if (question == &request->u.enumeration.q_default && !AddRecord) return;
39655ffb0c9bSToomas Soome
39665ffb0c9bSToomas Soome if (AddRecord)
39675ffb0c9bSToomas Soome {
39685ffb0c9bSToomas Soome flags |= kDNSServiceFlagsAdd;
39695ffb0c9bSToomas Soome if (question == &request->u.enumeration.q_default) flags |= kDNSServiceFlagsDefault;
39705ffb0c9bSToomas Soome }
39715ffb0c9bSToomas Soome
39725ffb0c9bSToomas Soome ConvertDomainNameToCString(&answer->rdata->u.name, domain);
39735ffb0c9bSToomas Soome // Note that we do NOT propagate specific interface indexes to the client - for example, a domain we learn from
39745ffb0c9bSToomas Soome // a machine's system preferences may be discovered on the LocalOnly interface, but should be browsed on the
39755ffb0c9bSToomas Soome // network, so we just pass kDNSServiceInterfaceIndexAny
39765ffb0c9bSToomas Soome reply = format_enumeration_reply(request, domain, flags, kDNSServiceInterfaceIndexAny, kDNSServiceErr_NoError);
39775ffb0c9bSToomas Soome if (!reply) { LogMsg("ERROR: enum_result_callback, format_enumeration_reply"); return; }
39785ffb0c9bSToomas Soome
3979*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
3980*472cd20dSToomas Soome "[R%d->Q%d] DNSServiceEnumerateDomains(%2.*s) RESULT " PUB_S ": " PRI_S,
3981*472cd20dSToomas Soome request->request_id, mDNSVal16(question->TargetQID), question->qname.c[0], &question->qname.c[1],
3982*472cd20dSToomas Soome AddRecord ? "ADD" : "RMV", domain);
39835ffb0c9bSToomas Soome
39845ffb0c9bSToomas Soome append_reply(request, reply);
39855ffb0c9bSToomas Soome }
39865ffb0c9bSToomas Soome
handle_enum_request(request_state * request)39875ffb0c9bSToomas Soome mDNSlocal mStatus handle_enum_request(request_state *request)
39885ffb0c9bSToomas Soome {
39895ffb0c9bSToomas Soome mStatus err;
39905ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
39915ffb0c9bSToomas Soome DNSServiceFlags reg = flags & kDNSServiceFlagsRegistrationDomains;
39925ffb0c9bSToomas Soome mDNS_DomainType t_all = reg ? mDNS_DomainTypeRegistration : mDNS_DomainTypeBrowse;
39935ffb0c9bSToomas Soome mDNS_DomainType t_default = reg ? mDNS_DomainTypeRegistrationDefault : mDNS_DomainTypeBrowseDefault;
39945ffb0c9bSToomas Soome mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
39955ffb0c9bSToomas Soome mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
39965ffb0c9bSToomas Soome if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
39975ffb0c9bSToomas Soome
39985ffb0c9bSToomas Soome if (!request->msgptr)
39995ffb0c9bSToomas Soome { LogMsg("%3d: DNSServiceEnumerateDomains(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
40005ffb0c9bSToomas Soome
4001cda73f64SToomas Soome request->flags = flags;
4002cda73f64SToomas Soome request->interfaceIndex = interfaceIndex;
4003cda73f64SToomas Soome
40045ffb0c9bSToomas Soome // mark which kind of enumeration we're doing so that we know what domain enumeration queries to stop
40055ffb0c9bSToomas Soome request->u.enumeration.flags = reg;
40065ffb0c9bSToomas Soome
40075ffb0c9bSToomas Soome // enumeration requires multiple questions, so we must link all the context pointers so that
40085ffb0c9bSToomas Soome // necessary context can be reached from the callbacks
40095ffb0c9bSToomas Soome request->u.enumeration.q_all.QuestionContext = request;
40105ffb0c9bSToomas Soome request->u.enumeration.q_default.QuestionContext = request;
4011c65ebfc7SToomas Soome if (!reg) request->u.enumeration.q_autoall.QuestionContext = request;
40125ffb0c9bSToomas Soome
40135ffb0c9bSToomas Soome // if the caller hasn't specified an explicit interface, we use local-only to get the system-wide list.
40145ffb0c9bSToomas Soome if (!InterfaceID) InterfaceID = mDNSInterface_LocalOnly;
40155ffb0c9bSToomas Soome
40165ffb0c9bSToomas Soome // make the calls
40175ffb0c9bSToomas Soome LogOperation("%3d: DNSServiceEnumerateDomains(%X=%s)", request->sd, flags,
40185ffb0c9bSToomas Soome (flags & kDNSServiceFlagsBrowseDomains ) ? "kDNSServiceFlagsBrowseDomains" :
40195ffb0c9bSToomas Soome (flags & kDNSServiceFlagsRegistrationDomains) ? "kDNSServiceFlagsRegistrationDomains" : "<<Unknown>>");
40205ffb0c9bSToomas Soome err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_all, t_all, NULL, InterfaceID, enum_result_callback, request);
40215ffb0c9bSToomas Soome if (!err)
40225ffb0c9bSToomas Soome {
40235ffb0c9bSToomas Soome err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_default, t_default, NULL, InterfaceID, enum_result_callback, request);
40245ffb0c9bSToomas Soome if (err) mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
4025c65ebfc7SToomas Soome else if (!reg)
4026c65ebfc7SToomas Soome {
4027c65ebfc7SToomas Soome err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_autoall, mDNS_DomainTypeBrowseAutomatic, NULL, InterfaceID, enum_result_callback, request);
4028c65ebfc7SToomas Soome if (err)
4029c65ebfc7SToomas Soome {
4030c65ebfc7SToomas Soome mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
4031c65ebfc7SToomas Soome mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_default);
4032c65ebfc7SToomas Soome }
4033c65ebfc7SToomas Soome }
4034c65ebfc7SToomas Soome if (!err) request->terminate = enum_termination_callback;
40355ffb0c9bSToomas Soome }
40365ffb0c9bSToomas Soome if (!err)
40375ffb0c9bSToomas Soome {
40385ffb0c9bSToomas Soome // Start the domain enumeration queries to discover the WAB Browse/Registration domains
40395ffb0c9bSToomas Soome if (reg)
40405ffb0c9bSToomas Soome {
40415ffb0c9bSToomas Soome LogInfo("%3d: DNSServiceEnumerateDomains Start WAB Registration PID[%d](%s)", request->sd, request->process_id, request->pid_name);
40425ffb0c9bSToomas Soome uDNS_StartWABQueries(&mDNSStorage, UDNS_WAB_REG_QUERY);
40435ffb0c9bSToomas Soome }
4044c65ebfc7SToomas Soome else
40455ffb0c9bSToomas Soome {
40465ffb0c9bSToomas Soome LogInfo("%3d: DNSServiceEnumerateDomains Start WAB Browse PID[%d](%s)", request->sd, request->process_id, request->pid_name);
4047c65ebfc7SToomas Soome uDNS_StartWABQueries(&mDNSStorage, UDNS_WAB_BROWSE_QUERY | UDNS_WAB_LBROWSE_QUERY);
40485ffb0c9bSToomas Soome }
40495ffb0c9bSToomas Soome }
40505ffb0c9bSToomas Soome
40515ffb0c9bSToomas Soome return(err);
40525ffb0c9bSToomas Soome }
40535ffb0c9bSToomas Soome
40545ffb0c9bSToomas Soome // ***************************************************************************
40555ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
40565ffb0c9bSToomas Soome #pragma mark -
40575ffb0c9bSToomas Soome #pragma mark - DNSServiceReconfirmRecord & Misc
40585ffb0c9bSToomas Soome #endif
40595ffb0c9bSToomas Soome
handle_reconfirm_request(request_state * request)40605ffb0c9bSToomas Soome mDNSlocal mStatus handle_reconfirm_request(request_state *request)
40615ffb0c9bSToomas Soome {
40625ffb0c9bSToomas Soome mStatus status = mStatus_BadParamErr;
40635ffb0c9bSToomas Soome AuthRecord *rr = read_rr_from_ipc_msg(request, 0, 0);
40645ffb0c9bSToomas Soome if (rr)
40655ffb0c9bSToomas Soome {
40665ffb0c9bSToomas Soome status = mDNS_ReconfirmByValue(&mDNSStorage, &rr->resrec);
40675ffb0c9bSToomas Soome LogOperation(
40685ffb0c9bSToomas Soome (status == mStatus_NoError) ?
4069c65ebfc7SToomas Soome "%3d: DNSServiceReconfirmRecord(%s) interface %d initiated PID[%d](%s)" :
4070c65ebfc7SToomas Soome "%3d: DNSServiceReconfirmRecord(%s) interface %d failed PID[%d](%s) status %d",
40715ffb0c9bSToomas Soome request->sd, RRDisplayString(&mDNSStorage, &rr->resrec),
4072c65ebfc7SToomas Soome mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, rr->resrec.InterfaceID, mDNSfalse),
4073c65ebfc7SToomas Soome request->process_id, request->pid_name, status);
40745ffb0c9bSToomas Soome freeL("AuthRecord/handle_reconfirm_request", rr);
40755ffb0c9bSToomas Soome }
40765ffb0c9bSToomas Soome return(status);
40775ffb0c9bSToomas Soome }
40785ffb0c9bSToomas Soome
40795ffb0c9bSToomas Soome #if APPLE_OSX_mDNSResponder
40805ffb0c9bSToomas Soome
handle_release_request(request_state * request)40815ffb0c9bSToomas Soome mDNSlocal mStatus handle_release_request(request_state *request)
40825ffb0c9bSToomas Soome {
40835ffb0c9bSToomas Soome mStatus err = 0;
40845ffb0c9bSToomas Soome char name[256], regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
40855ffb0c9bSToomas Soome domainname instance;
40865ffb0c9bSToomas Soome
40875ffb0c9bSToomas Soome // extract the data from the message
40885ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
40895ffb0c9bSToomas Soome
4090*472cd20dSToomas Soome if (get_string(&request->msgptr, request->msgend, name, sizeof(name )) < 0 ||
4091*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, regtype, sizeof(regtype)) < 0 ||
4092*472cd20dSToomas Soome get_string(&request->msgptr, request->msgend, domain, sizeof(domain )) < 0)
40935ffb0c9bSToomas Soome {
40945ffb0c9bSToomas Soome LogMsg("ERROR: handle_release_request - Couldn't read name/regtype/domain");
40955ffb0c9bSToomas Soome return(mStatus_BadParamErr);
40965ffb0c9bSToomas Soome }
40975ffb0c9bSToomas Soome
40985ffb0c9bSToomas Soome if (!request->msgptr)
40995ffb0c9bSToomas Soome {
41005ffb0c9bSToomas Soome LogMsg("%3d: PeerConnectionRelease(unreadable parameters)", request->sd);
41015ffb0c9bSToomas Soome return(mStatus_BadParamErr);
41025ffb0c9bSToomas Soome }
41035ffb0c9bSToomas Soome
41045ffb0c9bSToomas Soome if (build_domainname_from_strings(&instance, name, regtype, domain) < 0)
41055ffb0c9bSToomas Soome {
41065ffb0c9bSToomas Soome LogMsg("ERROR: handle_release_request bad “%s” “%s” “%s”", name, regtype, domain);
41075ffb0c9bSToomas Soome return(mStatus_BadParamErr);
41085ffb0c9bSToomas Soome }
41095ffb0c9bSToomas Soome
4110*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4111*472cd20dSToomas Soome "[R%d] PeerConnectionRelease(%X " PRI_DM_NAME ") START PID[%d](" PUB_S ")",
4112*472cd20dSToomas Soome request->request_id, flags, DM_NAME_PARAM(&instance), request->process_id, request->pid_name);
4113c65ebfc7SToomas Soome
4114*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, D2D)
41155ffb0c9bSToomas Soome external_connection_release(&instance);
4116*472cd20dSToomas Soome #endif
41175ffb0c9bSToomas Soome return(err);
41185ffb0c9bSToomas Soome }
41195ffb0c9bSToomas Soome
41205ffb0c9bSToomas Soome #else // APPLE_OSX_mDNSResponder
41215ffb0c9bSToomas Soome
handle_release_request(request_state * request)41225ffb0c9bSToomas Soome mDNSlocal mStatus handle_release_request(request_state *request)
41235ffb0c9bSToomas Soome {
4124c65ebfc7SToomas Soome (void) request;
41255ffb0c9bSToomas Soome return mStatus_UnsupportedErr;
41265ffb0c9bSToomas Soome }
41275ffb0c9bSToomas Soome
41285ffb0c9bSToomas Soome #endif // APPLE_OSX_mDNSResponder
41295ffb0c9bSToomas Soome
handle_setdomain_request(request_state * request)41305ffb0c9bSToomas Soome mDNSlocal mStatus handle_setdomain_request(request_state *request)
41315ffb0c9bSToomas Soome {
41325ffb0c9bSToomas Soome char domainstr[MAX_ESCAPED_DOMAIN_NAME];
41335ffb0c9bSToomas Soome domainname domain;
41345ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
41355ffb0c9bSToomas Soome (void)flags; // Unused
4136*472cd20dSToomas Soome if (get_string(&request->msgptr, request->msgend, domainstr, sizeof(domainstr)) < 0 ||
41375ffb0c9bSToomas Soome !MakeDomainNameFromDNSNameString(&domain, domainstr))
41385ffb0c9bSToomas Soome { LogMsg("%3d: DNSServiceSetDefaultDomainForUser(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
41395ffb0c9bSToomas Soome
41405ffb0c9bSToomas Soome LogOperation("%3d: DNSServiceSetDefaultDomainForUser(%##s)", request->sd, domain.c);
41415ffb0c9bSToomas Soome return(mStatus_NoError);
41425ffb0c9bSToomas Soome }
41435ffb0c9bSToomas Soome
41445ffb0c9bSToomas Soome typedef packedstruct
41455ffb0c9bSToomas Soome {
41465ffb0c9bSToomas Soome mStatus err;
41475ffb0c9bSToomas Soome mDNSu32 len;
41485ffb0c9bSToomas Soome mDNSu32 vers;
41495ffb0c9bSToomas Soome } DaemonVersionReply;
41505ffb0c9bSToomas Soome
handle_getproperty_request(request_state * request)41515ffb0c9bSToomas Soome mDNSlocal void handle_getproperty_request(request_state *request)
41525ffb0c9bSToomas Soome {
41535ffb0c9bSToomas Soome const mStatus BadParamErr = dnssd_htonl((mDNSu32)mStatus_BadParamErr);
41545ffb0c9bSToomas Soome char prop[256];
41555ffb0c9bSToomas Soome if (get_string(&request->msgptr, request->msgend, prop, sizeof(prop)) >= 0)
41565ffb0c9bSToomas Soome {
4157*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4158*472cd20dSToomas Soome "[R%d] DNSServiceGetProperty(" PUB_S ")", request->request_id, prop);
41595ffb0c9bSToomas Soome if (!strcmp(prop, kDNSServiceProperty_DaemonVersion))
41605ffb0c9bSToomas Soome {
41615ffb0c9bSToomas Soome DaemonVersionReply x = { 0, dnssd_htonl(4), dnssd_htonl(_DNS_SD_H) };
41625ffb0c9bSToomas Soome send_all(request->sd, (const char *)&x, sizeof(x));
41635ffb0c9bSToomas Soome return;
41645ffb0c9bSToomas Soome }
41655ffb0c9bSToomas Soome }
41665ffb0c9bSToomas Soome
41675ffb0c9bSToomas Soome // If we didn't recogize the requested property name, return BadParamErr
41685ffb0c9bSToomas Soome send_all(request->sd, (const char *)&BadParamErr, sizeof(BadParamErr));
41695ffb0c9bSToomas Soome }
41705ffb0c9bSToomas Soome
41715ffb0c9bSToomas Soome #ifdef APPLE_OSX_mDNSResponder
41725ffb0c9bSToomas Soome // The caller can specify either the pid or the uuid. If the pid is not specified,
41735ffb0c9bSToomas Soome // update the effective uuid. Don't overwrite the pid which is used for debugging
41745ffb0c9bSToomas Soome // purposes and initialized when the socket is opened.
handle_connection_delegate_request(request_state * request)41755ffb0c9bSToomas Soome mDNSlocal void handle_connection_delegate_request(request_state *request)
41765ffb0c9bSToomas Soome {
41775ffb0c9bSToomas Soome mDNSs32 pid;
41785ffb0c9bSToomas Soome socklen_t len;
41795ffb0c9bSToomas Soome
4180*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4181*472cd20dSToomas Soome "[R%d] DNSServiceCreateDelegateConnection START PID[%d](" PUB_S ")",
4182*472cd20dSToomas Soome request->request_id, request->process_id, request->pid_name);
4183c65ebfc7SToomas Soome request->terminate = connection_termination;
4184c65ebfc7SToomas Soome
41855ffb0c9bSToomas Soome len = 0;
41865ffb0c9bSToomas Soome pid = get_uint32(&request->msgptr, request->msgend);
41875ffb0c9bSToomas Soome #ifdef LOCAL_PEEREPID
41885ffb0c9bSToomas Soome if (pid)
41895ffb0c9bSToomas Soome {
41905ffb0c9bSToomas Soome len = sizeof(pid);
41915ffb0c9bSToomas Soome if (getsockopt(request->sd, SOL_LOCAL, LOCAL_PEEREPID, &request->process_id, &len) != 0)
4192c65ebfc7SToomas Soome {
4193c65ebfc7SToomas Soome LogMsg("handle_connection_delegate_request: getsockopt for LOCAL_PEEREPID failed errno:%d / %s", errno, strerror(errno));
41945ffb0c9bSToomas Soome return;
4195c65ebfc7SToomas Soome }
41965ffb0c9bSToomas Soome // to extract the process name from the pid value
41975ffb0c9bSToomas Soome if (proc_pidinfo(request->process_id, PROC_PIDT_SHORTBSDINFO, 1, &proc, PROC_PIDT_SHORTBSDINFO_SIZE) == 0)
41985ffb0c9bSToomas Soome return;
4199c65ebfc7SToomas Soome mDNSPlatformStrLCopy(request->pid_name, proc.pbsi_comm, sizeof(request->pid_name));
4200cda73f64SToomas Soome debugf("handle_connection_delegate_request: process id %d, name %s", request->process_id, request->pid_name);
42015ffb0c9bSToomas Soome }
42025ffb0c9bSToomas Soome #endif
42035ffb0c9bSToomas Soome #ifdef LOCAL_PEEREUUID
42045ffb0c9bSToomas Soome if (!pid)
42055ffb0c9bSToomas Soome {
42065ffb0c9bSToomas Soome len = UUID_SIZE;
42075ffb0c9bSToomas Soome if (getsockopt(request->sd, SOL_LOCAL, LOCAL_PEEREUUID, request->uuid, &len) != 0)
4208c65ebfc7SToomas Soome {
4209c65ebfc7SToomas Soome LogMsg("handle_connection_delegate_request: getsockopt for LOCAL_PEEREUUID failed errno:%d / %s", errno, strerror(errno));
42105ffb0c9bSToomas Soome return;
4211c65ebfc7SToomas Soome }
42125ffb0c9bSToomas Soome request->validUUID = mDNStrue;
42135ffb0c9bSToomas Soome }
42145ffb0c9bSToomas Soome #endif
42155ffb0c9bSToomas Soome }
42165ffb0c9bSToomas Soome #else
handle_connection_delegate_request(request_state * request)42175ffb0c9bSToomas Soome mDNSlocal void handle_connection_delegate_request(request_state *request)
42185ffb0c9bSToomas Soome {
42195ffb0c9bSToomas Soome (void) request;
42205ffb0c9bSToomas Soome }
42215ffb0c9bSToomas Soome #endif
42225ffb0c9bSToomas Soome
42235ffb0c9bSToomas Soome typedef packedstruct
42245ffb0c9bSToomas Soome {
42255ffb0c9bSToomas Soome mStatus err;
42265ffb0c9bSToomas Soome mDNSs32 pid;
42275ffb0c9bSToomas Soome } PIDInfo;
42285ffb0c9bSToomas Soome
42295ffb0c9bSToomas Soome // ***************************************************************************
42305ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
42315ffb0c9bSToomas Soome #pragma mark -
42325ffb0c9bSToomas Soome #pragma mark - DNSServiceNATPortMappingCreate
42335ffb0c9bSToomas Soome #endif
42345ffb0c9bSToomas Soome
42355ffb0c9bSToomas Soome #define DNSServiceProtocol(X) ((X) == NATOp_AddrRequest ? 0 : (X) == NATOp_MapUDP ? kDNSServiceProtocol_UDP : kDNSServiceProtocol_TCP)
42365ffb0c9bSToomas Soome
port_mapping_termination_callback(request_state * request)42375ffb0c9bSToomas Soome mDNSlocal void port_mapping_termination_callback(request_state *request)
42385ffb0c9bSToomas Soome {
4239*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO, "[R%d] DNSServiceNATPortMappingCreate(%X, %u, %u, %d) STOP PID[%d](" PUB_S ")",
4240*472cd20dSToomas Soome request->request_id, DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
4241*472cd20dSToomas Soome mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
4242*472cd20dSToomas Soome request->process_id, request->pid_name);
4243*472cd20dSToomas Soome
42445ffb0c9bSToomas Soome mDNS_StopNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
42455ffb0c9bSToomas Soome }
42465ffb0c9bSToomas Soome
42475ffb0c9bSToomas Soome // Called via function pointer when we get a NAT Traversal (address request or port mapping) response
port_mapping_create_request_callback(mDNS * m,NATTraversalInfo * n)42485ffb0c9bSToomas Soome mDNSlocal void port_mapping_create_request_callback(mDNS *m, NATTraversalInfo *n)
42495ffb0c9bSToomas Soome {
42505ffb0c9bSToomas Soome request_state *request = (request_state *)n->clientContext;
42515ffb0c9bSToomas Soome reply_state *rep;
42525ffb0c9bSToomas Soome int replyLen;
42535ffb0c9bSToomas Soome char *data;
42545ffb0c9bSToomas Soome
42555ffb0c9bSToomas Soome if (!request) { LogMsg("port_mapping_create_request_callback called with unknown request_state object"); return; }
42565ffb0c9bSToomas Soome
42575ffb0c9bSToomas Soome // calculate reply data length
42585ffb0c9bSToomas Soome replyLen = sizeof(DNSServiceFlags);
42595ffb0c9bSToomas Soome replyLen += 3 * sizeof(mDNSu32); // if index + addr + ttl
42605ffb0c9bSToomas Soome replyLen += sizeof(DNSServiceErrorType);
42615ffb0c9bSToomas Soome replyLen += 2 * sizeof(mDNSu16); // Internal Port + External Port
42625ffb0c9bSToomas Soome replyLen += sizeof(mDNSu8); // protocol
42635ffb0c9bSToomas Soome
42645ffb0c9bSToomas Soome rep = create_reply(port_mapping_reply_op, replyLen, request);
42655ffb0c9bSToomas Soome
42665ffb0c9bSToomas Soome rep->rhdr->flags = dnssd_htonl(0);
42675ffb0c9bSToomas Soome rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, n->InterfaceID, mDNSfalse));
42685ffb0c9bSToomas Soome rep->rhdr->error = dnssd_htonl(n->Result);
42695ffb0c9bSToomas Soome
42705ffb0c9bSToomas Soome data = (char *)&rep->rhdr[1];
42715ffb0c9bSToomas Soome
42725ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.ExternalAddress.b[0];
42735ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.ExternalAddress.b[1];
42745ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.ExternalAddress.b[2];
42755ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.ExternalAddress.b[3];
42765ffb0c9bSToomas Soome *data++ = DNSServiceProtocol(request->u.pm.NATinfo.Protocol);
42775ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.IntPort.b[0];
42785ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.IntPort.b[1];
42795ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.ExternalPort.b[0];
42805ffb0c9bSToomas Soome *data++ = request->u.pm.NATinfo.ExternalPort.b[1];
42815ffb0c9bSToomas Soome put_uint32(request->u.pm.NATinfo.Lifetime, &data);
42825ffb0c9bSToomas Soome
4283*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4284*472cd20dSToomas Soome "[R%d] DNSServiceNATPortMappingCreate(%X, %u, %u, %d) RESULT " PRI_IPv4_ADDR ":%u TTL %u",
4285*472cd20dSToomas Soome request->request_id, DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
4286*472cd20dSToomas Soome mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
4287*472cd20dSToomas Soome &request->u.pm.NATinfo.ExternalAddress, mDNSVal16(request->u.pm.NATinfo.ExternalPort),
4288*472cd20dSToomas Soome request->u.pm.NATinfo.Lifetime);
42895ffb0c9bSToomas Soome
42905ffb0c9bSToomas Soome append_reply(request, rep);
42915ffb0c9bSToomas Soome }
42925ffb0c9bSToomas Soome
handle_port_mapping_request(request_state * request)42935ffb0c9bSToomas Soome mDNSlocal mStatus handle_port_mapping_request(request_state *request)
42945ffb0c9bSToomas Soome {
42955ffb0c9bSToomas Soome mDNSu32 ttl = 0;
42965ffb0c9bSToomas Soome mStatus err = mStatus_NoError;
42975ffb0c9bSToomas Soome
42985ffb0c9bSToomas Soome DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
42995ffb0c9bSToomas Soome mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
43005ffb0c9bSToomas Soome mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
43015ffb0c9bSToomas Soome mDNSu8 protocol = (mDNSu8)get_uint32(&request->msgptr, request->msgend);
43025ffb0c9bSToomas Soome (void)flags; // Unused
43035ffb0c9bSToomas Soome if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
43045ffb0c9bSToomas Soome if (request->msgptr + 8 > request->msgend) request->msgptr = NULL;
43055ffb0c9bSToomas Soome else
43065ffb0c9bSToomas Soome {
43075ffb0c9bSToomas Soome request->u.pm.NATinfo.IntPort.b[0] = *request->msgptr++;
43085ffb0c9bSToomas Soome request->u.pm.NATinfo.IntPort.b[1] = *request->msgptr++;
43095ffb0c9bSToomas Soome request->u.pm.ReqExt.b[0] = *request->msgptr++;
43105ffb0c9bSToomas Soome request->u.pm.ReqExt.b[1] = *request->msgptr++;
43115ffb0c9bSToomas Soome ttl = get_uint32(&request->msgptr, request->msgend);
43125ffb0c9bSToomas Soome }
43135ffb0c9bSToomas Soome
43145ffb0c9bSToomas Soome if (!request->msgptr)
4315*472cd20dSToomas Soome {
4316*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
4317*472cd20dSToomas Soome "[R%d] DNSServiceNATPortMappingCreate(unreadable parameters)", request->request_id);
4318*472cd20dSToomas Soome return(mStatus_BadParamErr);
4319*472cd20dSToomas Soome }
43205ffb0c9bSToomas Soome
43215ffb0c9bSToomas Soome if (protocol == 0) // If protocol == 0 (i.e. just request public address) then IntPort, ExtPort, ttl must be zero too
43225ffb0c9bSToomas Soome {
43235ffb0c9bSToomas Soome if (!mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort) || !mDNSIPPortIsZero(request->u.pm.ReqExt) || ttl) return(mStatus_BadParamErr);
43245ffb0c9bSToomas Soome }
43255ffb0c9bSToomas Soome else
43265ffb0c9bSToomas Soome {
43275ffb0c9bSToomas Soome if (mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort)) return(mStatus_BadParamErr);
43285ffb0c9bSToomas Soome if (!(protocol & (kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP))) return(mStatus_BadParamErr);
43295ffb0c9bSToomas Soome }
43305ffb0c9bSToomas Soome
4331cda73f64SToomas Soome request->flags = flags;
4332cda73f64SToomas Soome request->interfaceIndex = interfaceIndex;
43335ffb0c9bSToomas Soome request->u.pm.NATinfo.Protocol = !protocol ? NATOp_AddrRequest : (protocol == kDNSServiceProtocol_UDP) ? NATOp_MapUDP : NATOp_MapTCP;
43345ffb0c9bSToomas Soome // u.pm.NATinfo.IntPort = already set above
43355ffb0c9bSToomas Soome request->u.pm.NATinfo.RequestedPort = request->u.pm.ReqExt;
43365ffb0c9bSToomas Soome request->u.pm.NATinfo.NATLease = ttl;
43375ffb0c9bSToomas Soome request->u.pm.NATinfo.clientCallback = port_mapping_create_request_callback;
43385ffb0c9bSToomas Soome request->u.pm.NATinfo.clientContext = request;
43395ffb0c9bSToomas Soome
4340*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4341*472cd20dSToomas Soome "[R%d] DNSServiceNATPortMappingCreate(%X, %u, %u, %d) START PID[%d](" PUB_S ")",
4342*472cd20dSToomas Soome request->request_id, protocol, mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt),
4343*472cd20dSToomas Soome request->u.pm.NATinfo.NATLease, request->process_id, request->pid_name);
43445ffb0c9bSToomas Soome err = mDNS_StartNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
43455ffb0c9bSToomas Soome if (err) LogMsg("ERROR: mDNS_StartNATOperation: %d", (int)err);
43465ffb0c9bSToomas Soome else request->terminate = port_mapping_termination_callback;
43475ffb0c9bSToomas Soome
43485ffb0c9bSToomas Soome return(err);
43495ffb0c9bSToomas Soome }
43505ffb0c9bSToomas Soome
43515ffb0c9bSToomas Soome // ***************************************************************************
43525ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
43535ffb0c9bSToomas Soome #pragma mark -
43545ffb0c9bSToomas Soome #pragma mark - DNSServiceGetAddrInfo
43555ffb0c9bSToomas Soome #endif
43565ffb0c9bSToomas Soome
addrinfo_termination_callback(request_state * request)43575ffb0c9bSToomas Soome mDNSlocal void addrinfo_termination_callback(request_state *request)
43585ffb0c9bSToomas Soome {
4359*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4360*472cd20dSToomas Soome "[R%u] DNSServiceGetAddrInfo(" PRI_DM_NAME ") STOP PID[%d](" PUB_S ")",
4361*472cd20dSToomas Soome request->request_id, DM_NAME_PARAM(GetAddrInfoClientRequestGetQName(&request->u.addrinfo)),
4362*472cd20dSToomas Soome request->process_id, request->pid_name);
43635ffb0c9bSToomas Soome
4364*472cd20dSToomas Soome GetAddrInfoClientRequestStop(&request->u.addrinfo);
4365*472cd20dSToomas Soome }
4366c65ebfc7SToomas Soome
4367*472cd20dSToomas Soome typedef struct {
4368*472cd20dSToomas Soome mDNSu32 protocols;
4369*472cd20dSToomas Soome char hostname[MAX_ESCAPED_DOMAIN_NAME];
4370*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
4371*472cd20dSToomas Soome mDNSBool require_privacy;
4372*472cd20dSToomas Soome #endif
4373*472cd20dSToomas Soome } _addrinfo_start_params_t;
4374*472cd20dSToomas Soome
_handle_addrinfo_request_start(request_state * request,const _addrinfo_start_params_t * const params)4375*472cd20dSToomas Soome mDNSlocal mStatus _handle_addrinfo_request_start(request_state *request, const _addrinfo_start_params_t * const params)
4376*472cd20dSToomas Soome {
4377*472cd20dSToomas Soome mStatus err;
43785ffb0c9bSToomas Soome
4379*472cd20dSToomas Soome request->terminate = addrinfo_termination_callback;
4380*472cd20dSToomas Soome
4381*472cd20dSToomas Soome GetAddrInfoClientRequestParams gaiParams;
4382*472cd20dSToomas Soome GetAddrInfoClientRequestParamsInit(&gaiParams);
4383*472cd20dSToomas Soome gaiParams.requestID = request->request_id;
4384*472cd20dSToomas Soome gaiParams.hostnameStr = params->hostname;
4385*472cd20dSToomas Soome gaiParams.interfaceIndex = request->interfaceIndex;
4386*472cd20dSToomas Soome gaiParams.flags = request->flags;
4387*472cd20dSToomas Soome gaiParams.protocols = params->protocols;
4388*472cd20dSToomas Soome gaiParams.effectivePID = request->validUUID ? 0 : request->process_id;
4389*472cd20dSToomas Soome gaiParams.effectiveUUID = request->validUUID ? request->uuid : mDNSNULL;
4390*472cd20dSToomas Soome gaiParams.peerUID = request->uid;
4391*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
4392*472cd20dSToomas Soome gaiParams.needEncryption = params->require_privacy ? mDNStrue : mDNSfalse;
4393*472cd20dSToomas Soome gaiParams.customID = request->custom_service_id;
4394*472cd20dSToomas Soome #endif
4395*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, AUDIT_TOKEN)
4396*472cd20dSToomas Soome gaiParams.peerAuditToken = &request->audit_token;
4397*472cd20dSToomas Soome #endif
4398*472cd20dSToomas Soome err = GetAddrInfoClientRequestStart(&request->u.addrinfo, &gaiParams, queryrecord_result_reply, request);
4399c65ebfc7SToomas Soome
4400*472cd20dSToomas Soome return err;
4401*472cd20dSToomas Soome }
4402*472cd20dSToomas Soome
4403*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
4404*472cd20dSToomas Soome
_return_addrinfo_request_error(request_state * request,mStatus error)4405*472cd20dSToomas Soome mDNSlocal void _return_addrinfo_request_error(request_state * request, mStatus error)
4406*472cd20dSToomas Soome {
4407*472cd20dSToomas Soome _return_queryrecord_request_error(request, error);
4408*472cd20dSToomas Soome }
4409*472cd20dSToomas Soome
_handle_addrinfo_request_with_trust(request_state * request,const _addrinfo_start_params_t * const params)4410*472cd20dSToomas Soome mDNSlocal mStatus _handle_addrinfo_request_with_trust(request_state *request, const _addrinfo_start_params_t * const params)
4411*472cd20dSToomas Soome {
4412*472cd20dSToomas Soome mStatus err;
4413*472cd20dSToomas Soome if (audit_token_to_pid(request->audit_token) == 0)
44145ffb0c9bSToomas Soome {
4415*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_addrinfo_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
4416*472cd20dSToomas Soome err = _handle_addrinfo_request_start(request, params);
44175ffb0c9bSToomas Soome }
4418*472cd20dSToomas Soome else
44195ffb0c9bSToomas Soome {
4420*472cd20dSToomas Soome mdns_trust_flags_t flags = mdns_trust_flags_none;
4421*472cd20dSToomas Soome mdns_trust_status_t status = mdns_trust_check_getaddrinfo(request->audit_token, params->hostname, &flags);
4422*472cd20dSToomas Soome switch (status)
44235ffb0c9bSToomas Soome {
4424*472cd20dSToomas Soome case mdns_trust_status_denied:
4425*472cd20dSToomas Soome case mdns_trust_status_pending:
44265ffb0c9bSToomas Soome {
4427*472cd20dSToomas Soome mdns_trust_t trust = mdns_trust_create(request->audit_token, NULL, flags);
4428*472cd20dSToomas Soome if (!trust )
4429*472cd20dSToomas Soome {
4430*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
4431*472cd20dSToomas Soome goto exit;
4432*472cd20dSToomas Soome }
4433*472cd20dSToomas Soome
4434*472cd20dSToomas Soome void * context = mallocL("context/_handle_addrinfo_request_with_trust", sizeof(_addrinfo_start_params_t));
4435*472cd20dSToomas Soome if (!context)
4436*472cd20dSToomas Soome {
4437*472cd20dSToomas Soome my_perror("ERROR: mallocL context/_handle_addrinfo_request_with_trust");
4438*472cd20dSToomas Soome mdns_release(trust);
4439*472cd20dSToomas Soome err = mStatus_NoMemoryErr;
4440*472cd20dSToomas Soome goto exit;
4441*472cd20dSToomas Soome }
4442*472cd20dSToomas Soome memcpy(context, params, sizeof(_addrinfo_start_params_t));
4443*472cd20dSToomas Soome mdns_trust_set_context(trust, context);
4444*472cd20dSToomas Soome mdns_trust_set_queue(trust, _get_trust_results_dispatch_queue());
4445*472cd20dSToomas Soome mdns_trust_set_event_handler(trust, ^(mdns_trust_event_t event, mdns_trust_status_t update)
4446*472cd20dSToomas Soome {
4447*472cd20dSToomas Soome if (event == mdns_trust_event_result)
4448*472cd20dSToomas Soome {
4449*472cd20dSToomas Soome mStatus error = (update != mdns_trust_status_granted) ? mStatus_PolicyDenied : mStatus_NoError;
4450*472cd20dSToomas Soome KQueueLock();
4451*472cd20dSToomas Soome _addrinfo_start_params_t * _params = mdns_trust_get_context(trust);
4452*472cd20dSToomas Soome if (_params)
4453*472cd20dSToomas Soome {
4454*472cd20dSToomas Soome if (!error)
4455*472cd20dSToomas Soome {
4456*472cd20dSToomas Soome error = _handle_addrinfo_request_start(request, _params);
4457*472cd20dSToomas Soome // No context means the request was canceled before we got here
4458*472cd20dSToomas Soome }
4459*472cd20dSToomas Soome if (error) // (not else if) Always check for error result
4460*472cd20dSToomas Soome {
4461*472cd20dSToomas Soome _return_addrinfo_request_error(request, error);
4462*472cd20dSToomas Soome }
4463*472cd20dSToomas Soome }
4464*472cd20dSToomas Soome KQueueUnlock("_handle_addrinfo_request_with_trust");
4465*472cd20dSToomas Soome }
4466*472cd20dSToomas Soome });
4467*472cd20dSToomas Soome request->trust = trust;
4468*472cd20dSToomas Soome mdns_trust_activate(trust);
4469*472cd20dSToomas Soome err = mStatus_NoError;
4470*472cd20dSToomas Soome break;
44715ffb0c9bSToomas Soome }
4472*472cd20dSToomas Soome
4473*472cd20dSToomas Soome case mdns_trust_status_no_entitlement:
4474*472cd20dSToomas Soome err = mStatus_NoAuth;
4475*472cd20dSToomas Soome break;
4476*472cd20dSToomas Soome
4477*472cd20dSToomas Soome case mdns_trust_status_granted:
4478*472cd20dSToomas Soome err = _handle_addrinfo_request_start(request, params);
4479*472cd20dSToomas Soome break;
4480*472cd20dSToomas Soome
4481*472cd20dSToomas Soome default:
4482*472cd20dSToomas Soome err = mStatus_UnknownErr;
4483*472cd20dSToomas Soome break;
44845ffb0c9bSToomas Soome }
44855ffb0c9bSToomas Soome }
4486*472cd20dSToomas Soome exit:
4487*472cd20dSToomas Soome return err;
44885ffb0c9bSToomas Soome }
4489*472cd20dSToomas Soome #endif // TRUST_ENFORCEMENT
44905ffb0c9bSToomas Soome
handle_addrinfo_request(request_state * request)44915ffb0c9bSToomas Soome mDNSlocal mStatus handle_addrinfo_request(request_state *request)
44925ffb0c9bSToomas Soome {
4493*472cd20dSToomas Soome mStatus err;
4494*472cd20dSToomas Soome DNSServiceFlags flags;
4495*472cd20dSToomas Soome mDNSu32 interfaceIndex;
4496*472cd20dSToomas Soome _addrinfo_start_params_t params;
44975ffb0c9bSToomas Soome
4498*472cd20dSToomas Soome flags = get_flags(&request->msgptr, request->msgend);
4499*472cd20dSToomas Soome interfaceIndex = get_uint32(&request->msgptr, request->msgend);
4500*472cd20dSToomas Soome params.protocols = get_uint32(&request->msgptr, request->msgend);
4501*472cd20dSToomas Soome if (get_string(&request->msgptr, request->msgend, params.hostname, sizeof(params.hostname)) < 0)
45025ffb0c9bSToomas Soome {
4503*472cd20dSToomas Soome err = mStatus_BadParamErr;
4504*472cd20dSToomas Soome goto exit;
45055ffb0c9bSToomas Soome }
4506*472cd20dSToomas Soome if (!request->msgptr)
45075ffb0c9bSToomas Soome {
4508*472cd20dSToomas Soome LogMsg("%3d: DNSServiceGetAddrInfo(unreadable parameters)", request->sd);
4509*472cd20dSToomas Soome err = mStatus_BadParamErr;
4510*472cd20dSToomas Soome goto exit;
45115ffb0c9bSToomas Soome }
4512*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
4513*472cd20dSToomas Soome params.require_privacy = mDNSfalse;
45145ffb0c9bSToomas Soome #endif
4515*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER) && MDNSRESPONDER_SUPPORTS(APPLE, IPC_TLV)
4516*472cd20dSToomas Soome if (request->msgptr && (request->hdr.ipc_flags & IPC_FLAGS_TRAILING_TLVS))
4517*472cd20dSToomas Soome {
4518*472cd20dSToomas Soome size_t len;
4519*472cd20dSToomas Soome const mDNSu8 *const start = (const mDNSu8 *)request->msgptr;
4520*472cd20dSToomas Soome const mDNSu8 *const end = (const mDNSu8 *)request->msgend;
4521*472cd20dSToomas Soome const mDNSu8 *const data = ipc_tlv_get_resolver_config_plist_data(start, end, &len);
4522*472cd20dSToomas Soome if (data)
4523c65ebfc7SToomas Soome {
4524*472cd20dSToomas Soome request->custom_service_id = Querier_RegisterCustomDNSServiceWithPListData(data, len);
45255ffb0c9bSToomas Soome }
4526*472cd20dSToomas Soome params.require_privacy = ipc_tlv_get_require_privacy(start, end);
45275ffb0c9bSToomas Soome }
4528*472cd20dSToomas Soome #endif
4529*472cd20dSToomas Soome request->flags = flags;
4530*472cd20dSToomas Soome request->interfaceIndex = interfaceIndex;
45315ffb0c9bSToomas Soome
4532*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4533*472cd20dSToomas Soome "[R%u] DNSServiceGetAddrInfo(%X, %d, %u, " PRI_S ") START PID[%d](" PUB_S ")",
4534*472cd20dSToomas Soome request->request_id, request->flags, request->interfaceIndex, params.protocols, params.hostname, request->process_id,
4535*472cd20dSToomas Soome request->pid_name);
45365ffb0c9bSToomas Soome
4537*472cd20dSToomas Soome mDNSPlatformMemZero(&request->u.addrinfo, (mDNSu32)sizeof(request->u.addrinfo));
4538*472cd20dSToomas Soome request->terminate = NULL;
4539c65ebfc7SToomas Soome
4540*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, TRUST_ENFORCEMENT)
4541*472cd20dSToomas Soome if (os_feature_enabled(mDNSResponder, bonjour_privacy))
4542*472cd20dSToomas Soome {
4543*472cd20dSToomas Soome err = _handle_addrinfo_request_with_trust(request, ¶ms);
4544*472cd20dSToomas Soome }
4545*472cd20dSToomas Soome else
4546*472cd20dSToomas Soome {
4547*472cd20dSToomas Soome err = _handle_addrinfo_request_start(request, ¶ms);
45485ffb0c9bSToomas Soome }
4549*472cd20dSToomas Soome #else
4550*472cd20dSToomas Soome err = _handle_addrinfo_request_start(request, ¶ms);
4551*472cd20dSToomas Soome #endif
45525ffb0c9bSToomas Soome
4553*472cd20dSToomas Soome exit:
45545ffb0c9bSToomas Soome return(err);
45555ffb0c9bSToomas Soome }
45565ffb0c9bSToomas Soome
45575ffb0c9bSToomas Soome // ***************************************************************************
45585ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
45595ffb0c9bSToomas Soome #pragma mark -
45605ffb0c9bSToomas Soome #pragma mark - Main Request Handler etc.
45615ffb0c9bSToomas Soome #endif
45625ffb0c9bSToomas Soome
NewRequest(void)45635ffb0c9bSToomas Soome mDNSlocal request_state *NewRequest(void)
45645ffb0c9bSToomas Soome {
4565*472cd20dSToomas Soome request_state *request;
45665ffb0c9bSToomas Soome request_state **p = &all_requests;
4567*472cd20dSToomas Soome request = (request_state *) callocL("request_state", sizeof(*request));
4568*472cd20dSToomas Soome if (!request) FatalError("ERROR: calloc");
4569*472cd20dSToomas Soome while (*p) p = &(*p)->next;
4570*472cd20dSToomas Soome *p = request;
4571*472cd20dSToomas Soome return(request);
45725ffb0c9bSToomas Soome }
45735ffb0c9bSToomas Soome
45745ffb0c9bSToomas Soome // read_msg may be called any time when the transfer state (req->ts) is t_morecoming.
45755ffb0c9bSToomas Soome // if there is no data on the socket, the socket will be closed and t_terminated will be returned
read_msg(request_state * req)45765ffb0c9bSToomas Soome mDNSlocal void read_msg(request_state *req)
45775ffb0c9bSToomas Soome {
45785ffb0c9bSToomas Soome if (req->ts == t_terminated || req->ts == t_error)
4579*472cd20dSToomas Soome {
4580*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4581*472cd20dSToomas Soome "[R%u] ERROR: read_msg called with transfer state terminated or error", req->request_id);
4582*472cd20dSToomas Soome req->ts = t_error;
4583*472cd20dSToomas Soome return;
4584*472cd20dSToomas Soome }
45855ffb0c9bSToomas Soome
45865ffb0c9bSToomas Soome if (req->ts == t_complete) // this must be death or something is wrong
45875ffb0c9bSToomas Soome {
45885ffb0c9bSToomas Soome char buf[4]; // dummy for death notification
45895ffb0c9bSToomas Soome int nread = udsSupportReadFD(req->sd, buf, 4, 0, req->platform_data);
45905ffb0c9bSToomas Soome if (!nread) { req->ts = t_terminated; return; }
45915ffb0c9bSToomas Soome if (nread < 0) goto rerror;
4592*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4593*472cd20dSToomas Soome "[R%u] ERROR: read data from a completed request", req->request_id);
45945ffb0c9bSToomas Soome req->ts = t_error;
45955ffb0c9bSToomas Soome return;
45965ffb0c9bSToomas Soome }
45975ffb0c9bSToomas Soome
45985ffb0c9bSToomas Soome if (req->ts != t_morecoming)
4599*472cd20dSToomas Soome {
4600*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4601*472cd20dSToomas Soome "[R%u] ERROR: read_msg called with invalid transfer state (%d)", req->request_id, req->ts);
4602*472cd20dSToomas Soome req->ts = t_error;
4603*472cd20dSToomas Soome return;
4604*472cd20dSToomas Soome }
46055ffb0c9bSToomas Soome
46065ffb0c9bSToomas Soome if (req->hdr_bytes < sizeof(ipc_msg_hdr))
46075ffb0c9bSToomas Soome {
46085ffb0c9bSToomas Soome mDNSu32 nleft = sizeof(ipc_msg_hdr) - req->hdr_bytes;
46095ffb0c9bSToomas Soome int nread = udsSupportReadFD(req->sd, (char *)&req->hdr + req->hdr_bytes, nleft, 0, req->platform_data);
46105ffb0c9bSToomas Soome if (nread == 0) { req->ts = t_terminated; return; }
46115ffb0c9bSToomas Soome if (nread < 0) goto rerror;
46125ffb0c9bSToomas Soome req->hdr_bytes += nread;
46135ffb0c9bSToomas Soome if (req->hdr_bytes > sizeof(ipc_msg_hdr))
4614*472cd20dSToomas Soome {
4615*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4616*472cd20dSToomas Soome "[R%u] ERROR: read_msg - read too many header bytes", req->request_id);
4617*472cd20dSToomas Soome req->ts = t_error;
4618*472cd20dSToomas Soome return;
4619*472cd20dSToomas Soome }
46205ffb0c9bSToomas Soome
46215ffb0c9bSToomas Soome // only read data if header is complete
46225ffb0c9bSToomas Soome if (req->hdr_bytes == sizeof(ipc_msg_hdr))
46235ffb0c9bSToomas Soome {
46245ffb0c9bSToomas Soome ConvertHeaderBytes(&req->hdr);
46255ffb0c9bSToomas Soome if (req->hdr.version != VERSION)
4626*472cd20dSToomas Soome {
4627*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4628*472cd20dSToomas Soome "[R%u] ERROR: client version 0x%08X daemon version 0x%08X", req->request_id, req->hdr.version, VERSION);
4629*472cd20dSToomas Soome req->ts = t_error;
4630*472cd20dSToomas Soome return;
4631*472cd20dSToomas Soome }
46325ffb0c9bSToomas Soome
46335ffb0c9bSToomas Soome // Largest conceivable single request is a DNSServiceRegisterRecord() or DNSServiceAddRecord()
46345ffb0c9bSToomas Soome // with 64kB of rdata. Adding 1009 byte for a maximal domain name, plus a safety margin
46355ffb0c9bSToomas Soome // for other overhead, this means any message above 70kB is definitely bogus.
46365ffb0c9bSToomas Soome if (req->hdr.datalen > 70000)
4637*472cd20dSToomas Soome {
4638*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4639*472cd20dSToomas Soome "[R%u] ERROR: read_msg: hdr.datalen %u (0x%X) > 70000", req->request_id, req->hdr.datalen, req->hdr.datalen);
4640*472cd20dSToomas Soome req->ts = t_error;
4641*472cd20dSToomas Soome return;
4642*472cd20dSToomas Soome }
4643*472cd20dSToomas Soome req->msgbuf = (char *) callocL("request_state msgbuf", req->hdr.datalen + MSG_PAD_BYTES);
4644*472cd20dSToomas Soome if (!req->msgbuf) { my_perror("ERROR: calloc"); req->ts = t_error; return; }
46455ffb0c9bSToomas Soome req->msgptr = req->msgbuf;
46465ffb0c9bSToomas Soome req->msgend = req->msgbuf + req->hdr.datalen;
46475ffb0c9bSToomas Soome }
46485ffb0c9bSToomas Soome }
46495ffb0c9bSToomas Soome
46505ffb0c9bSToomas Soome // If our header is complete, but we're still needing more body data, then try to read it now
46515ffb0c9bSToomas Soome // Note: For cancel_request req->hdr.datalen == 0, but there's no error return socket for cancel_request
46525ffb0c9bSToomas Soome // Any time we need to get the error return socket we know we'll have at least one data byte
46535ffb0c9bSToomas Soome // (even if only the one-byte empty C string placeholder for the old ctrl_path parameter)
46545ffb0c9bSToomas Soome if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes < req->hdr.datalen)
46555ffb0c9bSToomas Soome {
46565ffb0c9bSToomas Soome mDNSu32 nleft = req->hdr.datalen - req->data_bytes;
4657*472cd20dSToomas Soome ssize_t nread;
46585ffb0c9bSToomas Soome #if !defined(_WIN32)
46595ffb0c9bSToomas Soome struct iovec vec = { req->msgbuf + req->data_bytes, nleft }; // Tell recvmsg where we want the bytes put
46605ffb0c9bSToomas Soome struct msghdr msg;
46615ffb0c9bSToomas Soome struct cmsghdr *cmsg;
46625ffb0c9bSToomas Soome char cbuf[CMSG_SPACE(4 * sizeof(dnssd_sock_t))];
46635ffb0c9bSToomas Soome msg.msg_name = 0;
46645ffb0c9bSToomas Soome msg.msg_namelen = 0;
46655ffb0c9bSToomas Soome msg.msg_iov = &vec;
46665ffb0c9bSToomas Soome msg.msg_iovlen = 1;
46675ffb0c9bSToomas Soome msg.msg_control = cbuf;
46685ffb0c9bSToomas Soome msg.msg_controllen = sizeof(cbuf);
46695ffb0c9bSToomas Soome msg.msg_flags = 0;
46705ffb0c9bSToomas Soome nread = recvmsg(req->sd, &msg, 0);
46715ffb0c9bSToomas Soome #else
46725ffb0c9bSToomas Soome nread = udsSupportReadFD(req->sd, (char *)req->msgbuf + req->data_bytes, nleft, 0, req->platform_data);
46735ffb0c9bSToomas Soome #endif
46745ffb0c9bSToomas Soome if (nread == 0) { req->ts = t_terminated; return; }
46755ffb0c9bSToomas Soome if (nread < 0) goto rerror;
46765ffb0c9bSToomas Soome req->data_bytes += nread;
46775ffb0c9bSToomas Soome if (req->data_bytes > req->hdr.datalen)
4678*472cd20dSToomas Soome {
4679*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4680*472cd20dSToomas Soome "[R%u] ERROR: read_msg - read too many data bytes", req->request_id);
4681*472cd20dSToomas Soome req->ts = t_error;
4682*472cd20dSToomas Soome return;
4683*472cd20dSToomas Soome }
46845ffb0c9bSToomas Soome #if !defined(_WIN32)
46855ffb0c9bSToomas Soome cmsg = CMSG_FIRSTHDR(&msg);
46865ffb0c9bSToomas Soome #if DEBUG_64BIT_SCM_RIGHTS
4687*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
4688*472cd20dSToomas Soome "[R%u] Expecting %d %d %d %d", req->request_id, sizeof(cbuf), sizeof(cbuf), SOL_SOCKET, SCM_RIGHTS);
4689*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
4690*472cd20dSToomas Soome "[R%u] Got %d %d %d %d", req->request_id, msg.msg_controllen, cmsg ? cmsg->cmsg_len : -1, cmsg ? cmsg->cmsg_level : -1, cmsg ? cmsg->cmsg_type : -1);
46915ffb0c9bSToomas Soome #endif // DEBUG_64BIT_SCM_RIGHTS
4692cda73f64SToomas Soome if (cmsg && cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS)
46935ffb0c9bSToomas Soome {
46945ffb0c9bSToomas Soome #if APPLE_OSX_mDNSResponder
46955ffb0c9bSToomas Soome // Strictly speaking BPF_fd belongs solely in the platform support layer, but because
46965ffb0c9bSToomas Soome // of privilege separation on Mac OS X we need to get BPF_fd from mDNSResponderHelper,
46975ffb0c9bSToomas Soome // and it's convenient to repurpose the existing fd-passing code here for that task
46985ffb0c9bSToomas Soome if (req->hdr.op == send_bpf)
46995ffb0c9bSToomas Soome {
47005ffb0c9bSToomas Soome dnssd_sock_t x = *(dnssd_sock_t *)CMSG_DATA(cmsg);
4701*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
4702*472cd20dSToomas Soome "[R%u] Got len %d, BPF %d", req->request_id, cmsg->cmsg_len, x);
4703c65ebfc7SToomas Soome mDNSPlatformReceiveBPF_fd(x);
47045ffb0c9bSToomas Soome }
47055ffb0c9bSToomas Soome else
47065ffb0c9bSToomas Soome #endif // APPLE_OSX_mDNSResponder
47075ffb0c9bSToomas Soome req->errsd = *(dnssd_sock_t *)CMSG_DATA(cmsg);
47085ffb0c9bSToomas Soome #if DEBUG_64BIT_SCM_RIGHTS
4709*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT,
4710*472cd20dSToomas Soome "[R%u] read req->errsd %d", req->request_id, req->errsd);
47115ffb0c9bSToomas Soome #endif // DEBUG_64BIT_SCM_RIGHTS
47125ffb0c9bSToomas Soome if (req->data_bytes < req->hdr.datalen)
47135ffb0c9bSToomas Soome {
4714*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEBUG,
4715*472cd20dSToomas Soome "[R%u] Client(PID [%d](" PUB_S ")) sent result code socket %d via SCM_RIGHTS with req->data_bytes %d < req->hdr.datalen %d",
4716*472cd20dSToomas Soome req->request_id, req->process_id, req->pid_name, req->errsd, req->data_bytes, req->hdr.datalen);
47175ffb0c9bSToomas Soome req->ts = t_error;
47185ffb0c9bSToomas Soome return;
47195ffb0c9bSToomas Soome }
47205ffb0c9bSToomas Soome }
47215ffb0c9bSToomas Soome #endif
47225ffb0c9bSToomas Soome }
47235ffb0c9bSToomas Soome
47245ffb0c9bSToomas Soome // If our header and data are both complete, see if we need to make our separate error return socket
47255ffb0c9bSToomas Soome if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes == req->hdr.datalen)
47265ffb0c9bSToomas Soome {
47275ffb0c9bSToomas Soome if (req->terminate && req->hdr.op != cancel_request)
47285ffb0c9bSToomas Soome {
47295ffb0c9bSToomas Soome dnssd_sockaddr_t cliaddr;
47305ffb0c9bSToomas Soome #if defined(USE_TCP_LOOPBACK)
47315ffb0c9bSToomas Soome mDNSOpaque16 port;
47325ffb0c9bSToomas Soome u_long opt = 1;
47335ffb0c9bSToomas Soome port.b[0] = req->msgptr[0];
47345ffb0c9bSToomas Soome port.b[1] = req->msgptr[1];
47355ffb0c9bSToomas Soome req->msgptr += 2;
47365ffb0c9bSToomas Soome cliaddr.sin_family = AF_INET;
47375ffb0c9bSToomas Soome cliaddr.sin_port = port.NotAnInteger;
47385ffb0c9bSToomas Soome cliaddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
47395ffb0c9bSToomas Soome #else
47405ffb0c9bSToomas Soome char ctrl_path[MAX_CTLPATH];
47415ffb0c9bSToomas Soome get_string(&req->msgptr, req->msgend, ctrl_path, MAX_CTLPATH); // path is first element in message buffer
47425ffb0c9bSToomas Soome mDNSPlatformMemZero(&cliaddr, sizeof(cliaddr));
47435ffb0c9bSToomas Soome cliaddr.sun_family = AF_LOCAL;
4744c65ebfc7SToomas Soome mDNSPlatformStrLCopy(cliaddr.sun_path, ctrl_path, sizeof(cliaddr.sun_path));
47455ffb0c9bSToomas Soome // If the error return path UDS name is empty string, that tells us
47465ffb0c9bSToomas Soome // that this is a new version of the library that's going to pass us
47475ffb0c9bSToomas Soome // the error return path socket via sendmsg/recvmsg
47485ffb0c9bSToomas Soome if (ctrl_path[0] == 0)
47495ffb0c9bSToomas Soome {
47505ffb0c9bSToomas Soome if (req->errsd == req->sd)
4751*472cd20dSToomas Soome {
4752*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4753*472cd20dSToomas Soome "[R%u] read_msg: ERROR failed to get errsd via SCM_RIGHTS", req->request_id);
4754*472cd20dSToomas Soome req->ts = t_error;
4755*472cd20dSToomas Soome return;
4756*472cd20dSToomas Soome }
47575ffb0c9bSToomas Soome goto got_errfd;
47585ffb0c9bSToomas Soome }
47595ffb0c9bSToomas Soome #endif
47605ffb0c9bSToomas Soome
47615ffb0c9bSToomas Soome req->errsd = socket(AF_DNSSD, SOCK_STREAM, 0);
4762c65ebfc7SToomas Soome if (!dnssd_SocketValid(req->errsd))
4763c65ebfc7SToomas Soome {
47645ffb0c9bSToomas Soome my_throttled_perror("ERROR: socket");
47655ffb0c9bSToomas Soome req->ts = t_error;
47665ffb0c9bSToomas Soome return;
47675ffb0c9bSToomas Soome }
47685ffb0c9bSToomas Soome
47695ffb0c9bSToomas Soome if (connect(req->errsd, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) < 0)
47705ffb0c9bSToomas Soome {
47715ffb0c9bSToomas Soome #if !defined(USE_TCP_LOOPBACK)
47725ffb0c9bSToomas Soome struct stat sb;
4773*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4774*472cd20dSToomas Soome "[R%u] read_msg: Couldn't connect to error return path socket " PUB_S " errno %d (" PUB_S ")",
4775*472cd20dSToomas Soome req->request_id, cliaddr.sun_path, dnssd_errno, dnssd_strerror(dnssd_errno));
47765ffb0c9bSToomas Soome if (stat(cliaddr.sun_path, &sb) < 0)
4777*472cd20dSToomas Soome {
4778*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4779*472cd20dSToomas Soome "[R%u] read_msg: stat failed " PUB_S " errno %d (" PUB_S ")",
4780*472cd20dSToomas Soome req->request_id, cliaddr.sun_path, dnssd_errno, dnssd_strerror(dnssd_errno));
4781*472cd20dSToomas Soome }
47825ffb0c9bSToomas Soome else
4783*472cd20dSToomas Soome {
4784*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4785*472cd20dSToomas Soome "[R%u] read_msg: file " PUB_S " mode %o (octal) uid %d gid %d",
4786*472cd20dSToomas Soome req->request_id, cliaddr.sun_path, sb.st_mode, sb.st_uid, sb.st_gid);
4787*472cd20dSToomas Soome }
47885ffb0c9bSToomas Soome #endif
47895ffb0c9bSToomas Soome req->ts = t_error;
47905ffb0c9bSToomas Soome return;
47915ffb0c9bSToomas Soome }
47925ffb0c9bSToomas Soome
47935ffb0c9bSToomas Soome #if !defined(USE_TCP_LOOPBACK)
47945ffb0c9bSToomas Soome got_errfd:
47955ffb0c9bSToomas Soome #endif
4796*472cd20dSToomas Soome
47975ffb0c9bSToomas Soome #if defined(_WIN32)
47985ffb0c9bSToomas Soome if (ioctlsocket(req->errsd, FIONBIO, &opt) != 0)
47995ffb0c9bSToomas Soome #else
48005ffb0c9bSToomas Soome if (fcntl(req->errsd, F_SETFL, fcntl(req->errsd, F_GETFL, 0) | O_NONBLOCK) != 0)
48015ffb0c9bSToomas Soome #endif
48025ffb0c9bSToomas Soome {
4803*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4804*472cd20dSToomas Soome "[R%u] ERROR: could not set control socket to non-blocking mode errno %d (" PUB_S ")",
4805*472cd20dSToomas Soome req->request_id, dnssd_errno, dnssd_strerror(dnssd_errno));
48065ffb0c9bSToomas Soome req->ts = t_error;
48075ffb0c9bSToomas Soome return;
48085ffb0c9bSToomas Soome }
48095ffb0c9bSToomas Soome }
48105ffb0c9bSToomas Soome
48115ffb0c9bSToomas Soome req->ts = t_complete;
48125ffb0c9bSToomas Soome }
48135ffb0c9bSToomas Soome
48145ffb0c9bSToomas Soome return;
48155ffb0c9bSToomas Soome
48165ffb0c9bSToomas Soome rerror:
48175ffb0c9bSToomas Soome if (dnssd_errno == dnssd_EWOULDBLOCK || dnssd_errno == dnssd_EINTR) return;
4818*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_ERROR,
4819*472cd20dSToomas Soome "[R%u] ERROR: read_msg errno %d (" PUB_S ")", req->request_id, dnssd_errno, dnssd_strerror(dnssd_errno));
48205ffb0c9bSToomas Soome req->ts = t_error;
48215ffb0c9bSToomas Soome }
48225ffb0c9bSToomas Soome
handle_client_request(request_state * req)4823c65ebfc7SToomas Soome mDNSlocal mStatus handle_client_request(request_state *req)
4824c65ebfc7SToomas Soome {
4825c65ebfc7SToomas Soome mStatus err = mStatus_NoError;
4826*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, AUDIT_TOKEN)
4827*472cd20dSToomas Soome SetupAuditTokenForRequest(req);
4828*472cd20dSToomas Soome #endif
4829c65ebfc7SToomas Soome switch(req->hdr.op)
4830c65ebfc7SToomas Soome {
4831c65ebfc7SToomas Soome // These are all operations that have their own first-class request_state object
4832c65ebfc7SToomas Soome case connection_request:
4833*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4834*472cd20dSToomas Soome "[R%d] DNSServiceCreateConnection START PID[%d](" PUB_S ")",
4835*472cd20dSToomas Soome req->request_id, req->process_id, req->pid_name);
4836c65ebfc7SToomas Soome req->terminate = connection_termination;
4837c65ebfc7SToomas Soome break;
4838c65ebfc7SToomas Soome case connection_delegate_request:
4839*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
4840*472cd20dSToomas Soome "[R%d] DNSServiceCreateDelegateConnection START PID[%d](" PRI_S ")",
4841*472cd20dSToomas Soome req->request_id, req->process_id, req->pid_name);
4842c65ebfc7SToomas Soome req->terminate = connection_termination;
4843c65ebfc7SToomas Soome handle_connection_delegate_request(req);
4844c65ebfc7SToomas Soome break;
4845c65ebfc7SToomas Soome case resolve_request: err = handle_resolve_request (req); break;
4846c65ebfc7SToomas Soome case query_request: err = handle_queryrecord_request (req); break;
4847c65ebfc7SToomas Soome case browse_request: err = handle_browse_request (req); break;
4848c65ebfc7SToomas Soome case reg_service_request: err = handle_regservice_request (req); break;
4849c65ebfc7SToomas Soome case enumeration_request: err = handle_enum_request (req); break;
4850c65ebfc7SToomas Soome case reconfirm_record_request: err = handle_reconfirm_request (req); break;
4851c65ebfc7SToomas Soome case setdomain_request: err = handle_setdomain_request (req); break;
4852c65ebfc7SToomas Soome case getproperty_request: handle_getproperty_request (req); break;
4853c65ebfc7SToomas Soome case port_mapping_request: err = handle_port_mapping_request(req); break;
4854c65ebfc7SToomas Soome case addrinfo_request: err = handle_addrinfo_request (req); break;
4855c65ebfc7SToomas Soome case send_bpf: /* Do nothing for send_bpf */ break;
4856c65ebfc7SToomas Soome
4857c65ebfc7SToomas Soome // These are all operations that work with an existing request_state object
4858c65ebfc7SToomas Soome case reg_record_request: err = handle_regrecord_request (req); break;
4859c65ebfc7SToomas Soome case add_record_request: err = handle_add_request (req); break;
4860c65ebfc7SToomas Soome case update_record_request: err = handle_update_request (req); break;
4861c65ebfc7SToomas Soome case remove_record_request: err = handle_removerecord_request(req); break;
4862c65ebfc7SToomas Soome case cancel_request: handle_cancel_request (req); break;
4863c65ebfc7SToomas Soome case release_request: err = handle_release_request (req); break;
4864c65ebfc7SToomas Soome default: LogMsg("request_callback: %3d:ERROR: Unsupported UDS req:%d PID[%d][%s]",
4865c65ebfc7SToomas Soome req->sd, req->hdr.op, req->process_id, req->pid_name);
4866c65ebfc7SToomas Soome err = mStatus_BadParamErr;
4867c65ebfc7SToomas Soome break;
4868c65ebfc7SToomas Soome }
4869c65ebfc7SToomas Soome
4870c65ebfc7SToomas Soome return err;
4871c65ebfc7SToomas Soome }
4872c65ebfc7SToomas Soome
48735ffb0c9bSToomas Soome #define RecordOrientedOp(X) \
48745ffb0c9bSToomas Soome ((X) == reg_record_request || (X) == add_record_request || (X) == update_record_request || (X) == remove_record_request)
48755ffb0c9bSToomas Soome
48765ffb0c9bSToomas Soome // The lightweight operations are the ones that don't need a dedicated request_state structure allocated for them
48775ffb0c9bSToomas Soome #define LightweightOp(X) (RecordOrientedOp(X) || (X) == cancel_request)
48785ffb0c9bSToomas Soome
request_callback(int fd,void * info)4879*472cd20dSToomas Soome mDNSlocal void request_callback(int fd, void *info)
48805ffb0c9bSToomas Soome {
48815ffb0c9bSToomas Soome mStatus err = 0;
48825ffb0c9bSToomas Soome request_state *req = info;
48835ffb0c9bSToomas Soome mDNSs32 min_size = sizeof(DNSServiceFlags);
48845ffb0c9bSToomas Soome (void)fd; // Unused
48855ffb0c9bSToomas Soome
48865ffb0c9bSToomas Soome for (;;)
48875ffb0c9bSToomas Soome {
48885ffb0c9bSToomas Soome read_msg(req);
4889c65ebfc7SToomas Soome if (req->ts == t_morecoming)
4890c65ebfc7SToomas Soome return;
4891c65ebfc7SToomas Soome if (req->ts == t_terminated || req->ts == t_error)
4892c65ebfc7SToomas Soome {
4893c65ebfc7SToomas Soome AbortUnlinkAndFree(req);
48945ffb0c9bSToomas Soome return;
48955ffb0c9bSToomas Soome }
4896c65ebfc7SToomas Soome if (req->ts != t_complete)
48975ffb0c9bSToomas Soome {
4898c65ebfc7SToomas Soome LogMsg("request_callback: req->ts %d != t_complete PID[%d][%s]", req->ts, req->process_id, req->pid_name);
48995ffb0c9bSToomas Soome AbortUnlinkAndFree(req);
49005ffb0c9bSToomas Soome return;
49015ffb0c9bSToomas Soome }
49025ffb0c9bSToomas Soome
49035ffb0c9bSToomas Soome switch(req->hdr.op) // Interface + other data
49045ffb0c9bSToomas Soome {
49055ffb0c9bSToomas Soome case connection_request: min_size = 0; break;
49065ffb0c9bSToomas Soome case connection_delegate_request: min_size = 4; /* pid */ break;
49075ffb0c9bSToomas Soome case reg_service_request: min_size += sizeof(mDNSu32) + 4 /* name, type, domain, host */ + 4 /* port, textlen */; break;
49085ffb0c9bSToomas Soome case add_record_request: min_size += 4 /* type, rdlen */ + 4 /* ttl */; break;
49095ffb0c9bSToomas Soome case update_record_request: min_size += 2 /* rdlen */ + 4 /* ttl */; break;
49105ffb0c9bSToomas Soome case remove_record_request: break;
49115ffb0c9bSToomas Soome case browse_request: min_size += sizeof(mDNSu32) + 2 /* type, domain */; break;
49125ffb0c9bSToomas Soome case resolve_request: min_size += sizeof(mDNSu32) + 3 /* type, type, domain */; break;
49135ffb0c9bSToomas Soome case query_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 4 /* type, class*/; break;
49145ffb0c9bSToomas Soome case enumeration_request: min_size += sizeof(mDNSu32); break;
49155ffb0c9bSToomas Soome case reg_record_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 6 /* type, class, rdlen */ + 4 /* ttl */; break;
49165ffb0c9bSToomas Soome case reconfirm_record_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 6 /* type, class, rdlen */; break;
49175ffb0c9bSToomas Soome case setdomain_request: min_size += 1 /* domain */; break;
49185ffb0c9bSToomas Soome case getproperty_request: min_size = 2; break;
49195ffb0c9bSToomas Soome case port_mapping_request: min_size += sizeof(mDNSu32) + 4 /* udp/tcp */ + 4 /* int/ext port */ + 4 /* ttl */; break;
49205ffb0c9bSToomas Soome case addrinfo_request: min_size += sizeof(mDNSu32) + 4 /* v4/v6 */ + 1 /* hostname */; break;
49215ffb0c9bSToomas Soome case send_bpf: // Same as cancel_request below
49225ffb0c9bSToomas Soome case cancel_request: min_size = 0; break;
49235ffb0c9bSToomas Soome case release_request: min_size += sizeof(mDNSu32) + 3 /* type, type, domain */; break;
4924c65ebfc7SToomas Soome default: LogMsg("request_callback: ERROR: validate_message - unsupported req type: %d PID[%d][%s]",
4925c65ebfc7SToomas Soome req->hdr.op, req->process_id, req->pid_name);
49265ffb0c9bSToomas Soome min_size = -1; break;
49275ffb0c9bSToomas Soome }
49285ffb0c9bSToomas Soome
49295ffb0c9bSToomas Soome if ((mDNSs32)req->data_bytes < min_size)
4930c65ebfc7SToomas Soome {
4931c65ebfc7SToomas Soome LogMsg("request_callback: Invalid message %d bytes; min for %d is %d PID[%d][%s]",
4932c65ebfc7SToomas Soome req->data_bytes, req->hdr.op, min_size, req->process_id, req->pid_name);
4933c65ebfc7SToomas Soome AbortUnlinkAndFree(req);
4934c65ebfc7SToomas Soome return;
49355ffb0c9bSToomas Soome }
49365ffb0c9bSToomas Soome if (LightweightOp(req->hdr.op) && !req->terminate)
4937c65ebfc7SToomas Soome {
4938c65ebfc7SToomas Soome LogMsg("request_callback: Reg/Add/Update/Remove %d require existing connection PID[%d][%s]",
4939c65ebfc7SToomas Soome req->hdr.op, req->process_id, req->pid_name);
4940c65ebfc7SToomas Soome AbortUnlinkAndFree(req);
4941c65ebfc7SToomas Soome return;
49425ffb0c9bSToomas Soome }
49435ffb0c9bSToomas Soome
49445ffb0c9bSToomas Soome // If req->terminate is already set, this means this operation is sharing an existing connection
49455ffb0c9bSToomas Soome if (req->terminate && !LightweightOp(req->hdr.op))
49465ffb0c9bSToomas Soome {
49475ffb0c9bSToomas Soome request_state *newreq = NewRequest();
49485ffb0c9bSToomas Soome newreq->primary = req;
49495ffb0c9bSToomas Soome newreq->sd = req->sd;
49505ffb0c9bSToomas Soome newreq->errsd = req->errsd;
49515ffb0c9bSToomas Soome newreq->uid = req->uid;
49525ffb0c9bSToomas Soome newreq->hdr = req->hdr;
49535ffb0c9bSToomas Soome newreq->msgbuf = req->msgbuf;
49545ffb0c9bSToomas Soome newreq->msgptr = req->msgptr;
49555ffb0c9bSToomas Soome newreq->msgend = req->msgend;
4956*472cd20dSToomas Soome newreq->request_id = GetNewRequestID();
4957*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, AUDIT_TOKEN)
4958*472cd20dSToomas Soome newreq->audit_token = req->audit_token;
4959*472cd20dSToomas Soome #endif
49605ffb0c9bSToomas Soome // if the parent request is a delegate connection, copy the
49615ffb0c9bSToomas Soome // relevant bits
49625ffb0c9bSToomas Soome if (req->validUUID)
49635ffb0c9bSToomas Soome {
49645ffb0c9bSToomas Soome newreq->validUUID = mDNStrue;
4965c65ebfc7SToomas Soome mDNSPlatformMemCopy(newreq->uuid, req->uuid, UUID_SIZE);
49665ffb0c9bSToomas Soome }
49675ffb0c9bSToomas Soome else
49685ffb0c9bSToomas Soome {
49695ffb0c9bSToomas Soome if (req->process_id)
49705ffb0c9bSToomas Soome {
49715ffb0c9bSToomas Soome newreq->process_id = req->process_id;
4972c65ebfc7SToomas Soome mDNSPlatformStrLCopy(newreq->pid_name, req->pid_name, (mDNSu32)sizeof(newreq->pid_name));
49735ffb0c9bSToomas Soome }
49745ffb0c9bSToomas Soome else
49755ffb0c9bSToomas Soome {
49765ffb0c9bSToomas Soome set_peer_pid(newreq);
49775ffb0c9bSToomas Soome }
49785ffb0c9bSToomas Soome }
49795ffb0c9bSToomas Soome req = newreq;
49805ffb0c9bSToomas Soome }
49815ffb0c9bSToomas Soome
4982cda73f64SToomas Soome // Check if the request wants no asynchronous replies.
4983cda73f64SToomas Soome if (req->hdr.ipc_flags & IPC_FLAGS_NOREPLY) req->no_reply = 1;
4984cda73f64SToomas Soome
49855ffb0c9bSToomas Soome // If we're shutting down, don't allow new client requests
49865ffb0c9bSToomas Soome // We do allow "cancel" and "getproperty" during shutdown
49875ffb0c9bSToomas Soome if (mDNSStorage.ShutdownTime && req->hdr.op != cancel_request && req->hdr.op != getproperty_request)
49885ffb0c9bSToomas Soome err = mStatus_ServiceNotRunning;
49895ffb0c9bSToomas Soome else
4990c65ebfc7SToomas Soome err = handle_client_request(req);
4991c65ebfc7SToomas Soome
49925ffb0c9bSToomas Soome // req->msgbuf may be NULL, e.g. for connection_request or remove_record_request
49935ffb0c9bSToomas Soome if (req->msgbuf) freeL("request_state msgbuf", req->msgbuf);
49945ffb0c9bSToomas Soome
49955ffb0c9bSToomas Soome // There's no return data for a cancel request (DNSServiceRefDeallocate returns no result)
49965ffb0c9bSToomas Soome // For a DNSServiceGetProperty call, the handler already generated the response, so no need to do it again here
49975ffb0c9bSToomas Soome if (req->hdr.op != cancel_request && req->hdr.op != getproperty_request && req->hdr.op != send_bpf && req->hdr.op != getpid_request)
49985ffb0c9bSToomas Soome {
49995ffb0c9bSToomas Soome const mStatus err_netorder = dnssd_htonl(err);
50005ffb0c9bSToomas Soome send_all(req->errsd, (const char *)&err_netorder, sizeof(err_netorder));
50015ffb0c9bSToomas Soome if (req->errsd != req->sd)
50025ffb0c9bSToomas Soome {
50035ffb0c9bSToomas Soome dnssd_close(req->errsd);
50045ffb0c9bSToomas Soome req->errsd = req->sd;
50055ffb0c9bSToomas Soome // Also need to reset the parent's errsd, if this is a subordinate operation
50065ffb0c9bSToomas Soome if (req->primary) req->primary->errsd = req->primary->sd;
50075ffb0c9bSToomas Soome }
50085ffb0c9bSToomas Soome }
50095ffb0c9bSToomas Soome
50105ffb0c9bSToomas Soome // Reset ready to accept the next req on this pipe
50115ffb0c9bSToomas Soome if (req->primary) req = req->primary;
50125ffb0c9bSToomas Soome req->ts = t_morecoming;
50135ffb0c9bSToomas Soome req->hdr_bytes = 0;
50145ffb0c9bSToomas Soome req->data_bytes = 0;
50155ffb0c9bSToomas Soome req->msgbuf = mDNSNULL;
50165ffb0c9bSToomas Soome req->msgptr = mDNSNULL;
50175ffb0c9bSToomas Soome req->msgend = 0;
50185ffb0c9bSToomas Soome }
50195ffb0c9bSToomas Soome }
50205ffb0c9bSToomas Soome
connect_callback(int fd,void * info)5021*472cd20dSToomas Soome mDNSlocal void connect_callback(int fd, void *info)
50225ffb0c9bSToomas Soome {
50235ffb0c9bSToomas Soome dnssd_sockaddr_t cliaddr;
50245ffb0c9bSToomas Soome dnssd_socklen_t len = (dnssd_socklen_t) sizeof(cliaddr);
50255ffb0c9bSToomas Soome dnssd_sock_t sd = accept(fd, (struct sockaddr*) &cliaddr, &len);
50265ffb0c9bSToomas Soome #if defined(SO_NOSIGPIPE) || defined(_WIN32)
50275ffb0c9bSToomas Soome unsigned long optval = 1;
50285ffb0c9bSToomas Soome #endif
50295ffb0c9bSToomas Soome
50305ffb0c9bSToomas Soome (void)info; // Unused
50315ffb0c9bSToomas Soome
50325ffb0c9bSToomas Soome if (!dnssd_SocketValid(sd))
50335ffb0c9bSToomas Soome {
5034c65ebfc7SToomas Soome if (dnssd_errno != dnssd_EWOULDBLOCK)
50355ffb0c9bSToomas Soome my_throttled_perror("ERROR: accept");
50365ffb0c9bSToomas Soome return;
50375ffb0c9bSToomas Soome }
50385ffb0c9bSToomas Soome
50395ffb0c9bSToomas Soome #ifdef SO_NOSIGPIPE
50405ffb0c9bSToomas Soome // Some environments (e.g. OS X) support turning off SIGPIPE for a socket
50415ffb0c9bSToomas Soome if (setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)) < 0)
50425ffb0c9bSToomas Soome LogMsg("%3d: WARNING: setsockopt - SO_NOSIGPIPE %d (%s)", sd, dnssd_errno, dnssd_strerror(dnssd_errno));
50435ffb0c9bSToomas Soome #endif
50445ffb0c9bSToomas Soome
50455ffb0c9bSToomas Soome #if defined(_WIN32)
50465ffb0c9bSToomas Soome if (ioctlsocket(sd, FIONBIO, &optval) != 0)
50475ffb0c9bSToomas Soome #else
50485ffb0c9bSToomas Soome if (fcntl(sd, F_SETFL, fcntl(sd, F_GETFL, 0) | O_NONBLOCK) != 0)
50495ffb0c9bSToomas Soome #endif
50505ffb0c9bSToomas Soome {
50515ffb0c9bSToomas Soome my_perror("ERROR: fcntl(sd, F_SETFL, O_NONBLOCK) - aborting client");
50525ffb0c9bSToomas Soome dnssd_close(sd);
50535ffb0c9bSToomas Soome return;
50545ffb0c9bSToomas Soome }
50555ffb0c9bSToomas Soome else
50565ffb0c9bSToomas Soome {
50575ffb0c9bSToomas Soome request_state *request = NewRequest();
50585ffb0c9bSToomas Soome request->ts = t_morecoming;
50595ffb0c9bSToomas Soome request->sd = sd;
50605ffb0c9bSToomas Soome request->errsd = sd;
5061*472cd20dSToomas Soome request->request_id = GetNewRequestID();
50625ffb0c9bSToomas Soome set_peer_pid(request);
50635ffb0c9bSToomas Soome #if APPLE_OSX_mDNSResponder
50645ffb0c9bSToomas Soome struct xucred x;
50655ffb0c9bSToomas Soome socklen_t xucredlen = sizeof(x);
5066cda73f64SToomas Soome if (getsockopt(sd, 0, LOCAL_PEERCRED, &x, &xucredlen) >= 0 && x.cr_version == XUCRED_VERSION)
5067cda73f64SToomas Soome request->uid = x.cr_uid; // save the effective userid of the client
5068cda73f64SToomas Soome else
5069cda73f64SToomas Soome my_perror("ERROR: getsockopt, LOCAL_PEERCRED");
50705ffb0c9bSToomas Soome debugf("LOCAL_PEERCRED %d %u %u %d", xucredlen, x.cr_version, x.cr_uid, x.cr_ngroups);
50715ffb0c9bSToomas Soome #endif // APPLE_OSX_mDNSResponder
50723b436d06SToomas Soome LogDebug("%3d: connect_callback: Adding FD for uid %u", request->sd, request->uid);
50735ffb0c9bSToomas Soome udsSupportAddFDToEventLoop(sd, request_callback, request, &request->platform_data);
50745ffb0c9bSToomas Soome }
50755ffb0c9bSToomas Soome }
50765ffb0c9bSToomas Soome
uds_socket_setup(dnssd_sock_t skt)50775ffb0c9bSToomas Soome mDNSlocal mDNSBool uds_socket_setup(dnssd_sock_t skt)
50785ffb0c9bSToomas Soome {
50795ffb0c9bSToomas Soome #if defined(SO_NP_EXTENSIONS)
50805ffb0c9bSToomas Soome struct so_np_extensions sonpx;
50815ffb0c9bSToomas Soome socklen_t optlen = sizeof(struct so_np_extensions);
50825ffb0c9bSToomas Soome sonpx.npx_flags = SONPX_SETOPTSHUT;
50835ffb0c9bSToomas Soome sonpx.npx_mask = SONPX_SETOPTSHUT;
50845ffb0c9bSToomas Soome if (setsockopt(skt, SOL_SOCKET, SO_NP_EXTENSIONS, &sonpx, optlen) < 0)
50855ffb0c9bSToomas Soome my_perror("WARNING: could not set sockopt - SO_NP_EXTENSIONS");
50865ffb0c9bSToomas Soome #endif
50875ffb0c9bSToomas Soome #if defined(_WIN32)
50885ffb0c9bSToomas Soome // SEH: do we even need to do this on windows?
50895ffb0c9bSToomas Soome // This socket will be given to WSAEventSelect which will automatically set it to non-blocking
50905ffb0c9bSToomas Soome u_long opt = 1;
50915ffb0c9bSToomas Soome if (ioctlsocket(skt, FIONBIO, &opt) != 0)
50925ffb0c9bSToomas Soome #else
50935ffb0c9bSToomas Soome if (fcntl(skt, F_SETFL, fcntl(skt, F_GETFL, 0) | O_NONBLOCK) != 0)
50945ffb0c9bSToomas Soome #endif
50955ffb0c9bSToomas Soome {
50965ffb0c9bSToomas Soome my_perror("ERROR: could not set listen socket to non-blocking mode");
50975ffb0c9bSToomas Soome return mDNSfalse;
50985ffb0c9bSToomas Soome }
50995ffb0c9bSToomas Soome
51005ffb0c9bSToomas Soome if (listen(skt, LISTENQ) != 0)
51015ffb0c9bSToomas Soome {
51025ffb0c9bSToomas Soome my_perror("ERROR: could not listen on listen socket");
51035ffb0c9bSToomas Soome return mDNSfalse;
51045ffb0c9bSToomas Soome }
51055ffb0c9bSToomas Soome
51065ffb0c9bSToomas Soome if (mStatus_NoError != udsSupportAddFDToEventLoop(skt, connect_callback, (void *) NULL, (void **) NULL))
51075ffb0c9bSToomas Soome {
51085ffb0c9bSToomas Soome my_perror("ERROR: could not add listen socket to event loop");
51095ffb0c9bSToomas Soome return mDNSfalse;
51105ffb0c9bSToomas Soome }
51115ffb0c9bSToomas Soome else
5112c65ebfc7SToomas Soome {
5113cda73f64SToomas Soome LogOperation("%3d: Listening for incoming Unix Domain Socket client requests", skt);
51145ffb0c9bSToomas Soome mDNSStorage.uds_listener_skt = skt;
51155ffb0c9bSToomas Soome }
51165ffb0c9bSToomas Soome return mDNStrue;
51175ffb0c9bSToomas Soome }
51185ffb0c9bSToomas Soome
5119*472cd20dSToomas Soome #if MDNS_MALLOC_DEBUGGING
5120*472cd20dSToomas Soome mDNSlocal void udsserver_validatelists(void *context);
5121*472cd20dSToomas Soome #endif
5122*472cd20dSToomas Soome
udsserver_init(dnssd_sock_t skts[],const size_t count)5123*472cd20dSToomas Soome mDNSexport int udsserver_init(dnssd_sock_t skts[], const size_t count)
51245ffb0c9bSToomas Soome {
51255ffb0c9bSToomas Soome dnssd_sockaddr_t laddr;
51265ffb0c9bSToomas Soome int ret;
51275ffb0c9bSToomas Soome
5128*472cd20dSToomas Soome #ifndef NO_PID_FILE
5129*472cd20dSToomas Soome FILE *fp = fopen(PID_FILE, "w");
5130*472cd20dSToomas Soome if (fp != NULL)
51315ffb0c9bSToomas Soome {
5132*472cd20dSToomas Soome fprintf(fp, "%d\n", getpid());
5133*472cd20dSToomas Soome fclose(fp);
51345ffb0c9bSToomas Soome }
5135*472cd20dSToomas Soome #endif
5136*472cd20dSToomas Soome
5137*472cd20dSToomas Soome #if MDNS_MALLOC_DEBUGGING
5138*472cd20dSToomas Soome static mDNSListValidator validator;
5139*472cd20dSToomas Soome mDNSPlatformAddListValidator(&validator, udsserver_validatelists, "udsserver_validatelists", NULL);
5140*472cd20dSToomas Soome #endif
51415ffb0c9bSToomas Soome
51425ffb0c9bSToomas Soome if (skts)
51435ffb0c9bSToomas Soome {
5144*472cd20dSToomas Soome size_t i;
51455ffb0c9bSToomas Soome for (i = 0; i < count; i++)
51465ffb0c9bSToomas Soome if (dnssd_SocketValid(skts[i]) && !uds_socket_setup(skts[i]))
51475ffb0c9bSToomas Soome goto error;
51485ffb0c9bSToomas Soome }
51495ffb0c9bSToomas Soome else
51505ffb0c9bSToomas Soome {
51515ffb0c9bSToomas Soome listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
51525ffb0c9bSToomas Soome if (!dnssd_SocketValid(listenfd))
51535ffb0c9bSToomas Soome {
51545ffb0c9bSToomas Soome my_perror("ERROR: socket(AF_DNSSD, SOCK_STREAM, 0); failed");
51555ffb0c9bSToomas Soome goto error;
51565ffb0c9bSToomas Soome }
51575ffb0c9bSToomas Soome
51585ffb0c9bSToomas Soome mDNSPlatformMemZero(&laddr, sizeof(laddr));
51595ffb0c9bSToomas Soome
51605ffb0c9bSToomas Soome #if defined(USE_TCP_LOOPBACK)
51615ffb0c9bSToomas Soome {
51625ffb0c9bSToomas Soome laddr.sin_family = AF_INET;
51635ffb0c9bSToomas Soome laddr.sin_port = htons(MDNS_TCP_SERVERPORT);
51645ffb0c9bSToomas Soome laddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
51655ffb0c9bSToomas Soome ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));
51665ffb0c9bSToomas Soome if (ret < 0)
51675ffb0c9bSToomas Soome {
51685ffb0c9bSToomas Soome my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");
51695ffb0c9bSToomas Soome goto error;
51705ffb0c9bSToomas Soome }
51715ffb0c9bSToomas Soome }
51725ffb0c9bSToomas Soome #else
51735ffb0c9bSToomas Soome {
51745ffb0c9bSToomas Soome mode_t mask = umask(0);
5175c65ebfc7SToomas Soome unlink(boundPath); // OK if this fails
51765ffb0c9bSToomas Soome laddr.sun_family = AF_LOCAL;
51775ffb0c9bSToomas Soome #ifndef NOT_HAVE_SA_LEN
51785ffb0c9bSToomas Soome // According to Stevens (section 3.2), there is no portable way to
51795ffb0c9bSToomas Soome // determine whether sa_len is defined on a particular platform.
51805ffb0c9bSToomas Soome laddr.sun_len = sizeof(struct sockaddr_un);
51815ffb0c9bSToomas Soome #endif
5182c65ebfc7SToomas Soome if (strlen(boundPath) >= sizeof(laddr.sun_path))
51835ffb0c9bSToomas Soome {
51845ffb0c9bSToomas Soome LogMsg("ERROR: MDNS_UDS_SERVERPATH must be < %d characters", (int)sizeof(laddr.sun_path));
51855ffb0c9bSToomas Soome goto error;
51865ffb0c9bSToomas Soome }
5187c65ebfc7SToomas Soome mDNSPlatformStrLCopy(laddr.sun_path, boundPath, sizeof(laddr.sun_path));
51885ffb0c9bSToomas Soome ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));
51895ffb0c9bSToomas Soome umask(mask);
51905ffb0c9bSToomas Soome if (ret < 0)
51915ffb0c9bSToomas Soome {
51925ffb0c9bSToomas Soome my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");
51935ffb0c9bSToomas Soome goto error;
51945ffb0c9bSToomas Soome }
51955ffb0c9bSToomas Soome }
51965ffb0c9bSToomas Soome #endif
51975ffb0c9bSToomas Soome
51985ffb0c9bSToomas Soome if (!uds_socket_setup(listenfd)) goto error;
51995ffb0c9bSToomas Soome }
52005ffb0c9bSToomas Soome
52015ffb0c9bSToomas Soome #if !defined(PLATFORM_NO_RLIMIT)
52025ffb0c9bSToomas Soome {
52035ffb0c9bSToomas Soome // Set maximum number of open file descriptors
52045ffb0c9bSToomas Soome #define MIN_OPENFILES 10240
52055ffb0c9bSToomas Soome struct rlimit maxfds, newfds;
52065ffb0c9bSToomas Soome
52075ffb0c9bSToomas Soome // Due to bugs in OS X (<rdar://problem/2941095>, <rdar://problem/3342704>, <rdar://problem/3839173>)
52085ffb0c9bSToomas Soome // you have to get and set rlimits once before getrlimit will return sensible values
52095ffb0c9bSToomas Soome if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
52105ffb0c9bSToomas Soome if (setrlimit(RLIMIT_NOFILE, &maxfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");
52115ffb0c9bSToomas Soome
52125ffb0c9bSToomas Soome if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
52135ffb0c9bSToomas Soome newfds.rlim_max = (maxfds.rlim_max > MIN_OPENFILES) ? maxfds.rlim_max : MIN_OPENFILES;
52145ffb0c9bSToomas Soome newfds.rlim_cur = (maxfds.rlim_cur > MIN_OPENFILES) ? maxfds.rlim_cur : MIN_OPENFILES;
52155ffb0c9bSToomas Soome if (newfds.rlim_max != maxfds.rlim_max || newfds.rlim_cur != maxfds.rlim_cur)
52165ffb0c9bSToomas Soome if (setrlimit(RLIMIT_NOFILE, &newfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");
52175ffb0c9bSToomas Soome
52185ffb0c9bSToomas Soome if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
52195ffb0c9bSToomas Soome debugf("maxfds.rlim_max %d", (long)maxfds.rlim_max);
52205ffb0c9bSToomas Soome debugf("maxfds.rlim_cur %d", (long)maxfds.rlim_cur);
52215ffb0c9bSToomas Soome }
52225ffb0c9bSToomas Soome #endif
52235ffb0c9bSToomas Soome
52245ffb0c9bSToomas Soome // We start a "LocalOnly" query looking for Automatic Browse Domain records.
52255ffb0c9bSToomas Soome // When Domain Enumeration in uDNS.c finds an "lb" record from the network, its "FoundDomain" routine
52265ffb0c9bSToomas Soome // creates a "LocalOnly" record, which results in our AutomaticBrowseDomainChange callback being invoked
52275ffb0c9bSToomas Soome mDNS_GetDomains(&mDNSStorage, &mDNSStorage.AutomaticBrowseDomainQ, mDNS_DomainTypeBrowseAutomatic,
52285ffb0c9bSToomas Soome mDNSNULL, mDNSInterface_LocalOnly, AutomaticBrowseDomainChange, mDNSNULL);
52295ffb0c9bSToomas Soome
52305ffb0c9bSToomas Soome // Add "local" as recommended registration domain ("dns-sd -E"), recommended browsing domain ("dns-sd -F"), and automatic browsing domain
52315ffb0c9bSToomas Soome RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeRegistration);
52325ffb0c9bSToomas Soome RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeBrowse);
52335ffb0c9bSToomas Soome AddAutoBrowseDomain(0, &localdomain);
52345ffb0c9bSToomas Soome
52355ffb0c9bSToomas Soome udsserver_handle_configchange(&mDNSStorage);
52365ffb0c9bSToomas Soome return 0;
52375ffb0c9bSToomas Soome
52385ffb0c9bSToomas Soome error:
52395ffb0c9bSToomas Soome
52405ffb0c9bSToomas Soome my_perror("ERROR: udsserver_init");
52415ffb0c9bSToomas Soome return -1;
52425ffb0c9bSToomas Soome }
52435ffb0c9bSToomas Soome
udsserver_exit(void)52445ffb0c9bSToomas Soome mDNSexport int udsserver_exit(void)
52455ffb0c9bSToomas Soome {
52465ffb0c9bSToomas Soome // Cancel all outstanding client requests
52475ffb0c9bSToomas Soome while (all_requests) AbortUnlinkAndFree(all_requests);
52485ffb0c9bSToomas Soome
52495ffb0c9bSToomas Soome // Clean up any special mDNSInterface_LocalOnly records we created, both the entries for "local" we
52505ffb0c9bSToomas Soome // created in udsserver_init, and others we created as a result of reading local configuration data
52515ffb0c9bSToomas Soome while (LocalDomainEnumRecords)
52525ffb0c9bSToomas Soome {
52535ffb0c9bSToomas Soome ARListElem *rem = LocalDomainEnumRecords;
52545ffb0c9bSToomas Soome LocalDomainEnumRecords = LocalDomainEnumRecords->next;
52555ffb0c9bSToomas Soome mDNS_Deregister(&mDNSStorage, &rem->ar);
52565ffb0c9bSToomas Soome }
52575ffb0c9bSToomas Soome
52585ffb0c9bSToomas Soome // If the launching environment created no listening socket,
52595ffb0c9bSToomas Soome // that means we created it ourselves, so we should clean it up on exit
52605ffb0c9bSToomas Soome if (dnssd_SocketValid(listenfd))
52615ffb0c9bSToomas Soome {
52625ffb0c9bSToomas Soome dnssd_close(listenfd);
52635ffb0c9bSToomas Soome #if !defined(USE_TCP_LOOPBACK)
52645ffb0c9bSToomas Soome // Currently, we're unable to remove /var/run/mdnsd because we've changed to userid "nobody"
52655ffb0c9bSToomas Soome // to give up unnecessary privilege, but we need to be root to remove this Unix Domain Socket.
52665ffb0c9bSToomas Soome // It would be nice if we could find a solution to this problem
5267c65ebfc7SToomas Soome if (unlink(boundPath))
52685ffb0c9bSToomas Soome debugf("Unable to remove %s", MDNS_UDS_SERVERPATH);
52695ffb0c9bSToomas Soome #endif
52705ffb0c9bSToomas Soome }
52715ffb0c9bSToomas Soome
5272*472cd20dSToomas Soome #ifndef NO_PID_FILE
5273*472cd20dSToomas Soome unlink(PID_FILE);
5274*472cd20dSToomas Soome #endif
52755ffb0c9bSToomas Soome
52765ffb0c9bSToomas Soome return 0;
52775ffb0c9bSToomas Soome }
52785ffb0c9bSToomas Soome
LogClientInfoToFD(int fd,request_state * req)5279*472cd20dSToomas Soome mDNSlocal void LogClientInfoToFD(int fd, request_state *req)
52805ffb0c9bSToomas Soome {
5281*472cd20dSToomas Soome char reqIDStr[14];
5282*472cd20dSToomas Soome char prefix[18];
5283*472cd20dSToomas Soome
5284*472cd20dSToomas Soome mDNS_snprintf(reqIDStr, sizeof(reqIDStr), "[R%u]", req->request_id);
5285*472cd20dSToomas Soome
5286*472cd20dSToomas Soome mDNS_snprintf(prefix, sizeof(prefix), "%-6s %2s", reqIDStr, req->primary ? "->" : "");
5287*472cd20dSToomas Soome
5288*472cd20dSToomas Soome if (!req->terminate)
5289*472cd20dSToomas Soome LogToFD(fd, "%s No operation yet on this socket", prefix);
5290*472cd20dSToomas Soome else if (req->terminate == connection_termination)
5291*472cd20dSToomas Soome {
5292*472cd20dSToomas Soome int num_records = 0, num_ops = 0;
5293*472cd20dSToomas Soome const registered_record_entry *p;
5294*472cd20dSToomas Soome request_state *r;
5295*472cd20dSToomas Soome for (p = req->u.reg_recs; p; p=p->next) num_records++;
5296*472cd20dSToomas Soome for (r = req->next; r; r=r->next) if (r->primary == req) num_ops++;
5297*472cd20dSToomas Soome LogToFD(fd, "%s DNSServiceCreateConnection: %d registered record%s, %d kDNSServiceFlagsShareConnection operation%s PID[%d](%s)",
5298*472cd20dSToomas Soome prefix, num_records, num_records != 1 ? "s" : "", num_ops, num_ops != 1 ? "s" : "",
5299*472cd20dSToomas Soome req->process_id, req->pid_name);
5300*472cd20dSToomas Soome for (p = req->u.reg_recs; p; p=p->next)
5301*472cd20dSToomas Soome LogToFD(fd, " -> DNSServiceRegisterRecord 0x%08X %2d %3d %s PID[%d](%s)",
5302*472cd20dSToomas Soome req->flags, req->interfaceIndex, p->key, ARDisplayString(&mDNSStorage, p->rr), req->process_id, req->pid_name);
5303*472cd20dSToomas Soome for (r = req->next; r; r=r->next) if (r->primary == req) LogClientInfoToFD(fd, r);
5304*472cd20dSToomas Soome }
5305*472cd20dSToomas Soome else if (req->terminate == regservice_termination_callback)
5306*472cd20dSToomas Soome {
5307*472cd20dSToomas Soome service_instance *ptr;
5308*472cd20dSToomas Soome for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
5309*472cd20dSToomas Soome LogToFD(fd, "%-9s DNSServiceRegister 0x%08X %2d %##s %u/%u PID[%d](%s)",
5310*472cd20dSToomas Soome (ptr == req->u.servicereg.instances) ? prefix : "", req->flags, req->interfaceIndex, ptr->srs.RR_SRV.resrec.name->c,
5311*472cd20dSToomas Soome mDNSVal16(req->u.servicereg.port),
5312*472cd20dSToomas Soome SRS_PORT(&ptr->srs), req->process_id, req->pid_name);
5313*472cd20dSToomas Soome }
5314*472cd20dSToomas Soome else if (req->terminate == browse_termination_callback)
5315*472cd20dSToomas Soome {
5316*472cd20dSToomas Soome browser_t *blist;
5317*472cd20dSToomas Soome for (blist = req->u.browser.browsers; blist; blist = blist->next)
5318*472cd20dSToomas Soome LogToFD(fd, "%-9s DNSServiceBrowse 0x%08X %2d %##s PID[%d](%s)",
5319*472cd20dSToomas Soome (blist == req->u.browser.browsers) ? prefix : "", req->flags, req->interfaceIndex, blist->q.qname.c,
5320*472cd20dSToomas Soome req->process_id, req->pid_name);
5321*472cd20dSToomas Soome }
5322*472cd20dSToomas Soome else if (req->terminate == resolve_termination_callback)
5323*472cd20dSToomas Soome LogToFD(fd, "%s DNSServiceResolve 0x%08X %2d %##s PID[%d](%s)",
5324*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex, req->u.resolve.qsrv.qname.c, req->process_id, req->pid_name);
5325*472cd20dSToomas Soome else if (req->terminate == queryrecord_termination_callback)
5326*472cd20dSToomas Soome LogToFD(fd, "%s DNSServiceQueryRecord 0x%08X %2d %##s (%s) PID[%d](%s)",
5327*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex, QueryRecordClientRequestGetQName(&req->u.queryrecord), DNSTypeName(QueryRecordClientRequestGetType(&req->u.queryrecord)), req->process_id, req->pid_name);
5328*472cd20dSToomas Soome else if (req->terminate == enum_termination_callback)
5329*472cd20dSToomas Soome LogToFD(fd, "%s DNSServiceEnumerateDomains 0x%08X %2d %##s PID[%d](%s)",
5330*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex, req->u.enumeration.q_all.qname.c, req->process_id, req->pid_name);
5331*472cd20dSToomas Soome else if (req->terminate == port_mapping_termination_callback)
5332*472cd20dSToomas Soome LogToFD(fd, "%s DNSServiceNATPortMapping 0x%08X %2d %s%s Int %5d Req %5d Ext %.4a:%5d Req TTL %5d Granted TTL %5d PID[%d](%s)",
5333*472cd20dSToomas Soome prefix,
5334*472cd20dSToomas Soome req->flags,
5335*472cd20dSToomas Soome req->interfaceIndex,
5336*472cd20dSToomas Soome req->u.pm.NATinfo.Protocol & NATOp_MapTCP ? "TCP" : " ",
5337*472cd20dSToomas Soome req->u.pm.NATinfo.Protocol & NATOp_MapUDP ? "UDP" : " ",
5338*472cd20dSToomas Soome mDNSVal16(req->u.pm.NATinfo.IntPort),
5339*472cd20dSToomas Soome mDNSVal16(req->u.pm.ReqExt),
5340*472cd20dSToomas Soome &req->u.pm.NATinfo.ExternalAddress,
5341*472cd20dSToomas Soome mDNSVal16(req->u.pm.NATinfo.ExternalPort),
5342*472cd20dSToomas Soome req->u.pm.NATinfo.NATLease,
5343*472cd20dSToomas Soome req->u.pm.NATinfo.Lifetime,
5344*472cd20dSToomas Soome req->process_id, req->pid_name);
5345*472cd20dSToomas Soome else if (req->terminate == addrinfo_termination_callback)
5346*472cd20dSToomas Soome LogToFD(fd, "%s DNSServiceGetAddrInfo 0x%08X %2d %s%s %##s PID[%d](%s)",
5347*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex,
5348*472cd20dSToomas Soome req->u.addrinfo.protocols & kDNSServiceProtocol_IPv4 ? "v4" : " ",
5349*472cd20dSToomas Soome req->u.addrinfo.protocols & kDNSServiceProtocol_IPv6 ? "v6" : " ",
5350*472cd20dSToomas Soome GetAddrInfoClientRequestGetQName(&req->u.addrinfo), req->process_id, req->pid_name);
5351c65ebfc7SToomas Soome else
5352*472cd20dSToomas Soome LogToFD(fd, "%s Unrecognized operation %p", prefix, req->terminate);
5353*472cd20dSToomas Soome }
5354*472cd20dSToomas Soome
LogClientInfo(request_state * req)5355*472cd20dSToomas Soome mDNSlocal void LogClientInfo(request_state *req)
5356*472cd20dSToomas Soome {
5357*472cd20dSToomas Soome char reqIDStr[14];
5358*472cd20dSToomas Soome char prefix[18];
5359*472cd20dSToomas Soome
5360*472cd20dSToomas Soome mDNS_snprintf(reqIDStr, sizeof(reqIDStr), "[R%u]", req->request_id);
5361*472cd20dSToomas Soome
5362*472cd20dSToomas Soome mDNS_snprintf(prefix, sizeof(prefix), "%-6s %2s", reqIDStr, req->primary ? "->" : "");
53635ffb0c9bSToomas Soome
53645ffb0c9bSToomas Soome if (!req->terminate)
5365*472cd20dSToomas Soome LogMsgNoIdent("%s No operation yet on this socket", prefix);
53665ffb0c9bSToomas Soome else if (req->terminate == connection_termination)
53675ffb0c9bSToomas Soome {
53685ffb0c9bSToomas Soome int num_records = 0, num_ops = 0;
53695ffb0c9bSToomas Soome const registered_record_entry *p;
53705ffb0c9bSToomas Soome request_state *r;
53715ffb0c9bSToomas Soome for (p = req->u.reg_recs; p; p=p->next) num_records++;
53725ffb0c9bSToomas Soome for (r = req->next; r; r=r->next) if (r->primary == req) num_ops++;
5373c65ebfc7SToomas Soome LogMsgNoIdent("%s DNSServiceCreateConnection: %d registered record%s, %d kDNSServiceFlagsShareConnection operation%s PID[%d](%s)",
5374*472cd20dSToomas Soome prefix, num_records, num_records != 1 ? "s" : "", num_ops, num_ops != 1 ? "s" : "",
5375*472cd20dSToomas Soome req->process_id, req->pid_name);
53765ffb0c9bSToomas Soome for (p = req->u.reg_recs; p; p=p->next)
5377*472cd20dSToomas Soome LogMsgNoIdent(" -> DNSServiceRegisterRecord 0x%08X %2d %3d %s PID[%d](%s)",
5378*472cd20dSToomas Soome req->flags, req->interfaceIndex, p->key, ARDisplayString(&mDNSStorage, p->rr), req->process_id, req->pid_name);
5379c65ebfc7SToomas Soome for (r = req->next; r; r=r->next) if (r->primary == req) LogClientInfo(r);
53805ffb0c9bSToomas Soome }
53815ffb0c9bSToomas Soome else if (req->terminate == regservice_termination_callback)
53825ffb0c9bSToomas Soome {
53835ffb0c9bSToomas Soome service_instance *ptr;
53845ffb0c9bSToomas Soome for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
5385*472cd20dSToomas Soome LogMsgNoIdent("%-9s DNSServiceRegister 0x%08X %2d %##s %u/%u PID[%d](%s)",
5386*472cd20dSToomas Soome (ptr == req->u.servicereg.instances) ? prefix : "", req->flags, req->interfaceIndex, ptr->srs.RR_SRV.resrec.name->c,
5387*472cd20dSToomas Soome mDNSVal16(req->u.servicereg.port),
5388*472cd20dSToomas Soome SRS_PORT(&ptr->srs), req->process_id, req->pid_name);
53895ffb0c9bSToomas Soome }
53905ffb0c9bSToomas Soome else if (req->terminate == browse_termination_callback)
53915ffb0c9bSToomas Soome {
53925ffb0c9bSToomas Soome browser_t *blist;
53935ffb0c9bSToomas Soome for (blist = req->u.browser.browsers; blist; blist = blist->next)
5394*472cd20dSToomas Soome LogMsgNoIdent("%-9s DNSServiceBrowse 0x%08X %2d %##s PID[%d](%s)",
5395*472cd20dSToomas Soome (blist == req->u.browser.browsers) ? prefix : "", req->flags, req->interfaceIndex, blist->q.qname.c,
5396*472cd20dSToomas Soome req->process_id, req->pid_name);
53975ffb0c9bSToomas Soome }
53985ffb0c9bSToomas Soome else if (req->terminate == resolve_termination_callback)
5399*472cd20dSToomas Soome LogMsgNoIdent("%s DNSServiceResolve 0x%08X %2d %##s PID[%d](%s)",
5400*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex, req->u.resolve.qsrv.qname.c, req->process_id, req->pid_name);
54015ffb0c9bSToomas Soome else if (req->terminate == queryrecord_termination_callback)
5402*472cd20dSToomas Soome LogMsgNoIdent("%s DNSServiceQueryRecord 0x%08X %2d %##s (%s) PID[%d](%s)",
5403*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex, QueryRecordClientRequestGetQName(&req->u.queryrecord), DNSTypeName(QueryRecordClientRequestGetType(&req->u.queryrecord)), req->process_id, req->pid_name);
54045ffb0c9bSToomas Soome else if (req->terminate == enum_termination_callback)
5405*472cd20dSToomas Soome LogMsgNoIdent("%s DNSServiceEnumerateDomains 0x%08X %2d %##s PID[%d](%s)",
5406*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex, req->u.enumeration.q_all.qname.c, req->process_id, req->pid_name);
54075ffb0c9bSToomas Soome else if (req->terminate == port_mapping_termination_callback)
5408*472cd20dSToomas Soome LogMsgNoIdent("%s DNSServiceNATPortMapping 0x%08X %2d %s%s Int %5d Req %5d Ext %.4a:%5d Req TTL %5d Granted TTL %5d PID[%d](%s)",
5409*472cd20dSToomas Soome prefix,
5410*472cd20dSToomas Soome req->flags,
5411*472cd20dSToomas Soome req->interfaceIndex,
5412*472cd20dSToomas Soome req->u.pm.NATinfo.Protocol & NATOp_MapTCP ? "TCP" : " ",
5413*472cd20dSToomas Soome req->u.pm.NATinfo.Protocol & NATOp_MapUDP ? "UDP" : " ",
5414*472cd20dSToomas Soome mDNSVal16(req->u.pm.NATinfo.IntPort),
5415*472cd20dSToomas Soome mDNSVal16(req->u.pm.ReqExt),
5416*472cd20dSToomas Soome &req->u.pm.NATinfo.ExternalAddress,
5417*472cd20dSToomas Soome mDNSVal16(req->u.pm.NATinfo.ExternalPort),
5418*472cd20dSToomas Soome req->u.pm.NATinfo.NATLease,
5419*472cd20dSToomas Soome req->u.pm.NATinfo.Lifetime,
5420*472cd20dSToomas Soome req->process_id, req->pid_name);
54215ffb0c9bSToomas Soome else if (req->terminate == addrinfo_termination_callback)
5422*472cd20dSToomas Soome LogMsgNoIdent("%s DNSServiceGetAddrInfo 0x%08X %2d %s%s %##s PID[%d](%s)",
5423*472cd20dSToomas Soome prefix, req->flags, req->interfaceIndex,
5424*472cd20dSToomas Soome req->u.addrinfo.protocols & kDNSServiceProtocol_IPv4 ? "v4" : " ",
5425*472cd20dSToomas Soome req->u.addrinfo.protocols & kDNSServiceProtocol_IPv6 ? "v6" : " ",
5426*472cd20dSToomas Soome GetAddrInfoClientRequestGetQName(&req->u.addrinfo), req->process_id, req->pid_name);
54275ffb0c9bSToomas Soome else
5428*472cd20dSToomas Soome LogMsgNoIdent("%s Unrecognized operation %p", prefix, req->terminate);
54295ffb0c9bSToomas Soome }
54305ffb0c9bSToomas Soome
GetMcastClients(request_state * req)54315ffb0c9bSToomas Soome mDNSlocal void GetMcastClients(request_state *req)
54325ffb0c9bSToomas Soome {
54335ffb0c9bSToomas Soome if (req->terminate == connection_termination)
54345ffb0c9bSToomas Soome {
54355ffb0c9bSToomas Soome int num_records = 0, num_ops = 0;
54365ffb0c9bSToomas Soome const registered_record_entry *p;
54375ffb0c9bSToomas Soome request_state *r;
5438c65ebfc7SToomas Soome for (p = req->u.reg_recs; p; p=p->next)
54395ffb0c9bSToomas Soome num_records++;
5440c65ebfc7SToomas Soome for (r = req->next; r; r=r->next)
5441c65ebfc7SToomas Soome if (r->primary == req)
54425ffb0c9bSToomas Soome num_ops++;
54435ffb0c9bSToomas Soome for (p = req->u.reg_recs; p; p=p->next)
54445ffb0c9bSToomas Soome {
54455ffb0c9bSToomas Soome if (!AuthRecord_uDNS(p->rr))
54465ffb0c9bSToomas Soome n_mrecords++;
54475ffb0c9bSToomas Soome }
5448c65ebfc7SToomas Soome for (r = req->next; r; r=r->next)
5449c65ebfc7SToomas Soome if (r->primary == req)
54505ffb0c9bSToomas Soome GetMcastClients(r);
54515ffb0c9bSToomas Soome }
54525ffb0c9bSToomas Soome else if (req->terminate == regservice_termination_callback)
54535ffb0c9bSToomas Soome {
54545ffb0c9bSToomas Soome service_instance *ptr;
54555ffb0c9bSToomas Soome for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
54565ffb0c9bSToomas Soome {
54575ffb0c9bSToomas Soome if (!AuthRecord_uDNS(&ptr->srs.RR_SRV))
5458c65ebfc7SToomas Soome n_mrecords++;
54595ffb0c9bSToomas Soome }
54605ffb0c9bSToomas Soome }
54615ffb0c9bSToomas Soome else if (req->terminate == browse_termination_callback)
54625ffb0c9bSToomas Soome {
54635ffb0c9bSToomas Soome browser_t *blist;
54645ffb0c9bSToomas Soome for (blist = req->u.browser.browsers; blist; blist = blist->next)
54655ffb0c9bSToomas Soome {
54665ffb0c9bSToomas Soome if (mDNSOpaque16IsZero(blist->q.TargetQID))
54675ffb0c9bSToomas Soome n_mquests++;
54685ffb0c9bSToomas Soome }
54695ffb0c9bSToomas Soome }
54705ffb0c9bSToomas Soome else if (req->terminate == resolve_termination_callback)
54715ffb0c9bSToomas Soome {
54725ffb0c9bSToomas Soome if ((mDNSOpaque16IsZero(req->u.resolve.qsrv.TargetQID)) && (req->u.resolve.qsrv.ThisQInterval > 0))
54735ffb0c9bSToomas Soome n_mquests++;
54745ffb0c9bSToomas Soome }
54755ffb0c9bSToomas Soome else if (req->terminate == queryrecord_termination_callback)
54765ffb0c9bSToomas Soome {
5477*472cd20dSToomas Soome if (QueryRecordClientRequestIsMulticast(&req->u.queryrecord))
54785ffb0c9bSToomas Soome n_mquests++;
54795ffb0c9bSToomas Soome }
54805ffb0c9bSToomas Soome else if (req->terminate == addrinfo_termination_callback)
54815ffb0c9bSToomas Soome {
5482*472cd20dSToomas Soome if (GetAddrInfoClientRequestIsMulticast(&req->u.addrinfo))
54835ffb0c9bSToomas Soome n_mquests++;
54845ffb0c9bSToomas Soome }
54854b22b933Srs else
54865ffb0c9bSToomas Soome {
54875ffb0c9bSToomas Soome return;
54884b22b933Srs }
54895ffb0c9bSToomas Soome }
54904b22b933Srs
54915ffb0c9bSToomas Soome
LogMcastClientInfo(request_state * req)54925ffb0c9bSToomas Soome mDNSlocal void LogMcastClientInfo(request_state *req)
54935ffb0c9bSToomas Soome {
54945ffb0c9bSToomas Soome if (!req->terminate)
54955ffb0c9bSToomas Soome LogMcastNoIdent("No operation yet on this socket");
54965ffb0c9bSToomas Soome else if (req->terminate == connection_termination)
54974b22b933Srs {
54985ffb0c9bSToomas Soome int num_records = 0, num_ops = 0;
54995ffb0c9bSToomas Soome const registered_record_entry *p;
55005ffb0c9bSToomas Soome request_state *r;
5501c65ebfc7SToomas Soome for (p = req->u.reg_recs; p; p=p->next)
55025ffb0c9bSToomas Soome num_records++;
5503c65ebfc7SToomas Soome for (r = req->next; r; r=r->next)
5504c65ebfc7SToomas Soome if (r->primary == req)
55055ffb0c9bSToomas Soome num_ops++;
55065ffb0c9bSToomas Soome for (p = req->u.reg_recs; p; p=p->next)
55075ffb0c9bSToomas Soome {
55085ffb0c9bSToomas Soome if (!AuthRecord_uDNS(p->rr))
5509c65ebfc7SToomas Soome LogMcastNoIdent("R: -> DNSServiceRegisterRecord: %##s %s PID[%d](%s)", p->rr->resrec.name->c,
55105ffb0c9bSToomas Soome DNSTypeName(p->rr->resrec.rrtype), req->process_id, req->pid_name, i_mcount++);
55115ffb0c9bSToomas Soome }
5512c65ebfc7SToomas Soome for (r = req->next; r; r=r->next)
5513c65ebfc7SToomas Soome if (r->primary == req)
55145ffb0c9bSToomas Soome LogMcastClientInfo(r);
55155ffb0c9bSToomas Soome }
55165ffb0c9bSToomas Soome else if (req->terminate == regservice_termination_callback)
55174b22b933Srs {
55185ffb0c9bSToomas Soome service_instance *ptr;
55195ffb0c9bSToomas Soome for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
55204b22b933Srs {
5521c65ebfc7SToomas Soome if (!AuthRecord_uDNS(&ptr->srs.RR_SRV))
5522c65ebfc7SToomas Soome LogMcastNoIdent("R: DNSServiceRegister: %##s %u/%u PID[%d](%s)", ptr->srs.RR_SRV.resrec.name->c, mDNSVal16(req->u.servicereg.port),
55235ffb0c9bSToomas Soome SRS_PORT(&ptr->srs), req->process_id, req->pid_name, i_mcount++);
55244b22b933Srs }
55255ffb0c9bSToomas Soome }
55265ffb0c9bSToomas Soome else if (req->terminate == browse_termination_callback)
55275ffb0c9bSToomas Soome {
55285ffb0c9bSToomas Soome browser_t *blist;
55295ffb0c9bSToomas Soome for (blist = req->u.browser.browsers; blist; blist = blist->next)
55304b22b933Srs {
55315ffb0c9bSToomas Soome if (mDNSOpaque16IsZero(blist->q.TargetQID))
55325ffb0c9bSToomas Soome LogMcastNoIdent("Q: DNSServiceBrowse %##s %s PID[%d](%s)", blist->q.qname.c, DNSTypeName(blist->q.qtype),
55335ffb0c9bSToomas Soome req->process_id, req->pid_name, i_mcount++);
55344b22b933Srs }
55354b22b933Srs }
55365ffb0c9bSToomas Soome else if (req->terminate == resolve_termination_callback)
55375ffb0c9bSToomas Soome {
55385ffb0c9bSToomas Soome if ((mDNSOpaque16IsZero(req->u.resolve.qsrv.TargetQID)) && (req->u.resolve.qsrv.ThisQInterval > 0))
55395ffb0c9bSToomas Soome LogMcastNoIdent("Q: DNSServiceResolve %##s %s PID[%d](%s)", req->u.resolve.qsrv.qname.c, DNSTypeName(req->u.resolve.qsrv.qtype),
55405ffb0c9bSToomas Soome req->process_id, req->pid_name, i_mcount++);
55415ffb0c9bSToomas Soome }
55425ffb0c9bSToomas Soome else if (req->terminate == queryrecord_termination_callback)
55435ffb0c9bSToomas Soome {
5544*472cd20dSToomas Soome if (QueryRecordClientRequestIsMulticast(&req->u.queryrecord))
5545*472cd20dSToomas Soome {
5546*472cd20dSToomas Soome LogMcastNoIdent("Q: DNSServiceQueryRecord %##s %s PID[%d](%s)",
5547*472cd20dSToomas Soome QueryRecordClientRequestGetQName(&req->u.queryrecord),
5548*472cd20dSToomas Soome DNSTypeName(QueryRecordClientRequestGetType(&req->u.queryrecord)),
55495ffb0c9bSToomas Soome req->process_id, req->pid_name, i_mcount++);
5550*472cd20dSToomas Soome }
55515ffb0c9bSToomas Soome }
55525ffb0c9bSToomas Soome else if (req->terminate == addrinfo_termination_callback)
55535ffb0c9bSToomas Soome {
5554*472cd20dSToomas Soome if (GetAddrInfoClientRequestIsMulticast(&req->u.addrinfo))
5555*472cd20dSToomas Soome {
55565ffb0c9bSToomas Soome LogMcastNoIdent("Q: DNSServiceGetAddrInfo %s%s %##s PID[%d](%s)",
5557*472cd20dSToomas Soome req->u.addrinfo.protocols & kDNSServiceProtocol_IPv4 ? "v4" : " ",
5558*472cd20dSToomas Soome req->u.addrinfo.protocols & kDNSServiceProtocol_IPv6 ? "v6" : " ",
5559*472cd20dSToomas Soome GetAddrInfoClientRequestGetQName(&req->u.addrinfo), req->process_id, req->pid_name, i_mcount++);
5560*472cd20dSToomas Soome }
55614b22b933Srs }
55625ffb0c9bSToomas Soome }
55634b22b933Srs
RecordTypeName(mDNSu8 rtype)55645ffb0c9bSToomas Soome mDNSlocal char *RecordTypeName(mDNSu8 rtype)
55655ffb0c9bSToomas Soome {
55665ffb0c9bSToomas Soome switch (rtype)
55674b22b933Srs {
55685ffb0c9bSToomas Soome case kDNSRecordTypeUnregistered: return ("Unregistered ");
55695ffb0c9bSToomas Soome case kDNSRecordTypeDeregistering: return ("Deregistering");
55705ffb0c9bSToomas Soome case kDNSRecordTypeUnique: return ("Unique ");
55715ffb0c9bSToomas Soome case kDNSRecordTypeAdvisory: return ("Advisory ");
55725ffb0c9bSToomas Soome case kDNSRecordTypeShared: return ("Shared ");
55735ffb0c9bSToomas Soome case kDNSRecordTypeVerified: return ("Verified ");
55745ffb0c9bSToomas Soome case kDNSRecordTypeKnownUnique: return ("KnownUnique ");
55755ffb0c9bSToomas Soome default: return("Unknown");
55764b22b933Srs }
55775ffb0c9bSToomas Soome }
55785ffb0c9bSToomas Soome
LogEtcHostsToFD(int fd,mDNS * const m)5579*472cd20dSToomas Soome mDNSlocal int LogEtcHostsToFD(int fd, mDNS *const m)
55805ffb0c9bSToomas Soome {
55815ffb0c9bSToomas Soome mDNSBool showheader = mDNStrue;
55825ffb0c9bSToomas Soome const AuthRecord *ar;
55835ffb0c9bSToomas Soome mDNSu32 slot;
55845ffb0c9bSToomas Soome AuthGroup *ag;
55855ffb0c9bSToomas Soome int count = 0;
55865ffb0c9bSToomas Soome int authslot = 0;
55875ffb0c9bSToomas Soome mDNSBool truncated = 0;
55885ffb0c9bSToomas Soome
55895ffb0c9bSToomas Soome for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
55904b22b933Srs {
55915ffb0c9bSToomas Soome if (m->rrauth.rrauth_hash[slot]) authslot++;
55925ffb0c9bSToomas Soome for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next)
55935ffb0c9bSToomas Soome for (ar = ag->members; ar; ar = ar->next)
55945ffb0c9bSToomas Soome {
55955ffb0c9bSToomas Soome if (ar->RecordCallback != FreeEtcHosts) continue;
5596*472cd20dSToomas Soome if (showheader) { showheader = mDNSfalse; LogToFD(fd, " State Interface"); }
55974b22b933Srs
55985ffb0c9bSToomas Soome // Print a maximum of 50 records
55995ffb0c9bSToomas Soome if (count++ >= 50) { truncated = mDNStrue; continue; }
56005ffb0c9bSToomas Soome if (ar->ARType == AuthRecordLocalOnly)
56015ffb0c9bSToomas Soome {
56025ffb0c9bSToomas Soome if (ar->resrec.InterfaceID == mDNSInterface_LocalOnly)
5603*472cd20dSToomas Soome LogToFD(fd, " %s LO %s", RecordTypeName(ar->resrec.RecordType), ARDisplayString(m, ar));
56045ffb0c9bSToomas Soome else
56055ffb0c9bSToomas Soome {
56065ffb0c9bSToomas Soome mDNSu32 scopeid = (mDNSu32)(uintptr_t)ar->resrec.InterfaceID;
5607*472cd20dSToomas Soome LogToFD(fd, " %s %u %s", RecordTypeName(ar->resrec.RecordType), scopeid, ARDisplayString(m, ar));
56085ffb0c9bSToomas Soome }
56095ffb0c9bSToomas Soome }
56105ffb0c9bSToomas Soome }
56114b22b933Srs }
56124b22b933Srs
5613*472cd20dSToomas Soome if (showheader) LogToFD(fd, "<None>");
5614*472cd20dSToomas Soome else if (truncated) LogToFD(fd, "<Truncated: to 50 records, Total records %d, Total Auth Groups %d, Auth Slots %d>", count, m->rrauth.rrauth_totalused, authslot);
5615c65ebfc7SToomas Soome return count;
56165ffb0c9bSToomas Soome }
56174b22b933Srs
LogLocalOnlyAuthRecordsToFD(int fd,mDNS * const m)5618*472cd20dSToomas Soome mDNSlocal void LogLocalOnlyAuthRecordsToFD(int fd, mDNS *const m)
56195ffb0c9bSToomas Soome {
56205ffb0c9bSToomas Soome mDNSBool showheader = mDNStrue;
56215ffb0c9bSToomas Soome const AuthRecord *ar;
56225ffb0c9bSToomas Soome mDNSu32 slot;
56235ffb0c9bSToomas Soome AuthGroup *ag;
56244b22b933Srs
56255ffb0c9bSToomas Soome for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
56264b22b933Srs {
56275ffb0c9bSToomas Soome for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next)
56285ffb0c9bSToomas Soome for (ar = ag->members; ar; ar = ar->next)
56295ffb0c9bSToomas Soome {
56305ffb0c9bSToomas Soome if (ar->RecordCallback == FreeEtcHosts) continue;
5631*472cd20dSToomas Soome if (showheader) { showheader = mDNSfalse; LogToFD(fd, " State Interface"); }
56325ffb0c9bSToomas Soome
56335ffb0c9bSToomas Soome // Print a maximum of 400 records
56345ffb0c9bSToomas Soome if (ar->ARType == AuthRecordLocalOnly)
5635*472cd20dSToomas Soome LogToFD(fd, " %s LO %s", RecordTypeName(ar->resrec.RecordType), ARDisplayString(m, ar));
56365ffb0c9bSToomas Soome else if (ar->ARType == AuthRecordP2P)
5637c65ebfc7SToomas Soome {
5638c65ebfc7SToomas Soome if (ar->resrec.InterfaceID == mDNSInterface_BLE)
5639*472cd20dSToomas Soome LogToFD(fd, " %s BLE %s", RecordTypeName(ar->resrec.RecordType), ARDisplayString(m, ar));
5640c65ebfc7SToomas Soome else
5641*472cd20dSToomas Soome LogToFD(fd, " %s PP %s", RecordTypeName(ar->resrec.RecordType), ARDisplayString(m, ar));
5642c65ebfc7SToomas Soome }
56435ffb0c9bSToomas Soome }
56444b22b933Srs }
56454b22b933Srs
5646*472cd20dSToomas Soome if (showheader) LogToFD(fd, "<None>");
56475ffb0c9bSToomas Soome }
56484b22b933Srs
LogOneAuthRecordToFD(int fd,const AuthRecord * ar,mDNSs32 now,const char * ifname)5649*472cd20dSToomas Soome mDNSlocal void LogOneAuthRecordToFD(int fd, const AuthRecord *ar, mDNSs32 now, const char *ifname)
56505ffb0c9bSToomas Soome {
56515ffb0c9bSToomas Soome if (AuthRecord_uDNS(ar))
56525ffb0c9bSToomas Soome {
5653*472cd20dSToomas Soome LogToFD(fd, "%7d %7d %7d %-7s %4d %s %s",
5654*472cd20dSToomas Soome ar->ThisAPInterval / mDNSPlatformOneSecond,
5655*472cd20dSToomas Soome (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond,
5656*472cd20dSToomas Soome ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0,
5657*472cd20dSToomas Soome "-U-",
5658*472cd20dSToomas Soome ar->state,
5659*472cd20dSToomas Soome ar->AllowRemoteQuery ? "☠" : " ",
5660*472cd20dSToomas Soome ARDisplayString(&mDNSStorage, ar));
56615ffb0c9bSToomas Soome }
56624b22b933Srs else
56635ffb0c9bSToomas Soome {
5664*472cd20dSToomas Soome LogToFD(fd, "%7d %7d %7d %-7s 0x%02X %s %s",
5665*472cd20dSToomas Soome ar->ThisAPInterval / mDNSPlatformOneSecond,
5666*472cd20dSToomas Soome ar->AnnounceCount ? (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond : 0,
5667*472cd20dSToomas Soome ar->TimeExpire ? (ar->TimeExpire - now) / mDNSPlatformOneSecond : 0,
5668*472cd20dSToomas Soome ifname ? ifname : "ALL",
5669*472cd20dSToomas Soome ar->resrec.RecordType,
5670*472cd20dSToomas Soome ar->AllowRemoteQuery ? "☠" : " ",
5671*472cd20dSToomas Soome ARDisplayString(&mDNSStorage, ar));
56724b22b933Srs }
56735ffb0c9bSToomas Soome }
56745ffb0c9bSToomas Soome
LogAuthRecordsToFD(int fd,const mDNSs32 now,AuthRecord * ResourceRecords,int * proxy)5675*472cd20dSToomas Soome mDNSlocal void LogAuthRecordsToFD(int fd,
5676*472cd20dSToomas Soome const mDNSs32 now, AuthRecord *ResourceRecords, int *proxy)
56775ffb0c9bSToomas Soome {
56785ffb0c9bSToomas Soome mDNSBool showheader = mDNStrue;
56795ffb0c9bSToomas Soome const AuthRecord *ar;
56805ffb0c9bSToomas Soome OwnerOptData owner = zeroOwner;
56815ffb0c9bSToomas Soome for (ar = ResourceRecords; ar; ar=ar->next)
56824b22b933Srs {
5683c65ebfc7SToomas Soome const char *const ifname = InterfaceNameForID(&mDNSStorage, ar->resrec.InterfaceID);
56845ffb0c9bSToomas Soome if ((ar->WakeUp.HMAC.l[0] != 0) == (proxy != mDNSNULL))
56854b22b933Srs {
5686*472cd20dSToomas Soome if (showheader) { showheader = mDNSfalse; LogToFD(fd, " Int Next Expire if State"); }
56875ffb0c9bSToomas Soome if (proxy) (*proxy)++;
56885ffb0c9bSToomas Soome if (!mDNSPlatformMemSame(&owner, &ar->WakeUp, sizeof(owner)))
56894b22b933Srs {
56905ffb0c9bSToomas Soome owner = ar->WakeUp;
56915ffb0c9bSToomas Soome if (owner.password.l[0])
5692*472cd20dSToomas Soome LogToFD(fd, "Proxying for H-MAC %.6a I-MAC %.6a Password %.6a seq %d", &owner.HMAC, &owner.IMAC, &owner.password, owner.seq);
56935ffb0c9bSToomas Soome else if (!mDNSSameEthAddress(&owner.HMAC, &owner.IMAC))
5694*472cd20dSToomas Soome LogToFD(fd, "Proxying for H-MAC %.6a I-MAC %.6a seq %d", &owner.HMAC, &owner.IMAC, owner.seq);
56955ffb0c9bSToomas Soome else
5696*472cd20dSToomas Soome LogToFD(fd, "Proxying for %.6a seq %d", &owner.HMAC, owner.seq);
56974b22b933Srs }
56985ffb0c9bSToomas Soome if (AuthRecord_uDNS(ar))
56994b22b933Srs {
5700*472cd20dSToomas Soome LogOneAuthRecordToFD(fd, ar, now, ifname);
57014b22b933Srs }
57025ffb0c9bSToomas Soome else if (ar->ARType == AuthRecordLocalOnly)
57035ffb0c9bSToomas Soome {
5704*472cd20dSToomas Soome LogToFD(fd, " LO %s", ARDisplayString(&mDNSStorage, ar));
57055ffb0c9bSToomas Soome }
57065ffb0c9bSToomas Soome else if (ar->ARType == AuthRecordP2P)
57074b22b933Srs {
5708c65ebfc7SToomas Soome if (ar->resrec.InterfaceID == mDNSInterface_BLE)
5709*472cd20dSToomas Soome LogToFD(fd, " BLE %s", ARDisplayString(&mDNSStorage, ar));
5710c65ebfc7SToomas Soome else
5711*472cd20dSToomas Soome LogToFD(fd, " PP %s", ARDisplayString(&mDNSStorage, ar));
57124b22b933Srs }
57135ffb0c9bSToomas Soome else
57144b22b933Srs {
5715*472cd20dSToomas Soome LogOneAuthRecordToFD(fd, ar, now, ifname);
57164b22b933Srs }
57174b22b933Srs }
57185ffb0c9bSToomas Soome }
5719*472cd20dSToomas Soome if (showheader) LogToFD(fd, "<None>");
57205ffb0c9bSToomas Soome }
57215ffb0c9bSToomas Soome
PrintOneCacheRecordToFD(int fd,const CacheRecord * cr,mDNSu32 slot,const mDNSu32 remain,const char * ifname,mDNSu32 * CacheUsed)5722*472cd20dSToomas Soome mDNSlocal void PrintOneCacheRecordToFD(int fd, const CacheRecord *cr, mDNSu32 slot, const mDNSu32 remain, const char *ifname, mDNSu32 *CacheUsed)
57235ffb0c9bSToomas Soome {
5724*472cd20dSToomas Soome LogToFD(fd, "%3d %s%8d %-7s%s %-6s%s",
5725*472cd20dSToomas Soome slot,
5726*472cd20dSToomas Soome cr->CRActiveQuestion ? "*" : " ",
5727*472cd20dSToomas Soome remain,
5728*472cd20dSToomas Soome ifname ? ifname : "-U-",
5729*472cd20dSToomas Soome (cr->resrec.RecordType == kDNSRecordTypePacketNegative) ? "-" :
5730*472cd20dSToomas Soome (cr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ? " " : "+",
5731*472cd20dSToomas Soome DNSTypeName(cr->resrec.rrtype),
5732*472cd20dSToomas Soome CRDisplayString(&mDNSStorage, cr));
57335ffb0c9bSToomas Soome (*CacheUsed)++;
57345ffb0c9bSToomas Soome }
57355ffb0c9bSToomas Soome
PrintCachedRecordsToFD(int fd,const CacheRecord * cr,mDNSu32 slot,const mDNSu32 remain,const char * ifname,mDNSu32 * CacheUsed)5736*472cd20dSToomas Soome mDNSlocal void PrintCachedRecordsToFD(int fd, const CacheRecord *cr, mDNSu32 slot, const mDNSu32 remain, const char *ifname, mDNSu32 *CacheUsed)
57375ffb0c9bSToomas Soome {
57385ffb0c9bSToomas Soome CacheRecord *soa;
57395ffb0c9bSToomas Soome
57405ffb0c9bSToomas Soome soa = cr->soa;
57415ffb0c9bSToomas Soome if (soa)
57425ffb0c9bSToomas Soome {
5743*472cd20dSToomas Soome PrintOneCacheRecordToFD(fd, soa, slot, remain, ifname, CacheUsed);
57445ffb0c9bSToomas Soome }
57455ffb0c9bSToomas Soome }
57464b22b933Srs
LogMDNSStatisticsToFD(int fd,mDNS * const m)5747*472cd20dSToomas Soome mDNSexport void LogMDNSStatisticsToFD(int fd, mDNS *const m)
57485ffb0c9bSToomas Soome {
5749*472cd20dSToomas Soome LogToFD(fd, "--- MDNS Statistics ---");
5750*472cd20dSToomas Soome
5751*472cd20dSToomas Soome LogToFD(fd, "Name Conflicts %u", m->mDNSStats.NameConflicts);
5752*472cd20dSToomas Soome LogToFD(fd, "KnownUnique Name Conflicts %u", m->mDNSStats.KnownUniqueNameConflicts);
5753*472cd20dSToomas Soome LogToFD(fd, "Duplicate Query Suppressions %u", m->mDNSStats.DupQuerySuppressions);
5754*472cd20dSToomas Soome LogToFD(fd, "KA Suppressions %u", m->mDNSStats.KnownAnswerSuppressions);
5755*472cd20dSToomas Soome LogToFD(fd, "KA Multiple Packets %u", m->mDNSStats.KnownAnswerMultiplePkts);
5756*472cd20dSToomas Soome LogToFD(fd, "Poof Cache Deletions %u", m->mDNSStats.PoofCacheDeletions);
5757*472cd20dSToomas Soome LogToFD(fd, "--------------------------------");
5758*472cd20dSToomas Soome
5759*472cd20dSToomas Soome LogToFD(fd, "Multicast packets Sent %u", m->MulticastPacketsSent);
5760*472cd20dSToomas Soome LogToFD(fd, "Multicast packets Received %u", m->MPktNum);
5761*472cd20dSToomas Soome LogToFD(fd, "Remote Subnet packets %u", m->RemoteSubnet);
5762*472cd20dSToomas Soome LogToFD(fd, "QU questions received %u", m->mDNSStats.UnicastBitInQueries);
5763*472cd20dSToomas Soome LogToFD(fd, "Normal multicast questions %u", m->mDNSStats.NormalQueries);
5764*472cd20dSToomas Soome LogToFD(fd, "Answers for questions %u", m->mDNSStats.MatchingAnswersForQueries);
5765*472cd20dSToomas Soome LogToFD(fd, "Unicast responses %u", m->mDNSStats.UnicastResponses);
5766*472cd20dSToomas Soome LogToFD(fd, "Multicast responses %u", m->mDNSStats.MulticastResponses);
5767*472cd20dSToomas Soome LogToFD(fd, "Unicast response Demotions %u", m->mDNSStats.UnicastDemotedToMulticast);
5768*472cd20dSToomas Soome LogToFD(fd, "--------------------------------");
5769*472cd20dSToomas Soome
5770*472cd20dSToomas Soome LogToFD(fd, "Sleeps %u", m->mDNSStats.Sleeps);
5771*472cd20dSToomas Soome LogToFD(fd, "Wakeups %u", m->mDNSStats.Wakes);
5772*472cd20dSToomas Soome LogToFD(fd, "Interface UP events %u", m->mDNSStats.InterfaceUp);
5773*472cd20dSToomas Soome LogToFD(fd, "Interface UP Flap events %u", m->mDNSStats.InterfaceUpFlap);
5774*472cd20dSToomas Soome LogToFD(fd, "Interface Down events %u", m->mDNSStats.InterfaceDown);
5775*472cd20dSToomas Soome LogToFD(fd, "Interface DownFlap events %u", m->mDNSStats.InterfaceDownFlap);
5776*472cd20dSToomas Soome LogToFD(fd, "Cache refresh queries %u", m->mDNSStats.CacheRefreshQueries);
5777*472cd20dSToomas Soome LogToFD(fd, "Cache refreshed %u", m->mDNSStats.CacheRefreshed);
5778*472cd20dSToomas Soome LogToFD(fd, "Wakeup on Resolves %u", m->mDNSStats.WakeOnResolves);
5779*472cd20dSToomas Soome }
57804b22b933Srs
udsserver_info_dump_to_fd(int fd)5781*472cd20dSToomas Soome mDNSexport void udsserver_info_dump_to_fd(int fd)
57825ffb0c9bSToomas Soome {
5783c65ebfc7SToomas Soome mDNS *const m = &mDNSStorage;
57845ffb0c9bSToomas Soome const mDNSs32 now = mDNS_TimeNow(m);
57855ffb0c9bSToomas Soome mDNSu32 CacheUsed = 0, CacheActive = 0, slot;
57865ffb0c9bSToomas Soome int ProxyA = 0, ProxyD = 0;
5787c65ebfc7SToomas Soome mDNSu32 groupCount = 0;
5788c65ebfc7SToomas Soome mDNSu32 mcastRecordCount = 0;
5789c65ebfc7SToomas Soome mDNSu32 ucastRecordCount = 0;
57905ffb0c9bSToomas Soome const CacheGroup *cg;
57915ffb0c9bSToomas Soome const CacheRecord *cr;
57925ffb0c9bSToomas Soome const DNSQuestion *q;
57935ffb0c9bSToomas Soome const DNameListElem *d;
57945ffb0c9bSToomas Soome const SearchListElem *s;
57955ffb0c9bSToomas Soome
5796*472cd20dSToomas Soome LogToFD(fd, "------------ Cache -------------");
5797*472cd20dSToomas Soome LogToFD(fd, "Slt Q TTL if U Type rdlen");
57985ffb0c9bSToomas Soome for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
57995ffb0c9bSToomas Soome {
58005ffb0c9bSToomas Soome for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)
58014b22b933Srs {
5802c65ebfc7SToomas Soome groupCount++; // Count one cache entity for the CacheGroup object
58035ffb0c9bSToomas Soome for (cr = cg->members; cr; cr=cr->next)
58045ffb0c9bSToomas Soome {
58055ffb0c9bSToomas Soome const mDNSs32 remain = cr->resrec.rroriginalttl - (now - cr->TimeRcvd) / mDNSPlatformOneSecond;
58065ffb0c9bSToomas Soome const char *ifname;
58075ffb0c9bSToomas Soome mDNSInterfaceID InterfaceID = cr->resrec.InterfaceID;
5808c65ebfc7SToomas Soome mDNSu32 *const countPtr = InterfaceID ? &mcastRecordCount : &ucastRecordCount;
5809*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
5810*472cd20dSToomas Soome if (!InterfaceID && cr->resrec.dnsservice &&
5811*472cd20dSToomas Soome (mdns_dns_service_get_scope(cr->resrec.dnsservice) == mdns_dns_service_scope_interface))
5812*472cd20dSToomas Soome {
5813*472cd20dSToomas Soome InterfaceID = (mDNSInterfaceID)(uintptr_t)mdns_dns_service_get_interface_index(cr->resrec.dnsservice);
5814*472cd20dSToomas Soome }
5815*472cd20dSToomas Soome #else
5816*472cd20dSToomas Soome if (!InterfaceID && cr->resrec.rDNSServer && cr->resrec.rDNSServer->scopeType)
58175ffb0c9bSToomas Soome InterfaceID = cr->resrec.rDNSServer->interface;
5818*472cd20dSToomas Soome #endif
58195ffb0c9bSToomas Soome ifname = InterfaceNameForID(m, InterfaceID);
58205ffb0c9bSToomas Soome if (cr->CRActiveQuestion) CacheActive++;
5821*472cd20dSToomas Soome PrintOneCacheRecordToFD(fd, cr, slot, remain, ifname, countPtr);
5822*472cd20dSToomas Soome PrintCachedRecordsToFD(fd, cr, slot, remain, ifname, countPtr);
58235ffb0c9bSToomas Soome }
58244b22b933Srs }
58255ffb0c9bSToomas Soome }
58265ffb0c9bSToomas Soome
5827c65ebfc7SToomas Soome CacheUsed = groupCount + mcastRecordCount + ucastRecordCount;
58285ffb0c9bSToomas Soome if (m->rrcache_totalused != CacheUsed)
5829*472cd20dSToomas Soome LogToFD(fd, "Cache use mismatch: rrcache_totalused is %lu, true count %lu", m->rrcache_totalused, CacheUsed);
58305ffb0c9bSToomas Soome if (m->rrcache_active != CacheActive)
5831*472cd20dSToomas Soome LogToFD(fd, "Cache use mismatch: rrcache_active is %lu, true count %lu", m->rrcache_active, CacheActive);
5832*472cd20dSToomas Soome LogToFD(fd, "Cache size %u entities; %u in use (%u group, %u multicast, %u unicast); %u referenced by active questions",
5833*472cd20dSToomas Soome m->rrcache_size, CacheUsed, groupCount, mcastRecordCount, ucastRecordCount, CacheActive);
58345ffb0c9bSToomas Soome
5835*472cd20dSToomas Soome LogToFD(fd, "--------- Auth Records ---------");
5836*472cd20dSToomas Soome LogAuthRecordsToFD(fd, now, m->ResourceRecords, mDNSNULL);
58375ffb0c9bSToomas Soome
5838*472cd20dSToomas Soome LogToFD(fd, "--------- LocalOnly, P2P Auth Records ---------");
5839*472cd20dSToomas Soome LogLocalOnlyAuthRecordsToFD(fd, m);
58405ffb0c9bSToomas Soome
5841*472cd20dSToomas Soome LogToFD(fd, "--------- /etc/hosts ---------");
5842*472cd20dSToomas Soome LogEtcHostsToFD(fd, m);
58435ffb0c9bSToomas Soome
5844*472cd20dSToomas Soome LogToFD(fd, "------ Duplicate Records -------");
5845*472cd20dSToomas Soome LogAuthRecordsToFD(fd, now, m->DuplicateRecords, mDNSNULL);
58465ffb0c9bSToomas Soome
5847*472cd20dSToomas Soome LogToFD(fd, "----- Auth Records Proxied -----");
5848*472cd20dSToomas Soome LogAuthRecordsToFD(fd, now, m->ResourceRecords, &ProxyA);
58495ffb0c9bSToomas Soome
5850*472cd20dSToomas Soome LogToFD(fd, "-- Duplicate Records Proxied ---");
5851*472cd20dSToomas Soome LogAuthRecordsToFD(fd, now, m->DuplicateRecords, &ProxyD);
58525ffb0c9bSToomas Soome
5853*472cd20dSToomas Soome LogToFD(fd, "---------- Questions -----------");
5854*472cd20dSToomas Soome if (!m->Questions) LogToFD(fd, "<None>");
58555ffb0c9bSToomas Soome else
58565ffb0c9bSToomas Soome {
58575ffb0c9bSToomas Soome CacheUsed = 0;
58585ffb0c9bSToomas Soome CacheActive = 0;
5859*472cd20dSToomas Soome LogToFD(fd, " Int Next if T NumAns VDNS Qptr DupOf SU SQ Type Name");
58605ffb0c9bSToomas Soome for (q = m->Questions; q; q=q->next)
58614b22b933Srs {
58625ffb0c9bSToomas Soome mDNSs32 i = q->ThisQInterval / mDNSPlatformOneSecond;
58635ffb0c9bSToomas Soome mDNSs32 n = (NextQSendTime(q) - now) / mDNSPlatformOneSecond;
58645ffb0c9bSToomas Soome char *ifname = InterfaceNameForID(m, q->InterfaceID);
58655ffb0c9bSToomas Soome CacheUsed++;
58665ffb0c9bSToomas Soome if (q->ThisQInterval) CacheActive++;
5867*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
5868*472cd20dSToomas Soome LogToFD(fd, "%6d%6d %-7s%s %5d 0x%p 0x%p %1d %2d %-5s%##s%s",
5869*472cd20dSToomas Soome #else
5870*472cd20dSToomas Soome LogToFD(fd, "%6d%6d %-7s%s %5d 0x%08x%08x%08x%08x 0x%p 0x%p %1d %2d %-5s%##s%s",
5871*472cd20dSToomas Soome #endif
5872*472cd20dSToomas Soome i, n,
5873*472cd20dSToomas Soome ifname ? ifname : mDNSOpaque16IsZero(q->TargetQID) ? "" : "-U-",
5874*472cd20dSToomas Soome mDNSOpaque16IsZero(q->TargetQID) ? (q->LongLived ? "l" : " ") : (q->LongLived ? "L" : "O"),
5875*472cd20dSToomas Soome q->CurrentAnswers,
5876*472cd20dSToomas Soome #if !MDNSRESPONDER_SUPPORTS(APPLE, QUERIER)
5877*472cd20dSToomas Soome q->validDNSServers.l[3], q->validDNSServers.l[2], q->validDNSServers.l[1], q->validDNSServers.l[0],
5878*472cd20dSToomas Soome #endif
5879*472cd20dSToomas Soome q, q->DuplicateOf,
5880*472cd20dSToomas Soome q->SuppressUnusable, q->Suppressed, DNSTypeName(q->qtype), q->qname.c,
5881*472cd20dSToomas Soome q->DuplicateOf ? " (dup)" : "");
5882*472cd20dSToomas Soome }
5883*472cd20dSToomas Soome LogToFD(fd, "%lu question%s; %lu active", CacheUsed, CacheUsed > 1 ? "s" : "", CacheActive);
5884*472cd20dSToomas Soome }
5885*472cd20dSToomas Soome
5886*472cd20dSToomas Soome LogToFD(fd, "----- LocalOnly, P2P Questions -----");
5887*472cd20dSToomas Soome if (!m->LocalOnlyQuestions) LogToFD(fd, "<None>");
58885ffb0c9bSToomas Soome else for (q = m->LocalOnlyQuestions; q; q=q->next)
5889*472cd20dSToomas Soome LogToFD(fd, " %3s %5d %-6s%##s%s",
5890*472cd20dSToomas Soome q->InterfaceID == mDNSInterface_LocalOnly ? "LO ": q->InterfaceID == mDNSInterface_BLE ? "BLE": "P2P",
5891*472cd20dSToomas Soome q->CurrentAnswers, DNSTypeName(q->qtype), q->qname.c, q->DuplicateOf ? " (dup)" : "");
58925ffb0c9bSToomas Soome
5893*472cd20dSToomas Soome LogToFD(fd, "---- Active UDS Client Requests ----");
5894*472cd20dSToomas Soome if (!all_requests) LogToFD(fd, "<None>");
58955ffb0c9bSToomas Soome else
58965ffb0c9bSToomas Soome {
58975ffb0c9bSToomas Soome request_state *req, *r;
58985ffb0c9bSToomas Soome for (req = all_requests; req; req=req->next)
58995ffb0c9bSToomas Soome {
59005ffb0c9bSToomas Soome if (req->primary) // If this is a subbordinate operation, check that the parent is in the list
59014b22b933Srs {
59025ffb0c9bSToomas Soome for (r = all_requests; r && r != req; r=r->next) if (r == req->primary) goto foundparent;
5903*472cd20dSToomas Soome LogToFD(fd, "%3d: Orhpan operation %p; parent %p not found in request list", req->sd);
59044b22b933Srs }
59055ffb0c9bSToomas Soome // For non-subbordinate operations, and subbordinate operations that have lost their parent, write out their info
5906*472cd20dSToomas Soome LogClientInfoToFD(fd, req);
5907*472cd20dSToomas Soome foundparent:;
59084b22b933Srs }
59094b22b933Srs }
59104b22b933Srs
5911*472cd20dSToomas Soome LogToFD(fd, "-------- NAT Traversals --------");
5912*472cd20dSToomas Soome LogToFD(fd, "ExtAddress %.4a Retry %d Interval %d",
5913*472cd20dSToomas Soome &m->ExtAddress,
5914*472cd20dSToomas Soome m->retryGetAddr ? (m->retryGetAddr - now) / mDNSPlatformOneSecond : 0,
5915*472cd20dSToomas Soome m->retryIntervalGetAddr / mDNSPlatformOneSecond);
59165ffb0c9bSToomas Soome if (m->NATTraversals)
59175ffb0c9bSToomas Soome {
59185ffb0c9bSToomas Soome const NATTraversalInfo *nat;
59195ffb0c9bSToomas Soome for (nat = m->NATTraversals; nat; nat=nat->next)
59204b22b933Srs {
5921*472cd20dSToomas Soome LogToFD(fd, "%p %s Int %5d %s Err %d Retry %5d Interval %5d Expire %5d Req %.4a:%d Ext %.4a:%d",
5922*472cd20dSToomas Soome nat,
5923*472cd20dSToomas Soome nat->Protocol ? (nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP") : "ADD",
5924*472cd20dSToomas Soome mDNSVal16(nat->IntPort),
5925*472cd20dSToomas Soome (nat->lastSuccessfulProtocol == NATTProtocolNone ? "None " :
5926*472cd20dSToomas Soome nat->lastSuccessfulProtocol == NATTProtocolNATPMP ? "NAT-PMP " :
5927*472cd20dSToomas Soome nat->lastSuccessfulProtocol == NATTProtocolUPNPIGD ? "UPnP/IGD" :
5928*472cd20dSToomas Soome nat->lastSuccessfulProtocol == NATTProtocolPCP ? "PCP " :
5929*472cd20dSToomas Soome /* else */ "Unknown " ),
5930*472cd20dSToomas Soome nat->Result,
5931*472cd20dSToomas Soome nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0,
5932*472cd20dSToomas Soome nat->retryInterval / mDNSPlatformOneSecond,
5933*472cd20dSToomas Soome nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0,
5934*472cd20dSToomas Soome &nat->NewAddress, mDNSVal16(nat->RequestedPort),
5935*472cd20dSToomas Soome &nat->ExternalAddress, mDNSVal16(nat->ExternalPort));
5936*472cd20dSToomas Soome }
5937*472cd20dSToomas Soome }
5938*472cd20dSToomas Soome
5939*472cd20dSToomas Soome LogToFD(fd, "--------- AuthInfoList ---------");
5940*472cd20dSToomas Soome if (!m->AuthInfoList) LogToFD(fd, "<None>");
59415ffb0c9bSToomas Soome else
59424b22b933Srs {
59435ffb0c9bSToomas Soome const DomainAuthInfo *a;
59445ffb0c9bSToomas Soome for (a = m->AuthInfoList; a; a = a->next)
59454b22b933Srs {
5946*472cd20dSToomas Soome LogToFD(fd, "%##s %##s %##s %d %d",
5947*472cd20dSToomas Soome a->domain.c, a->keyname.c,
5948*472cd20dSToomas Soome a->hostname.c, (a->port.b[0] << 8 | a->port.b[1]),
5949*472cd20dSToomas Soome (a->deltime ? (a->deltime - now) : 0));
59504b22b933Srs }
59514b22b933Srs }
59524b22b933Srs
5953*472cd20dSToomas Soome LogToFD(fd, "---------- Misc State ----------");
59544b22b933Srs
5955*472cd20dSToomas Soome LogToFD(fd, "PrimaryMAC: %.6a", &m->PrimaryMAC);
59564b22b933Srs
5957*472cd20dSToomas Soome LogToFD(fd, "m->SleepState %d (%s) seq %d",
5958*472cd20dSToomas Soome m->SleepState,
5959*472cd20dSToomas Soome m->SleepState == SleepState_Awake ? "Awake" :
5960*472cd20dSToomas Soome m->SleepState == SleepState_Transferring ? "Transferring" :
5961*472cd20dSToomas Soome m->SleepState == SleepState_Sleeping ? "Sleeping" : "?",
5962*472cd20dSToomas Soome m->SleepSeqNum);
59635ffb0c9bSToomas Soome
5964*472cd20dSToomas Soome if (!m->SPSSocket) LogToFD(fd, "Not offering Sleep Proxy Service");
59655ffb0c9bSToomas Soome #ifndef SPC_DISABLED
5966*472cd20dSToomas Soome else LogToFD(fd, "Offering Sleep Proxy Service: %#s", m->SPSRecords.RR_SRV.resrec.name->c);
59675ffb0c9bSToomas Soome #endif
5968*472cd20dSToomas Soome if (m->ProxyRecords == ProxyA + ProxyD) LogToFD(fd, "ProxyRecords: %d + %d = %d", ProxyA, ProxyD, ProxyA + ProxyD);
5969*472cd20dSToomas Soome else LogToFD(fd, "ProxyRecords: MISMATCH %d + %d = %d ≠ %d", ProxyA, ProxyD, ProxyA + ProxyD, m->ProxyRecords);
59705ffb0c9bSToomas Soome
5971*472cd20dSToomas Soome LogToFD(fd, "------ Auto Browse Domains -----");
5972*472cd20dSToomas Soome if (!AutoBrowseDomains) LogToFD(fd, "<None>");
5973*472cd20dSToomas Soome else for (d=AutoBrowseDomains; d; d=d->next) LogToFD(fd, "%##s", d->name.c);
59745ffb0c9bSToomas Soome
5975*472cd20dSToomas Soome LogToFD(fd, "--- Auto Registration Domains --");
5976*472cd20dSToomas Soome if (!AutoRegistrationDomains) LogToFD(fd, "<None>");
5977*472cd20dSToomas Soome else for (d=AutoRegistrationDomains; d; d=d->next) LogToFD(fd, "%##s", d->name.c);
59785ffb0c9bSToomas Soome
5979*472cd20dSToomas Soome LogToFD(fd, "--- Search Domains --");
5980*472cd20dSToomas Soome if (!SearchList) LogToFD(fd, "<None>");
59815ffb0c9bSToomas Soome else
59825ffb0c9bSToomas Soome {
59835ffb0c9bSToomas Soome for (s=SearchList; s; s=s->next)
59844b22b933Srs {
59855ffb0c9bSToomas Soome char *ifname = InterfaceNameForID(m, s->InterfaceID);
5986*472cd20dSToomas Soome LogToFD(fd, "%##s %s", s->domain.c, ifname ? ifname : "");
59874b22b933Srs }
59884b22b933Srs }
5989*472cd20dSToomas Soome LogMDNSStatisticsToFD(fd, m);
59904b22b933Srs
5991*472cd20dSToomas Soome LogToFD(fd, "---- Task Scheduling Timers ----");
59925ffb0c9bSToomas Soome
5993*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, BONJOUR_ON_DEMAND)
5994*472cd20dSToomas Soome LogToFD(fd, "BonjourEnabled %d", m->BonjourEnabled);
5995*472cd20dSToomas Soome #endif
5996c65ebfc7SToomas Soome
5997c65ebfc7SToomas Soome #if APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
5998*472cd20dSToomas Soome LogToFD(fd, "EnableBLEBasedDiscovery %d", EnableBLEBasedDiscovery);
5999*472cd20dSToomas Soome LogToFD(fd, "DefaultToBLETriggered %d", DefaultToBLETriggered);
6000c65ebfc7SToomas Soome #endif // APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR
6001c65ebfc7SToomas Soome
60025ffb0c9bSToomas Soome if (!m->NewQuestions)
6003*472cd20dSToomas Soome LogToFD(fd, "NewQuestion <NONE>");
60045ffb0c9bSToomas Soome else
6005*472cd20dSToomas Soome LogToFD(fd, "NewQuestion DelayAnswering %d %d %##s (%s)",
6006*472cd20dSToomas Soome m->NewQuestions->DelayAnswering, m->NewQuestions->DelayAnswering-now,
6007*472cd20dSToomas Soome m->NewQuestions->qname.c, DNSTypeName(m->NewQuestions->qtype));
60085ffb0c9bSToomas Soome
60095ffb0c9bSToomas Soome if (!m->NewLocalOnlyQuestions)
6010*472cd20dSToomas Soome LogToFD(fd, "NewLocalOnlyQuestions <NONE>");
60115ffb0c9bSToomas Soome else
6012*472cd20dSToomas Soome LogToFD(fd, "NewLocalOnlyQuestions %##s (%s)",
6013*472cd20dSToomas Soome m->NewLocalOnlyQuestions->qname.c, DNSTypeName(m->NewLocalOnlyQuestions->qtype));
60144b22b933Srs
60155ffb0c9bSToomas Soome if (!m->NewLocalRecords)
6016*472cd20dSToomas Soome LogToFD(fd, "NewLocalRecords <NONE>");
60175ffb0c9bSToomas Soome else
6018*472cd20dSToomas Soome LogToFD(fd, "NewLocalRecords %02X %s", m->NewLocalRecords->resrec.RecordType, ARDisplayString(m, m->NewLocalRecords));
6019*472cd20dSToomas Soome
6020*472cd20dSToomas Soome LogToFD(fd, "SPSProxyListChanged%s", m->SPSProxyListChanged ? "" : " <NONE>");
6021*472cd20dSToomas Soome LogToFD(fd, "LocalRemoveEvents%s", m->LocalRemoveEvents ? "" : " <NONE>");
6022*472cd20dSToomas Soome LogToFD(fd, "m->WABBrowseQueriesCount %d", m->WABBrowseQueriesCount);
6023*472cd20dSToomas Soome LogToFD(fd, "m->WABLBrowseQueriesCount %d", m->WABLBrowseQueriesCount);
6024*472cd20dSToomas Soome LogToFD(fd, "m->WABRegQueriesCount %d", m->WABRegQueriesCount);
6025*472cd20dSToomas Soome LogToFD(fd, "m->AutoTargetServices %u", m->AutoTargetServices);
6026*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, RANDOM_AWDL_HOSTNAME)
6027*472cd20dSToomas Soome LogToFD(fd, "m->AutoTargetAWDLIncludedCount %u", m->AutoTargetAWDLIncludedCount);
6028*472cd20dSToomas Soome LogToFD(fd, "m->AutoTargetAWDLOnlyCount %u", m->AutoTargetAWDLOnlyCount);
6029*472cd20dSToomas Soome #endif
60305ffb0c9bSToomas Soome
6031*472cd20dSToomas Soome LogToFD(fd, " ABS (hex) ABS (dec) REL (hex) REL (dec)");
6032*472cd20dSToomas Soome LogToFD(fd, "m->timenow %08X %11d", now, now);
6033*472cd20dSToomas Soome LogToFD(fd, "m->timenow_adjust %08X %11d", m->timenow_adjust, m->timenow_adjust);
6034*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledEvent ", m->NextScheduledEvent);
60355ffb0c9bSToomas Soome
60365ffb0c9bSToomas Soome #ifndef UNICAST_DISABLED
6037*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextuDNSEvent ", m->NextuDNSEvent);
6038*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextSRVUpdate ", m->NextSRVUpdate);
6039*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledNATOp ", m->NextScheduledNATOp);
6040*472cd20dSToomas Soome LogTimerToFD(fd, "m->retryGetAddr ", m->retryGetAddr);
60415ffb0c9bSToomas Soome #endif
60424b22b933Srs
6043*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextCacheCheck ", m->NextCacheCheck);
6044*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledSPS ", m->NextScheduledSPS);
6045*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledKA ", m->NextScheduledKA);
6046c65ebfc7SToomas Soome
6047*472cd20dSToomas Soome #if MDNSRESPONDER_SUPPORTS(APPLE, BONJOUR_ON_DEMAND)
6048*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextBonjourDisableTime ", m->NextBonjourDisableTime);
6049*472cd20dSToomas Soome #endif
6050c65ebfc7SToomas Soome
6051*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledSPRetry ", m->NextScheduledSPRetry);
6052*472cd20dSToomas Soome LogTimerToFD(fd, "m->DelaySleep ", m->DelaySleep);
60535ffb0c9bSToomas Soome
6054*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledQuery ", m->NextScheduledQuery);
6055*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledProbe ", m->NextScheduledProbe);
6056*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledResponse", m->NextScheduledResponse);
60575ffb0c9bSToomas Soome
6058*472cd20dSToomas Soome LogTimerToFD(fd, "m->SuppressSending ", m->SuppressSending);
6059*472cd20dSToomas Soome LogTimerToFD(fd, "m->SuppressProbes ", m->SuppressProbes);
6060*472cd20dSToomas Soome LogTimerToFD(fd, "m->ProbeFailTime ", m->ProbeFailTime);
6061*472cd20dSToomas Soome LogTimerToFD(fd, "m->DelaySleep ", m->DelaySleep);
6062*472cd20dSToomas Soome LogTimerToFD(fd, "m->SleepLimit ", m->SleepLimit);
6063*472cd20dSToomas Soome LogTimerToFD(fd, "m->NextScheduledStopTime ", m->NextScheduledStopTime);
60645ffb0c9bSToomas Soome }
60655ffb0c9bSToomas Soome
6066*472cd20dSToomas Soome #if MDNS_MALLOC_DEBUGGING
udsserver_validatelists(void * context)6067*472cd20dSToomas Soome mDNSlocal void udsserver_validatelists(void *context)
60685ffb0c9bSToomas Soome {
60695ffb0c9bSToomas Soome const request_state *req, *p;
6070*472cd20dSToomas Soome (void)context; // unused
60715ffb0c9bSToomas Soome for (req = all_requests; req; req=req->next)
60724b22b933Srs {
60735ffb0c9bSToomas Soome if (req->next == (request_state *)~0 || (req->sd < 0 && req->sd != -2))
60745ffb0c9bSToomas Soome LogMemCorruption("UDS request list: %p is garbage (%d)", req, req->sd);
60754b22b933Srs
60765ffb0c9bSToomas Soome if (req->primary == req)
60775ffb0c9bSToomas Soome LogMemCorruption("UDS request list: req->primary should not point to self %p/%d", req, req->sd);
60784b22b933Srs
60795ffb0c9bSToomas Soome if (req->primary && req->replies)
60805ffb0c9bSToomas Soome LogMemCorruption("UDS request list: Subordinate request %p/%d/%p should not have replies (%p)",
60815ffb0c9bSToomas Soome req, req->sd, req->primary && req->replies);
60824b22b933Srs
60835ffb0c9bSToomas Soome p = req->primary;
60845ffb0c9bSToomas Soome if ((long)p & 3)
60855ffb0c9bSToomas Soome LogMemCorruption("UDS request list: req %p primary %p is misaligned (%d)", req, p, req->sd);
60865ffb0c9bSToomas Soome else if (p && (p->next == (request_state *)~0 || (p->sd < 0 && p->sd != -2)))
60875ffb0c9bSToomas Soome LogMemCorruption("UDS request list: req %p primary %p is garbage (%d)", req, p, p->sd);
60884b22b933Srs
60895ffb0c9bSToomas Soome reply_state *rep;
60905ffb0c9bSToomas Soome for (rep = req->replies; rep; rep=rep->next)
60915ffb0c9bSToomas Soome if (rep->next == (reply_state *)~0)
60925ffb0c9bSToomas Soome LogMemCorruption("UDS req->replies: %p is garbage", rep);
60934b22b933Srs
60945ffb0c9bSToomas Soome if (req->terminate == connection_termination)
60955ffb0c9bSToomas Soome {
60965ffb0c9bSToomas Soome registered_record_entry *r;
60975ffb0c9bSToomas Soome for (r = req->u.reg_recs; r; r=r->next)
60985ffb0c9bSToomas Soome if (r->next == (registered_record_entry *)~0)
60995ffb0c9bSToomas Soome LogMemCorruption("UDS req->u.reg_recs: %p is garbage", r);
61005ffb0c9bSToomas Soome }
61015ffb0c9bSToomas Soome else if (req->terminate == regservice_termination_callback)
61025ffb0c9bSToomas Soome {
61035ffb0c9bSToomas Soome service_instance *s;
61045ffb0c9bSToomas Soome for (s = req->u.servicereg.instances; s; s=s->next)
61055ffb0c9bSToomas Soome if (s->next == (service_instance *)~0)
61065ffb0c9bSToomas Soome LogMemCorruption("UDS req->u.servicereg.instances: %p is garbage", s);
61075ffb0c9bSToomas Soome }
61085ffb0c9bSToomas Soome else if (req->terminate == browse_termination_callback)
61095ffb0c9bSToomas Soome {
61105ffb0c9bSToomas Soome browser_t *b;
61115ffb0c9bSToomas Soome for (b = req->u.browser.browsers; b; b=b->next)
61125ffb0c9bSToomas Soome if (b->next == (browser_t *)~0)
61135ffb0c9bSToomas Soome LogMemCorruption("UDS req->u.browser.browsers: %p is garbage", b);
61145ffb0c9bSToomas Soome }
61155ffb0c9bSToomas Soome }
61165ffb0c9bSToomas Soome
61175ffb0c9bSToomas Soome DNameListElem *d;
61185ffb0c9bSToomas Soome for (d = SCPrefBrowseDomains; d; d=d->next)
61195ffb0c9bSToomas Soome if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
61205ffb0c9bSToomas Soome LogMemCorruption("SCPrefBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
61215ffb0c9bSToomas Soome
61225ffb0c9bSToomas Soome ARListElem *b;
61235ffb0c9bSToomas Soome for (b = LocalDomainEnumRecords; b; b=b->next)
61245ffb0c9bSToomas Soome if (b->next == (ARListElem *)~0 || b->ar.resrec.name->c[0] > 63)
61255ffb0c9bSToomas Soome LogMemCorruption("LocalDomainEnumRecords: %p is garbage (%d)", b, b->ar.resrec.name->c[0]);
61265ffb0c9bSToomas Soome
61275ffb0c9bSToomas Soome for (d = AutoBrowseDomains; d; d=d->next)
61285ffb0c9bSToomas Soome if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
61295ffb0c9bSToomas Soome LogMemCorruption("AutoBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
61305ffb0c9bSToomas Soome
61315ffb0c9bSToomas Soome for (d = AutoRegistrationDomains; d; d=d->next)
61325ffb0c9bSToomas Soome if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
61335ffb0c9bSToomas Soome LogMemCorruption("AutoRegistrationDomains: %p is garbage (%d)", d, d->name.c[0]);
61345ffb0c9bSToomas Soome }
6135*472cd20dSToomas Soome #endif // MDNS_MALLOC_DEBUGGING
61365ffb0c9bSToomas Soome
send_msg(request_state * const req)61375ffb0c9bSToomas Soome mDNSlocal int send_msg(request_state *const req)
61385ffb0c9bSToomas Soome {
61395ffb0c9bSToomas Soome reply_state *const rep = req->replies; // Send the first waiting reply
61405ffb0c9bSToomas Soome ssize_t nwriten;
61415ffb0c9bSToomas Soome
61425ffb0c9bSToomas Soome ConvertHeaderBytes(rep->mhdr);
61435ffb0c9bSToomas Soome nwriten = send(req->sd, (char *)&rep->mhdr + rep->nwriten, rep->totallen - rep->nwriten, 0);
61445ffb0c9bSToomas Soome ConvertHeaderBytes(rep->mhdr);
61454b22b933Srs
61465ffb0c9bSToomas Soome if (nwriten < 0)
61475ffb0c9bSToomas Soome {
61485ffb0c9bSToomas Soome if (dnssd_errno == dnssd_EINTR || dnssd_errno == dnssd_EWOULDBLOCK) nwriten = 0;
61495ffb0c9bSToomas Soome else
61505ffb0c9bSToomas Soome {
61515ffb0c9bSToomas Soome #if !defined(PLATFORM_NO_EPIPE)
61525ffb0c9bSToomas Soome if (dnssd_errno == EPIPE)
61535ffb0c9bSToomas Soome return(req->ts = t_terminated);
61545ffb0c9bSToomas Soome else
61555ffb0c9bSToomas Soome #endif
61565ffb0c9bSToomas Soome {
61575ffb0c9bSToomas Soome LogMsg("send_msg ERROR: failed to write %d of %d bytes to fd %d errno %d (%s)",
61585ffb0c9bSToomas Soome rep->totallen - rep->nwriten, rep->totallen, req->sd, dnssd_errno, dnssd_strerror(dnssd_errno));
61595ffb0c9bSToomas Soome return(t_error);
61605ffb0c9bSToomas Soome }
61615ffb0c9bSToomas Soome }
61625ffb0c9bSToomas Soome }
61635ffb0c9bSToomas Soome rep->nwriten += nwriten;
61645ffb0c9bSToomas Soome return (rep->nwriten == rep->totallen) ? t_complete : t_morecoming;
61655ffb0c9bSToomas Soome }
61664b22b933Srs
udsserver_idle(mDNSs32 nextevent)61675ffb0c9bSToomas Soome mDNSexport mDNSs32 udsserver_idle(mDNSs32 nextevent)
61685ffb0c9bSToomas Soome {
61695ffb0c9bSToomas Soome mDNSs32 now = mDNS_TimeNow(&mDNSStorage);
61705ffb0c9bSToomas Soome request_state **req = &all_requests;
61714b22b933Srs
61725ffb0c9bSToomas Soome while (*req)
61735ffb0c9bSToomas Soome {
61745ffb0c9bSToomas Soome request_state *const r = *req;
61754b22b933Srs
61765ffb0c9bSToomas Soome if (r->terminate == resolve_termination_callback)
61775ffb0c9bSToomas Soome if (r->u.resolve.ReportTime && now - r->u.resolve.ReportTime >= 0)
61785ffb0c9bSToomas Soome {
61795ffb0c9bSToomas Soome r->u.resolve.ReportTime = 0;
6180c65ebfc7SToomas Soome // if client received results and resolve still active
6181c65ebfc7SToomas Soome if (r->u.resolve.txt && r->u.resolve.srv)
6182c65ebfc7SToomas Soome LogMsgNoIdent("Client application PID[%d](%s) has received results for DNSServiceResolve(%##s) yet remains active over two minutes.", r->process_id, r->pid_name, r->u.resolve.qsrv.qname.c);
61835ffb0c9bSToomas Soome }
61844b22b933Srs
61855ffb0c9bSToomas Soome // Note: Only primary req's have reply lists, not subordinate req's.
61865ffb0c9bSToomas Soome while (r->replies) // Send queued replies
61875ffb0c9bSToomas Soome {
61885ffb0c9bSToomas Soome transfer_state result;
6189c65ebfc7SToomas Soome if (r->replies->next)
61905ffb0c9bSToomas Soome r->replies->rhdr->flags |= dnssd_htonl(kDNSServiceFlagsMoreComing);
61915ffb0c9bSToomas Soome result = send_msg(r); // Returns t_morecoming if buffer full because client is not reading
61925ffb0c9bSToomas Soome if (result == t_complete)
61935ffb0c9bSToomas Soome {
61945ffb0c9bSToomas Soome reply_state *fptr = r->replies;
61955ffb0c9bSToomas Soome r->replies = r->replies->next;
61965ffb0c9bSToomas Soome freeL("reply_state/udsserver_idle", fptr);
61975ffb0c9bSToomas Soome r->time_blocked = 0; // reset failure counter after successful send
61985ffb0c9bSToomas Soome r->unresponsiveness_reports = 0;
61995ffb0c9bSToomas Soome continue;
62005ffb0c9bSToomas Soome }
6201c65ebfc7SToomas Soome else if (result == t_terminated)
6202c65ebfc7SToomas Soome {
6203c65ebfc7SToomas Soome LogInfo("%3d: Could not write data to client PID[%d](%s) because connection is terminated by the client", r->sd, r->process_id, r->pid_name);
6204c65ebfc7SToomas Soome abort_request(r);
6205c65ebfc7SToomas Soome }
6206c65ebfc7SToomas Soome else if (result == t_error)
62075ffb0c9bSToomas Soome {
6208cda73f64SToomas Soome LogMsg("%3d: Could not write data to client PID[%d](%s) because of error - aborting connection", r->sd, r->process_id, r->pid_name);
6209c65ebfc7SToomas Soome LogClientInfo(r);
62105ffb0c9bSToomas Soome abort_request(r);
62115ffb0c9bSToomas Soome }
62125ffb0c9bSToomas Soome break;
62135ffb0c9bSToomas Soome }
62144b22b933Srs
62155ffb0c9bSToomas Soome if (r->replies) // If we failed to send everything, check our time_blocked timer
62165ffb0c9bSToomas Soome {
6217c65ebfc7SToomas Soome if (nextevent - now > mDNSPlatformOneSecond)
62185ffb0c9bSToomas Soome nextevent = now + mDNSPlatformOneSecond;
62195ffb0c9bSToomas Soome
6220*472cd20dSToomas Soome LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_INFO,
6221*472cd20dSToomas Soome "[R%u] Could not send all replies. Will try again in %d ticks.", r->request_id, nextevent - now);
6222c65ebfc7SToomas Soome if (mDNSStorage.SleepState != SleepState_Awake)
62235ffb0c9bSToomas Soome r->time_blocked = 0;
6224c65ebfc7SToomas Soome else if (!r->time_blocked)
62255ffb0c9bSToomas Soome r->time_blocked = NonZeroTime(now);
62265ffb0c9bSToomas Soome else if (now - r->time_blocked >= 10 * mDNSPlatformOneSecond * (r->unresponsiveness_reports+1))
62275ffb0c9bSToomas Soome {
62285ffb0c9bSToomas Soome int num = 0;
62295ffb0c9bSToomas Soome struct reply_state *x = r->replies;
6230c65ebfc7SToomas Soome while (x)
6231c65ebfc7SToomas Soome {
6232c65ebfc7SToomas Soome num++;
6233c65ebfc7SToomas Soome x=x->next;
62345ffb0c9bSToomas Soome }
62355ffb0c9bSToomas Soome LogMsg("%3d: Could not write data to client PID[%d](%s) after %ld seconds, %d repl%s waiting",
62365ffb0c9bSToomas Soome r->sd, r->process_id, r->pid_name, (now - r->time_blocked) / mDNSPlatformOneSecond, num, num == 1 ? "y" : "ies");
62375ffb0c9bSToomas Soome if (++r->unresponsiveness_reports >= 60)
62385ffb0c9bSToomas Soome {
62395ffb0c9bSToomas Soome LogMsg("%3d: Client PID[%d](%s) unresponsive; aborting connection", r->sd, r->process_id, r->pid_name);
6240c65ebfc7SToomas Soome LogClientInfo(r);
62415ffb0c9bSToomas Soome abort_request(r);
62425ffb0c9bSToomas Soome }
62435ffb0c9bSToomas Soome }
62445ffb0c9bSToomas Soome }
62454b22b933Srs
62465ffb0c9bSToomas Soome if (!dnssd_SocketValid(r->sd)) // If this request is finished, unlink it from the list and free the memory
62475ffb0c9bSToomas Soome {
62485ffb0c9bSToomas Soome // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
62495ffb0c9bSToomas Soome *req = r->next;
62505ffb0c9bSToomas Soome freeL("request_state/udsserver_idle", r);
62515ffb0c9bSToomas Soome }
62525ffb0c9bSToomas Soome else
62535ffb0c9bSToomas Soome req = &r->next;
62545ffb0c9bSToomas Soome }
62555ffb0c9bSToomas Soome return nextevent;
62565ffb0c9bSToomas Soome }
62575ffb0c9bSToomas Soome
62585ffb0c9bSToomas Soome struct CompileTimeAssertionChecks_uds_daemon
62595ffb0c9bSToomas Soome {
62605ffb0c9bSToomas Soome // Check our structures are reasonable sizes. Including overly-large buffers, or embedding
62615ffb0c9bSToomas Soome // other overly-large structures instead of having a pointer to them, can inadvertently
62625ffb0c9bSToomas Soome // cause structure sizes (and therefore memory usage) to balloon unreasonably.
6263*472cd20dSToomas Soome char sizecheck_request_state [(sizeof(request_state) <= 3880) ? 1 : -1];
62645ffb0c9bSToomas Soome char sizecheck_registered_record_entry[(sizeof(registered_record_entry) <= 60) ? 1 : -1];
62655ffb0c9bSToomas Soome char sizecheck_service_instance [(sizeof(service_instance) <= 6552) ? 1 : -1];
6266*472cd20dSToomas Soome char sizecheck_browser_t [(sizeof(browser_t) <= 1480) ? 1 : -1];
62675ffb0c9bSToomas Soome char sizecheck_reply_hdr [(sizeof(reply_hdr) <= 12) ? 1 : -1];
62685ffb0c9bSToomas Soome char sizecheck_reply_state [(sizeof(reply_state) <= 64) ? 1 : -1];
62695ffb0c9bSToomas Soome };
6270c65ebfc7SToomas Soome
6271c65ebfc7SToomas Soome #ifdef UNIT_TEST
6272c65ebfc7SToomas Soome #include "../unittests/uds_daemon_ut.c"
6273c65ebfc7SToomas Soome #endif // UNIT_TEST
6274