void UnloadBundle(CFBundleRef theBundle)
{
/*get bundle resource and convert from xml to propertylist struct so we can look for revdontunload attribute and not unload- necessary for external
that interface with Cocoa*/
Boolean dontunload = False;
CFPropertyListRef tCFPropertyListRef = NULL;
short resrefnum = CFBundleOpenBundleResourceMap (theBundle );
CFURLRef resFileCFURLRef = CFBundleCopyResourceURL(theBundle,CFSTR("revinfo"),CFSTR("plist"),NULL);
CFDataRef resCFDataRef;
if (resFileCFURLRef && CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault,resFileCFURLRef,&resCFDataRef,nil,nil,nil))
{
if (resCFDataRef)
{
CFStringRef errorString;
tCFPropertyListRef = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,resCFDataRef,kCFPropertyListImmutable,&errorString);
CFRelease(resCFDataRef);
}
}
if (tCFPropertyListRef)
{
if (CFDictionaryGetValueIfPresent((CFDictionaryRef)tCFPropertyListRef,CFSTR("revdontunload"),NULL))
dontunload = True;
}
if (resFileCFURLRef)
CFRelease(resFileCFURLRef);
CFBundleCloseBundleResourceMap (theBundle,resrefnum);
if (theBundle && !dontunload)
{
CFBundleUnloadExecutable(theBundle);
CFRelease(theBundle);
}
}
extern pascal OSStatus CFQPropertyListCreateFromXMLCFURL(CFURLRef xmlFile, CFPropertyListMutabilityOptions options, CFPropertyListRef *result)
// See comment in header.
{
OSStatus err;
CFDataRef xmlData;
assert(xmlFile != NULL);
assert( result != NULL);
assert(*result == NULL);
xmlData = NULL;
err = noErr;
if ( ! CFURLCreateDataAndPropertiesFromResource(NULL, xmlFile, &xmlData, NULL, NULL, &err) && (err == noErr) ) {
err = coreFoundationUnknownErr;
}
if (err == noErr) {
*result = CFPropertyListCreateFromXMLData(NULL, xmlData, options, NULL);
if (*result == NULL) {
err = coreFoundationUnknownErr;
}
}
CFQRelease(xmlData);
assert( (err == noErr) == (*result != NULL) );
return err;
}
inline SQLite3StatementRef SQLite3StatementCreateWithBundleResource(SQLite3ConnectionRef connection, CFBundleRef bundle, CFStringRef type, CFStringRef name, CFStringRef subdir) {
SQLite3StatementRef statement = NULL;
if (connection) {
SInt32 errorCode = 0;
CFDictionaryRef properties = NULL;
CFDataRef data = NULL;
CFURLRef url = CFBundleCopyResourceURL(bundle, name, type, subdir);
if (url) {
if (CFURLCreateDataAndPropertiesFromResource(connection->allocator, url, &data, &properties, NULL, &errorCode)) {
CFStringRef sql = CFStringCreateWithBytes(connection->allocator, CFDataGetBytePtr(data), CFDataGetLength(data), kCFStringEncodingUTF8, 0);
if (sql) {
statement = SQLite3StatementCreate(connection, sql);
CFRelease(sql);
}
CFRelease(data);
if (properties)
CFRelease(properties);
} else {
// TODO: Error
}
CFRelease(url);
}
}
return statement;
}
static CFPropertyListRef getPropertyList()
{
CFDataRef xmlData;
CFStringRef error;
CFPropertyListRef propertyList;
CFBundleRef appBundle;
CFURLRef myRef;
// locate the starter's bundle:
appBundle = CFBundleGetMainBundle();
// get a URL for the named resource
myRef = CFBundleCopyResourceURL(appBundle, CFSTR(RSRCNAME),
NULL, NULL);
if (myRef == NULL) {
return NULL;
}
// Load the XML data using its URL.
CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, myRef,
&xmlData, NULL, NULL, NULL);
// convert to a Property List
propertyList = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, xmlData,
kCFPropertyListImmutable,
&error);
if (error != NULL) {
return NULL;
}
return propertyList;
}
CFPropertyListRef Resources::getPropertyList(const char* filename)
{
CFDataRef xmlCFDataRef;
CFStringRef error;
char cerror[10240];
CFPropertyListRef myCFPropertyListRef = NULL;
Boolean readOK;
char filePathBuf[PATH_MAX];
CFStringRef filePath = this->getResourcePath(filename);
CFStringGetCString(filePath, filePathBuf, sizeof(filePathBuf), kCFStringEncodingUTF8);
CFURLRef fileURL = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault, (const unsigned char*)filePathBuf, strlen (filePathBuf), false);
if (fileURL!=NULL) {
readOK = CFURLCreateDataAndPropertiesFromResource( kCFAllocatorDefault, fileURL, &xmlCFDataRef, NULL, NULL, NULL);
if (readOK)
{
myCFPropertyListRef = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, xmlCFDataRef, kCFPropertyListImmutable, &error);
if (error != NULL){
CFStringGetCString(error, cerror, sizeof(cerror), kCFStringEncodingUTF8);
scprintf("getPropertyList error: %s\n", cerror);
}
CFRelease(xmlCFDataRef);
}
else{
scprintf("Couldn't read Plist File %s\n", filePathBuf);
}
}
return myCFPropertyListRef;
}
// ---------------------------------
// Load the element strings from the given resource (XML) file into a CFPropertyListRef
static CFPropertyListRef xml_load(const CFStringRef pResourceName,const CFStringRef pResourceExtension)
{
CFPropertyListRef tCFPropertyListRef = NULL;
CFURLRef resFileCFURLRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(), pResourceName, pResourceExtension, NULL);
if (NULL != resFileCFURLRef)
{
CFDataRef resCFDataRef;
if (CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, resFileCFURLRef, &resCFDataRef, nil, nil, nil))
{
if (NULL != resCFDataRef)
{
CFStringRef errorString;
tCFPropertyListRef = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, resCFDataRef, kCFPropertyListImmutable, &errorString);
if (NULL == tCFPropertyListRef)
CFShow(errorString);
CFRelease(resCFDataRef);
}
}
CFRelease(resFileCFURLRef);
}
return tCFPropertyListRef;
}
bool QConfFileSettingsPrivate::readPlistFile(const QString &fileName, ParsedSettingsMap *map) const
{
QCFType<CFDataRef> resource;
SInt32 code;
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, urlFromFileName(fileName),
&resource, 0, 0, &code))
return false;
QCFString errorStr;
QCFType<CFPropertyListRef> propertyList =
CFPropertyListCreateFromXMLData(kCFAllocatorDefault, resource, kCFPropertyListImmutable,
&errorStr);
if (!propertyList)
return true;
if (CFGetTypeID(propertyList) != CFDictionaryGetTypeID())
return false;
CFDictionaryRef cfdict =
static_cast<CFDictionaryRef>(static_cast<CFPropertyListRef>(propertyList));
int size = (int)CFDictionaryGetCount(cfdict);
QVarLengthArray<CFPropertyListRef> keys(size);
QVarLengthArray<CFPropertyListRef> values(size);
CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data());
for (int i = 0; i < size; ++i) {
QString key = qtKey(static_cast<CFStringRef>(keys[i]));
map->insert(QSettingsKey(key, Qt::CaseSensitive), qtValue(values[i]));
}
return true;
}
/* @overload read_plist(path)
*
* Reads from the specified path and de-serializes the property list.
*
* @note This does not yet support all possible types that can exist in a valid property list.
*
* @note This currently only assumes to be given an Xcode project document.
* This means that it only accepts dictionaries, arrays, and strings in
* the document.
*
* @param [String] path The path to the property list file.
* @return [Hash] The dictionary contents of the document.
*/
static VALUE
read_plist(VALUE self, VALUE path) {
CFPropertyListRef dict;
CFStringRef errorString;
CFDataRef resourceData;
SInt32 errorCode;
CFURLRef fileURL = str_to_url(path);
if (CFURLCreateDataAndPropertiesFromResource(NULL, fileURL, &resourceData, NULL, NULL, &errorCode)) {
CFRelease(fileURL);
}
if (!resourceData) {
rb_raise(rb_eArgError, "Unable to read data from `%s'", RSTRING_PTR(rb_inspect(path)));
}
dict = CFPropertyListCreateFromXMLData(NULL, resourceData, kCFPropertyListImmutable, &errorString);
if (!dict) {
rb_raise(rb_eArgError, "Unable to read plist data from `%s': %s", RSTRING_PTR(rb_inspect(path)), RSTRING_PTR(cfstr_to_str(errorString)));
}
CFRelease(resourceData);
register VALUE hash = rb_hash_new();
CFDictionaryApplyFunction(dict, hash_set, (void *)hash);
CFRelease(dict);
return hash;
}
/* ------------------------------------------------------------------
* read_user_settings ()
*/
static CFPropertyListRef read_user_settings ( const char *in_file, CFPropertyListMutabilityOptions in_opts )
{
CFPropertyListRef cf_prop_list = NULL;
CFURLRef cf_url = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8 *)in_file, strlen(in_file), FALSE);
if ( !cf_url ) {
msg_error( "aod: could not create URL from %s", in_file);
return( NULL );
}
SInt32 err;
CFDataRef cf_data = NULL;
if ( !CFURLCreateDataAndPropertiesFromResource(NULL, cf_url, &cf_data, NULL, NULL, &err) ) {
if ( msg_verbose )
msg_info("aod: no local user settings (%s), using defaults", in_file);
CFRelease(cf_url);
return( NULL );
}
CFStringRef cf_str_err = NULL;
if ( cf_data ) {
cf_prop_list = CFPropertyListCreateFromXMLData( kCFAllocatorDefault, cf_data, in_opts, &cf_str_err);
if ( cf_prop_list )
CFRetain(cf_prop_list);
} else
msg_error("aod: enable to create CFData ref for %s", in_file);
CFRelease(cf_url);
if ( cf_str_err )
CFRelease( cf_str_err );
if ( cf_data )
CFRelease( cf_data );
return( cf_prop_list );
} /* read_user_settings */
// Assumes the domain has already been locked
static void _loadXMLDomainIfStale(CFURLRef url, _CFXMLPreferencesDomain *domain) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
int idx;
if (domain->_domainDict) {
CFDateRef modDate;
CFAbsoluteTime modTime;
CFURLRef testURL = url;
if (CFDictionaryGetCount(domain->_domainDict) == 0) {
// domain never existed; check the parent directory, not the child
testURL = CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR(".."), kCFURLPOSIXPathStyle, true, url);
}
modDate = (CFDateRef )CFURLCreatePropertyFromResource(alloc, testURL, kCFURLFileLastModificationTime, NULL);
modTime = modDate ? CFDateGetAbsoluteTime(modDate) : 0.0;
// free before possible return. we can test non-NULL of modDate but don't depend on contents after this.
if (testURL != url) CFRelease(testURL);
if (modDate) CFRelease(modDate);
if (modDate != NULL && modTime < domain->_lastReadTime) { // We're up-to-date
return;
}
}
// We're out-of-date; destroy domainDict and reload
if (domain->_domainDict) {
CFRelease(domain->_domainDict);
domain->_domainDict = NULL;
}
// We no longer lock on read; instead, we assume parse failures are because someone else is writing the file, and just try to parse again. If we fail 3 times in a row, we assume the file is corrupted. REW, 7/13/99
for (idx = 0; idx < 3; idx ++) {
CFDataRef data;
if (!CFURLCreateDataAndPropertiesFromResource(alloc, url, &data, NULL, NULL, NULL) || !data) {
// Either a file system error (so we can't read the file), or an empty (or perhaps non-existant) file
domain->_domainDict = CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
break;
} else {
CFTypeRef pList = CFPropertyListCreateFromXMLData(alloc, data, kCFPropertyListImmutable, NULL);
CFRelease(data);
if (pList && CFGetTypeID(pList) == CFDictionaryGetTypeID()) {
domain->_domainDict = CFDictionaryCreateMutableCopy(alloc, 0, (CFDictionaryRef)pList);
CFRelease(pList);
break;
} else if (pList) {
CFRelease(pList);
}
// Assume the file is being written; sleep for a short time (to allow the write to complete) then re-read
__CFMilliSleep(150);
}
}
if (!domain->_domainDict) {
// Failed to ever load
domain->_domainDict = CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
domain->_lastReadTime = CFAbsoluteTimeGetCurrent();
}
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;
}
static WTF::RetainPtr<CFDictionaryRef> readPListFile(CFStringRef fileName, bool createFile, CFBundleRef bundle)
{
if (createFile) {
BP_CreatePluginMIMETypesPreferencesFuncPtr funcPtr =
(BP_CreatePluginMIMETypesPreferencesFuncPtr)CFBundleGetFunctionPointerForName(bundle, CFSTR("BP_CreatePluginMIMETypesPreferences"));
if (funcPtr)
funcPtr();
}
WTF::RetainPtr<CFDictionaryRef> map;
WTF::RetainPtr<CFURLRef> url =
CFURLCreateWithFileSystemPath(kCFAllocatorDefault, fileName, kCFURLPOSIXPathStyle, false);
CFDataRef resource = 0;
SInt32 code;
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, url.get(), &resource, 0, 0, &code))
return map;
WTF::RetainPtr<CFPropertyListRef> propertyList =
CFPropertyListCreateFromXMLData(kCFAllocatorDefault, resource, kCFPropertyListImmutable, 0);
CFRelease(resource);
if (!propertyList)
return map;
if (CFGetTypeID(propertyList.get()) != CFDictionaryGetTypeID())
return map;
map = static_cast<CFDictionaryRef>(static_cast<CFPropertyListRef>(propertyList.get()));
return map;
}
CFArrayRef copyTrustedAppListFromBundle(CFStringRef bundlePath, CFStringRef trustedAppListFileName)
{
CFStringRef errorString = nil;
CFURLRef bundleURL,trustedAppsURL = NULL;
CFBundleRef secBundle = NULL;
CFPropertyListRef trustedAppsPlist = NULL;
CFDataRef xmlDataRef = NULL;
SInt32 errorCode;
CFArrayRef trustedAppList = NULL;
CFMutableStringRef trustedAppListFileNameWithoutExtension = NULL;
// Make a CFURLRef from the CFString representation of the bundleÕs path.
bundleURL = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault,bundlePath,kCFURLPOSIXPathStyle,true);
CFRange wholeStrRange;
if (!bundleURL)
goto xit;
// Make a bundle instance using the URLRef.
secBundle = CFBundleCreate(kCFAllocatorDefault,bundleURL);
if (!secBundle)
goto xit;
trustedAppListFileNameWithoutExtension =
CFStringCreateMutableCopy(NULL,CFStringGetLength(trustedAppListFileName),trustedAppListFileName);
wholeStrRange = CFStringFind(trustedAppListFileName,CFSTR(".plist"),0);
CFStringDelete(trustedAppListFileNameWithoutExtension,wholeStrRange);
// Look for a resource in the bundle by name and type
trustedAppsURL = CFBundleCopyResourceURL(secBundle,trustedAppListFileNameWithoutExtension,CFSTR("plist"),NULL);
if (!trustedAppsURL)
goto xit;
if ( trustedAppListFileNameWithoutExtension )
CFRelease(trustedAppListFileNameWithoutExtension);
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault,trustedAppsURL,&xmlDataRef,NULL,NULL,&errorCode))
goto xit;
trustedAppsPlist = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,xmlDataRef,kCFPropertyListImmutable,&errorString);
trustedAppList = (CFArrayRef)trustedAppsPlist;
xit:
if (bundleURL)
CFRelease(bundleURL);
if (secBundle)
CFRelease(secBundle);
if (trustedAppsURL)
CFRelease(trustedAppsURL);
if (xmlDataRef)
CFRelease(xmlDataRef);
if (errorString)
CFRelease(errorString);
return trustedAppList;
}
void get(const StringSlice& url, WriteTarget out) {
cf::Url cfurl(url);
cf::Data cfdata;
SInt32 error;
if (CFURLCreateDataAndPropertiesFromResource(
NULL, cfurl.c_obj(), &cfdata.c_obj(), NULL, NULL, &error)) {
write(out, cfdata.data());
} else {
throw Exception(format("Couldn't load requested url {0}", url));
}
}
//
// CFURLAccess wrappers for specific purposes
//
CFDataRef cfLoadFile(CFURLRef url)
{
assert(url);
CFDataRef data;
SInt32 error;
if (CFURLCreateDataAndPropertiesFromResource(NULL, url,
&data, NULL, NULL, &error)) {
return data;
} else {
secdebug("cfloadfile", "failed to fetch %s error=%d", cfString(url).c_str(), int(error));
return NULL;
}
}
RemoteVSTClient::RemoteVSTClient(CFBundleRef bundle, audioMasterCallback theMaster, AEffect *theEffect, bool showGUI) :
RemotePluginClient(theMaster, theEffect)
{
m_bundle = bundle;
m_audioMaster = theMaster;
pid_t child;
SInt32 errorCode;
CFDataRef data;
CFURLRef configUrl = CFBundleCopyResourceURL(bundle, CFSTR("config"), CFSTR("plist"), NULL);
if (configUrl == 0) {
return;
}
CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, configUrl, &data, NULL, NULL, &errorCode);
m_props = (CFDictionaryRef) CFPropertyListCreateFromXMLData( kCFAllocatorDefault, data, kCFPropertyListImmutable, NULL);
std::string dllName(CFStringGetCStringPtr(get_path_prop(CFSTR("plugin-name")), NULL));
std::string arg = dllName + "," + getFileIdentifiers();
if (showGUI) arg = "-g " + arg;
const char *argStr = arg.c_str();
CFURLRef server_url = CFBundleCopyResourceURL(m_bundle, CFSTR("dssi-vst-server.exe"), CFSTR("so"), NULL);
if (server_url != NULL) {
CFStringRef server_path = CFURLCopyFileSystemPath(server_url, kCFURLPOSIXPathStyle);
if (server_path != NULL) {
const char *c_server_path = CFStringGetCStringPtr(server_path, NULL);
CFStringRef wine_path = (CFStringRef) CFDictionaryGetValue(m_props, CFSTR("wine-path"));
if (wine_path != NULL) {
const char *c_wine_path = CFStringGetCStringPtr(wine_path, NULL);
std::cerr << "RemoteVSTClient: executing " << c_server_path << "\n";
// if no dispaly environment guess...
// setenv("DISPLAY", ":0", 0);
setenv("DYLD_FALLBACK_LIBRARY_PATH", "/usr/X11/lib:/usr/lib", 0);
if ((child = fork()) < 0) {
cleanup();
throw((std::string)"Fork failed");
} else if (child == 0) { // child process
if (execlp(c_wine_path, "wine", c_server_path, argStr, NULL)) {
perror("Exec failed");
exit(1);
}
}
syncStartup();
return;
}
}
}
cleanup();
throw((std::string)"Failed to find dssi-vst-server executable");
return;
}
OSStatus GenerateThumbnailForURL(void *thisInterface, QLThumbnailRequestRef thumbnail, CFURLRef url, CFStringRef contentTypeUTI, CFDictionaryRef options, CGSize maxSize)
{
// load the actual file
CFDataRef fileData = nil;
CFDictionaryRef propertyDictionary = nil;
SInt32 errorCode;
if (CFURLCreateDataAndPropertiesFromResource(NULL, url, &fileData, &propertyDictionary, nil, &errorCode)) {
CFIndex dataLength = CFDataGetLength(fileData);
UInt8 *bytes = (UInt8 *)CFDataGetBytePtr(fileData);
long pages = dataLength / ONE_LCD_FRAME_BYTESIZE;
CGSize lcdSize = CGSizeMake(LCD_FRAME_PIXEL_WIDTH, LCD_FRAME_PIXEL_HEIGHT * pages);
CGContextRef cgContext = QLThumbnailRequestCreateContext(thumbnail, lcdSize, true, NULL);
if(cgContext) {
CGColorRef lcdForegroundColor = CGColorCreateGenericRGB(0.467, 0.522, 0.047, 1.000);
CGColorRef lcdBackgroundColor = CGColorCreateGenericRGB(0.227, 0.192, 0.000, 1.000);
CGContextSetFillColorWithColor(cgContext, lcdBackgroundColor);
CGContextFillRect(cgContext, CGRectMake(0,0,lcdSize.width,lcdSize.height));
CGPoint origin = CGPointMake(0,0);
while (pages-- > 0) {
CGContextSetFillColorWithColor(cgContext, lcdForegroundColor);
// CGContextFillRect(cgContext, CGRectMake(origin.x,origin.y,10,10));
for (int y=0;y<9;y++) {
for (int x=0; x < LCD_FRAME_PIXEL_WIDTH; x++) {
UInt8 byte = bytes[y*LCD_FRAME_PIXEL_WIDTH + (LCD_FRAME_PIXEL_WIDTH - x - 1)];
if (byte > 0) {
UInt8 byteMask = 1;
for (int littleY = 0; littleY < 8; littleY++) {
if ((byte & (byteMask << littleY))) {
CGContextFillRect(cgContext, CGRectMake(origin.x + x,origin.y + y*8 + littleY,1,1));
}
}
}
}
}
origin.y += 68;
bytes += ONE_LCD_FRAME_BYTESIZE;
}
// When we are done with our drawing code QLPreviewRequestFlushContext() is called to flush the context
QLThumbnailRequestFlushContext(thumbnail, cgContext);
}
CFRelease(cgContext);
CFRelease(fileData);
CFRelease(propertyDictionary);
}
return noErr;
}
const void *
macosx_parse_plist(const char *path)
{
CFPropertyListRef plist = NULL;
const char url_header[] = "file://";
char *url_text = NULL;
CFURLRef url = NULL;
CFAllocatorRef cf_alloc = kCFAllocatorDefault;
size_t url_text_len = ((sizeof(url_header) - 1UL) + strlen(path) + 1UL);
url_text = (char *)xmalloc(url_text_len);
/* Create URL text for the Info.plist file: */
strcpy(url_text, url_header);
strcat(url_text, path);
/* Generate a CoreFoundation URL from the URL text: */
url = CFURLCreateWithBytes(cf_alloc, (const UInt8 *)url_text,
url_text_len, kCFStringEncodingUTF8, NULL);
if (url)
{
/* Extract the contents of the file into a CoreFoundation data
buffer. */
CFDataRef data = NULL;
if (CFURLCreateDataAndPropertiesFromResource(cf_alloc, url, &data,
NULL, NULL, NULL)
&& (data != NULL))
{
/* Create the property list from XML data or from the binary
plist data. */
plist = CFPropertyListCreateFromXMLData(cf_alloc, data,
kCFPropertyListImmutable,
NULL);
CFRelease(data);
if (plist != NULL)
{
/* Make sure the property list was a CFDictionary, free it
* and NULL the pointer if it was not as such: */
if (CFGetTypeID(plist) != CFDictionaryGetTypeID())
{
CFRelease(plist);
plist = NULL;
}
}
}
CFRelease(url);
}
xfree(url_text);
return plist;
}
CFDictionaryRef APCreateDictionaryForLicenseFile(CFURLRef path)
{
// Read the XML file
CFDataRef data;
SInt32 errorCode;
Boolean status;
status = CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, path, &data, NULL, NULL, &errorCode);
if (errorCode || status != true)
return NULL;
CFDictionaryRef licenseDictionary = APCreateDictionaryForLicenseData(data);
CFRelease(data);
return licenseDictionary;
}
CFDictionaryRef CreateDictionaryFromPlist(CFStringRef stringPlist, SInt32 *errorCode)
{
CFDataRef dataRef;
CFStringRef errorStringRef;
CFURLRef fileURLRef = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,stringPlist,kCFURLPOSIXPathStyle,false);
Boolean status = CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault,fileURLRef,&dataRef,NULL,NULL,errorCode);
if (!status) {
//error
}
CFDictionaryRef dictRef = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,dataRef,
kCFPropertyListMutableContainersAndLeaves,&errorStringRef);
CFRelease(fileURLRef);
CFRelease(dataRef);
return dictRef;
}
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;
}
CFPropertyListRef ReadPresetFromPresetFile (char* filePath)
{
if (!filePath)
return NULL;
FSRef ref;
if (FSPathMakeRef((UInt8 *)filePath, &ref, NULL))
return NULL;
CFDataRef resourceData = NULL;
CFPropertyListRef theData = NULL;
CFStringRef errString = NULL;
CFURLRef fileURL = CFURLCreateFromFSRef (kCFAllocatorDefault, &ref);
if (fileURL == NULL) {
goto home;
}
SInt32 result;
// Read the XML file.
Boolean status; status = CFURLCreateDataAndPropertiesFromResource (kCFAllocatorDefault, fileURL,
&resourceData, // place to put file data
NULL, NULL, &result);
if (status == false || result) {
goto home;
}
theData = CFPropertyListCreateFromXMLData (kCFAllocatorDefault, resourceData,
kCFPropertyListImmutable, &errString);
if (theData == NULL || errString) {
if (theData)
CFRelease (theData);
theData = NULL;
goto home;
}
home:
if (fileURL)
CFRelease (fileURL);
if (resourceData)
CFRelease (resourceData);
if (errString)
CFRelease (errString);
return theData;
}
// Translates an iPod binary Property-list into a text property list.
//
// Returns:
// true on success
// false on failure
//
bool CiPoTApi::TranslatePLIST(char *originalFile, char *newFile)
{
CFPropertyListRef propertyList;
CFURLRef fileURL;
CFStringRef inputFile, errorString;
CFDataRef resourceData;
Boolean status;
SInt32 errorCode;
bool ok = false;
// Create a URL that specifies the file we will create to hold the XML data.
inputFile = CFStringCreateWithCString(kCFAllocatorDefault, originalFile, kStrEncoding);
fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, inputFile, kPathStyle, false);
if (!fileURL)
return false;
// Read the XML file.
status = CFURLCreateDataAndPropertiesFromResource(
kCFAllocatorDefault, fileURL, &resourceData, NULL, NULL, &errorCode);
if (resourceData) {
// Reconstitute the dictionary using the XML data.
propertyList = CFPropertyListCreateFromXMLData(
kCFAllocatorDefault, resourceData,kCFPropertyListImmutable, &errorString);
if (propertyList != NULL) {
CFStringRef outputFile;
CFDataRef xmlData;
Boolean status;
SInt32 errorCode;
CFRelease(fileURL);
outputFile = CFStringCreateWithCString(kCFAllocatorDefault, newFile, kStrEncoding);
fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, outputFile, kPathStyle, false);
// Convert the property list into XML data.
xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, propertyList);
// Write the XML data to the file.
status = CFURLWriteDataAndPropertiesToResource(fileURL, xmlData, NULL, &errorCode);
ok = status ? true : false;
CFRelease(xmlData);
CFRelease(outputFile);
CFRelease(propertyList);
}
}
CFRelease(inputFile);
CFRelease(fileURL);
return ok;
}
static CFDictionaryRef _CFCopyVersionDictionary(CFStringRef path) {
CFPropertyListRef plist = NULL;
CFDataRef data;
CFURLRef url;
url = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, path, kCFURLPOSIXPathStyle, false);
if (url && CFURLCreateDataAndPropertiesFromResource(kCFAllocatorSystemDefault, url, &data, NULL, NULL, NULL)) {
plist = CFPropertyListCreateFromXMLData(kCFAllocatorSystemDefault, data, kCFPropertyListMutableContainers, NULL);
CFRelease(data);
}
if (url) CFRelease(url);
if (plist) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
CFBundleRef locBundle = NULL;
CFStringRef fullVersion, vers, versExtra, build;
CFStringRef versionString = _CFCopyLocalizedVersionKey(&locBundle, _kCFSystemVersionProductVersionStringKey);
CFStringRef buildString = _CFCopyLocalizedVersionKey(&locBundle, _kCFSystemVersionBuildStringKey);
CFStringRef fullVersionString = _CFCopyLocalizedVersionKey(&locBundle, CFSTR("FullVersionString"));
if (locBundle) CFRelease(locBundle);
// Now build the full version string
if (CFEqual(fullVersionString, CFSTR("FullVersionString"))) {
CFRelease(fullVersionString);
fullVersionString = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("%@ %%@ (%@ %%@)"), versionString, buildString);
}
vers = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)plist, _kCFSystemVersionProductVersionKey);
versExtra = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)plist, _kCFSystemVersionProductVersionExtraKey);
if (vers && versExtra) vers = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("%@ %@"), vers, versExtra);
build = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)plist, _kCFSystemVersionBuildVersionKey);
fullVersion = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, fullVersionString, (vers ? vers : CFSTR("?")), build ? build : CFSTR("?"));
if (vers && versExtra) CFRelease(vers);
CFDictionarySetValue((CFMutableDictionaryRef)plist, _kCFSystemVersionProductVersionStringKey, versionString);
CFDictionarySetValue((CFMutableDictionaryRef)plist, _kCFSystemVersionBuildStringKey, buildString);
CFDictionarySetValue((CFMutableDictionaryRef)plist, CFSTR("FullVersionString"), fullVersion);
CFRelease(versionString);
CFRelease(buildString);
CFRelease(fullVersionString);
CFRelease(fullVersion);
#endif
}
return (CFDictionaryRef)plist;
}
static CFMutableDictionaryRef copyInfoDict(CFBundleRef bundle)
{
CFMutableDictionaryRef infoDict = NULL;
CFURLRef infoDictURL;
CFDataRef data;
infoDictURL = _CFBundleCopyInfoPlistURL(bundle);
if (infoDictURL)
{
if (CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, infoDictURL, &data,
NULL, NULL, NULL))
{
infoDict = (CFMutableDictionaryRef) CFPropertyListCreateFromXMLData(kCFAllocatorDefault,
data, kCFPropertyListMutableContainers, NULL);
}
CFRelease(infoDictURL);
}
return( infoDict );
}
/*************************************************************************
*
* hu_LoadFromXMLFile( inCFURLRef )
*
* Purpose: load a property list from an XML file
*
* Inputs: inCFURLRef - URL for the file
*
* Returns: CFPropertyListRef - the data
*/
static CFPropertyListRef hu_LoadFromXMLFile(CFURLRef inCFURLRef) {
CFDataRef xmlCFDataRef;
CFPropertyListRef myCFPropertyListRef = NULL;
// Read the XML file.
SInt32 error;
if ( CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, inCFURLRef, &xmlCFDataRef, NULL, NULL, &error) ) {
CFStringRef errorString;
// Reconstitute the dictionary using the XML data.
myCFPropertyListRef = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,
xmlCFDataRef,
kCFPropertyListImmutable,
&errorString);
// Release the XML data
CFRelease(xmlCFDataRef);
}
return (myCFPropertyListRef);
} // hu_LoadFromXMLFile
int main() {
SInt32 ret_code;
UInt8 *myPtr;
CFDataRef myData;
CFStringRef url = CFSTR("http://localhost:8080/index.html");
printf("Requesting URL\n");
CFURLRef myURL = CFURLCreateWithString(kCFAllocatorDefault, url, NULL);
CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, myURL, &myData,
NULL, NULL, &ret_code);
if (myData != NULL) {
myPtr = (UInt8 *)CFDataGetBytePtr(myData);
printf("Data: %s\n", myPtr);
}
CFRelease(myURL);
CFRelease(url);
}
static CFPropertyListRef CreateMyPropertyListFromFile(const char *posixfile)
{
CFPropertyListRef propertyList;
CFStringRef errorString;
CFDataRef resourceData;
SInt32 errorCode;
CFURLRef fileURL;
fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, posixfile, strlen(posixfile), false);
if (!fileURL)
fprintf(stderr, "%s: CFURLCreateFromFileSystemRepresentation(%s) failed\n", argv0, posixfile);
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, fileURL, &resourceData, NULL, NULL, &errorCode))
fprintf(stderr, "%s: CFURLCreateDataAndPropertiesFromResource(%s) failed: %d\n", argv0, posixfile, (int)errorCode);
propertyList = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, resourceData, kCFPropertyListImmutable, &errorString);
if (!propertyList)
fprintf(stderr, "%s: propertyList is NULL\n", argv0);
CFRelease(resourceData);
return propertyList;
}
static CFPropertyListRef load_plist_from_path(const char * path)
{
CFURLRef url = NULL;
CFDataRef data = NULL;
CFStringRef err = NULL;
CFPropertyListRef plist = NULL;
url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)path, strlen(path),
false /* isDirectory */);
if (url == NULL) {
VERBOSE("failed to build CFURL for '%s'\n", path);
goto done;
}
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault,
url, &data, NULL, NULL, NULL)) {
VERBOSE("failed to read CFURL data for '%s'\n", path);
goto done;
}
/* Despite the name, this actually reads both binary and XML plists. */
plist = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,
data, kCFPropertyListImmutable, &err);
if (!plist) {
char errbuf[256];
CFStringGetCString(err, errbuf, sizeof(errbuf), kCFStringEncodingUTF8);
VERBOSE("plist parse error for '%s': %s\n",
path, errbuf);
}
done:
safe_release(err);
safe_release(url);
safe_release(data);
return plist;
}
// not used
static CFPropertyListRef XML_HIDCookieStringLoad (void)
{
CFPropertyListRef tCFPropertyListRef = NULL;
CFURLRef resFileCFURLRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(),CFSTR("HID_cookie_strings"),CFSTR("plist"),NULL);
CFDataRef resCFDataRef;
if (CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault,resFileCFURLRef,&resCFDataRef,nil,nil,nil))
{
if (NULL != resCFDataRef)
{
CFStringRef errorString;
tCFPropertyListRef = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,resCFDataRef,kCFPropertyListImmutable,&errorString);
if (NULL == tCFPropertyListRef)
CFShow(errorString);
CFRelease(resCFDataRef);
}
}
if (NULL != resFileCFURLRef)
CFRelease(resFileCFURLRef);
return tCFPropertyListRef;
}