]> git.saurik.com Git - apple/configd.git/blob - Plugins/IPMonitor/proxy-configuration.c
configd-801.1.1.tar.gz
[apple/configd.git] / Plugins / IPMonitor / proxy-configuration.c
1 /*
2 * Copyright (c) 2011-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 /*
25 * Modification History
26 *
27 * January 3, 2011 Allan Nathanson <ajn@apple.com>
28 * - initial revision
29 */
30
31 #include <TargetConditionals.h>
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <net/if.h>
35
36 #include <CoreFoundation/CoreFoundation.h>
37 #include <SystemConfiguration/SystemConfiguration.h>
38 #include <SystemConfiguration/SCPrivate.h>
39 #include <SystemConfiguration/SCValidation.h>
40 #include "ip_plugin.h"
41
42
43 #define DEFAULT_MATCH_ORDER 200000 /* match order for the "default" proxy configuration */
44
45
46 #define PROXY_MATCH_ORDER_KEY CFSTR("__MATCH_ORDER__")
47 #define ORDER_KEY CFSTR("__ORDER__")
48
49
50 CFBooleanRef G_supplemental_proxies_follow_dns = NULL;
51
52
53 static void
54 add_proxy(CFMutableArrayRef proxies, CFMutableDictionaryRef proxy)
55 {
56 CFIndex i;
57 CFIndex n_proxies;
58 CFNumberRef order;
59
60 n_proxies = CFArrayGetCount(proxies);
61 for (i = 0; i < n_proxies; i++) {
62 CFDictionaryRef match_proxy;
63
64 match_proxy = CFArrayGetValueAtIndex(proxies, i);
65 if (CFEqual(proxy, match_proxy)) {
66 // a real duplicate
67 return;
68 }
69 }
70
71 order = CFNumberCreate(NULL, kCFNumberCFIndexType, &n_proxies);
72 CFDictionarySetValue(proxy, ORDER_KEY, order);
73 CFRelease(order);
74
75 CFArrayAppendValue(proxies, proxy);
76 return;
77 }
78
79
80 static void
81 add_supplemental(CFMutableArrayRef proxies, CFDictionaryRef proxy, uint32_t defaultOrder)
82 {
83 CFArrayRef domains;
84 CFIndex i;
85 CFIndex n_domains;
86 CFArrayRef orders;
87
88 domains = CFDictionaryGetValue(proxy, kSCPropNetProxiesSupplementalMatchDomains);
89 n_domains = isA_CFArray(domains) ? CFArrayGetCount(domains) : 0;
90 if (n_domains == 0) {
91 return;
92 }
93
94 orders = CFDictionaryGetValue(proxy, kSCPropNetProxiesSupplementalMatchOrders);
95 if (orders != NULL) {
96 if (!isA_CFArray(orders) || (n_domains != CFArrayGetCount(orders))) {
97 return;
98 }
99 }
100
101 /*
102 * yes, this is a "supplemental" proxy configuration, expand
103 * the match domains and add each to the proxies list.
104 */
105 for (i = 0; i < n_domains; i++) {
106 CFStringRef match_domain;
107 CFNumberRef match_order;
108 CFMutableDictionaryRef match_proxy;
109
110 match_domain = CFArrayGetValueAtIndex(domains, i);
111 if (!isA_CFString(match_domain)) {
112 continue;
113 }
114
115 match_proxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
116
117 // set supplemental proxy match "domain"
118 match_domain = _SC_trimDomain(match_domain);
119 if (match_domain != NULL) {
120 CFDictionarySetValue(match_proxy, kSCPropNetProxiesSupplementalMatchDomain, match_domain);
121 CFRelease(match_domain);
122 } else {
123 CFDictionaryRemoveValue(match_proxy, kSCPropNetProxiesSupplementalMatchDomain);
124 }
125
126 // set supplemental proxy match "order"
127 match_order = (orders != NULL) ? CFArrayGetValueAtIndex(orders, i) : NULL;
128 if (isA_CFNumber(match_order)) {
129 CFDictionarySetValue(match_proxy, PROXY_MATCH_ORDER_KEY, match_order);
130 } else {
131 CFNumberRef num;
132
133 num = CFNumberCreate(NULL, kCFNumberIntType, &defaultOrder);
134 CFDictionarySetValue(match_proxy, PROXY_MATCH_ORDER_KEY, num);
135 CFRelease(num);
136
137 defaultOrder++; // if multiple domains, maintain ordering
138 }
139
140 // remove keys we don't want in a supplemental proxy
141 CFDictionaryRemoveValue(match_proxy, kSCPropNetProxiesSupplementalMatchDomains);
142 CFDictionaryRemoveValue(match_proxy, kSCPropNetProxiesSupplementalMatchOrders);
143 CFDictionaryRemoveValue(match_proxy, kSCPropInterfaceName);
144
145 add_proxy(proxies, match_proxy);
146 CFRelease(match_proxy);
147 }
148
149 return;
150 }
151
152
153 #define N_QUICK 32
154
155
156 static void
157 add_supplemental_proxies(CFMutableArrayRef proxies, CFDictionaryRef services, CFArrayRef service_order)
158 {
159 const void * keys_q[N_QUICK];
160 const void ** keys = keys_q;
161 CFIndex i;
162 CFIndex n_order;
163 CFIndex n_services;
164 const void * vals_q[N_QUICK];
165 const void ** vals = vals_q;
166
167 n_services = isA_CFDictionary(services) ? CFDictionaryGetCount(services) : 0;
168 if (n_services == 0) {
169 return; // if no services
170 }
171
172 if (n_services > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
173 keys = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
174 vals = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
175 }
176
177 n_order = isA_CFArray(service_order) ? CFArrayGetCount(service_order) : 0;
178
179 CFDictionaryGetKeysAndValues(services, keys, vals);
180 for (i = 0; i < n_services; i++) {
181 uint32_t defaultOrder;
182 CFDictionaryRef proxy;
183 CFMutableDictionaryRef proxyWithDNS = NULL;
184 CFDictionaryRef service = (CFDictionaryRef)vals[i];
185
186 if (!isA_CFDictionary(service)) {
187 continue;
188 }
189
190 proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
191 if (!isA_CFDictionary(proxy)) {
192 continue;
193 }
194
195 if ((G_supplemental_proxies_follow_dns != NULL) && CFBooleanGetValue(G_supplemental_proxies_follow_dns)) {
196 CFDictionaryRef dns;
197 CFArrayRef matchDomains;
198 CFArrayRef matchOrders;
199
200 if (!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomains) &&
201 CFDictionaryGetValueIfPresent(service, kSCEntNetDNS, (const void **)&dns) &&
202 isA_CFDictionary(dns) &&
203 CFDictionaryGetValueIfPresent(dns, kSCPropNetDNSSupplementalMatchDomains, (const void **)&matchDomains) &&
204 isA_CFArray(matchDomains)) {
205 proxyWithDNS = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
206 CFDictionarySetValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchDomains, matchDomains);
207 if (CFDictionaryGetValueIfPresent(dns, kSCPropNetDNSSupplementalMatchOrders, (const void **)&matchOrders) &&
208 isA_CFArray(matchOrders)) {
209 CFDictionarySetValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchOrders, matchOrders);
210 } else {
211 CFDictionaryRemoveValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchOrders);
212 }
213 proxy = proxyWithDNS;
214 }
215 }
216
217 defaultOrder = DEFAULT_MATCH_ORDER
218 - (DEFAULT_MATCH_ORDER / 2)
219 + ((DEFAULT_MATCH_ORDER / 1000) * (uint32_t)i);
220 if ((n_order > 0) &&
221 !CFArrayContainsValue(service_order, CFRangeMake(0, n_order), keys[i])) {
222 // push out services not specified in service order
223 defaultOrder += (DEFAULT_MATCH_ORDER / 1000) * n_services;
224 }
225
226 add_supplemental(proxies, proxy, defaultOrder);
227 if (proxyWithDNS != NULL) CFRelease(proxyWithDNS);
228 }
229
230 if (keys != keys_q) {
231 CFAllocatorDeallocate(NULL, keys);
232 CFAllocatorDeallocate(NULL, vals);
233 }
234
235 return;
236 }
237
238
239 static CFComparisonResult
240 compareBySearchOrder(const void *val1, const void *val2, void *context)
241 {
242 CFDictionaryRef proxy1 = (CFDictionaryRef)val1;
243 CFDictionaryRef proxy2 = (CFDictionaryRef)val2;
244 CFNumberRef num1;
245 CFNumberRef num2;
246 uint32_t order1 = DEFAULT_MATCH_ORDER;
247 uint32_t order2 = DEFAULT_MATCH_ORDER;
248
249 num1 = CFDictionaryGetValue(proxy1, PROXY_MATCH_ORDER_KEY);
250 if (!isA_CFNumber(num1) ||
251 !CFNumberGetValue(num1, kCFNumberIntType, &order1)) {
252 order1 = DEFAULT_MATCH_ORDER;
253 }
254
255 num2 = CFDictionaryGetValue(proxy2, PROXY_MATCH_ORDER_KEY);
256 if (!isA_CFNumber(num2) ||
257 !CFNumberGetValue(num2, kCFNumberIntType, &order2)) {
258 order2 = DEFAULT_MATCH_ORDER;
259 }
260
261 if (order1 == order2) {
262 // if same match "order", retain original ordering for configurations
263 if (CFDictionaryGetValueIfPresent(proxy1, ORDER_KEY, (const void **)&num1) &&
264 CFDictionaryGetValueIfPresent(proxy2, ORDER_KEY, (const void **)&num2) &&
265 isA_CFNumber(num1) &&
266 isA_CFNumber(num2) &&
267 CFNumberGetValue(num1, kCFNumberIntType, &order1) &&
268 CFNumberGetValue(num2, kCFNumberIntType, &order2)) {
269 if (order1 == order2) {
270 return kCFCompareEqualTo;
271 } else {
272 return (order1 < order2) ? kCFCompareLessThan : kCFCompareGreaterThan;
273 }
274 }
275
276 return kCFCompareEqualTo;
277 }
278
279 return (order1 < order2) ? kCFCompareLessThan : kCFCompareGreaterThan;
280 }
281
282
283 static __inline__ Boolean
284 isSupplementalProxy(CFDictionaryRef proxy)
285 {
286 if ((proxy != NULL) &&
287 CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
288 return TRUE;
289 }
290
291 return FALSE;
292 }
293
294
295 static CFArrayRef
296 copy_supplemental_proxies(CFArrayRef proxies, Boolean skip)
297 {
298 CFIndex i;
299 CFIndex n_proxies;
300 CFMutableArrayRef supplemental = NULL;
301
302 // iterate over services
303
304 n_proxies = isA_CFArray(proxies) ? CFArrayGetCount(proxies) : 0;
305 for (i = 0; i < n_proxies; i++) {
306 CFDictionaryRef proxy;
307
308 proxy = CFArrayGetValueAtIndex(proxies, i);
309 if (!isSupplementalProxy(proxy)) {
310 // if not supplemental proxy (i.e. no match domain)
311 continue;
312 }
313
314 // add [supplemental] proxy entry
315 if (supplemental == NULL) {
316 supplemental = CFArrayCreateMutable(NULL,
317 0,
318 &kCFTypeArrayCallBacks);
319 }
320 CFArrayAppendValue(supplemental, proxy);
321 }
322
323 return supplemental;
324 }
325
326
327 static CFArrayRef
328 service_order_copy_all(CFDictionaryRef services, CFArrayRef service_order)
329 {
330 const void * keys_q[N_QUICK];
331 const void ** keys = keys_q;
332 CFIndex i;
333 CFIndex n_order;
334 CFIndex n_services;
335 CFMutableArrayRef order;
336
337 // ensure that we process all services in order
338 n_services = isA_CFDictionary(services) ? CFDictionaryGetCount(services) : 0;
339 if (n_services == 0) {
340 // if no services
341 return NULL;
342 }
343
344 // ensure that we process all services in order
345
346 n_order = isA_CFArray(service_order) ? CFArrayGetCount(service_order) : 0;
347 if (n_order > 0) {
348 order = CFArrayCreateMutableCopy(NULL, 0, service_order);
349 } else {
350 order = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
351 }
352
353 if (n_services > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
354 keys = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
355 }
356 CFDictionaryGetKeysAndValues(services, keys, NULL);
357 for (i = 0; i < n_services; i++) {
358 CFStringRef serviceID = (CFStringRef)keys[i];
359
360 if (!CFArrayContainsValue(order, CFRangeMake(0, n_order), serviceID)) {
361 CFArrayAppendValue(order, serviceID);
362 n_order++;
363 }
364 }
365 if (keys != keys_q) {
366 CFAllocatorDeallocate(NULL, keys);
367 }
368
369 return order;
370 }
371
372
373 static CFDictionaryRef
374 copy_app_layer_vpn_proxies(CFDictionaryRef services, CFArrayRef order, CFDictionaryRef services_info)
375 {
376 CFMutableDictionaryRef app_layer_proxies = NULL;
377 CFIndex i;
378 CFIndex n_order;
379
380 if (!isA_CFDictionary(services_info)) {
381 return NULL;
382 }
383
384 // iterate over services
385
386 n_order = isA_CFArray(order) ? CFArrayGetCount(order) : 0;
387 for (i = 0; i < n_order; i++) {
388 CFMutableDictionaryRef newProxy;
389 CFDictionaryRef proxy;
390 CFDictionaryRef service;
391 CFStringRef serviceID;
392 CFNumberRef isServiceSpecific;
393 int boolValue = 0;
394
395 serviceID = CFArrayGetValueAtIndex(order, i);
396 service = CFDictionaryGetValue(services, serviceID);
397 if (!isA_CFDictionary(service)) {
398 // if no service
399 continue;
400 }
401
402 proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
403 if (!isA_CFDictionary(proxy)) {
404 // if no proxy
405 continue;
406 }
407
408 isServiceSpecific = CFDictionaryGetValue(proxy, kSCPropNetProxiesServiceSpecific);
409 if (!isA_CFNumber(isServiceSpecific) || !CFNumberGetValue(isServiceSpecific, kCFNumberIntType, &boolValue) || !boolValue) {
410 // if not a service-specific proxy configuration
411 continue;
412 }
413
414 if ((app_layer_proxies != NULL) &&
415 CFDictionaryContainsKey(app_layer_proxies, serviceID)) {
416 // if we've already processed this [app_layer_proxies] interface
417 continue;
418 }
419
420 // add [app_layer_proxies] proxy entry
421 newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
422 CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
423 CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
424 CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesServiceSpecific);
425 if (app_layer_proxies == NULL) {
426 app_layer_proxies = CFDictionaryCreateMutable(NULL,
427 0,
428 &kCFTypeDictionaryKeyCallBacks,
429 &kCFTypeDictionaryValueCallBacks);
430 }
431 CFDictionarySetValue(app_layer_proxies, serviceID, newProxy);
432 CFRelease(newProxy);
433 }
434
435 return app_layer_proxies;
436 }
437
438
439 static CFDictionaryRef
440 copy_scoped_proxies(CFDictionaryRef services, CFArrayRef order)
441 {
442 CFIndex i;
443 CFIndex n_order;
444 CFMutableDictionaryRef scoped = NULL;
445
446 // iterate over services
447
448 n_order = isA_CFArray(order) ? CFArrayGetCount(order) : 0;
449 for (i = 0; i < n_order; i++) {
450 char if_name[IF_NAMESIZE];
451 CFStringRef interface;
452 CFMutableDictionaryRef newProxy;
453 CFDictionaryRef proxy;
454 CFDictionaryRef service;
455 CFStringRef serviceID;
456
457 serviceID = CFArrayGetValueAtIndex(order, i);
458 service = CFDictionaryGetValue(services, serviceID);
459 if (!isA_CFDictionary(service)) {
460 // if no service
461 continue;
462 }
463
464 proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
465 if (!isA_CFDictionary(proxy)) {
466 // if no proxy
467 continue;
468 }
469
470 interface = CFDictionaryGetValue(proxy, kSCPropInterfaceName);
471 if (interface == NULL) {
472 // if no [scoped] interface
473 continue;
474 }
475 if ((scoped != NULL) &&
476 CFDictionaryContainsKey(scoped, interface)) {
477 // if we've already processed this [scoped] interface
478 continue;
479 }
480
481 if ((_SC_cfstring_to_cstring(interface,
482 if_name,
483 sizeof(if_name),
484 kCFStringEncodingASCII) == NULL) ||
485 ((my_if_nametoindex(if_name)) == 0)) {
486 // if interface index not available
487 continue;
488 }
489
490 // add [scoped] proxy entry
491 // ... and remove keys we don't want in a [scoped] proxy
492 CFRetain(interface);
493 newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
494 CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
495 CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
496 CFDictionaryRemoveValue(newProxy, kSCPropInterfaceName);
497 if (scoped == NULL) {
498 scoped = CFDictionaryCreateMutable(NULL,
499 0,
500 &kCFTypeDictionaryKeyCallBacks,
501 &kCFTypeDictionaryValueCallBacks);
502 }
503 CFDictionarySetValue(scoped, interface, newProxy);
504 CFRelease(newProxy);
505 CFRelease(interface);
506 }
507
508 return scoped;
509 }
510
511
512 static void
513 add_default_proxy(CFMutableArrayRef proxies,
514 CFDictionaryRef defaultProxy,
515 Boolean *orderAdded)
516 {
517 CFMutableDictionaryRef myDefault;
518 uint32_t myOrder = DEFAULT_MATCH_ORDER;
519 CFNumberRef order = NULL;
520
521 if (defaultProxy == NULL) {
522 myDefault = CFDictionaryCreateMutable(NULL,
523 0,
524 &kCFTypeDictionaryKeyCallBacks,
525 &kCFTypeDictionaryValueCallBacks);
526 } else {
527 myDefault = CFDictionaryCreateMutableCopy(NULL, 0, defaultProxy);
528 CFDictionaryRemoveValue(myDefault, kSCPropInterfaceName);
529 order = CFDictionaryGetValue(myDefault, PROXY_MATCH_ORDER_KEY);
530 }
531
532 // ensure that the default proxy has a search order
533
534 if (!isA_CFNumber(order) ||
535 !CFNumberGetValue(order, kCFNumberIntType, &myOrder)) {
536 myOrder = DEFAULT_MATCH_ORDER;
537 order = CFNumberCreate(NULL, kCFNumberIntType, &myOrder);
538 CFDictionarySetValue(myDefault, PROXY_MATCH_ORDER_KEY, order);
539 CFRelease(order);
540 *orderAdded = TRUE;
541 }
542
543 // add the default proxy
544
545 add_proxy(proxies, myDefault);
546 CFRelease(myDefault);
547 return;
548 }
549
550
551 static CFComparisonResult
552 compareDomain(const void *val1, const void *val2, void *context)
553 {
554 CFDictionaryRef proxy1 = (CFDictionaryRef)val1;
555 CFDictionaryRef proxy2 = (CFDictionaryRef)val2;
556 CFStringRef domain1;
557 CFStringRef domain2;
558 CFArrayRef labels1 = NULL;
559 CFArrayRef labels2 = NULL;
560 CFIndex n1;
561 CFIndex n2;
562 CFComparisonResult result;
563 Boolean rev1;
564 Boolean rev2;
565
566 // "default" domains sort before "supplemental" domains
567 domain1 = CFDictionaryGetValue(proxy1, kSCPropNetProxiesSupplementalMatchDomain);
568 domain2 = CFDictionaryGetValue(proxy2, kSCPropNetProxiesSupplementalMatchDomain);
569 if (domain1 == NULL) {
570 if (domain2 == NULL) {
571 return kCFCompareEqualTo;
572 }
573 return kCFCompareLessThan;
574 } else if (domain2 == NULL) {
575 return kCFCompareGreaterThan;
576 }
577
578 // forward (A, AAAA) domains sort before reverse (PTR) domains
579 rev1 = CFStringHasSuffix(domain1, CFSTR(".arpa"));
580 rev2 = CFStringHasSuffix(domain2, CFSTR(".arpa"));
581 if (rev1 != rev2) {
582 if (rev1) {
583 return kCFCompareGreaterThan;
584 } else {
585 return kCFCompareLessThan;
586 }
587 }
588
589 labels1 = CFStringCreateArrayBySeparatingStrings(NULL, domain1, CFSTR("."));
590 n1 = CFArrayGetCount(labels1);
591
592 labels2 = CFStringCreateArrayBySeparatingStrings(NULL, domain2, CFSTR("."));
593 n2 = CFArrayGetCount(labels2);
594
595 while ((n1 > 0) && (n2 > 0)) {
596 CFStringRef label1 = CFArrayGetValueAtIndex(labels1, --n1);
597 CFStringRef label2 = CFArrayGetValueAtIndex(labels2, --n2);
598
599 // compare domain labels
600 result = CFStringCompare(label1, label2, kCFCompareCaseInsensitive);
601 if (result != kCFCompareEqualTo) {
602 goto done;
603 }
604 }
605
606 // longer labels (corp.apple.com) sort before shorter labels (apple.com)
607 if (n1 > n2) {
608 result = kCFCompareLessThan;
609 goto done;
610 } else if (n1 < n2) {
611 result = kCFCompareGreaterThan;
612 goto done;
613 }
614
615 // sort by search order
616 result = compareBySearchOrder(val1, val2, context);
617
618 done :
619
620 if (labels1 != NULL) CFRelease(labels1);
621 if (labels2 != NULL) CFRelease(labels2);
622 return result;
623 }
624
625
626 __private_extern__
627 CF_RETURNS_RETAINED CFDictionaryRef
628 proxy_configuration_update(CFDictionaryRef defaultProxy,
629 CFDictionaryRef services,
630 CFArrayRef serviceOrder,
631 CFDictionaryRef servicesInfo)
632 {
633 CFIndex i;
634 CFMutableDictionaryRef myDefault;
635 Boolean myOrderAdded = FALSE;
636 CFMutableDictionaryRef newProxy = NULL;
637 CFIndex n_proxies;
638 CFDictionaryRef proxy;
639 CFMutableArrayRef proxies;
640
641 // establish full list of proxies
642
643 proxies = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
644
645 // collect (and add) any "supplemental" proxy configurations
646
647 add_supplemental_proxies(proxies, services, serviceOrder);
648
649 // add the "default" proxy
650
651 add_default_proxy(proxies, defaultProxy, &myOrderAdded);
652
653 // sort proxies, cleanup
654
655 n_proxies = CFArrayGetCount(proxies);
656 if (n_proxies > 1) {
657 CFArraySortValues(proxies, CFRangeMake(0, n_proxies), compareDomain, NULL);
658 }
659
660 // cleanup
661
662 for (i = n_proxies - 1; i >= 0; i--) {
663 proxy = CFArrayGetValueAtIndex(proxies, i);
664
665 if ((i > 0) &&
666 !CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
667 // remove non-supplemental proxy
668 CFArrayRemoveValueAtIndex(proxies, i);
669 n_proxies--;
670 continue;
671 }
672
673 newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
674 CFDictionaryRemoveValue(newProxy, PROXY_MATCH_ORDER_KEY);
675 CFDictionaryRemoveValue(newProxy, ORDER_KEY);
676 CFArraySetValueAtIndex(proxies, i, newProxy);
677 CFRelease(newProxy);
678 }
679
680 // update the default proxy
681
682 myDefault = CFDictionaryCreateMutableCopy(NULL,
683 0,
684 CFArrayGetValueAtIndex(proxies, 0));
685 if (myOrderAdded && (n_proxies > 1)) {
686 CFDictionaryRef proxy;
687
688 proxy = CFArrayGetValueAtIndex(proxies, 1);
689 if (CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
690 // if not a supplemental "default" proxy (a match domain name is
691 // present)
692 CFDictionaryRemoveValue(myDefault, PROXY_MATCH_ORDER_KEY);
693 }
694 }
695 CFArraySetValueAtIndex(proxies, 0, myDefault);
696 CFRelease(myDefault);
697
698 // establish proxy configuration
699
700 if (n_proxies > 0) {
701 CFDictionaryRef app_layer;
702 CFDictionaryRef scoped;
703 CFArrayRef serviceOrderAll;
704 Boolean skip = FALSE;
705 CFArrayRef supplemental;
706
707 proxy = CFArrayGetValueAtIndex(proxies, 0);
708 if (!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
709 // if we have "a" default (non-supplemental) proxy
710 newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
711 CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
712 CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
713 skip = TRUE;
714 } else {
715 newProxy = CFDictionaryCreateMutable(NULL,
716 0,
717 &kCFTypeDictionaryKeyCallBacks,
718 &kCFTypeDictionaryValueCallBacks);
719 }
720
721 serviceOrderAll = service_order_copy_all(services, serviceOrder);
722
723 // collect (and add) any "supplemental" proxy configurations
724
725 supplemental = copy_supplemental_proxies(proxies, skip);
726 if (supplemental != NULL) {
727 CFDictionarySetValue(newProxy, kSCPropNetProxiesSupplemental, supplemental);
728 CFRelease(supplemental);
729 }
730
731 // collect (and add) any "scoped" proxy configurations
732
733 scoped = copy_scoped_proxies(services, serviceOrderAll);
734 if (scoped != NULL) {
735 CFDictionarySetValue(newProxy, kSCPropNetProxiesScoped, scoped);
736 CFRelease(scoped);
737 }
738
739 // collect (and add) any "services" based proxy configurations
740
741 app_layer = copy_app_layer_vpn_proxies(services, serviceOrderAll, servicesInfo);
742 if (app_layer != NULL) {
743 CFDictionarySetValue(newProxy, kSCPropNetProxiesServices, app_layer);
744 CFRelease(app_layer);
745 }
746
747 if (serviceOrderAll != NULL) {
748 CFRelease(serviceOrderAll);
749 }
750 } else {
751 newProxy = NULL;
752 }
753
754 CFRelease(proxies);
755 return newProxy;
756 }
757
758
759 __private_extern__
760 void
761 proxy_configuration_init(CFBundleRef bundle)
762 {
763 CFDictionaryRef dict;
764
765 dict = CFBundleGetInfoDictionary(bundle);
766 if (isA_CFDictionary(dict)) {
767 G_supplemental_proxies_follow_dns = CFDictionaryGetValue(dict, CFSTR("SupplementalProxiesFollowSupplementalDNS"));
768 G_supplemental_proxies_follow_dns = isA_CFBoolean(G_supplemental_proxies_follow_dns);
769 }
770
771 return;
772 }
773
774
775 #pragma mark -
776 #pragma mark Standalone test code
777
778
779 #ifdef MAIN
780
781 static void
782 mergeDict(const void *key, const void *value, void *context)
783 {
784 CFMutableDictionaryRef newDict = (CFMutableDictionaryRef)context;
785
786 CFDictionarySetValue(newDict, key, value);
787 return;
788 }
789
790
791 static void
792 split(const void * key, const void * value, void * context)
793 {
794 CFArrayRef components;
795 CFStringRef entity_id;
796 CFStringRef service_id;
797 CFMutableDictionaryRef state_dict;
798
799 components = CFStringCreateArrayBySeparatingStrings(NULL, (CFStringRef)key, CFSTR("/"));
800 service_id = CFArrayGetValueAtIndex(components, 3);
801 entity_id = CFArrayGetValueAtIndex(components, 4);
802 state_dict = (CFMutableDictionaryRef)CFDictionaryGetValue(context, service_id);
803 if (state_dict != NULL) {
804 state_dict = CFDictionaryCreateMutableCopy(NULL, 0, state_dict);
805 } else {
806 state_dict = CFDictionaryCreateMutable(NULL,
807 0,
808 &kCFTypeDictionaryKeyCallBacks,
809 &kCFTypeDictionaryValueCallBacks);
810 }
811
812 if (CFEqual(entity_id, kSCEntNetIPv4) ||
813 CFEqual(entity_id, kSCEntNetIPv6)) {
814 CFStringRef interface;
815
816 interface = CFDictionaryGetValue((CFDictionaryRef)value, kSCPropInterfaceName);
817 if (interface != NULL) {
818 CFDictionaryRef proxy;
819 CFMutableDictionaryRef new_proxy;
820
821 proxy = CFDictionaryGetValue(state_dict, kSCEntNetProxies);
822 if (proxy != NULL) {
823 new_proxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
824 } else {
825 new_proxy = CFDictionaryCreateMutable(NULL,
826 0,
827 &kCFTypeDictionaryKeyCallBacks,
828 &kCFTypeDictionaryValueCallBacks);
829 }
830 CFDictionarySetValue(new_proxy, kSCPropInterfaceName, interface);
831 CFDictionarySetValue(state_dict, kSCEntNetProxies, new_proxy);
832 CFRelease(new_proxy);
833 }
834 } else if (CFEqual(entity_id, kSCEntNetProxies)) {
835 CFDictionaryRef proxy;
836
837 proxy = CFDictionaryGetValue(state_dict, kSCEntNetProxies);
838 if (proxy != NULL) {
839 CFStringRef domain;
840 CFMutableDictionaryRef new_proxy;
841
842 // if we already have some Setup: or State: proxy content
843 domain = CFArrayGetValueAtIndex(components, 0);
844 if (CFEqual(domain, kSCDynamicStoreDomainState)) {
845 // if we've already seen the Setup: key
846 new_proxy = CFDictionaryCreateMutableCopy(NULL, 0, (CFDictionaryRef)value);
847 CFDictionaryApplyFunction(proxy, mergeDict, new_proxy);
848 } else {
849 // if we've already seen the State: key
850 new_proxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
851 CFDictionaryApplyFunction((CFDictionaryRef)value, mergeDict, new_proxy);
852 }
853 CFDictionarySetValue(state_dict, kSCEntNetProxies, new_proxy);
854 CFRelease(new_proxy);
855 } else {
856 CFDictionarySetValue(state_dict, kSCEntNetProxies, (CFDictionaryRef)value);
857 }
858 } else {
859 CFDictionarySetValue(state_dict, entity_id, (CFDictionaryRef)value);
860 }
861
862 CFDictionarySetValue((CFMutableDictionaryRef)context, service_id, state_dict);
863 CFRelease(state_dict);
864 CFRelease(components);
865
866 return;
867 }
868
869 int
870 main(int argc, char **argv)
871 {
872 CFDictionaryRef entities;
873 CFStringRef key;
874 CFDictionaryRef newProxy = NULL;
875 CFStringRef pattern;
876 CFMutableArrayRef patterns;
877 CFStringRef primary = NULL;
878 CFMutableDictionaryRef primary_proxy = NULL;
879 CFArrayRef service_order = NULL;
880 CFMutableDictionaryRef service_state_dict;
881 CFDictionaryRef setup_global_ipv4;
882 CFDictionaryRef state_global_ipv4;
883 SCDynamicStoreRef store;
884
885 _sc_log = FALSE;
886 _sc_verbose = (argc > 1) ? TRUE : FALSE;
887
888 store = SCDynamicStoreCreate(NULL, CFSTR("TEST"), NULL, NULL);
889
890 // get IPv4, IPv6, and Proxies entities
891 patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
892 pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
893 kSCDynamicStoreDomainState,
894 kSCCompAnyRegex,
895 kSCEntNetIPv4);
896 CFArrayAppendValue(patterns, pattern);
897 CFRelease(pattern);
898 pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
899 kSCDynamicStoreDomainState,
900 kSCCompAnyRegex,
901 kSCEntNetIPv6);
902 CFArrayAppendValue(patterns, pattern);
903 CFRelease(pattern);
904 pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
905 kSCDynamicStoreDomainSetup,
906 kSCCompAnyRegex,
907 kSCEntNetProxies);
908 CFArrayAppendValue(patterns, pattern);
909 CFRelease(pattern);
910 pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
911 kSCDynamicStoreDomainState,
912 kSCCompAnyRegex,
913 kSCEntNetProxies);
914 CFArrayAppendValue(patterns, pattern);
915 CFRelease(pattern);
916 entities = SCDynamicStoreCopyMultiple(store, NULL, patterns);
917 CFRelease(patterns);
918
919 service_state_dict = CFDictionaryCreateMutable(NULL,
920 0,
921 &kCFTypeDictionaryKeyCallBacks,
922 &kCFTypeDictionaryValueCallBacks);
923 CFDictionaryApplyFunction(entities, split, service_state_dict);
924 CFRelease(entities);
925
926 // get primary service ID
927 key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
928 kSCDynamicStoreDomainState,
929 kSCEntNetIPv4);
930 state_global_ipv4 = SCDynamicStoreCopyValue(store, key);
931 CFRelease(key);
932 if (state_global_ipv4 != NULL) {
933 primary = CFDictionaryGetValue(state_global_ipv4, kSCDynamicStorePropNetPrimaryService);
934 if (primary != NULL) {
935 CFDictionaryRef service_dict;
936
937 // get proxy configuration for primary service
938 service_dict = CFDictionaryGetValue(service_state_dict, primary);
939 if (service_dict != NULL) {
940 CFDictionaryRef service_proxy;
941
942 service_proxy = CFDictionaryGetValue(service_dict, kSCEntNetProxies);
943 if (service_proxy != NULL) {
944 primary_proxy = CFDictionaryCreateMutableCopy(NULL, 0, service_proxy);
945 CFDictionaryRemoveValue(primary_proxy, kSCPropInterfaceName);
946 }
947 }
948 }
949 }
950
951 // get serviceOrder
952 key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
953 kSCDynamicStoreDomainSetup,
954 kSCEntNetIPv4);
955 setup_global_ipv4 = SCDynamicStoreCopyValue(store, key);
956 CFRelease(key);
957 if (setup_global_ipv4 != NULL) {
958 service_order = CFDictionaryGetValue(setup_global_ipv4, kSCPropNetServiceOrder);
959 }
960
961 // update proxy configuration
962 proxy_configuration_init(CFBundleGetMainBundle());
963 newProxy = proxy_configuration_update(primary_proxy,
964 service_state_dict,
965 service_order,
966 NULL);
967 if (newProxy != NULL) {
968 SCPrint(TRUE, stdout, CFSTR("%@\n"), newProxy);
969 CFRelease(newProxy);
970 }
971
972 // cleanup
973 if (setup_global_ipv4 != NULL) CFRelease(setup_global_ipv4);
974 if (state_global_ipv4 != NULL) CFRelease(state_global_ipv4);
975 CFRelease(service_state_dict);
976 CFRelease(store);
977
978 /* not reached */
979 exit(0);
980 return 0;
981 }
982 #endif
983