SCNetworkReachabilityServer_client.c   [plain text]

/*
 * Copyright (c) 2011, 2012 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <CoreFoundation/CoreFoundation.h>
#include <SystemConfiguration/SystemConfiguration.h>
#include <SystemConfiguration/SCPrivate.h>
#include "SCNetworkReachabilityInternal.h"

#ifdef	HAVE_REACHABILITY_SERVER

#include <xpc/xpc.h>
#include <xpc/private.h>

#include "rb.h"


#pragma mark -
#pragma mark Globals


static const struct addrinfo	hints0	= {
#ifdef  AI_PARALLEL
	.ai_flags	= AI_PARALLEL | AI_ADDRCONFIG
#else  // AI_PARALLEL
	.ai_flags	= AI_ADDRCONFIG
#endif  // AI_PARALLEL
};


static Boolean			serverAvailable	= TRUE;


#pragma mark -
#pragma mark Support functions


static void
log_xpc_object(const char *msg, xpc_object_t obj)
{
	char		*desc;

	desc = xpc_copy_description(obj);
	SCLog(TRUE, LOG_DEBUG, CFSTR("%s = %s"), msg, desc);
	free(desc);
}


#pragma mark -
#pragma mark Reachability [RBT] client support


typedef struct {
	struct rb_node			rbn;
	SCNetworkReachabilityRef	target;
} reach_request_t;


#define RBNODE_TO_REACH_REQUEST(node) \
	((reach_request_t *)((uintptr_t)node - offsetof(reach_request_t, rbn)))


static int
_rbt_compare_transaction_nodes(const struct rb_node *n1, const struct rb_node *n2)
{
	uint64_t	a = (uintptr_t)(RBNODE_TO_REACH_REQUEST(n1)->target);
	uint64_t	b = (uintptr_t)(RBNODE_TO_REACH_REQUEST(n2)->target);

	return (a - b);
}


static int
_rbt_compare_transaction_key(const struct rb_node *n1, const void *key)
{
	uint64_t	a = (uintptr_t)(RBNODE_TO_REACH_REQUEST(n1)->target);
	uint64_t	b = *(uint64_t *)key;

	return (a - b);
}


static struct rb_tree *
_reach_requests_rbt()
{
	static dispatch_once_t		once;
	static const struct rb_tree_ops	ops = {
		.rbto_compare_nodes	= _rbt_compare_transaction_nodes,
		.rbto_compare_key	= _rbt_compare_transaction_key,
	};
	static struct rb_tree		rbtree;

	dispatch_once(&once, ^{
		rb_tree_init(&rbtree, &ops);
	});

	return &rbtree;
}


static dispatch_queue_t
_reach_requests_rbt_queue()
{
	static dispatch_once_t	once;
	static dispatch_queue_t	q;

	dispatch_once(&once, ^{
		q = dispatch_queue_create(REACH_SERVICE_NAME ".rbt", NULL);
	});

	return q;
}


static reach_request_t *
_reach_request_create(SCNetworkReachabilityRef target)
{
	reach_request_t	*request;

	request = calloc(1, sizeof(*request));
	request->target = CFRetain(target);

	return request;
}


static void
_reach_request_release(reach_request_t *request)
{
	SCNetworkReachabilityRef	target	= request->target;

	CFRelease(target);
	free(request);

	return;
}


static void
_reach_request_add(SCNetworkReachabilityRef target)
{
	uint64_t	target_id	= (uintptr_t)target;

	dispatch_sync(_reach_requests_rbt_queue(), ^{
		struct rb_node		*rbn;

		rbn = rb_tree_find_node(_reach_requests_rbt(), &target_id);
		if (rbn == NULL) {
			reach_request_t	*request;

			request = _reach_request_create(target);
			if (request == NULL || !rb_tree_insert_node(_reach_requests_rbt(), &request->rbn)) {
				__builtin_trap();
			}
		}
	});

	return;
}


static void
_reach_request_remove(SCNetworkReachabilityRef target)
{
	uint64_t	target_id	= (uintptr_t)target;

	dispatch_sync(_reach_requests_rbt_queue(), ^{		// FIXME ?? use dispatch_async?
		struct rb_node		*rbn;
		struct rb_tree		*rbtree = _reach_requests_rbt();

		rbn = rb_tree_find_node(rbtree, &target_id);
		if (rbn != NULL) {
			reach_request_t	*request	= RBNODE_TO_REACH_REQUEST(rbn);

			rb_tree_remove_node(rbtree, rbn);
			_reach_request_release(request);
		}
	});
}


static SCNetworkReachabilityRef
_reach_request_copy_target(uint64_t target_id)
{
	__block SCNetworkReachabilityRef	target	= NULL;

	dispatch_sync(_reach_requests_rbt_queue(), ^{
		struct rb_node	*rbn;

		rbn = rb_tree_find_node(_reach_requests_rbt(), &target_id);
		if (rbn != NULL) {
			// handle the [async] reply
			target = (SCNetworkReachabilityRef)(uintptr_t)target_id;
			CFRetain(target);
		}
	});

	return target;
}


#pragma mark -
#pragma mark Reachability [XPC] client support


static void
handle_reachability_status(SCNetworkReachabilityRef target, xpc_object_t dict)
{
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	if (_sc_debug) {
		SCLog(TRUE, LOG_INFO, CFSTR("%sgot [async] notification"),
		      targetPrivate->log_prefix);
//		log_xpc_object("  status", dict);
	}

	__SCNetworkReachabilityPerformNoLock(target);

	return;
}


static void
handle_async_notification(SCNetworkReachabilityRef target, xpc_object_t dict)
{
	int64_t				op;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	op = xpc_dictionary_get_int64(dict, MESSAGE_NOTIFY);
	switch (op) {
		case MESSAGE_REACHABILITY_STATUS :
			handle_reachability_status(target, dict);
			break;
		default :
			SCLog(TRUE, LOG_ERR, CFSTR("%sgot [async] unknown reply : %d"),
			      targetPrivate->log_prefix,
			      op);
			log_xpc_object("  reply", dict);
			break;
	}

	return;
}


static dispatch_queue_t
_reach_xpc_queue()
{
	static dispatch_once_t	once;
	static dispatch_queue_t	q;

	dispatch_once(&once, ^{
		q = dispatch_queue_create(REACH_SERVICE_NAME ".xpc", NULL);
	});

	return q;
}


static void
_reach_connection_reconnect(xpc_connection_t connection);


static xpc_connection_t
_reach_connection_create()
{
	xpc_connection_t		c;
	const char			*name;
	dispatch_queue_t		q	= _reach_xpc_queue();

	// create XPC connection
	name = getenv("REACH_SERVER");
	if ((name == NULL) || (issetugid() != 0)) {
		name = REACH_SERVICE_NAME;
	}

	c = xpc_connection_create_mach_service(name,
					       q,
					       XPC_CONNECTION_MACH_SERVICE_PRIVILEGED);

	xpc_connection_set_event_handler(c, ^(xpc_object_t xobj) {
		xpc_type_t	type;

		type = xpc_get_type(xobj);
		if (type == XPC_TYPE_DICTIONARY) {
			SCNetworkReachabilityRef	target;
			uint64_t			target_id;

			target_id = xpc_dictionary_get_uint64(xobj, REACH_CLIENT_TARGET_ID);
			if (target_id == 0) {
				SCLog(TRUE, LOG_ERR,
				      CFSTR("reach client %p: async reply with no target [ID]"),
				      c);
				log_xpc_object("  reply", xobj);
				return;
			}

			target = _reach_request_copy_target(target_id);
			if (target == NULL) {
				SCLog(TRUE, LOG_ERR,
				      CFSTR("received unexpected target [ID] from SCNetworkReachability server"));
				log_xpc_object("  reply", xobj);
				return;
			}

			handle_async_notification(target, xobj);
			CFRelease(target);

		} else if (type == XPC_TYPE_ERROR) {
			if (xobj == XPC_ERROR_CONNECTION_INVALID) {
				SCLog(TRUE, LOG_ERR,
				      CFSTR("SCNetworkReachability server not available"));
				serverAvailable = FALSE;
			} else if (xobj == XPC_ERROR_CONNECTION_INTERRUPTED) {
				SCLog(TRUE, LOG_DEBUG,
				      CFSTR("SCNetworkReachability server failure, reconnecting"));
				_reach_connection_reconnect(c);
			} else {
				const char	*desc;

				desc = xpc_dictionary_get_string(xobj, XPC_ERROR_KEY_DESCRIPTION);
				SCLog(TRUE, LOG_ERR,
				      CFSTR("reach client %p: Connection error: %s"),
				      c,
				      desc);
			}

		} else {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("reach client %p: unknown event type : %x"),
			      c,
			      type);
		}
	});
	xpc_connection_resume(c);

	return c;
}


static xpc_connection_t
_reach_connection()
{
	static xpc_connection_t		c;
	static dispatch_once_t		once;
	static dispatch_queue_t		q;

	if (!serverAvailable) {
		// if SCNetworkReachabilty [XPC] server not available
		return NULL;
	}

	dispatch_once(&once, ^{
		q = dispatch_queue_create(REACH_SERVICE_NAME ".connection", NULL);
	});

	dispatch_sync(q, ^{
		if (c == NULL) {
			c = _reach_connection_create();
		}
	});

	return c;
}


typedef void (^reach_server_reply_handler_t)(xpc_object_t reply);


static void
add_proc_name(xpc_object_t reqdict)
{
	static const char	*name	= NULL;
	static dispatch_once_t	once;

	// add the process name
	dispatch_once(&once, ^{
		name = getprogname();
	});
	xpc_dictionary_set_string(reqdict, REACH_CLIENT_PROC_NAME, name);

	return;
}


static void
_reach_server_target_reconnect(xpc_connection_t connection, SCNetworkReachabilityRef target);


static Boolean
_reach_server_target_add(xpc_connection_t connection, SCNetworkReachabilityRef target)
{
	Boolean				ok		= FALSE;
	xpc_object_t			reply;
	xpc_object_t			reqdict;
	Boolean				retry		= FALSE;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	// create message
	reqdict = xpc_dictionary_create(NULL, NULL, 0);

	// set request
	xpc_dictionary_set_int64(reqdict, REACH_REQUEST, REACH_REQUEST_CREATE);

	// add reachability target info
	if (targetPrivate->name != NULL) {
		xpc_dictionary_set_string(reqdict,
					  REACH_TARGET_NAME,
					  targetPrivate->name);
	}
	if (targetPrivate->serv != NULL) {
		xpc_dictionary_set_string(reqdict,
					  REACH_TARGET_SERV,
					  targetPrivate->serv);
	}
	if (targetPrivate->localAddress != NULL) {
		xpc_dictionary_set_data(reqdict,
					REACH_TARGET_LOCAL_ADDR,
					targetPrivate->localAddress,
					targetPrivate->localAddress->sa_len);
	}
	if (targetPrivate->remoteAddress != NULL) {
		xpc_dictionary_set_data(reqdict,
					REACH_TARGET_REMOTE_ADDR,
					targetPrivate->remoteAddress,
					targetPrivate->remoteAddress->sa_len);
	}
	if (bcmp(&targetPrivate->hints, &hints0, sizeof(struct addrinfo)) != 0) {
		xpc_dictionary_set_data(reqdict,
					REACH_TARGET_HINTS,
					&targetPrivate->hints,
					sizeof(targetPrivate->hints));
	}
	if (targetPrivate->if_index != 0) {
		xpc_dictionary_set_int64(reqdict,
					 REACH_TARGET_IF_INDEX,
					 targetPrivate->if_index);
		xpc_dictionary_set_string(reqdict,
					  REACH_TARGET_IF_NAME,
					  targetPrivate->if_name);
	}
	if (targetPrivate->onDemandBypass) {
		xpc_dictionary_set_bool(reqdict,
					REACH_TARGET_ONDEMAND_BYPASS,
					TRUE);
	}
	if (targetPrivate->resolverBypass) {
		xpc_dictionary_set_bool(reqdict,
					REACH_TARGET_RESOLVER_BYPASS,
					TRUE);
	}


	// add the target [ID]
	xpc_dictionary_set_uint64(reqdict, REACH_CLIENT_TARGET_ID, (uintptr_t)target);

	// add the process name (for debugging)
	add_proc_name(reqdict);

    retry :

	// send request to the SCNetworkReachability server
	reply = xpc_connection_send_message_with_reply_sync(connection, reqdict);
	if (reply != NULL) {
		xpc_type_t	type;

		type = xpc_get_type(reply);
		if (type == XPC_TYPE_DICTIONARY) {
			int64_t		status;

			status = xpc_dictionary_get_int64(reply, REACH_REQUEST_REPLY);
			ok = (status == REACH_REQUEST_REPLY_OK);
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INVALID)) {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("SCNetworkReachability server not available"));
			serverAvailable = FALSE;
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INTERRUPTED)) {
			SCLog(TRUE, LOG_DEBUG,
			      CFSTR("reach target %p: SCNetworkReachability server failure, retrying"),
			      target);
			retry = TRUE;
		} else {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("reach target %p: _targetAdd with unexpected reply"),
			      target);
			log_xpc_object("  reply", reply);
		}

		xpc_release(reply);
	}

	if (retry) {
		retry = FALSE;
		goto retry;
	}

	xpc_release(reqdict);
	return ok;
}


static Boolean
_reach_server_target_remove(xpc_connection_t connection, SCNetworkReachabilityRef target)
{
	Boolean				ok		= FALSE;
	xpc_object_t			reply;
	xpc_object_t			reqdict;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	// create message
	reqdict = xpc_dictionary_create(NULL, NULL, 0);

	// set request
	xpc_dictionary_set_int64(reqdict, REACH_REQUEST, REACH_REQUEST_REMOVE);

	// add the target [ID]
	xpc_dictionary_set_uint64(reqdict, REACH_CLIENT_TARGET_ID, (uintptr_t)target);

	reply = xpc_connection_send_message_with_reply_sync(connection, reqdict);
	if (reply != NULL) {
		xpc_type_t	type;

		type = xpc_get_type(reply);
		if (type == XPC_TYPE_DICTIONARY) {
			int64_t		status;

			status = xpc_dictionary_get_int64(reply, REACH_REQUEST_REPLY);
			switch (status) {
				case REACH_REQUEST_REPLY_OK :
					ok = TRUE;
					break;
				case REACH_REQUEST_REPLY_UNKNOWN :
					SCLog(TRUE, LOG_DEBUG,
					      CFSTR("reach target %p: SCNetworkReachability server failure, no need to remove"),
					      target);
					ok = TRUE;
					break;
				default : {
					SCLog(TRUE, LOG_ERR, CFSTR("%s  target remove failed"),
					      targetPrivate->log_prefix);
					log_xpc_object("  reply", reply);
				}
			}
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INVALID)) {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("SCNetworkReachability server not available"));
			serverAvailable = FALSE;
			ok = TRUE;
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INTERRUPTED)) {
			SCLog(TRUE, LOG_DEBUG,
			      CFSTR("reach target %p: SCNetworkReachability server failure, no need to remove"),
			      target);
			ok = TRUE;
		} else {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("reach target %p: _targetRemove with unexpected reply"),
			      target);
			log_xpc_object("  reply", reply);
		}

		xpc_release(reply);
	}

	xpc_release(reqdict);
	return ok;
}


static Boolean
_reach_server_target_schedule(xpc_connection_t connection, SCNetworkReachabilityRef target)
{
	Boolean				ok		= FALSE;
	xpc_object_t			reply;
	xpc_object_t			reqdict;
	Boolean				retry		= FALSE;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	// create message
	reqdict = xpc_dictionary_create(NULL, NULL, 0);

	// set request
	xpc_dictionary_set_int64(reqdict, REACH_REQUEST, REACH_REQUEST_SCHEDULE);

	// add the target [ID]
	xpc_dictionary_set_uint64(reqdict, REACH_CLIENT_TARGET_ID, (uintptr_t)target);

    retry :

	reply = xpc_connection_send_message_with_reply_sync(connection, reqdict);
	if (reply != NULL) {
		xpc_type_t	type;

		type = xpc_get_type(reply);
		if (type == XPC_TYPE_DICTIONARY) {
			int64_t		status;

			status = xpc_dictionary_get_int64(reply, REACH_REQUEST_REPLY);
			switch (status) {
				case REACH_REQUEST_REPLY_OK :
					ok = TRUE;
					break;
				case REACH_REQUEST_REPLY_UNKNOWN :
					SCLog(TRUE, LOG_DEBUG,
					      CFSTR("reach target %p: SCNetworkReachability server failure, retry schedule"),
					      target);
					retry = TRUE;
					break;
				default : {
					SCLog(TRUE, LOG_ERR, CFSTR("%s  target schedule failed"),
					      targetPrivate->log_prefix);
					log_xpc_object("  reply", reply);
				}
			}

			if (ok) {
				CFRetain(target);
			}
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INVALID)) {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("SCNetworkReachability server not available"));
			serverAvailable = FALSE;
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INTERRUPTED)) {
			SCLog(TRUE, LOG_DEBUG,
			      CFSTR("reach target %p: SCNetworkReachability server failure, retry schedule"),
			      target);
			retry = TRUE;
		} else {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("reach target %p: _targetSchedule with unexpected reply"),
			      target);
			log_xpc_object("  reply", reply);
		}

		xpc_release(reply);
	}

	if (retry) {
		// reconnect
		_reach_server_target_reconnect(connection, target);

		// and retry
		retry = FALSE;
		goto retry;
	}

	xpc_release(reqdict);
	return ok;
}


static void
_reach_reply_set_reachability(SCNetworkReachabilityRef	target,
			      xpc_object_t		reply)
{
	char				*if_name;
	size_t				len		= 0;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	targetPrivate->serverInfo.cycle = xpc_dictionary_get_uint64(reply,
								    REACH_STATUS_CYCLE);

	targetPrivate->serverInfo.flags = xpc_dictionary_get_uint64(reply,
								    REACH_STATUS_FLAGS);

	targetPrivate->serverInfo.if_index = xpc_dictionary_get_uint64(reply,
								       REACH_STATUS_IF_INDEX);

	bzero(&targetPrivate->serverInfo.if_name, sizeof(targetPrivate->serverInfo.if_name));
	if_name = (void *)xpc_dictionary_get_data(reply,
						  REACH_STATUS_IF_NAME,
						  &len);
	if ((if_name != NULL) && (len > 0)) {
		if (len > sizeof(targetPrivate->serverInfo.if_name)) {
			len = sizeof(targetPrivate->serverInfo.if_name);
		}

		bcopy(if_name, targetPrivate->serverInfo.if_name, len);
	}

	targetPrivate->serverInfo.sleeping = xpc_dictionary_get_bool(reply,
								     REACH_STATUS_SLEEPING);

	if (targetPrivate->type == reachabilityTypeName) {
		xpc_object_t		addresses;

		if (targetPrivate->resolvedAddress != NULL) {
			CFRelease(targetPrivate->resolvedAddress);
			targetPrivate->resolvedAddress = NULL;
		}

		targetPrivate->resolvedAddressError = xpc_dictionary_get_int64(reply,
									       REACH_STATUS_RESOLVED_ADDRESS_ERROR);

		addresses = xpc_dictionary_get_value(reply, REACH_STATUS_RESOLVED_ADDRESS);
		if ((addresses != NULL) && (xpc_get_type(addresses) != XPC_TYPE_ARRAY)) {
			addresses = NULL;
		}

		if ((targetPrivate->resolvedAddressError == 0) && (addresses != NULL)) {
			int			i;
			int			n;
			CFMutableArrayRef	newAddresses;

			newAddresses = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);

			n = xpc_array_get_count(addresses);
			for (i = 0; i < n; i++) {
				struct addrinfo	*sa;
				size_t		len;
				CFDataRef	newAddress;

				sa = (struct addrinfo *)xpc_array_get_data(addresses, i, &len);
				newAddress = CFDataCreate(NULL, (const UInt8 *)sa, len);
				CFArrayAppendValue(newAddresses, newAddress);
				CFRelease(newAddress);
			}

			targetPrivate->resolvedAddress = newAddresses;
		} else {
			/* save the error associated with the attempt to resolve the name */
			targetPrivate->resolvedAddress = CFRetain(kCFNull);
		}
		targetPrivate->needResolve = FALSE;
	}

	return;
}


__private_extern__
Boolean
_reach_server_target_status(xpc_connection_t connection, SCNetworkReachabilityRef target)
{
	Boolean				ok		= FALSE;
	xpc_object_t			reply;
	xpc_object_t			reqdict;
	Boolean				retry		= FALSE;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	if (_sc_debug) {
		CFStringRef	str;

		str = _SCNetworkReachabilityCopyTargetDescription(target);
		SCLog(TRUE, LOG_INFO, CFSTR("%scheckReachability(%@)"),
		      targetPrivate->log_prefix,
		      str);
		CFRelease(str);
	}

	// create message
	reqdict = xpc_dictionary_create(NULL, NULL, 0);

	// set request
	xpc_dictionary_set_int64(reqdict, REACH_REQUEST, REACH_REQUEST_STATUS);

	// add the target [ID]
	xpc_dictionary_set_uint64(reqdict, REACH_CLIENT_TARGET_ID, (uintptr_t)target);

    retry :

	reply = xpc_connection_send_message_with_reply_sync(connection, reqdict);
	if (reply != NULL) {
		xpc_type_t	type;

		type = xpc_get_type(reply);
		if (type == XPC_TYPE_DICTIONARY) {
			int64_t		status;

			status = xpc_dictionary_get_int64(reply, REACH_REQUEST_REPLY);
			switch (status) {
				case REACH_REQUEST_REPLY_OK :
					ok = TRUE;
					break;
				case REACH_REQUEST_REPLY_UNKNOWN :
					SCLog(TRUE, LOG_DEBUG,
					      CFSTR("reach target %p: SCNetworkReachability server failure, retry status"),
					      target);
					retry = TRUE;
					break;
				default :
					SCLog(TRUE, LOG_INFO, CFSTR("%s  target status failed"),
					      targetPrivate->log_prefix);
					log_xpc_object("  reply", reply);
			}

			if (ok) {
				_reach_reply_set_reachability(target, reply);

				if (_sc_debug) {
					SCLog(TRUE, LOG_INFO, CFSTR("%s  flags     = 0x%08x"),
					      targetPrivate->log_prefix,
					      targetPrivate->serverInfo.flags);
					if (targetPrivate->serverInfo.if_index != 0) {
						SCLog(TRUE, LOG_INFO, CFSTR("%s  device    = %s (%hu%s)"),
						      targetPrivate->log_prefix,
						      targetPrivate->serverInfo.if_name,
						      targetPrivate->serverInfo.if_index,
						      targetPrivate->serverInfo.sleeping ? ", z" : "");
					}
					if (targetPrivate->serverInfo.cycle != targetPrivate->cycle) {
						SCLog(TRUE, LOG_INFO, CFSTR("%s  forced"),
						      targetPrivate->log_prefix);
					}
				}
			}
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INVALID)) {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("SCNetworkReachability server not available"));
			serverAvailable = FALSE;
			ok = TRUE;
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INTERRUPTED)) {
			SCLog(TRUE, LOG_DEBUG,
			      CFSTR("reach target %p: SCNetworkReachability server failure, retry status"),
			      target);
			retry = TRUE;
		} else {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("reach target %p: _targetStatus with unexpected reply"),
			      target);
			log_xpc_object("  reply", reply);
		}

		xpc_release(reply);
	}

	if (retry) {
		// reconnect
		_reach_server_target_reconnect(connection, target);

		// and retry
		retry = FALSE;
		goto retry;
	}

	xpc_release(reqdict);
	return ok;
}


static Boolean
_reach_server_target_unschedule(xpc_connection_t connection, SCNetworkReachabilityRef target)
{
	Boolean				ok		= FALSE;
	xpc_object_t			reply;
	xpc_object_t			reqdict;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	// create message
	reqdict = xpc_dictionary_create(NULL, NULL, 0);

	// set request
	xpc_dictionary_set_int64(reqdict, REACH_REQUEST, REACH_REQUEST_UNSCHEDULE);

	// add the target [ID]
	xpc_dictionary_set_uint64(reqdict, REACH_CLIENT_TARGET_ID, (uintptr_t)target);

	reply = xpc_connection_send_message_with_reply_sync(connection, reqdict);
	if (reply != NULL) {
		xpc_type_t	type;

		type = xpc_get_type(reply);
		if (type == XPC_TYPE_DICTIONARY) {
			int64_t		status;

			status = xpc_dictionary_get_int64(reply, REACH_REQUEST_REPLY);
			switch (status) {
				case REACH_REQUEST_REPLY_OK :
					ok = TRUE;
					break;
				case REACH_REQUEST_REPLY_UNKNOWN :
					SCLog(TRUE, LOG_DEBUG,
					      CFSTR("reach target %p: SCNetworkReachability server failure, no need to unschedule"),
					      target);
					break;
				default :
					SCLog(TRUE, LOG_INFO, CFSTR("%s  target unschedule failed"),
					      targetPrivate->log_prefix);
					log_xpc_object("  reply", reply);
			}

			if (ok) {
				CFRelease(target);
			}
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INVALID)) {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("SCNetworkReachability server not available"));
			serverAvailable = FALSE;
			ok = TRUE;
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INTERRUPTED)) {
			SCLog(TRUE, LOG_DEBUG,
			      CFSTR("reach target %p: SCNetworkReachability server failure, no need to unschedule"),
			      target);
			ok = TRUE;
		} else {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("reach target %p: _targetUnschedule with unexpected reply"),
			      target);
			log_xpc_object("  reply", reply);
		}

		xpc_release(reply);
	}

	xpc_release(reqdict);
	return ok;
}


#pragma mark -
#pragma mark Reconnect


static void
_reach_server_target_reconnect(xpc_connection_t connection, SCNetworkReachabilityRef target)
{
	Boolean				ok;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	if (!targetPrivate->serverActive) {
		// if target already removed
		return;
	}

	// server has been restarted
	targetPrivate->cycle = 0;

	// re-associate with server
	ok = _reach_server_target_add(connection, target);
	if (!ok) {
		// if we could not add the target
		return;
	}

	if (!targetPrivate->serverScheduled) {
		// if not scheduled
		return;
	}

	// ... and re-schedule with server
	ok = _reach_server_target_schedule(connection, target);
	if (!ok) {
		// if we could not reschedule the target
		return;
	}

	// .. and update our status
	__SCNetworkReachabilityPerformNoLock(target);

	return;
}


static void
_reach_connection_reconnect(xpc_connection_t connection)
{
	dispatch_queue_t	q;

	q = _reach_requests_rbt_queue();
	dispatch_sync(q, ^{
		struct rb_node		*rbn;
		struct rb_tree		*rbt;

		rbt = _reach_requests_rbt();
		rbn = rb_tree_iterate(rbt, NULL, RB_DIR_RIGHT);
		for ( ; rbn != NULL ; rbn = rb_tree_iterate(rbt, rbn, RB_DIR_LEFT)) {
			reach_request_t			*rbt_request;
			SCNetworkReachabilityRef	target;

			rbt_request = RBNODE_TO_REACH_REQUEST(rbn);

			target = rbt_request->target;
			CFRetain(target);
			dispatch_async(__SCNetworkReachability_concurrent_queue(), ^{
				_reach_server_target_reconnect(connection, target);
				CFRelease(target);
			});
		}
	});

	return;
}


#pragma mark -
#pragma mark SPI (exposed)


Boolean
_SCNetworkReachabilityServer_snapshot(void)
{
	xpc_connection_t	c;
	Boolean			ok	= FALSE;
	xpc_object_t		reply;
	xpc_object_t		reqdict;

	// initialize connection with SCNetworkReachability server
	c = _reach_connection();
	if (c == NULL) {
		return FALSE;
	}

	// create message
	reqdict = xpc_dictionary_create(NULL, NULL, 0);

	// set request
	xpc_dictionary_set_int64(reqdict, REACH_REQUEST, REACH_REQUEST_SNAPSHOT);

	// add the process name (for debugging)
	add_proc_name(reqdict);

    retry :

	// send request
	reply = xpc_connection_send_message_with_reply_sync(c, reqdict);
	if (reply != NULL) {
		xpc_type_t	type;

		type = xpc_get_type(reply);
		if (type == XPC_TYPE_DICTIONARY) {
			int64_t		status;

			status = xpc_dictionary_get_int64(reply, REACH_REQUEST_REPLY);
			ok = (status == REACH_REQUEST_REPLY_OK);
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INVALID)) {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("SCNetworkReachability server not available"));
			serverAvailable = FALSE;
		} else if ((type == XPC_TYPE_ERROR) && (reply == XPC_ERROR_CONNECTION_INTERRUPTED)) {
			SCLog(TRUE, LOG_DEBUG,
			      CFSTR("SCNetworkReachability server failure, retrying"));
			xpc_release(reply);
			goto retry;
		} else {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("_snapshot with unexpected reply"));
			log_xpc_object("  reply", reply);
		}

		xpc_release(reply);
	}

	xpc_release(reqdict);
	return ok;
}


__private_extern__
Boolean
__SCNetworkReachabilityServer_targetAdd(SCNetworkReachabilityRef target)
{
	xpc_connection_t		c;
	Boolean				ok;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	c = _reach_connection();
	if (c == NULL) {
		return FALSE;
	}

	ok = _reach_server_target_add(c, target);
	if (ok) {
		_SC_ATOMIC_CMPXCHG(&targetPrivate->serverActive, FALSE, TRUE);
	}

	return ok;
}


__private_extern__
void
__SCNetworkReachabilityServer_targetRemove(SCNetworkReachabilityRef target)
{
	xpc_connection_t		c;
	Boolean				ok;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	if (!targetPrivate->serverActive) {
		// if not active
		return;
	}

	c = _reach_connection();
	if (c == NULL) {
		return;
	}

	ok = _reach_server_target_remove(c, target);
	if (ok) {
		_SC_ATOMIC_CMPXCHG(&targetPrivate->serverActive, TRUE, FALSE);
	}

	return;
}


__private_extern__
Boolean
__SCNetworkReachabilityServer_targetSchedule(SCNetworkReachabilityRef target)
{
	xpc_connection_t		c;
	Boolean				ok;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	c = _reach_connection();
	if (c == NULL) {
		return FALSE;
	}

	_reach_request_add(target);
	ok = _reach_server_target_schedule(c, target);
	if (ok) {
		_SC_ATOMIC_CMPXCHG(&targetPrivate->serverScheduled, FALSE, TRUE);
	} else {
		_reach_request_remove(target);
	}

	return ok;
}


__private_extern__
Boolean
__SCNetworkReachabilityServer_targetStatus(SCNetworkReachabilityRef target)
{
	xpc_connection_t		c;
	Boolean				ok;

	c = _reach_connection();
	if (c == NULL) {
		return FALSE;
	}

	ok = _reach_server_target_status(c, target);
	return ok;
}


__private_extern__
Boolean
__SCNetworkReachabilityServer_targetUnschedule(SCNetworkReachabilityRef target)
{
	xpc_connection_t		c;
	Boolean				ok;
	SCNetworkReachabilityPrivateRef	targetPrivate	= (SCNetworkReachabilityPrivateRef)target;

	if (!targetPrivate->serverScheduled) {
		// if not scheduled
		return TRUE;
	}

	c = _reach_connection();
	if (c == NULL) {
		return FALSE;
	}

	ok = _reach_server_target_unschedule(c, target);
	if (ok) {
		_SC_ATOMIC_CMPXCHG(&targetPrivate->serverScheduled, TRUE, FALSE);
		_reach_request_remove(target);
	} else {
		// if unschedule failed
	}

	return ok;
}

#endif	// HAVE_REACHABILITY_SERVER