mirror of
https://github.com/VibeDarling/darling-configd.git
synced 2026-11-15 18:39:47 -10:00
987 lines
26 KiB
C
987 lines
26 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@
|
|
*/
|
|
|
|
/*
|
|
* IPMonitorControlServer.c
|
|
* - IPC channel to IPMonitor
|
|
* - used to create interface rank assertions
|
|
*/
|
|
|
|
/*
|
|
* Modification History
|
|
*
|
|
* December 16, 2013 Dieter Siegmund ([email protected])
|
|
* - initial revision
|
|
*/
|
|
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include <xpc/xpc.h>
|
|
#include <xpc/private.h>
|
|
#include <sys/queue.h>
|
|
#include <CoreFoundation/CFRunLoop.h>
|
|
#include <SystemConfiguration/SCNetworkConfigurationPrivate.h>
|
|
#include <SystemConfiguration/SCPrivate.h>
|
|
#include "IPMonitorControlServer.h"
|
|
#include "symbol_scope.h"
|
|
#include "IPMonitorControlPrivate.h"
|
|
#include "IPMonitorAWDReport.h"
|
|
|
|
#ifdef TEST_IPMONITOR_CONTROL
|
|
#define my_log(__level, __format, ...) SCPrint(TRUE, stdout, CFSTR(__format "\n"), ## __VA_ARGS__)
|
|
|
|
#else /* TEST_IPMONITOR_CONTROL */
|
|
#include "ip_plugin.h"
|
|
#endif /* TEST_IPMONITOR_CONTROL */
|
|
|
|
STATIC dispatch_queue_t S_IPMonitorControlServerQueue;
|
|
|
|
typedef struct ControlSession ControlSession, * ControlSessionRef;
|
|
|
|
#define LIST_HEAD_ControlSession LIST_HEAD(ControlSessionHead, ControlSession)
|
|
#define LIST_ENTRY_ControlSession LIST_ENTRY(ControlSession)
|
|
LIST_HEAD_ControlSession S_ControlSessions;
|
|
|
|
struct ControlSession {
|
|
LIST_ENTRY_ControlSession link;
|
|
xpc_connection_t connection;
|
|
|
|
CFMutableDictionaryRef assertions; /* ifname<string> = rank<number> */
|
|
CFMutableDictionaryRef advisories; /* ifname<string> = advisory<number> */
|
|
};
|
|
|
|
/**
|
|
** Support Functions
|
|
**/
|
|
STATIC CFMutableArrayRef S_if_changes;
|
|
STATIC CFRange S_if_changes_range;
|
|
|
|
STATIC CFNumberRef
|
|
RankLastNumberGet(void)
|
|
{
|
|
STATIC CFNumberRef rank_last;
|
|
|
|
if (rank_last == NULL) {
|
|
SCNetworkServicePrimaryRank rank;
|
|
|
|
rank = kSCNetworkServicePrimaryRankLast;
|
|
rank_last = CFNumberCreate(NULL, kCFNumberSInt32Type, &rank);
|
|
}
|
|
return (rank_last);
|
|
}
|
|
|
|
STATIC void
|
|
InterfaceChangedListAddInterface(CFStringRef ifname)
|
|
{
|
|
if (S_if_changes == NULL) {
|
|
S_if_changes = CFArrayCreateMutable(NULL,
|
|
0, &kCFTypeArrayCallBacks);
|
|
CFArrayAppendValue(S_if_changes, ifname);
|
|
S_if_changes_range.length = 1;
|
|
}
|
|
else if (!CFArrayContainsValue(S_if_changes, S_if_changes_range, ifname)) {
|
|
CFArrayAppendValue(S_if_changes, ifname);
|
|
S_if_changes_range.length++;
|
|
}
|
|
}
|
|
|
|
STATIC CFArrayRef
|
|
InterfaceChangedListCopy(void)
|
|
{
|
|
CFArrayRef current_list;
|
|
|
|
current_list = S_if_changes;
|
|
S_if_changes = NULL;
|
|
return (current_list);
|
|
}
|
|
|
|
STATIC void
|
|
InterfaceRankAssertionAdd(const void * key, const void * value, void * context)
|
|
{
|
|
CFMutableDictionaryRef * assertions_p;
|
|
CFNumberRef existing_rank;
|
|
CFNumberRef rank = (CFNumberRef)value;
|
|
|
|
assertions_p = (CFMutableDictionaryRef *)context;
|
|
if (*assertions_p == NULL) {
|
|
*assertions_p
|
|
= CFDictionaryCreateMutable(NULL, 0,
|
|
&kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks);
|
|
CFDictionarySetValue(*assertions_p, key, rank);
|
|
return;
|
|
}
|
|
existing_rank = CFDictionaryGetValue(*assertions_p, key);
|
|
if (existing_rank == NULL
|
|
|| (CFNumberCompare(rank, existing_rank, NULL)
|
|
== kCFCompareGreaterThan)) {
|
|
CFDictionarySetValue(*assertions_p, key, rank);
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
InterfaceAdvisoryAdd(const void * key, const void * value, void * context)
|
|
{
|
|
#pragma unused(value)
|
|
CFMutableDictionaryRef * assertions_p;
|
|
CFNumberRef existing_rank;
|
|
CFNumberRef rank;
|
|
|
|
/* an interface advisory implies RankLast */
|
|
rank = RankLastNumberGet();
|
|
assertions_p = (CFMutableDictionaryRef *)context;
|
|
if (*assertions_p == NULL) {
|
|
*assertions_p
|
|
= CFDictionaryCreateMutable(NULL, 0,
|
|
&kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks);
|
|
CFDictionarySetValue(*assertions_p, key, rank);
|
|
return;
|
|
}
|
|
existing_rank = CFDictionaryGetValue(*assertions_p, key);
|
|
if (existing_rank == NULL
|
|
|| (CFNumberCompare(rank, existing_rank, NULL)
|
|
== kCFCompareGreaterThan)) {
|
|
CFDictionarySetValue(*assertions_p, key, rank);
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC CFDictionaryRef
|
|
InterfaceRankAssertionsCopy(void)
|
|
{
|
|
CFMutableDictionaryRef assertions = NULL;
|
|
ControlSessionRef session;
|
|
|
|
LIST_FOREACH(session, &S_ControlSessions, link) {
|
|
if (session->advisories != NULL) {
|
|
CFDictionaryApplyFunction(session->advisories,
|
|
InterfaceAdvisoryAdd,
|
|
&assertions);
|
|
}
|
|
if (session->assertions != NULL) {
|
|
CFDictionaryApplyFunction(session->assertions,
|
|
InterfaceRankAssertionAdd,
|
|
&assertions);
|
|
}
|
|
}
|
|
return (assertions);
|
|
}
|
|
|
|
STATIC Boolean
|
|
InterfaceHasAdvisories(CFStringRef ifname)
|
|
{
|
|
ControlSessionRef session;
|
|
|
|
LIST_FOREACH(session, &S_ControlSessions, link) {
|
|
if (session->advisories != NULL
|
|
&& CFDictionaryContainsKey(session->advisories, ifname)) {
|
|
return (TRUE);
|
|
}
|
|
}
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
STATIC AWDIPMonitorInterfaceAdvisoryReport_Flags
|
|
advisory_to_flags(SCNetworkInterfaceAdvisory advisory)
|
|
{
|
|
AWDIPMonitorInterfaceAdvisoryReport_Flags flags;
|
|
|
|
switch (advisory) {
|
|
case kSCNetworkInterfaceAdvisoryNone:
|
|
default:
|
|
flags = 0;
|
|
break;
|
|
case kSCNetworkInterfaceAdvisoryLinkLayerIssue:
|
|
flags = AWDIPMonitorInterfaceAdvisoryReport_Flags_LINK_LAYER_ISSUE;
|
|
break;
|
|
case kSCNetworkInterfaceAdvisoryUplinkIssue:
|
|
flags = AWDIPMonitorInterfaceAdvisoryReport_Flags_UPLINK_ISSUE;
|
|
break;
|
|
}
|
|
return (flags);
|
|
}
|
|
|
|
STATIC AWDIPMonitorInterfaceAdvisoryReport_Flags
|
|
InterfaceGetAdvisoryFlags(CFStringRef ifname,
|
|
ControlSessionRef exclude_session,
|
|
uint32_t * ret_count)
|
|
{
|
|
uint32_t count;
|
|
AWDIPMonitorInterfaceAdvisoryReport_Flags flags = 0;
|
|
ControlSessionRef session;
|
|
|
|
count = 0;
|
|
LIST_FOREACH(session, &S_ControlSessions, link) {
|
|
SCNetworkInterfaceAdvisory advisory = 0;
|
|
CFNumberRef advisory_cf;
|
|
|
|
if (session->advisories == NULL) {
|
|
continue;
|
|
}
|
|
if (exclude_session != NULL && exclude_session == session) {
|
|
continue;
|
|
}
|
|
advisory_cf = CFDictionaryGetValue(session->advisories, ifname);
|
|
if (advisory_cf == NULL) {
|
|
/* session has no advisories for this interface */
|
|
continue;
|
|
}
|
|
(void)CFNumberGetValue(advisory_cf, kCFNumberSInt32Type, &advisory);
|
|
flags |= advisory_to_flags(advisory);
|
|
count++;
|
|
}
|
|
*ret_count = count;
|
|
return (flags);
|
|
}
|
|
|
|
STATIC Boolean
|
|
AnyInterfaceHasAdvisories(void)
|
|
{
|
|
ControlSessionRef session;
|
|
|
|
LIST_FOREACH(session, &S_ControlSessions, link) {
|
|
if (session->advisories != NULL) {
|
|
return (TRUE);
|
|
}
|
|
}
|
|
return (FALSE);
|
|
}
|
|
|
|
STATIC CFRunLoopRef S_runloop;
|
|
STATIC CFRunLoopSourceRef S_signal_source;
|
|
|
|
STATIC void
|
|
SetNotificationInfo(CFRunLoopRef runloop, CFRunLoopSourceRef rls)
|
|
{
|
|
S_runloop = runloop;
|
|
S_signal_source = rls;
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
NotifyIPMonitor(void)
|
|
{
|
|
if (S_signal_source != NULL) {
|
|
CFRunLoopSourceSignal(S_signal_source);
|
|
if (S_runloop != NULL) {
|
|
CFRunLoopWakeUp(S_runloop);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
NotifyInterfaceAdvisory(CFStringRef ifname)
|
|
{
|
|
CFStringRef key;
|
|
|
|
key = _IPMonitorControlCopyInterfaceAdvisoryNotificationKey(ifname);
|
|
SCDynamicStoreNotifyValue(NULL, key);
|
|
CFRelease(key);
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
SubmitInterfaceAdvisoryMetric(CFStringRef ifname,
|
|
AWDIPMonitorInterfaceAdvisoryReport_Flags flags,
|
|
uint32_t count)
|
|
{
|
|
InterfaceAdvisoryReportRef report;
|
|
AWDIPMonitorInterfaceType type;
|
|
|
|
/* XXX need to actually figure out what the interface type is */
|
|
if (CFStringHasPrefix(ifname, CFSTR("pdp"))) {
|
|
type = AWDIPMonitorInterfaceType_IPMONITOR_INTERFACE_TYPE_CELLULAR;
|
|
}
|
|
else {
|
|
type = AWDIPMonitorInterfaceType_IPMONITOR_INTERFACE_TYPE_WIFI;
|
|
}
|
|
report = InterfaceAdvisoryReportCreate(type);
|
|
if (report == NULL) {
|
|
return;
|
|
}
|
|
InterfaceAdvisoryReportSetFlags(report, flags);
|
|
InterfaceAdvisoryReportSetAdvisoryCount(report, count);
|
|
InterfaceAdvisoryReportSubmit(report);
|
|
my_log(LOG_NOTICE, "%@: submitted AWD report %@", ifname, report);
|
|
CFRelease(report);
|
|
}
|
|
|
|
/**
|
|
** ControlSession
|
|
**/
|
|
STATIC void
|
|
AddChangedInterface(const void * key, const void * value, void * context)
|
|
{
|
|
#pragma unused(value)
|
|
#pragma unused(context)
|
|
InterfaceChangedListAddInterface((CFStringRef)key);
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
AddChangedInterfaceNotify(const void * key, const void * value, void * context)
|
|
{
|
|
#pragma unused(value)
|
|
#pragma unused(context)
|
|
InterfaceChangedListAddInterface((CFStringRef)key);
|
|
NotifyInterfaceAdvisory((CFStringRef)key);
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
GenerateMetricForInterfaceAtSessionClose(const void * key, const void * value,
|
|
void * context)
|
|
{
|
|
uint32_t count_after;
|
|
uint32_t count_before;
|
|
AWDIPMonitorInterfaceAdvisoryReport_Flags flags_after;
|
|
AWDIPMonitorInterfaceAdvisoryReport_Flags flags_before;
|
|
CFStringRef ifname = (CFStringRef)key;
|
|
ControlSessionRef session = (ControlSessionRef)context;
|
|
|
|
#pragma unused(value)
|
|
/*
|
|
* Get the flags and count including this session, then again
|
|
* excluding this session. If either flags or count are different,
|
|
* generate the metric.
|
|
*/
|
|
flags_before = InterfaceGetAdvisoryFlags(ifname, NULL, &count_before);
|
|
flags_after = InterfaceGetAdvisoryFlags(ifname, session, &count_after);
|
|
if (flags_before != flags_after || count_before != count_after) {
|
|
SubmitInterfaceAdvisoryMetric(ifname, flags_after, count_after);
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
ControlSessionGenerateMetricsAtClose(ControlSessionRef session)
|
|
{
|
|
if (session->advisories == NULL) {
|
|
return;
|
|
}
|
|
CFDictionaryApplyFunction(session->advisories,
|
|
GenerateMetricForInterfaceAtSessionClose,
|
|
session);
|
|
}
|
|
|
|
STATIC void
|
|
ControlSessionInvalidate(ControlSessionRef session)
|
|
{
|
|
my_log(LOG_DEBUG, "Invalidating %p", session);
|
|
ControlSessionGenerateMetricsAtClose(session);
|
|
LIST_REMOVE(session, link);
|
|
if (session->assertions != NULL || session->advisories != NULL) {
|
|
if (session->advisories != NULL) {
|
|
my_log(LOG_NOTICE,
|
|
"pid %d removing advisories %@",
|
|
xpc_connection_get_pid(session->connection),
|
|
session->advisories);
|
|
CFDictionaryApplyFunction(session->advisories,
|
|
AddChangedInterfaceNotify,
|
|
NULL);
|
|
my_CFRelease(&session->advisories);
|
|
}
|
|
if (session->assertions != NULL) {
|
|
my_log(LOG_NOTICE,
|
|
"pid %d removing assertions %@",
|
|
xpc_connection_get_pid(session->connection),
|
|
session->assertions);
|
|
CFDictionaryApplyFunction(session->assertions, AddChangedInterface,
|
|
NULL);
|
|
my_CFRelease(&session->assertions);
|
|
}
|
|
NotifyIPMonitor();
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
ControlSessionRelease(void * p)
|
|
{
|
|
my_log(LOG_DEBUG, "Releasing %p", p);
|
|
free(p);
|
|
return;
|
|
}
|
|
|
|
STATIC ControlSessionRef
|
|
ControlSessionLookup(xpc_connection_t connection)
|
|
{
|
|
return ((ControlSessionRef)xpc_connection_get_context(connection));
|
|
}
|
|
|
|
STATIC ControlSessionRef
|
|
ControlSessionCreate(xpc_connection_t connection)
|
|
{
|
|
ControlSessionRef session;
|
|
|
|
session = (ControlSessionRef)malloc(sizeof(*session));
|
|
memset(session, 0, sizeof(*session));
|
|
session->connection = connection;
|
|
xpc_connection_set_finalizer_f(connection, ControlSessionRelease);
|
|
xpc_connection_set_context(connection, session);
|
|
LIST_INSERT_HEAD(&S_ControlSessions, session, link);
|
|
my_log(LOG_DEBUG, "Created %p (connection %p)", session, connection);
|
|
return (session);
|
|
}
|
|
|
|
STATIC ControlSessionRef
|
|
ControlSessionForConnection(xpc_connection_t connection)
|
|
{
|
|
ControlSessionRef session;
|
|
|
|
session = ControlSessionLookup(connection);
|
|
if (session != NULL) {
|
|
return (session);
|
|
}
|
|
return (ControlSessionCreate(connection));
|
|
}
|
|
|
|
STATIC void
|
|
ControlSessionSetInterfaceRank(ControlSessionRef session,
|
|
const char * ifname,
|
|
SCNetworkServicePrimaryRank rank)
|
|
{
|
|
CFStringRef ifname_cf;
|
|
|
|
if (session->assertions == NULL) {
|
|
if (rank == kSCNetworkServicePrimaryRankDefault) {
|
|
/* no assertions, no need to store rank */
|
|
return;
|
|
}
|
|
session->assertions
|
|
= CFDictionaryCreateMutable(NULL, 0,
|
|
&kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks);
|
|
}
|
|
ifname_cf = CFStringCreateWithCString(NULL, ifname,
|
|
kCFStringEncodingUTF8);
|
|
|
|
if (rank == kSCNetworkServicePrimaryRankDefault) {
|
|
CFDictionaryRemoveValue(session->assertions, ifname_cf);
|
|
if (CFDictionaryGetCount(session->assertions) == 0) {
|
|
CFRelease(session->assertions);
|
|
session->assertions = NULL;
|
|
}
|
|
}
|
|
else {
|
|
CFNumberRef rank_cf;
|
|
|
|
rank_cf = CFNumberCreate(NULL, kCFNumberSInt32Type, &rank);
|
|
CFDictionarySetValue(session->assertions, ifname_cf, rank_cf);
|
|
CFRelease(rank_cf);
|
|
}
|
|
InterfaceChangedListAddInterface(ifname_cf);
|
|
NotifyIPMonitor();
|
|
CFRelease(ifname_cf);
|
|
return;
|
|
}
|
|
|
|
STATIC SCNetworkServicePrimaryRank
|
|
ControlSessionGetInterfaceRank(ControlSessionRef session,
|
|
const char * ifname)
|
|
{
|
|
SCNetworkServicePrimaryRank rank = kSCNetworkServicePrimaryRankDefault;
|
|
|
|
if (session->assertions != NULL) {
|
|
CFStringRef ifname_cf;
|
|
CFNumberRef rank_cf;
|
|
|
|
ifname_cf = CFStringCreateWithCString(NULL, ifname,
|
|
kCFStringEncodingUTF8);
|
|
rank_cf = CFDictionaryGetValue(session->assertions, ifname_cf);
|
|
CFRelease(ifname_cf);
|
|
if (rank_cf != NULL) {
|
|
(void)CFNumberGetValue(rank_cf, kCFNumberSInt32Type, &rank);
|
|
}
|
|
}
|
|
return (rank);
|
|
}
|
|
|
|
STATIC void
|
|
ControlSessionSetInterfaceAdvisory(ControlSessionRef session,
|
|
const char * ifname,
|
|
SCNetworkInterfaceAdvisory advisory)
|
|
{
|
|
uint32_t count_after;
|
|
uint32_t count_before;
|
|
AWDIPMonitorInterfaceAdvisoryReport_Flags flags_after;
|
|
AWDIPMonitorInterfaceAdvisoryReport_Flags flags_before;
|
|
CFStringRef ifname_cf;
|
|
|
|
if (session->advisories == NULL) {
|
|
if (advisory == kSCNetworkInterfaceAdvisoryNone) {
|
|
/* no advisories, no need to store advisory */
|
|
return;
|
|
}
|
|
session->advisories
|
|
= CFDictionaryCreateMutable(NULL, 0,
|
|
&kCFTypeDictionaryKeyCallBacks,
|
|
&kCFTypeDictionaryValueCallBacks);
|
|
}
|
|
ifname_cf = CFStringCreateWithCString(NULL, ifname,
|
|
kCFStringEncodingUTF8);
|
|
flags_before = InterfaceGetAdvisoryFlags(ifname_cf, NULL, &count_before);
|
|
if (advisory == kSCNetworkInterfaceAdvisoryNone) {
|
|
CFDictionaryRemoveValue(session->advisories, ifname_cf);
|
|
if (CFDictionaryGetCount(session->advisories) == 0) {
|
|
CFRelease(session->advisories);
|
|
session->advisories = NULL;
|
|
}
|
|
}
|
|
else {
|
|
CFNumberRef advisory_cf;
|
|
|
|
advisory_cf = CFNumberCreate(NULL, kCFNumberSInt32Type, &advisory);
|
|
CFDictionarySetValue(session->advisories, ifname_cf, advisory_cf);
|
|
CFRelease(advisory_cf);
|
|
}
|
|
flags_after = InterfaceGetAdvisoryFlags(ifname_cf, NULL, &count_after);
|
|
if (flags_before != flags_after || count_before != count_after) {
|
|
SubmitInterfaceAdvisoryMetric(ifname_cf, flags_after, count_after);
|
|
}
|
|
InterfaceChangedListAddInterface(ifname_cf);
|
|
NotifyInterfaceAdvisory(ifname_cf);
|
|
NotifyIPMonitor();
|
|
CFRelease(ifname_cf);
|
|
return;
|
|
}
|
|
|
|
/**
|
|
** IPMonitorControlServer
|
|
**/
|
|
|
|
STATIC const char *
|
|
get_process_name(xpc_object_t request)
|
|
{
|
|
const char * process_name;
|
|
|
|
process_name
|
|
= xpc_dictionary_get_string(request,
|
|
kIPMonitorControlRequestKeyProcessName);
|
|
if (process_name == NULL) {
|
|
process_name = "<unknown>";
|
|
}
|
|
return (process_name);
|
|
}
|
|
|
|
STATIC Boolean
|
|
IPMonitorControlServerConnectionIsRoot(xpc_connection_t connection)
|
|
{
|
|
uid_t uid;
|
|
|
|
uid = xpc_connection_get_euid(connection);
|
|
return (uid == 0);
|
|
}
|
|
|
|
STATIC Boolean
|
|
IPMonitorControlServerConnectionHasEntitlement(xpc_connection_t connection,
|
|
const char * entitlement)
|
|
{
|
|
Boolean entitled = FALSE;
|
|
xpc_object_t val;
|
|
|
|
val = xpc_connection_copy_entitlement_value(connection, entitlement);
|
|
if (val != NULL) {
|
|
if (xpc_get_type(val) == XPC_TYPE_BOOL) {
|
|
entitled = xpc_bool_get_value(val);
|
|
}
|
|
xpc_release(val);
|
|
}
|
|
return (entitled);
|
|
}
|
|
|
|
STATIC const char *
|
|
get_rank_str(SCNetworkServicePrimaryRank rank)
|
|
{
|
|
const char * str = NULL;
|
|
|
|
switch (rank) {
|
|
case kSCNetworkServicePrimaryRankDefault:
|
|
str = "Default";
|
|
break;
|
|
case kSCNetworkServicePrimaryRankFirst:
|
|
str = "First";
|
|
break;
|
|
case kSCNetworkServicePrimaryRankLast:
|
|
str = "Last";
|
|
break;
|
|
case kSCNetworkServicePrimaryRankNever:
|
|
str = "Never";
|
|
break;
|
|
case kSCNetworkServicePrimaryRankScoped:
|
|
str = "Scoped";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return (str);
|
|
}
|
|
|
|
STATIC int
|
|
HandleSetInterfaceRank(xpc_connection_t connection,
|
|
xpc_object_t request,
|
|
xpc_object_t reply)
|
|
{
|
|
#pragma unused(reply)
|
|
const char * ifname;
|
|
SCNetworkServicePrimaryRank rank;
|
|
const char * rank_str;
|
|
ControlSessionRef session;
|
|
|
|
if (!IPMonitorControlServerConnectionIsRoot(connection)) {
|
|
my_log(LOG_INFO, "connection %p pid %d permission denied",
|
|
connection, xpc_connection_get_pid(connection));
|
|
return (EPERM);
|
|
}
|
|
ifname
|
|
= xpc_dictionary_get_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName);
|
|
if (ifname == NULL) {
|
|
return (EINVAL);
|
|
}
|
|
rank = (SCNetworkServicePrimaryRank)
|
|
xpc_dictionary_get_uint64(request,
|
|
kIPMonitorControlRequestKeyPrimaryRank);
|
|
rank_str = get_rank_str(rank);
|
|
if (rank_str == NULL) {
|
|
return (EINVAL);
|
|
}
|
|
session = ControlSessionForConnection(connection);
|
|
ControlSessionSetInterfaceRank(session, ifname, rank);
|
|
my_log(LOG_NOTICE, "%s[%d] SetInterfaceRank(%s) = %s (%u)",
|
|
get_process_name(request),
|
|
xpc_connection_get_pid(connection), ifname, rank_str, rank);
|
|
return (0);
|
|
}
|
|
|
|
STATIC int
|
|
HandleGetInterfaceRank(xpc_connection_t connection,
|
|
xpc_object_t request,
|
|
xpc_object_t reply)
|
|
{
|
|
const char * ifname;
|
|
SCNetworkServicePrimaryRank rank;
|
|
ControlSessionRef session;
|
|
|
|
if (reply == NULL) {
|
|
/* no point in processing the request if we can't provide an answer */
|
|
return (EINVAL);
|
|
}
|
|
session = ControlSessionLookup(connection);
|
|
if (session == NULL) {
|
|
/* no session, no rank assertion */
|
|
return (ENOENT);
|
|
}
|
|
ifname
|
|
= xpc_dictionary_get_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName);
|
|
if (ifname == NULL) {
|
|
return (EINVAL);
|
|
}
|
|
rank = ControlSessionGetInterfaceRank(session, ifname);
|
|
xpc_dictionary_set_uint64(reply, kIPMonitorControlResponseKeyPrimaryRank,
|
|
rank);
|
|
return (0);
|
|
}
|
|
|
|
STATIC const char *
|
|
get_advisory_str(SCNetworkInterfaceAdvisory advisory)
|
|
{
|
|
const char * str = NULL;
|
|
|
|
switch (advisory) {
|
|
case kSCNetworkInterfaceAdvisoryNone:
|
|
str = "None";
|
|
break;
|
|
case kSCNetworkInterfaceAdvisoryLinkLayerIssue:
|
|
str = "LinkLayerIssue";
|
|
break;
|
|
case kSCNetworkInterfaceAdvisoryUplinkIssue:
|
|
str = "UplinkIssue";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return (str);
|
|
}
|
|
|
|
STATIC int
|
|
HandleSetInterfaceAdvisory(xpc_connection_t connection,
|
|
xpc_object_t request,
|
|
xpc_object_t reply)
|
|
{
|
|
#pragma unused(reply)
|
|
SCNetworkInterfaceAdvisory advisory;
|
|
const char * advisory_str;
|
|
const char * ifname;
|
|
const char * reason;
|
|
ControlSessionRef session;
|
|
|
|
#define ENTITLEMENT "com.apple.SystemConfiguration.SCNetworkInterfaceSetAdvisory"
|
|
if (!IPMonitorControlServerConnectionIsRoot(connection)
|
|
&& !IPMonitorControlServerConnectionHasEntitlement(connection,
|
|
ENTITLEMENT)) {
|
|
my_log(LOG_INFO, "connection %p pid %d permission denied",
|
|
connection, xpc_connection_get_pid(connection));
|
|
return (EPERM);
|
|
}
|
|
ifname
|
|
= xpc_dictionary_get_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName);
|
|
if (ifname == NULL) {
|
|
return (EINVAL);
|
|
}
|
|
reason
|
|
= xpc_dictionary_get_string(request,
|
|
kIPMonitorControlRequestKeyReason);
|
|
advisory = (SCNetworkInterfaceAdvisory)
|
|
xpc_dictionary_get_uint64(request, kIPMonitorControlRequestKeyAdvisory);
|
|
|
|
/* validate the advisory code */
|
|
advisory_str = get_advisory_str(advisory);
|
|
if (advisory_str == NULL) {
|
|
return (EINVAL);
|
|
}
|
|
session = ControlSessionForConnection(connection);
|
|
ControlSessionSetInterfaceAdvisory(session, ifname, advisory);
|
|
my_log(LOG_NOTICE, "%s[%d] SetInterfaceAdvisory(%s) = %s (%u) reason='%s'",
|
|
get_process_name(request),
|
|
xpc_connection_get_pid(connection), ifname, advisory_str, advisory,
|
|
reason != NULL ? reason : "" );
|
|
return (0);
|
|
}
|
|
|
|
STATIC int
|
|
HandleInterfaceAdvisoryIsSet(xpc_connection_t connection,
|
|
xpc_object_t request,
|
|
xpc_object_t reply)
|
|
{
|
|
#pragma unused(connection)
|
|
const char * ifname;
|
|
CFStringRef ifname_cf;
|
|
|
|
if (reply == NULL) {
|
|
/* no point in processing the request if we can't provide an answer */
|
|
return (EINVAL);
|
|
}
|
|
ifname
|
|
= xpc_dictionary_get_string(request,
|
|
kIPMonitorControlRequestKeyInterfaceName);
|
|
if (ifname == NULL) {
|
|
return (EINVAL);
|
|
}
|
|
ifname_cf = CFStringCreateWithCString(NULL, ifname,
|
|
kCFStringEncodingUTF8);
|
|
xpc_dictionary_set_bool(reply,
|
|
kIPMonitorControlResponseKeyAdvisoryIsSet,
|
|
InterfaceHasAdvisories(ifname_cf));
|
|
CFRelease(ifname_cf);
|
|
return (0);
|
|
}
|
|
|
|
STATIC int
|
|
HandleAnyInterfaceAdvisoryIsSet(xpc_connection_t connection,
|
|
xpc_object_t request,
|
|
xpc_object_t reply)
|
|
{
|
|
#pragma unused(connection)
|
|
#pragma unused(request)
|
|
if (reply == NULL) {
|
|
/* no point in processing the request if we can't provide an answer */
|
|
return (EINVAL);
|
|
}
|
|
xpc_dictionary_set_bool(reply,
|
|
kIPMonitorControlResponseKeyAdvisoryIsSet,
|
|
AnyInterfaceHasAdvisories());
|
|
return (0);
|
|
}
|
|
|
|
STATIC void
|
|
IPMonitorControlServerHandleDisconnect(xpc_connection_t connection)
|
|
{
|
|
ControlSessionRef session;
|
|
|
|
my_log(LOG_DEBUG, "IPMonitorControlServer: client %p went away",
|
|
connection);
|
|
session = ControlSessionLookup(connection);
|
|
if (session == NULL) {
|
|
/* never asserted anything */
|
|
return;
|
|
}
|
|
ControlSessionInvalidate(session);
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
IPMonitorControlServerHandleRequest(xpc_connection_t connection,
|
|
xpc_object_t request)
|
|
{
|
|
xpc_type_t type;
|
|
|
|
type = xpc_get_type(request);
|
|
if (type == XPC_TYPE_DICTIONARY) {
|
|
int error = 0;
|
|
uint64_t request_type;
|
|
xpc_connection_t remote;
|
|
xpc_object_t reply;
|
|
|
|
request_type
|
|
= xpc_dictionary_get_uint64(request,
|
|
kIPMonitorControlRequestKeyType);
|
|
reply = xpc_dictionary_create_reply(request);
|
|
switch (request_type) {
|
|
case kIPMonitorControlRequestTypeSetInterfaceRank:
|
|
error = HandleSetInterfaceRank(connection, request, reply);
|
|
break;
|
|
case kIPMonitorControlRequestTypeGetInterfaceRank:
|
|
error = HandleGetInterfaceRank(connection, request, reply);
|
|
break;
|
|
case kIPMonitorControlRequestTypeSetInterfaceAdvisory:
|
|
error = HandleSetInterfaceAdvisory(connection, request, reply);
|
|
break;
|
|
case kIPMonitorControlRequestTypeInterfaceAdvisoryIsSet:
|
|
error = HandleInterfaceAdvisoryIsSet(connection, request, reply);
|
|
break;
|
|
case kIPMonitorControlRequestTypeAnyInterfaceAdvisoryIsSet:
|
|
error = HandleAnyInterfaceAdvisoryIsSet(connection, request, reply);
|
|
break;
|
|
default:
|
|
error = EINVAL;
|
|
break;
|
|
}
|
|
if (reply == NULL) {
|
|
/* client didn't want a reply */
|
|
return;
|
|
}
|
|
xpc_dictionary_set_int64(reply, kIPMonitorControlResponseKeyError,
|
|
error);
|
|
remote = xpc_dictionary_get_remote_connection(request);
|
|
xpc_connection_send_message(remote, reply);
|
|
xpc_release(reply);
|
|
}
|
|
else if (type == XPC_TYPE_ERROR) {
|
|
if (request == XPC_ERROR_CONNECTION_INVALID) {
|
|
IPMonitorControlServerHandleDisconnect(connection);
|
|
}
|
|
else if (request == XPC_ERROR_CONNECTION_INTERRUPTED) {
|
|
my_log(LOG_INFO, "connection interrupted");
|
|
}
|
|
}
|
|
else {
|
|
my_log(LOG_NOTICE, "unexpected event");
|
|
}
|
|
return;
|
|
}
|
|
|
|
STATIC void
|
|
IPMonitorControlServerHandleNewConnection(xpc_connection_t connection)
|
|
{
|
|
xpc_handler_t handler;
|
|
|
|
handler = ^(xpc_object_t event) {
|
|
IPMonitorControlServerHandleRequest(connection, event);
|
|
};
|
|
xpc_connection_set_event_handler(connection, handler);
|
|
xpc_connection_set_target_queue(connection, S_IPMonitorControlServerQueue);
|
|
xpc_connection_resume(connection);
|
|
return;
|
|
}
|
|
|
|
STATIC xpc_connection_t
|
|
IPMonitorControlServerCreate(dispatch_queue_t queue, const char * name)
|
|
{
|
|
uint64_t flags = XPC_CONNECTION_MACH_SERVICE_LISTENER;
|
|
xpc_connection_t connection;
|
|
xpc_handler_t handler;
|
|
|
|
connection = xpc_connection_create_mach_service(name, queue, flags);
|
|
if (connection == NULL) {
|
|
return (NULL);
|
|
}
|
|
handler = ^(xpc_object_t event) {
|
|
xpc_type_t type;
|
|
|
|
type = xpc_get_type(event);
|
|
if (type == XPC_TYPE_CONNECTION) {
|
|
IPMonitorControlServerHandleNewConnection(event);
|
|
}
|
|
else if (type == XPC_TYPE_ERROR) {
|
|
const char * desc;
|
|
|
|
desc = xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION);
|
|
if (event == XPC_ERROR_CONNECTION_INVALID) {
|
|
my_log(LOG_NOTICE, "%s", desc);
|
|
xpc_release(connection);
|
|
}
|
|
else {
|
|
my_log(LOG_NOTICE, "%s", desc);
|
|
}
|
|
}
|
|
else {
|
|
my_log(LOG_NOTICE, "unknown event %p", type);
|
|
}
|
|
};
|
|
S_IPMonitorControlServerQueue = queue;
|
|
xpc_connection_set_event_handler(connection, handler);
|
|
xpc_connection_resume(connection);
|
|
return (connection);
|
|
}
|
|
|
|
PRIVATE_EXTERN Boolean
|
|
IPMonitorControlServerStart(CFRunLoopRef runloop, CFRunLoopSourceRef rls,
|
|
Boolean * verbose)
|
|
{
|
|
#pragma unused(verbose)
|
|
dispatch_queue_t q;
|
|
xpc_connection_t connection;
|
|
|
|
SetNotificationInfo(runloop, rls);
|
|
q = dispatch_queue_create("IPMonitorControlServer", NULL);
|
|
connection = IPMonitorControlServerCreate(q, kIPMonitorControlServerName);
|
|
if (connection == NULL) {
|
|
my_log(LOG_ERR,
|
|
"IPMonitorControlServer: failed to create server");
|
|
dispatch_release(q);
|
|
return (FALSE);
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
PRIVATE_EXTERN CFArrayRef
|
|
IPMonitorControlServerCopyInterfaceRankInformation(CFDictionaryRef * info)
|
|
{
|
|
__block CFArrayRef changed;
|
|
__block CFDictionaryRef dict;
|
|
|
|
dispatch_sync(S_IPMonitorControlServerQueue,
|
|
^{
|
|
dict = InterfaceRankAssertionsCopy();
|
|
changed = InterfaceChangedListCopy();
|
|
});
|
|
*info = dict;
|
|
return (changed);
|
|
}
|