Lines Matching defs:serv
124 static int dispose_service(struct service *serv);
127 static int ondemand_remove_service(struct service *serv);
129 static int add_client(struct service *serv, void *client, int autoclose);
130 static int remove_client(struct service *serv, void *client);
131 static struct service_client *get_client(struct service *serv, void *client);
132 static int remove_all_clients(struct service *serv);
208 struct service *serv;
212 TAILQ_FOREACH(serv, &service_head, next) {
213 scnc_stop(serv, 0, SIGTERM, SCNC_STOP_TERM_ALL);
296 struct service *serv;
302 TAILQ_FOREACH(serv, &service_head, next) {
303 switch (serv->type) {
304 case TYPE_PPP: status = ppp_getstatus(serv); break;
305 case TYPE_IPSEC: status = ipsec_getstatus(serv); break;
324 int allow_dispose(struct service *serv)
326 if (serv->flags & FLAG_FREE) {
327 dispose_service(serv);
495 ^(struct service *serv) {
496 if (serv->flags & FLAG_SETUP_ONDEMAND) {
497 ondemand_add_service(serv, FALSE);
838 struct service *serv = NULL;
961 TAILQ_FOREACH(serv, &service_head, next){
962 if (serv->flags & FLAG_SETUP_NETWORKDETECTION) {
964 my_CFEqual(serv->serviceID, primaryServiceID)) || /* If we are the primary service and NWI order changed OR */
967 (newGlobalDNS != serv->ondemandSavedDns) && /* different from last stored */
968 (((newGlobalDNS == NULL) || (serv->ondemandSavedDns == NULL)) ||
969 (!CFEqual(newGlobalDNS, serv->ondemandSavedDns))))) {
971 if (serv->ondemand_paused == ONDEMAND_PAUSE_STATE_TYPE_UNTIL_NETCHANGE) {
972 ondemand_set_pause(serv, ONDEMAND_PAUSE_STATE_TYPE_OFF, FALSE);
975 check_network(serv); /* Network has changed */
978 if (serv->type == TYPE_IPSEC &&
979 scnc_getstatus(serv) != kSCNetworkConnectionDisconnected &&
980 serv->u.ipsec.lower_interface_cellular) {
982 if (my_CFEqual(serv->serviceID, primaryServiceID)) {
986 primaryInterface = copy_primary_interface_name(serv->serviceID);
993 scnc_stop(serv, 0, SIGTERM, SCNC_STOP_NONE);
1000 my_CFRelease(&serv->ondemandSavedDns);
1003 serv->ondemandSavedDns = newGlobalDNS;
1085 struct service *serv;
1088 TAILQ_FOREACH(serv, &service_head, next) {
1090 switch (serv->type) {
1091 case TYPE_PPP: prevent = !ppp_can_sleep(serv); break;
1092 case TYPE_IPSEC: prevent = !ipsec_can_sleep(serv); break;
1110 struct service *serv;
1112 TAILQ_FOREACH(serv, &service_head, next) {
1114 serv->flags &= ~FLAG_DARKWAKE;
1116 switch (serv->type) {
1117 case TYPE_PPP: ret |= ppp_will_sleep(serv, checking); break;
1118 case TYPE_IPSEC: ret |= ipsec_will_sleep(serv, checking); break;
1131 struct service *serv;
1133 TAILQ_FOREACH(serv, &service_head, next) {
1134 serv->flags |= FLAG_FIRSTDIAL;
1137 serv->flags |= FLAG_DARKWAKE;
1139 serv->flags &= ~FLAG_DARKWAKE;
1141 switch (serv->type) {
1142 case TYPE_PPP: if (isFullWake) ppp_wake_up(serv); break;
1143 case TYPE_IPSEC: if (isFullWake) ipsec_wake_up(serv); break;
1186 struct service *serv;
1189 TAILQ_FOREACH(serv, &service_head, next) {
1190 serv->flags &= ~FLAG_DARKWAKE;
1198 void service_started(struct service *serv)
1200 switch (serv->type) {
1204 serv->vt = vproc_transaction_begin(NULL);
1205 if ( serv->vt == NULL)
1217 service_ending_verify_primaryservice(struct service *serv)
1225 if (serv->type == TYPE_PPP &&
1226 (serv->subtype == PPP_TYPE_PPPoE ||
1227 serv->subtype == PPP_TYPE_SERIAL ||
1228 serv->subtype == PPP_TYPE_SYNCSERIAL)) {
1234 _SC_CFEqual(serv->serviceID, newPrimary)) { // primary is still our service
1253 void service_ended(struct service *serv)
1258 if (serv->cellular_timerref) {
1259 CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), serv->cellular_timerref, kCFRunLoopCommonModes);
1260 my_CFRelease(&serv->cellular_timerref);
1263 my_CFRelease(&serv->cellularConnection);
1267 service_ending_verify_primaryservice(serv);
1268 switch (serv->type) {
1272 if ( serv->vt)
1273 vproc_transaction_end(NULL, serv->vt);
1289 struct service *serv;
1291 TAILQ_FOREACH(serv, &service_head, next) {
1292 switch (serv->type) {
1293 case TYPE_PPP: ppp_log_out(serv); break;
1294 case TYPE_IPSEC: ipsec_log_out(serv); break;
1305 struct service *serv;
1307 TAILQ_FOREACH(serv, &service_head, next) {
1308 serv->flags |= FLAG_FIRSTDIAL;
1309 switch (serv->type) {
1310 case TYPE_PPP: ppp_log_in(serv); break;
1311 case TYPE_IPSEC: ipsec_log_in(serv); break;
1322 struct service *serv;
1324 TAILQ_FOREACH(serv, &service_head, next) {
1325 serv->flags |= FLAG_FIRSTDIAL;
1326 switch (serv->type) {
1327 case TYPE_PPP: ppp_log_switch(serv); break;
1328 case TYPE_IPSEC: ipsec_log_switch(serv); break;
1341 struct service *serv;
1348 TAILQ_FOREACH(serv, &service_head, next) {
1349 serv->flags |= FLAG_FIRSTDIAL;
1350 switch (serv->type) {
1351 case TYPE_PPP: ppp_ipv4_state_changed(serv); break;
1352 case TYPE_IPSEC: ipsec_ipv4_state_changed(serv); break;
1357 _SC_CFEqual(serv->serviceID, newPrimary)) {
1384 struct service *serv;
1386 serv = findbyserviceID(serviceID);
1392 if (!interface || (serv && !my_CFEqual(iftype, serv->typeRef))) {
1394 if (serv) {
1396 dispose_service(serv);
1406 if (serv && !my_CFEqual(subtype, serv->subtypeRef)) {
1408 dispose_service(serv);
1409 serv = 0;
1414 if (!serv) {
1415 serv = new_service(serviceID, iftype, subtype);
1416 if (!serv)
1421 serv->flags |= FLAG_SETUP;
1436 struct service *serv = 0;
1440 serv = malloc(sizeof(struct service));
1441 if (!serv)
1444 bzero(serv, sizeof(struct service));
1446 serv->serviceID = my_CFRetain(serviceID);
1447 serv->typeRef = my_CFRetain(typeRef);
1448 serv->subtypeRef = my_CFRetain(subtypeRef);
1452 if ((serv->sid = malloc(len))) {
1453 CFStringGetCString(serviceID, (char*)serv->sid, len, kCFStringEncodingUTF8);
1458 serv->type = TYPE_PPP;
1459 serv->subtype = ppp_subtype(subtypeRef);
1462 serv->type = TYPE_IPSEC;
1463 serv->subtype = ipsec_subtype(subtypeRef);
1468 serv->unit = findfreeunit(serv->type, serv->subtype);
1469 if (serv->unit == 0xFFFF)
1472 switch (serv->type) {
1473 case TYPE_PPP: err = ppp_new_service(serv); break;
1474 case TYPE_IPSEC: err = ipsec_new_service(serv); break;
1479 serv->uid = 0;
1480 serv->flags |= FLAG_FIRSTDIAL;
1482 TAILQ_INIT(&serv->client_head);
1484 TAILQ_INSERT_TAIL(&service_head, serv, next);
1486 client_notify(serv->serviceID, serv->sid, makeref(serv), 0, 0, CLIENT_FLAG_NOTIFY_STATUS, kSCNetworkConnectionDisconnected);
1488 return serv;
1491 if (serv) {
1492 my_CFRelease(&serv->serviceID);
1493 my_CFRelease(&serv->typeRef);
1494 my_CFRelease(&serv->subtypeRef);
1495 if (serv->sid)
1496 free(serv->sid);
1498 free(serv);
1508 int dispose_service(struct service *serv)
1513 scnc_stop(serv, 0, SIGTERM, SCNC_STOP_SERV_DISPOSE);
1515 switch (serv->type) {
1516 case TYPE_PPP: delay = ppp_dispose_service(serv); break;
1517 case TYPE_IPSEC: delay = ipsec_dispose_service(serv); break;
1520 serv->flags |= FLAG_FREE;
1523 serv->flags &= ~FLAG_FREE;
1528 my_CFRelease(&serv->profileIdentifier);
1531 if (serv->flags & FLAG_SETUP_ONDEMAND) {
1532 serv->flags &= ~FLAG_SETUP_ONDEMAND;
1533 ondemand_remove_service(serv);
1536 TAILQ_REMOVE(&service_head, serv, next);
1538 reachability_clear(serv);
1540 client_notify(serv->serviceID, serv->sid, makeref(serv), 0, 0, CLIENT_FLAG_NOTIFY_STATUS, kSCNetworkConnectionInvalid);
1543 if (serv->sid)
1544 free(serv->sid);
1546 if (serv->userNotificationRef) {
1547 CFUserNotificationCancel(serv->userNotificationRef);
1548 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), serv->userNotificationRLS, kCFRunLoopDefaultMode);
1549 my_CFRelease(&serv->userNotificationRef);
1550 my_CFRelease(&serv->userNotificationRLS);
1553 scnc_bootstrap_dealloc(serv);
1554 scnc_ausession_dealloc(serv);
1556 my_CFRelease(&serv->serviceID);
1557 my_CFRelease(&serv->subtypeRef);
1558 my_CFRelease(&serv->authSubtypeRef);
1559 my_CFRelease(&serv->typeRef);
1560 my_CFRelease(&serv->environmentVars);
1561 my_CFRelease(&serv->ondemandAction);
1562 my_CFRelease(&serv->ondemandActionParameters);
1563 my_CFRelease(&serv->ondemandProbeResults);
1564 my_CFRelease(&serv->ondemandDNSTriggeringDicts);
1565 my_CFRelease(&serv->ondemandSavedDns);
1566 my_CFRelease(&serv->dnsRedirectedAddresses);
1567 my_CFRelease(&serv->routeCache);
1568 free(serv);
1579 struct service *serv;
1587 if ((serv = findbyserviceID(serviceID))) {
1589 TAILQ_REMOVE(&service_head, serv, next);
1590 TAILQ_INSERT_TAIL(&service_head, serv, next);
1601 struct service *serv;
1609 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
1610 if (serv->serviceID) {
1611 CFArrayAppendValue(service_array, serv->serviceID);
1645 struct service *serv;
1657 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
1658 if (serv->flags & FLAG_SETUP) {
1660 serv->flags &= ~(FLAG_FREE + FLAG_SETUP);
1662 if (serv->flags & FLAG_SETUP_ONDEMAND) {
1663 serv->flags &= ~FLAG_SETUP_ONDEMAND;
1664 ondemand_remove_service(serv);
1667 switch (serv->type) {
1668 case TYPE_PPP: setup_result = ppp_setup_service(serv); break;
1669 case TYPE_IPSEC: setup_result = ipsec_setup_service(serv); break;
1673 serv->initialized = FALSE;
1676 serv->initialized = TRUE;
1679 my_CFRelease(&serv->profileIdentifier);
1680 CFDictionaryRef payloadRoot = copyEntity(gDynamicStore, kSCDynamicStoreDomainSetup, serv->serviceID, CFSTR("com.apple.payload/PayloadRoot"));
1682 serv->profileIdentifier = CFDictionaryGetValue(payloadRoot, CFSTR("PayloadIdentifier"));
1683 serv->profileIdentifier = isA_CFString(serv->profileIdentifier);
1684 if (serv->profileIdentifier)
1685 CFRetain(serv->profileIdentifier);
1690 if (serv->flags & FLAG_SETUP_ONDEMAND){
1691 scnc_cache_init_service(serv);
1692 reachability_reset(serv);
1693 ondemand_add_service(serv, TRUE);
1696 reachability_clear(serv);
1699 if (dochecknetwork && (serv->flags & FLAG_SETUP_NETWORKDETECTION)) {
1700 check_network(serv);
1717 struct service *serv;
1722 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
1723 if (serv->flags & FLAG_SETUP_NETWORKDETECTION){
1724 check_network(serv);
1733 struct service *serv;
1735 TAILQ_FOREACH(serv, &service_head, next)
1736 if (CFStringCompare(serv->serviceID, serviceID, 0) == kCFCompareEqualTo)
1737 return serv;
1745 struct service *serv;
1747 TAILQ_FOREACH(serv, &service_head, next) {
1748 switch (serv->type) {
1750 if (ppp_is_pid(serv, pid))
1751 return serv;
1764 struct service *serv;
1766 TAILQ_FOREACH(serv, &service_head, next)
1767 if (serv->sid && (strlen((char*)serv->sid) == len) && !strncmp((char*)serv->sid, (char*)data, len))
1768 return serv;
1775 u_int32_t makeref(struct service *serv)
1777 return (((u_int32_t)serv->subtype) << 16) + serv->unit;
1788 struct service *serv;
1790 TAILQ_FOREACH(serv, &service_head, next) {
1791 if ((type == serv->type)
1792 && (((serv->subtype == subtype) || (subtype == 0xFFFF))
1793 && ((serv->unit == unit) || (unit == 0xFFFF)))) {
1794 return serv;
1806 struct service *serv = TAILQ_FIRST(&service_head);
1809 while (serv) {
1810 if ((type == serv->type)
1811 && (subtype == serv->subtype)
1812 && (serv->unit == unit)) {
1816 serv = TAILQ_FIRST(&service_head); // restart
1819 serv = TAILQ_NEXT(serv, next); // continue
1830 struct service *serv;
1833 TAILQ_FOREACH(serv, &service_head, next) {
1834 switch (serv->type) {
1836 SCLog(TRUE, LOG_INFO, CFSTR("SCNC Controller: Service = %@, type = PPP, subtype = %@"), serv->serviceID, serv->subtypeRef);
1839 SCLog(TRUE, LOG_INFO, CFSTR("SCNC Controller: Service = %@, type = IPSec"), serv->serviceID);
1842 SCLog(TRUE, LOG_INFO, CFSTR("SCNC Controller: Service = %@, type = Unknown"), serv->serviceID);
1851 void phase_changed(struct service *serv, int phase)
1854 if (serv->flags & FLAG_SETUP_ONDEMAND)
1855 ondemand_add_service(serv, FALSE);
1857 client_notify(serv->serviceID, serv->sid, makeref(serv), phase, 0, CLIENT_FLAG_NOTIFY_STATUS, scnc_getstatus(serv));
1863 int start_profile_janitor(struct service *serv)
1871 if (serv->profileIdentifier == NULL)
1874 if (!CFStringGetCString(serv->profileIdentifier, payloadIdentifierStr, sizeof(payloadIdentifierStr), kCFStringEncodingUTF8))
1907 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC Controller: Started Profile Janitor for profile '%@'"), serv->profileIdentifier);
1909 SCLog(TRUE, LOG_ERR, CFSTR("SCNC Controller: Failed to start Profile Janitor for profile '%@'"), serv->profileIdentifier);
1928 struct service *serv;
1930 TAILQ_FOREACH(serv, &service_head, next) {
1931 if (serv->userNotificationRef == userNotification) {
1936 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), serv->userNotificationRLS, kCFRunLoopDefaultMode);
1937 my_CFRelease(&serv->userNotificationRef);
1938 my_CFRelease(&serv->userNotificationRLS);
1940 switch (serv->type) {
1941 case TYPE_PPP: ppp_user_notification_callback(serv, userNotification, responseFlags); break;
1942 case TYPE_IPSEC: ipsec_user_notification_callback(serv, userNotification, responseFlags); break;
2006 static Boolean ondemand_publish_dns_triggering_dicts (struct service *serv)
2008 if (serv->ondemandDNSTriggeringDicts
2009 && !serv->ondemandDNSTriggeringDictsArePublished
2010 && SCDynamicStoreSetMultiple(gDynamicStore, serv->ondemandDNSTriggeringDicts, NULL, NULL)) {
2011 serv->ondemandDNSTriggeringDictsArePublished = TRUE;
2014 return serv->ondemandDNSTriggeringDictsArePublished;
2017 Boolean ondemand_unpublish_dns_triggering_dicts (struct service *serv)
2023 if (serv->ondemandDNSTriggeringDicts == NULL || !serv->ondemandDNSTriggeringDictsArePublished)
2026 count = CFDictionaryGetCount(serv->ondemandDNSTriggeringDicts);
2034 CFDictionaryGetKeysAndValues(serv->ondemandDNSTriggeringDicts, (const void**)keys, NULL);
2041 serv->ondemandDNSTriggeringDictsArePublished = FALSE;
2050 return !serv->ondemandDNSTriggeringDictsArePublished;
2055 int ondemand_add_service(struct service *serv, Boolean update_configuration)
2065 if (!(serv->flags & FLAG_SETUP_ONDEMAND)) {
2073 service_status = scnc_getstatus(serv);
2077 ondemand_unpublish_dns_triggering_dicts(serv);
2079 ondemand_publish_dns_triggering_dicts(serv);
2099 if (CFStringCompare(serviceid, serv->serviceID, 0) == kCFCompareEqualTo) {
2142 if (serv->ondemandAction) {
2143 CFDictionarySetValue(new_trigger_dict, kSCPropNetVPNOnDemandRuleAction, serv->ondemandAction);
2149 if (serv->ondemandActionParameters) {
2150 CFDictionarySetValue(new_trigger_dict, kSCPropNetVPNOnDemandRuleActionParameters, serv->ondemandActionParameters);
2156 if (serv->ondemandProbeResults) {
2157 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandProbeResults, serv->ondemandProbeResults);
2163 if (serv->dnsRedirectDetected) {
2165 if (isA_CFDictionary(serv->dnsRedirectedAddresses)) {
2166 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandDNSRedirectedAddresses, serv->dnsRedirectedAddresses);
2174 if (serv->routeCache) {
2175 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandTunneledNetworks, serv->routeCache);
2181 num = CFNumberCreate(NULL, kCFNumberIntType, &serv->remote_address_reach_flags);
2188 num = CFNumberCreate(NULL, kCFNumberIntType, &serv->remote_address_reach_ifindex);
2194 if (serv->type == TYPE_VPN) {
2195 int numPlugins = serv->u.vpn.numPlugins;
2201 uint32_t pid = serv->u.vpn.plugin[i].pid;
2202 if (serv->u.vpn.plugin[i].state == VPN_PLUGIN_STATE_NONE || pid <= 0) {
2225 num = CFNumberCreate(NULL, kCFNumberIntType, &serv->ondemand_paused);
2231 num = flow_divert_copy_service_identifier(serv);
2243 switch (serv->type) {
2245 ppp_ondemand_add_service_data(serv, new_trigger_dict);
2248 ipsec_ondemand_add_service_data(serv, new_trigger_dict);
2253 CFDictionarySetValue(new_trigger_dict, kSCNetworkConnectionOnDemandServiceID, serv->serviceID);
2256 struct service *serv;
2257 TAILQ_FOREACH(serv, &service_head, next) {
2258 if (!(serv->flags & FLAG_FREE)) {
2259 serv->flags |= FLAG_SETUP;
2316 int ondemand_remove_service(struct service *serv)
2329 ondemand_unpublish_dns_triggering_dicts(serv);
2349 if (CFStringCompare(serviceid, serv->serviceID, 0) == kCFCompareEqualTo) {
2401 void disable_ondemand(struct service *serv)
2403 if (serv->flags & FLAG_SETUP_ONDEMAND) {
2404 serv->flags &= ~FLAG_SETUP_ONDEMAND;
2405 ondemand_remove_service(serv);
2417 void cellular_event(struct service *serv, int event)
2419 switch (serv->type) {
2420 case TYPE_IPSEC: ipsec_cellular_event(serv, event); break;
2427 struct service *serv = info;
2429 my_CFRelease(&serv->cellular_timerref);
2430 cellular_event(serv, CELLULAR_BRINGUP_SUCCESS_EVENT);
2436 struct service *serv = (struct service *)info;
2438 CFRunLoopTimerContext timer_ctxt = { 0, serv, NULL, NULL, NULL };
2447 my_CFRelease(&serv->cellularConnection);
2449 serv->cellular_timerref = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + TIMEOUT_EDGE, FAR_FUTURE, 0, 0, cellular_timer, &timer_ctxt);
2450 if (!serv->cellular_timerref) {
2452 cellular_event(serv, CELLULAR_BRINGUP_FATAL_FAILURE_EVENT);
2455 CFRunLoopAddTimer(CFRunLoopGetCurrent(), serv->cellular_timerref, kCFRunLoopCommonModes);
2461 cellular_event(serv, CELLULAR_BRINGUP_NETWORK_FAILURE_EVENT);
2477 int bringup_cellular(struct service *serv)
2479 _CTServerConnectionContext ctxt = { 0, serv, NULL, NULL, NULL };
2480 CFMachPortContext mach_ctxt = { 0, serv, NULL, NULL, NULL };
2481 CFRunLoopTimerContext timer_ctxt = { 0, serv, NULL, NULL, NULL };
2486 serv->cellularConnection = _CTServerConnectionCreate(kCFAllocatorDefault, cellular_callback, &ctxt);
2487 if (!serv->cellularConnection)
2490 error = _CTServerConnectionGetPacketContextActive(serv->cellularConnection, 0, &active);
2498 my_CFRelease(&serv->cellularConnection);
2499 serv->cellular_timerref = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + TIMEOUT_EDGE, FAR_FUTURE, 0, 0, cellular_timer, &timer_ctxt);
2500 if (!serv->cellular_timerref) {
2504 CFRunLoopAddTimer(CFRunLoopGetCurrent(), serv->cellular_timerref, kCFRunLoopCommonModes);
2508 error = _CTServerConnectionRegisterForNotification(serv->cellularConnection, kCTRegistrationDataStatusChangedNotification);
2510 error = _CTServerConnectionRegisterForNotification(serv->cellularConnection, kCTRegistrationDataActivateFailedNotification);
2512 error = _CTServerConnectionSetPacketContextActiveByServiceType(serv->cellularConnection, kCTDataConnectionServiceTypeInternet, TRUE);
2516 _CTServerConnectionAddToRunLoop(serv->cellularConnection, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
2522 my_CFRelease(&serv->cellularConnection);
2578 int add_client(struct service *serv, void *client, int autoclose)
2588 TAILQ_INSERT_TAIL(&serv->client_head, servclient, next);
2595 int remove_client(struct service *serv, void *client)
2599 TAILQ_FOREACH(servclient, &serv->client_head, next) {
2601 TAILQ_REMOVE(&serv->client_head, servclient, next);
2613 struct service_client *get_client(struct service *serv, void *client)
2617 TAILQ_FOREACH(servclient, &serv->client_head, next)
2627 int remove_all_clients(struct service *serv)
2631 while ((servclient = TAILQ_FIRST(&serv->client_head))) {
2632 TAILQ_REMOVE(&serv->client_head, servclient, next);
2639 get_plugin_pid_str (struct service *serv, int pid, char *pid_buf, int pid_buf_len)
2657 log_scnc_stop (struct service *serv, pid_t pid, int scnc_reason)
2671 p = get_plugin_pid_str(serv, pid, pid_buf, sizeof(pid_buf));
2673 if (serv->type == TYPE_IPSEC) {
2674 const char *status_str = ipsec_error_to_string(serv->u.ipsec.laststatus);
2677 } else if (serv->u.ipsec.laststatus) {
2679 scnc_reason_str, serv->u.ipsec.laststatus);
2683 } else if (serv->type == TYPE_PPP) {
2684 const char *status_str = ppp_error_to_string(serv->u.ppp.laststatus);
2685 const char *dev_status_str = ppp_dev_error_to_string(serv->subtype, serv->u.ppp.lastdevstatus);
2687 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %s.%s"), p, serv->subtypeRef,
2692 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %s.(%d)"), p, serv->subtypeRef,
2695 serv->u.ppp.lastdevstatus);
2697 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status (%d).%s"), p, serv->subtypeRef,
2699 serv->u.ppp.laststatus,
2701 } else if (serv->u.ppp.laststatus || serv->u.ppp.lastdevstatus) {
2702 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status (%d.%d)"), p, serv->subtypeRef,
2704 serv->u.ppp.laststatus,
2705 serv->u.ppp.lastdevstatus);
2707 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s"), p, serv->subtypeRef, scnc_reason_str);
2709 } else if (serv->type == TYPE_VPN) {
2710 const char *status_str = vpn_error_to_string(serv->u.vpn.laststatus);
2712 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %s"), p, serv->subtypeRef, scnc_reason_str, status_str);
2713 } else if (serv->u.vpn.laststatus) {
2714 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status %d"), p, serv->subtypeRef,
2715 scnc_reason_str, serv->u.vpn.laststatus);
2717 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s"), p, serv->subtypeRef, scnc_reason_str);
2720 SCLog(TRUE, LOG_NOTICE, CFSTR("SCNC: stop%s, type %@, reason %s, status Unknown"), p, serv->subtypeRef, scnc_reason_str);
2725 log_scnc_start (struct service *serv, int onDemand, CFStringRef onDemandHostName, int pid, int status, int trafficClass)
2728 char *p = get_plugin_pid_str(serv, pid, pid_buf, sizeof(pid_buf));
2731 if (serv->type == TYPE_IPSEC) {
2741 serv->subtypeRef,
2747 if (serv->type == TYPE_IPSEC) {
2756 serv->subtypeRef,
2764 get_metric_protocol (struct service *serv)
2766 switch (serv->type) {
2768 switch (serv->subtype) {
2789 static void log_vpn_metrics (struct service *serv)
2794 if (!serv)
2797 if (!serv->establishtime) {
2804 vpn_metric_protocol_t protocol = get_metric_protocol(serv);
2819 int scnc_stop(struct service *serv, void *client, int signal, int scnc_reason)
2827 if (get_client(serv, client))
2828 remove_client(serv, client);
2831 if (TAILQ_FIRST(&serv->client_head))
2835 remove_all_clients(serv);
2838 log_scnc_stop(serv, pid, scnc_reason);
2839 log_vpn_metrics(serv);
2841 switch (serv->type) {
2842 case TYPE_PPP: ret = ppp_stop(serv, signal); break;
2843 case TYPE_IPSEC: ret = ipsec_stop(serv, signal); break;
2855 static tc_behavior scnc_evaluate_traffic_class (struct service *serv, uint32_t trafficClass)
2874 void scnc_bootstrap_dealloc(struct service *serv)
2876 if (serv->bootstrap != MACH_PORT_NULL) {
2877 mach_port_deallocate(mach_task_self(), serv->bootstrap);
2878 serv->bootstrap = MACH_PORT_NULL;
2882 void scnc_bootstrap_retain(struct service *serv, mach_port_t bootstrap)
2884 if (serv->bootstrap != bootstrap) {
2885 if (serv->bootstrap != MACH_PORT_NULL)
2886 mach_port_deallocate(mach_task_self(), serv->bootstrap);
2889 serv->bootstrap = bootstrap;
2893 void scnc_ausession_dealloc(struct service *serv)
2895 if (serv->au_session != MACH_PORT_NULL) {
2896 mach_port_deallocate(mach_task_self(), serv->au_session);
2897 serv->au_session = MACH_PORT_NULL;
2901 void scnc_ausession_retain(struct service *serv, mach_port_t au_session)
2903 if (serv->au_session != au_session) {
2904 if (serv->au_session != MACH_PORT_NULL)
2905 mach_port_deallocate(mach_task_self(), serv->au_session);
2908 serv->au_session = au_session;
2914 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)
2928 tc_behavior behavior = scnc_evaluate_traffic_class(serv, trafficClass);
2930 (serv->ondemand_paused == ONDEMAND_PAUSE_STATE_TYPE_UNTIL_REBOOT) ||
2931 ((behavior == tc_behavior_normal) && (serv->ondemand_paused != ONDEMAND_PAUSE_STATE_TYPE_OFF))) {
2986 if (serv->flags & FLAG_FIRSTDIAL) {
3020 (gSleeping && (serv->flags & FLAG_SETUP_DISCONNECTONSLEEP)))
3023 serv->persist_connect = 0;
3024 serv->persist_connect_status = 0;
3025 serv->persist_connect_devstatus = 0;
3028 ondemand_set_pause(serv, ONDEMAND_PAUSE_STATE_TYPE_OFF, FALSE);
3030 switch (serv->type) {
3031 case TYPE_PPP: ret = ppp_start(serv, options, uid, gid, bootstrap, au_session, 0, onDemand); break;
3032 case TYPE_IPSEC: ret = ipsec_start(serv, options, uid, gid, bootstrap, 0, onDemand); break;
3035 log_scnc_start(serv, onDemand, onDemandHostName, pid, ret, trafficClass);
3039 serv->flags &= ~FLAG_FIRSTDIAL;
3042 add_client(serv, client, autoclose);
3050 int scnc_suspend(struct service *serv)
3054 switch (serv->type) {
3055 case TYPE_PPP: ret = ppp_suspend(serv); break;
3064 int scnc_resume(struct service *serv)
3068 switch (serv->type) {
3069 case TYPE_PPP: ret = ppp_resume(serv); break;
3078 int scnc_getstatus(struct service *serv)
3082 switch (serv->type) {
3083 case TYPE_PPP: status = ppp_getstatus(serv); break;
3084 case TYPE_IPSEC: status = ipsec_getstatus(serv); break;
3092 int scnc_copyextendedstatus(struct service *serv, void **reply, u_int16_t *replylen)
3096 switch (serv->type) {
3097 case TYPE_PPP: ret = ppp_copyextendedstatus(serv, reply, replylen); break;
3098 case TYPE_IPSEC: ret = ipsec_copyextendedstatus(serv, reply, replylen); break;
3106 int scnc_copystatistics(struct service *serv, void **reply, u_int16_t *replylen)
3110 switch (serv->type) {
3111 case TYPE_PPP: ret = ppp_copystatistics(serv, reply, replylen); break;
3112 case TYPE_IPSEC: ret = ipsec_copystatistics(serv, reply, replylen); break;
3120 int scnc_getconnectdata(struct service *serv, void **reply, u_int16_t *replylen, int all)
3124 switch (serv->type) {
3125 case TYPE_PPP: ret = ppp_getconnectdata(serv, reply, replylen, all); break;
3126 case TYPE_IPSEC: ret = ipsec_getconnectdata(serv, reply, replylen, all); break;
3134 int scnc_getconnectsystemdata(struct service *serv, void **reply, u_int16_t *replylen)
3138 switch (serv->type) {
3139 case TYPE_PPP: ret = ppp_getconnectsystemdata(serv, reply, replylen); break;
3140 case TYPE_IPSEC: /* ret = ipsec_getconnectsystemdata(serv, reply, replylen) */; break;
3147 static double scnc_getsleepwaketimeout (struct service *serv)
3149 if (serv->sleepwaketimeout == 0)
3151 return (double)serv->sleepwaketimeout;
3155 static void scnc_idle_disconnect (struct service *serv)
3157 switch (serv->type) {
3159 serv->u.ppp.laststatus = EXIT_IDLE_TIMEOUT;
3160 ppp_stop(serv, SIGTERM);
3163 serv->u.ipsec.laststatus = IPSEC_IDLETIMEOUT_ERROR;
3164 ipsec_stop(serv, SIGTERM);
3167 serv->u.vpn.laststatus = VPN_IDLETIMEOUT_ERROR;
3168 serv->u.vpn.disconnect_reason = kVPNValTunnelDisconnectReasonIdleTimeout;
3169 vpn_stop(serv);
3175 int scnc_disconnectifoverslept (const char *function, struct service *serv, char *if_name)
3178 if ((serv->flags & FLAG_SETUP_DISCONNECTONWAKE) &&
3185 scnc_idle_disconnect(serv);
3189 if ((serv->flags & FLAG_SETUP_DISCONNECTONWAKE) &&
3192 double timeout = scnc_getsleepwaketimeout(serv);
3198 serv->connectionslepttime += (u_int32_t)sleptFor;
3205 scnc_idle_disconnect(serv);
3219 void ondemand_set_pause(struct service *serv, uint32_t pauseFlag, Boolean update_store)
3227 if (!serv->flags & FLAG_SETUP_ONDEMAND) {
3228 SCLog(TRUE, LOG_DEBUG, CFSTR("SCNC Controller: ondemand_set_pause ignored for non-OnDemand service %@"), serv->serviceID);
3232 SCLog(TRUE, LOG_DEBUG, CFSTR("SCNC Controller: ondemand_set_pause %d service %@"), pauseFlag, serv->serviceID);
3234 serv->ondemand_paused = pauseFlag;
3237 clear_ondemand_pause_timer(serv);
3240 index = copy_trigger_info(serv, &new_ondemand_dict, &new_triggers_array, &new_trigger_dict);
3269 struct service *serv = info;
3274 my_CFRelease(&serv->ondemand_pause_timerref);
3277 ondemand_set_pause(serv, serv->ondemand_pause_type_on_timer_expire, TRUE);
3282 Boolean set_ondemand_pause_timer(struct service *serv, uint32_t timeout, uint32_t pause_type, uint32_t pause_type_on_expire)
3284 CFRunLoopTimerContext context = { 0, serv, NULL, NULL, NULL };
3288 ondemand_set_pause(serv, pause_type_on_expire, TRUE);
3295 if (serv->ondemand_paused != pause_type) {
3296 ondemand_set_pause(serv, pause_type, TRUE);
3304 clear_ondemand_pause_timer(serv);
3307 ondemand_set_pause(serv, pause_type, TRUE);
3309 serv->ondemand_pause_type_on_timer_expire = pause_type_on_expire;
3311 serv->ondemand_pause_timerref = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() + timeout, 0, 0, 0, ondemand_pause_time_expire, &context);
3312 if (!serv->ondemand_pause_timerref) {
3315 ondemand_set_pause(serv, pause_type_on_expire, TRUE);
3319 CFRunLoopAddTimer(CFRunLoopGetCurrent(), serv->ondemand_pause_timerref, kCFRunLoopCommonModes);
3326 void clear_ondemand_pause_timer(struct service *serv)
3328 if (serv->ondemand_pause_timerref) {
3329 CFRunLoopTimerInvalidate(serv->ondemand_pause_timerref);
3330 my_CFRelease(&serv->ondemand_pause_timerref);
3337 struct service *serv;
3342 TAILQ_FOREACH_SAFE(serv, &service_head, next, serv_tmp) {
3343 if ((serv->flags & FLAG_SETUP_ONDEMAND) && (serv->ondemand_paused == type_to_clear)) {
3344 ondemand_set_pause(serv, ONDEMAND_PAUSE_STATE_TYPE_OFF, TRUE);