react-native-zeroconf 0.13.7 → 0.14.0

package/android/src/main/jni/mdnsresponder/mDNSCore/uDNS.h

@@ -0,0 +1,132 @@
+/* -*- Mode: C; tab-width: 4 -*-
+ *
+ * Copyright (c) 2002-2003 Apple Computer, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __UDNS_H_
+#define __UDNS_H_
+
+#include "mDNSEmbeddedAPI.h"
+#include "DNSCommon.h"
+
+#ifdef	__cplusplus
+	extern "C" {
+#endif
+
+#define RESTART_GOODBYE_DELAY    (6 * mDNSPlatformOneSecond) // delay after restarting LLQ before nuking previous known answers (avoids flutter if we restart before we have networking up)
+#define INIT_UCAST_POLL_INTERVAL (3 * mDNSPlatformOneSecond) // this interval is used after send failures on network transitions
+	                                                         // which typically heal quickly, so we start agressively and exponentially back off
+#define MAX_UCAST_POLL_INTERVAL (60 * 60 * mDNSPlatformOneSecond)
+//#define MAX_UCAST_POLL_INTERVAL (1 * 60 * mDNSPlatformOneSecond)
+#define LLQ_POLL_INTERVAL       (15 * 60 * mDNSPlatformOneSecond) // Polling interval for zones w/ an advertised LLQ port (ie not static zones) if LLQ fails due to NAT, etc.
+#define RESPONSE_WINDOW (60 * mDNSPlatformOneSecond)         // require server responses within one minute of request
+#define MAX_UCAST_UNANSWERED_QUERIES 2                       // the number of unanswered queries from any one uDNS server before trying another server
+#define DNSSERVER_PENALTY_TIME (60 * mDNSPlatformOneSecond) // number of seconds for which new questions don't pick this server
+
+#define DEFAULT_UPDATE_LEASE 7200
+
+#define QuestionIntervalStep 3
+#define QuestionIntervalStep2 (QuestionIntervalStep*QuestionIntervalStep)
+#define QuestionIntervalStep3 (QuestionIntervalStep*QuestionIntervalStep*QuestionIntervalStep)
+#define InitialQuestionInterval ((mDNSPlatformOneSecond + QuestionIntervalStep-1) / QuestionIntervalStep)
+
+// For Unicast record registrations, we initialize the interval to 1 second. When we send any query for
+// the record registration e.g., GetZoneData, we always back off by QuestionIntervalStep
+// so that the first retry does not happen until 3 seconds which should be enough for TCP/TLS to be done.
+#define INIT_RECORD_REG_INTERVAL (1 * mDNSPlatformOneSecond)
+#define MAX_RECORD_REG_INTERVAL	(15 * 60 * mDNSPlatformOneSecond)
+#define MERGE_DELAY_TIME	(1 * mDNSPlatformOneSecond)
+
+// If we are refreshing, we do it at least 5 times with a min update frequency of 
+// 5 minutes
+#define MAX_UPDATE_REFRESH_COUNT	5
+#define MIN_UPDATE_REFRESH_TIME		(5 * 60 * mDNSPlatformOneSecond)
+
+// For questions that use kDNSServiceFlagsTimeout and we don't have a matching resolver e.g., no dns servers,
+// then use the default value of 30 seconds
+#define DEFAULT_UDNS_TIMEOUT	30 // in seconds
+
+// Entry points into unicast-specific routines
+
+extern void LLQGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneInfo);
+extern void startLLQHandshake(mDNS *m, DNSQuestion *q);
+extern void sendLLQRefresh(mDNS *m, DNSQuestion *q);
+
+extern void SleepRecordRegistrations(mDNS *m);
+
+// uDNS_UpdateRecord
+// following fields must be set, and the update validated, upon entry.
+// rr->NewRData
+// rr->newrdlength
+// rr->UpdateCallback
+
+extern mStatus uDNS_UpdateRecord(mDNS *m, AuthRecord *rr);
+
+extern void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q);
+extern CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 slot, const mDNSu32 namehash, const domainname *const name);
+extern mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr);
+extern mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt);
+extern mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question);
+extern mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question);
+extern mStatus mDNS_StartNATOperation_internal(mDNS *const m, NATTraversalInfo *traversal);
+
+extern void RecordRegistrationGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneData);
+extern mStatus uDNS_DeregisterRecord(mDNS *const m, AuthRecord *const rr);
+extern const domainname *GetServiceTarget(mDNS *m, AuthRecord *const rr);
+extern void uDNS_CheckCurrentQuestion(mDNS *const m);
+
+// integer fields of msg header must be in HOST byte order before calling this routine
+extern void uDNS_ReceiveMsg(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
+	const mDNSAddr *const srcaddr, const mDNSIPPort srcport);
+
+extern void uDNS_Tasks(mDNS *const m);
+extern void UpdateAllSRVRecords(mDNS *m);
+extern void CheckNATMappings(mDNS *m);
+
+extern mStatus         uDNS_SetupDNSConfig(mDNS *const m);
+
+// uDNS_SetupSearchDomains by default adds search domains. It also can be called with one or
+// more values for "action" which does the following:
+//
+// -UDNS_START_WAB_QUERY - start Wide Area Bonjour (domain enumeration) queries
+
+#define UDNS_START_WAB_QUERY    0x00000001
+
+extern mStatus         uDNS_SetupSearchDomains(mDNS *const m, int action);
+extern domainname      *uDNS_GetNextSearchDomain(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSs8 *searchIndex, mDNSBool ignoreDotLocal);
+
+typedef enum
+	{
+	uDNS_LLQ_Not = 0,	// Normal uDNS answer: Flush any stale records from cache, and respect record TTL
+	uDNS_LLQ_Ignore,	// LLQ initial challenge packet: ignore -- has no useful records for us
+	uDNS_LLQ_Entire,	// LLQ initial set of answers: Flush any stale records from cache, but assume TTL is 2 x LLQ refresh interval
+	uDNS_LLQ_Events		// LLQ event packet: don't flush cache; assume TTL is 2 x LLQ refresh interval
+	} uDNS_LLQType;
+
+extern uDNS_LLQType    uDNS_recvLLQResponse(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, const mDNSAddr *const srcaddr, const mDNSIPPort srcport, DNSQuestion **matchQuestion);
+extern DomainAuthInfo *GetAuthInfoForName_internal(mDNS *m, const domainname *const name);
+extern DomainAuthInfo *GetAuthInfoForQuestion(mDNS *m, const DNSQuestion *const q);
+extern void DisposeTCPConn(struct tcpInfo_t *tcp);
+
+// NAT traversal
+extern void	uDNS_ReceiveNATPMPPacket(mDNS *m, const mDNSInterfaceID InterfaceID, mDNSu8 *pkt, mDNSu16 len);	// Called for each received NAT-PMP packet
+extern void	natTraversalHandleAddressReply(mDNS *const m, mDNSu16 err, mDNSv4Addr ExtAddr);
+extern void	natTraversalHandlePortMapReply(mDNS *const m, NATTraversalInfo *n, const mDNSInterfaceID InterfaceID, mDNSu16 err, mDNSIPPort extport, mDNSu32 lease);
+
+#ifdef	__cplusplus
+	}
+#endif
+
+#endif // __UDNS_H_

package/android/src/main/jni/mdnsresponder/mDNSPosix/Client.c

@@ -0,0 +1,223 @@
+/* -*- Mode: C; tab-width: 4 -*-
+ *
+ * Copyright (c) 2002-2004 Apple Computer, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "mDNSEmbeddedAPI.h"// Defines the interface to the mDNS core code
+#include "mDNSPosix.h"    // Defines the specific types needed to run mDNS on this platform
+#include "ExampleClientApp.h"
+
+// Globals
+static mDNS mDNSStorage;       // mDNS core uses this to store its globals
+static mDNS_PlatformSupport PlatformStorage;  // Stores this platform's globals
+#define RR_CACHE_SIZE 500
+static CacheEntity gRRCache[RR_CACHE_SIZE];
+
+mDNSexport const char ProgramName[] = "mDNSClientPosix";
+
+static const char *gProgramName = ProgramName;
+
+static void BrowseCallback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
+    // A callback from the core mDNS code that indicates that we've received a 
+    // response to our query.  Note that this code runs on the main thread 
+    // (in fact, there is only one thread!), so we can safely printf the results.
+{
+    domainlabel name;
+    domainname  type;
+    domainname  domain;
+	char nameC  [MAX_DOMAIN_LABEL+1];			// Unescaped name: up to 63 bytes plus C-string terminating NULL.
+	char typeC  [MAX_ESCAPED_DOMAIN_NAME];
+	char domainC[MAX_ESCAPED_DOMAIN_NAME];
+    const char *state;
+
+	(void)m;		// Unused
+	(void)question;	// Unused
+
+    assert(answer->rrtype == kDNSType_PTR);
+
+    DeconstructServiceName(&answer->rdata->u.name, &name, &type, &domain);
+
+    ConvertDomainLabelToCString_unescaped(&name, nameC);
+    ConvertDomainNameToCString(&type, typeC);
+    ConvertDomainNameToCString(&domain, domainC);
+
+    // If the TTL has hit 0, the service is no longer available.
+    if (!AddRecord) {
+        state = "Lost ";
+    } else {
+        state = "Found";
+    }
+    fprintf(stderr, "*** %s name = '%s', type = '%s', domain = '%s'\n", state, nameC, typeC, domainC);
+}
+
+static mDNSBool CheckThatServiceTypeIsUsable(const char *serviceType, mDNSBool printExplanation)
+    // Checks that serviceType is a reasonable service type 
+    // label and, if it isn't and printExplanation is true, prints 
+    // an explanation of why not.
+{
+    mDNSBool result;
+    
+    result = mDNStrue;
+    if (result && strlen(serviceType) > 63) {
+        if (printExplanation) {
+            fprintf(stderr, 
+                    "%s: Service type specified by -t is too long (must be 63 characters or less)\n", 
+                    gProgramName);
+        }
+        result = mDNSfalse;
+    }
+    if (result && serviceType[0] == 0) {
+        if (printExplanation) {
+            fprintf(stderr, 
+                    "%s: Service type specified by -t can't be empty\n", 
+                    gProgramName);
+        }
+        result = mDNSfalse;
+    }
+    return result;
+}
+
+static const char kDefaultServiceType[] = "_afpovertcp._tcp";
+static const char kDefaultDomain[]      = "local.";
+
+static void PrintUsage()
+{
+    fprintf(stderr, 
+            "Usage: %s [-v level] [-t type] [-d domain]\n",
+            gProgramName);
+    fprintf(stderr, "          -v verbose mode, level is a number from 0 to 2\n");
+    fprintf(stderr, "             0 = no debugging info (default)\n");
+    fprintf(stderr, "             1 = standard debugging info\n");
+    fprintf(stderr, "             2 = intense debugging info\n");
+    fprintf(stderr, "          -t uses 'type' as the service type (default is '%s')\n", kDefaultServiceType);
+    fprintf(stderr, "          -d uses 'domain' as the domain to browse (default is '%s')\n", kDefaultDomain);
+}
+
+static const char *gServiceType      = kDefaultServiceType;
+static const char *gServiceDomain    = kDefaultDomain;
+
+static void ParseArguments(int argc, char **argv)
+    // Parses our command line arguments into the global variables 
+    // listed above.
+{
+    int ch;
+    
+    // Set gProgramName to the last path component of argv[0]
+    
+    gProgramName = strrchr(argv[0], '/');
+    if (gProgramName == NULL) {
+        gProgramName = argv[0];
+    } else {
+        gProgramName += 1;
+    }
+    
+    // Parse command line options using getopt.
+    
+    do {
+        ch = getopt(argc, argv, "v:t:d:");
+        if (ch != -1) {
+            switch (ch) {
+                case 'v':
+                    gMDNSPlatformPosixVerboseLevel = atoi(optarg);
+                    if (gMDNSPlatformPosixVerboseLevel < 0 || gMDNSPlatformPosixVerboseLevel > 2) {
+                        fprintf(stderr, 
+                                "%s: Verbose mode must be in the range 0..2\n", 
+                                gProgramName);
+                        exit(1);
+                    }
+                    break;
+                case 't':
+                    gServiceType = optarg;
+                    if ( ! CheckThatServiceTypeIsUsable(gServiceType, mDNStrue) ) {
+                        exit(1);
+                    }
+                    break;
+                case 'd':
+                    gServiceDomain = optarg;
+                    break;
+                case '?':
+                default:
+                    PrintUsage();
+                    exit(1);
+                    break;
+            }
+        }
+    } while (ch != -1);
+
+    // Check for any left over command line arguments.
+    
+    if (optind != argc) {
+        fprintf(stderr, "%s: Unexpected argument '%s'\n", gProgramName, argv[optind]);
+        exit(1);
+    }
+}
+
+int main(int argc, char **argv)
+    // The program's main entry point.  The program does a trivial 
+    // mDNS query, looking for all AFP servers in the local domain.
+{
+    int     result;
+    mStatus     status;
+    DNSQuestion question;
+    domainname  type;
+    domainname  domain;
+
+    // Parse our command line arguments.  This won't come back if there's an error.
+    ParseArguments(argc, argv);
+
+    // Initialise the mDNS core.
+	status = mDNS_Init(&mDNSStorage, &PlatformStorage,
+    	gRRCache, RR_CACHE_SIZE,
+    	mDNS_Init_DontAdvertiseLocalAddresses,
+    	mDNS_Init_NoInitCallback, mDNS_Init_NoInitCallbackContext);
+    if (status == mStatus_NoError) {
+    
+        // Construct and start the query.
+        
+        MakeDomainNameFromDNSNameString(&type, gServiceType);
+        MakeDomainNameFromDNSNameString(&domain, gServiceDomain);
+
+        status = mDNS_StartBrowse(&mDNSStorage, &question, &type, &domain, mDNSInterface_Any, mDNSfalse, BrowseCallback, NULL);
+    
+        // Run the platform main event loop until the user types ^C. 
+        // The BrowseCallback routine is responsible for printing 
+        // any results that we find.
+        
+        if (status == mStatus_NoError) {
+            fprintf(stderr, "Hit ^C when you're bored waiting for responses.\n");
+        	ExampleClientEventLoop(&mDNSStorage);
+            mDNS_StopQuery(&mDNSStorage, &question);
+			mDNS_Close(&mDNSStorage);
+        }
+    }
+    
+    if (status == mStatus_NoError) {
+        result = 0;
+    } else {
+        result = 2;
+    }
+    if ( (result != 0) || (gMDNSPlatformPosixVerboseLevel > 0) ) {
+        fprintf(stderr, "%s: Finished with status %d, result %d\n", gProgramName, (int)status, result);
+    }
+
+    return 0;
+}

package/android/src/main/jni/mdnsresponder/mDNSPosix/ExampleClientApp.c

@@ -0,0 +1,91 @@
+/* -*- Mode: C; tab-width: 4 -*-
+ *
+ * Copyright (c) 2002-2004 Apple Computer, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>			// For printf()
+#include <stdlib.h>			// For exit() etc.
+#include <string.h>			// For strlen() etc.
+#include <unistd.h>			// For select()
+#include <errno.h>			// For errno, EINTR
+#include <netinet/in.h>		// For INADDR_NONE
+#include <arpa/inet.h>		// For inet_addr()
+#include <netdb.h>			// For gethostbyname()
+#include <signal.h>			// For SIGINT, etc.
+
+#include "mDNSEmbeddedAPI.h"  // Defines the interface to the client layer above
+#include "mDNSPosix.h"      // Defines the specific types needed to run mDNS on this platform
+
+//*******************************************************************************************
+// Main
+
+static volatile mDNSBool StopNow;
+
+mDNSlocal void HandleSIG(int signal)
+	{
+	(void)signal;	// Unused
+	debugf("%s","");
+	debugf("HandleSIG");
+	StopNow = mDNStrue;
+	}
+
+mDNSexport void ExampleClientEventLoop(mDNS *const m)
+	{
+	signal(SIGINT, HandleSIG);	// SIGINT is what you get for a Ctrl-C
+	signal(SIGTERM, HandleSIG);
+
+	while (!StopNow)
+		{
+		int nfds = 0;
+		fd_set readfds;
+		struct timeval timeout;
+		int result;
+		
+		// 1. Set up the fd_set as usual here.
+		// This example client has no file descriptors of its own,
+		// but a real application would call FD_SET to add them to the set here
+		FD_ZERO(&readfds);
+		
+		// 2. Set up the timeout.
+		// This example client has no other work it needs to be doing,
+		// so we set an effectively infinite timeout
+		timeout.tv_sec = 0x3FFFFFFF;
+		timeout.tv_usec = 0;
+		
+		// 3. Give the mDNSPosix layer a chance to add its information to the fd_set and timeout
+		mDNSPosixGetFDSet(m, &nfds, &readfds, &timeout);
+		
+		// 4. Call select as normal
+		verbosedebugf("select(%d, %d.%06d)", nfds, timeout.tv_sec, timeout.tv_usec);
+		result = select(nfds, &readfds, NULL, NULL, &timeout);
+		
+		if (result < 0)
+			{
+			verbosedebugf("select() returned %d errno %d", result, errno);
+			if (errno != EINTR) StopNow = mDNStrue;
+			}
+		else
+			{
+			// 5. Call mDNSPosixProcessFDSet to let the mDNSPosix layer do its work
+			mDNSPosixProcessFDSet(m, &readfds);
+			
+			// 6. This example client has no other work it needs to be doing,
+			// but a real client would do its work here
+			// ... (do work) ...
+			}
+		}
+
+	debugf("Exiting");
+	}

package/android/src/main/jni/mdnsresponder/mDNSPosix/ExampleClientApp.h

@@ -0,0 +1,18 @@
+/* -*- Mode: C; tab-width: 4 -*-
+ *
+ * Copyright (c) 2002-2003 Apple Computer, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+extern void ExampleClientEventLoop(mDNS *const m);