static CFDictionaryRef _CFCopyVersionDictionary(CFStringRef path)
{
CFURLRef url;
CFDataRef resourceData;
Boolean status;
SInt32 errorCode;
CFErrorRef err;
CFPropertyListRef plist;
url = CFURLCreateWithFileSystemPath(NULL, path, kCFURLPOSIXPathStyle, 0);
status = CFURLCreateDataAndPropertiesFromResource(NULL, url, &resourceData,
NULL, NULL, &errorCode);
if (!status)
{
CFRelease(url);
return NULL;
}
plist = CFPropertyListCreateWithData(NULL, resourceData, kCFPropertyListImmutable,
NULL, &err);
CFRelease(resourceData);
CFRelease(url);
return plist;
}
RefPtr<LegacyWebArchive> LegacyWebArchive::create(const URL&, SharedBuffer& data)
{
LOG(Archives, "LegacyWebArchive - Creating from raw data");
Ref<LegacyWebArchive> archive = create();
RetainPtr<CFDataRef> cfData = data.createCFData();
if (!cfData)
return nullptr;
CFErrorRef error = nullptr;
RetainPtr<CFDictionaryRef> plist = adoptCF(static_cast<CFDictionaryRef>(CFPropertyListCreateWithData(0, cfData.get(), kCFPropertyListImmutable, 0, &error)));
if (!plist) {
#ifndef NDEBUG
RetainPtr<CFStringRef> errorString = error ? adoptCF(CFErrorCopyDescription(error)) : 0;
const char* cError = errorString ? CFStringGetCStringPtr(errorString.get(), kCFStringEncodingUTF8) : "unknown error";
LOG(Archives, "LegacyWebArchive - Error parsing PropertyList from archive data - %s", cError);
#endif
if (error)
CFRelease(error);
return nullptr;
}
if (CFGetTypeID(plist.get()) != CFDictionaryGetTypeID()) {
LOG(Archives, "LegacyWebArchive - Archive property list is not the expected CFDictionary, aborting invalid WebArchive");
return nullptr;
}
if (!archive->extract(plist.get()))
return nullptr;
return WTFMove(archive);
}
bool ReceiptsDb::getInstalledPackageInfo(const char* identifier, std::string& plistXml)
{
std::string path;
std::unique_ptr<Reader> fileReader;
std::unique_ptr<UInt8[]> fileData;
CFDataRef data;
CFDictionaryRef plist;
path = getReceiptsPath(identifier, ".plist");
if (::access(path.c_str(), F_OK) != 0)
return false;
fileReader.reset(new FileReader(path));
fileData.reset(new UInt8[fileReader->length()]);
if (fileReader->read(fileData.get(), fileReader->length(), 0) != fileReader->length())
throw std::runtime_error("Short read in getInstalledPackageInfo()");
data = CFDataCreate(nullptr, fileData.get(), fileReader->length());
fileData.reset(nullptr);
plist = (CFDictionaryRef) CFPropertyListCreateWithData(nullptr, data,
kCFPropertyListImmutable, nullptr, nullptr);
CFRelease(data);
data = CFPropertyListCreateData(nullptr, plist,
kCFPropertyListXMLFormat_v1_0, 0, nullptr);
CFRelease(plist);
plistXml.assign((const char*) CFDataGetBytePtr(data), CFDataGetLength(data));
CFRelease(data);
return true;
}
PRIVATE_EXTERN CFPropertyListRef
my_CFPropertyListCreateFromFile(const char * filename)
{
void * buf;
size_t bufsize;
CFDataRef data = NULL;
CFPropertyListRef plist = NULL;
buf = read_file(filename, &bufsize);
if (buf == NULL) {
return (NULL);
}
data = CFDataCreateWithBytesNoCopy(NULL, buf, bufsize, kCFAllocatorNull);
if (data == NULL) {
goto done;
}
plist = CFPropertyListCreateWithData(NULL,
data,
kCFPropertyListImmutable,
NULL,
NULL);
done:
if (data)
CFRelease(data);
if (buf)
free(buf);
return (plist);
}
sdmmd_return_t SDMMD_ServiceReceiveMessage(SocketConnection handle, CFPropertyListRef *data) {
CFDataRef dataBuffer = NULL;
sdmmd_return_t result;
*data = NULL;
CFErrorRef error = NULL;
result = SDMMD_ServiceReceive(handle, &dataBuffer);
if (result == kAMDSuccess) {
// ServiceReceive success does not guarantee that valid data is available
if (dataBuffer) {
// CFPropertyListCreateWithData will return NULL if data is invalid format
*data = CFPropertyListCreateWithData(kCFAllocatorDefault, dataBuffer, kCFPropertyListImmutable, NULL, &error);
}
if (*data == NULL) {
// Could not parse received data
result = kAMDInvalidResponseError;
}
}
CFSafeRelease(dataBuffer);
// Return an empty dictionary if a receive OR parse failure occurred
if (result != kAMDSuccess) {
*data = CFDictionaryCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
return result;
}
static int CreatePropertyListFromData(CFDataRef prop_data, CFTypeID output_type, CFTypeRef* plistRef)
{
int result = -1; // Guilt until proven
CFPropertyListRef aPlistRef = NULL;
CFPropertyListFormat list_format = kCFPropertyListXMLFormat_v1_0;
CFErrorRef error = NULL;
if (NULL == prop_data || NULL == plistRef)
{
return result;
}
*plistRef = NULL;
aPlistRef = CFPropertyListCreateWithData(kCFAllocatorDefault, prop_data, 0, &list_format, &error);
if (NULL != error || NULL == aPlistRef)
{
if (NULL != error)
{
CFRelease(error);
}
return result;
}
if (CFGetTypeID(aPlistRef) != output_type)
{
CFRelease(aPlistRef);
return result;
}
*plistRef = aPlistRef;
result = (NULL == *plistRef) ? -1 : 0;
return result;
}
Status parseApplicationAliasData(const std::string& data, std::string& result) {
std::string decoded_data = base64Decode(data);
if (decoded_data.empty()) {
return Status(1, "Failed to base64 decode data");
}
CFDataRef resourceData = CFDataCreate(
nullptr,
static_cast<const UInt8*>(static_cast<const void*>(decoded_data.c_str())),
decoded_data.length());
if (resourceData == nullptr) {
return Status(1, "Failed to allocate resource data");
}
auto alias = (CFDataRef)CFPropertyListCreateWithData(kCFAllocatorDefault,
resourceData,
kCFPropertyListImmutable,
nullptr,
nullptr);
CFRelease(resourceData);
if (alias == nullptr) {
return Status(1, "Failed to allocate alias data");
}
auto bookmark =
CFURLCreateBookmarkDataFromAliasRecord(kCFAllocatorDefault, alias);
CFRelease(alias);
if (bookmark == nullptr) {
return Status(1, "Alias data is not a bookmark");
}
auto url = CFURLCreateByResolvingBookmarkData(
kCFAllocatorDefault, bookmark, 0, nullptr, nullptr, nullptr, nullptr);
CFRelease(bookmark);
if (url == nullptr) {
return Status(1, "Alias data is not a URL bookmark");
}
auto replaced = CFURLCreateStringByReplacingPercentEscapes(
kCFAllocatorDefault, CFURLGetString(url), CFSTR(""));
CFRelease(url);
if (replaced == nullptr) {
return Status(1, "Failed to replace percent escapes.");
}
// Get the URL-formatted path.
result = stringFromCFString(replaced);
CFRelease(replaced);
if (result.empty()) {
return Status(1, "Return result is zero size");
}
if (result.length() > 6 && result.substr(0, 7) == "file://") {
result = result.substr(7);
}
return Status(0, "OK");
}
inline CFPropertyListRef SQLite3StatementCreatePropertyListWithColumn(SQLite3StatementRef statement, CFIndex index, CFOptionFlags options, CFPropertyListFormat *format) {
CFPropertyListRef result = NULL;
CFDataRef data = SQLite3StatementCreateDataWithColumn(statement, index);
if (data) {
result = CFPropertyListCreateWithData(statement->allocator, data, options, format, NULL);
CFRelease(data);
}
return result;
}
/**
* Import the #plist_t structure from binary format.
*
* @param plist_bin a pointer to the xml buffer.
* @param length length of the buffer to read.
* @param plist a pointer to the imported plist.
*/
void plist_from_bin(const char *plist_bin, uint32_t length, plist_t * plist)
{
*plist = NULL;
CFDataRef data = CFDataCreate(kCFAllocatorDefault, (UInt8 *)plist_bin, length);
if (data) {
*plist = CFPropertyListCreateWithData(kCFAllocatorDefault, data, kCFPropertyListMutableContainers, NULL, NULL);
CFRelease(data);
}
}
KeyedDecoder::KeyedDecoder(const uint8_t* data, size_t size)
{
auto cfData = adoptCF(CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, data, size, kCFAllocatorNull));
if (auto rootDictionary = adoptCF(dynamic_cf_cast<CFDictionaryRef>(CFPropertyListCreateWithData(kCFAllocatorDefault, cfData.get(), kCFPropertyListImmutable, nullptr, nullptr))))
m_rootDictionary = std::move(rootDictionary);
else
m_rootDictionary = adoptCF(CFDictionaryCreate(kCFAllocatorDefault, nullptr, nullptr, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
m_dictionaryStack.append(m_rootDictionary.get());
}
/*! Creates a new target object from byte representation. */
iSCSISessionConfigRef iSCSITargetCreateWithData(CFDataRef data)
{
CFPropertyListFormat format;
iSCSITargetRef target = CFPropertyListCreateWithData(kCFAllocatorDefault,data,0,&format,NULL);
if(format == kCFPropertyListBinaryFormat_v1_0)
return target;
CFRelease(target);
return NULL;
}
/*! Creates a new connection config object from an external data representation.
* @param data data used to construct an iSCSI connection config object.
* @return an iSCSI connection configuration object
* or NULL if object creation failed */
iSCSIConnectionConfigRef iSCSIConnectionConfigCreateWithData(CFDataRef data)
{
CFPropertyListFormat format;
iSCSIConnectionConfigRef connCfg = CFPropertyListCreateWithData(kCFAllocatorDefault,data,0,&format,NULL);
if(format == kCFPropertyListBinaryFormat_v1_0)
return connCfg;
CFRelease(connCfg);
return NULL;
}
/*! Creates a new portal object from byte representation. */
iSCSIPortalRef iSCSIPortalCreateWithData(CFDataRef data)
{
CFPropertyListFormat format;
iSCSIPortalRef portal = CFPropertyListCreateWithData(
kCFAllocatorDefault,data,kCFPropertyListImmutable,&format,NULL);
if(format == kCFPropertyListBinaryFormat_v1_0)
return portal;
CFRelease(portal);
return NULL;
}
/*! Creates a new authentication object from byte representation. */
iSCSIAuthRef iSCSIAuthCreateWithData(CFDataRef data)
{
CFPropertyListFormat format;
iSCSIAuthRef auth = CFPropertyListCreateWithData(kCFAllocatorDefault,data,0,&format,NULL);
if(format == kCFPropertyListBinaryFormat_v1_0)
return auth;
CFRelease(auth);
return NULL;
}
sdmmd_return_t SDMMD_ServiceReceiveMessage(SocketConnection handle, CFPropertyListRef *data) {
CFDataRef dataBuffer = NULL;
if (SDM_MD_CallSuccessful(SDMMD_ServiceReceive(handle, &dataBuffer))) {
if (dataBuffer && CFDataGetLength(dataBuffer)) {
*data = CFPropertyListCreateWithData(0, dataBuffer, kCFPropertyListImmutable, NULL, NULL);
} else {
*data = CFDictionaryCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
return kAMDSuccess;
} else {
return kAMDNotConnectedError;
}
}
/*! Creates a discovery record from an external data representation.
* @param data data used to construct an iSCSI discovery object.
* @return an iSCSI discovery object or NULL if object creation failed */
iSCSIMutableDiscoveryRecRef iSCSIDiscoveryRecCreateMutableWithData(CFDataRef data)
{
CFPropertyListFormat format;
iSCSIMutableDiscoveryRecRef discoveryRec = (iSCSIMutableDiscoveryRecRef)
CFPropertyListCreateWithData(kCFAllocatorDefault,data,kCFPropertyListImmutable,&format,NULL);
if(format == kCFPropertyListBinaryFormat_v1_0)
return discoveryRec;
if(discoveryRec)
CFRelease(discoveryRec);
return NULL;
}
static CFDictionaryRef
__copyTemplates()
{
CFBundleRef bundle;
CFErrorRef error = NULL;
Boolean ok;
CFDictionaryRef templates;
CFURLRef url;
CFDataRef xmlTemplates = NULL;
bundle = _SC_CFBundleGet();
if (bundle == NULL) {
return NULL;
}
url = CFBundleCopyResourceURL(bundle, CFSTR("NetworkConfiguration"), CFSTR("plist"), NULL);
if (url == NULL) {
return NULL;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated"
ok = CFURLCreateDataAndPropertiesFromResource(NULL, url, &xmlTemplates, NULL, NULL, NULL);
#pragma GCC diagnostic pop
CFRelease(url);
if (!ok || (xmlTemplates == NULL)) {
return NULL;
}
// convert the XML data into a property list
templates = CFPropertyListCreateWithData(NULL, xmlTemplates, kCFPropertyListImmutable, NULL, &error);
CFRelease(xmlTemplates);
if (templates == NULL) {
if (error != NULL) {
SCLog(TRUE, LOG_DEBUG, CFSTR("could not load SCNetworkConfiguration templates: %@"), error);
CFRelease(error);
}
return NULL;
}
if (!isA_CFDictionary(templates)) {
CFRelease(templates);
return NULL;
}
return templates;
}
sdmmd_return_t SDMMD_ServiceReceiveMessage(SocketConnection handle, CFPropertyListRef *data) {
CFDataRef dataBuffer = NULL;
sdmmd_return_t result;
result = SDMMD_ServiceReceive(handle, &dataBuffer);
if (result == kAMDSuccess) {
if (dataBuffer && CFDataGetLength(dataBuffer)) {
*data = CFPropertyListCreateWithData(kCFAllocatorDefault, dataBuffer, kCFPropertyListImmutable, NULL, NULL);
}
else {
*data = CFDictionaryCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
result = kAMDInvalidResponseError;
}
}
return result;
}
int main(int argc, char **argv) {
if (argc != 3) {
printf("Usage: plconvert <in file> <out file>\nIf the in file is an XML property list, convert to binary property list in out file. If the in file is a binary property list, convert to XML property list in out file.\n");
} else {
CFMutableDataRef plistData = createDataFromFile(argv[1]);
if (!plistData) {
printf("Unable to create data from file name: %s", argv[1]);
} else {
CFPropertyListFormat fmt;
CFErrorRef err;
CFPropertyListRef plist = CFPropertyListCreateWithData(kCFAllocatorSystemDefault, (CFDataRef)plistData, 0, &fmt, &err);
if (!plist) {
logIt(CFSTR("Unable to create property list from data: %@"), err);
} else {
logIt(CFSTR("Property list contents:\n%@"), plist);
if (fmt == kCFPropertyListBinaryFormat_v1_0) {
logIt(CFSTR("Converting to XML property list at: %s"), argv[2]);
fmt = kCFPropertyListXMLFormat_v1_0;
} else if (fmt == kCFPropertyListXMLFormat_v1_0) {
logIt(CFSTR("Converting to binary property list at: %s"), argv[2]);
fmt = kCFPropertyListBinaryFormat_v1_0;
} else {
logIt(CFSTR("Unknown property list format! Not converting output format."));
}
CFDataRef outputData = CFPropertyListCreateData(kCFAllocatorSystemDefault, plist, fmt, 0, &err);
if (!outputData) {
logIt(CFSTR("Unable to write property list to data: %@"), err);
} else {
bool success = writeDataToFile(outputData, argv[2]);
if (!success) {
logIt(CFSTR("Unable to write data to file"));
}
CFRelease(outputData);
}
CFRelease(plist);
}
CFRelease(plistData);
}
}
}
bool ReceiptsDb::getInstalledPackageInfo(const char* identifier, ReceiptsDb::InstalledPackageInfo& info)
{
std::string path;
CFDataRef data;
CFDateRef date;
CFDictionaryRef plist;
std::unique_ptr<Reader> fileReader;
std::unique_ptr<UInt8[]> fileData;
path = getReceiptsPath(identifier, ".plist");
if (::access(path.c_str(), F_OK) != 0)
return false;
fileReader.reset(new FileReader(path));
fileData.reset(new UInt8[fileReader->length()]);
if (fileReader->read(fileData.get(), fileReader->length(), 0) != fileReader->length())
throw std::runtime_error("Short read in getInstalledPackageInfo()");
data = CFDataCreate(nullptr, fileData.get(), fileReader->length());
fileData.reset(nullptr);
plist = (CFDictionaryRef) CFPropertyListCreateWithData(nullptr, data,
kCFPropertyListImmutable, nullptr, nullptr);
CFRelease(data);
if (plist == nullptr)
throw std::runtime_error("Failed to parse plist in getInstalledPackageInfo()");
info.identifier = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("PackageIdentifier")));
info.version = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("PackageVersion")));
info.prefixPath = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("InstallPrefixPath")));
info.installProcessName = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("InstallProcessName")));
info.packageFileName = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("PackageFileName")));
date = (CFDateRef) CFDictionaryGetValue(plist, CFSTR("InstallDate"));
info.installDate = CFDateGetAbsoluteTime(date);
CFRelease(plist);
return true;
}
/*! Creates a dictionary of connection parameters for the connection associated
* with the specified target and portal, if one exists.
* @param handle a handle to a daemon connection.
* @param target the target associated with the the specified portal.
* @param portal the portal to check for active connections to generate
* a dictionary of connection parameters.
* @return a dictionary of connection properties. */
CFDictionaryRef iSCSIDaemonCreateCFPropertiesForConnection(iSCSIDaemonHandle handle,
iSCSITargetRef target,
iSCSIPortalRef portal)
{
// Validate inputs
if(handle < 0 || !target || !portal)
return NULL;
CFDictionaryRef properties = NULL;
CFDataRef targetData = iSCSITargetCreateData(target);
CFDataRef portalData = iSCSIPortalCreateData(portal);
// Send command to daemon
iSCSIDMsgCreateCFPropertiesForConnectionCmd cmd = iSCSIDMsgCreateCFPropertiesForConnectionCmdInit;
cmd.targetLength = (UInt32)CFDataGetLength(targetData);
cmd.portalLength = (UInt32)CFDataGetLength(portalData);
errno_t error = iSCSIDaemonSendMsg(handle,(iSCSIDMsgGeneric *)&cmd,
targetData,portalData,NULL);
CFRelease(targetData);
CFRelease(portalData);
iSCSIDMsgCreateCFPropertiesForConnectionRsp rsp;
if(!error)
error = iSCSIDaemonRecvMsg(handle,(iSCSIDMsgGeneric*)&rsp,NULL);
if(!error) {
CFDataRef data = NULL;
error = iSCSIDaemonRecvMsg(handle,0,&data,rsp.dataLength,NULL);
if(!error && data) {
CFPropertyListFormat format;
properties = CFPropertyListCreateWithData(kCFAllocatorDefault,data,0,&format,NULL);
CFRelease(data);
}
}
return properties;
}
/*! Creates an array of active portal objects.
* @param target the target to retrieve active portals.
* @param handle a handle to a daemon connection.
* @return an array of active target objects or NULL if no targets are active. */
CFArrayRef iSCSIDaemonCreateArrayOfActivePortalsForTarget(iSCSIDaemonHandle handle,
iSCSITargetRef target)
{
// Validate inputs
if(handle < 0)
return NULL;
CFArrayRef activePortals = NULL;
errno_t error = 0;
// Send command to daemon
iSCSIDMsgCreateArrayOfActivePortalsForTargetCmd cmd = iSCSIDMsgCreateArrayOfActivePortalsForTargetCmdInit;
if(send(handle,&cmd,sizeof(cmd),0) != sizeof(cmd))
error = EIO;
iSCSIDMsgCreateArrayOfActivePortalsForTargetRsp rsp;
if(!error)
error = iSCSIDaemonRecvMsg(handle,(iSCSIDMsgGeneric*)&rsp,NULL);
if(!error) {
CFDataRef data = NULL;
error = iSCSIDaemonRecvMsg(handle,0,&data,rsp.dataLength,NULL);
if(!error && data) {
CFPropertyListFormat format;
activePortals = CFPropertyListCreateWithData(kCFAllocatorDefault,data,0,&format,NULL);
CFRelease(data);
if(format != kCFPropertyListBinaryFormat_v1_0) {
if(activePortals) {
CFRelease(activePortals);
activePortals = NULL;
}
}
}
}
return activePortals;
}
CFStringRef createXMLStringFromWebArchiveData(CFDataRef webArchiveData)
{
CFErrorRef error = 0;
CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0;
RetainPtr<CFMutableDictionaryRef> propertyList = adoptCF((CFMutableDictionaryRef)CFPropertyListCreateWithData(kCFAllocatorDefault, webArchiveData, kCFPropertyListMutableContainersAndLeaves, &format, &error));
if (!propertyList) {
if (error)
return CFErrorCopyDescription(error);
return static_cast<CFStringRef>(CFRetain(CFSTR("An unknown error occurred converting data to property list.")));
}
RetainPtr<CFMutableArrayRef> resources = adoptCF(CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks));
CFArrayAppendValue(resources.get(), propertyList.get());
while (CFArrayGetCount(resources.get())) {
RetainPtr<CFMutableDictionaryRef> resourcePropertyList = (CFMutableDictionaryRef)CFArrayGetValueAtIndex(resources.get(), 0);
CFArrayRemoveValueAtIndex(resources.get(), 0);
CFMutableDictionaryRef mainResource = (CFMutableDictionaryRef)CFDictionaryGetValue(resourcePropertyList.get(), CFSTR("WebMainResource"));
normalizeWebResourceURL((CFMutableStringRef)CFDictionaryGetValue(mainResource, CFSTR("WebResourceURL")));
convertWebResourceDataToString(mainResource);
// Add subframeArchives to list for processing
CFMutableArrayRef subframeArchives = (CFMutableArrayRef)CFDictionaryGetValue(resourcePropertyList.get(), CFSTR("WebSubframeArchives")); // WebSubframeArchivesKey in WebArchive.m
if (subframeArchives)
CFArrayAppendArray(resources.get(), subframeArchives, CFRangeMake(0, CFArrayGetCount(subframeArchives)));
CFMutableArrayRef subresources = (CFMutableArrayRef)CFDictionaryGetValue(resourcePropertyList.get(), CFSTR("WebSubresources")); // WebSubresourcesKey in WebArchive.m
if (!subresources)
continue;
CFIndex subresourcesCount = CFArrayGetCount(subresources);
for (CFIndex i = 0; i < subresourcesCount; ++i) {
CFMutableDictionaryRef subresourcePropertyList = (CFMutableDictionaryRef)CFArrayGetValueAtIndex(subresources, i);
normalizeWebResourceURL((CFMutableStringRef)CFDictionaryGetValue(subresourcePropertyList, CFSTR("WebResourceURL")));
convertWebResourceResponseToDictionary(subresourcePropertyList);
convertWebResourceDataToString(subresourcePropertyList);
}
// Sort the subresources so they're always in a predictable order for the dump
CFArraySortValues(subresources, CFRangeMake(0, CFArrayGetCount(subresources)), compareResourceURLs, 0);
}
error = 0;
RetainPtr<CFDataRef> xmlData = adoptCF(CFPropertyListCreateData(kCFAllocatorDefault, propertyList.get(), kCFPropertyListXMLFormat_v1_0, 0, &error));
if (!xmlData) {
if (error)
return CFErrorCopyDescription(error);
return static_cast<CFStringRef>(CFRetain(CFSTR("An unknown error occurred converting property list to data.")));
}
RetainPtr<CFStringRef> xmlString = adoptCF(CFStringCreateFromExternalRepresentation(kCFAllocatorDefault, xmlData.get(), kCFStringEncodingUTF8));
RetainPtr<CFMutableStringRef> string = adoptCF(CFStringCreateMutableCopy(kCFAllocatorDefault, 0, xmlString.get()));
// Replace "Apple Computer" with "Apple" in the DTD declaration.
CFStringFindAndReplace(string.get(), CFSTR("-//Apple Computer//"), CFSTR("-//Apple//"), CFRangeMake(0, CFStringGetLength(string.get())), 0);
return string.leakRef();
}
void CASettingsStorage::RefreshSettings()
{
// if this storage is only supporting a single file, there is no need to hit the disk unless
// required to by it being the first time or if the refresh is specifically forced for some reason
if(!mIsSingleProcessOnly || (mSettingsCache == NULL) || ((mSettingsCacheTime.tv_sec == 0) && (mSettingsCacheTime.tv_nsec == 0)) || mSettingsCacheForceRefresh)
{
// first, we need to stat the file to check the mod date, this has the side effect of also
// telling us if the file exisits
struct stat theFileInfo;
int theStatError = stat(mSettingsFilePath, &theFileInfo);
// we use this boolean to make error recovery easier since we need a case for when there's no file anyway
bool theSettingsWereCached = false;
bool theSettingsNeedSaving = true;
if(theStatError == 0)
{
// stat says there is something there, only have to do work if we either don't have a cache or the cache is out of date
if((mSettingsCache == NULL) || (mSettingsCacheTime < theFileInfo.st_mtimespec) || mSettingsCacheForceRefresh)
{
// open the file
FILE* theFile = fopen(mSettingsFilePath, "r");
if(theFile != NULL)
{
// lock the file (this call blocks until the lock is taken)
int theError = flock(fileno(theFile), LOCK_EX);
if(theError == 0)
{
// get the length of the file
fseek(theFile, 0, SEEK_END);
size_t theFileLength = ftell(theFile);
fseek(theFile, 0, SEEK_SET);
if(theFileLength > 0)
{
// allocate a block of memory to hold the data in the file
CAAutoFree<Byte> theRawFileData(theFileLength);
// read all the data in
fread(static_cast<Byte*>(theRawFileData), theFileLength, 1, theFile);
// release the lock
flock(fileno(theFile), LOCK_UN);
// put it into a CFData object
CACFData theRawFileDataCFData(static_cast<Byte*>(theRawFileData), static_cast<UInt32>(theFileLength));
// get rid of the existing cache
if(mSettingsCache != NULL)
{
CFRelease(mSettingsCache);
mSettingsCache = NULL;
}
// parse the data as a property list
mSettingsCache = (CFMutableDictionaryRef)CFPropertyListCreateWithData(NULL, theRawFileDataCFData.GetCFData(), kCFPropertyListMutableContainersAndLeaves, NULL, NULL);
// check to be sure we parsed a plist out of the file
if(mSettingsCache != NULL)
{
// save the date of the cache
mSettingsCacheTime = theFileInfo.st_mtimespec;
// mark that we're done
theSettingsWereCached = true;
theSettingsNeedSaving = false;
}
}
}
// close the file
fclose(theFile);
mSettingsCacheForceRefresh = false;
}
}
else
{
// nothing to do since the file was older than the cached data
theSettingsNeedSaving = false;
theSettingsWereCached = true;
}
}
// if there was a failure, we need to clean up
if((theStatError != 0) || theSettingsNeedSaving || !theSettingsWereCached)
{
// we get here if either there isn't a file or something wacky happenned while parsing it
// all we do here is make sure that the member variables are set to their initial values
if(mSettingsCache != NULL)
{
CFRelease(mSettingsCache);
mSettingsCache = NULL;
}
mSettingsCache = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
mSettingsCacheTime.tv_sec = 0;
mSettingsCacheTime.tv_nsec = 0;
if((theStatError != 0) || theSettingsNeedSaving)
{
SaveSettings();
}
}
}
}
void setupAUGraph(MyMIDIPlayer *player) {
CheckError(NewAUGraph(&player->graph),
"Couldn't open AU Graph");
// generate description that will match our output device (speakers)
AudioComponentDescription outputcd = {0};
outputcd.componentType = kAudioUnitType_Output;
outputcd.componentSubType = kAudioUnitSubType_DefaultOutput;
outputcd.componentManufacturer = kAudioUnitManufacturer_Apple;
// adds a node with above description to the graph
AUNode outputNode;
CheckError(AUGraphAddNode(player->graph, &outputcd, &outputNode),
"AUGraphAddNode[kAudioUnitSubType_DefaultOutput] failed");
AudioComponentDescription instrumentcd = {0};
instrumentcd.componentManufacturer = kAudioUnitManufacturer_Apple;
instrumentcd.componentType = kAudioUnitType_MusicDevice;
instrumentcd.componentSubType = kAudioUnitSubType_Sampler; // changed!
AUNode instrumentNode;
CheckError(AUGraphAddNode(player->graph, &instrumentcd, &instrumentNode),
"AUGraphAddNode[kAudioUnitSubType_DLSSynth] failed");
// opening the graph opens all contained audio units but does not allocate any resources yet
CheckError(AUGraphOpen(player->graph),
"AUGraphOpen failed");
// get the reference to the AudioUnit object for the instrument graph node
CheckError(AUGraphNodeInfo(player->graph, instrumentNode, NULL, &player->instrumentUnit),
"AUGraphNodeInfo failed");
// connect the output source of the instrument AU to the input source of the output node
CheckError(AUGraphConnectNodeInput(player->graph, instrumentNode, 0, outputNode, 0),
"AUGraphConnectNodeInput");
// now initialize the graph (causes resources to be allocated)
CheckError(AUGraphInitialize(player->graph),
"AUGraphInitialize failed");
// configure the AUSampler
// 2nd parameter obviously needs to be a full path on your system, and 3rd param is its length in characters
CFURLRef presetURL = CFURLCreateFromFileSystemRepresentation(
kCFAllocatorDefault,
"/Users/cadamson/Library/Audio/Presets/Apple/AUSampler/ch12-aupreset.aupreset",
77,
false);
// load preset file into a CFDataRef
CFDataRef presetData = NULL;
SInt32 errorCode = noErr;
Boolean gotPresetData =
CFURLCreateDataAndPropertiesFromResource(kCFAllocatorSystemDefault,
presetURL,
&presetData,
NULL,
NULL,
&errorCode);
CheckError(errorCode, "couldn't load .aupreset data");
CheckError(!gotPresetData, "couldn't load .aupreset data");
// convert this into a property list
CFPropertyListFormat presetPlistFormat = {0};
CFErrorRef presetPlistError = NULL;
CFPropertyListRef presetPlist = CFPropertyListCreateWithData(kCFAllocatorSystemDefault,
presetData,
kCFPropertyListImmutable,
&presetPlistFormat,
&presetPlistError);
if (presetPlistError) {
printf ("Couldn't create plist object for .aupreset");
return;
}
// set this plist as the kAudioUnitProperty_ClassInfo on _auSampler
if (presetPlist) {
CheckError(AudioUnitSetProperty(player->instrumentUnit,
kAudioUnitProperty_ClassInfo,
kAudioUnitScope_Global,
0,
&presetPlist,
sizeof(presetPlist)),
"Couldn't set aupreset plist as sampler's class info");
}
}
__private_extern__ void
__SCPreferencesAccess(SCPreferencesRef prefs)
{
CFAllocatorRef allocator = CFGetAllocator(prefs);
int fd = -1;
SCPreferencesPrivateRef prefsPrivate = (SCPreferencesPrivateRef)prefs;
struct stat statBuf;
if (prefsPrivate->accessed) {
// if preference data has already been accessed
return;
}
if (!prefsPrivate->authorizationRequired) {
if (access(prefsPrivate->path, R_OK) == 0) {
fd = open(prefsPrivate->path, O_RDONLY, 0644);
} else {
fd = -1;
}
} else {
errno = EACCES;
}
if (fd != -1) {
// create signature
if (fstat(fd, &statBuf) == -1) {
SCLog(TRUE, LOG_ERR, CFSTR("__SCPreferencesAccess fstat() failed: %s"), strerror(errno));
bzero(&statBuf, sizeof(statBuf));
}
} else {
switch (errno) {
case ENOENT :
/* no preference data, start fresh */
break;
case EPERM :
case EACCES :
if (prefsPrivate->authorizationData != NULL) {
if (__SCPreferencesAccess_helper(prefs)) {
goto done;
} else {
SCLog(TRUE, LOG_ERR,
CFSTR("__SCPreferencesAccess_helper() failed: %s"),
SCErrorString(SCError()));
}
break;
}
// fall through
default :
SCLog(TRUE, LOG_ERR, CFSTR("__SCPreferencesAccess open() failed: %s"), strerror(errno));
break;
}
bzero(&statBuf, sizeof(statBuf));
}
if (prefsPrivate->signature != NULL) CFRelease(prefsPrivate->signature);
prefsPrivate->signature = __SCPSignatureFromStatbuf(&statBuf);
if (statBuf.st_size > 0) {
CFDictionaryRef dict;
CFErrorRef error = NULL;
CFMutableDataRef xmlData;
/*
* extract property list
*/
xmlData = CFDataCreateMutable(allocator, (CFIndex)statBuf.st_size);
CFDataSetLength(xmlData, (CFIndex)statBuf.st_size);
if (read(fd, (void *)CFDataGetBytePtr(xmlData), (CFIndex)statBuf.st_size) != (CFIndex)statBuf.st_size) {
/* corrupt prefs file, start fresh */
SCLog(_sc_verbose, LOG_DEBUG, CFSTR("__SCPreferencesAccess read(): could not load preference data."));
CFRelease(xmlData);
xmlData = NULL;
goto done;
}
/*
* load preferences
*/
dict = CFPropertyListCreateWithData(allocator, xmlData, kCFPropertyListImmutable, NULL, &error);
CFRelease(xmlData);
if (dict == NULL) {
/* corrupt prefs file, start fresh */
if (error != NULL) {
SCLog(TRUE, LOG_ERR,
CFSTR("__SCPreferencesAccess CFPropertyListCreateWithData(): %@"),
error);
CFRelease(error);
}
goto done;
}
/*
* make sure that we've got a dictionary
*/
if (!isA_CFDictionary(dict)) {
/* corrupt prefs file, start fresh */
SCLog(_sc_verbose, LOG_DEBUG, CFSTR("__SCPreferencesAccess CFGetTypeID(): not a dictionary."));
CFRelease(dict);
goto done;
}
prefsPrivate->prefs = CFDictionaryCreateMutableCopy(allocator, 0, dict);
CFRelease(dict);
}
done :
if (fd != -1) {
(void) close(fd);
}
if (prefsPrivate->prefs == NULL) {
/*
* new file, create empty preferences
*/
// SCLog(_sc_verbose, LOG_DEBUG, CFSTR("__SCPreferencesAccess(): creating new preferences file."));
prefsPrivate->prefs = CFDictionaryCreateMutable(allocator,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
prefsPrivate->changed = TRUE;
}
prefsPrivate->accessed = TRUE;
return;
}
/* OS X only: __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_NA) */
OSStatus
SecTrustSetOptions(SecTrustRef trustRef, SecTrustOptionFlags options)
{
/* bridge to support API functionality for legacy callers */
OSStatus status = errSecSuccess;
CFDataRef encodedExceptions = SecTrustCopyExceptions(trustRef);
CFArrayRef exceptions = NULL,
oldExceptions = SecTrustGetTrustExceptionsArray(trustRef);
if (encodedExceptions) {
exceptions = (CFArrayRef)CFPropertyListCreateWithData(kCFAllocatorDefault,
encodedExceptions, kCFPropertyListImmutable, NULL, NULL);
CFRelease(encodedExceptions);
encodedExceptions = NULL;
}
if (exceptions && CFGetTypeID(exceptions) != CFArrayGetTypeID()) {
CFRelease(exceptions);
exceptions = NULL;
}
if (oldExceptions && exceptions &&
CFArrayGetCount(oldExceptions) > CFArrayGetCount(exceptions)) {
oldExceptions = NULL;
}
/* verify both exceptions are for the same leaf */
if (oldExceptions && exceptions && CFArrayGetCount(oldExceptions) > 0) {
CFDictionaryRef oldLeafExceptions = (CFDictionaryRef)CFArrayGetValueAtIndex(oldExceptions, 0);
CFDictionaryRef leafExceptions = (CFDictionaryRef)CFArrayGetValueAtIndex(exceptions, 0);
CFDataRef oldDigest = (CFDataRef)CFDictionaryGetValue(oldLeafExceptions, CFSTR("SHA1Digest"));
CFDataRef digest = (CFDataRef)CFDictionaryGetValue(leafExceptions, CFSTR("SHA1Digest"));
if (!oldDigest || !digest || !CFEqual(oldDigest, digest)) {
oldExceptions = NULL;
}
}
/* add only those exceptions which are allowed by the supplied options */
if (exceptions) {
CFMutableArrayRef filteredExceptions = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
CFIndex i, exceptionCount = (filteredExceptions) ? CFArrayGetCount(exceptions) : 0;
for (i = 0; i < exceptionCount; ++i) {
CFDictionaryRef exception = (CFDictionaryRef)CFArrayGetValueAtIndex(exceptions, i);
CFDictionaryRef oldException = NULL;
if (oldExceptions && i < CFArrayGetCount(oldExceptions)) {
oldException = (CFDictionaryRef)CFArrayGetValueAtIndex(oldExceptions, i);
}
CFMutableDictionaryRef filteredException = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (exception && filteredException) {
SecExceptionFilterContext filterContext = { options, i, trustRef, filteredException, oldException };
CFDictionaryApplyFunction(exception, filter_exception, &filterContext);
CFArrayAppendValue(filteredExceptions, filteredException);
CFRelease(filteredException);
}
}
if (filteredExceptions) {
CFIndex filteredCount = CFArrayGetCount(filteredExceptions);
/* remove empty trailing entries to match iOS behavior */
for (i = filteredCount; i-- > 1;) {
CFDictionaryRef exception = (CFDictionaryRef)CFArrayGetValueAtIndex(filteredExceptions, i);
if (CFDictionaryGetCount(exception) == 0) {
CFArrayRemoveValueAtIndex(filteredExceptions, i);
} else {
break;
}
}
encodedExceptions = CFPropertyListCreateData(kCFAllocatorDefault,
filteredExceptions, kCFPropertyListBinaryFormat_v1_0, 0, NULL);
CFRelease(filteredExceptions);
SecTrustSetExceptions(trustRef, encodedExceptions);
CFRelease(encodedExceptions);
}
CFRelease(exceptions);
}
#if SECTRUST_DEPRECATION_WARNINGS
bool displayModifyMsg = false;
bool displayNetworkMsg = false;
bool displayPolicyMsg = false;
const char *baseMsg = "WARNING: SecTrustSetOptions called with";
const char *modifyMsg = "Use SecTrustSetExceptions and SecTrustCopyExceptions to modify default trust results.";
const char *networkMsg = "Use SecTrustSetNetworkFetchAllowed to specify whether missing certificates can be fetched from the network.";
const char *policyMsg = "Use SecPolicyCreateRevocation to specify revocation policy requirements.";
if (options & kSecTrustOptionAllowExpired) {
syslog(LOG_ERR, "%s %s.", baseMsg, "kSecTrustOptionAllowExpired");
displayModifyMsg = true;
}
if (options & kSecTrustOptionAllowExpiredRoot) {
syslog(LOG_ERR, "%s %s.", baseMsg, "kSecTrustOptionAllowExpiredRoot");
displayModifyMsg = true;
}
if (options & kSecTrustOptionFetchIssuerFromNet) {
syslog(LOG_ERR, "%s %s.", baseMsg, "kSecTrustOptionFetchIssuerFromNet");
displayNetworkMsg = true;
}
if (options & kSecTrustOptionRequireRevPerCert) {
syslog(LOG_ERR, "%s %s.", baseMsg, "kSecTrustOptionRequireRevPerCert");
displayPolicyMsg = true;
}
if (displayModifyMsg || displayNetworkMsg || displayPolicyMsg) {
syslog(LOG_ERR, "%s %s %s",
(displayModifyMsg) ? modifyMsg : "",
(displayNetworkMsg) ? networkMsg : "",
(displayPolicyMsg) ? policyMsg : "");
}
#endif
return status;
}
//-----------------------------------------------------------------------------
bool LoadAsioLibInfo(CFURLRef asioLibUrl, AsioLibInfo & buffer)
{
CFDataRef resourceData;
SInt32 errorCode;
Boolean status;
CFErrorRef errorRef;
CFPropertyListRef propertyList;
Boolean ok;
const void * val;
buffer.Number = 0;
memset(buffer.Id, '\0', ASIO_LIB_ID_CAPACITY);
memset(buffer.DisplayName, '\0', ASIO_LIB_DISPLAYNAME_CAPACITY);
memset(buffer.Company, '\0', ASIO_LIB_COMPANY_CAPACITY);
memset(buffer.InstallFolder, '\0', ASIO_LIB_FOLDER_CAPACITY);
memset(buffer.Architectures, '\0', ASIO_LIB_ARCHITECTURES_CAPACITY);
status = CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, asioLibUrl, &resourceData, NULL, NULL, &errorCode);
if ( ! status ) {
return false;
}
errorRef = NULL;
propertyList = CFPropertyListCreateWithData(kCFAllocatorDefault, resourceData, kCFPropertyListImmutable, NULL, &errorRef);
if (propertyList) {
// name
ok = CFDictionaryGetValueIfPresent((CFDictionaryRef)propertyList, CFSTR("Name"), &val);
if (ok) {
if (val) {
/*ok =*/ CFStringGetCString((CFStringRef)val, buffer.Id, ASIO_LIB_ID_CAPACITY, kCFStringEncodingASCII);
}
}
ok = CFDictionaryGetValueIfPresent((CFDictionaryRef)propertyList, CFSTR("Number"), &val);
if (ok) {
if (val) {
/*ok =*/ CFNumberGetValue((CFNumberRef)val, kCFNumberSInt32Type, &buffer.Number);
}
}
// number
// display name
ok = CFDictionaryGetValueIfPresent((CFDictionaryRef)propertyList, CFSTR("DisplayName"), &val);
if (ok) {
if (val) {
/*ok =*/ CFStringGetCString((CFStringRef)val, buffer.DisplayName, ASIO_LIB_DISPLAYNAME_CAPACITY, kCFStringEncodingASCII);
}
}
// company
ok = CFDictionaryGetValueIfPresent((CFDictionaryRef)propertyList, CFSTR("Company"), &val);
if (ok) {
if (val) {
/*ok =*/ CFStringGetCString((CFStringRef)val, buffer.Company, ASIO_LIB_COMPANY_CAPACITY, kCFStringEncodingASCII);
}
}
// installation folder
ok = CFDictionaryGetValueIfPresent((CFDictionaryRef)propertyList, CFSTR("InstallationFolder"), &val);
if (ok) {
if (val) {
/*ok =*/ CFStringGetCString((CFStringRef)val, buffer.InstallFolder, ASIO_LIB_FOLDER_CAPACITY, kCFStringEncodingASCII);
}
}
// build architectures
ok = CFDictionaryGetValueIfPresent((CFDictionaryRef)propertyList, CFSTR("Architectures"), &val);
if (ok) {
if (val) {
/*ok =*/ CFStringGetCString((CFStringRef)val, buffer.Architectures, ASIO_LIB_ARCHITECTURES_CAPACITY, kCFStringEncodingASCII);
}
}
}
// cleanup
CFRelease(resourceData);
if (errorRef) {
CFRelease(errorRef);
}
if (propertyList) {
CFRelease(propertyList);
}
// Id and DisplayName are mandatory, other fields are optional
return (strlen(buffer.Id) > 0) && (strlen(buffer.DisplayName) > 0);
}
static CFStringRef _copyStringFromTable(CFBundleRef bundle, CFStringRef tableName, CFStringRef key, CFStringRef localizationName) {
// Check the cache first. If it's not there, populate the cache and check again.
__CFLock(&bundle->_lock);
// Only consult the cache when a specific localization has not been requested. We only cache results for the preferred language as determined by normal bundle lookup rules.
if (!localizationName && bundle->_stringTable) {
CFDictionaryRef stringTable = (CFDictionaryRef)CFDictionaryGetValue(bundle->_stringTable, tableName);
if (stringTable) {
CFStringRef result = CFDictionaryGetValue(stringTable, key);
if (result) {
CFRetain(result);
}
__CFUnlock(&bundle->_lock);
return result;
}
}
// Not in the local cache, so load the table. Unlock so we don't hold the lock across file system access.
__CFUnlock(&bundle->_lock);
CFDictionaryRef stringsTable = NULL;
CFURLRef stringsTableURL = NULL;
CFURLRef stringsDictTableURL = NULL;
// Find the resource URL.
if (localizationName) {
stringsTableURL = CFBundleCopyResourceURLForLocalization(bundle, tableName, _CFBundleStringTableType, NULL, localizationName);
stringsDictTableURL = CFBundleCopyResourceURLForLocalization(bundle, tableName, _CFBundleStringDictTableType, NULL, localizationName);
} else {
stringsTableURL = CFBundleCopyResourceURL(bundle, tableName, _CFBundleStringTableType, NULL);
stringsDictTableURL = CFBundleCopyResourceURL(bundle, tableName, _CFBundleStringDictTableType, NULL);
}
// Next, look on disk for the regular strings file.
if (!stringsTable && stringsTableURL) {
CFDataRef tableData = _CFDataCreateFromURL(stringsTableURL, NULL);
if (tableData) {
CFErrorRef error = NULL;
stringsTable = (CFDictionaryRef)CFPropertyListCreateWithData(CFGetAllocator(bundle), tableData, kCFPropertyListImmutable, NULL, &error);
CFRelease(tableData);
if (stringsTable && CFDictionaryGetTypeID() != CFGetTypeID(stringsTable)) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .strings file: %@ / %@: Top-level object was not a dictionary", bundle, tableName);
CFRelease(stringsTable);
stringsTable = NULL;
} else if (!stringsTable && error) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .strings file: %@ / %@: %@", bundle, tableName, error);
CFRelease(error);
error = NULL;
}
}
}
// Check for a .stringsdict file.
if (stringsDictTableURL) {
CFDataRef tableData = _CFDataCreateFromURL(stringsDictTableURL, NULL);
if (tableData) {
CFErrorRef error = NULL;
CFDictionaryRef stringsDictTable = (CFDictionaryRef)CFPropertyListCreateWithData(CFGetAllocator(bundle), tableData, kCFPropertyListImmutable, NULL, &error);
CFRelease(tableData);
if (!stringsDictTable && error) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .stringsdict file: %@ / %@: %@", bundle, tableName, error);
CFRelease(error);
error = NULL;
} else if (stringsDictTable && CFDictionaryGetTypeID() != CFGetTypeID(stringsDictTable)) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .stringsdict file: %@ / %@: Top-level object was not a dictionary", bundle, tableName);
CFRelease(stringsDictTable);
stringsDictTable = NULL;
} else if (stringsDictTable) {
// Post-process the strings table.
CFMutableDictionaryRef mutableStringsDictTable;
if (stringsTable) {
// Any strings that are in the stringsTable that are not in the stringsDict must be added to the stringsDict.
// However, any entry in the stringsDictTable must override the content from stringsTable.
// Start by copying the stringsTable.
mutableStringsDictTable = CFDictionaryCreateMutableCopy(NULL, 0, stringsTable);
// Replace any stringsTable entries with entries from stringsDictTable. This will override any entries from the original stringsTable if they existed.
CFDictionaryApplyFunction(stringsDictTable, __CFStringsDictMergeApplyFunction, mutableStringsDictTable);
} else {
// Start with a copy of the stringsDictTable on its own.
mutableStringsDictTable = CFDictionaryCreateMutableCopy(NULL, 0, stringsDictTable);
}
CFRelease(stringsDictTable);
if (stringsTable) CFRelease(stringsTable);
// The new strings table is the result of all the transforms above.
stringsTable = mutableStringsDictTable;
}
}
}
if (stringsTableURL) CFRelease(stringsTableURL);
if (stringsDictTableURL) CFRelease(stringsDictTableURL);
// Last resort: create an empty table
if (!stringsTable) {
os_log_debug(_CFBundleLocalizedStringLogger(), "Hit last resort and creating empty strings table");
stringsTable = CFDictionaryCreate(CFGetAllocator(bundle), NULL, NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
// Insert the result into our local cache
if ((!CFStringHasSuffix(tableName, CFSTR(".nocache")) || !_CFExecutableLinkedOnOrAfter(CFSystemVersionLeopard)) && localizationName == NULL) {
// Take lock again, because this we will unlock after getting the value out of the table.
__CFLock(&bundle->_lock);
if (!bundle->_stringTable) bundle->_stringTable = CFDictionaryCreateMutable(CFGetAllocator(bundle), 0, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
// If another thread beat us to setting this tableName, then we'll just replace it here.
CFDictionarySetValue(bundle->_stringTable, tableName, stringsTable);
} else {
// Take lock again, because this we will unlock after getting the value out of the table.
__CFLock(&bundle->_lock);
}
// Finally, fetch the result from the table
CFStringRef result = CFDictionaryGetValue(stringsTable, key);
if (result) {
CFRetain(result);
}
__CFUnlock(&bundle->_lock);
CFRelease(stringsTable);
return result;
}
kern_return_t
_io_pm_schedule_repeat_event
(
mach_port_t server __unused,
audit_token_t token,
vm_offset_t flatPackage,
mach_msg_type_number_t packageLen,
int action,
int *return_code
)
{
CFDictionaryRef events = NULL;
CFDictionaryRef offEvents = NULL;
CFDictionaryRef onEvents = NULL;
CFDataRef dataRef = NULL;
uid_t callerEUID;
SCPreferencesRef prefs = 0;
CFStringRef prevOffType = NULL;
CFStringRef prevOnType = NULL;
CFStringRef newOffType = NULL;
CFStringRef newOnType = NULL;
*return_code = kIOReturnSuccess;
audit_token_to_au32(token, NULL, &callerEUID, NULL, NULL, NULL, NULL, NULL, NULL);
dataRef = CFDataCreate(0, (const UInt8 *)flatPackage, packageLen);
if (dataRef) {
events = (CFDictionaryRef)CFPropertyListCreateWithData(0, dataRef, 0, NULL, NULL);
}
if (!events) {
*return_code = kIOReturnBadArgument;
goto exit;
}
offEvents = isA_CFDictionary(CFDictionaryGetValue(
events,
CFSTR(kIOPMRepeatingPowerOffKey)));
onEvents = isA_CFDictionary(CFDictionaryGetValue(
events,
CFSTR(kIOPMRepeatingPowerOnKey)));
if( !is_valid_repeating_dictionary(offEvents)
|| !is_valid_repeating_dictionary(onEvents) )
{
syslog(LOG_INFO, "PMCFGD: Invalid formatted repeating power event dictionary\n");
*return_code = kIOReturnBadArgument;
goto exit;
}
if((*return_code = createSCSession(&prefs, callerEUID, 1)) != kIOReturnSuccess)
goto exit;
/* Need to take a retain on these strings as these dictionaries get released below */
prevOffType = getRepeatingDictionaryType(repeatingPowerOff); CFRetain(prevOffType);
prevOnType = getRepeatingDictionaryType(repeatingPowerOn); CFRetain(prevOnType);
/*
* Remove both off & on events first. If off or on event is not set thru this request,
* then it is assumed that user is requesting to delete it.
*/
if (repeatingPowerOff && isA_CFDictionary(repeatingPowerOff))
CFRelease(repeatingPowerOff);
if (repeatingPowerOn && isA_CFDictionary(repeatingPowerOn))
CFRelease(repeatingPowerOn);
repeatingPowerOff = repeatingPowerOn = NULL;
if (offEvents) {
repeatingPowerOff = CFDictionaryCreateMutableCopy(0,0,offEvents);
}
if (onEvents) {
repeatingPowerOn = CFDictionaryCreateMutableCopy(0,0,onEvents);
}
if ((*return_code = updateRepeatEventsOnDisk(prefs)) != kIOReturnSuccess)
goto exit;
newOffType = getRepeatingDictionaryType(repeatingPowerOff);
newOnType = getRepeatingDictionaryType(repeatingPowerOn);
/*
* Re-schedule the modified event types in case these new events are earlier
* than previously scheduled ones
*/
schedulePowerEventType(prevOffType);
schedulePowerEventType(prevOnType);
if (!CFEqual(prevOffType, newOffType))
schedulePowerEventType(newOffType);
if (!CFEqual(prevOnType, newOnType))
schedulePowerEventType(newOnType);
exit:
if (prevOffType)
CFRelease(prevOffType);
if (prevOnType)
CFRelease(prevOnType);
if (dataRef)
CFRelease(dataRef);
if (events)
CFRelease(events);
destroySCSession(prefs, 1);
vm_deallocate(mach_task_self(), flatPackage, packageLen);
return KERN_SUCCESS;
}
