/* * This routine will percent escape the input string by making a copy. The CreateStringByAddingPercentEscapesUTF8 * routine will either return a copy or take a retain on the original string. If doRelease is set then we do * a release on the inStr. * * NOTE: We always use kCFStringEncodingUTF8 and kCFAllocatorDefault. */ static void CreateStringByAddingPercentEscapesUTF8(CFStringRef *inOutStr, CFStringRef leaveUnescaped, CFStringRef toBeEscaped, Boolean doRelease) { CFStringRef inStr = (inOutStr) ? *inOutStr : NULL; if (!inStr) /* Just a safety check */ return; *inOutStr = CFURLCreateStringByAddingPercentEscapes(NULL, inStr, leaveUnescaped, toBeEscaped, kCFStringEncodingUTF8); if (doRelease) CFRelease(inStr); }
void QuartzBitmap_Output(QuartzDesc_t dev, QuartzBitmapDevice *qbd) { if(qbd->path && qbd->uti) { /* On 10.4+ we can employ the CGImageDestination API to create a variety of different bitmap formats */ #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 char buf[PATH_MAX+1]; snprintf(buf, PATH_MAX, qbd->path, qbd->page); buf[PATH_MAX] = '\0'; CFStringRef pathString = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8*) buf, strlen(buf), kCFStringEncodingUTF8, FALSE); CFURLRef path; if(CFStringFind(pathString, CFSTR("://"), 0).location != kCFNotFound) { CFStringRef pathEscaped = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, pathString, NULL, NULL, kCFStringEncodingUTF8); path = CFURLCreateWithString(kCFAllocatorDefault, pathEscaped, NULL); CFRelease(pathEscaped); } else { path = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (const UInt8*) buf, strlen(buf), FALSE); } CFRelease(pathString); CFStringRef scheme = CFURLCopyScheme(path); CFStringRef type = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8*) qbd->uti, strlen(qbd->uti), kCFStringEncodingUTF8, FALSE); CGImageRef image = CGBitmapContextCreateImage(qbd->bitmap); if(CFStringCompare(scheme,CFSTR("file"), 0) == 0) { /* file output */ CGImageDestinationRef dest = CGImageDestinationCreateWithURL(path, type, 1, NULL); if(dest) { CGImageDestinationAddImage(dest, image, NULL); CGImageDestinationFinalize(dest); CFRelease(dest); } else error(_("QuartzBitmap_Output - unable to open file '%s'"), buf); } else if(CFStringCompare(scheme, CFSTR("clipboard"), 0) == 0) { /* clipboard output */ CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, 0); CGImageDestinationRef dest = CGImageDestinationCreateWithData(data, type, 1, NULL); CGImageDestinationAddImage(dest, image, NULL); CGImageDestinationFinalize(dest); CFRelease(dest); PasteboardRef pb = NULL; if(PasteboardCreate(kPasteboardClipboard, &pb) == noErr) { PasteboardClear(pb); PasteboardSynchronize(pb); PasteboardPutItemFlavor(pb, (PasteboardItemID) 1, type, data, 0); } CFRelease(data); } else warning(_("not a supported scheme, no image data written")); CFRelease(scheme); CFRelease(type); CFRelease(path); CFRelease(image); #endif } }
void BrowserView::goToURL(const std::wstring& urlString) { CFStringRef string = CFStringCreateWithCharacters(0, (const UniChar*)urlString.data(), urlString.size()); CFStringRef escapedString = CFURLCreateStringByAddingPercentEscapes(0, string, 0, 0, kCFStringEncodingUTF8); CFRelease(string); CFURLRef cfURL = CFURLCreateWithString(0, escapedString, 0); CFRelease(escapedString); WKURLRef url = WKURLCreateWithCFURL(cfURL); CFRelease(cfURL); WKPageRef page = WKViewGetPage(m_webView); WKPageLoadURL(page, url); WKRelease(url); }
/* Create a URI suitable for use in an http GET request, will return NULL if the length would exceed 255 bytes. */ static CFURLRef createGetURL(CFURLRef responder, CFDataRef request) { CFURLRef getURL = NULL; CFMutableDataRef base64Request = NULL; CFStringRef base64RequestString = NULL; CFStringRef peRequest = NULL; CFIndex base64Len; base64Len = SecBase64Encode(NULL, CFDataGetLength(request), NULL, 0); /* Don't bother doing all the work below if we know the end result will exceed 255 bytes (minus one for the '/' separator makes 254). */ if (base64Len + CFURLGetBytes(responder, NULL, 0) > 254) return NULL; require(base64Request = CFDataCreateMutable(kCFAllocatorDefault, base64Len), errOut); CFDataSetLength(base64Request, base64Len); SecBase64Encode(CFDataGetBytePtr(request), CFDataGetLength(request), (char *)CFDataGetMutableBytePtr(base64Request), base64Len); require(base64RequestString = CFStringCreateWithBytes(kCFAllocatorDefault, CFDataGetBytePtr(base64Request), base64Len, kCFStringEncodingUTF8, false), errOut); require(peRequest = CFURLCreateStringByAddingPercentEscapes( kCFAllocatorDefault, base64RequestString, NULL, CFSTR("+/="), kCFStringEncodingUTF8), errOut); #if 1 CFStringRef urlString = CFURLGetString(responder); CFStringRef fullURL; if (CFStringHasSuffix(urlString, CFSTR("/"))) { fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@%@"), urlString, peRequest); } else { fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@/%@"), urlString, peRequest); } getURL = CFURLCreateWithString(kCFAllocatorDefault, fullURL, NULL); CFRelease(fullURL); #else getURL = CFURLCreateWithString(kCFAllocatorDefault, peRequest, responder); #endif errOut: CFReleaseSafe(base64Request); CFReleaseSafe(base64RequestString); CFReleaseSafe(peRequest); return getURL; }
CFURLRef Caching_Stream::createFileURLWithPath(CFStringRef path) { CFURLRef fileUrl = NULL; if (!path) { return fileUrl; } CFStringRef escapedPath = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, path, NULL, NULL, kCFStringEncodingUTF8); CFURLRef regularUrl = CFURLCreateWithString(kCFAllocatorDefault, (escapedPath ? escapedPath : path), NULL); if (regularUrl) { fileUrl = CFURLCreateFilePathURL(kCFAllocatorDefault, regularUrl, NULL); CFRelease(regularUrl); } if (escapedPath) { CFRelease(escapedPath); } return fileUrl; }
static netfsError CreateURL9P(CFDictionaryRef params, CFURLRef * url) { CFMutableStringRef urlstr; CFStringRef str; int e; TRACE(); if (url == NULL || params == NULL) return EINVAL; DEBUG("params=%s", NetFSCFStringtoCString(CFCopyDescription(params))); urlstr = CFStringCreateMutable(kCFAllocatorDefault, 0); if (urlstr == NULL) return ENOMEM; str = CFDictionaryGetValue(params, kNetFSSchemeKey); if (str == NULL) goto error; CFStringAppend(urlstr, str); CFStringAppend(urlstr, CFSTR("://")); str = CFDictionaryGetValue(params, kNetFSUserNameKey); if (str != NULL) { str = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, str, NULL, CFSTR("@:/?"), kCFStringEncodingUTF8); CFStringAppend(urlstr, str); CFRelease(str); str = CFDictionaryGetValue(params, kNetFSPasswordKey); if (str != NULL) { str = CFURLCreateStringByAddingPercentEscapes (kCFAllocatorDefault, str, NULL, CFSTR("@:/?"), kCFStringEncodingUTF8); CFStringAppend(urlstr, CFSTR(":")); CFStringAppend(urlstr, str); CFRelease(str); } CFStringAppend(urlstr, CFSTR("@")); } str = CFDictionaryGetValue(params, kNetFSHostKey); if (str == NULL) goto error; str = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, str, CFSTR("[]"), CFSTR("/@:,?=;&+$"), kCFStringEncodingUTF8); CFStringAppend(urlstr, str); CFRelease(str); str = CFDictionaryGetValue(params, kNetFSAlternatePortKey); if (str != NULL) { str = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, str, NULL, NULL, kCFStringEncodingUTF8); CFStringAppend(urlstr, CFSTR(":")); CFStringAppend(urlstr, str); CFRelease(str); } /* str = CFDictionaryGetValue(params, kNetFSPathKey); if (str != NULL) { str = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, str, NULL, CFSTR("?"), kCFStringEncodingUTF8); CFStringAppend(urlstr, str); CFRelease(str); } */ *url = CFURLCreateWithString(kCFAllocatorDefault, urlstr, NULL); if (*url == NULL) goto error; DEBUG("url=%s", NetFSCFStringtoCString(CFURLGetString(*url))); CFRelease(urlstr); return 0; error: e = errno; *url = NULL; CFRelease(urlstr); return e; }
/* * Given a c-style string create a CFURL. We assume the c-style string is in * URL or UNC format. Anything else will give unexpected behavior. * NOTE: The library code doesn't care if the scheme exist or not in the URL, * but we attempt to create a URL with a scheme, just for correctness sake. * * Note: If its a URL, then do not escape it out again since it should already * be escaped out properly. */ CFURLRef CreateSMBURL(const char *url) { CFURLRef ct_url = NULL; CFStringRef urlString = CFStringCreateWithCString(NULL, url, kCFStringEncodingUTF8); CFStringRef escapedUrlString; int UNCformat = 0; escapedUrlString = NULL; /* * We have a UNC path that we need to convert into a SMB URL. Currently we * just replace the backslashes with slashes */ if (urlString && (*url == '\\') && (*(url + 1) == '\\')) { CFArrayRef urlArray = CFStringCreateArrayBySeparatingStrings(NULL, urlString, CFSTR("\\")); CFRelease(urlString); urlString = NULL; if (urlArray) { urlString = CFStringCreateByCombiningStrings(NULL, urlArray, CFSTR("/")); CFRelease(urlArray); } UNCformat = 1; } /* Something failed just get out */ if (!urlString) { return NULL; } DebugLogCFString(urlString, "urlString ", __FUNCTION__, __LINE__); /* * No scheme, add one if we can, but not required by the library code. * NOTE: If no scheme, then expect the string to start with double slashes. */ if ((!CFStringHasPrefix(urlString, CFSTR("smb://"))) && (!CFStringHasPrefix(urlString, CFSTR("cifs://")))) { CFMutableStringRef urlStringM = CFStringCreateMutableCopy(NULL, 1024, CFSTR("smb:")); if (urlStringM) { CFStringAppend(urlStringM, urlString); CFRelease(urlString); urlString = urlStringM; } } /* Something failed just get out */ if (urlString == NULL) { return (NULL); } if (UNCformat == 1) { /* For UNC format strings, escape out any non-URL characters */ escapedUrlString = CFURLCreateStringByAddingPercentEscapes(NULL, urlString, NULL, NULL, kCFStringEncodingUTF8); CFRelease(urlString); /* Can release it now */ /* Something failed just get out */ if (escapedUrlString == NULL) { return (NULL); } /* now create the URL */ ct_url = CFURLCreateWithString(kCFAllocatorDefault, escapedUrlString, NULL); CFRelease(escapedUrlString); /* We create it now release it */ } else { /* * For URL format strings, it should already be escaped. * Just create the URL. */ ct_url = CFURLCreateWithString(kCFAllocatorDefault, urlString, NULL); CFRelease(urlString); /* Can release it now */ } return ct_url; }
static void addShareToDictionary(SMBHANDLE inConnection, CFMutableDictionaryRef shareDict, CFStringRef shareName, CFStringRef comments, u_int16_t shareType, struct statfs *fs, int fs_cnt) { CFMutableDictionaryRef currDict = NULL; CFRange foundSlash; CFRange foundPercentSign; CFStringRef tempShareName1 = NULL; CFStringRef tempShareName2 = NULL; if (shareName == NULL) { return; } currDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (currDict == NULL) { /* Log error here, but keep going */ SMBLogInfo("addShareToDictionary: Couldn't create the dictionary!", ASL_LEVEL_DEBUG); return; } if (CFStringHasSuffix(shareName, CFSTR("$"))) { CFDictionarySetValue (currDict, kNetFSIsHiddenKey, kCFBooleanTrue); } if (comments) { CFDictionarySetValue (currDict, kNetCommentStrKey, comments); } switch (shareType) { case SMB_ST_DISK: CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Disk")); /* Now check to see if this share is already mounted */ if (fs) { /* We only care if its already mounted ignore any other errors for now */ if (SMBCheckForAlreadyMountedShare(inConnection, shareName, currDict, fs, fs_cnt) == EEXIST) { CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanTrue); } else { CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse); } } break; case SMB_ST_PRINTER: CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Printer")); CFDictionarySetValue (currDict, kNetFSPrinterShareKey, kCFBooleanTrue); CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse); break; case SMB_ST_PIPE: CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Pipe")); CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse); break; case SMB_ST_COMM: CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Comm")); CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse); break; default: CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Unknown")); CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse); break; } CFDictionarySetValue (currDict, kNetFSHasPasswordKey, kCFBooleanFalse); /* Check for a '/' or '%' in the share name */ foundSlash = CFStringFind (shareName, CFSTR("/"), 0); foundPercentSign = CFStringFind (shareName, CFSTR("%"), 0); if ( (foundSlash.location != kCFNotFound) || (foundPercentSign.location != kCFNotFound) ) { /* found a '/' or '%' in the name, so set a disply name to be used */ CFDictionarySetValue (currDict, kNetFSDisplayNameKey, shareName); /* escape the vol name to get '/' converted to %2f and '%' to %25 */ tempShareName1 = CFURLCreateStringByAddingPercentEscapes(NULL, shareName, NULL, CFSTR("/%"), kCFStringEncodingUTF8); /* re-escape it leaving the '/' as %2f and '%' as %25 */ tempShareName2 = CFURLCreateStringByReplacingPercentEscapesUsingEncoding(NULL, tempShareName1, CFSTR("/%"), kCFStringEncodingUTF8); CFDictionarySetValue (shareDict, tempShareName2, currDict); CFRelease (tempShareName1); CFRelease (tempShareName2); } else { CFDictionarySetValue (shareDict, shareName, currDict); } CFRelease (currDict); }
nuiHTTPResponse* nuiHTTPRequest::SendRequest() { char* pUrl = mUrl.Export(); CFStringRef originalURLString = CFStringCreateWithCString(kCFAllocatorDefault, pUrl, kCFStringEncodingUTF8); CFStringRef preprocessedString = CFURLCreateStringByReplacingPercentEscapesUsingEncoding(kCFAllocatorDefault, originalURLString, CFSTR(""), kCFStringEncodingUTF8); CFStringRef urlString = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, preprocessedString, NULL, NULL, kCFStringEncodingUTF8); free(pUrl); CFURLRef url = CFURLCreateWithString(kCFAllocatorDefault, urlString, NULL); CFRelease(urlString); char* pMeth = mMethod.Export(); CFStringRef method = CFStringCreateWithCString(kCFAllocatorDefault, pMeth, kCFStringEncodingUTF8); free(pMeth); CFHTTPMessageRef req = CFHTTPMessageCreateRequest(kCFAllocatorDefault, method, url, kCFHTTPVersion1_1); CFStringRef userAgentField = CFSTR("User-Agent"); CFStringRef userAgentName = CFSTR("nuiHTTP/2.0"); CFHTTPMessageSetHeaderFieldValue(req, userAgentField, userAgentName); CFRelease(userAgentField); CFRelease(userAgentName); nuiHTTPHeaderMap::const_iterator end = mHeaders.end(); for (nuiHTTPHeaderMap::const_iterator it = mHeaders.begin(); it != end; ++it) { char* pName = it->first.Export(); char* pVal = it->second.Export(); CFStringRef fieldName = CFStringCreateWithCString(kCFAllocatorDefault, pName, kCFStringEncodingUTF8); CFStringRef fieldValue = CFStringCreateWithCString(kCFAllocatorDefault, pVal, kCFStringEncodingUTF8); CFHTTPMessageSetHeaderFieldValue(req, fieldName, fieldValue); CFRelease(fieldName); CFRelease(fieldValue); delete pName; delete pVal; } CFDataRef body = NULL; if (mBody.size()) { body = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, (UInt8*)&mBody[0], mBody.size(), kCFAllocatorNull); CFHTTPMessageSetBody(req, body); } CFReadStreamRef readStream = CFReadStreamCreateForHTTPRequest(kCFAllocatorDefault, req); CFReadStreamOpen(readStream); std::vector<char> buf; CFIndex pos = 0; CFIndex size = 0; bool cont = true; do { buf.resize(pos + 1024); size = CFReadStreamRead(readStream, (UInt8*)&buf[pos], 1024); if (size == -1) { return NULL; } else if (size == 0) { if (CFReadStreamGetStatus(readStream) == kCFStreamStatusAtEnd) cont = false; else nglThread::MsSleep(10); } pos += size; } while (cont); CFHTTPMessageRef responseHeader = (CFHTTPMessageRef)CFReadStreamCopyProperty(readStream, kCFStreamPropertyHTTPResponseHeader); CFStringRef statusLine = CFHTTPMessageCopyResponseStatusLine(responseHeader); CFIndex strSize = CFStringGetLength(statusLine)+1; char* pStatus = new char[strSize]; CFStringGetCString(statusLine, pStatus, strSize, kCFStringEncodingUTF8); nglString status(pStatus); UInt32 statusCode = CFHTTPMessageGetResponseStatusCode(responseHeader); nuiHTTPResponse* pResponse = new nuiHTTPResponse(statusCode, status); pResponse->SetBody(&buf[0], pos); delete[] pStatus; CFDictionaryRef dict = CFHTTPMessageCopyAllHeaderFields(responseHeader); CFIndex valueCount = CFDictionaryGetCount(dict); const CFStringRef* pNames = new CFStringRef[valueCount]; const CFStringRef* pValues = new CFStringRef[valueCount]; CFDictionaryGetKeysAndValues(dict, (const void**)pNames, (const void**)pValues); for (CFIndex i = 0; i< valueCount; i++) { strSize = CFStringGetLength(pNames[i])+1; char* pName = new char[strSize]; CFStringGetCString(pNames[i], pName, strSize, kCFStringEncodingUTF8); strSize = CFStringGetLength(pValues[i])+1; char* pVal = new char[strSize]; CFStringGetCString(pValues[i], pVal, strSize, kCFStringEncodingUTF8); nglString name(pName); nglString val(pVal); pResponse->AddHeader(name, val); delete[] pName; delete[] pVal; } delete[] pNames; delete[] pValues; CFRelease(responseHeader); CFRelease(url); CFRelease(method); CFRelease(req); CFRelease(readStream); CFRelease(dict); CFRelease(statusLine); if (body) CFRelease(body); return pResponse; }
QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query) { QList<QNetworkProxy> result; // obtain a dictionary to the proxy settings: CFDictionaryRef dict = SCDynamicStoreCopyProxies(NULL); if (!dict) { qWarning("QNetworkProxyFactory::systemProxyForQuery: SCDynamicStoreCopyProxies returned NULL"); return result; // failed } if (isHostExcluded(dict, query.peerHostName())) { CFRelease(dict); return result; // no proxy for this host } // is there a PAC enabled? If so, use it first. CFNumberRef pacEnabled; if ((pacEnabled = (CFNumberRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigEnable))) { int enabled; if (CFNumberGetValue(pacEnabled, kCFNumberIntType, &enabled) && enabled) { // PAC is enabled // kSCPropNetProxiesProxyAutoConfigURLString returns the URL string // as entered in the system proxy configuration dialog CFStringRef pacLocationSetting = (CFStringRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigURLString); QCFType<CFStringRef> cfPacLocation = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, pacLocationSetting, NULL, NULL, kCFStringEncodingUTF8); if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) { QCFType<CFDataRef> pacData; QCFType<CFURLRef> pacUrl = CFURLCreateWithString(kCFAllocatorDefault, cfPacLocation, NULL); if (!pacUrl) { qWarning("Invalid PAC URL \"%s\"", qPrintable(QCFString::toQString(cfPacLocation))); return result; } SInt32 errorCode; if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, pacUrl, &pacData, NULL, NULL, &errorCode)) { QString pacLocation = QCFString::toQString(cfPacLocation); qWarning("Unable to get the PAC script at \"%s\" (%s)", qPrintable(pacLocation), cfurlErrorDescription(errorCode)); return result; } if (!pacData) { qWarning("\"%s\" returned an empty PAC script", qPrintable(QCFString::toQString(cfPacLocation))); return result; } QCFType<CFStringRef> pacScript = CFStringCreateFromExternalRepresentation(kCFAllocatorDefault, pacData, kCFStringEncodingISOLatin1); if (!pacScript) { // This should never happen, but the documentation says it may return NULL if there was a problem creating the object. QString pacLocation = QCFString::toQString(cfPacLocation); qWarning("Unable to read the PAC script at \"%s\"", qPrintable(pacLocation)); return result; } QByteArray encodedURL = query.url().toEncoded(); // converted to UTF-8 if (encodedURL.isEmpty()) { return result; // Invalid URL, abort } QCFType<CFURLRef> targetURL = CFURLCreateWithBytes(kCFAllocatorDefault, (UInt8*)encodedURL.data(), encodedURL.size(), kCFStringEncodingUTF8, NULL); if (!targetURL) { return result; // URL creation problem, abort } QCFType<CFErrorRef> pacError; QCFType<CFArrayRef> proxies = CFNetworkCopyProxiesForAutoConfigurationScript(pacScript, targetURL, &pacError); if (!proxies) { QString pacLocation = QCFString::toQString(cfPacLocation); QCFType<CFStringRef> pacErrorDescription = CFErrorCopyDescription(pacError); qWarning("Execution of PAC script at \"%s\" failed: %s", qPrintable(pacLocation), qPrintable(QCFString::toQString(pacErrorDescription))); return result; } CFIndex size = CFArrayGetCount(proxies); for (CFIndex i = 0; i < size; ++i) { CFDictionaryRef proxy = (CFDictionaryRef)CFArrayGetValueAtIndex(proxies, i); result << proxyFromDictionary(proxy); } return result; } else { QString pacLocation = QCFString::toQString(cfPacLocation); qWarning("Mac system proxy: PAC script at \"%s\" not handled", qPrintable(pacLocation)); } } } // no PAC, decide which proxy we're looking for based on the query bool isHttps = false; QString protocol = query.protocolTag().toLower(); // try the protocol-specific proxy QNetworkProxy protocolSpecificProxy; if (protocol == QLatin1String("ftp")) { protocolSpecificProxy = proxyFromDictionary(dict, QNetworkProxy::FtpCachingProxy, kSCPropNetProxiesFTPEnable, kSCPropNetProxiesFTPProxy, kSCPropNetProxiesFTPPort); } else if (protocol == QLatin1String("http")) { protocolSpecificProxy = proxyFromDictionary(dict, QNetworkProxy::HttpProxy, kSCPropNetProxiesHTTPEnable, kSCPropNetProxiesHTTPProxy, kSCPropNetProxiesHTTPPort); } else if (protocol == QLatin1String("https")) { isHttps = true; protocolSpecificProxy = proxyFromDictionary(dict, QNetworkProxy::HttpProxy, kSCPropNetProxiesHTTPSEnable, kSCPropNetProxiesHTTPSProxy, kSCPropNetProxiesHTTPSPort); } if (protocolSpecificProxy.type() != QNetworkProxy::DefaultProxy) result << protocolSpecificProxy; // let's add SOCKSv5 if present too QNetworkProxy socks5 = proxyFromDictionary(dict, QNetworkProxy::Socks5Proxy, kSCPropNetProxiesSOCKSEnable, kSCPropNetProxiesSOCKSProxy, kSCPropNetProxiesSOCKSPort); if (socks5.type() != QNetworkProxy::DefaultProxy) result << socks5; // let's add the HTTPS proxy if present (and if we haven't added // yet) if (!isHttps) { QNetworkProxy https = proxyFromDictionary(dict, QNetworkProxy::HttpProxy, kSCPropNetProxiesHTTPSEnable, kSCPropNetProxiesHTTPSProxy, kSCPropNetProxiesHTTPSPort); if (https.type() != QNetworkProxy::DefaultProxy && https != protocolSpecificProxy) result << https; } CFRelease(dict); return result; }