mDNSResponder-2200.60.25.0.4

Imported from mDNSResponder-2200.60.25.0.4.tar.gz

Author: AppleOSSDistributions

Clients/dnssdutil/dnssdutil.c

@@ -201,7 +201,7 @@ struct dso_transport {
     uint8_t *NULLABLE buf;
     dso_state_t *NULLABLE dso;
     tls_context_t *NULLABLE tls_context;
-    addr_t address, multicast;
+    addr_t address, multicast, local;
     size_t message_length_len;
     size_t message_length, message_cur;
     uint8_t message_length_bytes[2];
@@ -383,6 +383,7 @@ bool ioloop_udp_send_message(comm_t *NONNULL comm, addr_t *NULLABLE source, addr
                              struct iovec *NONNULL iov, int iov_len);
 void ioloop_udp_read_callback(io_t *NONNULL io, void *NULLABLE context);
 #endif
+int get_num_fds(void);
 
 // Local Variables:
 // mode: C

ServiceRegistration/dnssd-proxy.c

@@ -599,6 +599,9 @@ datagram_read(comm_t *connection, size_t length, dispatch_data_t content, nw_err
             return true;
         });
     if (ret == true) {
+        // Set the local address
+        message->local = connection->local;
+
         // Process the message.
         if (connection->listener_state != NULL) {
             connection->listener_state->datagram_callback(connection, message, connection->listener_state->context);
@@ -821,6 +824,30 @@ connection_state_changed(comm_t *connection, nw_connection_state_t state, nw_err
     }
 }
 
+static void
+ioloop_connection_get_address_from_endpoint(addr_t *addr, nw_endpoint_t endpoint)
+{
+    nw_endpoint_type_t endpoint_type = nw_endpoint_get_type(endpoint);
+    if (endpoint_type == nw_endpoint_type_address) {
+        char *address_string = nw_endpoint_copy_address_string(endpoint);
+        if (address_string == NULL) {
+            ERROR("unable to get description of new connection.");
+        } else {
+            getipaddr(addr, address_string);
+            if (addr->sa.sa_family == AF_INET6) {
+                SEGMENTED_IPv6_ADDR_GEN_SRP(&addr->sin6.sin6_addr, rdata_buf);
+                INFO("parsed connection local IPv6 address is: " PRI_SEGMENTED_IPv6_ADDR_SRP,
+                     SEGMENTED_IPv6_ADDR_PARAM_SRP(&addr->sin6.sin6_addr, rdata_buf));
+            } else {
+                IPv4_ADDR_GEN_SRP(&addr->sin.sin_addr, rdata_buf);
+                INFO("parsed connection local IPv4 address is: " PRI_IPv4_ADDR_SRP,
+                     IPv4_ADDR_PARAM_SRP(&addr->sin.sin_addr, rdata_buf));
+            }
+        }
+        free(address_string);
+    }
+}
+
 static void
 ioloop_connection_set_name_from_endpoint(comm_t *listener, comm_t *connection, nw_endpoint_t endpoint)
 {
@@ -835,11 +862,11 @@ ioloop_connection_set_name_from_endpoint(comm_t *listener, comm_t *connection, n
             getipaddr(&connection->address, address_string);
             if (connection->address.sa.sa_family == AF_INET6) {
                 SEGMENTED_IPv6_ADDR_GEN_SRP(&connection->address.sin6.sin6_addr, rdata_buf);
-                INFO("parsed connection IPv6 address is: " PRI_SEGMENTED_IPv6_ADDR_SRP,
+                INFO("parsed connection remote IPv6 address is: " PRI_SEGMENTED_IPv6_ADDR_SRP,
                      SEGMENTED_IPv6_ADDR_PARAM_SRP(&connection->address.sin6.sin6_addr, rdata_buf));
             } else {
                 IPv4_ADDR_GEN_SRP(&connection->address.sin.sin_addr, rdata_buf);
-                INFO("parsed connection IPv4 address is: " PRI_IPv4_ADDR_SRP,
+                INFO("parsed connection remote IPv4 address is: " PRI_IPv4_ADDR_SRP,
                      IPv4_ADDR_PARAM_SRP(&connection->address.sin.sin_addr, rdata_buf));
             }
         }
@@ -905,6 +932,13 @@ connection_callback(comm_t *listener, nw_connection_t new_connection)
         connection->name = strdup("unidentified");
     }
 
+    // Best effort
+    nw_endpoint_t local_endpoint = nw_connection_copy_connected_local_endpoint(connection->connection);
+    if (local_endpoint != NULL) {
+        ioloop_connection_get_address_from_endpoint(&connection->local, endpoint);
+        nw_release(local_endpoint);
+    }
+
     connection->datagram_callback = listener->datagram_callback;
     connection->tcp_stream = listener->tcp_stream;
     connection->server = true;
@@ -975,10 +1009,27 @@ ioloop_listener_cancel(comm_t *connection)
         // connection->listener will be released in ioloop_listener_state_changed_handler: nw_listener_state_cancelled.
     }
 #if UDP_LISTENER_USES_CONNECTION_GROUPS
-    if (!connection->stream && connection->io.fd != -1) {
-        ioloop_close(&connection->io);
-        io->refcnt = 100; // Prevent read_cancel from finalizing the io object
-        ioloop_read_cancel(&connection->io);
+    if (connection->connection_group != NULL) {
+        INFO("%p %p", connection, connection->connection_group);
+        nw_connection_group_cancel(connection->connection_group);
+    }
+#else
+    if (!connection->tcp_stream && connection->connection == NULL) {
+        int fd = connection->io.fd;
+        if (fd != -1) {
+            ioloop_close(&connection->io);
+            close(fd);
+            ioloop_read_cancel(&connection->io);
+            if (connection->cancel != NULL) {
+                RETAIN_HERE(connection, listener);
+                dispatch_async(ioloop_main_queue, ^{
+                        if (connection->cancel != NULL) {
+                            connection->cancel(connection->context);
+                        }
+                        RELEASE_HERE(connection, listener);
+                    });
+            }
+        }
     }
 #endif
 }
@@ -1200,12 +1251,12 @@ ioloop_udp_listener_setup(comm_t *listener, const addr_t *ip_address, uint16_t p
         if (family == AF_INET) {
             IPv4_ADDR_GEN_SRP(&listener->address.sin.sin_addr.s_addr, ipv4_addr_buf);
             ERROR("Can't bind to " PRI_IPv4_ADDR_SRP "#%d: %s",
-                  IPv4_ADDR_PARAM_SRP(&listener->address.sin.sin_addr.s_addr, ipv4_addr_buf), ntohs(port),
+                  IPv4_ADDR_PARAM_SRP(&listener->address.sin.sin_addr.s_addr, ipv4_addr_buf), port,
                   strerror(errno));
         } else {
             SEGMENTED_IPv6_ADDR_GEN_SRP(&listener->address.sin6.sin6_addr.s6_addr, ipv6_addr_buf);
             ERROR("Can't bind to " PRI_SEGMENTED_IPv6_ADDR_SRP "#%d: %s",
-                  SEGMENTED_IPv6_ADDR_PARAM_SRP(&listener->address.sin6.sin6_addr.s6_addr, ipv6_addr_buf), ntohs(port),
+                  SEGMENTED_IPv6_ADDR_PARAM_SRP(&listener->address.sin6.sin6_addr.s6_addr, ipv6_addr_buf), port,
                   strerror(errno));
         }
     out:

ServiceRegistration/ioloop.h

@@ -102,11 +102,10 @@ static void
 nat64_infra_prefix_monitor_cancel(nat64_infra_prefix_monitor_t *monitor)
 {
     if (monitor != NULL) {
-        nat64_prefix_t **ppref, *prefix;
-        ppref = &monitor->infra_nat64_prefixes;
-        while (*ppref != NULL) {
-            prefix = *ppref;
-            ppref = &prefix->next;
+        nat64_prefix_t *next;
+        for (nat64_prefix_t *prefix = monitor->infra_nat64_prefixes; prefix != NULL; prefix = next) {
+            next = prefix->next;
+            prefix->next = NULL;
             RELEASE_HERE(prefix, nat64_prefix);
         }
         monitor->infra_nat64_prefixes = NULL;
@@ -142,6 +141,7 @@ nat64_thread_prefix_monitor_cancel(nat64_thread_prefix_monitor_t *monitor)
         nat64_prefix_t *next;
         for (nat64_prefix_t *prefix = monitor->thread_nat64_prefixes; prefix != NULL; prefix = next) {
             next = prefix->next;
+            prefix->next = NULL;
             RELEASE_HERE(prefix, nat64_prefix);
         }
         monitor->thread_nat64_prefixes = NULL;
@@ -1118,8 +1118,8 @@ nat64_infra_prefix_publisher_publishing_action(nat64_infra_prefix_publisher_t *s
     if (event == NULL) {
         return nat64_infra_prefix_publisher_state_invalid;
     } else if (event->event_type == nat64_event_nat64_infra_prefix_publisher_infra_prefix_changed ||
-			   event->event_type == nat64_event_nat64_infra_prefix_publisher_shutdown)
-	{
+               event->event_type == nat64_event_nat64_infra_prefix_publisher_shutdown)
+    {
         nat64_prefix_t *infra_prefix;
         for (infra_prefix = event->prefix; infra_prefix; infra_prefix = infra_prefix->next) {
             if (!in6prefix_compare(&infra_prefix->prefix, &state_machine->proposed_prefix->prefix, NAT64_PREFIX_SLASH_96_BYTES)) {
@@ -1148,8 +1148,8 @@ nat64_infra_prefix_publisher_publishing_action(nat64_infra_prefix_publisher_t *s
             return nat64_infra_prefix_publisher_state_wait;
         }
     } else if (event->event_type == nat64_event_nat64_infra_prefix_publisher_routable_omr_prefix_went_away ||
-			   event->event_type == nat64_event_nat64_infra_prefix_publisher_shutdown)
-	{
+               event->event_type == nat64_event_nat64_infra_prefix_publisher_shutdown)
+    {
         // Routable OMR prefix is gone
         SEGMENTED_IPv6_ADDR_GEN_SRP(state_machine->proposed_prefix->prefix.s6_addr, nat64_prefix_buf);
         INFO("Routable OMR prefix is gone, unpublishing infra prefix " PRI_SEGMENTED_IPv6_ADDR_SRP,
@@ -1413,8 +1413,8 @@ nat64_br_prefix_publisher_publishing_action(nat64_br_prefix_publisher_t *state_m
             }
         }
     } else if (event->event_type == nat64_event_nat64_br_prefix_publisher_ipv4_default_route_went_away ||
-			   event->event_type == nat64_event_nat64_br_prefix_publisher_shutdown)
-	{
+               event->event_type == nat64_event_nat64_br_prefix_publisher_shutdown)
+    {
         nat64_unpublish_br_prefix(state_machine);
         return nat64_br_prefix_publisher_state_wait_for_anything;
     } else if (event->event_type == nat64_event_nat64_br_prefix_publisher_infra_prefix_changed) {
@@ -1734,16 +1734,25 @@ nat64_offmesh_route_list_callback(route_state_t *route_state, cti_route_vec_t *r
 void
 nat64_thread_shutdown(route_state_t *route_state)
 {
-	nat64_t *nat64 = route_state->nat64;
-	if (nat64->nat64_infra_prefix_publisher != NULL) {
-		nat64_infra_prefix_publisher_event_t infra_event;
-		nat64_infra_prefix_publisher_event_init(&infra_event, nat64_event_nat64_infra_prefix_publisher_shutdown);
-		nat64_infra_prefix_publisher_event_deliver(nat64->nat64_infra_prefix_publisher, &infra_event);
-	}
-	if (nat64->nat64_br_prefix_publisher != NULL) {
-		nat64_br_prefix_publisher_event_t br_event;
-		nat64_br_prefix_publisher_event_init(&br_event, nat64_event_nat64_br_prefix_publisher_shutdown);
-		nat64_br_prefix_publisher_event_deliver(nat64->nat64_br_prefix_publisher, &br_event);
-	}
+    nat64_t *nat64 = route_state->nat64;
+    if (nat64->nat64_infra_prefix_publisher != NULL) {
+        nat64_infra_prefix_publisher_event_t infra_event;
+        nat64_infra_prefix_publisher_event_init(&infra_event, nat64_event_nat64_infra_prefix_publisher_shutdown);
+        nat64_infra_prefix_publisher_event_deliver(nat64->nat64_infra_prefix_publisher, &infra_event);
+    }
+    if (nat64->nat64_br_prefix_publisher != NULL) {
+        nat64_br_prefix_publisher_event_t br_event;
+        nat64_br_prefix_publisher_event_init(&br_event, nat64_event_nat64_br_prefix_publisher_shutdown);
+        nat64_br_prefix_publisher_event_deliver(nat64->nat64_br_prefix_publisher, &br_event);
+    }
 }
 #endif
+
+// Local Variables:
+// mode: C
+// tab-width: 4
+// c-file-style: "bsd"
+// c-basic-offset: 4
+// fill-column: 120
+// indent-tabs-mode: nil
+// End:

ServiceRegistration/macos-ioloop.c

@@ -71,6 +71,12 @@ ioloop_dump_object_allocation_stats(void)
             INFO(PUB_S_SRP, outbuf);
         }
     }
+    int num_fds = get_num_fds();
+    if (num_fds < 0) {
+        FAULT("out of file descriptors!!");
+        abort();
+    }
+    INFO("%d file descriptors in use", num_fds);
 }
 
 interface_address_state_t *interface_addresses;
@@ -459,22 +465,29 @@ time_t srp_time(void)
     return tm.tv_sec;
 }
 
-#ifdef DEBUG_FD_LEAKS
 int
 get_num_fds(void)
 {
-    DIR *dirfd = opendir("/dev/fd");
     int num = 0;
+    DIR *dirfd = opendir("/dev/fd");
     if (dirfd == NULL) {
-        return -1;
+        if (errno == EMFILE) {
+            FAULT("per-process open file limit reached.");
+            return -1;
+        } else if (errno == ENFILE) {
+            FAULT("per-system open file limit reached.");
+            return -1;
+        } else {
+            ERROR("errno %d " PUB_S_SRP, errno, strerror(errno));
+            return 0;
+        }
     }
     while (readdir(dirfd) != NULL) {
         num++;
     }
     closedir(dirfd);
     return num;
 }
-#endif // DEBUG_VERBOSE
 
 #ifdef MALLOC_DEBUG_LOGGING
 #undef malloc

ServiceRegistration/nat64.c

@@ -3091,7 +3091,7 @@ cti_get_xpanid_callback(void *context, uint64_t new_xpanid, cti_status_t status)
     in6addr_zero(&route_state->xpanid_prefix);
     route_state->xpanid_prefix.s6_addr[0] = 0xfd;
     for (int i = 1; i < 8; i++) {
-        route_state->xpanid_prefix.s6_addr[i] = ((route_state->srp_server->xpanid >> ((7 - i) * 8)) & 0xFFU);
+        route_state->xpanid_prefix.s6_addr[i] = ((route_state->srp_server->xpanid >> ((8 - i) * 8)) & 0xFFU);
     }
     route_state->have_xpanid_prefix = true;
 
@@ -3519,7 +3519,7 @@ partition_start_srp_listener(route_state_t *route_state)
 
     INFO("starting listener.");
     route_state->srp_listener = srp_proxy_listen(avoid_ports, num_avoid_ports, partition_proxy_listener_ready,
-                                                 partition_srp_listener_canceled, NULL, route_state->srp_server);
+                                                 partition_srp_listener_canceled, NULL, NULL, route_state->srp_server);
     if (route_state->srp_listener == NULL) {
         ERROR("partition_start_srp_listener: Unable to start SRP Proxy listener, so can't advertise it");
         return;

ServiceRegistration/posix.c

@@ -139,8 +139,12 @@ service_publisher_is_address_mesh_local(service_publisher_t *publisher, addr_t *
 {
     if (address->sa.sa_family == AF_INET) {
         IPv4_ADDR_GEN_SRP(&address->sin.sin_addr, addr_buf);
-        INFO(PRI_IPv4_ADDR_SRP "is not mesh-local", IPv4_ADDR_PARAM_SRP(&address->sin.sin_addr, addr_buf));
-        return false;
+        if (!IN_LOOPBACK(address->sin.sin_addr.s_addr)) {
+            INFO(PRI_IPv4_ADDR_SRP "is not mesh-local", IPv4_ADDR_PARAM_SRP(&address->sin.sin_addr, addr_buf));
+            return false;
+        }
+        INFO(PRI_IPv4_ADDR_SRP "is the IPv4 loopback address", IPv4_ADDR_PARAM_SRP(&address->sin.sin_addr, addr_buf));
+        return true;
     }
     if (address->sa.sa_family != AF_INET6) {
         INFO("address family %d can't be mesh-local", address->sa.sa_family);
@@ -149,24 +153,24 @@ service_publisher_is_address_mesh_local(service_publisher_t *publisher, addr_t *
 
     uint8_t *addr_ptr = (uint8_t *)&address->sin6.sin6_addr;
     SEGMENTED_IPv6_ADDR_GEN_SRP(addr_ptr, addr_buf);
-    if (!publisher->have_ml_eid) {
-        INFO(PRI_SEGMENTED_IPv6_ADDR_SRP "is not mesh-local",
+    if (IN6_IS_ADDR_LOOPBACK(&address->sin6.sin6_addr)) {
+        INFO(PRI_SEGMENTED_IPv6_ADDR_SRP " is the IPv6 loopback address.",
              SEGMENTED_IPv6_ADDR_PARAM_SRP(addr_ptr, addr_buf));
-        return false;
-    }
-
-    int i;
-    for (i = 0; i < 15; i++) {
-        if (addr_ptr[i] != 0) {
-            break;
-        }
+        return true;
     }
-    if (i == 15 && addr_ptr[i] == 1) {
-        INFO(PRI_SEGMENTED_IPv6_ADDR_SRP " is the IPv6 localhost address.",
+    static const uint8_t ipv4mapped_loopback[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 127, 0, 0, 1 };
+    if (!memcmp(&address->sin6.sin6_addr, ipv4mapped_loopback, sizeof(ipv4mapped_loopback))) {
+        INFO(PRI_SEGMENTED_IPv6_ADDR_SRP " is the IPv4-mapped loopback address.",
              SEGMENTED_IPv6_ADDR_PARAM_SRP(addr_ptr, addr_buf));
         return true;
     }
 
+    if (!publisher->have_ml_eid) {
+        INFO(PRI_SEGMENTED_IPv6_ADDR_SRP "is not mesh-local",
+             SEGMENTED_IPv6_ADDR_PARAM_SRP(addr_ptr, addr_buf));
+        return false;
+    }
+
     SEGMENTED_IPv6_ADDR_GEN_SRP(&publisher->thread_mesh_local_address, mle_buf);
     if (in6prefix_compare(&address->sin6.sin6_addr, &publisher->thread_mesh_local_address, 8)) {
         INFO(PRI_SEGMENTED_IPv6_ADDR_SRP
@@ -816,6 +820,7 @@ service_publisher_listener_cancel(service_publisher_t *publisher)
         ioloop_comm_release(publisher->srp_listener);
         publisher->srp_listener = NULL;
     }
+    srp_mdns_flush(publisher->server_state);
 }
 
 static void
@@ -843,10 +848,12 @@ service_publisher_listener_start(service_publisher_t *publisher)
     }
     publisher->srp_listener = srp_proxy_listen(NULL, 0, service_publisher_listener_ready,
                                                service_publisher_listener_cancel_callback, NULL,
-                                               publisher->server_state);
+                                               service_publisher_context_release, publisher->server_state);
     if (publisher->srp_listener == NULL) {
         ERROR("failed to setup SRP listener");
     }
+    // The listener needs to hold a reference on the service publisher until its context release callback is called.
+    RETAIN_HERE(publisher, service_publisher);
 }
 
 // We go to this state when we have decided to publish, but perhaps do not currently have an SRP listener

ServiceRegistration/route.c

@@ -74,6 +74,7 @@ struct service_instance {
     service_t *NONNULL service;
     int num_instances;
     dns_rr_t *NULLABLE srv, *NULLABLE txt;
+    bool skip_update;
 };
 
 // The update_t structure is used to maintain the ongoing state of a particular DNS Update.