Lines Matching refs:serv
124 static int dispose_service(struct service *serv);
126 static int ondemand_remove_service(struct service *serv);
128 static int add_client(struct service *serv, void *client, int autoclose);
129 static int remove_client(struct service *serv, void *client);
130 static struct service_client *get_client(struct service *serv, void *client);
131 static int remove_all_clients(struct service *serv);
207 struct service *serv;
211 TAILQ_FOREACH(serv, &service_head, next) {
212 scnc_stop(serv, 0, SIGTERM, SCNC_STOP_TERM_ALL);
295 struct service *serv;
301 TAILQ_FOREACH(serv, &service_head, next) {
302 switch (serv->type) {
303 case TYPE_PPP: status = ppp_getstatus(serv); break;
304 case TYPE_IPSEC: status = ipsec_getstatus(serv); break;
323 int allow_dispose(struct service *serv)
325 if (serv->ne_sm_bridge != NULL) {
326 ne_sm_bridge_allow_dispose(serv->ne_sm_bridge);
328 } else if (serv->flags & FLAG_FREE) {
329 dispose_service(serv);
505 ^(struct service *serv) {
506 if (serv->flags & FLAG_SETUP_ONDEMAND) {
507 ondemand_add_service(serv, FALSE);
848 struct service *serv = NULL;
971 TAILQ_FOREACH(serv, &service_head, next){
972 if (serv->flags & FLAG_SETUP_NETWORKDETECTION) {
974 my_CFEqual(serv->serviceID, primaryServiceID)) || /* If we are the primary service and NWI order changed OR */
977 (newGlobalDNS != serv->ondemandSavedDns) && /* different from last stored */
978 (((newGlobalDNS == NULL) || (serv->ondemandSavedDns == NULL)) ||
979 (!CFEqual(newGlobalDNS, serv->ondemandSavedDns))))) {
981 if (serv->ondemand_paused == ONDEMAND_PAUSE_STATE_TYPE_UNTIL_NETCHANGE) {
982 ondemand_set_pause(serv, ONDEMAND_PAUSE_STATE_TYPE_OFF, FALSE);
985 check_network(serv); /* Network has changed */
988 if (serv->type == TYPE_IPSEC &&
989 scnc_getstatus(serv) != kSCNetworkConnectionDisconnected &&
990 serv->u.ipsec.lower_interface_cellular) {
992 if (my_CFEqual(serv->serviceID, primaryServiceID)) {
996 primaryInterface = copy_primary_interface_name(serv->serviceID);
1003 scnc_stop(serv, 0, SIGTERM, SCNC_STOP_NONE);
1010 my_CFRelease(&serv->ondemandSavedDns);
1013 serv->ondemandSavedDns = newGlobalDNS;
1095 struct service *serv;
1098 TAILQ_FOREACH(serv, &service_head, next) {
1100 switch (serv->type) {
1101 case TYPE_PPP: prevent = !ppp_can_sleep(serv); break;
1102 case TYPE_IPSEC: prevent = !ipsec_can_sleep(serv); break;
1120 struct service *serv;
1122 TAILQ_FOREACH(serv, &service_head, next) {
1124 serv->flags &= ~FLAG_DARKWAKE;
1126 switch (serv->type) {
1127 case TYPE_PPP: ret |= ppp_will_sleep(serv, checking); break;
1128 case TYPE_IPSEC: ret |= ipsec_will_sleep(serv, checking); break;
1141 struct service *serv;
1143 TAILQ_FOREACH(serv, &service_head, next) {
1144 serv->flags |= FLAG_FIRSTDIAL;
1147 serv->flags |= FLAG_DARKWAKE;
1149 serv->flags &= ~FLAG_DARKWAKE;
1151 switch (serv->type) {
1152 case TYPE_PPP: if (isFullWake) ppp_wake_up(serv); break;
1153 case TYPE_IPSEC: if (isFullWake) ipsec_wake_up(serv); break;
1196 struct service *serv;
1199 TAILQ_FOREACH(serv, &service_head, next) {
1200 serv->flags &= ~FLAG_DARKWAKE;
1208 void service_started(struct service *serv)
1210 switch (serv->type) {
1214 serv->vt = vproc_transaction_begin(NULL);
1215 if ( serv->vt == NULL)
1227 service_ending_verify_primaryservice(struct service *serv)
1235 if (serv->type == TYPE_PPP &&
1236 (serv->subtype == PPP_TYPE_PPPoE ||
1237 serv->subtype == PPP_TYPE_SERIAL ||
1238 serv->subtype == PPP_TYPE_SYNCSERIAL)) {
1244 _SC_CFEqual(serv->serviceID, newPrimary)) { // primary is still our service
1263 void service_ended(struct service *serv)
1268 if (serv->cellular_timerref) {
1269 CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), serv->cellular_timerref, kCFRunLoopCommonModes);
1270 my_CFRelease(&serv->cellular_timerref);
1273 my_CFRelease(&serv->cellularConnection);
1277 service_ending_verify_primaryservice(serv);
1278 switch (serv->type) {
1282 if ( serv->vt)
1283 vproc_transaction_end(NULL, serv->vt);
1299 struct service *serv;
1301 TAILQ_FOREACH(serv, &service_head, next) {
1302 switch (serv->type) {
1303 case TYPE_PPP: ppp_log_out(serv); break;
1304 case TYPE_IPSEC: ipsec_log_out(serv); break;
1315 struct service *serv;
1317 TAILQ_FOREACH(serv, &service_head, next) {
1318 serv->flags |= FLAG_FIRSTDIAL;
1319 switch (serv->type) {
1320 case TYPE_PPP: ppp_log_in(serv); break;
1321 case TYPE_IPSEC: ipsec_log_in(serv); break;
1332 struct service *serv;
1334 TAILQ_FOREACH(serv, &service_head, next) {
1335 serv->flags |= FLAG_FIRSTDIAL;
1336 switch (serv->type) {
1337 case TYPE_PPP: ppp_log_switch(serv); break;
1338 case TYPE_IPSEC: ipsec_log_switch(serv); break;
1351 struct service *serv;
1358 TAILQ_FOREACH(serv, &service_head, next) {
1359 serv->flags |= FLAG_FIRSTDIAL;
1360 switch (serv->type) {
1361 case TYPE_PPP: ppp_ipv4_state_changed(serv); break;
1362 case TYPE_IPSEC: ipsec_ipv4_state_changed(serv); break;
1367 _SC_CFEqual(serv->serviceID, newPrimary)) {
1394 struct service *serv;
1396 serv = findbyserviceID(serviceID);
1402 if (!interface || (serv && !my_CFEqual(iftype, serv->typeRef))) {
1404 if (serv) {
1406 dispose_service(serv);
1416 if (serv && !my_CFEqual(subtype, serv->subtypeRef)) {
1418 dispose_service(serv);
1419 serv = 0;
1424 if (!serv) {
1425 serv = new_service(serviceID, iftype, subtype);
1426 if (!serv)
1431 serv->flags |= FLAG_SETUP;
1446 struct service *serv = 0;
1450 serv = malloc(sizeof(struct service));
1451 if (!serv)
1454 bzero(serv, sizeof(struct service));
1456 serv->serviceID = my_CFRetain(serviceID);
1457 serv->typeRef = my_CFRetain(typeRef);
1458 serv->subtypeRef = my_CFRetain(subtypeRef);
1462 if ((serv->sid = malloc(len))) {
1463 CFStringGetCString(serviceID, (char*)serv->sid, len, kCFStringEncodingUTF8);
1468 serv->type = TYPE_PPP;
1469 serv->subtype = ppp_subtype(subtypeRef);
1472 serv->type = TYPE_IPSEC;
1473 serv->subtype = ipsec_subtype(subtypeRef);
1478 serv->unit = findfreeunit(serv->type, serv->subtype);
1479 if (serv->unit == 0xFFFF)
1482 switch (serv->type) {
1483 case TYPE_PPP: err = ppp_new_service(serv); break;
1484 case TYPE_IPSEC: err = ipsec_new_service(serv); break;
1489 serv->uid = 0;
1490 serv->flags |= FLAG_FIRSTDIAL;
1492 TAILQ_INIT(&serv->client_head);
1494 TAILQ_INSERT_TAIL(&service_head, serv, next);
1496 client_notify(serv->serviceID, serv->sid, makeref(serv), 0, 0, CLIENT_FLAG_NOTIFY_STATUS, kSCNetworkConnectionDisconnected);
1498 return serv;
1501 if (serv) {
1502 my_CFRelease(&serv->serviceID);
1503 my_CFRelease(&serv->typeRef);
1504 my_CFRelease(&serv->subtypeRef);
1505 if (serv->sid)
1506 free(serv->sid);
1508 free(serv);
1518 int dispose_service(struct service *serv)
1523 scnc_stop(serv, 0, SIGTERM, SCNC_STOP_SERV_DISPOSE);
1525 switch (serv->type) {
1526 case TYPE_PPP: delay = ppp_dispose_service(serv); break;
1527 case TYPE_IPSEC: delay = ipsec_dispose_service(serv); break;
1530 serv->flags |= FLAG_FREE;
1533 serv->flags &= ~FLAG_FREE;
1538 my_CFRelease(&serv->profileIdentifier);
1541 if (serv->flags & FLAG_SETUP_ONDEMAND) {
1542 serv->flags &= ~FLAG_SETUP_ONDEMAND;
1543 ondemand_remove_service(serv);
1546 TAILQ_REMOVE(&service_head, serv, next);
1548 reachability_clear(serv);
1550 client_notify(serv->serviceID, serv->sid, makeref(serv), 0, 0, CLIENT_FLAG_NOTIFY_STATUS, kSCNetworkConnectionInvalid);
1553 if (serv->sid)
1554 free(serv->sid);
1556 if (serv->userNotificationRef) {
1557 CFUserNotificationCancel(serv->userNotificationRef);
1558 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), serv->userNotificationRLS, kCFRunLoopDefaultMode);
1559 my_CFRelease(&serv->userNotificationRef);
1560 my_CFRelease(&serv->userNotificationRLS);
1563 scnc_bootstrap_dealloc(serv);
1564 scnc_ausession_dealloc(serv);
1566 my_CFRelease(&serv->serviceID);
1567 my_CFRelease(&serv->subtypeRef);
1568 my_CFRelease(&serv->authSubtypeRef);
1569 my_CFRelease(&serv->typeRef);
1570 my_CFRelease(&serv->ondemandAction);
1571 my_CFRelease(&serv->ondemandActionParameters);
1572 my_CFRelease(&serv->ondemandProbeResults);
1573 my_CFRelease(&serv->ondemandDNSTriggeringDicts);
1574 my_CFRelease(&serv->ondemandSavedDns);
1575 my_CFRelease(&serv->dnsRedirectedAddresses);
1576 my_CFRelease(&serv->routeCache);
1577 if (serv->envKeys)
1578 free(serv->envKeys);
1579 if (serv->envValues)
1580 free(serv->envValues);
1581 free(serv);
1592 struct service *serv;
1600 if ((serv = findbyserviceID(serviceID))) {
1602 TAILQ_REMOVE(&service_head, serv, next);
1603 TAILQ_INSERT_TAIL(&service_head, serv, next);
1614 struct service *serv;
1622 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
1623 if (serv->serviceID) {
1624 CFArrayAppendValue(service_array, serv->serviceID);
1658 struct service *serv;
1670 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
1671 if (serv->flags & FLAG_SETUP) {
1673 serv->flags &= ~(FLAG_FREE + FLAG_SETUP);
1675 if (serv->flags & FLAG_SETUP_ONDEMAND) {
1676 serv->flags &= ~FLAG_SETUP_ONDEMAND;
1677 ondemand_remove_service(serv);
1680 switch (serv->type) {
1681 case TYPE_PPP: setup_result = ppp_setup_service(serv); break;
1682 case TYPE_IPSEC: setup_result = ipsec_setup_service(serv); break;
1686 serv->initialized = FALSE;
1689 serv->initialized = TRUE;
1692 serv->flags &= ~(FLAG_SETUP_ONDEMAND | FLAG_SETUP_NETWORKDETECTION);
1696 my_CFRelease(&serv->profileIdentifier);
1697 CFDictionaryRef payloadRoot = copyEntity(gDynamicStore, kSCDynamicStoreDomainSetup, serv->serviceID, CFSTR("com.apple.payload/PayloadRoot"));
1699 serv->profileIdentifier = CFDictionaryGetValue(payloadRoot, CFSTR("PayloadIdentifier"));
1700 serv->profileIdentifier = isA_CFString(serv->profileIdentifier);
1701 if (serv->profileIdentifier)
1702 CFRetain(serv->profileIdentifier);
1707 if (serv->flags & FLAG_SETUP_ONDEMAND){
1708 scnc_cache_init_service(serv);
1709 reachability_reset(serv);
1710 ondemand_add_service(serv, TRUE);
1713 reachability_clear(serv);
1716 if (dochecknetwork && (serv->flags & FLAG_SETUP_NETWORKDETECTION)) {
1717 check_network(serv);
1730 struct service *serv;
1735 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
1736 if (serv->flags & FLAG_SETUP_NETWORKDETECTION){
1737 check_network(serv);
1746 struct service *serv;
1748 TAILQ_FOREACH(serv, &service_head, next)
1749 if (CFStringCompare(serv->serviceID, serviceID, 0) == kCFCompareEqualTo)
1750 return serv;
1758 struct service *serv;
1760 TAILQ_FOREACH(serv, &service_head, next) {
1761 switch (serv->type) {
1763 if (ppp_is_pid(serv, pid))
1764 return serv;
1777 struct service *serv;
1779 TAILQ_FOREACH(serv, &service_head, next)
1780 if (serv->sid && (strlen((char*)serv->sid) == len) && !strncmp((char*)serv->sid, (char*)data, len))
1781 return serv;
1788 u_int32_t makeref(struct service *serv)
1790 return (((u_int32_t)serv->subtype) << 16) + serv->unit;
1801 struct service *serv;
1803 TAILQ_FOREACH(serv, &service_head, next) {
1804 if ((type == serv->type)
1805 && (((serv->subtype == subtype) || (subtype == 0xFFFF))
1806 && ((serv->unit == unit) || (unit == 0xFFFF)))) {
1807 return serv;
1818 struct service *serv = TAILQ_FIRST(&service_head);
1821 while (serv) {
1822 if ((type == serv->type)
1823 && (subtype == serv->subtype)
1824 && (serv->unit == unit)) {
1828 serv = TAILQ_FIRST(&service_head); // restart
1831 serv = TAILQ_NEXT(serv, next); // continue
1842 struct service *serv;
1845 TAILQ_FOREACH(serv, &service_head, next) {
1846 switch (serv->type) {
1848 SCLog(TRUE, LOG_INFO, CFSTR("SCNC Controller: Service = %@, type = PPP, subtype = %@"), serv->serviceID, serv->subtypeRef);
1851 SCLog(TRUE, LOG_INFO, CFSTR("SCNC Controller: Service = %@, type = IPSec"), serv->serviceID);
1854 SCLog(TRUE, LOG_INFO, CFSTR("SCNC Controller: Service = %@, type = Unknown"), serv->serviceID);
1863 void phase_changed(struct service *serv, int phase)
1865 if (serv->ne_sm_bridge == NULL) {
1866 if (serv->flags & FLAG_SETUP_ONDEMAND)
1867 ondemand_add_service(serv, FALSE);
1869 client_notify(serv->serviceID, serv->sid, makeref(serv), phase, 0, CLIENT_FLAG_NOTIFY_STATUS, scnc_getstatus(serv));
1871 ne_sm_bridge_status_changed(serv->ne_sm_bridge);
1878 int start_profile_janitor(struct service *serv)
1886 if (serv->profileIdentifier == NULL)
1889 if (!CFStringGetCString(serv->profileIdentifier, payloadIdentifierStr, sizeof(payloadIdentifierStr), kCFStringEncodingUTF8))
1922 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC Controller: Started Profile Janitor for profile '%@'"), serv->profileIdentifier);
1924 SCLog(TRUE, LOG_ERR, CFSTR("SCNC Controller: Failed to start Profile Janitor for profile '%@'"), serv->profileIdentifier);
1943 struct service *serv;
1945 TAILQ_FOREACH(serv, &service_head, next) {
1946 if (serv->userNotificationRef == userNotification) {
1951 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), serv->userNotificationRLS, kCFRunLoopDefaultMode);
1952 my_CFRelease(&serv->userNotificationRef);
1953 my_CFRelease(&serv->userNotificationRLS);
1955 switch (serv->type) {
1956 case TYPE_PPP: ppp_user_notification_callback(serv, userNotification, responseFlags); break;
1957 case TYPE_IPSEC: ipsec_user_notification_callback(serv, userNotification, responseFlags); break;
2023 static Boolean ondemand_publish_dns_triggering_dicts (struct service *serv)
2025 if (serv->ondemandDNSTriggeringDicts
2026 && !serv->ondemandDNSTriggeringDictsArePublished
2027 && SCDynamicStoreSetMultiple(gDynamicStore, serv->ondemandDNSTriggeringDicts, NULL, NULL)) {
2028 serv->ondemandDNSTriggeringDictsArePublished = TRUE;
2031 return serv->ondemandDNSTriggeringDictsArePublished;
2034 Boolean ondemand_unpublish_dns_triggering_dicts (struct service *serv)
2040 if (serv->ondemandDNSTriggeringDicts == NULL || !serv->ondemandDNSTriggeringDictsArePublished)
2043 count = CFDictionaryGetCount(serv->ondemandDNSTriggeringDicts);
2051 CFDictionaryGetKeysAndValues(serv->ondemandDNSTriggeringDicts, (const void**)keys, NULL);
2058 serv->ondemandDNSTriggeringDictsArePublished = FALSE;
2067 return !serv->ondemandDNSTriggeringDictsArePublished;
2072 int ondemand_add_service(struct service *serv, Boolean update_configuration)
2082 if (!(serv->flags & FLAG_SETUP_ONDEMAND)) {
2090 service_status = scnc_getstatus(serv);
2094 ondemand_unpublish_dns_triggering_dicts(serv);
2096 ondemand_publish_dns_triggering_dicts(serv);
2116 if (CFStringCompare(serviceid, serv->serviceID, 0) == kCFCompareEqualTo) {
2159 if (serv->ondemandAction) {
2160 CFDictionarySetValue(new_trigger_dict, kSCPropNetVPNOnDemandRuleAction, serv->ondemandAction);
2166 if (serv->ondemandActionParameters) {
2167 CFDictionarySetValue(new_trigger_dict, kSCPropNetVPNOnDemandRuleActionParameters, serv->ondemandActionParameters);
2173 if (serv->ondemandProbeResults) {
2174 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandProbeResults, serv->ondemandProbeResults);
2180 if (serv->dnsRedirectDetected) {
2182 if (isA_CFDictionary(serv->dnsRedirectedAddresses)) {
2183 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandDNSRedirectedAddresses, serv->dnsRedirectedAddresses);
2191 if (serv->routeCache) {
2192 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandTunneledNetworks, serv->routeCache);
2198 num = CFNumberCreate(NULL, kCFNumberIntType, &serv->remote_address_reach_flags);
2205 num = CFNumberCreate(NULL, kCFNumberIntType, &serv->remote_address_reach_ifindex);
2211 if (serv->type == TYPE_VPN) {
2212 int numPlugins = serv->u.vpn.numPlugins;
2218 uint32_t pid = serv->u.vpn.plugin[i].pid;
2219 if (serv->u.vpn.plugin[i].state == VPN_PLUGIN_STATE_NONE || pid <= 0) {
2242 num = CFNumberCreate(NULL, kCFNumberIntType, &serv->ondemand_paused);
2248 num = flow_divert_copy_service_identifier(serv);
2260 switch (serv->type) {
2262 ppp_ondemand_add_service_data(serv, new_trigger_dict);
2265 ipsec_ondemand_add_service_data(serv, new_trigger_dict);
2270 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandServiceID, serv->serviceID);
2273 struct service *serv;
2274 TAILQ_FOREACH(serv, &service_head, next) {
2275 if (!(serv->flags & FLAG_FREE)) {
2276 serv->flags |= FLAG_SETUP;
2333 int ondemand_remove_service(struct service *serv)
2346 ondemand_unpublish_dns_triggering_dicts(serv);
2366 if (CFStringCompare(serviceid, serv->serviceID, 0) == kCFCompareEqualTo) {
2418 void disable_ondemand(struct service *serv)
2420 if (serv->flags & FLAG_SETUP_ONDEMAND) {
2421 serv->flags &= ~FLAG_SETUP_ONDEMAND;
2422 ondemand_remove_service(serv);
2434 void cellular_event(struct service *serv, int event)
2436 switch (serv->type) {
2437 case TYPE_IPSEC: ipsec_cellular_event(serv, event); break;
2444 struct service *serv = info;
2446 my_CFRelease(&serv->cellular_timerref);
2447 cellular_event(serv, CELLULAR_BRINGUP_SUCCESS_EVENT);
2453 struct service *serv = (struct service *)info;
2455 CFRunLoopTimerContext timer_ctxt = { 0, serv, NULL, NULL, NULL };
2464 my_CFRelease(&serv->cellularConnection);
2466 serv->cellular_timerref = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + TIMEOUT_EDGE, FAR_FUTURE, 0, 0, cellular_timer, &timer_ctxt);
2467 if (!serv->cellular_timerref) {
2469 cellular_event(serv, CELLULAR_BRINGUP_FATAL_FAILURE_EVENT);
2472 CFRunLoopAddTimer(CFRunLoopGetCurrent(), serv->cellular_timerref, kCFRunLoopCommonModes);
2478 cellular_event(serv, CELLULAR_BRINGUP_NETWORK_FAILURE_EVENT);
2494 int bringup_cellular(struct service *serv)
2496 _CTServerConnectionContext ctxt = { 0, serv, NULL, NULL, NULL };
2497 CFMachPortContext mach_ctxt = { 0, serv, NULL, NULL, NULL };
2498 CFRunLoopTimerContext timer_ctxt = { 0, serv, NULL, NULL, NULL };
2503 serv->cellularConnection = _CTServerConnectionCreate(kCFAllocatorDefault, cellular_callback, &ctxt);
2504 if (!serv->cellularConnection)
2507 error = _CTServerConnectionGetPacketContextActive(serv->cellularConnection, 0, &active);
2515 my_CFRelease(&serv->cellularConnection);
2516 serv->cellular_timerref = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + TIMEOUT_EDGE, FAR_FUTURE, 0, 0, cellular_timer, &timer_ctxt);
2517 if (!serv->cellular_timerref) {
2521 CFRunLoopAddTimer(CFRunLoopGetCurrent(), serv->cellular_timerref, kCFRunLoopCommonModes);
2525 error = _CTServerConnectionRegisterForNotification(serv->cellularConnection, kCTRegistrationDataStatusChangedNotification);
2527 error = _CTServerConnectionRegisterForNotification(serv->cellularConnection, kCTRegistrationDataActivateFailedNotification);
2529 error = _CTServerConnectionSetPacketContextActiveByServiceType(serv->cellularConnection, kCTDataConnectionServiceTypeInternet, TRUE);
2533 _CTServerConnectionAddToRunLoop(serv->cellularConnection, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
2539 my_CFRelease(&serv->cellularConnection);
2595 int add_client(struct service *serv, void *client, int autoclose)
2605 TAILQ_INSERT_TAIL(&serv->client_head, servclient, next);
2612 int remove_client(struct service *serv, void *client)
2616 TAILQ_FOREACH(servclient, &serv->client_head, next) {
2618 TAILQ_REMOVE(&serv->client_head, servclient, next);
2630 struct service_client *get_client(struct service *serv, void *client)
2634 TAILQ_FOREACH(servclient, &serv->client_head, next)
2644 int remove_all_clients(struct service *serv)
2648 while ((servclient = TAILQ_FIRST(&serv->client_head))) {
2649 TAILQ_REMOVE(&serv->client_head, servclient, next);
2656 get_plugin_pid_str (struct service *serv, int pid, char *pid_buf, int pid_buf_len)
2674 log_scnc_stop (struct service *serv, pid_t pid, int scnc_reason)
2688 p = get_plugin_pid_str(serv, pid, pid_buf, sizeof(pid_buf));
2690 if (serv->type == TYPE_IPSEC) {
2691 const char *status_str = ipsec_error_to_string(serv->u.ipsec.laststatus);
2694 } else if (serv->u.ipsec.laststatus) {
2696 scnc_reason_str, serv->u.ipsec.laststatus);
2700 } else if (serv->type == TYPE_PPP) {
2701 const char *status_str = ppp_error_to_string(serv->u.ppp.laststatus);
2702 const char *dev_status_str = ppp_dev_error_to_string(serv->subtype, serv->u.ppp.lastdevstatus);
2704 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %s.%s"), p, serv->subtypeRef,
2709 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %s.(%d)"), p, serv->subtypeRef,
2712 serv->u.ppp.lastdevstatus);
2714 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status (%d).%s"), p, serv->subtypeRef,
2716 serv->u.ppp.laststatus,
2718 } else if (serv->u.ppp.laststatus || serv->u.ppp.lastdevstatus) {
2719 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status (%d.%d)"), p, serv->subtypeRef,
2721 serv->u.ppp.laststatus,
2722 serv->u.ppp.lastdevstatus);
2724 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s"), p, serv->subtypeRef, scnc_reason_str);
2726 } else if (serv->type == TYPE_VPN) {
2727 const char *status_str = vpn_error_to_string(serv->u.vpn.laststatus);
2729 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %s"), p, serv->subtypeRef, scnc_reason_str, status_str);
2730 } else if (serv->u.vpn.laststatus) {
2731 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %d"), p, serv->subtypeRef,
2732 scnc_reason_str, serv->u.vpn.laststatus);
2734 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s"), p, serv->subtypeRef, scnc_reason_str);
2737 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status Unknown"), p, serv->subtypeRef, scnc_reason_str);
2742 log_scnc_start (struct service *serv, int onDemand, CFStringRef onDemandHostName, int pid, int status, int trafficClass)
2745 char *p = get_plugin_pid_str(serv, pid, pid_buf, sizeof(pid_buf));
2748 if (serv->type == TYPE_IPSEC) {
2758 serv->subtypeRef,
2764 if (serv->type == TYPE_IPSEC) {
2773 serv->subtypeRef,
2781 get_metric_protocol (struct service *serv)
2783 switch (serv->type) {
2785 switch (serv->subtype) {
2806 static void log_vpn_metrics (struct service *serv)
2811 if (!serv)
2814 if (!serv->establishtime) {
2821 vpn_metric_protocol_t protocol = get_metric_protocol(serv);
2836 int scnc_stop(struct service *serv, void *client, int signal, int scnc_reason)
2844 if (get_client(serv, client))
2845 remove_client(serv, client);
2848 if (TAILQ_FIRST(&serv->client_head))
2852 remove_all_clients(serv);
2855 log_scnc_stop(serv, pid, scnc_reason);
2856 log_vpn_metrics(serv);
2858 switch (serv->type) {
2859 case TYPE_PPP: ret = ppp_stop(serv, signal); break;
2860 case TYPE_IPSEC: ret = ipsec_stop(serv, signal); break;
2872 static tc_behavior scnc_evaluate_traffic_class (struct service *serv, uint32_t trafficClass)
2891 void scnc_bootstrap_dealloc(struct service *serv)
2893 if (serv->bootstrap != MACH_PORT_NULL) {
2894 mach_port_deallocate(mach_task_self(), serv->bootstrap);
2895 serv->bootstrap = MACH_PORT_NULL;
2899 void scnc_bootstrap_retain(struct service *serv, mach_port_t bootstrap)
2901 if (serv->bootstrap != bootstrap) {
2902 if (serv->bootstrap != MACH_PORT_NULL)
2903 mach_port_deallocate(mach_task_self(), serv->bootstrap);
2906 serv->bootstrap = bootstrap;
2910 void scnc_ausession_dealloc(struct service *serv)
2912 if (serv->au_session != MACH_PORT_NULL) {
2913 mach_port_deallocate(mach_task_self(), serv->au_session);
2914 serv->au_session = MACH_PORT_NULL;
2918 void scnc_ausession_retain(struct service *serv, mach_port_t au_session)
2920 if (serv->au_session != au_session) {
2921 if (serv->au_session != MACH_PORT_NULL)
2922 mach_port_deallocate(mach_task_self(), serv->au_session);
2925 serv->au_session = au_session;
2931 int scnc_start(struct service *serv, CFDictionaryRef options, void *client, int autoclose, uid_t uid, gid_t gid, int pid, mach_port_t bootstrap, mach_port_t au_session)
2945 tc_behavior behavior = scnc_evaluate_traffic_class(serv, trafficClass);
2947 (serv->ondemand_paused == ONDEMAND_PAUSE_STATE_TYPE_UNTIL_REBOOT) ||
2948 ((behavior == tc_behavior_normal) && (serv->ondemand_paused != ONDEMAND_PAUSE_STATE_TYPE_OFF))) {
3003 if (serv->flags & FLAG_FIRSTDIAL) {
3037 (gSleeping && (serv->flags & FLAG_SETUP_DISCONNECTONSLEEP)))
3040 serv->persist_connect = 0;
3041 serv->persist_connect_status = 0;
3042 serv->persist_connect_devstatus = 0;
3045 ondemand_set_pause(serv, ONDEMAND_PAUSE_STATE_TYPE_OFF, FALSE);
3047 switch (serv->type) {
3048 case TYPE_PPP: ret = ppp_start(serv, options, uid, gid, bootstrap, au_session, 0, onDemand); break;
3049 case TYPE_IPSEC: ret = ipsec_start(serv, options, uid, gid, bootstrap, 0, onDemand); break;
3052 log_scnc_start(serv, onDemand, onDemandHostName, pid, ret, trafficClass);
3056 serv->flags &= ~FLAG_FIRSTDIAL;
3059 add_client(serv, client, autoclose);
3067 int scnc_suspend(struct service *serv)
3071 switch (serv->type) {
3072 case TYPE_PPP: ret = ppp_suspend(serv); break;
3081 int scnc_resume(struct service *serv)
3085 switch (serv->type) {
3086 case TYPE_PPP: ret = ppp_resume(serv); break;
3095 int scnc_getstatus(struct service *serv)
3099 switch (serv->type) {
3100 case TYPE_PPP: status = ppp_getstatus(serv); break;
3101 case TYPE_IPSEC: status = ipsec_getstatus(serv); break;
3109 int scnc_copyextendedstatus(struct service *serv, void **reply, u_int16_t *replylen)
3118 switch (serv->type) {
3119 case TYPE_PPP: error = ppp_copyextendedstatus(serv, &statusdict); break;
3120 case TYPE_IPSEC: error = ipsec_copyextendedstatus(serv, &statusdict); break;
3152 scnc_log(LOG_NOTICE, CFSTR("Copy extended status for %@ failed: %s"), serv->serviceID, strerror(error));
3160 int scnc_copystatistics(struct service *serv, void **reply, u_int16_t *replylen)
3169 switch (serv->type) {
3170 case TYPE_PPP: error = ppp_copystatistics(serv, &statsdict); break;
3171 case TYPE_IPSEC: error = ipsec_copystatistics(serv, &statsdict); break;
3203 scnc_log(LOG_NOTICE, CFSTR("Copy statistics for %@ failed: %s"), serv->serviceID, strerror(error));
3211 int scnc_getconnectdata(struct service *serv, void **reply, u_int16_t *replylen, int all)
3220 switch (serv->type) {
3221 case TYPE_PPP: error = ppp_getconnectdata(serv, &options, all); break;
3222 case TYPE_IPSEC: error = ipsec_getconnectdata(serv, &options, all); break;
3257 int scnc_getconnectsystemdata(struct service *serv, void **reply, u_int16_t *replylen)
3261 switch (serv->type) {
3262 case TYPE_PPP: ret = ppp_getconnectsystemdata(serv, reply, replylen); break;
3263 case TYPE_IPSEC: /* ret = ipsec_getconnectsystemdata(serv, reply, replylen) */; break;
3270 double scnc_getsleepwaketimeout (struct service *serv)
3272 if (serv->sleepwaketimeout == 0)
3274 return (double)serv->sleepwaketimeout;
3278 void scnc_idle_disconnect (struct service *serv)
3280 switch (serv->type) {
3282 serv->u.ppp.laststatus = EXIT_IDLE_TIMEOUT;
3283 ppp_stop(serv, SIGTERM);
3286 serv->u.ipsec.laststatus = IPSEC_IDLETIMEOUT_ERROR;
3287 ipsec_stop(serv, SIGTERM);
3290 serv->u.vpn.laststatus = VPN_IDLETIMEOUT_ERROR;
3291 serv->u.vpn.disconnect_reason = kVPNValTunnelDisconnectReasonIdleTimeout;
3292 vpn_stop(serv);
3297 int scnc_disconnectifoverslept (const char *function, struct service *serv, char *if_name)
3300 if ((serv->flags & FLAG_SETUP_DISCONNECTONWAKE) &&
3307 scnc_idle_disconnect(serv);
3312 if ((serv->flags & FLAG_SETUP_DISCONNECTONWAKE) &&
3315 double timeout = scnc_getsleepwaketimeout(serv);
3321 serv->connectionslepttime += (u_int32_t)sleptFor;
3328 scnc_idle_disconnect(serv);
3342 void ondemand_set_pause(struct service *serv, uint32_t pauseFlag, Boolean update_store)
3350 if (!serv->flags & FLAG_SETUP_ONDEMAND) {
3351 SCLog(TRUE, LOG_DEBUG, CFSTR("SCNC Controller: ondemand_set_pause ignored for non-OnDemand service %@"), serv->serviceID);
3355 SCLog(TRUE, LOG_DEBUG, CFSTR("SCNC Controller: ondemand_set_pause %d service %@"), pauseFlag, serv->serviceID);
3357 serv->ondemand_paused = pauseFlag;
3360 clear_ondemand_pause_timer(serv);
3363 index = copy_trigger_info(serv, &new_ondemand_dict, &new_triggers_array, &new_trigger_dict);
3392 struct service *serv = info;
3397 my_CFRelease(&serv->ondemand_pause_timerref);
3400 ondemand_set_pause(serv, serv->ondemand_pause_type_on_timer_expire, TRUE);
3405 Boolean set_ondemand_pause_timer(struct service *serv, uint32_t timeout, uint32_t pause_type, uint32_t pause_type_on_expire)
3407 CFRunLoopTimerContext context = { 0, serv, NULL, NULL, NULL };
3411 ondemand_set_pause(serv, pause_type_on_expire, TRUE);
3418 if (serv->ondemand_paused != pause_type) {
3419 ondemand_set_pause(serv, pause_type, TRUE);
3427 clear_ondemand_pause_timer(serv);
3430 ondemand_set_pause(serv, pause_type, TRUE);
3432 serv->ondemand_pause_type_on_timer_expire = pause_type_on_expire;
3434 serv->ondemand_pause_timerref = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + timeout, 0, 0, 0, ondemand_pause_time_expire, &context);
3435 if (!serv->ondemand_pause_timerref) {
3438 ondemand_set_pause(serv, pause_type_on_expire, TRUE);
3442 CFRunLoopAddTimer(CFRunLoopGetCurrent(), serv->ondemand_pause_timerref, kCFRunLoopCommonModes);
3449 void clear_ondemand_pause_timer(struct service *serv)
3451 if (serv->ondemand_pause_timerref) {
3452 CFRunLoopTimerInvalidate(serv->ondemand_pause_timerref);
3453 my_CFRelease(&serv->ondemand_pause_timerref);
3460 struct service *serv;
3465 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
3466 if ((serv->flags & FLAG_SETUP_ONDEMAND) && (serv->ondemand_paused == type_to_clear)) {
3467 ondemand_set_pause(serv, ONDEMAND_PAUSE_STATE_TYPE_OFF, TRUE);