ServiceRegistration/service-tracker.c - mDNSResponder - Git at Google

 /* service-tracker.c
  *
  * Copyright (c) 2023-2024 Apple 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
  *
  *     https://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.
  *
  * Track services on the Thread mesh.
  */

 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <pwd.h>
 #include <errno.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <fcntl.h>
 #include <time.h>
 #include <dns_sd.h>
 #include <net/if.h>
 #include <inttypes.h>
 #include <sys/resource.h>
 #include <netinet/icmp6.h>
 #include "srp.h"
 #include "dns-msg.h"
 #include "srp-crypto.h"
 #include "ioloop.h"
 #include "srp-gw.h"
 #include "srp-proxy.h"
 #include "srp-mdns-proxy.h"
 #include "dnssd-proxy.h"
 #include "config-parse.h"
 #include "cti-services.h"
 #include "thread-device.h"
 #include "state-machine.h"
 #include "thread-service.h"
 #include "service-tracker.h"
 #include "probe-srp.h"
 #include "adv-ctl-server.h"

 struct service_tracker_callback {
 	service_tracker_callback_t *next;
 	void (*context_release)(void *NONNULL context);
 	void (*callback)(void *context);
     void *context;
 };

 struct service_tracker {
 	int ref_count;
     uint64_t id;
     route_state_t *route_state;
     srp_server_t *server_state;
     cti_connection_t NULLABLE thread_service_context;
 	service_tracker_callback_t *callbacks;
     thread_service_t *NULLABLE thread_services;
     uint16_t rloc16;
     bool user_service_seen;
 };

 static uint64_t service_tracker_serial_number = 0;

 static void
 service_tracker_finalize(service_tracker_t *tracker)
 {
     thread_service_t *next;
     for (thread_service_t *service = tracker->thread_services; service != NULL; service = next) {
         next = service->next;
         thread_service_release(service);
     }
     free(tracker);
 }

 static void
 service_tracker_context_release(void *context)
 {
     service_tracker_t *tracker = context;
     if (tracker != NULL) {
         RELEASE_HERE(tracker, service_tracker);
     }
 }

 RELEASE_RETAIN_FUNCS(service_tracker);

 void
 service_tracker_thread_service_note(service_tracker_t *tracker, thread_service_t *tservice, const char *event_description)
 {
     char owner_id[20];
     snprintf(owner_id, sizeof(owner_id), "[ST%lld]", tracker->id);
     thread_service_note(owner_id, tservice, event_description);
 }

 typedef struct state_debug_accumulator {
     char change[20]; // " +stable +user +ncp"
     char *p_change;
     size_t left;
     bool changed;
 } accumulator_t;

 static void
 service_tracker_flags_accumulator_init(accumulator_t *accumulator)
 {
     memset(accumulator, 0, sizeof(*accumulator));
     accumulator->p_change = accumulator->change;
     accumulator->left = sizeof(accumulator->change);
 }

 static void
 service_tracker_flags_accumulate(accumulator_t *accumulator, bool previous, bool cur, const char *name)
 {
     size_t len;
     if (previous != cur) {
         snprintf(accumulator->p_change, accumulator->left, "%s%s%s",
                  accumulator->p_change == accumulator->change ? "" : " ", cur ? "+" : "-", name);
         len = strlen(accumulator->p_change);
         accumulator->p_change += len;
         accumulator->left -= len;
         accumulator->changed = true;
     }
 }

 static void
 service_tracker_callback(void *context, cti_service_vec_t *services, cti_status_t status)
 {
     service_tracker_t *tracker = context;
     size_t i;
     thread_service_t **pservice = &tracker->thread_services, *service = NULL;
     tracker->user_service_seen = false;

     if (status == kCTIStatus_Disconnected || status == kCTIStatus_DaemonNotRunning) {
         INFO("[ST%lld] disconnected", tracker->id);
         cti_events_discontinue(tracker->thread_service_context);
         tracker->thread_service_context = NULL;
         RELEASE_HERE(tracker, service_tracker); // Not expecting any more callbacks.
         return;
     }

     if (status != kCTIStatus_NoError) {
         ERROR("[ST%lld] %d", tracker->id, status);
     } else {
         // Delete any SRP services that are not in the list provided by Thread.
         while (*pservice != NULL) {
             service = *pservice;
             if (service->service_type == unicast_service) {
                 struct thread_unicast_service *uservice = &service->u.unicast;
                 for (i = 0; i < services->num; i++) {
                     cti_service_t *cti_service = services->services[i];
                     // Is this a valid SRP service?
                     if (IS_SRP_SERVICE(cti_service)) {
                         // Is this service still present?
                         if (!memcmp(&uservice->address, cti_service->server, 16) &&
                             !memcmp(&uservice->port, &cti_service->server[16], 2)) {
                             break;
                         }
                     }
                 }
             } else if (service->service_type == anycast_service) {
                 struct thread_anycast_service *aservice = &service->u.anycast;
                 for (i = 0; i < services->num; i++) {
                     cti_service_t *cti_service = services->services[i];
                     // Is this a valid SRP anycast service?
                     if (IS_SRP_ANYCAST_SERVICE(cti_service)) {
                         // Is this service still present?
                         if (service->rloc16 == cti_service->rloc16 &&
                             aservice->sequence_number == cti_service->service[1]) {
                             break;
                         }
                     }
                 }
             } else if (service->service_type == pref_id) {
                 struct thread_pref_id *pref_id = &service->u.pref_id;
                 for (i = 0; i < services->num; i++) {
                     cti_service_t *cti_service = services->services[i];
                     // Is this an SRP service?
                     if (IS_PREF_ID_SERVICE(cti_service)) {
                         // Is this service still present?
                         if (!memcmp(&pref_id->partition_id, cti_service->server, 4) &&
                             !memcmp(pref_id->prefix, &cti_service->server[4], 5))
                         {
                             break;
                         }
                     }
                 }
             } else {
                 i = services->num;
             }

             if (i == services->num) {
                 service_tracker_thread_service_note(tracker, service, "went away");
                 *pservice = service->next;
                 thread_service_release(service);
                 service = NULL;
             } else {
                 // We'll re-initialize these flags from the service list when we check for duplicates.
                 service->previous_user = service->user;
                 service->user = false;
                 service->previous_stable = service->stable;
                 service->stable = false;
                 service->previous_ncp = service->ncp;
                 service->ncp = false;
                 pservice = &service->next;
                 service->ignore = false;
             }
         }

         // Add any services that are not present.
         for (i = 0; i < services->num; i++) {
             cti_service_t *cti_service = services->services[i];
             for (service = tracker->thread_services; service != NULL; service = service->next) {
                 if (IS_SRP_SERVICE(cti_service) && service->service_type == unicast_service) {
                     if (!memcmp(&service->u.unicast.address, cti_service->server, 16) &&
                         !memcmp(&service->u.unicast.port, &cti_service->server[16], 2)) {
                         break;
                     }
                 } else if (IS_SRP_ANYCAST_SERVICE(cti_service) && service->service_type == anycast_service) {
                     uint8_t sequence_number = cti_service->service[1];
                     if (service->rloc16 == cti_service->rloc16 &&
                         service->u.anycast.sequence_number == sequence_number) {
                         break;
                     }
                 } else if (IS_PREF_ID_SERVICE(cti_service) && service->service_type == pref_id) {

                     if (!memcmp(&service->u.pref_id.partition_id, cti_service->server, 4) &&
                         !memcmp(service->u.pref_id.prefix, &cti_service->server[4], 5))
                     {
                         break;
                     }
                 }
             }
             if (service == NULL) {
                 bool save = false;
                 if (IS_SRP_SERVICE(cti_service)) {
                     service = thread_service_unicast_create(cti_service->rloc16, cti_service->server,
                                                             &cti_service->server[16], cti_service->service_id);
                     save = true;
                 } else if (IS_SRP_ANYCAST_SERVICE(cti_service)) {
                     uint8_t sequence_number = cti_service->service[1];
                     service = thread_service_anycast_create(cti_service->rloc16, sequence_number,
                                                             cti_service->service_id);
                     save = true;
                 } else if (IS_PREF_ID_SERVICE(cti_service)) {
                     save = true;
                     service = thread_service_pref_id_create(cti_service->rloc16, cti_service->server,
                                                             &cti_service->server[4], cti_service->service_id);
                 }
                 if (save) {
                     if (service == NULL) {
                         ERROR("[ST%lld] no memory for service.", tracker->id);
                     } else {
                         service_tracker_thread_service_note(tracker, service, "showed up");
                         *pservice = service;
                         pservice = &service->next;
                     }
                 }
             }
             // Also, since we're combing the list, update ncp, user and stable flags.   Note that a service can
             // appear more than once in the thread service list.
             if (service != NULL) {
                 if (cti_service->flags & kCTIFlag_NCP) {
                     service->ncp = true;
                 } else {
                     service->user = true;
                     tracker->user_service_seen = true;
                 }
                 if (cti_service->flags & kCTIFlag_Stable) {
                     service->stable = true;
                 }
             }
         }
         accumulator_t accumulator;
         for (service = tracker->thread_services; service != NULL; service = service->next) {
             // For unicast services, see if there's also an anycast service on the same RLOC16.
             if (service->service_type == unicast_service) {
                 service->u.unicast.anycast_also_present = false;
                 for (thread_service_t *aservice = tracker->thread_services; aservice != NULL; aservice = aservice->next)
                 {
                     if (aservice->service_type == anycast_service && aservice->rloc16 == service->rloc16) {
                         service->u.unicast.anycast_also_present = true;
                     }
                 }
             }
             service_tracker_flags_accumulator_init(&accumulator);
             service_tracker_flags_accumulate(&accumulator, service->previous_ncp, service->ncp, "ncp");
             service_tracker_flags_accumulate(&accumulator, service->previous_stable, service->ncp, "stable");
             service_tracker_flags_accumulate(&accumulator, service->previous_user, service->user, "user");
             if (accumulator.changed) {
                 service_tracker_thread_service_note(tracker, service, accumulator.change);
             }
         }

         // At this point the thread prefix list contains the same information as what we just received.
         // Call any callbacks to trigger updates based on new information.
         for (service_tracker_callback_t *callback = tracker->callbacks; callback != NULL; callback = callback->next) {
             callback->callback(callback->context);
         }
         if (!tracker->user_service_seen && tracker->server_state != NULL &&
             tracker->server_state->awaiting_service_removal)
         {
             tracker->server_state->awaiting_service_removal = false;
             adv_ctl_thread_shutdown_status_check(tracker->server_state);
         }
     }
 }

 bool
 service_tracker_local_service_seen(service_tracker_t *tracker)
 {
     return tracker->user_service_seen;
 }

 service_tracker_t *
 service_tracker_create(srp_server_t *server_state)
 {
 	service_tracker_t *ret = NULL;
 	service_tracker_t *tracker = calloc(1, sizeof(*ret));
 	if (tracker == NULL) {
 		ERROR("[ST%lld] no memory", ++service_tracker_serial_number);
 		goto exit;
 	}
 	RETAIN_HERE(tracker, service_tracker);
     tracker->id = ++service_tracker_serial_number;
     tracker->server_state = server_state;

 	ret = tracker;
 	tracker = NULL;
 exit:
 	if (tracker != NULL) {
 		RELEASE_HERE(tracker, service_tracker);
 	}
 	return ret;
 }

 void
 service_tracker_start(service_tracker_t *tracker)
 {
     if (tracker->thread_service_context != NULL) {
         cti_events_discontinue(tracker->thread_service_context);
         tracker->thread_service_context = NULL;
         INFO("[ST%lld] restarting", tracker->id);
         if (tracker->ref_count != 1) {
             RELEASE_HERE(tracker, service_tracker); // Release the old retain for the callback.
         } else {
             FAULT("service tracker reference count should not be 1 here!");
         }
     }
     int status = cti_get_service_list(tracker->server_state, &tracker->thread_service_context,
                                       tracker, service_tracker_callback, NULL);
     if (status != kCTIStatus_NoError) {
         INFO("[ST%lld] service list get failed: %d", tracker->id, status);
         return;
     }
     INFO("[ST%lld] service list get started", tracker->id);
     RETAIN_HERE(tracker, service_tracker); // for the callback.
 }

 bool
 service_tracker_callback_add(service_tracker_t *tracker,
 							 void (*callback)(void *context), void (*context_release)(void *context), void *context)
 {
 	bool ret = false;
     service_tracker_callback_t **tpp;

 	// It's an error for two callbacks to have the same context
 	for (tpp = &tracker->callbacks; *tpp != NULL; tpp = &(*tpp)->next) {
 		if ((*tpp)->context == context) {
 			FAULT("[ST%lld] duplicate context %p", tracker->id, context);
 			goto exit;
 		}
 	}

 	service_tracker_callback_t *tracker_callback = calloc(1, sizeof(*tracker_callback));
 	if (tracker_callback == NULL) {
 		ERROR("[ST%lld] no memory", tracker->id);
 		goto exit;
 	}
 	tracker_callback->callback = callback;
 	tracker_callback->context_release = context_release;
 	tracker_callback->context = context;

 	// The callback list holds a reference to the tracker
 	if (tracker->callbacks == NULL) {
 		RETAIN_HERE(tracker, service_tracker);
 	}

 	// Keep the callback on the list.
 	*tpp = tracker_callback;

 	ret = true;
 exit:
 	return ret;

 }

 static void
 service_tracker_callback_free(service_tracker_callback_t *callback)
 {
     if (callback->context_release != NULL) {
         callback->context_release(callback->context);
     }
     free(callback);
 }

 void
 service_tracker_stop(service_tracker_t *tracker)
 {
     if (tracker == NULL) {
         return;
     }
 	if (tracker->thread_service_context != NULL) {
 		cti_events_discontinue(tracker->thread_service_context);
 		tracker->thread_service_context = NULL;
 		RELEASE_HERE(tracker, service_tracker);
 	}
 }

 void
 service_tracker_cancel(service_tracker_t *tracker)
 {
     if (tracker == NULL) {
         return;
     }
     service_tracker_stop(tracker);

 	if (tracker->callbacks != NULL) {
         service_tracker_callback_t *next;
 		for (service_tracker_callback_t *callback = tracker->callbacks; callback != NULL; callback = next) {
 			next = callback->next;
             service_tracker_callback_free(callback);
         }
 		tracker->callbacks = NULL;
 		// Release the reference held by the callback list.
 		RELEASE_HERE(tracker, service_tracker);
 	}
 }

 void
 service_tracker_callback_cancel(service_tracker_t *tracker, void *context)
 {
     if (tracker == NULL) {
         return;
     }
 	for (service_tracker_callback_t **tpp = &tracker->callbacks; *tpp != NULL; tpp = &((*tpp)->next)) {
 		service_tracker_callback_t *callback = *tpp;
 		if (callback->context == context) {
             *tpp = callback->next;
             service_tracker_callback_free(callback);
             return;
 		}
 	}
 }

 static int
 service_tracker_get_winning_anycast_sequence_number(service_tracker_t *NULLABLE tracker)
 {
     if (tracker == NULL) {
         return -1;
     }
     int winning_sequence_number = -1;
     // Find the sequence number that would win.
     for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next)
     {
         if (service->ignore) {
             continue;
         }
         if ((int)service->u.anycast.sequence_number > winning_sequence_number) {
             winning_sequence_number = service->u.anycast.sequence_number;
         }
     }
     return winning_sequence_number;
 }

 thread_service_t *
 service_tracker_services_get(service_tracker_t *NULLABLE tracker)
 {
 	if (tracker != NULL) {
 		return tracker->thread_services;
 	}
     return NULL;
 }

 // Check to see if a service exists that matches the service passed in as an argument, and if it is still validated.
 // Service object might be a different object
 bool
 service_tracker_verified_service_still_exists(service_tracker_t *NULLABLE tracker, thread_service_t *old_service)
 {
     if (tracker == NULL || old_service == NULL) {
         return false;
     }
     for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
         if (service->ignore) {
             continue;
         }
         if (service->responding && old_service->service_type == service->service_type) {
             if (service->service_type == unicast_service) {
                 if (service->u.unicast.port == old_service->u.unicast.port &&
                     !memcmp(&service->u.unicast.address, &old_service->u.unicast.address,
                             sizeof(service->u.unicast.address)))
                 {
                     return true;
                 }
             } else if (service->service_type == anycast_service) {
                 if (service->u.anycast.sequence_number == old_service->u.anycast.sequence_number) {
                     return true;
                 }
             }
             FAULT("old_service type is bogus: %d", old_service->service_type);
             return false;
         }
     }
     return false;
 }

 // If true, there is a service on the list that we've verified. Return it (caller must retain if saving pointer).
 thread_service_t *
 service_tracker_verified_service_get(service_tracker_t *NULLABLE tracker)
 {
     if (tracker == NULL) {
         return false;
     }
     for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
         if (service->ignore) {
             continue;
         }
         if (service->checked && service->responding) {
             return service;
         }
     }
     return false;
 }

 // Check for an unverified service on the list. If we are currently checking a service, return that service.
 thread_service_t *
 service_tracker_unverified_service_get(service_tracker_t *NULLABLE tracker, thread_service_type_t service_type)
 {
     thread_service_t *ret = NULL;
     if (tracker != NULL) {
         for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
             if (service_type != any_service && service_type != service->service_type) {
                 continue;
             }
             if (service->ignore) {
                 continue;
             }
             if (service->checking) {
                 return service;
             }
             if (ret == NULL && !service->checked && !service->probe_state && !service->user) {
                 ret = service;
             }
         }
     }
     if (tracker != NULL && ret != NULL) {
         char buf[128];
         snprintf(buf, sizeof(buf), "service_tracker_unverified_service_get returning %p", ret);
         service_tracker_thread_service_note(tracker, ret, buf);
     }
     return ret;
 }

 static void
 service_tracker_probe_callback(thread_service_t *UNUSED service, void *context, bool UNUSED succeeded)
 {
     service_tracker_t *tracker = context;
     // Notify consumers of service tracker callbacks that something has changed.
     for (service_tracker_callback_t *callback = tracker->callbacks; callback != NULL; callback = callback->next) {
         callback->callback(callback->context);
     }
 }

 // Find a service that is not currently being probed and has not been probed, and start probing it. If we are already probing a service,
 // or if there are no services remaining to probe, do nothing.
 void
 service_tracker_verify_next_service(service_tracker_t *NULLABLE tracker)
 {
     thread_service_t *service;
     if (tracker == NULL) {
         return;
     }
     int winning_sequence_number = service_tracker_get_winning_anycast_sequence_number(tracker);

     for (service = tracker->thread_services; service != NULL; service = service->next) {
         if (service->probe_state) {
             return;
         }
         // For anycast services, if not on the winning sequence number, don't check
         if (service->service_type == anycast_service && service->u.anycast.sequence_number != winning_sequence_number) {
             continue;
         }
         // If this is our service, we don't need to check it.
         if (service->user) {
             continue;
         }
         // If we've probed it recently, don't probe it again yet.
         if (srp_time() - service->last_probe_time < 300)
         {
             continue;
         }
         if (service->checked) {
             continue;
         }
         // If we didn't continue, yet, it's because we found a service we can probe, so probe it.
         RETAIN_HERE(tracker, service_tracker); // For the srp probe
         probe_srp_service(service, tracker, service_tracker_probe_callback, service_tracker_context_release);
         return;
     }
 }

 void
 service_tracker_cancel_probes(service_tracker_t *NULLABLE tracker)
 {
     if (tracker == NULL) {
         return;
     }
     for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
         if (service->probe_state) {
             probe_srp_service_probe_cancel(service);
         }
     }
 }

 // Local Variables:
 // mode: C
 // tab-width: 4
 // c-file-style: "bsd"
 // c-basic-offset: 4
 // fill-column: 120
 // indent-tabs-mode: nil
 // End:
	/* service-tracker.c
	*
	* Copyright (c) 2023-2024 Apple 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
	*
	* https://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.
	*
	* Track services on the Thread mesh.
	*/

	#include <stdlib.h>
	#include <string.h>
	#include <stdio.h>
	#include <unistd.h>
	#include <pwd.h>
	#include <errno.h>
	#include <sys/socket.h>
	#include <netinet/in.h>
	#include <arpa/inet.h>
	#include <fcntl.h>
	#include <time.h>
	#include <dns_sd.h>
	#include <net/if.h>
	#include <inttypes.h>
	#include <sys/resource.h>
	#include <netinet/icmp6.h>
	#include "srp.h"
	#include "dns-msg.h"
	#include "srp-crypto.h"
	#include "ioloop.h"
	#include "srp-gw.h"
	#include "srp-proxy.h"
	#include "srp-mdns-proxy.h"
	#include "dnssd-proxy.h"
	#include "config-parse.h"
	#include "cti-services.h"
	#include "thread-device.h"
	#include "state-machine.h"
	#include "thread-service.h"
	#include "service-tracker.h"
	#include "probe-srp.h"
	#include "adv-ctl-server.h"

	struct service_tracker_callback {
	service_tracker_callback_t *next;
	void (context_release)(void NONNULL context);
	void (callback)(void context);
	void *context;
	};

	struct service_tracker {
	int ref_count;
	uint64_t id;
	route_state_t *route_state;
	srp_server_t *server_state;
	cti_connection_t NULLABLE thread_service_context;
	service_tracker_callback_t *callbacks;
	thread_service_t *NULLABLE thread_services;
	uint16_t rloc16;
	bool user_service_seen;
	};

	static uint64_t service_tracker_serial_number = 0;

	static void
	service_tracker_finalize(service_tracker_t *tracker)
	{
	thread_service_t *next;
	for (thread_service_t *service = tracker->thread_services; service != NULL; service = next) {
	next = service->next;
	thread_service_release(service);
	}
	free(tracker);
	}

	static void
	service_tracker_context_release(void *context)
	{
	service_tracker_t *tracker = context;
	if (tracker != NULL) {
	RELEASE_HERE(tracker, service_tracker);
	}
	}

	RELEASE_RETAIN_FUNCS(service_tracker);

	void
	service_tracker_thread_service_note(service_tracker_t tracker, thread_service_t tservice, const char *event_description)
	{
	char owner_id[20];
	snprintf(owner_id, sizeof(owner_id), "[ST%lld]", tracker->id);
	thread_service_note(owner_id, tservice, event_description);
	}

	typedef struct state_debug_accumulator {
	char change[20]; // " +stable +user +ncp"
	char *p_change;
	size_t left;
	bool changed;
	} accumulator_t;

	static void
	service_tracker_flags_accumulator_init(accumulator_t *accumulator)
	{
	memset(accumulator, 0, sizeof(*accumulator));
	accumulator->p_change = accumulator->change;
	accumulator->left = sizeof(accumulator->change);
	}

	static void
	service_tracker_flags_accumulate(accumulator_t accumulator, bool previous, bool cur, const char name)
	{
	size_t len;
	if (previous != cur) {
	snprintf(accumulator->p_change, accumulator->left, "%s%s%s",
	accumulator->p_change == accumulator->change ? "" : " ", cur ? "+" : "-", name);
	len = strlen(accumulator->p_change);
	accumulator->p_change += len;
	accumulator->left -= len;
	accumulator->changed = true;
	}
	}

	static void
	service_tracker_callback(void context, cti_service_vec_t services, cti_status_t status)
	{
	service_tracker_t *tracker = context;
	size_t i;
	thread_service_t *pservice = &tracker->thread_services, service = NULL;
	tracker->user_service_seen = false;

	if (status == kCTIStatus_Disconnected \|\| status == kCTIStatus_DaemonNotRunning) {
	INFO("[ST%lld] disconnected", tracker->id);
	cti_events_discontinue(tracker->thread_service_context);
	tracker->thread_service_context = NULL;
	RELEASE_HERE(tracker, service_tracker); // Not expecting any more callbacks.
	return;
	}

	if (status != kCTIStatus_NoError) {
	ERROR("[ST%lld] %d", tracker->id, status);
	} else {
	// Delete any SRP services that are not in the list provided by Thread.
	while (*pservice != NULL) {
	service = *pservice;
	if (service->service_type == unicast_service) {
	struct thread_unicast_service *uservice = &service->u.unicast;
	for (i = 0; i < services->num; i++) {
	cti_service_t *cti_service = services->services[i];
	// Is this a valid SRP service?
	if (IS_SRP_SERVICE(cti_service)) {
	// Is this service still present?
	if (!memcmp(&uservice->address, cti_service->server, 16) &&
	!memcmp(&uservice->port, &cti_service->server[16], 2)) {
	break;
	}
	}
	}
	} else if (service->service_type == anycast_service) {
	struct thread_anycast_service *aservice = &service->u.anycast;
	for (i = 0; i < services->num; i++) {
	cti_service_t *cti_service = services->services[i];
	// Is this a valid SRP anycast service?
	if (IS_SRP_ANYCAST_SERVICE(cti_service)) {
	// Is this service still present?
	if (service->rloc16 == cti_service->rloc16 &&
	aservice->sequence_number == cti_service->service[1]) {
	break;
	}
	}
	}
	} else if (service->service_type == pref_id) {
	struct thread_pref_id *pref_id = &service->u.pref_id;
	for (i = 0; i < services->num; i++) {
	cti_service_t *cti_service = services->services[i];
	// Is this an SRP service?
	if (IS_PREF_ID_SERVICE(cti_service)) {
	// Is this service still present?
	if (!memcmp(&pref_id->partition_id, cti_service->server, 4) &&
	!memcmp(pref_id->prefix, &cti_service->server[4], 5))
	{
	break;
	}
	}
	}
	} else {
	i = services->num;
	}

	if (i == services->num) {
	service_tracker_thread_service_note(tracker, service, "went away");
	*pservice = service->next;
	thread_service_release(service);
	service = NULL;
	} else {
	// We'll re-initialize these flags from the service list when we check for duplicates.
	service->previous_user = service->user;
	service->user = false;
	service->previous_stable = service->stable;
	service->stable = false;
	service->previous_ncp = service->ncp;
	service->ncp = false;
	pservice = &service->next;
	service->ignore = false;
	}
	}

	// Add any services that are not present.
	for (i = 0; i < services->num; i++) {
	cti_service_t *cti_service = services->services[i];
	for (service = tracker->thread_services; service != NULL; service = service->next) {
	if (IS_SRP_SERVICE(cti_service) && service->service_type == unicast_service) {
	if (!memcmp(&service->u.unicast.address, cti_service->server, 16) &&
	!memcmp(&service->u.unicast.port, &cti_service->server[16], 2)) {
	break;
	}
	} else if (IS_SRP_ANYCAST_SERVICE(cti_service) && service->service_type == anycast_service) {
	uint8_t sequence_number = cti_service->service[1];
	if (service->rloc16 == cti_service->rloc16 &&
	service->u.anycast.sequence_number == sequence_number) {
	break;
	}
	} else if (IS_PREF_ID_SERVICE(cti_service) && service->service_type == pref_id) {

	if (!memcmp(&service->u.pref_id.partition_id, cti_service->server, 4) &&
	!memcmp(service->u.pref_id.prefix, &cti_service->server[4], 5))
	{
	break;
	}
	}
	}
	if (service == NULL) {
	bool save = false;
	if (IS_SRP_SERVICE(cti_service)) {
	service = thread_service_unicast_create(cti_service->rloc16, cti_service->server,
	&cti_service->server[16], cti_service->service_id);
	save = true;
	} else if (IS_SRP_ANYCAST_SERVICE(cti_service)) {
	uint8_t sequence_number = cti_service->service[1];
	service = thread_service_anycast_create(cti_service->rloc16, sequence_number,
	cti_service->service_id);
	save = true;
	} else if (IS_PREF_ID_SERVICE(cti_service)) {
	save = true;
	service = thread_service_pref_id_create(cti_service->rloc16, cti_service->server,
	&cti_service->server[4], cti_service->service_id);
	}
	if (save) {
	if (service == NULL) {
	ERROR("[ST%lld] no memory for service.", tracker->id);
	} else {
	service_tracker_thread_service_note(tracker, service, "showed up");
	*pservice = service;
	pservice = &service->next;
	}
	}
	}
	// Also, since we're combing the list, update ncp, user and stable flags. Note that a service can
	// appear more than once in the thread service list.
	if (service != NULL) {
	if (cti_service->flags & kCTIFlag_NCP) {
	service->ncp = true;
	} else {
	service->user = true;
	tracker->user_service_seen = true;
	}
	if (cti_service->flags & kCTIFlag_Stable) {
	service->stable = true;
	}
	}
	}
	accumulator_t accumulator;
	for (service = tracker->thread_services; service != NULL; service = service->next) {
	// For unicast services, see if there's also an anycast service on the same RLOC16.
	if (service->service_type == unicast_service) {
	service->u.unicast.anycast_also_present = false;
	for (thread_service_t *aservice = tracker->thread_services; aservice != NULL; aservice = aservice->next)
	{
	if (aservice->service_type == anycast_service && aservice->rloc16 == service->rloc16) {
	service->u.unicast.anycast_also_present = true;
	}
	}
	}
	service_tracker_flags_accumulator_init(&accumulator);
	service_tracker_flags_accumulate(&accumulator, service->previous_ncp, service->ncp, "ncp");
	service_tracker_flags_accumulate(&accumulator, service->previous_stable, service->ncp, "stable");
	service_tracker_flags_accumulate(&accumulator, service->previous_user, service->user, "user");
	if (accumulator.changed) {
	service_tracker_thread_service_note(tracker, service, accumulator.change);
	}
	}

	// At this point the thread prefix list contains the same information as what we just received.
	// Call any callbacks to trigger updates based on new information.
	for (service_tracker_callback_t *callback = tracker->callbacks; callback != NULL; callback = callback->next) {
	callback->callback(callback->context);
	}
	if (!tracker->user_service_seen && tracker->server_state != NULL &&
	tracker->server_state->awaiting_service_removal)
	{
	tracker->server_state->awaiting_service_removal = false;
	adv_ctl_thread_shutdown_status_check(tracker->server_state);
	}
	}
	}

	bool
	service_tracker_local_service_seen(service_tracker_t *tracker)
	{
	return tracker->user_service_seen;
	}

	service_tracker_t *
	service_tracker_create(srp_server_t *server_state)
	{
	service_tracker_t *ret = NULL;
	service_tracker_t tracker = calloc(1, sizeof(ret));
	if (tracker == NULL) {
	ERROR("[ST%lld] no memory", ++service_tracker_serial_number);
	goto exit;
	}
	RETAIN_HERE(tracker, service_tracker);
	tracker->id = ++service_tracker_serial_number;
	tracker->server_state = server_state;

	ret = tracker;
	tracker = NULL;
	exit:
	if (tracker != NULL) {
	RELEASE_HERE(tracker, service_tracker);
	}
	return ret;
	}

	void
	service_tracker_start(service_tracker_t *tracker)
	{
	if (tracker->thread_service_context != NULL) {
	cti_events_discontinue(tracker->thread_service_context);
	tracker->thread_service_context = NULL;
	INFO("[ST%lld] restarting", tracker->id);
	if (tracker->ref_count != 1) {
	RELEASE_HERE(tracker, service_tracker); // Release the old retain for the callback.
	} else {
	FAULT("service tracker reference count should not be 1 here!");
	}
	}
	int status = cti_get_service_list(tracker->server_state, &tracker->thread_service_context,
	tracker, service_tracker_callback, NULL);
	if (status != kCTIStatus_NoError) {
	INFO("[ST%lld] service list get failed: %d", tracker->id, status);
	return;
	}
	INFO("[ST%lld] service list get started", tracker->id);
	RETAIN_HERE(tracker, service_tracker); // for the callback.
	}

	bool
	service_tracker_callback_add(service_tracker_t *tracker,
	void (callback)(void context), void (context_release)(void context), void *context)
	{
	bool ret = false;
	service_tracker_callback_t **tpp;

	// It's an error for two callbacks to have the same context
	for (tpp = &tracker->callbacks; tpp != NULL; tpp = &(tpp)->next) {
	if ((*tpp)->context == context) {
	FAULT("[ST%lld] duplicate context %p", tracker->id, context);
	goto exit;
	}
	}

	service_tracker_callback_t tracker_callback = calloc(1, sizeof(tracker_callback));
	if (tracker_callback == NULL) {
	ERROR("[ST%lld] no memory", tracker->id);
	goto exit;
	}
	tracker_callback->callback = callback;
	tracker_callback->context_release = context_release;
	tracker_callback->context = context;

	// The callback list holds a reference to the tracker
	if (tracker->callbacks == NULL) {
	RETAIN_HERE(tracker, service_tracker);
	}

	// Keep the callback on the list.
	*tpp = tracker_callback;

	ret = true;
	exit:
	return ret;

	}

	static void
	service_tracker_callback_free(service_tracker_callback_t *callback)
	{
	if (callback->context_release != NULL) {
	callback->context_release(callback->context);
	}
	free(callback);
	}

	void
	service_tracker_stop(service_tracker_t *tracker)
	{
	if (tracker == NULL) {
	return;
	}
	if (tracker->thread_service_context != NULL) {
	cti_events_discontinue(tracker->thread_service_context);
	tracker->thread_service_context = NULL;
	RELEASE_HERE(tracker, service_tracker);
	}
	}

	void
	service_tracker_cancel(service_tracker_t *tracker)
	{
	if (tracker == NULL) {
	return;
	}
	service_tracker_stop(tracker);

	if (tracker->callbacks != NULL) {
	service_tracker_callback_t *next;
	for (service_tracker_callback_t *callback = tracker->callbacks; callback != NULL; callback = next) {
	next = callback->next;
	service_tracker_callback_free(callback);
	}
	tracker->callbacks = NULL;
	// Release the reference held by the callback list.
	RELEASE_HERE(tracker, service_tracker);
	}
	}

	void
	service_tracker_callback_cancel(service_tracker_t tracker, void context)
	{
	if (tracker == NULL) {
	return;
	}
	for (service_tracker_callback_t *tpp = &tracker->callbacks; tpp != NULL; tpp = &((*tpp)->next)) {
	service_tracker_callback_t callback = tpp;
	if (callback->context == context) {
	*tpp = callback->next;
	service_tracker_callback_free(callback);
	return;
	}
	}
	}

	static int
	service_tracker_get_winning_anycast_sequence_number(service_tracker_t *NULLABLE tracker)
	{
	if (tracker == NULL) {
	return -1;
	}
	int winning_sequence_number = -1;
	// Find the sequence number that would win.
	for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next)
	{
	if (service->ignore) {
	continue;
	}
	if ((int)service->u.anycast.sequence_number > winning_sequence_number) {
	winning_sequence_number = service->u.anycast.sequence_number;
	}
	}
	return winning_sequence_number;
	}

	thread_service_t *
	service_tracker_services_get(service_tracker_t *NULLABLE tracker)
	{
	if (tracker != NULL) {
	return tracker->thread_services;
	}
	return NULL;
	}

	// Check to see if a service exists that matches the service passed in as an argument, and if it is still validated.
	// Service object might be a different object
	bool
	service_tracker_verified_service_still_exists(service_tracker_t NULLABLE tracker, thread_service_t old_service)
	{
	if (tracker == NULL \|\| old_service == NULL) {
	return false;
	}
	for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
	if (service->ignore) {
	continue;
	}
	if (service->responding && old_service->service_type == service->service_type) {
	if (service->service_type == unicast_service) {
	if (service->u.unicast.port == old_service->u.unicast.port &&
	!memcmp(&service->u.unicast.address, &old_service->u.unicast.address,
	sizeof(service->u.unicast.address)))
	{
	return true;
	}
	} else if (service->service_type == anycast_service) {
	if (service->u.anycast.sequence_number == old_service->u.anycast.sequence_number) {
	return true;
	}
	}
	FAULT("old_service type is bogus: %d", old_service->service_type);
	return false;
	}
	}
	return false;
	}

	// If true, there is a service on the list that we've verified. Return it (caller must retain if saving pointer).
	thread_service_t *
	service_tracker_verified_service_get(service_tracker_t *NULLABLE tracker)
	{
	if (tracker == NULL) {
	return false;
	}
	for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
	if (service->ignore) {
	continue;
	}
	if (service->checked && service->responding) {
	return service;
	}
	}
	return false;
	}

	// Check for an unverified service on the list. If we are currently checking a service, return that service.
	thread_service_t *
	service_tracker_unverified_service_get(service_tracker_t *NULLABLE tracker, thread_service_type_t service_type)
	{
	thread_service_t *ret = NULL;
	if (tracker != NULL) {
	for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
	if (service_type != any_service && service_type != service->service_type) {
	continue;
	}
	if (service->ignore) {
	continue;
	}
	if (service->checking) {
	return service;
	}
	if (ret == NULL && !service->checked && !service->probe_state && !service->user) {
	ret = service;
	}
	}
	}
	if (tracker != NULL && ret != NULL) {
	char buf[128];
	snprintf(buf, sizeof(buf), "service_tracker_unverified_service_get returning %p", ret);
	service_tracker_thread_service_note(tracker, ret, buf);
	}
	return ret;
	}

	static void
	service_tracker_probe_callback(thread_service_t UNUSED service, void context, bool UNUSED succeeded)
	{
	service_tracker_t *tracker = context;
	// Notify consumers of service tracker callbacks that something has changed.
	for (service_tracker_callback_t *callback = tracker->callbacks; callback != NULL; callback = callback->next) {
	callback->callback(callback->context);
	}
	}

	// Find a service that is not currently being probed and has not been probed, and start probing it. If we are already probing a service,
	// or if there are no services remaining to probe, do nothing.
	void
	service_tracker_verify_next_service(service_tracker_t *NULLABLE tracker)
	{
	thread_service_t *service;
	if (tracker == NULL) {
	return;
	}
	int winning_sequence_number = service_tracker_get_winning_anycast_sequence_number(tracker);

	for (service = tracker->thread_services; service != NULL; service = service->next) {
	if (service->probe_state) {
	return;
	}
	// For anycast services, if not on the winning sequence number, don't check
	if (service->service_type == anycast_service && service->u.anycast.sequence_number != winning_sequence_number) {
	continue;
	}
	// If this is our service, we don't need to check it.
	if (service->user) {
	continue;
	}
	// If we've probed it recently, don't probe it again yet.
	if (srp_time() - service->last_probe_time < 300)
	{
	continue;
	}
	if (service->checked) {
	continue;
	}
	// If we didn't continue, yet, it's because we found a service we can probe, so probe it.
	RETAIN_HERE(tracker, service_tracker); // For the srp probe
	probe_srp_service(service, tracker, service_tracker_probe_callback, service_tracker_context_release);
	return;
	}
	}

	void
	service_tracker_cancel_probes(service_tracker_t *NULLABLE tracker)
	{
	if (tracker == NULL) {
	return;
	}
	for (thread_service_t *service = tracker->thread_services; service != NULL; service = service->next) {
	if (service->probe_state) {
	probe_srp_service_probe_cancel(service);
	}
	}
	}

	// Local Variables:
	// mode: C
	// tab-width: 4
	// c-file-style: "bsd"
	// c-basic-offset: 4
	// fill-column: 120
	// indent-tabs-mode: nil
	// End: