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;
}
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);
}
}
bool LegacyWebArchive::init(SharedBuffer* data)
{
ASSERT(data);
if (!data)
return false;
RetainPtr<CFDataRef> cfData(AdoptCF, data->createCFData());
if (!cfData)
return false;
CFStringRef errorString = 0;
RetainPtr<CFDictionaryRef> plist(AdoptCF, static_cast<CFDictionaryRef>(CFPropertyListCreateFromXMLData(0, cfData.get(), kCFPropertyListImmutable, &errorString)));
if (!plist) {
#ifndef NDEBUG
const char* cError = errorString ? CFStringGetCStringPtr(errorString, kCFStringEncodingUTF8) : "unknown error";
LOG(Archives, "LegacyWebArchive - Error parsing PropertyList from archive data - %s", cError);
#endif
if (errorString)
CFRelease(errorString);
return false;
}
if (CFGetTypeID(plist.get()) != CFDictionaryGetTypeID()) {
LOG(Archives, "LegacyWebArchive - Archive property list is not the expected CFDictionary, aborting invalid WebArchive");
return false;
}
return extract(plist.get());
}
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;
}
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;
}
/* ------------------------------------------------------------------
* 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 */
/* @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;
}
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;
}
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;
}
// ---------------------------------
// 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;
}
void writePropertyListToFile (CFDataRef data) {
CFStringRef errorString;
CFPropertyListRef propertyList = CFPropertyListCreateFromXMLData (NULL, data, kCFPropertyListMutableContainersAndLeaves, &errorString);
if (errorString == NULL) {
CFStringRef urlString = CFStringCreateWithCString (NULL, kFilename, CFStringGetSystemEncoding ());
CFURLRef fileURL = CFURLCreateWithFileSystemPath (NULL, urlString, kCFURLPOSIXPathStyle, FALSE);
CFWriteStreamRef stream = CFWriteStreamCreateWithFile (NULL, fileURL);
Boolean isOpen = CFWriteStreamOpen (stream);
CFShow (CFSTR ("Property list (as written to file):"));
CFShow (propertyList);
CFIndex bytesWritten = CFPropertyListWriteToStream (propertyList, stream, kCFPropertyListXMLFormat_v1_0, NULL);
CFWriteStreamClose (stream);
}
else {
CFShow (errorString);
CFRelease (errorString);
}
CFRelease (propertyList);
}
static void SecSystemAnchorSourceInit(void) {
SecSystemAnchorSourceRef result = (SecSystemAnchorSourceRef)
malloc(sizeof(*result));
result->base.copyParents = SecSystemAnchorSourceCopyParents;
result->base.contains = SecSystemAnchorSourceContains;
CFDataRef xmlData = SecFrameworkCopyResourceContents(
CFSTR("SystemAnchors"), CFSTR("plist"), NULL);
CFPropertyListRef plist = CFPropertyListCreateFromXMLData(
kCFAllocatorDefault, xmlData, kCFPropertyListImmutable, NULL);
if (plist) {
if (CFGetTypeID(plist) == CFDictionaryGetTypeID()) {
result->digests = (CFSetRef)plist;
} else {
secwarning("SystemAnchors plist is wrong type.");
CFRelease(plist);
}
}
if (!result->digests) {
result->digests = CFSetCreate(kCFAllocatorDefault, NULL, 0,
&kCFTypeSetCallBacks);
}
kSecSystemAnchorSource = (SecCertificateSourceRef)result;
}
// 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();
}
/* ------------------------------------------------------------------
* get_mail_attribute_values ()
*/
static CFMutableDictionaryRef get_mail_attribute_values ( const char *in_mail_attribute,
struct od_user_opts *in_out_opts )
{
CFMutableDictionaryRef cf_mut_dict_ref = NULL;
unsigned long ul_size = strlen( in_mail_attribute );
CFDataRef cf_data_ref = CFDataCreate( NULL, (const UInt8 *)in_mail_attribute, ul_size );
if ( !cf_data_ref )
return( NULL );
CFPropertyListRef cf_plist_ref = CFPropertyListCreateFromXMLData( kCFAllocatorDefault,
cf_data_ref, kCFPropertyListImmutable, NULL );
if ( cf_plist_ref ) {
if ( CFDictionaryGetTypeID() == CFGetTypeID( cf_plist_ref ) ) {
cf_mut_dict_ref = CFDictionaryCreateMutable( kCFAllocatorDefault,
0, &kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFRetain(cf_mut_dict_ref);
CFDictionaryAddValue( cf_mut_dict_ref, CFSTR(kXMLKeyAttrVersion), CFSTR(kXMLValueVersion2) );
CFDictionaryRef cf_dict_ref = (CFDictionaryRef)cf_plist_ref;
get_acct_state( cf_dict_ref, cf_mut_dict_ref, in_out_opts );
get_alt_loc( cf_dict_ref, cf_mut_dict_ref );
get_mail_quota( cf_dict_ref, cf_mut_dict_ref );
}
}
CFRelease( cf_data_ref );
return(cf_mut_dict_ref);
} /* get_mail_attribute_values */
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;
}
/**
* Import the #plist_t structure from XML format.
*
* @param plist_xml 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_xml(const char *plist_xml, uint32_t length, plist_t * plist)
{
*plist = NULL;
CFDataRef data = CFDataCreate(kCFAllocatorDefault, (UInt8 *)plist_xml, length);
if (data) {
*plist = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, data, kCFPropertyListMutableContainers, NULL);
CFRelease(data);
}
}
extern CFPropertyListRef INXCreateDictionaryWithString(CFStringRef s) {
if (s == NULL)
return NULL;
CFDataRef data = CFStringCreateExternalRepresentation(NULL, s, kCFStringEncodingUTF8, 0);
if (data == NULL)
return NULL;
CFPropertyListRef retval = CFPropertyListCreateFromXMLData(NULL, data, kCFPropertyListImmutable, NULL);
CFRelease(data);
return retval;
}
CFDictionaryRef makeCFDictionaryFrom(CFDataRef data)
{
if (data) {
CFPropertyListRef plist = CFPropertyListCreateFromXMLData(NULL, data,
kCFPropertyListImmutable, NULL);
if (plist && CFGetTypeID(plist) != CFDictionaryGetTypeID())
CFError::throwMe();
return CFDictionaryRef(plist);
} else
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;
}
extern OSStatus MySyncPaneFromTicket (
MyCustomContext context,
PMPrintSession session
)
{
OSStatus result = noErr;
PMTicketRef ticket = NULL;
result = MyGetTicket (session, kPDE_PMPrintSettingsRef, &ticket);
if (result == noErr)
{
CFDataRef xmlData = NULL;
CFDictionaryRef dict = NULL;
result = PMTicketGetCFData (
ticket,
kPMTopLevel,
kPMTopLevel,
kAppPrintDialogPDEOnlyKey,
&xmlData
);
if (result == noErr)
{
dict = CFPropertyListCreateFromXMLData (
kCFAllocatorDefault,
xmlData,
kCFPropertyListImmutable,
NULL
);
if (dict)
{
InternSettings(dict, &context->settings);
CFRelease(dict);
}
else
result = kPMKeyNotFound; // bad XML?
}
if (result == kPMKeyNotFound)
{
InitSettings(&context->settings);
result = noErr;
}
}
if (result == noErr)
SyncPaneFromSettings(context);
MyDebugMessage("MySyncPane", result);
return result;
}
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 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;
}
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;
}
SInt32 CFUserNotificationReceiveResponse(CFUserNotificationRef userNotification, CFTimeInterval timeout, CFOptionFlags *responseFlags) {
CHECK_FOR_FORK();
SInt32 retval = ERR_SUCCESS;
#if DEPLOYMENT_TARGET_MACOSX
mach_msg_timeout_t msgtime = (timeout > 0.0 && 1000.0 * timeout < INT_MAX) ? (mach_msg_timeout_t)(1000.0 * timeout) : 0;
mach_msg_base_t *msg = NULL;
CFIndex size = MAX_STRING_COUNT * MAX_STRING_LENGTH;
CFDataRef responseData;
if (userNotification && MACH_PORT_NULL != userNotification->_replyPort) {
msg = (mach_msg_base_t *)CFAllocatorAllocate(kCFAllocatorSystemDefault, size, 0);
if (__CFOASafe) __CFSetLastAllocationEventName(msg, "CFUserNotification (temp)");
if (msg) {
memset(msg, 0, size);
msg->header.msgh_size = size;
if (msgtime > 0) {
retval = mach_msg((mach_msg_header_t *)msg, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, size, userNotification->_replyPort, msgtime, MACH_PORT_NULL);
} else {
retval = mach_msg((mach_msg_header_t *)msg, MACH_RCV_MSG, 0, size, userNotification->_replyPort, 0, MACH_PORT_NULL);
}
if (ERR_SUCCESS == retval) {
if (responseFlags) *responseFlags = msg->header.msgh_id;
if (msg->header.msgh_size > sizeof(mach_msg_base_t)) {
responseData = CFDataCreate(kCFAllocatorSystemDefault, (uint8_t *)msg + sizeof(mach_msg_base_t), msg->header.msgh_size - sizeof(mach_msg_base_t));
if (responseData) {
userNotification->_responseDictionary = CFPropertyListCreateFromXMLData(kCFAllocatorSystemDefault, responseData, kCFPropertyListImmutable, NULL);
CFRelease(responseData);
}
}
if (userNotification->_machPort) {
CFMachPortInvalidate(userNotification->_machPort);
CFRelease(userNotification->_machPort);
userNotification->_machPort = NULL;
}
mach_port_destroy(mach_task_self(), userNotification->_replyPort);
userNotification->_replyPort = MACH_PORT_NULL;
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, msg);
} else {
retval = unix_err(ENOMEM);
}
}
#endif
return retval;
}
static void _CFUserNotificationMachPortCallBack(CFMachPortRef port, void *m, CFIndex size, void *info) {
CFUserNotificationRef userNotification = (CFUserNotificationRef)info;
mach_msg_base_t *msg = (mach_msg_base_t *)m;
CFOptionFlags responseFlags = msg->header.msgh_id;
if (msg->header.msgh_size > sizeof(mach_msg_base_t)) {
CFDataRef responseData = CFDataCreate(kCFAllocatorSystemDefault, (uint8_t *)msg + sizeof(mach_msg_base_t), msg->header.msgh_size - sizeof(mach_msg_base_t));
if (responseData) {
userNotification->_responseDictionary = CFPropertyListCreateFromXMLData(kCFAllocatorSystemDefault, responseData, kCFPropertyListImmutable, NULL);
CFRelease(responseData);
}
}
CFMachPortInvalidate(userNotification->_machPort);
CFRelease(userNotification->_machPort);
userNotification->_machPort = NULL;
mach_port_destroy(mach_task_self(), userNotification->_replyPort);
userNotification->_replyPort = MACH_PORT_NULL;
userNotification->_callout(userNotification, responseFlags);
}
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
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;
}