//

 //  CFGrowlAdditions.c

 //  Growl

 //

 //  Created by Mac-arena the Bored Zo on Wed Jun 18 2004.

 //  Copyright 2005-2006 The Growl Project.

 //

 // This file is under the BSD License, refer to License.txt for details

 #include <Carbon/Carbon.h>

 #include <unistd.h>

 #include <netinet/in.h>

 #include <arpa/inet.h>

 #include <netdb.h>

 #include "CFGrowlAdditions.h"

 #ifndef MIN

 # define MIN(a,b) ((a) < (b) ? (a) : (b))

 #endif

 extern Boolean CFStringGetFileSystemRepresentation() __attribute__((weak_import));

 extern CFIndex CFStringGetMaximumSizeOfFileSystemRepresentation(CFStringRef string) __attribute__((weak_import));

 char *createFileSystemRepresentationOfString(CFStringRef str) {

 	char *buffer;

 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4

 	/* CFStringGetFileSystemRepresentation will cause a link error despite the weak_import attribute above on 10.5 when compiling with 10.2 compatibility using gcc 3.3.

 	 * PPC will therefore always use the 10.3 and below method of creating a file system representation.

 	 */

 	if (CFStringGetFileSystemRepresentation) {

 		CFIndex size = CFStringGetMaximumSizeOfFileSystemRepresentation(str);

 		buffer = malloc(size);

 		CFStringGetFileSystemRepresentation(str, buffer, size);

 	} else 

 #endif

 	{

 		buffer = malloc(512);

 		CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, str, kCFURLPOSIXPathStyle, false);

 		if (!CFURLGetFileSystemRepresentation(url, false, (UInt8 *)buffer, 512)) {

 			free(buffer);

 			buffer = NULL;

 		}

 		CFRelease(url);

 	}

 	return buffer;

 }

 STRING_TYPE createStringWithDate(CFDateRef date) {

 	CFLocaleRef locale = CFLocaleCopyCurrent();

 	CFDateFormatterRef dateFormatter = CFDateFormatterCreate(kCFAllocatorDefault,

 															 locale,

 															 kCFDateFormatterMediumStyle,

 															 kCFDateFormatterMediumStyle);

 	CFRelease(locale);

 	CFStringRef dateString = CFDateFormatterCreateStringWithDate(kCFAllocatorDefault,

 																 dateFormatter,

 																 date);

 	CFRelease(dateFormatter);

 	return dateString;

 }

 STRING_TYPE createStringWithContentsOfFile(CFStringRef filename, CFStringEncoding encoding) {

 	CFStringRef str = NULL;

 	char *path = createFileSystemRepresentationOfString(filename);

 	if (path) {

 		FILE *fp = fopen(path, "rb");

 		if (fp) {

 			fseek(fp, 0, SEEK_END);

 			unsigned long size = ftell(fp);

 			fseek(fp, 0, SEEK_SET);

 			unsigned char *buffer = malloc(size);

 			if (buffer && fread(buffer, 1, size, fp) == size)

 				str = CFStringCreateWithBytes(kCFAllocatorDefault, buffer, size, encoding, true);

 			fclose(fp);

 		}

 		free(path);

 	}

 	return str;

 }

 STRING_TYPE createStringWithStringAndCharacterAndString(STRING_TYPE str0, UniChar ch, STRING_TYPE str1) {

 	CFStringRef cfstr0 = (CFStringRef)str0;

 	CFStringRef cfstr1 = (CFStringRef)str1;

 	CFIndex len0 = (cfstr0 ? CFStringGetLength(cfstr0) : 0);

 	CFIndex len1 = (cfstr1 ? CFStringGetLength(cfstr1) : 0);

 	unsigned length = (len0 + (ch != 0xffff) + len1);

 	UniChar *buf = malloc(sizeof(UniChar) * length);

 	unsigned i = 0U;

 	if (cfstr0) {

 		CFStringGetCharacters(cfstr0, CFRangeMake(0, len0), buf);

 		i += len0;

 	}

 	if (ch != 0xffff)

 		buf[i++] = ch;

 	if (cfstr1)

 		CFStringGetCharacters(cfstr1, CFRangeMake(0, len1), &buf[i]);

 	return CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, buf, length, /*contentsDeallocator*/ kCFAllocatorMalloc);

 }

 char *copyCString(STRING_TYPE str, CFStringEncoding encoding) {

 	CFIndex size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), encoding) + 1;

 	char *buffer = calloc(size, 1);

 	CFStringGetCString(str, buffer, size, encoding);

 	return buffer;

 }

 STRING_TYPE copyCurrentProcessName(void) {

 	ProcessSerialNumber PSN = { 0, kCurrentProcess };

 	CFStringRef name = NULL;

 	OSStatus err = CopyProcessName(&PSN, &name);

 	if (err != noErr) {

 		NSLog(CFSTR("in copyCurrentProcessName in CFGrowlAdditions: Could not get process name because CopyProcessName returned %li"), (long)err);

 		name = NULL;

 	}

 	return name;

 }

 URL_TYPE copyCurrentProcessURL(void) {

 	ProcessSerialNumber psn = { 0, kCurrentProcess };

 	FSRef fsref;

 	CFURLRef URL = NULL;

 	OSStatus err = GetProcessBundleLocation(&psn, &fsref);

 	if (err != noErr) {

 		NSLog(CFSTR("in copyCurrentProcessURL in CFGrowlAdditions: Could not get application location, because GetProcessBundleLocation returned %li\n"), (long)err);

 	} else {

 		URL = CFURLCreateFromFSRef(kCFAllocatorDefault, &fsref);

 	}

 	return URL;

 }

 STRING_TYPE copyCurrentProcessPath(void) {

 	CFURLRef URL = copyCurrentProcessURL();

 	CFStringRef path = CFURLCopyFileSystemPath(URL, kCFURLPOSIXPathStyle);

 	CFRelease(URL);

 	return path;

 }

 URL_TYPE copyTemporaryFolderURL(void) {

 	FSRef ref;

 	CFURLRef url = NULL;

 	OSStatus err = FSFindFolder(kOnAppropriateDisk, kTemporaryFolderType, kCreateFolder, &ref);

 	if (err != noErr)

 		NSLog(CFSTR("in copyTemporaryFolderPath in CFGrowlAdditions: Could not locate temporary folder because FSFindFolder returned %li"), (long)err);

 	else

 		url = CFURLCreateFromFSRef(kCFAllocatorDefault, &ref);

 	return url;

 }

 STRING_TYPE copyTemporaryFolderPath(void) {

 	CFStringRef path = NULL;

 	CFURLRef url = copyTemporaryFolderURL();

 	if (url) {

 		path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);

 		CFRelease(url);

 	}

 	return path;

 }

 DATA_TYPE readFile(const char *filename)

 {

 	CFDataRef data;

 	// read the file into a CFDataRef

 	FILE *fp = fopen(filename, "r");

 	if (fp) {

 		fseek(fp, 0, SEEK_END);

 		long dataLength = ftell(fp);

 		fseek(fp, 0, SEEK_SET);

 		unsigned char *fileData = malloc(dataLength);

 		fread(fileData, 1, dataLength, fp);

 		fclose(fp);

 		data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, fileData, dataLength, kCFAllocatorMalloc);

 	} else

 		data = NULL;

 	return data;

 }

 URL_TYPE copyURLForApplication(STRING_TYPE appName)

 {

 	CFURLRef appURL = NULL;

 	OSStatus err = LSFindApplicationForInfo(/*inCreator*/  kLSUnknownCreator,

 											/*inBundleID*/ NULL,

 											/*inName*/     appName,

 											/*outAppRef*/  NULL,

 											/*outAppURL*/  &appURL);

 	return (err == noErr) ? appURL : NULL;

 }

 STRING_TYPE createStringWithAddressData(DATA_TYPE aAddressData) {

 	struct sockaddr *socketAddress = (struct sockaddr *)CFDataGetBytePtr(aAddressData);

 	// IPv6 Addresses are "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF"

 	//      at max, which is 40 bytes (0-terminated)

 	// IPv4 Addresses are "255.255.255.255" at max which is smaller

 	char stringBuffer[40];

 	CFStringRef addressAsString = NULL;

 	if (socketAddress->sa_family == AF_INET) {

 		struct sockaddr_in *ipv4 = (struct sockaddr_in *)socketAddress;

 		if (inet_ntop(AF_INET, &(ipv4->sin_addr), stringBuffer, 40))

 			addressAsString = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%s:%d"), stringBuffer, ipv4->sin_port);

 		else

 			addressAsString = CFSTR("IPv4 un-ntopable");

 	} else if (socketAddress->sa_family == AF_INET6) {

 		struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)socketAddress;

 		if (inet_ntop(AF_INET6, &(ipv6->sin6_addr), stringBuffer, 40))

 			// Suggested IPv6 format (see http://www.faqs.org/rfcs/rfc2732.html)

 			addressAsString = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("[%s]:%d"), stringBuffer, ipv6->sin6_port);

 		else

 			addressAsString = CFSTR("IPv6 un-ntopable");

 	} else

 		addressAsString = CFSTR("neither IPv6 nor IPv4");

 	return addressAsString;

 }

 STRING_TYPE createHostNameForAddressData(DATA_TYPE aAddressData) {

 	char hostname[NI_MAXHOST];

 	struct sockaddr *socketAddress = (struct sockaddr *)CFDataGetBytePtr(aAddressData);

 	if (getnameinfo(socketAddress, CFDataGetLength(aAddressData),

 					hostname, sizeof(hostname),

 					/*serv*/ NULL, /*servlen*/ 0,

 					NI_NAMEREQD))

 		return NULL;

 	else

 		return CFStringCreateWithCString(kCFAllocatorDefault, hostname, kCFStringEncodingASCII);

 }

 DATA_TYPE copyIconDataForPath(STRING_TYPE path) {

 	CFDataRef data = NULL;

 	//false is probably safest, and is harmless when the object really is a directory.

 	CFURLRef URL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path, kCFURLPOSIXPathStyle, /*isDirectory*/ false);

 	if (URL) {

 		data = copyIconDataForURL(URL);

 		CFRelease(URL);

 	}

 	return data;

 }

 DATA_TYPE copyIconDataForURL(URL_TYPE URL)

 {

 	CFDataRef data = NULL;

 	if (URL) {

 		FSRef ref;

 		if (CFURLGetFSRef(URL, &ref)) {

 			IconRef icon = NULL;

 			SInt16 label_noOneCares;

 			OSStatus err = GetIconRefFromFileInfo(&ref,

 												  /*inFileNameLength*/ 0U, /*inFileName*/ NULL,

 												  kFSCatInfoNone, /*inCatalogInfo*/ NULL,

 												  kIconServicesNoBadgeFlag | kIconServicesUpdateIfNeededFlag,

 												  &icon,

 												  &label_noOneCares);

 			if (err != noErr) {

 				NSLog(CFSTR("in copyIconDataForURL in CFGrowlAdditions: could not get icon for %@: GetIconRefFromFileInfo returned %li\n"), URL, (long)err);

 			} else {

 				IconFamilyHandle fam = NULL;

 				err = IconRefToIconFamily(icon, kSelectorAllAvailableData, &fam);

 				if (err != noErr) {

 					NSLog(CFSTR("in copyIconDataForURL in CFGrowlAdditions: could not get icon for %@: IconRefToIconFamily returned %li\n"), URL, (long)err);

 				} else {

 					HLock((Handle)fam);

 					data = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)*(Handle)fam, GetHandleSize((Handle)fam));

 					HUnlock((Handle)fam);

 					DisposeHandle((Handle)fam);

 				}

 				ReleaseIconRef(icon);

 			}

 		}

 	}

 	return data;

 }

 URL_TYPE createURLByMakingDirectoryAtURLWithName(URL_TYPE parent, STRING_TYPE name)

 {

 	CFURLRef newDirectory = NULL;

 	CFAllocatorRef allocator = parent ? CFGetAllocator(parent) : name ? CFGetAllocator(name) : kCFAllocatorDefault;

 	if (parent) parent = CFRetain(parent);

 	else {

 		char *cwdBytes = alloca(PATH_MAX);

 		getcwd(cwdBytes, PATH_MAX);

 		parent = CFURLCreateFromFileSystemRepresentation(allocator, (const unsigned char *)cwdBytes, strlen(cwdBytes), /*isDirectory*/ true);

 		if (!name) {

 			newDirectory = parent;

 			goto end;

 		}

 	}

 	if (!parent)

 		NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: parent directory URL is NULL (please tell the Growl developers)\n"), parent);

 	else {

 		if (name)

 			name = CFRetain(name);

 		else {

 			name = CFURLCopyLastPathComponent(parent);

 			CFURLRef newParent = CFURLCreateCopyDeletingLastPathComponent(allocator, parent);

 			CFRelease(parent);

 			parent = newParent;

 		}

 		if (!name)

 			NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: name of directory to create is NULL (please tell the Growl developers)\n"), parent);

 		else {

 			FSRef parentRef;

 			if (!CFURLGetFSRef(parent, &parentRef))

 				NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: could not create FSRef for parent directory at %@ (please tell the Growl developers)\n"), parent);

 			else {

 				FSRef newDirectoryRef;

 				struct HFSUniStr255 nameUnicode;

 				CFRange range = { 0, MIN(CFStringGetLength(name), USHRT_MAX) };

 				CFStringGetCharacters(name, range, nameUnicode.unicode);

 				nameUnicode.length = range.length;

 				struct FSRefParam refPB = {

 					.ref              = &parentRef,

 					.nameLength       = nameUnicode.length,

 					.name             = nameUnicode.unicode,

 					.whichInfo        = kFSCatInfoNone,

 					.catInfo          = NULL,

 					.textEncodingHint = kTextEncodingUnknown,

 					.newRef           = &newDirectoryRef,

 				};

 				OSStatus err = PBCreateDirectoryUnicodeSync(&refPB);

 				if (err == dupFNErr) {

 					//dupFNErr == file (or folder) exists already. this is fine.

 					err = PBMakeFSRefUnicodeSync(&refPB);

 				}

 				if (err == noErr) {

 					NSLog(CFSTR("PBCreateDirectoryUnicodeSync or PBMakeFSRefUnicodeSync returned %li; calling CFURLCreateFromFSRef"), (long)err); //XXX

 					newDirectory = CFURLCreateFromFSRef(allocator, &newDirectoryRef);

 					NSLog(CFSTR("CFURLCreateFromFSRef returned %@"), newDirectory); //XXX

 				} else

 					NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: could not create directory '%@' in parent directory at %@: FSCreateDirectoryUnicode returned %li (please tell the Growl developers)"), name, parent, (long)err);

 			}

 		} //if (name)

 		if(parent)

 			CFRelease(parent);

 		if(name)

 			CFRelease(name);

 	} //if (parent)

 end:

 	return newDirectory;

 }

 #ifndef COPYFORK_BUFSIZE

 #	define COPYFORK_BUFSIZE 5242880U /*5 MiB*/

 #endif

 static OSStatus copyFork(const struct HFSUniStr255 *forkName, const FSRef *srcFile, const FSRef *destDir, const struct HFSUniStr255 *destName, FSRef *outDestFile) {

 	OSStatus err, closeErr;

 	struct FSForkIOParam srcPB = {

 		.ref = srcFile,

 		.forkNameLength = forkName->length,

 		.forkName = forkName->unicode,

 		.permissions = fsRdPerm,

 	};

 	unsigned char debuggingPathBuf[PATH_MAX] = "";

 	OSStatus debuggingPathErr;

 	err = PBOpenForkSync(&srcPB);

 	if (err != noErr) {

 		debuggingPathErr = FSRefMakePath(srcFile, debuggingPathBuf, PATH_MAX);

 		if (debuggingPathErr != noErr)

 			snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr);

 		NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBOpenForkSync (source: %s) returned %li"), debuggingPathBuf, (long)err);

 	} else {

 		FSRef destFile;

 		/*the first thing to do is get the name of the destination file, if one

 		 *	wasn't provided.

 		 *and while we're at it, we get the catalogue info as well.

 		 */

 		struct FSCatalogInfo catInfo;

 		struct FSRefParam refPB = {

 			.ref       = srcFile,

 			.whichInfo = kFSCatInfoGettableInfo & kFSCatInfoSettableInfo,

 			.catInfo   = &catInfo,

 			.spec      = NULL,

 			.parentRef = NULL,

 			.outName   = destName ? NULL : (struct HFSUniStr255 *)(destName = alloca(sizeof(struct HFSUniStr255))),

 		};

 		err = PBGetCatalogInfoSync(&refPB);

 		if (err != noErr) {

 			debuggingPathErr = FSRefMakePath(srcFile, debuggingPathBuf, PATH_MAX);

 			if (debuggingPathErr != noErr)

 				snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr);

 			NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBGetCatalogInfoSync (source: %s) returned %li"), debuggingPathBuf, (long)err);

 		} else {

 			refPB.ref              = destDir;

 			refPB.nameLength       = destName->length;

 			refPB.name             = destName->unicode;

 			refPB.textEncodingHint = kTextEncodingUnknown;

 			refPB.newRef           = &destFile;

 			const char *functionName = "PBMakeFSRefUnicodeSync"; //for error-reporting message

 			err = PBMakeFSRefUnicodeSync(&refPB);

 			if ((err != noErr) && (err != fnfErr)) {

 			handleMakeFSRefError:

 				debuggingPathErr = FSRefMakePath(destDir, debuggingPathBuf, PATH_MAX);

 				if (debuggingPathErr != noErr)

 					snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for destination directory: FSRefMakePath returned %li)", (long)debuggingPathErr);

 				//get filename too

 				CFStringRef debuggingFilename = CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault,

 																				   destName->unicode,

 																				   destName->length,

 																				   /*contentsDeallocator*/ kCFAllocatorNull);

 				if (!debuggingFilename)

 					debuggingFilename = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, "(could not get filename for destination file: CFStringCreateWithCharactersNoCopy returned NULL)", kCFStringEncodingASCII, /*contentsDeallocator*/ kCFAllocatorNull);

 				NSLog(CFSTR("in copyFork in CFGrowlAdditions: %s (destination: %s/%@) returned %li"), functionName, debuggingPathBuf, debuggingFilename, (long)err);

 				if (debuggingFilename) CFRelease(debuggingFilename);

 			} else {

 				//that file doesn't exist in that folder; create it.

 				err = PBCreateFileUnicodeSync(&refPB);

 				if (err == noErr) {

 					/*make sure the Finder knows about the new file.

 					 *FNNotify returns a status code too, but this isn't an

 					 *	essential step, so we just ignore it.

 					 */

 					FNNotify(destDir, kFNDirectoryModifiedMessage, kNilOptions);

 				} else if (err == dupFNErr) {

 					/*dupFNErr: the file already exists.

 					 *we can safely ignore this error.

 					 */

 					err = noErr;

 				} else {

 					functionName = "PBCreateFileUnicodeSync";

 					goto handleMakeFSRefError;

 				}

 			}

 		}

 		if (err == noErr) {

 			if (outDestFile)

 				memcpy(outDestFile, &destFile, sizeof(destFile));

 			struct FSForkIOParam destPB = {

 				.ref            = &destFile,

 				.forkNameLength = forkName->length,

 				.forkName       = forkName->unicode,

 				.permissions    = fsWrPerm,

 			};

 			err = PBOpenForkSync(&destPB);

 			NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBOpenForkSync (dest) returned %li"), (long)err);

 			if (err != noErr) {

 				debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX);

 				if (debuggingPathErr != noErr)

 					snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for dest file: FSRefMakePath returned %li)", (long)debuggingPathErr);

 				NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBOpenForkSync (destination: %s) returned %li"), debuggingPathBuf, (long)err);

 			} else {

 				void *buf = malloc(COPYFORK_BUFSIZE);

 				if (buf) {

 					srcPB.buffer = destPB.buffer = buf;

 					srcPB.requestCount = COPYFORK_BUFSIZE;

 					while (err == noErr) {

 						err = PBReadForkSync(&srcPB);

 						if (err == eofErr) {

 							err = noErr;

 							if (srcPB.actualCount == 0)

 								break;

 						}

 						if (err != noErr) {

 							debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX);

 							if (debuggingPathErr != noErr)

 								snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr);

 							NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBReadForkSync (source: %s) returned %li"), debuggingPathBuf, (long)err);

 						} else {

 							destPB.requestCount = srcPB.actualCount;

 							err = PBWriteForkSync(&destPB);

 							if (err != noErr) {

 								debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX);

 								if (debuggingPathErr != noErr)

 									snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for dest file: FSRefMakePath returned %li)", (long)debuggingPathErr);

 								NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBWriteForkSync (destination: %s) returned %li"), debuggingPathBuf, (long)err);

 							}

 						}

 					}

 					free(buf);

 				}

 				closeErr = PBCloseForkSync(&destPB);

 				if (closeErr != noErr) {

 					debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX);

 					if (debuggingPathErr != noErr)

 						snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for dest file: FSRefMakePath returned %li)", (long)debuggingPathErr);

 					NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBCloseForkSync (destination: %s) returned %li"), debuggingPathBuf, (long)err);

 				}

 				if (err == noErr) err = closeErr;

 			}

 		}

 		closeErr = PBCloseForkSync(&srcPB);

 		if (closeErr != noErr) {

 			debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX);

 			if (debuggingPathErr != noErr)

 				snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr);

 			NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBCloseForkSync (source: %s) returned %li"), debuggingPathBuf, (long)err);

 		}

 		if (err == noErr) err = closeErr;

 	}

 	return err;

 }

 static OSStatus GrowlCopyObjectSync(const FSRef *fileRef, const FSRef *destRef, FSRef *destFileRef) {

 	OSStatus err;

 	struct HFSUniStr255 forkName;

 	struct FSForkIOParam forkPB = {

 		.ref = fileRef,

 		.forkIterator = {

 			.initialize = 0L

 		},

 		.outForkName = &forkName,

 	};

 	do {

 		err = PBIterateForksSync(&forkPB);

 		NSLog(CFSTR("PBIterateForksSync returned %li"), (long)err);

 		if (err != noErr) {

 			if (err != errFSNoMoreItems)

 				NSLog(CFSTR("in GrowlCopyObjectSync in CFGrowlAdditions: PBIterateForksSync returned %li"), (long)err);

 		} else {

 			err = copyFork(&forkName, fileRef, destRef, /*destName*/ NULL, /*outDestFile*/ destFileRef);

 			//copyFork prints its own error messages

 		}

 	} while (err == noErr);

 	if (err == errFSNoMoreItems) err = noErr;

 	return err;

 }

 URL_TYPE createURLByCopyingFileFromURLToDirectoryURL(URL_TYPE file, URL_TYPE dest)

 {

 	CFURLRef destFileURL = NULL;

 	FSRef fileRef, destRef, destFileRef;

 	Boolean gotFileRef = CFURLGetFSRef(file, &fileRef);

 	Boolean gotDestRef = CFURLGetFSRef(dest, &destRef);

 	if (!gotFileRef)

 		NSLog(CFSTR("in createURLByCopyingFileFromURLToDirectoryURL in CFGrowlAdditions: CFURLGetFSRef failed with source URL %@"), file);

 	else if (!gotDestRef)

 		NSLog(CFSTR("in createURLByCopyingFileFromURLToDirectoryURL in CFGrowlAdditions: CFURLGetFSRef failed with destination URL %@"), dest);

 	else {

 		OSStatus err;

 		/*

 		 * 10.2 has a problem with weak symbols in frameworks so we use

 		 * MAC_OS_X_VERSION_MIN_REQUIRED >= 10.3.

 		 */

 #if defined(NSAppKitVersionNumber10_3) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3

 		if (FSCopyObjectSync) {

 			err = FSCopyObjectSync(&fileRef, &destRef, /*destName*/ NULL, &destFileRef, kFSFileOperationOverwrite);

 		} else {

 #endif

 			err = GrowlCopyObjectSync(&fileRef, &destRef, &destFileRef);

 #if defined(NSAppKitVersionNumber10_3) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3

 		}

 #endif

 		if (err == noErr)

 			destFileURL = CFURLCreateFromFSRef(kCFAllocatorDefault, &destFileRef);

 		else

 			NSLog(CFSTR("in createURLByCopyingFileFromURLToDirectoryURL in CFGrowlAdditions: CopyObjectSync returned %li for source URL %@"), (long)err, file);

 	}

 	return destFileURL;

 }

 PLIST_TYPE createPropertyListFromURL(URL_TYPE file, u_int32_t mutability, CFPropertyListFormat *outFormat, STRING_TYPE *outErrorString)

 {

 	CFPropertyListRef plist = NULL;

 	if (!file)

 		NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: cannot read from a NULL URL"));

 	else {

 		CFReadStreamRef stream = CFReadStreamCreateWithFile(kCFAllocatorDefault, file);

 		if (!stream)

 			NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: could not create stream for reading from URL %@"), file);

 		else {

 			if (!CFReadStreamOpen(stream))

 				NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: could not open stream for reading from URL %@"), file);

 			else {

 				CFPropertyListFormat format;

 				CFStringRef errorString = NULL;

 				plist = CFPropertyListCreateFromStream(kCFAllocatorDefault,

 													   stream,

 													   /*streamLength*/ 0,

 													   mutability,

 													   &format,

 													   &errorString);

 				if (!plist)

 					NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: could not read property list from URL %@ (error string: %@)"), file, errorString);

 				if (outFormat) *outFormat = format;

 				if (errorString) {

 					if (outErrorString)

 						*outErrorString = errorString;

 					else

 						CFRelease(errorString);

 				}

 				CFReadStreamClose(stream);

 			}

 			CFRelease(stream);

 		}

 	}

 	return plist;

 }