gnustep/libs-base
0
0
Fork 0
mirror of https://github.com/gnustep/libs-base.git synced 2025-04-24 01:11:01 +00:00
Code Issues Projects Releases Packages Wiki Activity
libs-base/Source/GSHTTPURLHandle.m

2021 lines
52 KiB
Objective-C
Raw Permalink Blame History

/** GSHTTPURLHandle.m - Class GSHTTPURLHandle
Copyright (C) 2000 Free Software Foundation, Inc.
Written by: Mark Allison <mark@brainstorm.co.uk>
Integrated by: Richard Frith-Macdonald <rfm@gnu.org>
Date: November 2000
This file is part of the GNUstep Library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110 USA.
*/
#import "common.h"
#import "Foundation/NSArray.h"
#import "Foundation/NSDictionary.h"
#import "Foundation/NSEnumerator.h"
#import "Foundation/NSByteOrder.h"
#import "Foundation/NSData.h"
#import "Foundation/NSException.h"
#import "Foundation/NSFileHandle.h"
#import "Foundation/NSHost.h"
#import "Foundation/NSLock.h"
#import "Foundation/NSMapTable.h"
#import "Foundation/NSNotification.h"
#import "Foundation/NSPathUtilities.h"
#import "Foundation/NSProcessInfo.h"
#import "Foundation/NSRunLoop.h"
#import "Foundation/NSURL.h"
#import "Foundation/NSURLHandle.h"
#import "Foundation/NSValue.h"
#import "GNUstepBase/GSMime.h"
#import "GNUstepBase/GSTLS.h"
#import "GNUstepBase/NSData+GNUstepBase.h"
#import "GNUstepBase/NSString+GNUstepBase.h"
#import "GNUstepBase/NSURL+GNUstepBase.h"
#import "NSCallBacks.h"
#import "GSURLPrivate.h"
#import "GSPrivate.h"
#ifdef HAVE_SYS_FILE_H
# include <sys/file.h>
#endif
#if defined(HAVE_SYS_FCNTL_H)
# include <sys/fcntl.h>
#elif defined(HAVE_FCNTL_H)
# include <fcntl.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h> // For MSG_PEEK, etc
#endif
@interface GSMimeHeader (HTTPRequest)
- (void) addToBuffer: (NSMutableData*)buf
masking: (NSMutableData**)masked;
@end
/*
* Implement map keys for strings with case insensitive comparisons,
* so we can have case insensitive matching of http headers (correct
* behavior), but actually preserve case of headers stored and written
* in case the remote server is buggy and requires particular
* captialisation of headers (some http software is faulty like that).
*/
static NSUInteger
_id_hash(void *table, NSString* o)
{
return [[o uppercaseString] hash];
}
static BOOL
_id_is_equal(void *table, NSString *o, NSString *p)
{
return ([o caseInsensitiveCompare: p] == NSOrderedSame) ? YES : NO;
}
typedef NSUInteger (*NSMT_hash_func_t)(NSMapTable *, const void *);
typedef BOOL (*NSMT_is_equal_func_t)(NSMapTable *, const void *, const void *);
typedef void (*NSMT_retain_func_t)(NSMapTable *, const void *);
typedef void (*NSMT_release_func_t)(NSMapTable *, void *);
typedef NSString *(*NSMT_describe_func_t)(NSMapTable *, const void *);
static const NSMapTableKeyCallBacks writeKeyCallBacks =
{
(NSMT_hash_func_t) _id_hash,
(NSMT_is_equal_func_t) _id_is_equal,
(NSMT_retain_func_t) _NS_id_retain,
(NSMT_release_func_t) _NS_id_release,
(NSMT_describe_func_t) _NS_id_describe,
NSNotAPointerMapKey
};
static NSString *httpVersion = @"1.1";
@interface GSHTTPURLHandle : NSURLHandle
{
BOOL tunnel;
BOOL debug;
BOOL keepalive;
BOOL returnAll;
BOOL inResponse;
id<GSLogDelegate> ioDelegate;
unsigned char challenged;
NSFileHandle *sock;
NSTimeInterval cacheAge;
NSString *urlKey;
NSURL *url;
NSURL *u;
NSURL *proxyURL;
NSMutableData *dat;
GSMimeParser *parser;
GSMimeDocument *document;
NSMutableDictionary *pageInfo;
NSMapTable *wProperties;
NSData *wData;
NSMutableDictionary *request;
unsigned int bodyPos;
unsigned int redirects;
enum {
idle,
connecting,
writing,
reading,
} connectionState;
@public
NSString *in;
NSString *out;
}
+ (void) setMaxCached: (NSUInteger)limit;
- (void) _tryLoadInBackground: (NSURL*)fromURL;
- (id<GSLogDelegate>) setDebugLogDelegate: (id<GSLogDelegate>)d;
@end
/**
* <p>
* This is a <em>PRIVATE</em> subclass of NSURLHandle.
* It is documented here in order to give you information about the
* default behavior of an NSURLHandle created to deal with a URL
* that has either the <code>http</code> or <code>https</code> scheme.
* The name and/or other implementation details of this class
* may be changed at any time.
* </p>
* <p>
* A GSHTTPURLHandle instance is used to manage connections to
* <code>http</code> and <code>https</code> URLs.
* Secure connections are handled automatically
* (using openSSL) for URLs with the scheme <code>https</code>.
* Connection via proxy server is supported, as is proxy tunneling
* for secure connections. Basic parsing of <code>http</code>
* headers is performed to extract <code>http</code> status
* information, cookies etc. Cookies are
* retained and automatically sent during subsequent requests where
* the cookie is valid.
* </p>
* <p>
* Header information from the current page may be obtained using
* -propertyForKey and -propertyForKeyIfAvailable. <code>HTTP</code>
* status information can be retrieved as by calling either of these
* methods specifying one of the following keys:
* </p>
* <list>
* <item>
* NSHTTPPropertyStatusCodeKey - numeric status code
* </item>
* <item>
* NSHTTPPropertyStatusReasonKey - text describing status
* </item>
* <item>
* NSHTTPPropertyServerHTTPVersionKey - <code>http</code>
* version supported by remote server
* </item>
* </list>
* <p>
* According to MacOS-X headers, the following should also
* be supported, but currently are not:
* </p>
* <list>
* <item>NSHTTPPropertyRedirectionHeadersKey</item>
* <item>NSHTTPPropertyErrorPageDataKey</item>
* </list>
* <p>
* The omission of these headers is not viewed as important at
* present, since the MacOS-X public beta implementation doesn't
* work either.
* </p>
* <p>
* Other calls to -propertyForKey and -propertyForKeyIfAvailable may
* be made specifying a <code>http</code> header field name.
* For example specifying a key name of &quot;Content-Length&quot;
* would return the value of the &quot;Content-Length&quot; header
* field.
* </p>
* <p>
* [GSHTTPURLHandle-writeProperty:forKey:]
* can be used to specify the parameters
* for the <code>http</code> request. The default request uses the
* &quot;GET&quot; method when fetching a page, and the
* &quot;POST&quot; method when using -writeData:.
* This can be over-ridden by calling -writeProperty:forKey: with
* the key name &quot;GSHTTPPropertyMethodKey&quot; and specifying an
* alternative method (i.e &quot;PUT&quot;).
* </p>
* <p>
* A Proxy may be specified by calling -writeProperty:forKey: to set a
* URL as the value for either https_proxy or http_proxy.<br />
* For backward compatibility a proxy may also be specified by calling
* -writeProperty:forKey:
* with the keys &quot;GSHTTPPropertyProxyHostKey&quot; and
* &quot;GSHTTPPropertyProxyPortKey&quot; to set the host and port
* of the proxy server respectively.<br />
* The proxy property can specify either the IP address or the hostname of
* the proxy server. If an attempt is made to load a page via a
* secure connection when a proxy is specified, GSHTTPURLHandle will
* attempt to open an SSL Tunnel through the proxy.
* </p>
* <p>
* Requests to the remote server may be forced to be bound to a
* particular local IP address by using the key
* &quot;GSHTTPPropertyLocalHostKey&quot; which must contain the
* IP address of a network interface on the local host.
* </p>
*/
@implementation GSHTTPURLHandle
static NSMutableDictionary *urlCache = nil;
static NSMutableArray *urlOrder = nil;
static NSLock *urlLock = nil;
static NSUInteger maxCached = 16;
static Class sslClass = 0;
static void
debugRead(GSHTTPURLHandle *handle, NSData *data)
{
int len = (int)[data length];
const uint8_t *ptr = (const uint8_t*)[data bytes];
uint8_t *hex;
NSUInteger hl;
int pos;
hl = ((len + 2) / 3) * 4;
hex = malloc(hl + 1);
hex[hl] = '\0';
GSPrivateEncodeBase64(ptr, (NSUInteger)len, hex);
for (pos = 0; pos < len; pos++)
{
if (0 == ptr[pos])
{
char *esc = [data escapedRepresentation: 0];
NSLog(@"Read for %p %@ of %d bytes (escaped) - '%s'\n<[%s]>",
handle, handle->in, len, esc, hex);
free(esc);
free(hex);
return;
}
}
NSLog(@"Read for %p %@ of %d bytes - '%*.*s'\n<[%s]>",
handle, handle->in, len, len, len, ptr, hex);
free(hex);
}
static void
debugWrite(GSHTTPURLHandle *handle, NSData *data)
{
int len = (int)[data length];
const uint8_t *ptr = (const uint8_t*)[data bytes];
uint8_t *hex;
NSUInteger hl;
int pos;
hl = ((len + 2) / 3) * 4;
hex = malloc(hl + 1);
hex[hl] = '\0';
GSPrivateEncodeBase64(ptr, (NSUInteger)len, hex);
for (pos = 0; pos < len; pos++)
{
if (0 == ptr[pos])
{
char *esc = [data escapedRepresentation: 0];
NSLog(@"Write for %p %@ of %d bytes (escaped) - '%s'\n<[%s]>",
handle, handle->out, len, esc, hex);
free(esc);
free(hex);
return;
}
}
NSLog(@"Write for %p %@ of %d bytes - '%*.*s'\n<[%s]>",
handle, handle->out, len, len, len, ptr, hex);
free(hex);
}
+ (NSURLHandle*) cachedHandleForURL: (NSURL*)newUrl
{
NSURLHandle *obj = nil;
NSString *s = [newUrl scheme];
if ([s caseInsensitiveCompare: @"http"] == NSOrderedSame
|| [s caseInsensitiveCompare: @"https"] == NSOrderedSame)
{
NSString *k = [newUrl cacheKey];
//NSLog(@"Lookup for handle for '%@'", newUrl);
[urlLock lock];
obj = RETAIN([urlCache objectForKey: k]);
if (obj != nil)
{
ASSIGN(((GSHTTPURLHandle*)obj)->url, newUrl);
[urlOrder removeObjectIdenticalTo: obj];
[urlOrder addObject: obj];
}
[urlLock unlock];
//NSLog(@"Found handle %@", obj);
}
return AUTORELEASE(obj);
}
+ (void) initialize
{
if (self == [GSHTTPURLHandle class])
{
urlCache = [NSMutableDictionary new];
[[NSObject leakAt: &urlCache] release];
urlOrder = [NSMutableArray new];
[[NSObject leakAt: &urlOrder] release];
urlLock = [NSLock new];
[[NSObject leakAt: &urlLock] release];
sslClass = [NSFileHandle sslClass];
}
}
+ (void) setMaxCached: (NSUInteger)limit
{
maxCached = limit;
}
- (void) _disconnect
{
if (sock)
{
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
[nc removeObserver: self name: nil object: sock];
[sock closeFile];
DESTROY(sock);
}
DESTROY(in);
DESTROY(out);
connectionState = idle;
}
- (void) dealloc
{
[self _disconnect];
DESTROY(out);
DESTROY(in);
DESTROY(u);
DESTROY(urlKey);
DESTROY(url);
DESTROY(proxyURL);
DESTROY(dat);
DESTROY(parser);
DESTROY(document);
DESTROY(pageInfo);
DESTROY(wData);
if (wProperties != 0)
{
NSFreeMapTable(wProperties);
}
DESTROY(request);
[super dealloc];
}
- (id) initWithURL: (NSURL*)newUrl
cached: (BOOL)cached
{
if ((self = [super initWithURL: newUrl cached: cached]) != nil)
{
debug = GSDebugSet(@"NSURLHandle");
dat = [NSMutableData new];
pageInfo = [NSMutableDictionary new];
wProperties = NSCreateMapTable(writeKeyCallBacks,
NSObjectMapValueCallBacks, 8);
request = [NSMutableDictionary new];
ASSIGN(url, newUrl);
ASSIGN(urlKey, [newUrl cacheKey]);
connectionState = idle;
if (cached == YES)
{
GSHTTPURLHandle *obj;
[urlLock lock];
obj = [urlCache objectForKey: urlKey];
[urlCache setObject: self forKey: urlKey];
if (obj != nil)
{
[urlOrder removeObjectIdenticalTo: obj];
}
[urlOrder addObject: self];
while ([urlOrder count] > maxCached)
{
obj = [urlOrder objectAtIndex: 0];
obj->cacheAge = 0.0; // Not to be re-cached
[urlCache removeObjectForKey: obj->urlKey];
[urlOrder removeObjectAtIndex: 0];
}
[urlLock unlock];
//NSLog(@"Cache handle %p for '%@'", self, newUrl);
}
}
return self;
}
+ (BOOL) canInitWithURL: (NSURL*)newUrl
{
NSString *scheme = [newUrl scheme];
if ([scheme isEqualToString: @"http"]
|| [scheme isEqualToString: @"https"])
{
return YES;
}
return NO;
}
- (void) bgdApply: (NSString*)basic
{
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
NSMutableString *s;
NSString *key;
NSString *val;
NSMutableData *buf;
NSMutableData *masked = nil;
NSString *version;
NSMapEnumerator enumerator;
RETAIN(self);
if (debug)
{
NSLog(@"%@ %p %@ %s",
NSStringFromSelector(_cmd), self, out,
(keepalive ? "re-used connection" : "initial connection"));
}
s = [basic mutableCopy];
if ([[u query] length] > 0)
{
[s appendFormat: @"?%@", [u query]];
}
version = [request objectForKey: NSHTTPPropertyServerHTTPVersionKey];
if (version == nil)
{
version = httpVersion;
}
[s appendFormat: @" HTTP/%@\r\n", version];
if ((id)NSMapGet(wProperties, (void*)@"Host") == nil)
{
NSString *s = [u scheme];
id p = [u port];
id h = [u host];
if (h == nil)
{
h = @""; // Must use an empty host header
}
if (([s isEqualToString: @"http"] && [p intValue] == 80)
|| ([s isEqualToString: @"https"] && [p intValue] == 443))
{
/* Some buggy systems object to the port being in the Host
* header when it's the default (optional) value. To keep
* them happy let's omit it in those cases.
*/
p = nil;
}
if (nil == p)
{
NSMapInsert(wProperties, (void*)@"Host", (void*)h);
}
else
{
NSMapInsert(wProperties, (void*)@"Host",
(void*)[NSString stringWithFormat: @"%@:%@", h, p]);
}
}
/* Ensure we set the correct content length (may be zero)
*/
if ((id)NSMapGet(wProperties, (void*)@"Content-Length") == nil)
{
NSMapInsert(wProperties, (void*)@"Content-Length",
(void*)[NSString stringWithFormat: @"%"PRIuPTR, [wData length]]);
}
if ([wData length] > 0)
{
/*
* Assume content type if not specified.
*/
if ((id)NSMapGet(wProperties, (void*)@"Content-Type") == nil)
{
NSMapInsert(wProperties, (void*)@"Content-Type",
(void*)@"application/x-www-form-urlencoded");
}
}
if ((id)NSMapGet(wProperties, (void*)@"Authorization") == nil)
{
NSURLProtectionSpace *space;
/*
* If we have username/password stored in the URL, and there is a
* known protection space for that URL, we generate an authentication
* header.
*/
if ([u user] != nil
&& (space = [GSHTTPAuthentication protectionSpaceForURL: u]) != nil)
{
NSString *auth;
GSHTTPAuthentication *authentication;
NSURLCredential *cred;
NSString *method;
/* Create credential from user and password stored in the URL.
* Returns nil if we have no username or password.
*/
cred = [[NSURLCredential alloc]
initWithUser: [u user]
password: [u password]
persistence: NSURLCredentialPersistenceForSession];
if (cred == nil)
{
authentication = nil;
}
else
{
/* Create authentication from credential ... returns nil if
* we have no credential.
*/
authentication = [GSHTTPAuthentication
authenticationWithCredential: cred
inProtectionSpace: space];
RELEASE(cred);
}
method = [request objectForKey: GSHTTPPropertyMethodKey];
if (method == nil)
{
if ([wData length] > 0)
{
method = @"POST";
}
else
{
method = @"GET";
}
}
auth = [authentication authorizationForAuthentication: nil
method: method
path: [u fullPath]];
/* If authentication is nil then auth will also be nil
*/
if (auth != nil)
{
[self writeProperty: auth forKey: @"Authorization"];
}
}
}
buf = [[s dataUsingEncoding: NSISOLatin1StringEncoding] mutableCopy];
enumerator = NSEnumerateMapTable(wProperties);
while (NSNextMapEnumeratorPair(&enumerator, (void **)(&key), (void**)&val))
{
GSMimeHeader *h;
h = [[GSMimeHeader alloc] initWithName: key value: val parameters: nil];
if (debug || masked)
{
[h addToBuffer: buf masking: &masked];
}
else
{
[h addToBuffer: buf masking: NULL];
}
RELEASE(h);
}
NSEndMapTableEnumeration(&enumerator);
[buf appendBytes: "\r\n" length: 2];
if (masked)
{
[masked appendBytes: "\r\n" length: 2];
}
/*
* Append any data to be sent
*/
if (wData != nil)
{
[buf appendData: wData];
if (masked)
{
[masked appendData: wData];
}
}
/*
* Watch for write completion.
*/
[nc addObserver: self
selector: @selector(bgdWrite:)
name: GSFileHandleWriteCompletionNotification
object: sock];
connectionState = writing;
/*
* Send request to server.
*/
if (debug)
{
if (nil == masked)
{
masked = buf; // Just log unmasked data
}
if (NO == [ioDelegate putBytes: [masked bytes]
ofLength: [masked length]
byHandle: self])
{
debugWrite(self, masked);
}
}
[sock writeInBackgroundAndNotify: buf];
RELEASE(buf);
RELEASE(s);
DESTROY(self);
}
- (void) bgdRead: (NSNotification*) not
{
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
NSDictionary *dict = [not userInfo];
NSData *d;
NSRange r;
unsigned readCount;
RETAIN(self);
if (debug)
NSLog(@"%@ %p %s", NSStringFromSelector(_cmd), self, keepalive?"K":"");
d = [dict objectForKey: NSFileHandleNotificationDataItem];
readCount = [d length];
if (debug)
{
if (NO == [ioDelegate getBytes: [d bytes]
ofLength: readCount
byHandle: self])
{
debugRead(self, d);
}
}
if (connectionState == idle)
{
/*
* We received an event on a handle which is not in use ...
* it should just be the connection being closed by the other
* end because of a timeout etc.
*/
if (debug)
{
NSUInteger length = [d length];
if (length > 0)
{
if (nil == ioDelegate)
{
NSLog(@"%@ %p %s Unexpected data (%*.*s) from remote!",
NSStringFromSelector(_cmd), self, keepalive?"K":"",
(int)[d length], (int)[d length], (char*)[d bytes]);
}
else
{
NSLog(@"%@ %p %s Unexpected data from remote!",
NSStringFromSelector(_cmd), self, keepalive?"K":"");
if (NO == [ioDelegate getBytes: [d bytes]
ofLength: length
byHandle: self])
{
NSLog(@"%@ %p %s (%*.*s)",
NSStringFromSelector(_cmd), self, keepalive?"K":"",
(int)[d length], (int)[d length], (char*)[d bytes]);
}
}
}
}
[self _disconnect];
}
else if (0 == readCount && NO == inResponse && YES == keepalive)
{
/* On a keepalive connection where the remote end
* dropped the connection without responding. We
* should try again.
*/
if (connectionState != idle)
{
[self _disconnect];
if (debug)
{
NSLog(@"%@ %p restart on new connection",
NSStringFromSelector(_cmd), self);
}
[self _tryLoadInBackground: u];
}
}
else if ([parser parse: d] == NO && [parser isComplete] == NO)
{
inResponse = YES;
if (debug)
{
NSLog(@"HTTP parse failure - %@", parser);
}
[self endLoadInBackground];
[self backgroundLoadDidFailWithReason: @"Response parse failed"];
}
else
{
BOOL complete;
inResponse = YES;
complete = [parser isComplete];
if (complete == NO && [parser isInHeaders] == NO)
{
GSMimeHeader *info;
NSString *enc;
NSString *len;
int status;
info = [document headerNamed: @"http"];
status = [[info objectForKey: NSHTTPPropertyStatusCodeKey] intValue];
len = [[document headerNamed: @"content-length"] value];
enc = [[document headerNamed: @"content-transfer-encoding"] value];
if (enc == nil)
{
enc = [[document headerNamed: @"transfer-encoding"] value];
}
if (status == 204 || status == 304)
{
complete = YES; // No body expected.
}
else if ([enc isEqualToString: @"chunked"] == YES)
{
complete = NO; // Read chunked body data
}
else if (nil != len && [len intValue] == 0)
{
complete = YES; // content-length explicitly zero
}
if (complete == NO && [d length] == 0)
{
complete = YES; // Had EOF ... terminate
}
}
if (complete == YES)
{
GSMimeHeader *info;
NSString *val;
NSNumber *num;
float ver;
int code;
connectionState = idle;
[nc removeObserver: self name: nil object: sock];
ver = [[[document headerNamed: @"http"] value] floatValue];
if (ver < 1.1)
{
[self _disconnect];
}
else if (nil != (val = [[document headerNamed: @"connection"] value]))
{
val = [val lowercaseString];
if (YES == [val isEqualToString: @"close"])
{
[self _disconnect];
}
else if ([val length] > 5)
{
NSEnumerator *e;
e = [[val componentsSeparatedByString: @","]
objectEnumerator];
while (nil != (val = [e nextObject]))
{
val = [val stringByTrimmingSpaces];
if (YES == [val isEqualToString: @"close"])
{
[self _disconnect];
break;
}
}
}
}
/*
* Retrieve essential keys from document
*/
info = [document headerNamed: @"http"];
num = [info objectForKey: NSHTTPPropertyStatusCodeKey];
code = [num intValue];
if (code == 401 && self->challenged < 2)
{
GSMimeHeader *ah;
self->challenged++; // Prevent repeated challenge/auth
if ((ah = [document headerNamed: @"WWW-Authenticate"]) != nil)
{
NSURLProtectionSpace *space;
NSString *ac;
GSHTTPAuthentication *authentication;
NSString *method;
NSString *auth;
ac = [ah value];
space = [GSHTTPAuthentication
protectionSpaceForAuthentication: ac requestURL: url];
if (space == nil)
{
authentication = nil;
}
else
{
NSURLCredential *cred;
/*
* Create credential from user and password
* stored in the URL.
* Returns nil if we have no username or password.
*/
cred = [[NSURLCredential alloc]
initWithUser: [url user]
password: [url password]
persistence: NSURLCredentialPersistenceForSession];
if (cred == nil)
{
authentication = nil;
}
else
{
/*
* Get the digest object and ask it for a header
* to use for authorisation.
* Returns nil if we have no credential.
*/
authentication = [GSHTTPAuthentication
authenticationWithCredential: cred
inProtectionSpace: space];
RELEASE(cred);
}
}
method = [request objectForKey: GSHTTPPropertyMethodKey];
if (method == nil)
{
if ([wData length] > 0)
{
method = @"POST";
}
else
{
method = @"GET";
}
}
auth = [authentication authorizationForAuthentication: ac
method: method
path: [url fullPath]];
if (auth != nil)
{
[self writeProperty: auth forKey: @"Authorization"];
[self _tryLoadInBackground: u];
RELEASE(self);
return; // Retrying.
}
}
}
if (num != nil)
{
[pageInfo setObject: num forKey: NSHTTPPropertyStatusCodeKey];
}
val = [info objectForKey: NSHTTPPropertyServerHTTPVersionKey];
if (val != nil)
{
[pageInfo setObject: val
forKey: NSHTTPPropertyServerHTTPVersionKey];
}
val = [info objectForKey: NSHTTPPropertyStatusReasonKey];
if (val != nil)
{
[pageInfo setObject: val forKey: NSHTTPPropertyStatusReasonKey];
}
/*
* Tell superclass that we have successfully loaded the data.
*/
d = [parser data];
r = NSMakeRange(bodyPos, [d length] - bodyPos);
bodyPos = 0;
DESTROY(wData);
NSResetMapTable(wProperties);
connectionState = idle; // Finished I/O
if (returnAll || (code >= 200 && code < 300))
{
[self didLoadBytes: [d subdataWithRange: r]
loadComplete: YES];
}
else
{
[self didLoadBytes: [d subdataWithRange: r]
loadComplete: NO];
[self cancelLoadInBackground];
}
}
else
{
/*
* Report partial data if possible.
*/
if ([parser isInBody])
{
d = [parser data];
r = NSMakeRange(bodyPos, [d length] - bodyPos);
bodyPos = [d length];
[self didLoadBytes: [d subdataWithRange: r]
loadComplete: NO];
}
}
if (complete == NO && readCount == 0)
{
/* The read failed ... dropped, but parsing is not complete.
* The request was sent, so we can't know whether it was
* lost in the network or the remote end received it and
* the response was lost.
*/
if (debug)
{
NSLog(@"HTTP response not received - %@", parser);
}
[self endLoadInBackground];
[self backgroundLoadDidFailWithReason: @"Response parse failed"];
}
if (sock != nil && connectionState == reading)
{
if ([sock readInProgress] == NO)
{
[sock readInBackgroundAndNotify];
}
}
}
DESTROY(self);
}
- (void) bgdTunnelRead: (NSNotification*) not
{
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
NSDictionary *dict = [not userInfo];
NSData *d;
GSMimeParser *p;
unsigned readCount;
RETAIN(self);
if (debug)
{
NSLog(@"%@ %p %s", NSStringFromSelector(_cmd), self, keepalive?"K":"");
}
d = [dict objectForKey: NSFileHandleNotificationDataItem];
readCount = [d length];
if (debug)
{
if (NO == [ioDelegate getBytes: [d bytes]
ofLength: [d length]
byHandle: self])
{
debugRead(self, d);
}
}
if (readCount > 0)
{
inResponse = YES;
[dat appendData: d];
}
else if (NO == inResponse)
{
/* remote end dropped the connection without responding
*/
[self _disconnect];
if (debug)
{
NSLog(@"%@ %p restart on new connection",
NSStringFromSelector(_cmd), self);
}
[self _tryLoadInBackground: u];
DESTROY(self);
return;
}
p = [GSMimeParser new];
[p parse: dat];
if ([p isInBody] == YES || [d length] == 0)
{
GSMimeHeader *info;
NSString *val;
NSNumber *num;
[p parse: nil];
info = [[p mimeDocument] headerNamed: @"http"];
val = [info objectForKey: NSHTTPPropertyServerHTTPVersionKey];
if (val != nil)
[pageInfo setObject: val forKey: NSHTTPPropertyServerHTTPVersionKey];
num = [info objectForKey: NSHTTPPropertyStatusCodeKey];
if (num != nil)
[pageInfo setObject: num forKey: NSHTTPPropertyStatusCodeKey];
val = [info objectForKey: NSHTTPPropertyStatusReasonKey];
if (val != nil)
[pageInfo setObject: val forKey: NSHTTPPropertyStatusReasonKey];
[nc removeObserver: self
name: NSFileHandleReadCompletionNotification
object: sock];
[dat setLength: 0];
tunnel = NO;
}
else
{
if ([sock readInProgress] == NO)
{
[sock readInBackgroundAndNotify];
}
}
RELEASE(p);
DESTROY(self);
}
- (void) loadInBackground
{
self->challenged = 0;
[self _tryLoadInBackground: nil];
}
- (void) endLoadInBackground
{
DESTROY(wData);
NSResetMapTable(wProperties);
/* Socket must be removed from I/O notifications and connection state
* marked idle, but the socket is already idle it may be re-used for
* another request.
*/
if (sock)
{
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
[nc removeObserver: self name: nil object: sock];
if (connectionState != idle)
{
[sock closeFile]; // Close to cancel any I/O in progress
DESTROY(sock);
}
}
connectionState = idle;
[super endLoadInBackground];
}
- (void) _apply
{
NSString *method;
NSString *path;
NSString *s;
/*
* Set up request - differs for proxy version unless tunneling via ssl.
*/
path = [[[u fullPath] stringByTrimmingSpaces]
stringByAddingPercentEscapesUsingEncoding: NSUTF8StringEncoding];
if ([path length] == 0)
{
path = @"/";
}
method = [request objectForKey: GSHTTPPropertyMethodKey];
if (method == nil)
{
if ([wData length] > 0)
{
method = @"POST";
}
else
{
method = @"GET";
}
}
if (proxyURL
&& [[u scheme] isEqualToString: @"https"] == NO)
{
if ([u port] == nil)
{
s = [[NSString alloc] initWithFormat: @"%@ http://%@%@",
method, [u host], path];
}
else
{
s = [[NSString alloc] initWithFormat: @"%@ http://%@:%@%@",
method, [u host], [u port], path];
}
}
else // no proxy
{
s = [[NSString alloc] initWithFormat: @"%@ %@",
method, path];
}
[self bgdApply: s];
RELEASE(s);
}
- (void) bgdConnect: (NSNotification*)notification
{
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
NSDictionary *userInfo = [notification userInfo];
NSString *e;
[nc removeObserver: self
name: GSFileHandleConnectCompletionNotification
object: sock];
/*
* See if the connection attempt caused an error.
*/
e = [userInfo objectForKey: GSFileHandleNotificationError];
if (e != nil)
{
NSLog(@"Unable to connect to %@:%@ via socket ... %@",
[sock socketAddress], [sock socketService], e);
/*
* Tell superclass that the load failed - let it do housekeeping.
*/
[self endLoadInBackground];
[self backgroundLoadDidFailWithReason:
[NSString stringWithFormat: @"Failed to connect: %@", e]];
return;
}
in = [[NSString alloc] initWithFormat: @"(%@:%@ <-- %@:%@)",
[sock socketLocalAddress], [sock socketLocalService],
[sock socketAddress], [sock socketService]];
out = [[NSString alloc] initWithFormat: @"(%@:%@ --> %@:%@)",
[sock socketLocalAddress], [sock socketLocalService],
[sock socketAddress], [sock socketService]];
if (debug)
{
NSLog(@"%@ %p", NSStringFromSelector(_cmd), self);
}
/*
* If SSL via proxy, set up tunnel first
*/
if (proxyURL && [[u scheme] isEqualToString: @"https"])
{
NSRunLoop *loop = [NSRunLoop currentRunLoop];
NSString *cmd;
NSTimeInterval last = 0.0;
NSTimeInterval limit = 0.01;
NSData *buf;
NSDate *when;
int status;
NSString *version;
version = [request objectForKey: NSHTTPPropertyServerHTTPVersionKey];
if (version == nil)
{
version = httpVersion;
}
if ([u port] == nil)
{
cmd = [NSString stringWithFormat: @"CONNECT %@:443 HTTP/%@\r\n\r\n",
[u host], version];
}
else
{
cmd = [NSString stringWithFormat: @"CONNECT %@:%@ HTTP/%@\r\n\r\n",
[u host], [u port], version];
}
/*
* Set up default status for if connection is lost.
*/
[pageInfo setObject: @"1.0" forKey: NSHTTPPropertyServerHTTPVersionKey];
[pageInfo setObject: [NSNumber numberWithInt: 503]
forKey: NSHTTPPropertyStatusCodeKey];
[pageInfo setObject: @"Connection dropped by proxy server"
forKey: NSHTTPPropertyStatusReasonKey];
tunnel = YES;
[nc addObserver: self
selector: @selector(bgdWrite:)
name: GSFileHandleWriteCompletionNotification
object: sock];
buf = [cmd dataUsingEncoding: NSASCIIStringEncoding];
if (debug)
{
if (NO == [ioDelegate putBytes: [buf bytes]
ofLength: [buf length]
byHandle: self])
{
debugWrite(self, buf);
}
}
[sock writeInBackgroundAndNotify: buf];
when = [NSDate alloc];
while (tunnel == YES)
{
if (limit < 1.0)
{
NSTimeInterval tmp = limit;
limit += last;
last = tmp;
}
when = [when initWithTimeIntervalSinceNow: limit];
[loop runUntilDate: when];
}
RELEASE(when);
status = [[pageInfo objectForKey: NSHTTPPropertyStatusCodeKey] intValue];
if (status != 200)
{
[self endLoadInBackground];
[self backgroundLoadDidFailWithReason: @"Failed proxy tunneling"];
return;
}
}
if ([[u scheme] isEqualToString: @"https"])
{
static NSArray *keys = nil;
NSMutableDictionary *opts;
NSUInteger count;
BOOL success = NO;
/* If we are an https connection, negotiate secure connection.
* Make sure we are not an observer of the file handle while
* it is connecting...
*/
[nc removeObserver: self name: nil object: sock];
if (nil == keys)
{
keys = [[NSArray alloc] initWithObjects:
GSTLSCAFile,
GSTLSCertificateFile,
GSTLSCertificateKeyFile,
GSTLSCertificateKeyPassword,
GSTLSDebug,
GSTLSIssuers,
GSTLSOwners,
GSTLSPriority,
GSTLSRemoteHosts,
GSTLSRevokeFile,
GSTLSServerName,
GSTLSVerify,
nil];
}
count = [keys count];
opts = [[NSMutableDictionary alloc] initWithCapacity: count];
while (count-- > 0)
{
NSString *key = [keys objectAtIndex: count];
NSString *str = [request objectForKey: key];
if (nil != str)
{
[opts setObject: str forKey: key];
}
}
/* If there is no value set for the server name, and the host in the
* URL is a domain name rather than an address, we use that.
*/
if (nil == [opts objectForKey: GSTLSServerName])
{
NSString *host = [u host];
unichar c = [host length] == 0 ? 0 : [host characterAtIndex: 0];
if (c != 0 && c != ':' && !isdigit(c))
{
[opts setObject: host forKey: GSTLSServerName];
}
}
if (debug) [opts setObject: @"YES" forKey: GSTLSDebug];
[sock sslSetOptions: opts];
RELEASE(opts);
if ([sock sslHandshakeEstablished: &success outgoing: YES])
{
if (NO == success)
{
if (debug)
NSLog(@"%@ %p %s Failed to make ssl connect",
NSStringFromSelector(_cmd), self, keepalive?"K":"");
[self endLoadInBackground];
[self backgroundLoadDidFailWithReason:
@"Failed to make ssl connect"];
return;
}
}
else
{
[nc addObserver: self
selector: @selector(bgdHandshake:)
name: NSFileHandleDataAvailableNotification
object: sock];
[sock waitForDataInBackgroundAndNotify];
return;
}
}
[self _apply];
}
- (void) bgdHandshake: (NSNotification*)notification
{
BOOL success = NO;
if ([sock sslHandshakeEstablished: &success outgoing: YES])
{
if (success)
{
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
[nc removeObserver: self
name: NSFileHandleDataAvailableNotification
object: sock];
[self _apply];
}
else
{
if (debug)
NSLog(@"%@ %p %s Failed to make ssl connect",
NSStringFromSelector(_cmd), self, keepalive?"K":"");
[self endLoadInBackground];
[self backgroundLoadDidFailWithReason:
@"Failed to make ssl connect"];
}
}
else
{
[sock waitForDataInBackgroundAndNotify];
}
}
- (void) bgdWrite: (NSNotification*)notification
{
NSNotificationCenter *nc;
NSDictionary *userInfo = [notification userInfo];
NSString *e;
RETAIN(self);
if (debug)
NSLog(@"%@ %p %s", NSStringFromSelector(_cmd), self, keepalive?"K":"");
e = [userInfo objectForKey: GSFileHandleNotificationError];
if (e != nil)
{
tunnel = NO;
if (keepalive == YES)
{
/*
* The write failed ... connection dropped ... and we
* are re-using an existing connection (keepalive = YES)
* then we may try again with a new connection.
*/
[self _disconnect];
if (debug)
{
NSLog(@"%@ %p restart on new connection",
NSStringFromSelector(_cmd), self);
}
[self _tryLoadInBackground: u];
RELEASE(self);
return;
}
NSLog(@"Failed to write command to socket - %@ %p %s",
e, self, keepalive?"K":"");
/*
* Tell superclass that the load failed - let it do housekeeping.
*/
[self endLoadInBackground];
[self backgroundLoadDidFailWithReason:
[NSString stringWithFormat: @"Failed to write request: %@", e]];
DESTROY(self);
return;
}
else
{
/*
* Don't watch for write completions any more.
*/
nc = [NSNotificationCenter defaultCenter];
[nc removeObserver: self
name: GSFileHandleWriteCompletionNotification
object: sock];
/*
* Ok - write completed, let's read the response.
*/
if (tunnel == YES)
{
[nc addObserver: self
selector: @selector(bgdTunnelRead:)
name: NSFileHandleReadCompletionNotification
object: sock];
}
else
{
bodyPos = 0;
[nc addObserver: self
selector: @selector(bgdRead:)
name: NSFileHandleReadCompletionNotification
object: sock];
}
if ([sock readInProgress] == NO)
{
[sock readInBackgroundAndNotify];
}
connectionState = reading;
}
DESTROY(self);
}
/**
* If necessary, this method calls -loadInForeground to send a
* request to the webserver, and get a page back. It then returns
* the property for the specified key -
* <list>
* <item>
* NSHTTPPropertyStatusCodeKey - numeric status code returned
* by the last request.
* </item>
* <item>
* NSHTTPPropertyStatusReasonKey - text describing status of
* the last request
* </item>
* <item>
* NSHTTPPropertyServerHTTPVersionKey - <code>http</code>
* version supported by remote server
* </item>
* <item>
* Other keys are taken to be the names of <code>http</code>
* headers and the corresponding header value (or nil if there
* is none) is returned.
* </item>
* </list>
*/
- (id) propertyForKey: (NSString*) propertyKey
{
if (document == nil)
[self loadInForeground];
return [self propertyForKeyIfAvailable: propertyKey];
}
- (id) propertyForKeyIfAvailable: (NSString*) propertyKey
{
id result = [pageInfo objectForKey: propertyKey];
if (result == nil)
{
NSString *key = [propertyKey lowercaseString];
NSArray *array = [document headersNamed: key];
if ([array count] == 0)
{
return nil;
}
else if ([array count] == 1)
{
GSMimeHeader *hdr = [array objectAtIndex: 0];
result = [hdr value];
}
else
{
NSEnumerator *enumerator = [array objectEnumerator];
GSMimeHeader *val;
result = [NSMutableArray arrayWithCapacity: [array count]];
while ((val = [enumerator nextObject]) != nil)
{
[result addObject: [val value]];
}
}
}
return result;
}
- (int) setDebug: (int)flag
{
int old = debug;
debug = flag ? YES : NO;
return old;
}
- (id<GSLogDelegate>) setDebugLogDelegate: (id<GSLogDelegate>)d
{
id<GSLogDelegate> old = ioDelegate;
NSAssert(nil == d || [d conformsToProtocol: @protocol(GSLogDelegate)],
NSInvalidArgumentException);
ioDelegate = d;
return old;
}
- (void) setReturnAll: (BOOL)flag
{
returnAll = flag;
}
- (void) setURL: (NSURL*)newUrl
{
NSAssert(connectionState == idle, NSInternalInconsistencyException);
NSAssert([newUrl isKindOfClass: [NSURL class]], NSInvalidArgumentException);
if (NO == [newUrl isEqual: url])
{
NSString *k = [newUrl cacheKey];
if (NO == [k isEqual: urlKey])
{
/* Changing the URL of a handle to one that's not cache-compatible
* implies that the handle must be removed from the cache and also
* that the underlying network connection can no longer be used.
*/
[urlLock lock];
if (self == [urlCache objectForKey: urlKey])
{
[urlCache removeObjectForKey: urlKey];
[urlOrder removeObjectIdenticalTo: self];
}
[urlLock unlock];
[self _disconnect];
ASSIGN(urlKey, k);
}
ASSIGN(url, newUrl);
}
}
- (void) _tryLoadInBackground: (NSURL*)fromURL
{
NSNotificationCenter *nc;
NSString *host = nil;
NSString *port = nil;
NSString *s;
/*
* Don't start a load if one is in progress.
*/
if (connectionState != idle)
{
NSLog(@"Attempt to load an http handle which is not idle ... ignored");
return;
}
inResponse = NO;
[dat setLength: 0];
RELEASE(document);
RELEASE(parser);
[pageInfo removeAllObjects];
parser = [GSMimeParser new];
document = RETAIN([parser mimeDocument]);
/*
* First time round, fromURL is nil, so we use the url ivar and
* we notify that the load is begining. On retries we get a real
* value in fromURL to use.
*/
if (fromURL == nil)
{
redirects = 0;
ASSIGN(u, url);
[self beginLoadInBackground];
}
else
{
ASSIGN(u, fromURL);
}
host = [u host];
port = (id)[u port];
if (port != nil)
{
port = [NSString stringWithFormat: @"%u", [port intValue]];
}
else
{
port = [u scheme];
}
if ([port isEqualToString: @"https"])
{
port = @"443";
}
else if ([port isEqualToString: @"http"])
{
port = @"80";
}
/* An existing socket with keepalive may have been closed by the other
* end.
* On unix systems we can simply peek on the file descriptor for a much
* more efficient check.
* On windows we use the same system, it is noted to be inefficient but
* we don't care because we peek rare enough at each HTTP request.
*/
if (sock != nil)
{
int fd = [sock fileDescriptor];
if (debug)
{
NSLog(@"%@ %p check for reusable socket",
NSStringFromSelector(_cmd), self);
}
if (fd >= 0)
{
int result;
unsigned char c;
#if !defined(MSG_DONTWAIT)
#define MSG_DONTWAIT 0
#endif
result = recv(fd, (void *)&c, 1, MSG_PEEK | MSG_DONTWAIT);
if (result == 0 || (result < 0 && errno != EAGAIN && errno != EINTR))
{
DESTROY(sock);
}
}
else
{
DESTROY(sock);
}
if (debug)
{
if (sock == nil)
{
NSLog(@"%@ %p socket closed by remote",
NSStringFromSelector(_cmd), self);
}
else
{
NSLog(@"%@ %p socket is still open",
NSStringFromSelector(_cmd), self);
}
}
}
if (sock == nil)
{
NSURLProtectionSpace *space;
NSURL *proxy = nil;
NSString *proxyStr = nil;
keepalive = NO; // New connection
/*
* If we have a local address specified,
* tell the file handle to bind to it.
*/
s = [request objectForKey: GSHTTPPropertyLocalHostKey];
if ([s length] > 0)
{
s = [NSString stringWithFormat: @"bind-%@", s];
}
else
{
s = @"tcp"; // Bind to any.
}
space = [GSHTTPAuthentication protectionSpaceForURL: u];
if ([space isProxy])
{
proxyStr = [NSString stringWithFormat: @"%@://%@:%u/",
[u scheme], [space host], (unsigned)[space port]];
}
else
{
NSString *ph;
NSString *pp;
ph = [request objectForKey: GSHTTPPropertyProxyHostKey];
pp = [request objectForKey: GSHTTPPropertyProxyPortKey];
if (ph)
{
if (pp)
{
proxyStr = [NSString stringWithFormat: @"%@://%@:%@/",
[u scheme], ph, pp];
}
else
{
proxyStr = [NSString stringWithFormat: @"%@://%@/",
[u scheme], ph];
}
}
/* The preferred proxy specification is by a URL set as a property
*/
if ([[u scheme] isEqualToString: @"https"])
{
proxy = [request objectForKey: @"https_proxy"];
}
else
{
proxy = [request objectForKey: @"http_proxy"];
}
}
if ([proxy isKindOfClass: [NSString class]])
{
proxyStr = (NSString*)proxy;
proxy = nil;
}
/* A generic fallback for the entire process can come from
* environment variables.
*/
if (nil == proxy && nil == proxyStr)
{
NSDictionary *env;
NSString *key;
env = [[NSProcessInfo processInfo] environment];
key = [[u scheme] stringByAppendingString: @"_proxy"];
if (nil == (proxyStr = [env objectForKey: key]))
{
proxyStr = [env objectForKey: [key uppercaseString]];
}
}
if (nil == proxy)
{
/* We make the proxy URL from a supplied string unless that is empty;
* An empty string in the request can be used to disable the process
* wide settings for that request..
*/
if ([proxyStr length])
{
proxy = [NSURL URLWithString: proxyStr];
}
}
/* Make sure the proxy URL has a port specified. The default port
* depends on the scheme of the request (4430 for TLS, 8080 unencrypted).
*/
if (proxy && [[proxy port] intValue] == 0)
{
NSURLComponents *c;
c = [NSURLComponents componentsWithURL: proxy
resolvingAgainstBaseURL: NO];
if ([[u scheme] isEqualToString: @"https"])
{
[c setPort: [NSNumber numberWithInteger: 4430]];
}
else
{
[c setPort: [NSNumber numberWithInteger: 8080]];
}
proxy = [c URL];
}
ASSIGN(proxyURL, proxy);
if (nil == proxyURL)
{
if ([[u scheme] isEqualToString: @"https"])
{
NSString *cert;
NSString *key;
NSString *pwd;
if (sslClass == 0)
{
[self backgroundLoadDidFailWithReason: @"https not supported"
@" ... needs gnustep-base built with GNUTLS"];
return;
}
sock = [sslClass fileHandleAsClientInBackgroundAtAddress: host
service: port
protocol: s];
/* Map old SSL keys onto new.
*/
cert = [request objectForKey: GSHTTPPropertyCertificateFileKey];
if (nil != cert)
{
[request setObject: cert
forKey: GSTLSCertificateFile];
}
key = [request objectForKey: GSHTTPPropertyKeyFileKey];
if (nil != key)
{
[request setObject: key
forKey: GSTLSCertificateKeyFile];
}
pwd = [request objectForKey: GSHTTPPropertyPasswordKey];
if (nil != pwd)
{
[request setObject: pwd
forKey: GSTLSCertificateKeyPassword];
}
}
else
{
sock = [NSFileHandle fileHandleAsClientInBackgroundAtAddress: host
service: port
protocol: s];
}
}
else
{
port = [[proxyURL port] description];
host = [proxyURL host];
if ([[u scheme] isEqualToString: @"https"])
{
if (sslClass == 0)
{
[self backgroundLoadDidFailWithReason: @"https not supported"
@" ... needs gnustep-base built with GNUTLS"];
return;
}
sock = [sslClass fileHandleAsClientInBackgroundAtAddress: host
service: port
protocol: s];
}
else
{
sock = [NSFileHandle
fileHandleAsClientInBackgroundAtAddress: host
service: port
protocol: s];
}
}
if (sock == nil)
{
/*
* Tell superclass that the load failed - let it do housekeeping.
*/
[self backgroundLoadDidFailWithReason:
[NSString stringWithFormat: @"Unable to connect to %@:%@ ... %@",
host, port, [NSError _last]]];
return;
}
RETAIN(sock);
nc = [NSNotificationCenter defaultCenter];
[nc addObserver: self
selector: @selector(bgdConnect:)
name: GSFileHandleConnectCompletionNotification
object: sock];
connectionState = connecting;
if (debug)
{
NSLog(@"%@ %p start connect to %@:%@",
NSStringFromSelector(_cmd), self, host, port);
}
}
else
{
NSString *method;
NSString *path;
NSString *basic;
// Stop waiting for connection to be closed down.
nc = [NSNotificationCenter defaultCenter];
[nc removeObserver: self
name: NSFileHandleReadCompletionNotification
object: sock];
/* Reusing a connection. Set flag to say that it has been kept
* alive and we don't know if the other end has dropped it
* until we write to it and read some response.
*/
keepalive = YES;
method = [request objectForKey: GSHTTPPropertyMethodKey];
if (method == nil)
{
if ([wData length] > 0)
{
method = @"POST";
}
else
{
method = @"GET";
}
}
path = [[[u fullPath] stringByTrimmingSpaces]
stringByAddingPercentEscapesUsingEncoding: NSUTF8StringEncoding];
if ([path length] == 0)
{
path = @"/";
}
basic = [NSString stringWithFormat: @"%@ %@", method, path];
[self bgdApply: basic];
}
}
/**
* Writes the specified data as the body of an <code>http</code>
* or <code>https</code> request to the web server.
* Returns YES on success,
* NO on failure. By default, this method performs a POST operation.
* On completion, the resource data for this handle is set to the
* page returned by the request.
*/
- (BOOL) writeData: (NSData*)d
{
ASSIGN(wData, d);
return YES;
}
/**
* Sets a property to be used in the next request made by this handle.
* The property is set as a header in the next request, unless it is
* one of the following -
* <list>
* <item>
* GSHTTPPropertyBodyKey - set an NSData item to be sent to
* the server as the body of the request.
* </item>
* <item>
* GSHTTPPropertyMethodKey - override the default method of
* the request (eg. &quot;PUT&quot;).
* </item>
* <item>
* GSHTTPPropertyProxyHostKey - specify the name or IP address
* of a host to proxy through. Obsolete ... use
* https_proxy or http_proxy to specify the URL of the proxy
* </item>
* <item>
* GSHTTPPropertyProxyPortKey - specify the port number to
* connect to on the proxy host. If not give, this defaults
* to 8080 for <code>http</code> and 4430 for <code>https</code>.
* Obsolete ... use https_proxy or http_proxy to specify the URL
* of the proxy.
* </item>
* <item>
* Any GSTLS... key to control TLS behavior
* </item>
* <item>
* Any NSHTTPProperty... key
* </item>
* </list>
*/
- (BOOL) writeProperty: (id) property forKey: (NSString*) propertyKey
{
if (propertyKey == nil
|| [propertyKey isKindOfClass: [NSString class]] == NO)
{
[NSException raise: NSInvalidArgumentException
format: @"%@ %p with invalid key", NSStringFromSelector(_cmd), self];
}
if ([propertyKey hasPrefix: @"GSHTTPProperty"]
|| [propertyKey hasPrefix: @"GSTLS"]
|| [propertyKey hasPrefix: @"NSHTTPProperty"])
{
if (property == nil)
{
[request removeObjectForKey: propertyKey];
}
else
{
[request setObject: property forKey: propertyKey];
}
}
else
{
if (property == nil)
{
NSMapRemove(wProperties, (void*)propertyKey);
}
else
{
NSMapInsert(wProperties, (void*)propertyKey, (void*)property);
}
}
return YES;
}
@end
Reference in a new issue View git blame Copy permalink