//

//  AIHostReachabilityMonitor.m

//  AIUtilities.framework

//

//  Created by Mac-arena the Bored Zo on 2005-02-11.

//

#import "AIHostReachabilityMonitor.h"

#import "AISleepNotification.h"

#import <SystemConfiguration/SystemConfiguration.h>

#import <arpa/inet.h>

#import <netdb.h>

#import <netinet/in.h>

#define CONNECTIVITY_DEBUG FALSE

static AIHostReachabilityMonitor *singleton = nil;

@interface AIHostReachabilityMonitor ()

- (void)scheduleReachabilityMonitoringForHost:(NSString *)nodename observer:(id)observer;

- (void)gotReachabilityRef:(SCNetworkReachabilityRef)reachabilityRef forHost:(NSString *)host observer:(id)observer;

- (void)addUnconfiguredHost:(NSString *)host observer:(id)observer;

- (void)removeUnconfiguredHost:(NSString *)host observer:(id)observer;

- (void)queryUnconfiguredHosts;

- (void)beginMonitorngIPChanges;

- (void)stopMonitoringIPChanges;

@end

@implementation AIHostReachabilityMonitor

#pragma mark Shared instance management

/*!

 *	@brief	Returns a shared instance, usable for most purposes.

 *	@return A shared AIHostReachabilityMonitor instance.

 */

+ (id)defaultMonitor

{

	if (!singleton) {

		singleton = [[AIHostReachabilityMonitor alloc] init];

	}

	return singleton;

}

#pragma mark -

#pragma mark Birth and death

/*

 * @brief Initialize

 */

- (id)init

{

	if ((self = [super init])) {

		hostAndObserverListLock = [[NSLock alloc] init];

		[hostAndObserverListLock setName:@"HostAndObserverListLock"];

		[hostAndObserverListLock lock];

		hosts          = [[NSMutableArray alloc] init];

		observers      = [[NSMutableArray alloc] init];

		reachabilities = [[NSMutableArray alloc] init];

		unconfiguredHostsAndObservers = [[NSMutableSet alloc] init];

		ipChangesRunLoopSourceRef = nil;

		[hostAndObserverListLock unlock];

		//Monitor system sleep so we can accurately report connectivity changes when the system wakes

		[[NSNotificationCenter defaultCenter] addObserver:self

												 selector:@selector(systemDidWake:)

													 name:AISystemDidWake_Notification

												   object:nil];

	}

	return self;

}

/*

 * @brief Deallocate

 */

- (void)dealloc

{

	[hostAndObserverListLock lock];

	[hosts          release]; hosts          = nil;

	[observers      release]; observers      = nil;

	[reachabilities release]; reachabilities = nil;

	[unconfiguredHostsAndObservers release]; unconfiguredHostsAndObservers = nil;

	[hostAndObserverListLock unlock];

	[hostAndObserverListLock release];

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[super dealloc];

}

#pragma mark -

#pragma mark Observer management

/*!

 *	@brief Begins observing a host's reachability for an object.

 */

- (void)addObserver:(id <AIHostReachabilityObserver>)newObserver forHost:(NSString *)host

{

	NSParameterAssert(host != nil);

	NSParameterAssert(newObserver != nil);

	NSString	*hostCopy = [host copy];

	[self scheduleReachabilityMonitoringForHost:hostCopy

									   observer:newObserver];

	[hostCopy release];

}

/*!

 *	@brief Stops an object's observation of a host's reachability.

 *

 *	When host is non-nil, stops observing that host's reachability for the given observer.

 *	When host is nil, stops observing all hosts' reachability for the given observer.

 */

- (void)removeObserver:(id <AIHostReachabilityObserver>)newObserver forHost:(NSString *)host

{

	//nil cannot observe, so it must not be in the list.

	if (!newObserver) return;

	[hostAndObserverListLock lock];

	unsigned numObservers = [observers count];

	for (unsigned i = 0; i < numObservers; ) {

		BOOL removed = NO;

		if (newObserver == [observers objectAtIndex:i]) {

			if ((!host) || ([host isEqualToString:[hosts objectAtIndex:i]])) {

				[hosts          removeObjectAtIndex:i];

				[observers      removeObjectAtIndex:i];

				SCNetworkReachabilityScheduleWithRunLoop((SCNetworkReachabilityRef)[reachabilities objectAtIndex:i],

														 CFRunLoopGetCurrent(),

														 kCFRunLoopDefaultMode);

				[reachabilities removeObjectAtIndex:i];

				[self removeUnconfiguredHost:host

									observer:newObserver];

				removed = YES;

				--numObservers;

			}

		}

		i += !removed;

	}

	[hostAndObserverListLock unlock];

}

/*

 * @brief Is an observer currently observing a host?

 *

 * @result YES if so, NO if not

 */

- (BOOL)observer:(id)observer isObservingHost:(NSString *)host

{

	BOOL isObserving = NO;

	[hostAndObserverListLock lock];

	if (host && observer) {

		unsigned numObservers = [observers count];

		for (unsigned i = 0; i < numObservers; i++) {

			if ((observer == [observers objectAtIndex:i]) &&

				([host isEqualToString:[hosts objectAtIndex:i]])) {

				isObserving = YES;

				break;

			}

		}

		if (!isObserving && [unconfiguredHostsAndObservers count]) {

			NSDictionary *unconfiguredHostObserverDict = [NSDictionary dictionaryWithObjectsAndKeys:

				observer, @"observer",

				host, @"host",

				nil];

			if ([unconfiguredHostsAndObservers containsObject:unconfiguredHostObserverDict]) {

				isObserving = YES;

			}

		}

	}

	[hostAndObserverListLock unlock];

	return isObserving;

}

#pragma mark -

#pragma mark Reachability monitoring

/*

 * @brief A host's reachability changed

 *

 * @param reachability The SCNetworkReachabilityRef for the host which changed

 * @param isReachable YES if the host is now reachable; NO if it is not reachable

 */

- (void)reachabilityChanged:(SCNetworkReachabilityRef)reachability

{

	[hostAndObserverListLock lock];

	NSUInteger i = [reachabilities indexOfObjectIdenticalTo:(id)reachability];

	if (i != NSNotFound) {

		NSString *host = [hosts objectAtIndex:i];

		id <AIHostReachabilityObserver> observer = [observers objectAtIndex:i];

		BOOL anyHostsReachable = NO;

		// If we have multiple host <-> IP links (AAAA record and an A record), we need to check agreement.

		for (NSUInteger index = 0; index < hosts.count; index++) {

			if (![host isEqualToString:[hosts objectAtIndex:index]])

				continue;

			SCNetworkReachabilityRef otherReachability = (SCNetworkReachabilityRef)[reachabilities objectAtIndex:index];

			SCNetworkConnectionFlags flags;

			if (SCNetworkReachabilityGetFlags(otherReachability, &flags)

				&& (flags & kSCNetworkFlagsReachable)

				&& !(flags & kSCNetworkFlagsConnectionRequired)) {

				anyHostsReachable = YES;

				break;

			}

		}

		// Return reachability based on any reachability response.

		if (anyHostsReachable) {

			[observer hostReachabilityMonitor:self hostIsReachable:host];

		} else {

			[observer hostReachabilityMonitor:self hostIsNotReachable:host];

		}

	}

	[hostAndObserverListLock unlock];

}

/*

 * @brief Callback for changes in a host's reachability (SCNetworkReachability)

 *

 * @param info The AIHostReachabilityMonitor which requested host reachability monitoring

 */

static void hostReachabilityChangedCallback(SCNetworkReachabilityRef target, SCNetworkConnectionFlags flags, void *info)

{

#if CONNECTIVITY_DEBUG

	NSLog(@"*** hostReachabilityChangedCallback got flags: %c%c%c%c%c%c%c \n",  

 	      (flags & kSCNetworkFlagsTransientConnection)  ? 't' : '-',  

 	      (flags & kSCNetworkFlagsReachable)            ? 'r' : '-',  

 	      (flags & kSCNetworkFlagsConnectionRequired)   ? 'c' : '-',  

 	      (flags & kSCNetworkFlagsConnectionAutomatic)  ? 'C' : '-',  

 	      (flags & kSCNetworkFlagsInterventionRequired) ? 'i' : '-',  

 	      (flags & kSCNetworkFlagsIsLocalAddress)       ? 'l' : '-',  

 	      (flags & kSCNetworkFlagsIsDirect)             ? 'd' : '-');

#endif

	AIHostReachabilityMonitor *self = info;

	[self reachabilityChanged:target];

}

/*

 * @brief Callbacak for resolution of a host's name to an IP (CFHost)

 *

 * @param info An NSDictionary with the keys @"self", @"observer", and @"host"

 */

static void hostResolvedCallback(CFHostRef theHost, CFHostInfoType typeInfo,  const CFStreamError *error, void *info)

{

	NSDictionary				*infoDict = info;

	AIHostReachabilityMonitor	*self = [infoDict objectForKey:@"self"];

	id							observer = [infoDict objectForKey:@"observer"];

	NSString					*host = [infoDict objectForKey:@"host"];

	if (typeInfo == kCFHostAddresses) {

		//CFHostGetAddressing returns a CFArrayRef of CFDataRefs which wrap struct sockaddr

		CFArrayRef addresses = CFHostGetAddressing(theHost, NULL);

		if (!CFArrayGetCount(addresses)) {

			/* We were not able to resolve the host name to an IP address.  This is most likely because we have no

			 * Internet connection or because the user is attempting to connect to MSN.

			 *

			 * Add to unconfiguredHostsAndObservers so we can try configuring again later.

			 */

			[self addUnconfiguredHost:host

							 observer:observer];

		}

		// Only add 1 observer for IPv6 and one for IPv4.

		BOOL addedIPv4 = NO, addedIPv6 = NO;

		for (NSData *saData in (NSArray *)addresses) {

			struct sockaddr							*remoteAddr = (struct sockaddr *)saData.bytes;

			if ((remoteAddr->sa_family == AF_INET && addedIPv4) || (remoteAddr->sa_family == AF_INET6 && addedIPv6)) {

				continue;

			}

			if (remoteAddr->sa_family == AF_INET)

				addedIPv4 = YES;

			if (remoteAddr->sa_family == AF_INET6)

				addedIPv6 = YES;

			SCNetworkReachabilityRef		reachabilityRef;

			SCNetworkReachabilityContext	reachabilityContext = {

				.version         = 0,

				.info            = self,

				.retain          = CFRetain,

				.release         = CFRelease,

				.copyDescription = CFCopyDescription,

			};

			SCNetworkConnectionFlags				flags;

			struct sockaddr_in						localAddr;

			/* Create a reachability reference pair with localhost and the remote host */

			//Our local address is 127.0.0.1

			bzero(&localAddr, sizeof(localAddr));

			localAddr.sin_len = sizeof(localAddr);

			localAddr.sin_family = AF_INET;

			inet_aton("127.0.0.1", &localAddr.sin_addr);

			//Create the pair

			reachabilityRef = SCNetworkReachabilityCreateWithAddressPair(NULL, 

																		 (struct sockaddr *)&localAddr, 

																		 remoteAddr);

			//Configure our callback

			SCNetworkReachabilitySetCallback(reachabilityRef, 

											 hostReachabilityChangedCallback, 

											 &reachabilityContext);

			//Add it to the run loop so we will receive the notifications

			SCNetworkReachabilityScheduleWithRunLoop(reachabilityRef,

													 CFRunLoopGetCurrent(),

													 kCFRunLoopDefaultMode);

			//Note that we succesfully configured for reachability notifications

			[self gotReachabilityRef:(SCNetworkReachabilityRef)[(NSObject *)reachabilityRef autorelease]

							 forHost:host

							observer:observer];

			if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags)) {

				//We already have valid flags for the reachabilityRef

		#if CONNECTIVITY_DEBUG

				NSLog(@"Immediate reachability info for %@", reachabilityRef);

		#endif

				hostReachabilityChangedCallback(reachabilityRef,

												flags,

												self);

			} else {

				/* Perform an immediate reachability check, since we've just scheduled checks for future changes

				* and won't be notified immediately.  We update the hostContext to include our reachabilityRef before

				* scheduling the info resolution (it's still in our run loop from when we requested the IP address).

				*/

				CFHostClientContext	hostContext = {

					.version		 = 0,

					.info			 = [NSDictionary dictionaryWithObjectsAndKeys:

						self, @"self",

						host, @"host",

						observer, @"observer",

						reachabilityRef, @"reachabilityRef",

						nil],

					.retain			 = CFRetain,

					.release		 = CFRelease,

					.copyDescription = CFCopyDescription,

				};

				CFHostSetClient(theHost,

								hostResolvedCallback,

								&hostContext);

				CFHostStartInfoResolution(theHost,

										  kCFHostReachability,

										  NULL);

			}

		}

	} else if (typeInfo == kCFHostReachability) {

		/* Asynchronous host reachability notification from CFHost(), triggered by CFHostStartInfoResolution() above. */

		SCNetworkConnectionFlags	flags;

		CFDataRef					flagsData = CFHostGetReachability(theHost,

																	  NULL);

		CFDataGetBytes(flagsData,

					   CFRangeMake(0, CFDataGetLength(flagsData)),

					   (UInt8 *)&flags);

		//Call the reachability changed callback directly

		hostReachabilityChangedCallback((SCNetworkReachabilityRef)[infoDict objectForKey:@"reachabilityRef"],

										flags,

										self);

		//No further need for this CFHost to be in our run loop

		CFHostUnscheduleFromRunLoop(theHost,

									CFRunLoopGetCurrent(),

									kCFRunLoopDefaultMode);

	}

}

/*

 * @brief We obtained an SCNetworkReachabilityRef for a host/observer pair

 *

 * We can now effectively monitor connectivity between us and the host.

 *

 * Add these three objects to our hosts, observers, and reachabilities arrays respectively so we can determine the

 * host and observer given the reachabilityRef in hostReachabilityChangedCallback() above.

 *

 * Remove the host/observer pair from the unconfigured dictionary.

 */

- (void)gotReachabilityRef:(SCNetworkReachabilityRef)reachabilityRef forHost:(NSString *)host observer:(id)observer

{

	//Add to our arrays for tracking

	[hostAndObserverListLock lock];

	[hosts          addObject:host];

	[observers      addObject:observer];

	[reachabilities addObject:(id)reachabilityRef];

	//Remove from our unconfigured array

	[self removeUnconfiguredHost:host

						observer:observer];

	[hostAndObserverListLock unlock];

#if CONNECTIVITY_DEBUG

	NSLog(@"Obtained reachability ref %@ for %@ (%@).",reachabilityRef, host, observer);

#endif

}

/*

 * @brief Schedule a reachability check for a host, with an observer

 *

 * This method begins the process of scheduling the reachability check.  It actually creates a CFHost to schedules

 * an asynchronous IP lookup for nodename.  hostResolvedCallback() will be called when it succeeds or fails.

 *

 * @param nodename The name such as "www.adiumxtras.com"

 * @param observer The observer which will be notified when the reachability changes

 */

- (void)scheduleReachabilityMonitoringForHost:(NSString *)nodename observer:(id)observer

{

	//Resolve the remote host domain name to an IP asynchronously

	CFHostClientContext	hostContext = {

		.version		 = 0,

		.info			 = [NSDictionary dictionaryWithObjectsAndKeys:

							self, @"self",

							nodename, @"host",

							observer, @"observer",

							nil],

		.retain			 = CFRetain,

		.release		 = CFRelease,

		.copyDescription = CFCopyDescription,

	};

	CFHostRef host = CFHostCreateWithName(kCFAllocatorDefault,

										  (CFStringRef)nodename);

	CFHostSetClient(host,

					hostResolvedCallback,

					&hostContext);

	CFHostScheduleWithRunLoop(host,

							  CFRunLoopGetCurrent(),

							  kCFRunLoopDefaultMode);

	CFHostStartInfoResolution(host,

							  kCFHostAddresses,

							  NULL);

#if CONNECTIVITY_DEBUG

	NSLog(@"Scheduled reachability check for %@",nodename);

#endif

	CFRelease(host);

}

#pragma mark -

#pragma mark Unconfigured hosts

/*

 * @brief Add an unconfigured host and observer to unconfiguredHostsAndObservers

 *

 * We have to resolve a host to an IP address before we can properly observe reachability.  unconfiguredHostsAndObservers

 * holds information on host/observer pairs which we haven't been able to resolve yet.  When the IP configuration changes,

 * we will try again, hoping to get an IP address this time.

 */

- (void)addUnconfiguredHost:(NSString *)host observer:(id)observer

{

	NSDictionary *unconfiguredHostDict = [NSDictionary dictionaryWithObjectsAndKeys:

		observer, @"observer",

		host, @"host",

		nil];

	BOOL addedNewUnconfiguredHost = NO;

	[hostAndObserverListLock lock];

	if (![unconfiguredHostsAndObservers containsObject:unconfiguredHostDict]) {

		addedNewUnconfiguredHost = YES;

		[unconfiguredHostsAndObservers addObject:unconfiguredHostDict];

	}

	[hostAndObserverListLock unlock];

	if (addedNewUnconfiguredHost) {

		/* If this is the first unconfigured host, begin monitoring IP changes so we can try to set it (and any others)

		* up at the earliest possible time.

		*/

		if ([unconfiguredHostsAndObservers count] == 1) {

			[self beginMonitorngIPChanges];

		}

#if CONNECTIVITY_DEBUG

		NSLog(@"Unable to resolve %@. Now monitoring IP changes for %@",host,unconfiguredHostsAndObservers);

#endif

		/*

		 * There are various ways we can get here when we already have an IP, such as when other network conditions

		 * need to be negotiated at the router-level before we're actually connected.  In such a case, IPs aren't going to

		 * change... so we'll check one more time, 10 seconds from the last time we get an unconfigured host call,

		 * for connectivity.

		 */

		[NSObject cancelPreviousPerformRequestsWithTarget:self

												 selector:@selector(queryUnconfiguredHosts)

												   object:nil];

		[self performSelector:@selector(queryUnconfiguredHosts)

				   withObject:nil

				   afterDelay:10.0];

	}

}

/*

 * @brief Remove an unconfigured host and observer from unconfiguredHostsAndObservers

 *

 * Must be called with the hostAndObserverListLock already obtained.

 */

- (void)removeUnconfiguredHost:(NSString *)host observer:(id)observer

{

	[unconfiguredHostsAndObservers removeObject:[NSDictionary dictionaryWithObjectsAndKeys:

		observer, @"observer",

		host, @"host",

		nil]];

	if ([unconfiguredHostsAndObservers count] == 0) {

		[self stopMonitoringIPChanges];

	}

}

/*

 * @brief Attempt to set up reachability monitoring for all currently unconfigured hosts

 *

 * Called by localIPsChangedCallback() in response to a change in the local IP list.

 *

 * Also called 5 seconds after one or more unconfigured hosts are added to verify they are actually unreachable.

 *

 * If we are able to schedule reachability monitoring for a given host, its dictionary in unconfiguredHostsAndObservers

 * will be removed.

 */

- (void)queryUnconfiguredHosts

{

	if ([unconfiguredHostsAndObservers count]) {

		NSEnumerator	*enumerator;

		NSDictionary	*unconfiguredDict;

		[hostAndObserverListLock lock];

		enumerator = [unconfiguredHostsAndObservers objectEnumerator];

		while ((unconfiguredDict = [enumerator nextObject])) {

			[self scheduleReachabilityMonitoringForHost:[unconfiguredDict objectForKey:@"host"]

											   observer:[unconfiguredDict objectForKey:@"observer"]];

		}

		[hostAndObserverListLock unlock];

	}

}

/*

 * @brief The local IP list changed (SCDynamicStore)

 *

 * @param info The AIHostReachabilityMonitor which set up the callback

 */

static void localIPsChangedCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)

{

	AIHostReachabilityMonitor	*self = info;

	/* Wait one second after receiving the callback, as it seems to be sent in some cases the middle of the change

	 * rather than after it is complete.

	 */

	[self performSelector:@selector(queryUnconfiguredHosts)

			   withObject:nil

			   afterDelay:1.0];	

}

static OSStatus CreateIPAddressListChangeCallbackSCF(SCDynamicStoreCallBack callback, void *contextPtr, 

													 SCDynamicStoreRef *storeRef, CFRunLoopSourceRef *sourceRef);

/*

 * @brief Monitor when our local IP list changes, which generally indicates a possible change in network connectivity

 */

- (void)beginMonitorngIPChanges

{

	if (!ipChangesRunLoopSourceRef) {		

		SCDynamicStoreRef	storeRef = nil;

		OSStatus			status;

		//Create the CFRunLoopSourceRef we will want to add to our run loop to have

		//localIPsChangedCallback() called when the IP list changes

		status = CreateIPAddressListChangeCallbackSCF(localIPsChangedCallback, 

													  self,

													  &storeRef,

													  &ipChangesRunLoopSourceRef);

		//Add it to the run loop so we will receive the notifications

		if((status == noErr) && ipChangesRunLoopSourceRef){

			CFRunLoopAddSource(CFRunLoopGetCurrent(),

							   ipChangesRunLoopSourceRef,

							   kCFRunLoopDefaultMode);

		}

		CFRelease(storeRef);

	}

}