IPMonitorControl/IPMonitorControl.c

   1 /*
   2  * Copyright (c) 2013-2015 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*
  25  * IPMonitorControl.c
  26  * - IPC channel to IPMonitor
  27  * - used to create interface rank assertions
  28  */
  29
  30 /*
  31  * Modification History
  32  *
  33  * December 16, 2013    Dieter Siegmund (dieter@apple.com)
  34  * - initial revision
  35  */
  36
  37 #include "IPMonitorControl.h"
  38 #include "IPMonitorControlPrivate.h"
  39 #include "symbol_scope.h"
  40 #include <CoreFoundation/CFRuntime.h>
  41 #include <net/if.h>
  42 #include <xpc/xpc.h>
  43 #include <xpc/private.h>
  44 #include <SystemConfiguration/SCPrivate.h>
  45
  46 #ifdef TEST_IPMONITOR_CONTROL
  47 #define my_log(__level, fmt, ...)       SCPrint(TRUE, stdout, CFSTR(fmt "\n"), ## __VA_ARGS__)
  48
  49 #else /* TEST_IPMONITOR_CONTROL */
  50
  51 #define my_log(__level, fmt, ...)       SCLog(TRUE, __level, CFSTR(fmt), ## __VA_ARGS__)
  52 #endif /* TEST_IPMONITOR_CONTROL */
  53
  54 /**
  55  ** IPMonitorControl CF object glue
  56  **/
  57
  58 struct IPMonitorControl {
  59     CFRuntimeBase               cf_base;
  60
  61     dispatch_queue_t            queue;
  62     xpc_connection_t            connection;
  63     CFMutableDictionaryRef      assertions; /* ifname<string> = rank<number> */
  64 };
  65
  66 STATIC CFStringRef      __IPMonitorControlCopyDebugDesc(CFTypeRef cf);
  67 STATIC void             __IPMonitorControlDeallocate(CFTypeRef cf);
  68
  69 STATIC CFTypeID __kIPMonitorControlTypeID = _kCFRuntimeNotATypeID;
  70
  71 STATIC const CFRuntimeClass __IPMonitorControlClass = {
  72     0,                                  /* version */
  73     "IPMonitorControl",                 /* className */
  74     NULL,                               /* init */
  75     NULL,                               /* copy */
  76     __IPMonitorControlDeallocate,       /* deallocate */
  77     NULL,                               /* equal */
  78     NULL,                               /* hash */
  79     NULL,                               /* copyFormattingDesc */
  80     __IPMonitorControlCopyDebugDesc     /* copyDebugDesc */
  81 };
  82
  83 STATIC CFStringRef
  84 __IPMonitorControlCopyDebugDesc(CFTypeRef cf)
  85 {
  86     CFAllocatorRef              allocator = CFGetAllocator(cf);
  87     IPMonitorControlRef         control = (IPMonitorControlRef)cf;
  88
  89     return (CFStringCreateWithFormat(allocator, NULL,
  90                                      CFSTR("<IPMonitorControl %p>"),
  91                                      control));
  92 }
  93
  94 STATIC void
  95 __IPMonitorControlDeallocate(CFTypeRef cf)
  96 {
  97     IPMonitorControlRef control = (IPMonitorControlRef)cf;
  98
  99     if (control->connection != NULL) {
 100         xpc_release(control->connection);
 101     }
 102     if (control->queue != NULL) {
 103         xpc_release(control->queue);
 104     }
 105     return;
 106 }
 107
 108 /**
 109  ** IPMonitorControl support functions
 110  **/
 111 STATIC void
 112 __IPMonitorControlRegisterClass(void)
 113 {
 114     STATIC dispatch_once_t      once;
 115
 116     dispatch_once(&once, ^{
 117             __kIPMonitorControlTypeID
 118                 = _CFRuntimeRegisterClass(&__IPMonitorControlClass);
 119         });
 120     return;
 121 }
 122
 123 STATIC IPMonitorControlRef
 124 __IPMonitorControlAllocate(CFAllocatorRef allocator)
 125 {
 126     IPMonitorControlRef         control;
 127     int                         size;
 128
 129     __IPMonitorControlRegisterClass();
 130     size = sizeof(*control) - sizeof(CFRuntimeBase);
 131     control = (IPMonitorControlRef)
 132         _CFRuntimeCreateInstance(allocator,
 133                                  __kIPMonitorControlTypeID, size, NULL);
 134     bzero(((void *)control) + sizeof(CFRuntimeBase), size);
 135     return (control);
 136 }
 137
 138 STATIC Boolean
 139 IPMonitorControlHandleResponse(xpc_object_t event, Boolean async,
 140                                Boolean * retry_p)
 141 {
 142     Boolean     retry = FALSE;
 143     Boolean     success = FALSE;
 144     xpc_type_t  type;
 145
 146     type = xpc_get_type(event);
 147     if (type == XPC_TYPE_DICTIONARY) {
 148         if (async) {
 149             /* we don't expect async responses messages */
 150             my_log(LOG_NOTICE, "unexpected message");
 151         }
 152         else {
 153             int64_t     error;
 154
 155             error = xpc_dictionary_get_int64(event,
 156                                              kIPMonitorControlResponseKeyError);
 157             if (error != 0) {
 158                 success = FALSE;
 159 #ifdef TEST_IPMONITOR_CONTROL
 160                 my_log(LOG_NOTICE, "failure code %lld", error);
 161 #endif /* TEST_IPMONITOR_CONTROL */
 162             }
 163             else {
 164                 success = TRUE;
 165             }
 166         }
 167     }
 168     else if (type == XPC_TYPE_ERROR) {
 169         if (event == XPC_ERROR_CONNECTION_INTERRUPTED) {
 170 #ifdef TEST_IPMONITOR_CONTROL
 171             my_log(LOG_NOTICE, "can retry");
 172 #endif /* TEST_IPMONITOR_CONTROL */
 173             retry = TRUE;
 174         }
 175         else {
 176             const char *        desc;
 177
 178             desc = xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION);
 179             my_log(LOG_NOTICE, "%s", desc);
 180         }
 181     }
 182     else {
 183         my_log(LOG_NOTICE, "unknown event type : %p", type);
 184     }
 185     if (retry_p != NULL) {
 186         *retry_p = retry;
 187     }
 188     return (success);
 189 }
 190
 191
 192 STATIC void
 193 IPMonitorControlSetInterfaceRank(IPMonitorControlRef control,
 194                                  CFStringRef ifname_cf,
 195                                  SCNetworkServicePrimaryRank rank)
 196 {
 197     if (control->assertions == NULL) {
 198         if (rank == kSCNetworkServicePrimaryRankDefault) {
 199             /* no assertions, no need to store rank */
 200             return;
 201         }
 202         control->assertions
 203             = CFDictionaryCreateMutable(NULL, 0,
 204                                         &kCFTypeDictionaryKeyCallBacks,
 205                                         &kCFTypeDictionaryValueCallBacks);
 206     }
 207     if (rank == kSCNetworkServicePrimaryRankDefault) {
 208         CFDictionaryRemoveValue(control->assertions, ifname_cf);
 209         if (CFDictionaryGetCount(control->assertions) == 0) {
 210             CFRelease(control->assertions);
 211             control->assertions = NULL;
 212         }
 213     }
 214     else {
 215         CFNumberRef     rank_cf;
 216
 217         rank_cf = CFNumberCreate(NULL, kCFNumberSInt32Type, &rank);
 218         CFDictionarySetValue(control->assertions, ifname_cf, rank_cf);
 219         CFRelease(rank_cf);
 220     }
 221     return;
 222 }
 223
 224 STATIC void
 225 ApplyInterfaceRank(const void * key, const void * value, void * context)
 226 {
 227     xpc_connection_t            connection = (xpc_connection_t)context;
 228     char                        ifname[IF_NAMESIZE];
 229     SCNetworkServicePrimaryRank rank;
 230     xpc_object_t                request;
 231
 232     if (CFStringGetCString(key, ifname, sizeof(ifname),
 233                            kCFStringEncodingUTF8) == FALSE) {
 234         return;
 235     }
 236     if (CFNumberGetValue(value, kCFNumberSInt32Type, &rank) == FALSE) {
 237         return;
 238     }
 239     request = xpc_dictionary_create(NULL, NULL, 0);
 240     xpc_dictionary_set_uint64(request,
 241                               kIPMonitorControlRequestKeyType,
 242                               kIPMonitorControlRequestTypeSetInterfaceRank);
 243     xpc_dictionary_set_string(request,
 244                               kIPMonitorControlRequestKeyInterfaceName,
 245                               ifname);
 246     xpc_dictionary_set_uint64(request,
 247                               kIPMonitorControlRequestKeyPrimaryRank,
 248                               rank);
 249     xpc_connection_send_message(connection, request);
 250     xpc_release(request);
 251     return;
 252 }
 253
 254
 255 /**
 256  ** IPMonitorControl SPI
 257  **/
 258 PRIVATE_EXTERN IPMonitorControlRef
 259 IPMonitorControlCreate(void)
 260 {
 261     xpc_connection_t    connection;
 262     IPMonitorControlRef control;
 263     uint64_t            flags = XPC_CONNECTION_MACH_SERVICE_PRIVILEGED;
 264     xpc_handler_t       handler;
 265     dispatch_queue_t    queue;
 266
 267     control = __IPMonitorControlAllocate(NULL);
 268     queue = dispatch_queue_create("IPMonitorControl", NULL);
 269     connection
 270         = xpc_connection_create_mach_service(kIPMonitorControlServerName,
 271                                              queue, flags);
 272     handler = ^(xpc_object_t event) {
 273         os_activity_t   activity_id;
 274         Boolean         retry;
 275
 276         activity_id = os_activity_start("processing IPMonitor [rank] reply",
 277                                         OS_ACTIVITY_FLAG_DEFAULT);
 278
 279         (void)IPMonitorControlHandleResponse(event, TRUE, &retry);
 280         if (retry && control->assertions != NULL) {
 281             CFDictionaryApplyFunction(control->assertions,
 282                                       ApplyInterfaceRank,
 283                                       control->connection);
 284         }
 285
 286         os_activity_end(activity_id);
 287     };
 288     xpc_connection_set_event_handler(connection, handler);
 289     control->connection = connection;
 290     control->queue = queue;
 291     xpc_connection_resume(connection);
 292     return (control);
 293 }
 294
 295 PRIVATE_EXTERN Boolean
 296 IPMonitorControlSetInterfacePrimaryRank(IPMonitorControlRef control,
 297                                         CFStringRef ifname_cf,
 298                                         SCNetworkServicePrimaryRank rank)
 299 {
 300     char                ifname[IF_NAMESIZE];
 301     xpc_object_t        request;
 302     Boolean             success = FALSE;
 303
 304     if (CFStringGetCString(ifname_cf, ifname, sizeof(ifname),
 305                            kCFStringEncodingUTF8) == FALSE) {
 306         return (FALSE);
 307     }
 308     request = xpc_dictionary_create(NULL, NULL, 0);
 309     xpc_dictionary_set_uint64(request,
 310                               kIPMonitorControlRequestKeyType,
 311                               kIPMonitorControlRequestTypeSetInterfaceRank);
 312     xpc_dictionary_set_string(request,
 313                               kIPMonitorControlRequestKeyInterfaceName,
 314                               ifname);
 315     xpc_dictionary_set_uint64(request,
 316                               kIPMonitorControlRequestKeyPrimaryRank,
 317                               rank);
 318     while (TRUE) {
 319         xpc_object_t    reply;
 320         Boolean         retry_on_error = FALSE;
 321
 322         reply = xpc_connection_send_message_with_reply_sync(control->connection,
 323                                                             request);
 324         if (reply == NULL) {
 325             my_log(LOG_NOTICE, "failed to send message");
 326             break;
 327         }
 328         success = IPMonitorControlHandleResponse(reply, FALSE,
 329                                                  &retry_on_error);
 330         xpc_release(reply);
 331         if (success) {
 332             break;
 333         }
 334         if (retry_on_error) {
 335             continue;
 336         }
 337         my_log(LOG_NOTICE, "fatal error");
 338         break;
 339     }
 340     xpc_release(request);
 341     if (success) {
 342         /* sync our state */
 343         CFRetain(ifname_cf);
 344         CFRetain(control);
 345         dispatch_async(control->queue,
 346                        ^{
 347                            IPMonitorControlSetInterfaceRank(control,
 348                                                             ifname_cf,
 349                                                             rank);
 350                            CFRelease(ifname_cf);
 351                            CFRelease(control);
 352                        });
 353     }
 354     return (success);
 355 }
 356
 357 SCNetworkServicePrimaryRank
 358 IPMonitorControlGetInterfacePrimaryRank(IPMonitorControlRef control,
 359                                         CFStringRef ifname_cf)
 360 {
 361     char                        ifname[IF_NAMESIZE];
 362     SCNetworkServicePrimaryRank rank;
 363     xpc_object_t                request;
 364
 365     rank = kSCNetworkServicePrimaryRankDefault;
 366     if (CFStringGetCString(ifname_cf, ifname, sizeof(ifname),
 367                            kCFStringEncodingUTF8) == FALSE) {
 368         goto done;
 369     }
 370     request = xpc_dictionary_create(NULL, NULL, 0);
 371     xpc_dictionary_set_uint64(request,
 372                               kIPMonitorControlRequestKeyType,
 373                               kIPMonitorControlRequestTypeGetInterfaceRank);
 374     xpc_dictionary_set_string(request,
 375                               kIPMonitorControlRequestKeyInterfaceName,
 376                               ifname);
 377     while (TRUE) {
 378         xpc_object_t    reply;
 379         Boolean         retry_on_error = FALSE;
 380         Boolean         success;
 381
 382         reply = xpc_connection_send_message_with_reply_sync(control->connection,
 383                                                             request);
 384         if (reply == NULL) {
 385             my_log(LOG_NOTICE, "failed to send message");
 386             break;
 387         }
 388         success = IPMonitorControlHandleResponse(reply, FALSE, &retry_on_error);
 389         if (success) {
 390             rank = (SCNetworkServicePrimaryRank)
 391                 xpc_dictionary_get_uint64(reply,
 392                                           kIPMonitorControlResponseKeyPrimaryRank);
 393         }
 394         xpc_release(reply);
 395         if (success) {
 396             break;
 397         }
 398         if (retry_on_error) {
 399             continue;
 400         }
 401         break;
 402     }
 403     xpc_release(request);
 404
 405  done:
 406     return (rank);
 407 }
 408