/* * Function: copy_configured_interface_names * * Purpose: * Return the BSD interface name of all configured interfaces. If * 'entity' is non-NULL, also check that the interface has the specified * extended configuration. */ STATIC CFArrayRef /* of CFStringRef */ copy_configured_interface_names(SCPreferencesRef prefs, CFStringRef entity_name) { SCNetworkSetRef current_set = NULL; int count; int i; CFMutableArrayRef ret_names = NULL; CFRange ret_names_range = { 0 , 0 }; CFArrayRef services = NULL; if (prefs == NULL) { goto done; } current_set = SCNetworkSetCopyCurrent(prefs); if (current_set == NULL) { goto done; } services = SCNetworkSetCopyServices(current_set); if (services == NULL) { goto done; } count = CFArrayGetCount(services); for (i = 0; i < count; i++) { CFStringRef this_if_name; SCNetworkInterfaceRef this_if; SCNetworkServiceRef s; s = (SCNetworkServiceRef)CFArrayGetValueAtIndex(services, i); this_if = SCNetworkServiceGetInterface(s); if (this_if == NULL) { continue; } if (entity_name != NULL && (SCNetworkInterfaceGetExtendedConfiguration(this_if, entity_name) == NULL)) { /* interface doesn't have specified entity */ continue; } this_if_name = SCNetworkInterfaceGetBSDName(this_if); if (this_if_name == NULL) { continue; } if (ret_names == NULL || CFArrayContainsValue(ret_names, ret_names_range, this_if_name) == FALSE) { if (ret_names == NULL) { ret_names = CFArrayCreateMutable(NULL, count, &kCFTypeArrayCallBacks); } CFArrayAppendValue(ret_names, this_if_name); ret_names_range.length++; } } done: my_CFRelease(¤t_set); my_CFRelease(&services); return (ret_names); }
static void nc_print_VPN_app_info(CFStringRef appInfo, CFDictionaryRef appInfoDict) { CFStringRef appName = NULL; Boolean isEnabled = FALSE; CFStringRef paddedAppInfo = NULL; CFStringRef paddedAppName = NULL; if (appInfo == NULL) { return; } isEnabled = VPNConfigurationIsVPNTypeEnabled(appInfo); CFDictionaryGetValueIfPresent(appInfoDict, CFSTR("CFBundleDisplayName"), (const void **)&appName); paddedAppName = copy_padded_string((appName == NULL) ? CFSTR("") : appName, 12, NULL, NULL); paddedAppInfo = copy_padded_string(appInfo, 30, NULL, NULL); SCPrint(TRUE, stdout, CFSTR("%@ %@ [%@]\n"), isEnabled ? CFSTR("(Enabled) ") : CFSTR("(Disabled)"), paddedAppName, appInfo); my_CFRelease(&paddedAppName); my_CFRelease(&paddedAppInfo); }
Boolean AFPUserList_init(AFPUserListRef users) { CFErrorRef error; int i; int n; CFArrayRef results; ODQueryRef query; bzero(users, sizeof(*users)); users->node = ODNodeCreateWithNodeType(NULL, kODSessionDefault, kODNodeTypeLocalNodes, &error); if (users->node == NULL) { my_log(LOG_NOTICE, "AFPUserList_init: ODNodeCreateWithNodeType() failed"); goto failed; } query = ODQueryCreateWithNode(NULL, users->node, // inNode CFSTR(kDSStdRecordTypeUsers), // inRecordTypeOrList CFSTR(NIPROP__CREATOR), // inAttribute kODMatchEqualTo, // inMatchType CFSTR(BSDPD_CREATOR), // inQueryValueOrList CFSTR(kDSAttributesAll), // inReturnAttributeOrList 0, // inMaxResults &error); if (query == NULL) { my_log(LOG_NOTICE, "AFPUserList_init: ODQueryCreateWithNode() failed"); my_CFRelease(&error); goto failed; } results = ODQueryCopyResults(query, FALSE, &error); CFRelease(query); if (results == NULL) { my_log(LOG_NOTICE, "AFPUserList_init: ODQueryCopyResults() failed"); my_CFRelease(&error); goto failed; } users->list = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); n = CFArrayGetCount(results); for (i = 0; i < n; i++) { ODRecordRef record; AFPUserRef user; record = (ODRecordRef)CFArrayGetValueAtIndex(results, i); user = AFPUser_create(record); CFArrayAppendValue(users->list, user); CFRelease(user); } CFRelease(results); return (TRUE); failed: AFPUserList_free(users); return (FALSE); }
/* ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- */ static void nc_enablevpn(int argc, char **argv) { CFStringRef argument = NULL; CFStringRef vendorType = NULL; int exit_code = 1; if (argc == 0) { SCPrint(TRUE, stderr, CFSTR("No service type or ID\n")); } else { argument = CFStringCreateWithCString(NULL, argv[0], kCFStringEncodingUTF8); vendorType = nc_copy_vendor_type(argument); my_CFRelease(&argument); if (!nc_enable_vpntype(vendorType)) { goto done; } #if !TARGET_OS_IPHONE if (argc >= 2) { argument = CFStringCreateWithCString(NULL, argv[1], kCFStringEncodingUTF8); nc_set_application_url(vendorType, argument); my_CFRelease(&argument); } #endif } exit_code = 0; done: my_CFRelease(&vendorType); exit(exit_code); }
void AFPUserList_free(AFPUserListRef users) { my_CFRelease(&users->node); my_CFRelease(&users->list); bzero(users, sizeof(*users)); }
static void nc_trigger(int argc, char **argv) { Boolean background = FALSE; int i; CFStringRef hostName = NULL; int port = 80; for (i = 0; i < 3 && i < argc; i++) { /* Parse host name. Must be first arg. */ if (i == 0) { hostName = CFStringCreateWithCString(NULL, argv[i], kCFStringEncodingUTF8); continue; } /* Check for optional background flag */ if (strcmp(argv[i], "background") == 0) { background = TRUE; continue; } /* Parse optional port number */ CFStringRef str = CFStringCreateWithCString(NULL, argv[i], kCFStringEncodingUTF8); if (str) { int num = CFStringGetIntValue(str); if (num) { port = num; } my_CFRelease(&str); } } if (hostName) { CFReadStreamRef readStream = NULL; CFWriteStreamRef writeStream = NULL; CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, hostName, port, &readStream, &writeStream); if (background) { CFReadStreamSetProperty(readStream, CFSTR("kCFStreamNetworkServiceType"), CFSTR("kCFStreamNetworkServiceTypeBackground")); CFWriteStreamSetProperty(writeStream, CFSTR("kCFStreamNetworkServiceType"), CFSTR("kCFStreamNetworkServiceTypeBackground")); } if (readStream && writeStream) { CFReadStreamOpen(readStream); CFWriteStreamOpen(writeStream); SCPrint(TRUE, stdout, CFSTR("Opened stream to %@, port %d%s\n"), hostName, port, background ? ", background traffic class" : ""); sleep(1); } my_CFRelease(&readStream); my_CFRelease(&writeStream); } else { SCPrint(TRUE, stderr, CFSTR("Invalid or missing host name\n")); } my_CFRelease(&hostName); exit(0); }
PRIVATE_EXTERN kern_return_t eapolclientitemid_remove_password(mach_port_t server, OOBData_t auth_data, mach_msg_type_number_t auth_data_length, xmlData_t itemID_data, mach_msg_type_number_t itemID_data_length, int * result) { EAPOLClientConfigurationRef cfg = NULL; EAPOLClientItemIDRef itemID = NULL; int ret = 0; if (authorization_is_valid(auth_data, auth_data_length) == FALSE) { ret = EPERM; goto done; } ret = init_itemID_and_cfg(itemID_data, itemID_data_length, &itemID, &cfg); if (ret != 0) { goto done; } if (EAPOLClientItemIDRemovePasswordItem(itemID, kEAPOLClientDomainSystem) == FALSE) { ret = ENXIO; } done: my_vm_deallocate((vm_address_t)auth_data, auth_data_length); my_vm_deallocate((vm_address_t)itemID_data, itemID_data_length); my_CFRelease(&cfg); my_CFRelease(&itemID); *result = ret; return (KERN_SUCCESS); }
/* * Function: set_eapol_configuration * Purpose: * Set the EAPOL configuration in the prefs. */ STATIC Boolean set_eapol_configuration(SCPreferencesRef prefs, CFStringRef if_name, CFDictionaryRef dict) { SCNetworkSetRef current_set = NULL; SCNetworkInterfaceRef net_if_save; Boolean ret = FALSE; SCNetworkServiceRef service = NULL; net_if_save = copy_interface(prefs, if_name, ¤t_set, &service); if (net_if_save != NULL) { ret = SCNetworkInterfaceSetExtendedConfiguration(net_if_save, kEAPOL, dict); if (ret == FALSE) { EAPLOG(LOG_ERR, "EAPOLClientConfiguration: SetExtendedConfiguration failed"); } } if (current_set != NULL) { SCNetworkSetRemoveService(current_set, service); CFRelease(current_set); } my_CFRelease(&service); my_CFRelease(&net_if_save); return (ret); }
OSStatus EAPOLClientSetACLForIdentity(SecIdentityRef identity) { SecKeyRef private_key = NULL; CFArrayRef trusted_apps = NULL; OSStatus status; status = SecIdentityCopyPrivateKey(identity, &private_key); if (status != noErr) { goto done; } trusted_apps = copy_trusted_applications(TRUE); if (trusted_apps == NULL) { status = errSecParam; goto done; } status = EAPSecKeychainItemSetAccessForTrustedApplications((SecKeychainItemRef) private_key, trusted_apps); done: my_CFRelease(&private_key); my_CFRelease(&trusted_apps); return (status); }
static int S_find_service(mach_port_t server, int argc, char * argv[]) { CFDataRef data = NULL; CFDictionaryRef dict; boolean_t exact = FALSE; char * method_name; if_name_t if_name; kern_return_t kret; inline_data_t service_id; unsigned int service_id_len = sizeof(service_id); ipconfig_status_t status = ipconfig_status_success_e; void * xml_data_ptr = NULL; int xml_data_len = 0; strlcpy(if_name, argv[0], sizeof(if_name)); argv++; argc--; if (argc > 1 && strcasecmp(argv[0], "exact") == 0) { exact = TRUE; argc--; argv++; } method_name = argv[0]; argc--; argv++; dict = ConfigDictCreate(if_name, argc, argv, command_name, method_name, FALSE); if (dict == NULL) { return (1); } data = CFPropertyListCreateData(NULL, dict, kCFPropertyListBinaryFormat_v1_0, 0, NULL); if (data == NULL) { CFRelease(dict); fprintf(stderr, "failed to allocate memory\n"); return (1); } xml_data_ptr = (void *)CFDataGetBytePtr(data); xml_data_len = (int)CFDataGetLength(data); kret = ipconfig_find_service(server, if_name, exact, xml_data_ptr, xml_data_len, service_id, &service_id_len, &status); my_CFRelease(&dict); my_CFRelease(&data); if (kret != KERN_SUCCESS) { mach_error("ipconfig_find_service failed", kret); return (1); } if (status != ipconfig_status_success_e) { fprintf(stderr, "ipconfig_find_service %s %s failed: %s\n", if_name, method_name, ipconfig_status_string(status)); return (1); } printf("%.*s\n", service_id_len, service_id); return (0); }
kern_return_t eapolclientitemid_set_password(mach_port_t server, OOBData_t auth_data, mach_msg_type_number_t auth_data_length, xmlData_t itemID_data, mach_msg_type_number_t itemID_data_length, uint32_t flags, OOBData_t name, mach_msg_type_number_t name_length, OOBData_t password, mach_msg_type_number_t password_length, int * result) { EAPOLClientConfigurationRef cfg = NULL; EAPOLClientItemIDRef itemID = NULL; CFDataRef name_data = NULL; CFDataRef password_data = NULL; int ret = 0; if (authorization_is_valid(auth_data, auth_data_length) == FALSE) { ret = EPERM; goto done; } ret = init_itemID_and_cfg(itemID_data, itemID_data_length, &itemID, &cfg); if (ret != 0) { goto done; } if ((flags & keapolcfg_auth_set_name) != 0) { name_data = CFDataCreate(NULL, (const UInt8 *)name, name_length); } else { syslog(LOG_NOTICE, "not setting name"); } if ((flags & keapolcfg_auth_set_password) != 0) { password_data = CFDataCreate(NULL, (const UInt8 *)password, password_length); } else { syslog(LOG_NOTICE, "not setting password"); } if (EAPOLClientItemIDSetPasswordItem(itemID, kEAPOLClientDomainSystem, name_data, password_data) == FALSE) { ret = ENXIO; } done: my_vm_deallocate((vm_address_t)auth_data, auth_data_length); my_vm_deallocate((vm_address_t)itemID_data, itemID_data_length); my_vm_deallocate((vm_address_t)name, name_length); my_vm_deallocate((vm_address_t)password, password_length); my_CFRelease(&name_data); my_CFRelease(&password_data); my_CFRelease(&cfg); my_CFRelease(&itemID); *result = ret; return (KERN_SUCCESS); }
/** ** MiG server routines **/ PRIVATE_EXTERN kern_return_t eapolclientitemid_set_identity(mach_port_t server, OOBData_t auth_data, mach_msg_type_number_t auth_data_length, xmlData_t itemID_data, mach_msg_type_number_t itemID_data_length, OOBData_t id_handle, mach_msg_type_number_t id_handle_length, int * result) { EAPOLClientConfigurationRef cfg = NULL; SecIdentityRef identity = NULL; EAPOLClientItemIDRef itemID = NULL; int ret = 0; if (authorization_is_valid(auth_data, auth_data_length) == FALSE) { ret = EPERM; goto done; } ret = init_itemID_and_cfg(itemID_data, itemID_data_length, &itemID, &cfg); if (ret != 0) { goto done; } if (id_handle != NULL) { CFDataRef data; OSStatus status; data = CFDataCreateWithBytesNoCopy(NULL, (const UInt8 *)id_handle, id_handle_length, kCFAllocatorNull); if (data == NULL) { ret = EINVAL; goto done; } status = EAPSecIdentityHandleCreateSecIdentity(data, &identity); CFRelease(data); if (status != noErr) { ret = ENOENT; goto done; } } if (EAPOLClientItemIDSetIdentity(itemID, kEAPOLClientDomainSystem, identity) == FALSE) { ret = ENXIO; } done: my_vm_deallocate((vm_address_t)auth_data, auth_data_length); my_vm_deallocate((vm_address_t)itemID_data, itemID_data_length); my_vm_deallocate((vm_address_t)id_handle, id_handle_length); my_CFRelease(&cfg); my_CFRelease(&itemID); my_CFRelease(&identity); *result = ret; return (KERN_SUCCESS); }
/* * Function: copy_interface * Purpose: * Get a reference to an SCNetworkInterfaceRef for the specified * interface name. First try to get an interface configured in the * current set. If that fails, copy a service configured over the * specified interface, and add it to the current set. * * Return the interface, service, and set for the caller to release. */ STATIC SCNetworkInterfaceRef copy_interface(SCPreferencesRef prefs, CFStringRef if_name, SCNetworkSetRef * ret_set_p, SCNetworkServiceRef * ret_service_p) { SCNetworkSetRef current_set = NULL; SCNetworkServiceRef service = NULL; SCNetworkInterfaceRef net_if; SCNetworkInterfaceRef ret = NULL; /* if the interface is part of a service/set, we're done */ net_if = copy_configured_interface(prefs, if_name); if (net_if != NULL) { ret = net_if; CFRetain(ret); goto done; } /* interface isn't part of a service/set, make it so */ net_if = copy_present_interface(if_name); if (net_if == NULL) { goto done; } /* find the service in any set */ service = copy_service(prefs, net_if); if (service == NULL) { EAPLOG(LOG_ERR, "EAPOLClientConfiguration: can't get service"); goto done; } /* add the service to the current set */ current_set = SCNetworkSetCopyCurrent(prefs); if (current_set == NULL) { EAPLOG(LOG_ERR, "EAPOLClientConfiguration: can't get current set"); goto done; } if (SCNetworkSetAddService(current_set, service) == FALSE) { EAPLOG(LOG_ERR, "EAPOLClientConfiguration: failed to add dummy service"); goto done; } /* return this SCNetworkInterfaceRef since it's bound to the prefs */ ret = SCNetworkServiceGetInterface(service); CFRetain(ret); done: my_CFRelease(&net_if); if (ret == NULL) { my_CFRelease(&service); my_CFRelease(¤t_set); } *ret_service_p = service; *ret_set_p = current_set; return (ret); }
static void nc_listvpn(int argc, char **argv) { CFDictionaryRef appDict = NULL; CFArrayRef appinfo = NULL; int i, j, count, subtypecount; const void * * keys = NULL; CFMutableDictionaryRef optionsDict = NULL; const void * * values = NULL; CFStringRef vpntype = NULL; optionsDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFDictionarySetValue(optionsDict, kLookupApplicationTypeKey, kApplicationTypeUser); CFDictionarySetValue(optionsDict, kLookupAttributeKey, CFSTR("UIVPNPlugin")); appDict = MobileInstallationLookup(optionsDict); if (!isA_CFDictionary(appDict)) goto done; count = CFDictionaryGetCount(appDict); if (count > 0) { keys = (const void * *)malloc(sizeof(CFTypeRef) * count); values = (const void * *)malloc(sizeof(CFTypeRef) * count); CFDictionaryGetKeysAndValues(appDict, keys, values); for (i=0; i<count; i++) { appinfo = CFDictionaryGetValue(values[i], CFSTR("UIVPNPlugin")); if (appinfo) { if (isA_CFString(appinfo)) { nc_print_VPN_app_info((CFStringRef)appinfo, (CFDictionaryRef)values[i]); } else if (isA_CFArray(appinfo)) { subtypecount = CFArrayGetCount((CFArrayRef)appinfo); for(j=0; j<subtypecount; j++) { vpntype = (CFStringRef)CFArrayGetValueAtIndex((CFArrayRef)appinfo, j); nc_print_VPN_app_info(vpntype, (CFDictionaryRef)values[i]); } } } } } done: if (keys) free(keys); if (values) free(values); my_CFRelease(&optionsDict); my_CFRelease(&appDict); exit(0); }
/** ** interface to eapolcfg_auth MiG routines **/ STATIC Boolean authEAPOLClientItemIDSetIdentity(EAPOLClientItemIDRef itemID, SecIdentityRef identity) { AuthorizationExternalForm * auth_ext_p; CFDataRef id_data = NULL; OOBData_t id_handle; mach_msg_type_number_t id_handle_length; CFDataRef itemID_data = NULL; kern_return_t kret; int result = ENXIO; mach_port_t server; server = eapolcfg_auth_server_port(); if (server == MACH_PORT_NULL) { return (FALSE); } auth_ext_p = EAPOLClientItemIDGetAuthorizationExternalForm(itemID); if (identity != NULL) { id_data = EAPSecIdentityHandleCreate(identity); if (id_data == NULL) { goto done; } id_handle = (OOBData_t)CFDataGetBytePtr(id_data); id_handle_length = CFDataGetLength(id_data); } else { id_handle = NULL; id_handle_length = 0; } itemID_data = itemID_copy_data(itemID); kret = eapolclientitemid_set_identity(server, auth_ext_p->bytes, sizeof(auth_ext_p->bytes), (xmlData_t) CFDataGetBytePtr(itemID_data), CFDataGetLength(itemID_data), id_handle, id_handle_length, &result); if (kret != KERN_SUCCESS) { EAPLOG(LOG_ERR, "eapolclientitemid_set_identity failed %d", kret); } if (result != 0) { EAPLOG(LOG_NOTICE, "eapolclientitemid_set_identity() returned %d", result); } done: my_CFRelease(&itemID_data); my_CFRelease(&id_data); return (result == 0); }
static int S_stress_start(int argc, char * argv[]) { CFDictionaryRef dict = NULL; int i; char * ifname = argv[0]; int result; SCDynamicStoreRef store; if (access(argv[1], R_OK) != 0) { fprintf(stderr, "%s: %s\n", argv[1], strerror(errno)); return (errno); } dict = (CFDictionaryRef)my_CFPropertyListCreateFromFile(argv[1]); if (isA_CFDictionary(dict) == NULL) { fprintf(stderr, "contents of file %s invalid\n", argv[1]); my_CFRelease(&dict); return (EINVAL); } store = config_session_start(NULL, NULL, ifname); if (store == NULL) { CFRelease(dict); return (EINVAL); } for (i = 0; TRUE; i++) { result = EAPOLControlStart(ifname, dict); if (result != 0) { fprintf(stderr, "EAPOLControlStart(%s) returned %d (%s)\n", ifname, result, strerror(result)); break; } result = S_wait_for_state(ifname, store, kEAPOLControlStateRunning, kEAPOLControlStateStarting); if (result != 0) { fprintf(stderr, "Waiting for Running failed\n"); break; } result = EAPOLControlStop(ifname); if (result != 0) { fprintf(stderr, "EAPOLControlStop(%s) returned %d (%s)\n", ifname, result, strerror(result)); break; } (void)S_wait_for_state(ifname, store, kEAPOLControlStateIdle, kEAPOLControlStateStopping); } fprintf(stderr, "Failed at iteration %d\n", i + 1); my_CFRelease(&dict); return (result); }
void clearVPNLocation (struct service *serv) { if (serv->connection_nap_monitor) { Apple80211Close((Apple80211Ref)serv->connection_nap_monitor); serv->connection_nap_monitor = NULL; } if (serv->type == TYPE_PPP) { serv->u.ppp.lower_interface[0] = 0; } my_CFRelease(&serv->connection_nid); my_CFRelease(&serv->connection_nap); }
static void eaptls_free_context(EAPTLSPluginDataRef context) { if (context->ssl_context != NULL) { CFRelease(context->ssl_context); context->ssl_context = NULL; } my_CFRelease(&context->certs); my_CFRelease(&context->server_certs); memoryIOClearBuffers(&context->mem_io); free(context); return; }
/* ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- */ __private_extern__ kern_return_t _pppcontroller_start(mach_port_t session, xmlData_t dataRef, /* raw XML bytes */ mach_msg_type_number_t dataLen, int linger, int * result) { struct client *client; struct service *serv = 0; CFDictionaryRef optRef = 0; int err; client = client_findbymachport(session); if (!client ) { *result = kSCStatusInvalidArgument; goto failed; } if ((serv = findbyserviceID(client->serviceID)) == 0) { *result = kSCStatusConnectionNoService; goto failed; } /* un-serialize the user options */ if (dataLen) { if (!_SCUnserialize((CFPropertyListRef *)&optRef, NULL, (void *)dataRef, dataLen)) { *result = kSCStatusFailed; goto failed; } if (!isA_CFDictionary(optRef)) { *result = kSCStatusInvalidArgument; goto failed; } } err = scnc_start(serv, optRef, client, linger ? 0 : 1, client->uid, client->gid, client->pid, client->bootstrap_port); if (err) { *result = kSCStatusFailed; goto failed; } my_CFRelease(&optRef); *result = kSCStatusOK; return (KERN_SUCCESS); failed: my_CFRelease(&optRef); return (KERN_SUCCESS); }
static CFDictionaryRef make_alert_dict(char * title, char * message) { CFMutableDictionaryRef dict = NULL; CFStringRef str = NULL; dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (dict == NULL) { goto failed; } /* bug: the default button title must be set to get the correct flags */ CFDictionaryAddValue(dict, kCFUserNotificationDefaultButtonTitleKey, CFSTR("OK")); /* title */ if (title) { str = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8); if (str == NULL) { goto failed; } CFDictionaryAddValue(dict, kCFUserNotificationAlertHeaderKey, str); my_CFRelease(&str); } else { CFDictionaryAddValue(dict, kCFUserNotificationAlertHeaderKey, CFSTR("<default title>")); } /* message */ if (message) { str = CFStringCreateWithCString(NULL, message, kCFStringEncodingUTF8); if (str == NULL) { goto failed; } CFDictionaryAddValue(dict, kCFUserNotificationAlertMessageKey, str); my_CFRelease(&str); } else { CFDictionaryAddValue(dict, kCFUserNotificationAlertMessageKey, CFSTR("<default message>")); } return (dict); failed: my_CFRelease(&dict); return (NULL); }
Alert * Alert_create(AlertCallback * func, void * arg1, void * arg2, char * title, char * message) { Alert * alert_p; CFUserNotificationRef alert = NULL; CFDictionaryRef dict = NULL; SInt32 error = 0; CFRunLoopSourceRef rls = NULL; alert_p = malloc(sizeof(*alert_p)); if (alert_p == NULL) { EAPLOG_FL(LOG_NOTICE, "malloc failed"); return (NULL); } bzero(alert_p, sizeof(*alert_p)); dict = make_alert_dict(title, message); if (dict == NULL) { EAPLOG_FL(LOG_NOTICE, "make_alert_dict failed"); goto failed; } alert = CFUserNotificationCreate(NULL, 0, 0, &error, dict); if (alert == NULL) { EAPLOG_FL(LOG_NOTICE, "CFUserNotificationCreate failed, %d", error); goto failed; } rls = CFUserNotificationCreateRunLoopSource(NULL, alert, Alert_response, 0); if (rls == NULL) { EAPLOG_FL(LOG_NOTICE, "CFUserNotificationCreateRunLoopSource failed"); goto failed; } CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode); alert_p->notif = alert; alert_p->rls = rls; alert_p->func = func; alert_p->arg1 = arg1; alert_p->arg2 = arg2; LIST_INSERT_HEAD(S_AlertHead_p, alert_p, entries); my_CFRelease(&dict); return (alert_p); failed: free(alert_p); my_CFRelease(&dict); my_CFRelease(&alert); my_CFRelease(&rls); return (NULL); }
static int S_remove_service(mach_port_t server, int argc, char * argv[]) { CFDataRef data = NULL; CFDictionaryRef dict; char * method_name; if_name_t if_name; kern_return_t kret; ipconfig_status_t status = ipconfig_status_success_e; void * xml_data_ptr = NULL; int xml_data_len = 0; strlcpy(if_name, argv[0], sizeof(if_name)); method_name = argv[1]; argv += 2; argc -= 2; dict = ConfigDictCreate(if_name, argc, argv, command_name, method_name, FALSE); if (dict == NULL) { return (1); } data = CFPropertyListCreateData(NULL, dict, kCFPropertyListBinaryFormat_v1_0, 0, NULL); if (data == NULL) { CFRelease(dict); fprintf(stderr, "failed to allocate memory\n"); return (1); } xml_data_ptr = (void *)CFDataGetBytePtr(data); xml_data_len = (int)CFDataGetLength(data); kret = ipconfig_remove_service(server, if_name, xml_data_ptr, xml_data_len, &status); my_CFRelease(&dict); my_CFRelease(&data); if (kret != KERN_SUCCESS) { mach_error("ipconfig_remove_service failed", kret); return (1); } if (status != ipconfig_status_success_e) { fprintf(stderr, "ipconfig_remove_service %s %s failed: %s\n", if_name, method_name, ipconfig_status_string(status)); return (1); } return (0); }
static uid_t uid_from_odrecord(ODRecordRef record) { uid_t uid = -2; CFArrayRef values = NULL; values = ODRecordCopyValues(record, CFSTR(kDS1AttrUniqueID), NULL); if ((values != NULL) && (CFArrayGetCount(values) > 0)) { char buf[64]; char * end; CFStringRef uidStr; unsigned long val; uidStr = CFArrayGetValueAtIndex(values, 0); (void) _SC_cfstring_to_cstring(uidStr, buf, sizeof(buf), kCFStringEncodingASCII); errno = 0; val = strtoul(buf, &end, 0); if ((buf[0] != '\0') && (*end == '\0') && (errno == 0)) { uid = (uid_t)val; } } my_CFRelease(&values); return (uid); }
static CFArrayRef wireless_scan_ssid(wireless_t wref, CFStringRef ssid) { CFArrayRef bssid_list = NULL; Apple80211Err error; CFDictionaryRef scan_args; CFArrayRef scan_result = NULL; EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_scan_ssid"); scan_args = make_scan_args(ssid, 1); error = Apple80211Scan((Apple80211Ref)wref, &scan_result, scan_args); CFRelease(scan_args); if (error != kA11NoErr) { EAPLOG(LOG_ERR, "Apple80211Scan failed, %d\n", error); goto failed; } bssid_list = copy_bssid_list_from_scan(scan_result, ssid); if (bssid_list == NULL) { EAPLOG(LOG_ERR, "No scan results\n"); } else { CFShow(bssid_list); } fflush(stdout); fflush(stderr); failed: my_CFRelease(&scan_result); return (bssid_list); }
STATIC Boolean authEAPOLClientItemIDRemovePasswordItem(EAPOLClientItemIDRef itemID) { AuthorizationExternalForm * auth_ext_p; CFDataRef itemID_data; kern_return_t kret; int result = ENXIO; mach_port_t server; server = eapolcfg_auth_server_port(); if (server == MACH_PORT_NULL) { return (FALSE); } auth_ext_p = EAPOLClientItemIDGetAuthorizationExternalForm(itemID); itemID_data = itemID_copy_data(itemID); kret = eapolclientitemid_remove_password(server, auth_ext_p->bytes, sizeof(auth_ext_p->bytes), (xmlData_t) CFDataGetBytePtr(itemID_data), CFDataGetLength(itemID_data), &result); if (kret != KERN_SUCCESS) { EAPLOG(LOG_ERR, "eapolclientitemid_remove_password failed %d", kret); } if (result != 0) { EAPLOG(LOG_DEBUG, "eapolclientitemid_remove_password() returned %d", result); } my_CFRelease(&itemID_data); return (result == 0); }
/* * Function: DHCPLeaseListWrite * * Purpose: * Write the last DHCP lease in the list for the given interface/client_id. * We only save the last (current) lease. See the comments for * DHCPLeaseListRead above for more information. */ void DHCPLeaseListWrite(DHCPLeaseListRef list_p, const char * ifname, uint8_t cid_type, const void * cid, int cid_length) { int count; char filename[PATH_MAX]; CFDictionaryRef lease_dict; DHCPLeaseRef lease_p; if (DHCPLeaseListGetPath(ifname, cid_type, cid, cid_length, filename, sizeof(filename)) == FALSE) { return; } DHCPLeaseListRemoveStaleLeases(list_p); count = dynarray_count(list_p); if (count == 0) { unlink(filename); return; } lease_p = dynarray_element(list_p, count - 1); lease_dict = DHCPLeaseCopyDictionary(lease_p); if (my_CFPropertyListWriteFile(lease_dict, filename, 0644) < 0) { /* * An ENOENT error is expected on a read-only filesystem. All * other errors should be reported. */ if (errno != ENOENT) { my_log(LOG_ERR, "my_CFPropertyListWriteFile(%s) failed, %s", filename, strerror(errno)); } } my_CFRelease(&lease_dict); return; }
/* Turns a service ID or name into a vendor type, or preserves type */ static CFStringRef nc_copy_vendor_type (CFStringRef input) { SCNetworkInterfaceRef child; SCNetworkInterfaceRef interface; CFStringRef output_name = input; SCNetworkServiceRef service = NULL; CFStringRef type; if (input == NULL) { goto done; } service = nc_copy_service(NULL, input); if (service != NULL) { interface = SCNetworkServiceGetInterface(service); child = SCNetworkInterfaceGetInterface(interface); type = SCNetworkInterfaceGetInterfaceType(interface); /* Must be of type VPN */ if (!CFEqual(type, kSCNetworkInterfaceTypeVPN)) { output_name = NULL; goto done; } output_name = SCNetworkInterfaceGetInterfaceType(child); goto done; } done : if (output_name != NULL) CFRetain(output_name); my_CFRelease(&service); return output_name; }
/* * Function: copy_service * Purpose: * Check the global list of SCNetworkServiceRefs for one that is configured * over the specifed SCNetworkInterfaceRef. The assumption here is that * a previous call has already checked for such a service in the current * set. */ STATIC SCNetworkServiceRef copy_service(SCPreferencesRef prefs, SCNetworkInterfaceRef net_if) { int count = 0; int i; SCNetworkServiceRef service = NULL; CFArrayRef list; list = SCNetworkServiceCopyAll(prefs); if (list != NULL) { count = CFArrayGetCount(list); } if (count == 0) { goto done; } for (i = 0; i < count; i++) { SCNetworkInterfaceRef this_if; SCNetworkServiceRef this_service; this_service = (SCNetworkServiceRef)CFArrayGetValueAtIndex(list, i); this_if = SCNetworkServiceGetInterface(this_service); if (this_if == NULL) { continue; } if (CFEqual(this_if, net_if)) { service = this_service; CFRetain(service); break; } } done: my_CFRelease(&list); return (service); }
static int pollCurrentVPNLocation (struct service *serv, CFStringRef *nidRef, CFStringRef *napRef) { int rc = 0; // poll current NID *nidRef = pollCurrentNID(serv); if (isVPNInterfaceWifi(serv)) { Boolean wifiErr = false; // poll current NAP *napRef = pollCurrentNAP(serv, &wifiErr); if (wifiErr) { // special case disconnection: a bad/driver error while trying to detect nhood, disconnect b/c it worked before SCLog(TRUE, LOG_INFO, CFSTR("%s: failed to detect nap %@ because of a scan/association error"), __FUNCTION__, serv->connection_nap); my_CFRelease(nidRef); rc = -1; } } else { SCLog(TRUE, LOG_INFO, CFSTR("%s: underlying interface isn't wifi. Skip NAP"), __FUNCTION__); *napRef = NULL; } return rc; }
/* * Function: copy_present_interface * Purpose: * Check the list of interfaces on the system, and find the one corresponding * to the specified BSD name. */ STATIC SCNetworkInterfaceRef copy_present_interface(CFStringRef if_name) { int count = 0; int i; CFArrayRef list; SCNetworkInterfaceRef ret = NULL; list = SCNetworkInterfaceCopyAll(); if (list != NULL) { count = CFArrayGetCount(list); } if (count == 0) { goto done; } for (i = 0; i < count; i++) { SCNetworkInterfaceRef this_if; CFStringRef this_if_name; this_if = (SCNetworkInterfaceRef)CFArrayGetValueAtIndex(list, i); this_if_name = SCNetworkInterfaceGetBSDName(this_if); if (this_if_name == NULL) { continue; } if (CFEqual(if_name, this_if_name)) { ret = this_if; CFRetain(ret); break; } } done: my_CFRelease(&list); return (ret); }