/*
* 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;
}
