KURL::KURL(CFURLRef url)
{
if (!url) {
parse(0, 0);
return;
}
CFIndex bytesLength = CFURLGetBytes(url, 0, 0);
Vector<char, 512> buffer(bytesLength + 6); // 5 for "file:", 1 for null character to end C string
char* bytes = &buffer[5];
CFURLGetBytes(url, reinterpret_cast<UInt8*>(bytes), bytesLength);
bytes[bytesLength] = '\0';
if (bytes[0] != '/') {
parse(bytes, 0);
return;
}
buffer[0] = 'f';
buffer[1] = 'i';
buffer[2] = 'l';
buffer[3] = 'e';
buffer[4] = ':';
parse(buffer.data(), 0);
}
void getURLBytes(CFURLRef url, URLCharBuffer& result)
{
CFIndex bytesLength = CFURLGetBytes(url, 0, 0);
result.resize(bytesLength);
CFIndex finalLength = CFURLGetBytes(url, reinterpret_cast<UInt8*>(result.data()), bytesLength);
ASSERT_UNUSED(finalLength, finalLength == bytesLength);
}
void getURLBytes(CFURLRef url, CString& result)
{
CFIndex bytesLength = CFURLGetBytes(url, 0, 0);
char* bytes;
result = CString::newUninitialized(bytesLength, bytes);
CFIndex finalLength = CFURLGetBytes(url, reinterpret_cast<UInt8*>(bytes), bytesLength);
ASSERT_UNUSED(finalLength, finalLength == bytesLength);
}
static PyObject *AE_ConvertPathToURL(PyObject* self, PyObject* args)
{
char *cStr;
CFURLPathStyle style;
CFStringRef str;
CFURLRef url;
CFIndex len;
char buffer[PATH_MAX];
if (!PyArg_ParseTuple(args, "esl", "utf8", &cStr, &style))
return NULL;
str = CFStringCreateWithBytes(NULL,
(UInt8 *)cStr,
(CFIndex)strlen(cStr),
kCFStringEncodingUTF8,
false);
if (!str) return AE_MacOSError(1000);
url = CFURLCreateWithFileSystemPath(NULL,
str,
(CFURLPathStyle)style,
false);
PyMem_Free(cStr);
if (!url) return AE_MacOSError(1001);
len = CFURLGetBytes(url, (UInt8 *)buffer, PATH_MAX);
CFRelease(url);
return PyUnicode_DecodeUTF8(buffer, len, NULL);
}
KURL::KURL(CFURLRef url)
{
if (url) {
CFIndex bytesLength = CFURLGetBytes(url, 0, 0);
Vector<char, 2048> buffer(bytesLength + 6); // 6 for "file:", 1 for NUL terminator
char* bytes = &buffer[5];
CFURLGetBytes(url, (UInt8*)bytes, bytesLength);
bytes[bytesLength] = '\0';
if (bytes[0] == '/') {
buffer[0] = 'f';
buffer[1] = 'i';
buffer[2] = 'l';
buffer[3] = 'e';
buffer[4] = ':';
parse(buffer.data(), 0);
} else
parse(bytes, 0);
} else
parse("", 0);
}
KURL::KURL(CFURLRef url)
{
if (!url) {
invalidate();
return;
}
CFIndex bytesLength = CFURLGetBytes(url, 0, 0);
Vector<char, 512> buffer(bytesLength + 1);
char* bytes = &buffer[0];
CFURLGetBytes(url, reinterpret_cast<UInt8*>(bytes), bytesLength);
bytes[bytesLength] = '\0';
#if !USE(WTFURL)
parse(bytes);
#else
// FIXME: Add WTFURL Implementation.
UNUSED_PARAM(url);
invalidate();
#endif // USE(WTFURL)
}
/* 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;
}
bool asyncHttpPost(CFURLRef responder, CFDataRef requestData /* , bool force_nocache */ ,
asynchttp_t *http) {
bool result = true; /* True, we didn't schedule any work. */
/* resources to release on exit */
CFURLRef getURL = NULL;
/* Interesting tidbit from rfc5019
When sending requests that are less than or equal to 255 bytes in
total (after encoding) including the scheme and delimiters (http://),
server name and base64-encoded OCSPRequest structure, clients MUST
use the GET method (to enable OCSP response caching). OCSP requests
larger than 255 bytes SHOULD be submitted using the POST method.
Interesting tidbit from rfc2616:
Note: Servers ought to be cautious about depending on URI lengths
above 255 bytes, because some older client or proxy
implementations might not properly support these lengths.
Given the second note I'm assuming that the note in rfc5019 is about the
length of the URI, not the length of the entire HTTP request.
If we need to consider the entire request we need to have 17 bytes less, or
17 + 25 = 42 if we are appending a "Cache-Control: no-cache CRLF" header
field.
The 17 and 42 above are based on the request encoding from rfc2616
Method SP Request-URI SP HTTP-Version CRLF (header CRLF)* CRLF
so in our case it's:
GET SP URI SP HTTP/1.1 CRLF CRLF
17 + len(URI) bytes
or
GET SP URI SP HTTP/1.1 CRLF Cache-Control: SP no-cache CRLF CRLF
42 + len(URI) bytes
*/
/* First let's try creating a GET request. */
getURL = createGetURL(responder, requestData);
if (getURL && CFURLGetBytes(getURL, NULL, 0) < 256) {
/* Get URI is less than 256 bytes encoded, making it safe even for
older proxy or caching servers, so let's use HTTP GET. */
secdebug("http", "GET[%ld] %@", CFURLGetBytes(getURL, NULL, 0), getURL);
require_quiet(http->request = CFHTTPMessageCreateRequest(kCFAllocatorDefault,
CFSTR("GET"), getURL, kCFHTTPVersion1_1), errOut);
} else {
/* GET Request too big to ensure error free transmission, let's
create a HTTP POST http->request instead. */
secdebug("http", "POST %@ CRLF body", responder);
require_quiet(http->request = CFHTTPMessageCreateRequest(kCFAllocatorDefault,
CFSTR("POST"), responder, kCFHTTPVersion1_1), errOut);
/* Set the body and required header fields. */
CFHTTPMessageSetBody(http->request, requestData);
CFHTTPMessageSetHeaderFieldValue(http->request, kContentType,
kAppOcspRequest);
}
#if 0
if (force_nocache) {
CFHTTPMessageSetHeaderFieldValue(http->request, CFSTR("Cache-Control"),
CFSTR("no-cache"));
}
#endif
result = asynchttp_request(NULL, http);
errOut:
CFReleaseSafe(getURL);
return result;
}
