mirror of
https://github.com/VibeDarling/darling-configd.git
synced 2026-11-15 18:39:47 -10:00
606 lines
16 KiB
C
606 lines
16 KiB
C
/*
|
|
* Copyright (c) 2013-2018 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@
|
|
*/
|
|
|
|
/*
|
|
* IPMonitorControl.c
|
|
* - IPC channel to IPMonitor
|
|
* - used to create interface rank assertions
|
|
*/
|
|
|
|
/*
|
|
* Modification History
|
|
*
|
|
* December 16, 2013 Dieter Siegmund ([email protected])
|
|
* - initial revision
|
|
*/
|
|
|
|
#include "IPMonitorControl.h"
|
|
#include "IPMonitorControlPrivate.h"
|
|
#include "symbol_scope.h"
|
|
#include <CoreFoundation/CFRuntime.h>
|
|
#include <net/if.h>
|
|
#include <xpc/xpc.h>
|
|
#include <xpc/private.h>
|
|
#include <SystemConfiguration/SCPrivate.h>
|
|
|
|
#ifdef TEST_IPMONITOR_CONTROL
|
|
|
|
#define my_log(__level, __format, ...) SCPrint(TRUE, stdout, CFSTR(__format "\n"), ## __VA_ARGS__)
|
|
|
|
#else /* TEST_IPMONITOR_CONTROL */
|
|
|
|
#define my_log(__level, __format, ...) SC_log(__level, __format, ## __VA_ARGS__)
|
|
|
|
#endif /* TEST_IPMONITOR_CONTROL */
|
|
|
|
/**
|
|
** IPMonitorControl CF object glue
|
|
**/
|
|
|
|
struct IPMonitorControl {
|
|
CFRuntimeBase cf_base;
|
|
|
|
dispatch_queue_t queue;
|
|
xpc_connection_t connection;
|
|
|
|
CFMutableDictionaryRef assertions; /* ifname<string> = rank<number> */
|
|
CFMutableDictionaryRef advisories; /* ifname<string> = adv<number> */
|
|
};
|
|
|
|
STATIC CFStringRef __IPMonitorControlCopyDebugDesc(CFTypeRef cf);
|
|
STATIC void __IPMonitorControlDeallocate(CFTypeRef cf);
|
|
|
|
STATIC CFTypeID __kIPMonitorControlTypeID = _kCFRuntimeNotATypeID;
|
|
|
|
STATIC const CFRuntimeClass __IPMonitorControlClass = {
|
|
0, /* version */
|
|
"IPMonitorControl", /* className */
|
|
NULL, /* init */
|
|
NULL, /* copy */
|
|
__IPMonitorControlDeallocate, /* deallocate */
|
|
NULL, /* equal */
|
|
NULL, /* hash */
|
|
NULL, /* copyFormattingDesc */
|
|
__IPMonitorControlCopyDebugDesc /* copyDebugDesc */
|
|
};
|
|
|
|
STATIC CFStringRef
|
|
__IPMonitorControlCopyDebugDesc(CFTypeRef cf)
|
|
{
|
|
CFAllocatorRef allocator = CFGetAllocator(cf);
|
|
IPMonitorControlRef control = (IPMonitorControlRef)cf;
|
|
|
|
return (CFStringCreateWithFormat(allocator, NULL,
|
|
CFSTR("<IPMonitorControl %p>"),
|
|
control));
|
|
}
|
|
|
|
STATIC void
|
|
__IPMonitorControlDeallocate(CFTypeRef cf)
|
|
{
|
|
IPMonitorControlRef control = (IPMonitorControlRef)cf;
|
|
|
|
if (control->connection != NULL) {
|
|
xpc_release(control->connection);
|
|
}
|
|
if (control->queue != NULL) {
|
|
dispatch_release(control->queue);
|
|
}
|
|
my_CFRelease(&control->advisories);
|
|
my_CFRelease(&control->assertions);
|
|
return;
|
|
}
|
|
|
|
/**
|
|
** IPMonitorControl support functions
|
|
**/
|
|
STATIC void
|
|
__IPMonitorControlRegisterClass(void)
|
|
{
|
|
STATIC dispatch_once_t once;
|
|
|
|
dispatch_once(&once, ^{
|
|
__kIPMonitorControlTypeID
|
|
= _CFRuntimeRegisterClass(&__IPMonitorControlClass);
|
|
});
|
|
return;
|
|
}
|
|
|
|
STATIC IPMonitorControlRef
|
|
__IPMonitorControlAllocate(CFAllocatorRef allocator)
|
|
{
|
|
IPMonitorControlRef control;
|
|
int size;
|
|
|
|
__IPMonitorControlRegisterClass();
|
|
size = sizeof(*control) - sizeof(CFRuntimeBase);
|
|
control = (IPMonitorControlRef)
|
|
_CFRuntimeCreateInstance(allocator,
|
|
__kIPMonitorControlTypeID, size, NULL);
|
|
return (control);
|
|
}
|
|
|
|
STATIC xpc_object_t
|
|
create_request_dictionary(void)
|
|
{
|
|
const char * progname;
|
|
xpc_object_t request;
|
|
|
|
request = xpc_dictionary_create(NULL, NULL, 0);
|
|
progname = getprogname();
|
|
if (progname != NULL) {
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyProcessName,
|
|
progname);
|
|
}
|
|
return (request);
|
|
}
|
|
|
|
STATIC Boolean
|
|
IPMonitorControlHandleResponse(xpc_object_t event, Boolean async,
|
|
Boolean * retry_p)
|
|
{
|
|
Boolean retry = FALSE;
|
|
Boolean success = FALSE;
|
|
xpc_type_t type;
|
|
|
|
type = xpc_get_type(event);
|
|
if (type == XPC_TYPE_DICTIONARY) {
|
|
if (async) {
|
|
/* we don't expect async responses messages */
|
|
my_log(LOG_NOTICE, "unexpected message");
|
|
}
|
|
else {
|
|
int64_t error;
|
|
|
|
error = xpc_dictionary_get_int64(event,
|
|
kIPMonitorControlResponseKeyError);
|
|
if (error != 0) {
|
|
success = FALSE;
|
|
#ifdef TEST_IPMONITOR_CONTROL
|
|
my_log(LOG_NOTICE, "failure code %lld", error);
|
|
#endif /* TEST_IPMONITOR_CONTROL */
|
|
}
|
|
else {
|
|
success = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else if (type == XPC_TYPE_ERROR) {
|
|
if (event == XPC_ERROR_CONNECTION_INTERRUPTED) {
|
|
#ifdef TEST_IPMONITOR_CONTROL
|
|
my_log(LOG_NOTICE, "can retry");
|
|
#endif /* TEST_IPMONITOR_CONTROL */
|
|
retry = TRUE;
|
|
}
|
|
else {
|
|
const char * desc;
|
|
|
|
desc = xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION);
|
|
my_log(LOG_NOTICE, "%s", desc);
|
|
}
|
|
}
|
|
else {
|
|
my_log(LOG_NOTICE, "unknown event type : %p", type);
|
|
}
|
|
if (retry_p != NULL) {
|
|
*retry_p = retry;
|
|
}
|
|
return (success);
|
|
}
|
|
|
|
|
|
STATIC void
|
|
_IPMonitorControlSetInterfacePrimaryRank(IPMonitorControlRef control,
|
|
CFStringRef ifname_cf,
|
|
SCNetworkServicePrimaryRank rank)
|
|
{
|
|
if (control->assertions == NULL) {
|
|
if (rank == kSCNetworkServicePrimaryRankDefault) {
|
|
/* no assertions, no need to store rank */
|
|
return;
|
|
}
|
|
control->assertions
|
|
= CFDictionaryCreateMutable(NULL, 0,
|
|
&kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks);
|
|
}
|
|
if (rank == kSCNetworkServicePrimaryRankDefault) {
|
|
CFDictionaryRemoveValue(control->assertions, ifname_cf);
|
|
if (CFDictionaryGetCount(control->assertions) == 0) {
|
|
my_CFRelease(&control->assertions);
|
|
}
|
|
}
|
|
else {
|
|
CFNumberRef rank_cf;
|
|
|
|
rank_cf = CFNumberCreate(NULL, kCFNumberSInt32Type, &rank);
|
|
CFDictionarySetValue(control->assertions, ifname_cf, rank_cf);
|
|
CFRelease(rank_cf);
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
ApplyInterfaceRank(const void * key, const void * value, void * context)
|
|
{
|
|
xpc_connection_t connection = (xpc_connection_t)context;
|
|
char ifname[IF_NAMESIZE];
|
|
SCNetworkServicePrimaryRank rank;
|
|
xpc_object_t request;
|
|
|
|
if (!CFStringGetCString(key, ifname, sizeof(ifname),
|
|
kCFStringEncodingUTF8)) {
|
|
return;
|
|
}
|
|
if (!CFNumberGetValue(value, kCFNumberSInt32Type, &rank)) {
|
|
return;
|
|
}
|
|
request = create_request_dictionary();
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyType,
|
|
kIPMonitorControlRequestTypeSetInterfaceRank);
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName,
|
|
ifname);
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyPrimaryRank,
|
|
rank);
|
|
xpc_connection_send_message(connection, request);
|
|
xpc_release(request);
|
|
return;
|
|
}
|
|
|
|
|
|
STATIC void
|
|
_IPMonitorControlSetInterfaceAdvisory(IPMonitorControlRef control,
|
|
CFStringRef ifname_cf,
|
|
SCNetworkInterfaceAdvisory advisory)
|
|
{
|
|
if (control->advisories == NULL) {
|
|
if (advisory == kSCNetworkInterfaceAdvisoryNone) {
|
|
/* no advisories, no need to store advisory */
|
|
return;
|
|
}
|
|
control->advisories
|
|
= CFDictionaryCreateMutable(NULL, 0,
|
|
&kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks);
|
|
}
|
|
if (advisory == kSCNetworkInterfaceAdvisoryNone) {
|
|
CFDictionaryRemoveValue(control->advisories, ifname_cf);
|
|
if (CFDictionaryGetCount(control->advisories) == 0) {
|
|
my_CFRelease(&control->advisories);
|
|
}
|
|
}
|
|
else {
|
|
CFNumberRef advisory_cf;
|
|
|
|
advisory_cf = CFNumberCreate(NULL, kCFNumberSInt32Type, &advisory);
|
|
CFDictionarySetValue(control->advisories, ifname_cf, advisory_cf);
|
|
CFRelease(advisory_cf);
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
ApplyInterfaceAdvisory(const void * key, const void * value, void * context)
|
|
{
|
|
xpc_connection_t connection = (xpc_connection_t)context;
|
|
char ifname[IF_NAMESIZE];
|
|
SCNetworkInterfaceAdvisory advisory;
|
|
xpc_object_t request;
|
|
|
|
if (!CFStringGetCString(key, ifname, sizeof(ifname),
|
|
kCFStringEncodingUTF8)) {
|
|
return;
|
|
}
|
|
if (!CFNumberGetValue(value, kCFNumberSInt32Type, &advisory)) {
|
|
return;
|
|
}
|
|
request = create_request_dictionary();
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyType,
|
|
kIPMonitorControlRequestTypeSetInterfaceAdvisory);
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName,
|
|
ifname);
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyAdvisory,
|
|
advisory);
|
|
xpc_connection_send_message(connection, request);
|
|
xpc_release(request);
|
|
return;
|
|
}
|
|
|
|
|
|
/**
|
|
** IPMonitorControl SPI
|
|
**/
|
|
PRIVATE_EXTERN IPMonitorControlRef
|
|
IPMonitorControlCreate(void)
|
|
{
|
|
xpc_connection_t connection;
|
|
IPMonitorControlRef control;
|
|
uint64_t flags = XPC_CONNECTION_MACH_SERVICE_PRIVILEGED;
|
|
xpc_handler_t handler;
|
|
dispatch_queue_t queue;
|
|
|
|
control = __IPMonitorControlAllocate(NULL);
|
|
queue = dispatch_queue_create("IPMonitorControl", NULL);
|
|
connection
|
|
= xpc_connection_create_mach_service(kIPMonitorControlServerName,
|
|
queue, flags);
|
|
handler = ^(xpc_object_t event) {
|
|
Boolean retry;
|
|
|
|
(void)IPMonitorControlHandleResponse(event, TRUE, &retry);
|
|
if (retry) {
|
|
if (control->assertions != NULL) {
|
|
CFDictionaryApplyFunction(control->assertions,
|
|
ApplyInterfaceRank,
|
|
control->connection);
|
|
}
|
|
if (control->advisories != NULL) {
|
|
CFDictionaryApplyFunction(control->advisories,
|
|
ApplyInterfaceAdvisory,
|
|
control->connection);
|
|
}
|
|
}
|
|
};
|
|
xpc_connection_set_event_handler(connection, handler);
|
|
control->connection = connection;
|
|
control->queue = queue;
|
|
xpc_connection_resume(connection);
|
|
return (control);
|
|
}
|
|
|
|
STATIC xpc_object_t
|
|
IPMonitorControlSendRequest(IPMonitorControlRef control,
|
|
xpc_object_t request)
|
|
{
|
|
xpc_object_t reply;
|
|
|
|
while (TRUE) {
|
|
Boolean retry_on_error = FALSE;
|
|
Boolean success;
|
|
|
|
reply = xpc_connection_send_message_with_reply_sync(control->connection,
|
|
request);
|
|
if (reply == NULL) {
|
|
my_log(LOG_NOTICE, "failed to send message");
|
|
break;
|
|
}
|
|
success = IPMonitorControlHandleResponse(reply, FALSE,
|
|
&retry_on_error);
|
|
if (success) {
|
|
break;
|
|
}
|
|
xpc_release(reply);
|
|
reply = NULL;
|
|
if (retry_on_error) {
|
|
continue;
|
|
}
|
|
my_log(LOG_NOTICE, "fatal error");
|
|
break;
|
|
}
|
|
return (reply);
|
|
}
|
|
|
|
PRIVATE_EXTERN Boolean
|
|
IPMonitorControlSetInterfacePrimaryRank(IPMonitorControlRef control,
|
|
CFStringRef ifname_cf,
|
|
SCNetworkServicePrimaryRank rank)
|
|
{
|
|
char ifname[IF_NAMESIZE];
|
|
xpc_object_t reply;
|
|
xpc_object_t request;
|
|
Boolean success = FALSE;
|
|
|
|
if (!CFStringGetCString(ifname_cf, ifname, sizeof(ifname),
|
|
kCFStringEncodingUTF8)) {
|
|
return (FALSE);
|
|
}
|
|
|
|
request = create_request_dictionary();
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyType,
|
|
kIPMonitorControlRequestTypeSetInterfaceRank);
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName,
|
|
ifname);
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyPrimaryRank,
|
|
rank);
|
|
reply = IPMonitorControlSendRequest(control, request);
|
|
xpc_release(request);
|
|
if (reply != NULL) {
|
|
success = TRUE;
|
|
xpc_release(reply);
|
|
|
|
/* sync our state */
|
|
CFRetain(ifname_cf);
|
|
CFRetain(control);
|
|
dispatch_async(control->queue,
|
|
^{
|
|
_IPMonitorControlSetInterfacePrimaryRank(control,
|
|
ifname_cf,
|
|
rank);
|
|
CFRelease(ifname_cf);
|
|
CFRelease(control);
|
|
});
|
|
}
|
|
return (success);
|
|
}
|
|
|
|
PRIVATE_EXTERN SCNetworkServicePrimaryRank
|
|
IPMonitorControlGetInterfacePrimaryRank(IPMonitorControlRef control,
|
|
CFStringRef ifname_cf)
|
|
{
|
|
char ifname[IF_NAMESIZE];
|
|
SCNetworkServicePrimaryRank rank;
|
|
xpc_object_t reply;
|
|
xpc_object_t request;
|
|
|
|
rank = kSCNetworkServicePrimaryRankDefault;
|
|
if (!CFStringGetCString(ifname_cf, ifname, sizeof(ifname),
|
|
kCFStringEncodingUTF8)) {
|
|
return rank;
|
|
}
|
|
|
|
request = create_request_dictionary();
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyType,
|
|
kIPMonitorControlRequestTypeGetInterfaceRank);
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName,
|
|
ifname);
|
|
reply = IPMonitorControlSendRequest(control, request);
|
|
if (reply != NULL) {
|
|
rank = (SCNetworkServicePrimaryRank)
|
|
xpc_dictionary_get_uint64(reply,
|
|
kIPMonitorControlResponseKeyPrimaryRank);
|
|
xpc_release(reply);
|
|
}
|
|
xpc_release(request);
|
|
return (rank);
|
|
}
|
|
|
|
PRIVATE_EXTERN Boolean
|
|
IPMonitorControlSetInterfaceAdvisory(IPMonitorControlRef control,
|
|
CFStringRef ifname_cf,
|
|
SCNetworkInterfaceAdvisory advisory,
|
|
CFStringRef reason)
|
|
{
|
|
char ifname[IF_NAMESIZE];
|
|
char * reason_str = NULL;
|
|
xpc_object_t reply;
|
|
xpc_object_t request;
|
|
Boolean success = FALSE;
|
|
|
|
if (!CFStringGetCString(ifname_cf, ifname, sizeof(ifname),
|
|
kCFStringEncodingUTF8)) {
|
|
return (FALSE);
|
|
}
|
|
if (reason != NULL) {
|
|
reason_str
|
|
= _SC_cfstring_to_cstring(reason, NULL, 0, kCFStringEncodingUTF8);
|
|
}
|
|
request = create_request_dictionary();
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyType,
|
|
kIPMonitorControlRequestTypeSetInterfaceAdvisory);
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName,
|
|
ifname);
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyAdvisory,
|
|
advisory);
|
|
if (reason_str != NULL) {
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyReason,
|
|
reason_str);
|
|
CFAllocatorDeallocate(NULL, reason_str);
|
|
}
|
|
reply = IPMonitorControlSendRequest(control, request);
|
|
xpc_release(request);
|
|
if (reply != NULL) {
|
|
xpc_release(reply);
|
|
success = TRUE;
|
|
|
|
/* sync our state */
|
|
CFRetain(ifname_cf);
|
|
CFRetain(control);
|
|
dispatch_async(control->queue,
|
|
^{
|
|
_IPMonitorControlSetInterfaceAdvisory(control,
|
|
ifname_cf,
|
|
advisory);
|
|
CFRelease(ifname_cf);
|
|
CFRelease(control);
|
|
});
|
|
}
|
|
return (success);
|
|
}
|
|
|
|
PRIVATE_EXTERN Boolean
|
|
IPMonitorControlInterfaceAdvisoryIsSet(IPMonitorControlRef control,
|
|
CFStringRef ifname_cf)
|
|
{
|
|
char ifname[IF_NAMESIZE];
|
|
xpc_object_t reply;
|
|
xpc_object_t request;
|
|
Boolean is_set = FALSE;
|
|
|
|
if (!CFStringGetCString(ifname_cf, ifname, sizeof(ifname),
|
|
kCFStringEncodingUTF8)) {
|
|
return (FALSE);
|
|
}
|
|
request = create_request_dictionary();
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyType,
|
|
kIPMonitorControlRequestTypeInterfaceAdvisoryIsSet);
|
|
xpc_dictionary_set_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName,
|
|
ifname);
|
|
reply = IPMonitorControlSendRequest(control, request);
|
|
xpc_release(request);
|
|
if (reply != NULL) {
|
|
if (xpc_dictionary_get_bool(reply,
|
|
kIPMonitorControlResponseKeyAdvisoryIsSet)) {
|
|
is_set = TRUE;
|
|
}
|
|
xpc_release(reply);
|
|
}
|
|
return (is_set);
|
|
}
|
|
|
|
PRIVATE_EXTERN Boolean
|
|
IPMonitorControlAnyInterfaceAdvisoryIsSet(IPMonitorControlRef control)
|
|
{
|
|
xpc_object_t reply;
|
|
xpc_object_t request;
|
|
Boolean is_set = FALSE;
|
|
|
|
request = create_request_dictionary();
|
|
xpc_dictionary_set_uint64(request,
|
|
kIPMonitorControlRequestKeyType,
|
|
kIPMonitorControlRequestTypeAnyInterfaceAdvisoryIsSet);
|
|
reply = IPMonitorControlSendRequest(control, request);
|
|
xpc_release(request);
|
|
if (reply != NULL) {
|
|
if (xpc_dictionary_get_bool(reply,
|
|
kIPMonitorControlResponseKeyAdvisoryIsSet)) {
|
|
is_set = TRUE;
|
|
}
|
|
xpc_release(reply);
|
|
}
|
|
return (is_set);
|
|
}
|
|
|
|
PRIVATE_EXTERN CFStringRef
|
|
IPMonitorControlCopyInterfaceAdvisoryNotificationKey(CFStringRef ifname)
|
|
{
|
|
return (_IPMonitorControlCopyInterfaceAdvisoryNotificationKey(ifname));
|
|
}
|