/*! Looks up the session identifier associated with a particular target name. * @param targetIQN the IQN name of the target (e.q., iqn.2015-01.com.example) * @return sessionId the session identifier. */ SID iSCSIKernelGetSessionIdForTargetIQN(CFStringRef targetIQN) { if(!targetIQN) return kiSCSIInvalidSessionId; const UInt32 expOutputCnt = 1; UInt64 output[expOutputCnt]; UInt32 outputCnt = expOutputCnt; kern_return_t result = IOConnectCallMethod( connection, kiSCSIGetSessionIdForTargetIQN,0,0, (const void*)CFStringGetCStringPtr(targetIQN,kCFStringEncodingASCII), CFStringGetLength(targetIQN)+1, output,&outputCnt,0,0); if(result == kIOReturnSuccess && outputCnt == expOutputCnt) return (SID)output[0]; return kiSCSIInvalidSessionId; }
int stransport_error(OSStatus ret) { CFStringRef message; if (ret == noErr || ret == errSSLClosedGraceful) { giterr_clear(); return 0; } #if !TARGET_OS_IPHONE message = SecCopyErrorMessageString(ret, NULL); GITERR_CHECK_ALLOC(message); giterr_set(GITERR_NET, "SecureTransport error: %s", CFStringGetCStringPtr(message, kCFStringEncodingUTF8)); CFRelease(message); #else giterr_set(GITERR_NET, "SecureTransport error: OSStatus %d", (unsigned int)ret); #endif return -1; }
OSErr AEDescCreateUTF8Text(CFStringRef string, AEDesc* outDescPtr) { OSErr err = noErr; CFStringEncoding kEncoding = kCFStringEncodingUTF8; DescType resultType = typeUTF8Text; const char *constBuff = CFStringGetCStringPtr(string, kEncoding); if (constBuff == NULL) { char *buffer; CFIndex charLen = CFStringGetLength(string); CFIndex maxLen = CFStringGetMaximumSizeForEncoding(charLen, kEncoding)+1; // +1 is for null termination. buffer = malloc(sizeof(char)*maxLen); CFStringGetCString(string, buffer, maxLen, kEncoding); err = AECreateDesc(resultType, buffer, strlen(buffer), outDescPtr); free(buffer); } else { err=AECreateDesc(resultType, constBuff, strlen(constBuff), outDescPtr); } return err; }
bool outOfSpace(CFStringRef pathName) { Boolean validKey; unsigned int minMeg; struct statfs fileSys; minMeg = CFPreferencesGetAppIntegerValue(MINMEG_PREF_KEY,PREF_DOMAIN,&validKey); if (!validKey) { minMeg = DEFAULT_MEG; CFPreferencesSetAppValue(MINMEG_PREF_KEY,CFNumberCreate(kCFAllocatorDefault,kCFNumberIntType,&minMeg),PREF_DOMAIN); } if (statfs(CFStringGetCStringPtr(pathName,CFStringGetFastestEncoding(pathName)),&fileSys)) return false; if ((fileSys.f_bsize/1024)*(fileSys.f_bavail/1024) < minMeg) return true; return false; }
//! Get the serial number for a HID device QString pjrc_rawhid::getserial(int num) { Q_UNUSED(num); QMutexLocker locker(m_readMutex); Q_UNUSED(locker); if (!device_open || unplugged) return ""; CFTypeRef serialnum = IOHIDDeviceGetProperty(dev, CFSTR(kIOHIDSerialNumberKey)); if(serialnum && CFGetTypeID(serialnum) == CFStringGetTypeID()) { //Note: I'm not sure it will always succeed if encoded as MacRoman but that //is a superset of UTF8 so I think this is fine CFStringRef str = (CFStringRef)serialnum; const char * buf = CFStringGetCStringPtr(str, kCFStringEncodingMacRoman); return QString(buf); } return QString("Error"); }
vector<string> DeckLinkController::getDeviceNameList() { vector<string> nameList; int deviceIndex = 0; while (deviceIndex < deviceList.size()) { CFStringRef cfStrName; // Get the name of this device if (deviceList[deviceIndex]->GetDisplayName(&cfStrName) == S_OK) { nameList.push_back(string(CFStringGetCStringPtr(cfStrName, kCFStringEncodingMacRoman))); CFRelease(cfStrName); } else { nameList.push_back("DeckLink"); } deviceIndex++; } return nameList; }
/* new in 10.6 */ SecPolicyRef SecPolicyCreateSSL(Boolean server, CFStringRef hostname) { // return a SecPolicyRef object for the SSL policy, given hostname and client options SecPolicyRef policy = nil; SecPolicySearchRef policySearch = nil; OSStatus status = SecPolicySearchCreate(CSSM_CERT_X_509v3, &CSSMOID_APPLE_TP_SSL, NULL, &policySearch); if (!status) { status = SecPolicySearchCopyNext(policySearch, &policy); } if (!status && policy) { // set options for client-side or server-side policy evaluation char *strbuf = NULL; const char *hostnamestr = NULL; if (hostname) { CFIndex strbuflen = 0; hostnamestr = CFStringGetCStringPtr(hostname, kCFStringEncodingUTF8); if (hostnamestr == NULL) { strbuflen = CFStringGetLength(hostname)*6; strbuf = (char *)malloc(strbuflen+1); if (CFStringGetCString(hostname, strbuf, strbuflen, kCFStringEncodingUTF8)) { hostnamestr = strbuf; } } } uint32 hostnamelen = (hostnamestr) ? strlen(hostnamestr) : 0; uint32 flags = (!server) ? CSSM_APPLE_TP_SSL_CLIENT : 0; CSSM_APPLE_TP_SSL_OPTIONS opts = {CSSM_APPLE_TP_SSL_OPTS_VERSION, hostnamelen, hostnamestr, flags}; CSSM_DATA data = {sizeof(opts), (uint8*)&opts}; SecPolicySetValue(policy, &data); if (strbuf) { free(strbuf); } } if (policySearch) { CFRelease(policySearch); } return policy; }
void mount_developer_image(AMDeviceRef device) { CFStringRef ds_path = copy_device_support_path(device); CFStringRef image_path = copy_developer_disk_image_path(device); CFStringRef sig_path = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@.signature"), image_path); CFRelease(ds_path); if (verbose) { printf("Device support path: "); fflush(stdout); CFShow(ds_path); printf("Developer disk image: "); fflush(stdout); CFShow(image_path); } FILE* sig = fopen(CFStringGetCStringPtr(sig_path, kCFStringEncodingMacRoman), "rb"); void *sig_buf = malloc(128); assert(fread(sig_buf, 1, 128, sig) == 128); fclose(sig); CFDataRef sig_data = CFDataCreateWithBytesNoCopy(NULL, sig_buf, 128, NULL); CFRelease(sig_path); CFTypeRef keys[] = { CFSTR("ImageSignature"), CFSTR("ImageType") }; CFTypeRef values[] = { sig_data, CFSTR("Developer") }; CFDictionaryRef options = CFDictionaryCreate(NULL, (const void **)&keys, (const void **)&values, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFRelease(sig_data); int result = AMDeviceMountImage(device, image_path, options, &mount_callback, 0); if (result == 0) { printf("[ 95%%] Developer disk image mounted successfully\n"); } else if (result == 0xe8000076 /* already mounted */) { printf("[ 95%%] Developer disk image already mounted\n"); } else { printf("[ !! ] Unable to mount developer disk image. (%x)\n", result); exit(1); } CFRelease(image_path); CFRelease(options); }
/* return AD realm if it exists */ const char *get_ad_realm ( struct auth_request *auth_request ) { const char *out_realm = NULL; SCDynamicStoreRef store = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("dovecot.digest.auth"), NULL, NULL); if ( store ) { CFDictionaryRef dict = SCDynamicStoreCopyValue(store, CFSTR("com.apple.opendirectoryd.ActiveDirectory")); if (dict) { CFStringRef domain = CFDictionaryGetValue(dict, CFSTR("DomainNameFlat")); if (domain) { const char *ad_realm = CFStringGetCStringPtr(domain, kCFStringEncodingUTF8); if (ad_realm) { auth_request_log_info(auth_request, "digest-md5", "ad realm: %s", ad_realm); out_realm = t_strdup(ad_realm); } } CFRelease(dict); } CFRelease(store); } return( out_realm ); }
static FILE* ios_open_from_bundle(const char path[], const char* perm) { // Get a reference to the main bundle CFBundleRef mainBundle = CFBundleGetMainBundle(); // Get a reference to the file's URL CFStringRef pathRef = CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8); CFURLRef imageURL = CFBundleCopyResourceURL(mainBundle, pathRef, NULL, NULL); if (!imageURL) { return nullptr; } // Convert the URL reference into a string reference CFStringRef imagePath = CFURLCopyFileSystemPath(imageURL, kCFURLPOSIXPathStyle); // Get the system encoding method CFStringEncoding encodingMethod = CFStringGetSystemEncoding(); // Convert the string reference into a C string const char *finalPath = CFStringGetCStringPtr(imagePath, encodingMethod); return fopen(finalPath, perm); }
/** * Get the location for global or user-local support files. * @return NULL if it could not be determined */ char *Bgetsupportdir(int global) { char *dir = NULL; #ifdef __APPLE__ FSRef ref; CFStringRef str; CFURLRef base; const char *s; if (FSFindFolder(global ? kLocalDomain : kUserDomain, kApplicationSupportFolderType, kDontCreateFolder, &ref) < 0) return NULL; base = CFURLCreateFromFSRef(NULL, &ref); if (!base) { return NULL; } str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle); CFRelease(base); if (!str) { return NULL; } s = CFStringGetCStringPtr(str, CFStringGetSystemEncoding()); if (s) { dir = strdup(s); } CFRelease(str); #else if (!global) { dir = Bgethomedir(); } #endif return dir; }
const void *subsurface_get_conf(char *name, pref_type_t type) { CFStringRef dict_entry; /* if no settings exist, we return the value for FALSE */ if (!propertyList) return NULL; switch (type) { case PREF_BOOL: dict_entry = CFDictionaryGetValue(propertyList, CFSTR_VAR(name)); if (dict_entry && ! CFStringCompare(CFSTR("1"), dict_entry, 0)) return (void *) 1; else return NULL; case PREF_STRING: return CFStringGetCStringPtr(CFDictionaryGetValue(propertyList, CFSTR_VAR(name)), kCFStringEncodingMacRoman); } /* we shouldn't get here, but having this line makes the compiler happy */ return NULL; }
static IOReturn PrintSpeedForDisc ( io_object_t opticalMedia ) { IOReturn error = kIOReturnError; CFMutableDictionaryRef properties = NULL; CFStringRef bsdNode = NULL; const char * bsdName = NULL; error = IORegistryEntryCreateCFProperties ( opticalMedia, &properties, kCFAllocatorDefault, kNilOptions ); require ( ( error == kIOReturnSuccess ), ErrorExit ); bsdNode = ( CFStringRef ) CFDictionaryGetValue ( properties, CFSTR ( kIOBSDNameKey ) ); require ( ( bsdNode != NULL ), ReleaseProperties ); bsdName = CFStringGetCStringPtr ( bsdNode, CFStringGetSystemEncoding ( ) ); require ( ( bsdName != NULL ), ReleaseProperties ); error = PrintSpeedForBSDNode ( bsdName ); require ( ( error == kIOReturnSuccess ), ReleaseProperties ); ReleaseProperties: require_quiet ( ( properties != NULL ), ErrorExit ); CFRelease ( properties ); properties = NULL; ErrorExit: return error; }
static char * cfstring2cstring(CFStringRef string) { CFIndex len; char *str; str = (char *) CFStringGetCStringPtr(string, kCFStringEncodingUTF8); if (str) return strdup(str); len = CFStringGetLength(string); len = 1 + CFStringGetMaximumSizeForEncoding(len, kCFStringEncodingUTF8); str = malloc(len); if (str == NULL) return NULL; if (!CFStringGetCString (string, str, len, kCFStringEncodingUTF8)) { free (str); return NULL; } return str; }
ST_FUNC ST_Error ST_ID3v1_setYearStr(ST_ID3v1 *tag, CFStringRef s) { char *prev = tag->year; const char *str; char tmp[5]; /* Make sure they aren't doing anything screwy */ if(!tag || tag->base.type != ST_TagType_ID3v1) return ST_Error_InvalidArgument; else if(CFStringGetLength(s) != 4) return ST_Error_InvalidArgument; if(!s) { free(tag->year); tag->year = NULL; return ST_Error_None; } /* Grab the ISO-8859-1 representation of the string */ if(!(str = CFStringGetCStringPtr(s, kCFStringEncodingISOLatin1))) { if(!CFStringGetCString(s, tmp, 5, kCFStringEncodingISOLatin1)) return ST_Error_InvalidEncoding; str = tmp; } /* One last sanity check... */ if(strlen(str) != 4 || (!is_8859digit(str[0]) || !is_8859digit(str[1]) || !is_8859digit(str[2]) || !is_8859digit(str[3]))) return ST_Error_InvalidArgument; /* Copy it in */ if((tag->year = strdup(str))) { free(prev); return ST_Error_None; } tag->year = prev; return ST_Error_errno; }
static CFDataRef digestString(CFStringRef str) { CFDataRef retval = NULL; CFErrorRef error = NULL; CFDataRef inputString = CFStringCreateExternalRepresentation(kCFAllocatorDefault, str, kCFStringEncodingUTF8, 0xff); SecTransformRef digestTrans = SecDigestTransformCreate(kSecDigestSHA2, 256, &error); if(error == NULL) { SecTransformSetAttribute(digestTrans, kSecTransformInputAttributeName, inputString, &error); if(error == NULL) { retval = SecTransformExecute(digestTrans, &error); if(retval == NULL) { secDebug(ASL_LEVEL_ERR, "Couldn't create digest %s\n", CFStringGetCStringPtr(CFErrorCopyFailureReason(error), kCFStringEncodingUTF8)); } } CFRelease(digestTrans); } CFRelease(inputString); return retval; }
QString ScPaths::bundleDir(void) const { // On MacOS/X, override the compile-time settings with a location // obtained from the system. #ifdef Q_WS_MAC // Set up the various app paths to look inside the app bundle CFURLRef pluginRef = CFBundleCopyBundleURL(CFBundleGetMainBundle()); CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef, kCFURLPOSIXPathStyle); const char *pathPtr = CFStringGetCStringPtr(macPath, CFStringGetSystemEncoding()); // make sure we get the Scribus.app directory, not some subdir // strip trailing '/': char *p = const_cast<char*>(pathPtr + strlen(pathPtr) - 1); while (*p == '/') --p; ++p; *p = '\0'; if (strcmp("/bin", p-4) == 0) { p -= 4; *p = '\0'; } if (strcmp("/MacOS", p-6) == 0) { p -= 6; *p = '\0'; } if (strcmp("/Contents", p-9) == 0) { p -= 9; *p = '\0'; } CFRelease(pluginRef); CFRelease(macPath); return QString("%1").arg(pathPtr); #endif return QString::null; }
static ST_Error setCFString(ST_ID3v1 *tag, char **ptr, CFStringRef s) { char *prev = *ptr; const char *str; char tmp[31]; /* Make sure they aren't doing anything screwy */ if(!tag || tag->base.type != ST_TagType_ID3v1) return ST_Error_InvalidArgument; else if(CFStringGetLength(s) > 30) return ST_Error_InvalidArgument; if(!s) { free(prev); *ptr = NULL; return ST_Error_None; } /* Grab the ISO-8859-1 representation of the string */ if(!(str = CFStringGetCStringPtr(s, kCFStringEncodingISOLatin1))) { if(!CFStringGetCString(s, tmp, 31, kCFStringEncodingISOLatin1)) return ST_Error_InvalidEncoding; str = tmp; } /* One last sanity check... */ if(strlen(str) > 30) return ST_Error_InvalidArgument; /* Copy it in */ if((*ptr = strdup(str))) { free(prev); return ST_Error_None; } *ptr = prev; return ST_Error_errno; }
char *cfStringToChar(CFStringRef inStr) { // Caller must free char *result = NULL; const char *str = NULL; if (!inStr) return strdup(""); // return a null string // quick path first if ((str = CFStringGetCStringPtr(inStr, kCFStringEncodingUTF8))) { result = strdup(str); } else { // need to extract into buffer CFIndex length = CFStringGetLength(inStr); // in 16-bit character units CFIndex bytesToAllocate = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1; result = malloc(bytesToAllocate); if (!CFStringGetCString(inStr, result, bytesToAllocate, kCFStringEncodingUTF8)) result[0] = 0; } return result; }
/** * Creates a VuoText value from a @c CFStringRef. */ VuoText VuoText_makeFromMacString(CFStringRef cfString) { // http://stackoverflow.com/questions/1609565/whats-the-cfstring-equiv-of-nsstrings-utf8string const char *useUTF8StringPtr = NULL; char *freeUTF8StringPtr = NULL; if ((useUTF8StringPtr = CFStringGetCStringPtr(cfString, kCFStringEncodingUTF8)) == NULL) { CFIndex stringLength = CFStringGetLength(cfString); CFIndex maxBytes = 4 * stringLength + 1; freeUTF8StringPtr = malloc(maxBytes); CFStringGetCString(cfString, freeUTF8StringPtr, maxBytes, kCFStringEncodingUTF8); useUTF8StringPtr = freeUTF8StringPtr; } VuoText text = VuoText_make(useUTF8StringPtr); if (freeUTF8StringPtr != NULL) free(freeUTF8StringPtr); return text; }
const char * MYCFStringGetUTF8String(CFStringRef aString, char **buffer) { if (aString == NULL) { return NULL; } const char *cstr = CFStringGetCStringPtr(aString, kCFStringEncodingUTF8); if (cstr == NULL) { CFIndex length = CFStringGetLength(aString); CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1; // +1 for NULL if (maxSize > malloc_size(buffer)) { *buffer = realloc(*buffer, maxSize); } if (CFStringGetCString(aString, *buffer, maxSize, kCFStringEncodingUTF8)) { cstr = *buffer; } } return cstr; }
PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(SharedBuffer* data) { LOG(Archives, "LegacyWebArchive - Creating from raw data"); RefPtr<LegacyWebArchive> archive = create(); ASSERT(data); if (!data) return 0; RetainPtr<CFDataRef> cfData(AdoptCF, data->createCFData()); if (!cfData) return 0; 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 0; } if (CFGetTypeID(plist.get()) != CFDictionaryGetTypeID()) { LOG(Archives, "LegacyWebArchive - Archive property list is not the expected CFDictionary, aborting invalid WebArchive"); return 0; } if (!archive->extract(plist.get())) return 0; return archive.release(); }
char *Bgethomedir(void) { #ifdef _WIN32 TCHAR appdata[MAX_PATH]; if (SUCCEEDED(SHGetSpecialFolderPathA(NULL, appdata, CSIDL_APPDATA, FALSE))) return strdup(appdata); return NULL; #elif defined __APPLE__ #if LOWANG_IOS const char* Sys_GetResourceDir(void); return strdup(Sys_GetResourceDir()); #else FSRef ref; CFStringRef str; CFURLRef base; char *s; if (FSFindFolder(kUserDomain, kVolumeRootFolderType, kDontCreateFolder, &ref) < 0) return NULL; base = CFURLCreateFromFSRef(NULL, &ref); if (!base) return NULL; str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle); CFRelease(base); if (!str) return NULL; s = (char*)CFStringGetCStringPtr(str,CFStringGetSystemEncoding()); if (s) s = strdup(s); CFRelease(str); return s; #endif #else char *e = getenv("HOME"); if (!e) return NULL; return strdup(e); #endif }
static void listServices() { IOHIDEventSystemClientRef eventSystem = IOHIDEventSystemClientCreateWithType(kCFAllocatorDefault, kIOHIDEventSystemClientTypeAdmin, NULL); CFArrayRef services = NULL; CFIndex index; require(eventSystem, exit); services = _IOHIDEventSystemClientCopyServiceDescriptions(eventSystem); require(services, exit); for ( index=0; index<CFArrayGetCount(services); index++ ) { CFStringRef serviceDebugDesc = (CFStringRef)CFArrayGetValueAtIndex(services, index); printf("%s\n", CFStringGetCStringPtr(serviceDebugDesc, CFStringGetSystemEncoding())); } exit: if ( services ) CFRelease(services); if (eventSystem) CFRelease(eventSystem); }
static void servicesAddedCallback(void * target, void * refcon, void * sender, CFArrayRef services) { CFIndex index, count; for(index=0, count = CFArrayGetCount(services); index<count; index++) { IOHIDServiceRef service = (IOHIDServiceRef)CFArrayGetValueAtIndex(services, index); CFStringRef string; IOHIDNotificationRef notification = IOHIDServiceCreateRemovalNotification(service, serviceRemovalCallback, NULL, NULL); if ( notification ) { CFDictionaryAddValue(__serviceNotifications, service, notification); CFRelease(notification); } printf("SERVICE %s:\n", (char *)kServiceAdded); string = CFCopyDescription(service); if ( string ) { printf("%s\n", CFStringGetCStringPtr(string, kCFStringEncodingMacRoman)); CFRelease(string); } } }
static PyObject* cfstring_to_pystring(CFStringRef ref) { const char* s; s = CFStringGetCStringPtr(ref, kCFStringEncodingUTF8); if (s) { return PyUnicode_DecodeUTF8( s, strlen(s), NULL); } else { CFIndex len = CFStringGetLength(ref); Boolean ok; PyObject* result; char* buf; buf = PyMem_Malloc(len*4); if (buf == NULL) { PyErr_NoMemory(); return NULL; } ok = CFStringGetCString(ref, buf, len * 4, kCFStringEncodingUTF8); if (!ok) { PyMem_Free(buf); return NULL; } else { result = PyUnicode_DecodeUTF8( buf, strlen(buf), NULL); PyMem_Free(buf); } return result; } }
void CCoreAudioHardware::GetOutputDeviceName(std::string& name) { name = "Default"; AudioDeviceID deviceId = GetDefaultOutputDevice(); if (deviceId) { AudioObjectPropertyAddress propertyAddress; propertyAddress.mScope = kAudioObjectPropertyScopeGlobal; propertyAddress.mElement = kAudioObjectPropertyElementMaster; propertyAddress.mSelector = kAudioObjectPropertyName; CFStringRef theDeviceName = NULL; UInt32 propertySize = sizeof(CFStringRef); OSStatus ret = AudioObjectGetPropertyData(deviceId, &propertyAddress, 0, NULL, &propertySize, &theDeviceName); if (ret != noErr) return; const char *cstr = CFStringGetCStringPtr(theDeviceName, kCFStringEncodingUTF8); if (cstr) name = cstr; CFRelease(theDeviceName); } }
char *Bgetsupportdir(int global) { #ifndef __APPLE__ return Bgethomedir(); #else FSRef ref; CFStringRef str; CFURLRef base; char *s; if (FSFindFolder(global ? kLocalDomain : kUserDomain, kApplicationSupportFolderType, kDontCreateFolder, &ref) < 0) return NULL; base = CFURLCreateFromFSRef(NULL, &ref); if (!base) return NULL; str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle); CFRelease(base); if (!str) return NULL; s = (char*)CFStringGetCStringPtr(str,CFStringGetSystemEncoding()); if (s) s = strdup(s); CFRelease(str); return s; #endif }
pid_t StartServer() { pid_t pid = fork(); if(pid == 0) { CFBundleRef bundle = CFBundleGetMainBundle(); CFURLRef url = CFBundleCopyExecutableURL(bundle); CFStringRef urlString = CFURLCopyPath(url); const char *file = CFStringGetCStringPtr(urlString, kCFStringEncodingUTF8); const char *args[] = { file, "--start", NULL }; execv(file, (char *const *)args); // Should not be reached, but let's exit gracefully anyway CFRelease(url); CFRelease(urlString); exit(EXIT_FAILURE); } return pid; }
QSettings mySettings; // For non static builds on mac and win (static builds are not supported) // we need to be sure we can find the qt image // plugins. In mac be sure to look in the // application bundle... #ifdef Q_OS_WIN QCoreApplication::addLibraryPath( QApplication::applicationDirPath() + QDir::separator() + "qtplugins" ); #endif #ifdef Q_OS_MACX //qDebug("Adding qt image plugins to plugin search path..."); CFURLRef myBundleRef = CFBundleCopyBundleURL( CFBundleGetMainBundle() ); CFStringRef myMacPath = CFURLCopyFileSystemPath( myBundleRef, kCFURLPOSIXPathStyle ); const char *mypPathPtr = CFStringGetCStringPtr( myMacPath, CFStringGetSystemEncoding() ); CFRelease( myBundleRef ); CFRelease( myMacPath ); QString myPath( mypPathPtr ); // if we are not in a bundle assume that the app is built // as a non bundle app and that image plugins will be // in system Qt frameworks. If the app is a bundle // lets try to set the qt plugin search path... QFileInfo myInfo( myPath ); if ( myInfo.isBundle() ) { // First clear the plugin search paths so we can be sure // only plugins from the bundle are being used QStringList myPathList; QCoreApplication::setLibraryPaths( myPathList ); // Now set the paths inside the bundle