libSystemConfiguration/libSystemConfiguration_server.c

   1 /*
   2  * Copyright (c) 2012-2014 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 #include <Availability.h>
  25 #include <TargetConditionals.h>
  26 #include <asl.h>
  27 #include <dispatch/dispatch.h>
  28 #include <vproc.h>
  29 #include <vproc_priv.h>
  30 #include <xpc/xpc.h>
  31 #include <xpc/private.h>
  32
  33 #include <CoreFoundation/CoreFoundation.h>
  34 #include <SystemConfiguration/SCPrivate.h>
  35
  36 #include "libSystemConfiguration_server.h"
  37
  38 #define kTrailingEdgeAgentEntitlement "com.apple.SystemConfiguration.trailing-edge-agent"
  39
  40 #pragma mark -
  41 #pragma mark Support functions
  42
  43
  44 //__private_extern__ void
  45 //log_xpc_object(const char *msg, xpc_object_t obj)
  46 //{
  47 //      char    *desc;
  48 //
  49 //      desc = xpc_copy_description(obj);
  50 //      asl_log(NULL, NULL, ASL_LEVEL_ERR, "%s = %s", msg, desc);
  51 //      free(desc);
  52 //}
  53
  54
  55 #pragma mark -
  56 #pragma mark client connection trackng
  57
  58
  59 typedef struct {
  60         xpc_connection_t        connection;
  61 } client_key_t;
  62
  63 typedef struct {
  64         pid_t                   pid;
  65         uint64_t                generation_pushed;
  66         uint64_t                generation_acknowledged;
  67 } client_val_t;
  68
  69
  70 static __inline__ CF_RETURNS_RETAINED CFDataRef
  71 _client_key(xpc_connection_t c)
  72 {
  73         client_key_t    key;
  74         CFDataRef       client_key;
  75
  76         key.connection = c;
  77         client_key = CFDataCreate(NULL, (UInt8 *)&key, sizeof(key));
  78         return client_key;
  79 }
  80
  81
  82 static void
  83 _handle_entitlement_check_failure(pid_t pid)
  84 {
  85         static Boolean                  cleanupScheduled        = FALSE;
  86         static dispatch_once_t          initializer             = 0;
  87         static CFMutableArrayRef        pids                    = NULL;
  88         static dispatch_queue_t         queue                   = NULL;
  89
  90         dispatch_once(&initializer, ^{
  91                 pids = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
  92                 queue = dispatch_queue_create("handle unentitled ack", NULL);
  93         });
  94
  95         dispatch_sync(queue, ^{
  96                 CFNumberRef     pidNumber       = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &pid);
  97
  98                 if (!CFArrayContainsValue(pids, CFRangeMake(0, CFArrayGetCount(pids)), pidNumber)) {
  99                         CFArrayAppendValue(pids, pidNumber);
 100
 101                         SCLog(TRUE, LOG_ERR, CFSTR("DNS/nwi dropping ack w/no entitlement, pid = %d"), pid);
 102
 103                         if (!cleanupScheduled) {
 104                                 cleanupScheduled = TRUE;
 105                                 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 180LL * NSEC_PER_SEC), queue, ^{
 106                                         CFArrayRemoveAllValues(pids);
 107                                         cleanupScheduled = FALSE;
 108                                 });
 109                         }
 110                 }
 111
 112                 CFRelease(pidNumber);
 113         });
 114 }
 115
 116
 117 /*
 118  * libSystemConfiguraiton_client
 119  *
 120  * - all APIs must be called from the same [serial] dispatch queue
 121  */
 122
 123
 124 __private_extern__
 125 void
 126 _libSC_info_server_init(libSC_info_server_t *server_info) {
 127         bzero(server_info, sizeof(*server_info));
 128         server_info->info = CFDictionaryCreateMutable(NULL,
 129                                                       0,
 130                                                       &kCFTypeDictionaryKeyCallBacks,
 131                                                       &kCFTypeDictionaryValueCallBacks);
 132         return;
 133 }
 134
 135
 136 __private_extern__
 137 void
 138 _libSC_info_server_set_data(libSC_info_server_t *server_info,
 139                             CFDataRef           data,
 140                             uint64_t            generation)
 141 {
 142         // update stored configuration
 143         if (server_info->data != NULL) {
 144                 CFRelease(server_info->data);
 145                 server_info->data = NULL;
 146         }
 147         if (data != NULL) {
 148                 CFRetain(data);
 149                 server_info->data = data;
 150         }
 151
 152         // update generation
 153         if (generation == 0) {
 154                 // generation must be non-zero
 155                 generation = 1;
 156         }
 157         server_info->generation = generation;
 158
 159         // new configuration, all ack'ing clients need to
 160         // check-in again
 161         server_info->inSync_NO += server_info->inSync_YES;
 162         server_info->inSync_YES = 0;
 163
 164         return;
 165 }
 166
 167
 168 /*
 169  * _libSC_info_server_in_sync
 170  *
 171  * Called to check if all of the "active" configuration [XPC] connection
 172  * are in sync with the requested generation.
 173  */
 174 __private_extern__
 175 Boolean
 176 _libSC_info_server_in_sync(libSC_info_server_t *server_info)
 177 {
 178         return (server_info->inSync_NO == 0) ? TRUE : FALSE;
 179 }
 180
 181
 182 /*
 183  * _libSC_info_server_open
 184  *
 185  * Called when a new configuration [XPC] connection
 186  * is established.
 187  *
 188  * - tracks the last generation pushed to the caller and
 189  *   the last generation ack'd by the caller
 190  */
 191 __private_extern__
 192 void
 193 _libSC_info_server_open(libSC_info_server_t     *server_info,
 194                         xpc_connection_t        c)
 195 {
 196         CFDataRef               client_key;
 197         CFMutableDataRef        client_val;
 198         client_val_t            *val;
 199
 200         client_key = _client_key(c);
 201
 202         client_val = CFDataCreateMutable(NULL, sizeof(*val));
 203         CFDataSetLength(client_val, sizeof(*val));
 204
 205         val = (client_val_t *)(void *)CFDataGetMutableBytePtr(client_val);
 206         val->pid                     = xpc_connection_get_pid(c);
 207         val->generation_pushed       = 0;
 208         val->generation_acknowledged = 0;
 209
 210         CFDictionarySetValue(server_info->info, client_key, client_val);
 211         CFRelease(client_key);
 212         CFRelease(client_val);
 213
 214         return;
 215 }
 216
 217
 218 /*
 219  * _libSC_info_server_get_data
 220  *
 221  * Called when a [XPC] connection wants the current configuration.
 222  *
 223  * - updates the last generation pushed to the caller
 224  */
 225 __private_extern__
 226 CFDataRef
 227 _libSC_info_server_get_data(libSC_info_server_t *server_info,
 228                             xpc_connection_t    c,
 229                             uint64_t            *generation)
 230 {
 231         CFDataRef               client_key;
 232         CFMutableDataRef        client_val;
 233         client_val_t            *val;
 234
 235         // update last generation pushed to client
 236         client_key = _client_key(c);
 237         client_val = (CFMutableDataRef)CFDictionaryGetValue(server_info->info, client_key);
 238         CFRelease(client_key);
 239
 240         val = (client_val_t *)(void *)CFDataGetMutableBytePtr(client_val);
 241         val->generation_pushed = server_info->generation;
 242
 243         // return generation
 244         *generation = server_info->generation;
 245         if (*generation == 1) {
 246                 *generation = 0;
 247         }
 248
 249         // return data
 250         return server_info->data;
 251 }
 252
 253
 254 /*
 255  * _libSC_info_server_acknowledged
 256  *
 257  * Called when a [XPC] connection wants to acknowledge a
 258  * processed configuration.
 259  *
 260  * - updates the last generation ack'd by the caller
 261  * - updates the count of [XPC] connections that are / not in sync
 262  */
 263 __private_extern__
 264 Boolean
 265 _libSC_info_server_acknowledged(libSC_info_server_t     *server_info,
 266                                 xpc_connection_t        c,
 267                                 uint64_t                generation)
 268 {
 269         CFDataRef               client_key;
 270         CFMutableDataRef        client_val;
 271         xpc_object_t            ent_value;
 272         Boolean                 entitled        = FALSE;
 273         Boolean                 sync_updated    = FALSE;
 274         client_val_t            *val;
 275
 276         ent_value = xpc_connection_copy_entitlement_value(c, kTrailingEdgeAgentEntitlement);
 277         if (ent_value != NULL) {
 278                 if (xpc_get_type(ent_value) == XPC_TYPE_BOOL) {
 279                         entitled = xpc_bool_get_value(ent_value);
 280                 }
 281                 xpc_release(ent_value);
 282         }
 283
 284         if (!entitled) {
 285                 _handle_entitlement_check_failure(xpc_connection_get_pid(c));
 286                 return FALSE;
 287         }
 288
 289         client_key = _client_key(c);
 290         client_val = (CFMutableDataRef)CFDictionaryGetValue(server_info->info, client_key);
 291         CFRelease(client_key);
 292
 293         val = (client_val_t *)(void *)CFDataGetMutableBytePtr(client_val);
 294
 295         if (val->generation_acknowledged == 0) {
 296                 // if first ack
 297                 if (generation == server_info->generation) {
 298                         server_info->inSync_YES++;
 299                 } else {
 300                         server_info->inSync_NO++;
 301                         sync_updated = TRUE;
 302                 }
 303         } else if ((generation != val->generation_acknowledged) &&
 304                     (generation == server_info->generation)) {
 305                 // if we've previously ack'd a configuration
 306                 // ... and if we are ack'ing a configuration
 307                 //     that we have not previously ack'd
 308                 // ... and if we're ack'ing the current stored
 309                 //     configuration
 310                 server_info->inSync_NO--;
 311                 server_info->inSync_YES++;
 312                 sync_updated = TRUE;
 313         }
 314
 315         val->generation_acknowledged = generation;
 316
 317         return sync_updated;
 318 }
 319
 320
 321 /*
 322  * _libSC_info_server_close
 323  *
 324  * Called when a configuration [XPC] connection is closed.
 325  */
 326 __private_extern__
 327 Boolean
 328 _libSC_info_server_close(libSC_info_server_t    *server_info,
 329                          xpc_connection_t       c)
 330 {
 331         CFDataRef               client_key;
 332         CFMutableDataRef        client_val;
 333         Boolean                 sync_updated    = FALSE;
 334
 335         client_key = _client_key(c);
 336
 337         // get client info, remove ack'd info
 338         client_val = (CFMutableDataRef)CFDictionaryGetValue(server_info->info, client_key);
 339         if (client_val != NULL) {
 340                 client_val_t    *val;
 341
 342                 val = (client_val_t *)(void *)CFDataGetMutableBytePtr(client_val);
 343                 if (val->generation_acknowledged > 0) {
 344                         // if we've previously ack'd a configuration
 345                         if (val->generation_acknowledged == server_info->generation) {
 346                                 // if currently in sync
 347                                 server_info->inSync_YES--;
 348                         } else {
 349                                 // if currently NOT in sync
 350                                 server_info->inSync_NO--;
 351                                 sync_updated = TRUE;
 352                         }
 353                 }
 354         }
 355
 356         CFDictionaryRemoveValue(server_info->info, client_key);
 357         CFRelease(client_key);
 358
 359         return sync_updated;
 360 }
 361