void TestController::initializeInjectedBundlePath()
{
CFStringRef exeContainerPath = CFURLCopyFileSystemPath(CFURLCreateCopyDeletingLastPathComponent(0, CFBundleCopyExecutableURL(CFBundleGetMainBundle())), kCFURLWindowsPathStyle);
CFMutableStringRef bundlePath = CFStringCreateMutableCopy(0, 0, exeContainerPath);
CFStringAppendCString(bundlePath, injectedBundleDLL, kCFStringEncodingWindowsLatin1);
m_injectedBundlePath.adopt(WKStringCreateWithCFString(bundlePath));
}
int convertChars(char *from, int fromLen, void *fromCode, char *to, int toLen, void *toCode, int norm, int term)
{
CFStringRef cfs= CFStringCreateWithBytes(NULL, (UInt8 *) from, fromLen, (CFStringEncoding)fromCode, 0);
if (cfs == NULL) {
toLen = 0;
to[toLen]= '\0';
return toLen;
}
CFMutableStringRef str= CFStringCreateMutableCopy(NULL, 0, cfs);
CFRelease(cfs);
if (norm) // HFS+ imposes Unicode2.1 decomposed UTF-8 encoding on all path elements
CFStringNormalize(str, kCFStringNormalizationFormD); // canonical decomposition
else
CFStringNormalize(str, kCFStringNormalizationFormC); // pre-combined
{
CFRange rng= CFRangeMake(0, CFStringGetLength(str));
CFIndex len= 0;
CFIndex num= CFStringGetBytes(str, rng, (CFStringEncoding)toCode, '?', 0, (UInt8 *)to, toLen - term, &len);
CFRelease(str);
if (!num)
return convertCopy(from, fromLen, to, toLen, term);
if (term)
to[len]= '\0';
return len;
}
}
void PathToFileViaFSRef(char *pathName, int pathNameMax, FSRef *theFSRef,CFStringEncoding encoding) {
CFURLRef sillyThing;
CFStringRef filePath;
Boolean isDirectory;
pathName[0]= 0x00;
sillyThing = CFURLCreateFromFSRef (kCFAllocatorDefault, theFSRef);
if (sillyThing == NULL)
return;
isDirectory = CFURLHasDirectoryPath(sillyThing);
filePath = CFURLCopyFileSystemPath (sillyThing, kCFURLPOSIXPathStyle);
CFRelease(sillyThing);
CFMutableStringRef mutableStr= CFStringCreateMutableCopy(NULL, 0, filePath);
CFRelease(filePath);
// HFS+ imposes Unicode2.1 decomposed UTF-8 encoding on all path elements
if (encoding == kCFStringEncodingUTF8)
CFStringNormalize(mutableStr, kCFStringNormalizationFormC); // pre-combined
CFStringGetCString (mutableStr, pathName,pathNameMax, encoding);
CFRelease(mutableStr);
if (isDirectory)
strcat(pathName,"/");
}
bool setPlayerWinTitle(CFStringRef sTitle)
{
CFMutableStringRef sFinalStr = NULL;
OSStatus iErr = noErr;
if (NULL == (sFinalStr = CFStringCreateMutableCopy(NULL, 8 + CFStringGetLength(sTitle), CFSTR("Frogg - "))))
{
fprintf(stderr, "setPlayerWinTitle() - CFStringCreateMutableCopy() failed!\n");
return false;
}
else
{
CFStringAppend(sFinalStr, sTitle);
if (noErr != (iErr = SetWindowTitleWithCFString(g_refPlayerWin, sFinalStr)))
{
CFRelease(sFinalStr);
fprintf(stderr, "setPlayerWinTitle() - SetWindowTitleWithCFString() failed, returning %lu!\n", (unsigned long) iErr);
return false;
}
CFRelease(sFinalStr);
return true;
}
}
__private_extern__
void
ipv6_duplicated_address(const char * if_name, const struct in6_addr * addr,
int hw_len, const void * hw_addr)
{
uint8_t * hw_addr_bytes = (uint8_t *)hw_addr;
int i;
CFStringRef if_name_cf;
CFMutableStringRef key;
char ntopbuf[INET6_ADDRSTRLEN];
CFStringRef prefix;
if_name_cf = CFStringCreateWithCString(NULL, if_name,
kCFStringEncodingASCII);
prefix = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
kSCDynamicStoreDomainState,
if_name_cf,
kSCEntNetIPv6DuplicatedAddress);
ntopbuf[0] = '\0';
(void)inet_ntop(AF_INET6, addr, ntopbuf, sizeof(ntopbuf));
key = CFStringCreateMutableCopy(NULL, 0, prefix);
CFStringAppendFormat(key, NULL, CFSTR("/%s"), ntopbuf);
for (i = 0; i < hw_len; i++) {
CFStringAppendFormat(key, NULL, CFSTR("%s%02x"),
(i == 0) ? "/" : ":", hw_addr_bytes[i]);
}
cache_SCDynamicStoreNotifyValue(store, key);
CFRelease(key);
CFRelease(prefix);
CFRelease(if_name_cf);
}
CF_EXPORT CFStringRef CFBundleCopyLocalizedStringForLocalization(CFBundleRef bundle, CFStringRef key, CFStringRef value, CFStringRef tableName, CFStringRef localizationName) {
if (!key) { return (value ? (CFStringRef)CFRetain(value) : (CFStringRef)CFRetain(CFSTR(""))); }
// Make sure to check the mixed localizations key early -- if the main bundle has not yet been cached, then we need to create the cache of the Info.plist before we start asking for resources (11172381)
(void)CFBundleAllowMixedLocalizations();
if (!tableName || CFEqual(tableName, CFSTR(""))) tableName = _CFBundleDefaultStringTableName;
CFStringRef result = _copyStringFromTable(bundle, tableName, key, localizationName);
if (!result) {
if (!value) {
result = (CFStringRef)CFRetain(key);
} else if (CFEqual(value, CFSTR(""))) {
result = (CFStringRef)CFRetain(key);
} else {
result = (CFStringRef)CFRetain(value);
}
static Boolean capitalize = false;
if (capitalize) {
CFMutableStringRef capitalizedResult = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, 0, result);
os_log_error(_CFBundleLocalizedStringLogger(), "ERROR: %@ not found in table %@ of bundle %@", key, tableName, bundle);
CFStringUppercase(capitalizedResult, NULL);
CFRelease(result);
result = capitalizedResult;
}
}
os_log_debug(_CFBundleLocalizedStringLogger(), "Bundle: %{private}@, key: %{public}@, value: %{public}@, table: %{public}@, localizationName: %{public}@, result: %{public}@", bundle, key, value, tableName, localizationName, result);
return result;
}
void CAComponent::SetCompNames () const
{
if (!mCompName) {
CFStringRef compName;
OSStatus result = AudioComponentCopyName (Comp(), &compName);
if (result) return;
const_cast<CAComponent*>(this)->mCompName = compName;
if (compName)
{
CFArrayRef splitStrArray = CFStringCreateArrayBySeparatingStrings(NULL, compName, CFSTR(":"));
// we need to retain these values so the strings are not lost when the array is released
const_cast<CAComponent*>(this)->mManuName = (CFStringRef)CFArrayGetValueAtIndex(splitStrArray, 0);
CFRetain(this->mManuName);
if (CFArrayGetCount(splitStrArray) > 1)
{
CFStringRef str = (CFStringRef)CFArrayGetValueAtIndex(splitStrArray, 1);
CFMutableStringRef mstr = CFStringCreateMutableCopy (NULL, CFStringGetLength(str), str);
// this needs to trim out white space:
CFStringTrimWhitespace (mstr);
const_cast<CAComponent*>(this)->mAUName = mstr;
} else
const_cast<CAComponent*>(this)->mAUName = NULL;
CFRelease(splitStrArray);
}
}
}
/*
* Create the target name using the host name. Note we will use the
* GSS_C_NT_HOSTBASE name type of cifs@<server> and will return a CFString
*/
CFStringRef TargetNameCreatedWithHostName(struct smb_ctx *ctx)
{
CFStringRef hostName;
CFMutableStringRef kerbHintsHostname;
/* We need to add "cifs@ server part" */
kerbHintsHostname = CFStringCreateMutableCopy(kCFAllocatorDefault, 0,
CFSTR("cifs@"));
if (kerbHintsHostname == NULL) {
return NULL;
}
/*
* The old code would return an IP dot address if the name was NetBIOS. This
* was done for Leopard gss. After talking this over with LHA we now always
* return the server name. The IP dot address never worked and was causing
* Dfs links to fail.
*/
hostName = CFStringCreateWithCString(kCFAllocatorDefault, ctx->serverName, kCFStringEncodingUTF8);
if (hostName) {
CFStringAppend(kerbHintsHostname, hostName);
CFRelease(hostName);
} else {
CFRelease(kerbHintsHostname);
kerbHintsHostname = NULL;
}
return kerbHintsHostname;
}
__private_extern__ CFStringRef _CFPreferencesGetByHostIdentifierString(void) {
static CFStringRef __byHostIdentifierString = NULL;
if (!__byHostIdentifierString) {
CFStringRef hostID = _CFGetHostUUIDString();
if (hostID) {
if (CFStringHasPrefix(hostID, CFSTR("00000000-0000-1000-8000-"))) {
// If the host UUID is prefixed by "00000000-0000-1000-8000-" then the UUID returned is the "compatible" type. The last field of the string will be the MAC address of the primary ethernet interface of the computer. We use this for compatibility with existing by-host preferences.
CFStringRef lastField = CFStringCreateWithSubstring(kCFAllocatorSystemDefault, hostID, CFRangeMake(24, 12));
CFMutableStringRef tmpstr = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, 0, lastField);
CFStringLowercase(tmpstr, NULL);
CFStringRef downcasedField = CFStringCreateCopy(kCFAllocatorSystemDefault, tmpstr);
if (!OSAtomicCompareAndSwapPtrBarrier(NULL, (void *)downcasedField, (void *)&__byHostIdentifierString)) {
CFRelease(downcasedField);
}
CFRelease(tmpstr);
CFRelease(lastField);
} else {
// The host UUID is a full UUID, and we should just use that. This doesn't involve any additional string creation, so we should just be able to do the assignment.
__byHostIdentifierString = hostID;
}
} else {
__byHostIdentifierString = CFSTR("UnknownHostID");
}
}
return __byHostIdentifierString;
}
CFStringRef
__NCParseExtendedFormatString(
CFStringRef format
)
{
CFMutableStringRef newFormat = CFStringCreateMutableCopy(
kCFAllocatorDefault,
0,
format);
CFIndex length = CFStringGetLength(newFormat);
CFRange searchRange = CFRangeMake(0,length);
CFRange foundRange;
// Scan through the mutable copy looking for '%!' sequences to
// parse-out:
while (CFStringFindWithOptions(newFormat,CFSTR("%!"),searchRange,0,&foundRange)) {
CFIndex start = foundRange.location;
CFIndex end;
if (CFStringFindWithOptions(newFormat,CFSTR(";"),CFRangeMake(start,length - start),0,&foundRange))
end = foundRange.location;
else
end = length;
__NCReplaceFormatToken(newFormat,start,end);
length = CFStringGetLength(newFormat);
if (end >= length)
break;
searchRange = CFRangeMake(start,length - start);
}
return newFormat;
}
OSErr makeFSSpec(char *pathString, int pathStringLength,FSSpec *spec)
{
CFURLRef sillyThing;
CFStringRef tmpStrRef;
CFMutableStringRef filePath;
FSRef theFSRef;
OSErr err;
tmpStrRef = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *) pathString,
pathStringLength, gCurrentVMEncoding, true);
if (tmpStrRef == nil)
return -1000;
filePath = CFStringCreateMutableCopy(NULL, 0, tmpStrRef);
if (gCurrentVMEncoding == kCFStringEncodingUTF8)
CFStringNormalize(filePath, kCFStringNormalizationFormD);
sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,filePath,kCFURLHFSPathStyle,false);
if (sillyThing == NULL)
return -2000;
if (CFURLGetFSRef(sillyThing,&theFSRef) == false) {
// name contains multiple aliases or does not exist, so fallback to lookupPath
CFRelease(filePath);
CFRelease(sillyThing);
return lookupPath(pathString,pathStringLength,spec,true,true);
}
CFRelease(filePath);
err = FSGetCatalogInfo (&theFSRef,kFSCatInfoNone,nil,nil,spec,nil);
CFRelease(sillyThing);
return err;
}
UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
{
if (!srcString.IsEmpty())
{
UString resultString;
const char * path = &srcString[0];
CFStringRef cfpath = CFStringCreateWithCString(NULL,path,kCFStringEncodingUTF8);
if (cfpath)
{
CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
CFRelease(cfpath);
CFStringNormalize(cfpath2,kCFStringNormalizationFormC);
size_t n = CFStringGetLength(cfpath2);
for(size_t i = 0 ; i< n ;i++) {
UniChar uc = CFStringGetCharacterAtIndex(cfpath2,i);
resultString += (wchar_t)uc; // FIXME
}
CFRelease(cfpath2);
return resultString;
}
}
UString resultString;
for (int i = 0; i < srcString.Len(); i++)
resultString += wchar_t(srcString[i] & 255);
return resultString;
}
int makeHFSFromPosixPath(char *pathString, int pathStringLength,char *dst,char *lastpart) {
CFStringRef filePath;
CFURLRef sillyThing;
CFStringRef filePath2,lastPathPart;
dst[0] = 0x00;
if (lastpart)
lastpart[0] = 0x00;
filePath = CFStringCreateWithBytes(kCFAllocatorDefault,
(UInt8 *)pathString,pathStringLength,gCurrentVMEncoding,false);
if (filePath == nil)
return -1;
// HFS+ imposes Unicode2.1 decomposed UTF-8 encoding on all path elements
CFMutableStringRef str= CFStringCreateMutableCopy(NULL, 0, filePath);
if (gCurrentVMEncoding == kCFStringEncodingUTF8)
CFStringNormalize(str, kCFStringNormalizationFormKC); // canonical decomposition
sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, str, kCFURLPOSIXPathStyle,false);
CFRelease(str);
if (sillyThing == NULL)
return -2;
filePath2 = CFURLCopyFileSystemPath (sillyThing, kCFURLHFSPathStyle);
CFStringGetCString (filePath2,dst,1000, gCurrentVMEncoding);
if (lastpart) {
lastPathPart = CFURLCopyLastPathComponent(sillyThing);
CFStringGetCString(lastPathPart,lastpart,256, gCurrentVMEncoding);
CFRelease(lastPathPart);
}
CFRelease(filePath);
CFRelease(sillyThing);
CFRelease(filePath2);
return 0;
}
void
GetServiceTypeToLookup(CFMutableStringRef * serviceString, UInt16 * serviceMenuItem)
{
ControlID controlID = { kNSLSample, kServicesTypePopup };
ControlRef control;
CFStringRef outString;
MenuRef menu;
SInt16 value;
OSStatus err;
err = GetControlByID(gMainWindow, &controlID, &control);
if (err == noErr)
{
value = GetControlValue(control);
if (serviceString)
{
menu = GetControlPopupMenuHandle(control);
if (menu)
{
CopyMenuItemTextAsCFString(menu, value, &outString);
if (serviceString)
{
*serviceString = CFStringCreateMutableCopy(NULL, CFStringGetLength(outString), outString);
CFStringLowercase(*serviceString, NULL);
}
if (outString) CFRelease(outString);
}
}
if (serviceMenuItem) *serviceMenuItem = value;
}
}
static CFStringRef BIMCreatePortName( const ProcessSerialNumber *inProcessSerialNumber )
{
CFMutableStringRef portName;
CFStringRef processSerialNumberStringRef;
Str255 processSerialNumberString;
Str255 processSerialNumberLowString;
// Convert the high and low parts of the process serial number into a string.
NumToString( inProcessSerialNumber->highLongOfPSN, processSerialNumberString );
NumToString( inProcessSerialNumber->lowLongOfPSN, processSerialNumberLowString );
BlockMoveData( processSerialNumberLowString + 1,
processSerialNumberString + processSerialNumberString [0] + 1,
processSerialNumberLowString [0] );
processSerialNumberString [0] += processSerialNumberLowString [0];
// Create a CFString and append the process serial number string onto the end.
portName = CFStringCreateMutableCopy( NULL, 255, CFSTR( kBasicServerPortName ) );
processSerialNumberStringRef = CFStringCreateWithPascalString( NULL,
processSerialNumberString,
CFStringGetSystemEncoding() );
CFStringAppend( portName, processSerialNumberStringRef );
CFRelease( processSerialNumberStringRef );
return portName;
}
/*
* Given a Dfs Referral string create a CFURL. Remember referral have a file
* syntax
*
* Example: "/smb-win2003.apple.com/DfsRoot/DfsLink1"
*/
CFURLRef CreateURLFromReferral(CFStringRef inStr)
{
CFURLRef ct_url = NULL;
CFMutableStringRef urlString = CFStringCreateMutableCopy(NULL, 0, CFSTR("smb:/"));
CFStringRef escapeStr = inStr;
/*
* CreateStringByAddingPercentEscapesUTF8() will either create a new string
* or return the original with ref count incremented. Either way we have to
* call CFRelease on the returned string
*/
CreateStringByAddingPercentEscapesUTF8(&escapeStr, NULL, NULL, FALSE);
if (urlString) {
CFStringAppend(urlString, escapeStr);
ct_url = CFURLCreateWithString(kCFAllocatorDefault, urlString, NULL);
CFRelease(urlString); /* We create it now release it */
}
if (!ct_url) {
LogCFString(inStr, "creating url failed", __FUNCTION__, __LINE__);
}
if (escapeStr) {
CFRelease(escapeStr);
}
return ct_url;
}
Boolean APSetKey(CFStringRef key)
{
hash = CFSTR("");
blacklist = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
// Create a new key
rsaKey = RSA_new();
// Public exponent is always 3
BN_hex2bn(&rsaKey->e, "3");
CFMutableStringRef mutableKey = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, key);
if (!mutableKey)
return FALSE;
CFIndex maximumCStringLength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(mutableKey), kCFStringEncodingMacRoman) + 1;
char *keyCStringBuffer = malloc(maximumCStringLength);
// Determine if we have a hex or decimal key
CFStringLowercase(mutableKey, NULL);
if (CFStringHasPrefix(mutableKey, CFSTR("0x"))) {
CFStringTrim(mutableKey, CFSTR("0x"));
CFStringGetCString(mutableKey, keyCStringBuffer, maximumCStringLength, kCFStringEncodingMacRoman);
BN_hex2bn(&rsaKey->n, keyCStringBuffer);
}
else {
CFStringGetCString(mutableKey, keyCStringBuffer, maximumCStringLength, kCFStringEncodingMacRoman);
BN_dec2bn(&rsaKey->n, keyCStringBuffer);
}
CFRelease(mutableKey);
free(keyCStringBuffer);
return TRUE;
}
OSStatus PosixPathToParentFSRefAndName(const char *path, FSRef &outParentDir, CFStringRef &outFileName)
{
// convert C string to CFString
#if !TARGET_OS_WIN32
CFStringRef cfFullPath = CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8);
#else
CFStringRef cfFullPath = CFStringCreateWithCString(NULL, path, kCFStringEncodingWindowsLatin1);
#endif
// convert CF string to URL
CFURLRef fullurl = CFURLCreateWithFileSystemPath(NULL, cfFullPath, TARGET_OS_WIN32 ? kCFURLWindowsPathStyle : kCFURLPOSIXPathStyle, false);
CFRelease(cfFullPath);
// get the directory portion of the URL
CFURLRef dirurl = CFURLCreateCopyDeletingLastPathComponent(NULL, fullurl);
// get the directory's FSSpec
OSStatus err = CFURLGetFSRef(dirurl, &outParentDir) ? OSStatus(noErr) : OSStatus(fnfErr);
CFRelease(dirurl);
CFStringRef lastPathComponent = CFURLCopyLastPathComponent(fullurl);
CFRelease(fullurl);
CFMutableStringRef filename = CFStringCreateMutableCopy(NULL, 0, lastPathComponent);
CFRelease(lastPathComponent);
// convert colons (legal in POSIX paths, illegal in File Manager) to slashes
CFStringFindAndReplace(filename, CFSTR(":"), CFSTR("/"), CFRangeMake(0, CFStringGetLength(filename)), 0);
outFileName = filename;
return err;
}
const CHXString& CHXString::operator =(CFStringRef ref)
{
#ifdef _MAC_CFM
CFStringEncoding encoding = CFStringGetSystemEncoding();
#else
CFStringEncoding encoding = kCFStringEncodingUTF8;
#endif
// we need the string to be canonically decomposed Unicode in case it'll be used as a path on
// an HFS disk, so we'll make a mutable copy of the string, normalize it, and then encode that as UTF-8
const CFIndex kNoMaxLength = 0;
CFMutableStringRef mutableRef = CFStringCreateMutableCopy(kCFAllocatorDefault, kNoMaxLength, ref);
#ifndef __MWERKS__
// our version of CodeWarrior doesn't have CFStringNormalize in the headers since they are pre-10.2 headers, alas
CFStringNormalize(mutableRef, kCFStringNormalizationFormD);
#endif
(void) SetFromCFString(mutableRef, encoding);
CFRelease(mutableRef);
return *this;
}
AString UnicodeStringToMultiByte(const UString &srcString, UINT codePage)
{
if (!srcString.IsEmpty())
{
const wchar_t * wcs = &srcString[0];
char utf8[4096];
UniChar unipath[4096];
size_t n = wcslen(wcs);
for(size_t i = 0 ; i<= n ;i++) {
unipath[i] = wcs[i];
}
CFStringRef cfpath = CFStringCreateWithCharacters(NULL,unipath,n);
CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
CFRelease(cfpath);
CFStringNormalize(cfpath2,kCFStringNormalizationFormD);
CFStringGetCString(cfpath2,(char *)utf8,4096,kCFStringEncodingUTF8);
CFRelease(cfpath2);
return AString(utf8);
}
AString resultString;
for (int i = 0; i < srcString.Len(); i++)
{
if (srcString[i] >= 256) resultString += '?';
else resultString += char(srcString[i]);
}
return resultString;
}
void getprocesspath(char* buffer, size_t bufferLen)
{
#if defined( OS_MACOSX )
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef bundleUrl = CFBundleCopyBundleURL(mainBundle);
CFURLRef workingUrl = CFURLCreateCopyDeletingPathExtension(kCFAllocatorSystemDefault, bundleUrl);
CFStringRef workingString = CFURLCopyFileSystemPath(workingUrl, kCFURLPOSIXPathStyle);
CFMutableStringRef normalizedString = CFStringCreateMutableCopy(NULL, 0, workingString);
CFStringGetCString(normalizedString, buffer, bufferLen - 1, kCFStringEncodingUTF8);
CFRelease(workingUrl);
CFRelease(workingString);
CFRelease(normalizedString);
CFRelease(bundleUrl);
#elif defined(__FreeBSD__)
sysctl_get_pathname(buffer, bufferLen);
dirname(buffer);
strcat(buffer, "/");
#else
int count = readlink("/proc/self/exe", buffer, bufferLen);
if (count != -1)
{
buffer[count] = 0;
dirname(buffer);
strcat(buffer, "/");
return;
}
*buffer = 0;
#endif
}
bool wxOSXAudioToolboxSoundData::Play(unsigned flags)
{
Stop();
m_flags = flags;
wxCFRef<CFMutableStringRef> cfMutableString(CFStringCreateMutableCopy(NULL, 0, wxCFStringRef(m_sndname)));
CFStringNormalize(cfMutableString,kCFStringNormalizationFormD);
wxCFRef<CFURLRef> url(CFURLCreateWithFileSystemPath(kCFAllocatorDefault, cfMutableString , kCFURLPOSIXPathStyle, false));
AudioServicesCreateSystemSoundID(url, &m_soundID);
AudioServicesAddSystemSoundCompletion( m_soundID, CFRunLoopGetCurrent(), NULL, wxOSXAudioToolboxSoundData::CompletionCallback, (void *) this );
bool sync = !(flags & wxSOUND_ASYNC);
AudioServicesPlaySystemSound(m_soundID);
if ( sync )
{
while( m_soundID )
{
CFRunLoopRun();
}
}
return true;
}
/*
* Get the server name out of the URL. CFURLCopyHostName will escape out the
* server name for us. So just convert it to the correct code page encoding.
*
* Note: Currently we put the server name into a c-style string. In the future
* it would be nice to keep this as a CFString.
*/
static int SetServerFromURL(struct smb_ctx *ctx, CFURLRef url)
{
CFIndex maxlen;
CFStringRef serverNameRef = CFURLCopyHostName(url);
char *ipV6Name = NULL;
ipV6Name = CStringCreateWithCFString(serverNameRef);
if (ipV6Name && isIPv6NumericName(ipV6Name)) {
/* CFURLCopyHostName removed the [] so put them back in */
CFMutableStringRef newServer = CFStringCreateMutableCopy(NULL, 1024, CFSTR("["));
if (newServer) {
CFStringAppend(newServer, serverNameRef);
CFStringAppend(newServer, CFSTR("]"));
CFRelease(serverNameRef);
serverNameRef = newServer;
}
}
/* Free up the buffer we allocated */
if (ipV6Name) {
free(ipV6Name);
}
/*
* Every time we parse the URL we end up replacing the server name. In the
* future we should skip replacing the server name if we already have one and
* the one return CFURLCopyHostName matches it.
*
* Not going to make that big of a change in an update, so lets limit to the
* case were we are dealing with using a domain controller.
*/
if (serverNameRef && ctx->serverNameRef && ctx->serverName &&
(ctx->serverIsDomainController) &&
(ctx->ct_flags & SMBCF_CONNECTED) &&
(CFStringCompare(serverNameRef, ctx->serverNameRef, 0) == kCFCompareEqualTo)) {
CFRelease(serverNameRef);
return 0; /* Same name nothing to do here */
}
if (ctx->serverNameRef) {
CFRelease(ctx->serverNameRef);
}
/* The serverNameRef should always contain the URL host name or the Bonjour Name */
ctx->serverNameRef = serverNameRef;
if (ctx->serverNameRef == NULL)
return EINVAL;
DebugLogCFString(ctx->serverNameRef, "Server", __FUNCTION__, __LINE__);
maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(ctx->serverNameRef), kCFStringEncodingUTF8) + 1;
if (ctx->serverName)
free(ctx->serverName);
ctx->serverName = malloc(maxlen);
if (!ctx->serverName) {
CFRelease(ctx->serverNameRef);
ctx->serverNameRef = NULL;
return ENOMEM;
}
CFStringGetCString(ctx->serverNameRef, ctx->serverName, maxlen, kCFStringEncodingUTF8);
return 0;
}
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 SavePrefs (void)
{
CFMutableStringRef mref;
CFStringRef sref;
CFDataRef data;
for (unsigned int i = 0; i < kPrefListSize; i++)
{
mref = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFSTR("Preferences_"));
if (mref)
{
sref = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *) &(prefList[i].itemName), sizeof(OSType), kCFStringEncodingMacRoman, false);
if (sref)
{
CFStringAppend(mref, sref);
data = CFDataCreate(kCFAllocatorDefault, (UInt8 *) prefList[i].itemPointer, prefList[i].size);
if (data)
{
CFPreferencesSetAppValue(mref, data, kCFPreferencesCurrentApplication);
CFRelease(data);
}
CFRelease(sref);
}
CFRelease(mref);
}
}
mref = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFSTR("Preferences_SaveFolder"));
if (mref)
{
if (saveFolderPath)
{
CFPreferencesSetAppValue(mref, saveFolderPath, kCFPreferencesCurrentApplication);
CFRelease(saveFolderPath);
}
else
CFPreferencesSetAppValue(mref, NULL, kCFPreferencesCurrentApplication);
CFRelease(mref);
}
CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
}
CFStringRef diff_CFStringCreateByCombiningTwoStrings(CFStringRef best_common_part1, CFStringRef best_common_part2) {
CFIndex best_common_length;
CFMutableStringRef best_common_mutable;
best_common_length = CFStringGetLength(best_common_part1) + CFStringGetLength(best_common_part2);
best_common_mutable = CFStringCreateMutableCopy(kCFAllocatorDefault, best_common_length, best_common_part1);
CFStringAppend(best_common_mutable, best_common_part2);
return best_common_mutable;
}
CFStringRef stringFromRange(const char *cstring, CFRange range)
{
CFStringRef str = CFStringCreateWithBytes (NULL, (uint8*)&cstring[range.location], range.length, kCFStringEncodingUTF8, false);
CFMutableStringRef mutableStr = CFStringCreateMutableCopy(NULL, 0, str);
CFStringTrimWhitespace(mutableStr);
CFRelease(str);
return mutableStr;
}
/**
* Determines the network proxy server to use (if any).
* @param url absolute URL for which to get the proxy server (not used)
* @return proxy URL, NULL if no proxy or error
*/
char *vlc_getProxyUrl(const char *url)
{
VLC_UNUSED(url);
CFDictionaryRef proxies = SCDynamicStoreCopyProxies(NULL);
char *proxy_url = NULL;
if (proxies) {
CFNumberRef cfn_httpProxyOn =
(CFNumberRef)CFDictionaryGetValue(proxies,
kSCPropNetProxiesHTTPEnable);
if (cfn_httpProxyOn) {
int i_httpProxyOn;
CFNumberGetValue(cfn_httpProxyOn, kCFNumberIntType, &i_httpProxyOn);
CFRelease(cfn_httpProxyOn);
if (i_httpProxyOn == 1) // http proxy is on
{
CFStringRef httpProxy =
(CFStringRef)CFDictionaryGetValue(proxies,
kSCPropNetProxiesHTTPProxy);
if (httpProxy) {
CFNumberRef cfn_httpProxyPort =
(CFNumberRef)CFDictionaryGetValue(proxies,
kSCPropNetProxiesHTTPPort);
int i_httpProxyPort;
CFNumberGetValue(cfn_httpProxyPort,
kCFNumberIntType,
&i_httpProxyPort);
CFRelease(cfn_httpProxyPort);
CFMutableStringRef outputURL =
CFStringCreateMutableCopy(kCFAllocatorDefault,
0,
httpProxy);
if (i_httpProxyPort > 0)
CFStringAppendFormat(outputURL,
NULL,
CFSTR(":%i"),
i_httpProxyPort);
char buffer[4096];
if (CFStringGetCString(outputURL, buffer, sizeof(buffer),
kCFStringEncodingUTF8))
proxy_url = strdup(buffer);
CFRelease(outputURL);
}
CFRelease(httpProxy);
}
}
CFRelease(proxies);
}
return proxy_url;
}
void write_gdb_prep_cmds(AMDeviceRef device, CFURLRef disk_app_url) {
CFMutableStringRef cmds = CFStringCreateMutableCopy(NULL, 0, GDB_PREP_CMDS);
CFRange range = { 0, CFStringGetLength(cmds) };
CFStringRef ds_path = copy_device_support_path(device);
CFStringFindAndReplace(cmds, CFSTR("{ds_path}"), ds_path, range, 0);
CFStringRef bundle_identifier = copy_disk_app_identifier(disk_app_url);
CFURLRef device_app_url = copy_device_app_url(device, bundle_identifier);
CFStringRef device_app_path = CFURLCopyFileSystemPath(device_app_url, kCFURLPOSIXPathStyle);
CFStringFindAndReplace(cmds, CFSTR("{device_app}"), device_app_path, range, 0);
CFStringRef disk_app_path = CFURLCopyFileSystemPath(disk_app_url, kCFURLPOSIXPathStyle);
CFStringFindAndReplace(cmds, CFSTR("{disk_app}"), disk_app_path, range, 0);
CFURLRef device_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, device_app_url);
CFStringRef device_container_path = CFURLCopyFileSystemPath(device_container_url, kCFURLPOSIXPathStyle);
CFMutableStringRef dcp_noprivate = CFStringCreateMutableCopy(NULL, 0, device_container_path);
CFStringFindAndReplace(dcp_noprivate, CFSTR("/private/var/"), CFSTR("/var/"), range, 0);
CFStringFindAndReplace(cmds, CFSTR("{device_container}"), dcp_noprivate, range, 0);
CFURLRef disk_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, disk_app_url);
CFStringRef disk_container_path = CFURLCopyFileSystemPath(disk_container_url, kCFURLPOSIXPathStyle);
CFStringFindAndReplace(cmds, CFSTR("{disk_container}"), disk_container_path, range, 0);
CFDataRef cmds_data = CFStringCreateExternalRepresentation(NULL, cmds, kCFStringEncodingASCII, 0);
FILE *out = fopen(PREP_CMDS_PATH, "w");
fwrite(CFDataGetBytePtr(cmds_data), CFDataGetLength(cmds_data), 1, out);
fclose(out);
CFRelease(cmds);
if (ds_path != NULL) CFRelease(ds_path);
CFRelease(bundle_identifier);
CFRelease(device_app_url);
CFRelease(device_app_path);
CFRelease(disk_app_path);
CFRelease(device_container_url);
CFRelease(device_container_path);
CFRelease(dcp_noprivate);
CFRelease(disk_container_url);
CFRelease(disk_container_path);
CFRelease(cmds_data);
}
static void __DAFileSystemProbeCallbackStage1( int status, CFDataRef output, void * parameter )
{
/*
* Process the probe command's completion.
*/
__DAFileSystemProbeContext * context = parameter;
if ( status == FSUR_RECOGNIZED )
{
/*
* Obtain the volume name.
*/
if ( output )
{
CFStringRef string;
string = CFStringCreateFromExternalRepresentation( kCFAllocatorDefault, output, kCFStringEncodingUTF8 );
if ( string )
{
if ( CFStringGetLength( string ) )
{
context->volumeName = CFStringCreateMutableCopy( kCFAllocatorDefault, 0, string );
if ( context->volumeName )
{
CFStringTrim( ( CFMutableStringRef ) context->volumeName, CFSTR( "\n" ) );
}
}
CFRelease( string );
}
}
/*
* Execute the "get UUID" command.
*/
DACommandExecute( context->probeCommand,
kDACommandExecuteOptionCaptureOutput,
___UID_ROOT,
___GID_WHEEL,
__DAFileSystemProbeCallbackStage2,
context,
CFSTR( "-k" ),
context->deviceName,
NULL );
}
else
{
__DAFileSystemProbeCallback( status, context, NULL );
}
}
