bool QConfFileSettingsPrivate::writePlistFile(const QString &fileName,
const ParsedSettingsMap &map) const
{
QVarLengthArray<QCFType<CFStringRef> > cfkeys(map.size());
QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(map.size());
int i = 0;
ParsedSettingsMap::const_iterator j;
for (j = map.constBegin(); j != map.constEnd(); ++j) {
cfkeys[i] = macKey(j.key());
cfvalues[i] = macValue(j.value());
++i;
}
QCFType<CFDictionaryRef> propertyList =
CFDictionaryCreate(kCFAllocatorDefault,
reinterpret_cast<const void **>(cfkeys.data()),
reinterpret_cast<const void **>(cfvalues.data()),
CFIndex(map.size()),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
QCFType<CFDataRef> xmlData = CFPropertyListCreateData(
kCFAllocatorDefault, propertyList, kCFPropertyListXMLFormat_v1_0, 0, 0);
SInt32 code;
return CFURLWriteDataAndPropertiesToResource(urlFromFileName(fileName), xmlData, 0, &code);
}
// Asssumes caller already knows the directory doesn't exist.
static Boolean _createDirectory(CFURLRef dirURL, Boolean worldReadable) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
CFURLRef parentURL = CFURLCreateCopyDeletingLastPathComponent(alloc, dirURL);
CFBooleanRef val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, parentURL, kCFURLFileExists, NULL);
Boolean parentExists = (val && CFBooleanGetValue(val));
SInt32 mode;
Boolean result;
if (val) CFRelease(val);
if (!parentExists) {
CFStringRef path = CFURLCopyPath(parentURL);
if (!CFEqual(path, CFSTR("/"))) {
_createDirectory(parentURL, worldReadable);
val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, parentURL, kCFURLFileExists, NULL);
parentExists = (val && CFBooleanGetValue(val));
if (val) CFRelease(val);
}
CFRelease(path);
}
if (parentURL) CFRelease(parentURL);
if (!parentExists) return false;
#if DEPLOYMENT_TARGET_MACOSX
mode = worldReadable ? S_IRWXU|S_IRWXG|S_IROTH|S_IXOTH : S_IRWXU;
#else
mode = 0666;
#endif
result = CFURLWriteDataAndPropertiesToResource(dirURL, (CFDataRef)dirURL, URLPropertyDictForPOSIXMode(mode), NULL);
URLPropertyDictRelease();
return result;
}
OSStatus DoWriteDataToFile(COMMAND_PROC_ARGUMENTS) {
#pragma unused (auth)
#pragma unused (userData)
OSStatus retval = noErr;
// Pre-conditions
// userData may be NULL
assert(request != NULL);
assert(response != NULL);
// asl may be NULL
// aslMsg may be NULL
// Get data to write and assert that it's a CFDataRef
CFDataRef data = CFDictionaryGetValue(request, CFSTR(kData)) ;
assert(data != NULL) ;
assert(CFGetTypeID(data) == CFDataGetTypeID()) ;
// Get path and assert that it's a CFStringRef
CFStringRef filePath = CFDictionaryGetValue(request, CFSTR(kPath)) ;
assert(filePath != NULL) ;
assert(CFGetTypeID(filePath) == CFStringGetTypeID()) ;
CFURLRef url = CFURLCreateWithFileSystemPath (
kCFAllocatorDefault,
filePath,
kCFURLPOSIXPathStyle,
false
) ;
SInt32 errorCode ;
Boolean ok = CFURLWriteDataAndPropertiesToResource (
url,
data,
NULL,
&errorCode
) ;
if (!ok) {
retval = errorCode ;
}
asl_log(asl,
aslMsg,
ASL_LEVEL_DEBUG,
"DoWriteDataToFile result ok=%d for %s",
ok,
CFStringGetCStringPtr(
filePath,
CFStringGetSystemEncoding()
)
) ;
// Clean up
CFQRelease(url) ;
return retval ;
}
void subsurface_close_conf(void)
{
Boolean status;
SInt32 errorCode;
CFDataRef xmlData;
propertyList = dict;
dict = NULL;
xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, propertyList);
status = CFURLWriteDataAndPropertiesToResource (fileURL, xmlData, NULL, &errorCode);
// some error handling - but really, what can we do?
CFRelease(xmlData);
CFRelease(propertyList);
}
void StoreDictionaryInPlist(CFPropertyListRef propListRef, CFStringRef stringPlist, SInt32 *errorCode)
{
CFErrorRef errorRef;
CFURLRef fileURLRef = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,stringPlist,kCFURLPOSIXPathStyle,false);
CFDataRef dataRef = CFPropertyListCreateData(kCFAllocatorDefault, propListRef, kCFPropertyListXMLFormat_v1_0, 0, &errorRef);
// Write the plist to the file.
Boolean status = CFURLWriteDataAndPropertiesToResource(fileURLRef, dataRef, NULL, errorCode);
if (!status) {
//error
}
CFRelease(fileURLRef);
CFRelease(dataRef);
}
/*************************************************************************
*
* hu_SaveToXMLFile( inCFPRef, inCFURLRef )
*
* Purpose: save a property list into an XML file
*
* Inputs: inCFPRef - the data
* inCFURLRef - URL for the file
*
* Returns: SInt32 - error code ( if any )
*/
static SInt32 hu_SaveToXMLFile(CFPropertyListRef inCFPRef, CFURLRef inCFURLRef) {
CFDataRef xmlCFDataRef;
SInt32 error = coreFoundationUnknownErr;
// Convert the property list into XML data.
xmlCFDataRef = CFPropertyListCreateXMLData(kCFAllocatorDefault, inCFPRef);
if ( xmlCFDataRef ) {
// Write the XML data to the file.
(void) CFURLWriteDataAndPropertiesToResource(inCFURLRef, xmlCFDataRef, NULL, &error);
// Release the XML data
CFRelease(xmlCFDataRef);
}
return (error);
} // hu_SaveToXMLFile
// 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;
}
/* ------------------------------------------------------------------
* write_user_settings ()
*/
static void write_user_settings ( const char *in_file, CFPropertyListRef in_data )
{
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;
}
CFDataRef cf_data = CFPropertyListCreateXMLData(NULL, in_data);
if ( cf_data ) {
SInt32 write_err = noErr;
if ( !CFURLWriteDataAndPropertiesToResource(cf_url, cf_data, NULL, &write_err) )
if ( msg_verbose )
msg_warn("aod: could not write to %s (error: %d)", in_file, (int) write_err);
CFRelease(cf_data);
}
CFRelease(cf_url);
} /* write_user_settings */
BOOL write_property_list( const char *path, CFPropertyListRef propertyList, CFPropertyListFormat format)
{
CFDataRef data = NULL;
CFStringRef pathstr = NULL;
CFURLRef fileURL = NULL;
CFErrorRef err = NULL;
BOOL ret = FALSE;
SInt32 errorCode;
pathstr = CFStringCreateWithFileSystemRepresentation(NULL, path);
if (!pathstr)
goto cleanup;
fileURL = CFURLCreateWithFileSystemPath( kCFAllocatorDefault,
pathstr,
kCFURLPOSIXPathStyle,
false );
if (!fileURL)
goto cleanup;
data = CFPropertyListCreateData(NULL, propertyList, format, 0, &err);
if (!data)
goto cleanup;
ret = CFURLWriteDataAndPropertiesToResource (
fileURL,
data,
NULL,
&errorCode);
cleanup:
if (pathstr)
CFRelease(pathstr);
if (fileURL)
CFRelease(fileURL);
if (data)
CFRelease(data);
if (err)
CFRelease(err);
return ret;
}
// domain should already be locked.
static Boolean _writeXMLFile(CFURLRef url, CFMutableDictionaryRef dict, Boolean isWorldReadable, Boolean *tryAgain) {
Boolean success = false;
CFAllocatorRef alloc = __CFPreferencesAllocator();
*tryAgain = false;
if (CFDictionaryGetCount(dict) == 0) {
// Destroy the file
CFBooleanRef val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, url, kCFURLFileExists, NULL);
if (val && CFBooleanGetValue(val)) {
success = CFURLDestroyResource(url, NULL);
} else {
success = true;
}
if (val) CFRelease(val);
} else {
CFPropertyListFormat desiredFormat = __CFPreferencesShouldWriteXML() ? kCFPropertyListXMLFormat_v1_0 : kCFPropertyListBinaryFormat_v1_0;
CFDataRef data = CFPropertyListCreateData(alloc, dict, desiredFormat, 0, NULL);
if (data) {
SInt32 mode;
#if TARGET_OS_OSX || TARGET_OS_LINUX
mode = isWorldReadable ? S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH : S_IRUSR|S_IWUSR;
#else
mode = 0666;
#endif
#if TARGET_OS_OSX
{ // Try quick atomic way first, then fallback to slower ways and error cases
CFStringRef scheme = CFURLCopyScheme(url);
if (!scheme) {
*tryAgain = false;
CFRelease(data);
return false;
} else if (CFStringCompare(scheme, CFSTR("file"), 0) == kCFCompareEqualTo) {
SInt32 length = CFDataGetLength(data);
const void *bytes = (0 == length) ? (const void *)"" : CFDataGetBytePtr(data);
Boolean atomicWriteSuccess = __CFWriteBytesToFileWithAtomicity(url, bytes, length, mode, true);
if (atomicWriteSuccess) {
CFRelease(scheme);
*tryAgain = false;
CFRelease(data);
return true;
}
if (!atomicWriteSuccess && thread_errno() == ENOSPC) {
CFRelease(scheme);
*tryAgain = false;
CFRelease(data);
return false;
}
}
CFRelease(scheme);
}
#endif
success = CFURLWriteDataAndPropertiesToResource(url, data, URLPropertyDictForPOSIXMode(mode), NULL);
URLPropertyDictRelease();
if (success) {
CFDataRef readData;
if (!CFURLCreateDataAndPropertiesFromResource(alloc, url, &readData, NULL, NULL, NULL) || !CFEqual(readData, data)) {
success = false;
*tryAgain = true;
}
if (readData) CFRelease(readData);
} else {
CFBooleanRef val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, url, kCFURLFileExists, NULL);
if (!val || !CFBooleanGetValue(val)) {
CFURLRef tmpURL = CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR("."), kCFURLPOSIXPathStyle, true, url); // Just "." because url is not a directory URL
CFURLRef parentURL = tmpURL ? CFURLCopyAbsoluteURL(tmpURL) : NULL;
if (tmpURL) CFRelease(tmpURL);
if (val) CFRelease(val);
val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, parentURL, kCFURLFileExists, NULL);
if ((!val || !CFBooleanGetValue(val)) && _createDirectory(parentURL, isWorldReadable)) {
// parent directory didn't exist; now it does; try again to write
success = CFURLWriteDataAndPropertiesToResource(url, data, URLPropertyDictForPOSIXMode(mode), NULL);
URLPropertyDictRelease();
if (success) {
CFDataRef rdData;
if (!CFURLCreateDataAndPropertiesFromResource(alloc, url, &rdData, NULL, NULL, NULL) || !CFEqual(rdData, data)) {
success = false;
*tryAgain = true;
}
if (rdData) CFRelease(rdData);
}
}
if (parentURL) CFRelease(parentURL);
}
if (val) CFRelease(val);
}
CFRelease(data);
} else {
// ??? This should never happen
CFLog(__kCFLogAssertion, CFSTR("Could not generate XML data for property list"));
success = false;
}
}
return success;
}
Boolean IOCFURLWriteDataAndPropertiesToResource(CFURLRef url, CFDataRef dataToWrite, CFDictionaryRef propertiesToWrite, SInt32 *errorCode)
{
return (CFURLWriteDataAndPropertiesToResource(url, dataToWrite, propertiesToWrite, errorCode));
}