#import "GCDAsyncSocket.h"
#import "HTTPServer.h"
#import "HTTPConnection.h"
#import "HTTPMessage.h"
#import "HTTPResponse.h"
#import "HTTPAuthenticationRequest.h"
#import "DDNumber.h"
#import "DDRange.h"
#import "DDData.h"
#import "HTTPFileResponse.h"
#import "HTTPAsyncFileResponse.h"
#import "WebSocket.h"
#import "HTTPLogging.h"

#if ! __has_feature(objc_arc)
#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
#endif

// Does ARC support support GCD objects?
// It does if the minimum deployment target is iOS 6+ or Mac OS X 8+

#if TARGET_OS_IPHONE

  // Compiling for iOS

  #if __IPHONE_OS_VERSION_MIN_REQUIRED >= 60000 // iOS 6.0 or later
    #define NEEDS_DISPATCH_RETAIN_RELEASE 0
  #else                                         // iOS 5.X or earlier
    #define NEEDS_DISPATCH_RETAIN_RELEASE 1
  #endif

#else

  // Compiling for Mac OS X

  #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1080     // Mac OS X 10.8 or later
    #define NEEDS_DISPATCH_RETAIN_RELEASE 0
  #else
    #define NEEDS_DISPATCH_RETAIN_RELEASE 1     // Mac OS X 10.7 or earlier
  #endif

#endif

// Log levels: off, error, warn, info, verbose
// Other flags: trace
static const DDLogLevel httpLogLevel = DDLogLevelWarning; // | HTTP_LOG_FLAG_TRACE;

// Define chunk size used to read in data for responses
// This is how much data will be read from disk into RAM at a time
#if TARGET_OS_IPHONE
  #define READ_CHUNKSIZE  (1024 * /*128*/256)
#else
  #define READ_CHUNKSIZE  (1024 * 512)
#endif

// Define chunk size used to read in POST upload data
#if TARGET_OS_IPHONE
  #define POST_CHUNKSIZE  (1024 * /*32*/256)
#else
  #define POST_CHUNKSIZE  (1024 * /*128*/512)
#endif

// Define the various timeouts (in seconds) for various parts of the HTTP process
#define TIMEOUT_READ_FIRST_HEADER_LINE       30
#define TIMEOUT_READ_SUBSEQUENT_HEADER_LINE  30
#define TIMEOUT_READ_BODY                    -1
#define TIMEOUT_WRITE_HEAD                   30
#define TIMEOUT_WRITE_BODY                   -1
#define TIMEOUT_WRITE_ERROR                  30
#define TIMEOUT_NONCE                       300

// Define the various limits
// MAX_HEADER_LINE_LENGTH: Max length (in bytes) of any single line in a header (including \r\n)
// MAX_HEADER_LINES      : Max number of lines in a single header (including first GET line)
#define MAX_HEADER_LINE_LENGTH  8190
#define MAX_HEADER_LINES         100
// MAX_CHUNK_LINE_LENGTH : For accepting chunked transfer uploads, max length of chunk size line (including \r\n)
#define MAX_CHUNK_LINE_LENGTH    200

// Define the various tags we'll use to differentiate what it is we're currently doing
#define HTTP_REQUEST_HEADER                10
#define HTTP_REQUEST_BODY                  11
#define HTTP_REQUEST_CHUNK_SIZE            12
#define HTTP_REQUEST_CHUNK_DATA            13
#define HTTP_REQUEST_CHUNK_TRAILER         14
#define HTTP_REQUEST_CHUNK_FOOTER          15
#define HTTP_PARTIAL_RESPONSE              20
#define HTTP_PARTIAL_RESPONSE_HEADER       21
#define HTTP_PARTIAL_RESPONSE_BODY         22
#define HTTP_CHUNKED_RESPONSE_HEADER       30
#define HTTP_CHUNKED_RESPONSE_BODY         31
#define HTTP_CHUNKED_RESPONSE_FOOTER       32
#define HTTP_PARTIAL_RANGE_RESPONSE_BODY   40
#define HTTP_PARTIAL_RANGES_RESPONSE_BODY  50
#define HTTP_RESPONSE                      90
#define HTTP_FINAL_RESPONSE                91

// A quick note about the tags:
// 
// The HTTP_RESPONSE and HTTP_FINAL_RESPONSE are designated tags signalling that the response is completely sent.
// That is, in the onSocket:didWriteDataWithTag: method, if the tag is HTTP_RESPONSE or HTTP_FINAL_RESPONSE,
// it is assumed that the response is now completely sent.
// Use HTTP_RESPONSE if it's the end of a response, and you want to start reading more requests afterwards.
// Use HTTP_FINAL_RESPONSE if you wish to terminate the connection after sending the response.
// 
// If you are sending multiple data segments in a custom response, make sure that only the last segment has
// the HTTP_RESPONSE tag. For all other segments prior to the last segment use HTTP_PARTIAL_RESPONSE, or some other
// tag of your own invention.

@interface HTTPConnection (PrivateAPI)
- (void)startReadingRequest;
- (void)sendResponseHeadersAndBody;
@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark -
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@implementation HTTPConnection

static dispatch_queue_t recentNonceQueue;
static NSMutableArray *recentNonces;

/**
 * This method is automatically called (courtesy of Cocoa) before the first instantiation of this class.
 * We use it to initialize any static variables.
**/
+ (void)initialize
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
        // Initialize class variables
        recentNonceQueue = dispatch_queue_create("HTTPConnection-Nonce", NULL);
        recentNonces = [[NSMutableArray alloc] initWithCapacity:5];
    });
}

/**
 * Generates and returns an authentication nonce.
 * A nonce is a  server-specified string uniquely generated for each 401 response.
 * The default implementation uses a single nonce for each session.
**/
+ (NSString *)generateNonce
{
    // We use the Core Foundation UUID class to generate a nonce value for us
    // UUIDs (Universally Unique Identifiers) are 128-bit values guaranteed to be unique.
    CFUUIDRef theUUID = CFUUIDCreate(NULL);
    NSString *newNonce = (__bridge_transfer NSString *)CFUUIDCreateString(NULL, theUUID);
    CFRelease(theUUID);
    
    // We have to remember that the HTTP protocol is stateless.
    // Even though with version 1.1 persistent connections are the norm, they are not guaranteed.
    // Thus if we generate a nonce for this connection,
    // it should be honored for other connections in the near future.
    // 
    // In fact, this is absolutely necessary in order to support QuickTime.
    // When QuickTime makes it's initial connection, it will be unauthorized, and will receive a nonce.
    // It then disconnects, and creates a new connection with the nonce, and proper authentication.
    // If we don't honor the nonce for the second connection, QuickTime will repeat the process and never connect.
    
    dispatch_async(recentNonceQueue, ^{ @autoreleasepool {
        
        [recentNonces addObject:newNonce];
    }});
    
    double delayInSeconds = TIMEOUT_NONCE;
    dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
    dispatch_after(popTime, recentNonceQueue, ^{ @autoreleasepool {
        
        [recentNonces removeObject:newNonce];
    }});
    
    return newNonce;
}

/**
 * Returns whether or not the given nonce is in the list of recently generated nonce's.
**/
+ (BOOL)hasRecentNonce:(NSString *)recentNonce
{
    __block BOOL result = NO;
    
    dispatch_sync(recentNonceQueue, ^{ @autoreleasepool {
        
        result = [recentNonces containsObject:recentNonce];
    }});
    
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Init, Dealloc:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Sole Constructor.
 * Associates this new HTTP connection with the given AsyncSocket.
 * This HTTP connection object will become the socket's delegate and take over responsibility for the socket.
**/
- (id)initWithAsyncSocket:(GCDAsyncSocket *)newSocket configuration:(HTTPConfig *)aConfig
{
    if ((self = [super init]))
    {
        HTTPLogTrace();
        
        if (aConfig.queue)
        {
            connectionQueue = aConfig.queue;
            #if NEEDS_DISPATCH_RETAIN_RELEASE
            dispatch_retain(connectionQueue);
            #endif
        }
        else
        {
            connectionQueue = dispatch_queue_create("HTTPConnection", NULL);
        }
        
        // Take over ownership of the socket
        asyncSocket = newSocket;
        [asyncSocket setDelegate:self delegateQueue:connectionQueue];
        
        // Store configuration
        config = aConfig;
        
        // Initialize lastNC (last nonce count).
        // Used with digest access authentication.
        // These must increment for each request from the client.
        lastNC = 0;
        
        // Create a new HTTP message
        request = [[HTTPMessage alloc] initEmptyRequest];
        
        numHeaderLines = 0;
        
        responseDataSizes = [[NSMutableArray alloc] initWithCapacity:5];
    }
    return self;
}

/**
 * Standard Deconstructor.
**/
- (void)dealloc
{
    HTTPLogTrace();
    
    #if NEEDS_DISPATCH_RETAIN_RELEASE
    dispatch_release(connectionQueue);
    #endif
    
    [asyncSocket setDelegate:nil delegateQueue:NULL];
    [asyncSocket disconnect];
    
    if ([httpResponse respondsToSelector:@selector(connectionDidClose)])
    {
        [httpResponse connectionDidClose];
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Method Support
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Returns whether or not the server will accept messages of a given method
 * at a particular URI.
**/
- (BOOL)supportsMethod:(NSString *)method atPath:(NSString *)path
{
    HTTPLogTrace();
    
    // Override me to support methods such as POST.
    // 
    // Things you may want to consider:
    // - Does the given path represent a resource that is designed to accept this method?
    // - If accepting an upload, is the size of the data being uploaded too big?
    //   To do this you can check the requestContentLength variable.
    // 
    // For more information, you can always access the HTTPMessage request variable.
    // 
    // You should fall through with a call to [super supportsMethod:method atPath:path]
    // 
    // See also: expectsRequestBodyFromMethod:atPath:
    
    if ([method isEqualToString:@"GET"])
        return YES;
    
    if ([method isEqualToString:@"HEAD"])
        return YES;
        
    return NO;
}

/**
 * Returns whether or not the server expects a body from the given method.
 * 
 * In other words, should the server expect a content-length header and associated body from this method.
 * This would be true in the case of a POST, where the client is sending data,
 * or for something like PUT where the client is supposed to be uploading a file.
**/
- (BOOL)expectsRequestBodyFromMethod:(NSString *)method atPath:(NSString *)path
{
    HTTPLogTrace();
    
    // Override me to add support for other methods that expect the client
    // to send a body along with the request header.
    // 
    // You should fall through with a call to [super expectsRequestBodyFromMethod:method atPath:path]
    // 
    // See also: supportsMethod:atPath:
    
    if ([method isEqualToString:@"POST"])
        return YES;
    
    if ([method isEqualToString:@"PUT"])
        return YES;
    
    return NO;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark HTTPS
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Returns whether or not the server is configured to be a secure server.
 * In other words, all connections to this server are immediately secured, thus only secure connections are allowed.
 * This is the equivalent of having an https server, where it is assumed that all connections must be secure.
 * If this is the case, then unsecure connections will not be allowed on this server, and a separate unsecure server
 * would need to be run on a separate port in order to support unsecure connections.
 * 
 * Note: In order to support secure connections, the sslIdentityAndCertificates method must be implemented.
**/
- (BOOL)isSecureServer
{
    HTTPLogTrace();
    
    // Override me to create an https server...
    
    return NO;
}

/**
 * This method is expected to returns an array appropriate for use in kCFStreamSSLCertificates SSL Settings.
 * It should be an array of SecCertificateRefs except for the first element in the array, which is a SecIdentityRef.
**/
- (NSArray *)sslIdentityAndCertificates
{
    HTTPLogTrace();
    
    // Override me to provide the proper required SSL identity.
    
    return nil;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Password Protection
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Returns whether or not the requested resource is password protected.
 * In this generic implementation, nothing is password protected.
**/
- (BOOL)isPasswordProtected:(NSString *)path
{
    HTTPLogTrace();
    
    // Override me to provide password protection...
    // You can configure it for the entire server, or based on the current request
    
    return NO;
}

/**
 * Returns whether or not the authentication challenge should use digest access authentication.
 * The alternative is basic authentication.
 * 
 * If at all possible, digest access authentication should be used because it's more secure.
 * Basic authentication sends passwords in the clear and should be avoided unless using SSL/TLS.
**/
- (BOOL)useDigestAccessAuthentication
{
    HTTPLogTrace();
    
    // Override me to customize the authentication scheme
    // Make sure you understand the security risks of using the weaker basic authentication
    
    return YES;
}

/**
 * Returns the authentication realm.
 * In this generic implmentation, a default realm is used for the entire server.
**/
- (NSString *)realm
{
    HTTPLogTrace();
    
    // Override me to provide a custom realm...
    // You can configure it for the entire server, or based on the current request
    
    return @"defaultRealm@host.com";
}

/**
 * Returns the password for the given username.
**/
- (NSString *)passwordForUser:(NSString *)username
{
    HTTPLogTrace();
    
    // Override me to provide proper password authentication
    // You can configure a password for the entire server, or custom passwords for users and/or resources
    
    // Security Note:
    // A nil password means no access at all. (Such as for user doesn't exist)
    // An empty string password is allowed, and will be treated as any other password. (To support anonymous access)
    
    return nil;
}

/**
 * Returns whether or not the user is properly authenticated.
**/
- (BOOL)isAuthenticated
{
    HTTPLogTrace();
    
    // Extract the authentication information from the Authorization header
    HTTPAuthenticationRequest *auth = [[HTTPAuthenticationRequest alloc] initWithRequest:request];
    
    if ([self useDigestAccessAuthentication])
    {
        // Digest Access Authentication (RFC 2617)
        
        if(![auth isDigest])
        {
            // User didn't send proper digest access authentication credentials
            return NO;
        }
        
        if ([auth username] == nil)
        {
            // The client didn't provide a username
            // Most likely they didn't provide any authentication at all
            return NO;
        }
        
        NSString *password = [self passwordForUser:[auth username]];
        if (password == nil)
        {
            // No access allowed (username doesn't exist in system)
            return NO;
        }
        
        NSString *url = [[request url] relativeString];
        
        if (![url isEqualToString:[auth uri]])
        {
            // Requested URL and Authorization URI do not match
            // This could be a replay attack
            // IE - attacker provides same authentication information, but requests a different resource
            return NO;
        }
        
        // The nonce the client provided will most commonly be stored in our local (cached) nonce variable
        if (![nonce isEqualToString:[auth nonce]])
        {
            // The given nonce may be from another connection
            // We need to search our list of recent nonce strings that have been recently distributed
            if ([[self class] hasRecentNonce:[auth nonce]])
            {
                // Store nonce in local (cached) nonce variable to prevent array searches in the future
                nonce = [[auth nonce] copy];
                
                // The client has switched to using a different nonce value
                // This may happen if the client tries to get a file in a directory with different credentials.
                // The previous credentials wouldn't work, and the client would receive a 401 error
                // along with a new nonce value. The client then uses this new nonce value and requests the file again.
                // Whatever the case may be, we need to reset lastNC, since that variable is on a per nonce basis.
                lastNC = 0;
            }
            else
            {
                // We have no knowledge of ever distributing such a nonce.
                // This could be a replay attack from a previous connection in the past.
                return NO;
            }
        }
        
        long authNC = strtol([[auth nc] UTF8String], NULL, 16);
        
        if (authNC <= lastNC)
        {
            // The nc value (nonce count) hasn't been incremented since the last request.
            // This could be a replay attack.
            return NO;
        }
        lastNC = authNC;
        
        NSString *HA1str = [NSString stringWithFormat:@"%@:%@:%@", [auth username], [auth realm], password];
        NSString *HA2str = [NSString stringWithFormat:@"%@:%@", [request method], [auth uri]];
        
        NSString *HA1 = [[[HA1str dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
        
        NSString *HA2 = [[[HA2str dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
        
        NSString *responseStr = [NSString stringWithFormat:@"%@:%@:%@:%@:%@:%@",
                                 HA1, [auth nonce], [auth nc], [auth cnonce], [auth qop], HA2];
        
        NSString *response = [[[responseStr dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
        
        return [response isEqualToString:[auth response]];
    }
    else
    {
        // Basic Authentication
        
        if (![auth isBasic])
        {
            // User didn't send proper base authentication credentials
            return NO;
        }
        
        // Decode the base 64 encoded credentials
        NSString *base64Credentials = [auth base64Credentials];
        
        NSData *temp = [[base64Credentials dataUsingEncoding:NSUTF8StringEncoding] base64Decoded];
        
        NSString *credentials = [[NSString alloc] initWithData:temp encoding:NSUTF8StringEncoding];
        
        // The credentials should be of the form "username:password"
        // The username is not allowed to contain a colon
        
        NSRange colonRange = [credentials rangeOfString:@":"];
        
        if (colonRange.length == 0)
        {
            // Malformed credentials
            return NO;
        }
        
        NSString *credUsername = [credentials substringToIndex:colonRange.location];
        NSString *credPassword = [credentials substringFromIndex:(colonRange.location + colonRange.length)];
        
        NSString *password = [self passwordForUser:credUsername];
        if (password == nil)
        {
            // No access allowed (username doesn't exist in system)
            return NO;
        }
        
        return [password isEqualToString:credPassword];
    }
}

/**
 * Adds a digest access authentication challenge to the given response.
**/
- (void)addDigestAuthChallenge:(HTTPMessage *)response
{
    HTTPLogTrace();
    
    NSString *authFormat = @"Digest realm=\"%@\", qop=\"auth\", nonce=\"%@\"";
    NSString *authInfo = [NSString stringWithFormat:authFormat, [self realm], [[self class] generateNonce]];
    
    [response setHeaderField:@"WWW-Authenticate" value:authInfo];
}

/**
 * Adds a basic authentication challenge to the given response.
**/
- (void)addBasicAuthChallenge:(HTTPMessage *)response
{
    HTTPLogTrace();
    
    NSString *authFormat = @"Basic realm=\"%@\"";
    NSString *authInfo = [NSString stringWithFormat:authFormat, [self realm]];
    
    [response setHeaderField:@"WWW-Authenticate" value:authInfo];
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Core
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Starting point for the HTTP connection after it has been fully initialized (including subclasses).
 * This method is called by the HTTP server.
**/
- (void)start
{
    dispatch_async(connectionQueue, ^{ @autoreleasepool {
        
        if (!started)
        {
            started = YES;
            [self startConnection];
        }
    }});
}

/**
 * This method is called by the HTTPServer if it is asked to stop.
 * The server, in turn, invokes stop on each HTTPConnection instance.
**/
- (void)stop
{
    dispatch_async(connectionQueue, ^{ @autoreleasepool {
        
        // Disconnect the socket.
        // The socketDidDisconnect delegate method will handle everything else.
        [asyncSocket disconnect];
    }});
}

/**
 * Starting point for the HTTP connection.
**/
- (void)startConnection
{
    // Override me to do any custom work before the connection starts.
    // 
    // Be sure to invoke [super startConnection] when you're done.
    
    HTTPLogTrace();
    
    if ([self isSecureServer])
    {
        // We are configured to be an HTTPS server.
        // That is, we secure via SSL/TLS the connection prior to any communication.
        
        NSArray *certificates = [self sslIdentityAndCertificates];
        
        if ([certificates count] > 0)
        {
            // All connections are assumed to be secure. Only secure connections are allowed on this server.
            NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithCapacity:3];
            
            // Configure this connection as the server
            [settings setObject:[NSNumber numberWithBool:YES]
                         forKey:(NSString *)kCFStreamSSLIsServer];
            
            [settings setObject:certificates
                         forKey:(NSString *)kCFStreamSSLCertificates];
            
            // Configure this connection to use the highest possible SSL level
            [settings setObject:(NSString *)kCFStreamSocketSecurityLevelNegotiatedSSL
                         forKey:(NSString *)kCFStreamSSLLevel];
            
            [asyncSocket startTLS:settings];
        }
    }
    
    [self startReadingRequest];
}

/**
 * Starts reading an HTTP request.
**/
- (void)startReadingRequest
{
    HTTPLogTrace();
    
    [asyncSocket readDataToData:[GCDAsyncSocket CRLFData]
                    withTimeout:TIMEOUT_READ_FIRST_HEADER_LINE
                      maxLength:MAX_HEADER_LINE_LENGTH
                            tag:HTTP_REQUEST_HEADER];
}

/**
 * Parses the given query string.
 * 
 * For example, if the query is "q=John%20Mayer%20Trio&num=50"
 * then this method would return the following dictionary:
 * { 
 *   q = "John Mayer Trio" 
 *   num = "50" 
 * }
**/
- (NSDictionary *)parseParams:(NSString *)query
{
    NSArray *components = [query componentsSeparatedByString:@"&"];
    NSMutableDictionary *result = [NSMutableDictionary dictionaryWithCapacity:[components count]];
    
    NSUInteger i;
    for (i = 0; i < [components count]; i++)
    { 
        NSString *component = [components objectAtIndex:i];
        if ([component length] > 0)
        {
            NSRange range = [component rangeOfString:@"="];
            if (range.location != NSNotFound)
            { 
                NSString *escapedKey = [component substringToIndex:(range.location + 0)]; 
                NSString *escapedValue = [component substringFromIndex:(range.location + 1)];
                
                if ([escapedKey length] > 0)
                {
                    CFStringRef k, v;
                    
                    k = CFURLCreateStringByReplacingPercentEscapes(NULL, (__bridge CFStringRef)escapedKey, CFSTR(""));
                    v = CFURLCreateStringByReplacingPercentEscapes(NULL, (__bridge CFStringRef)escapedValue, CFSTR(""));
                    
                    NSString *key, *value;
                    
                    key   = (__bridge_transfer NSString *)k;
                    value = (__bridge_transfer NSString *)v;
                    
                    if (key)
                    {
                        if (value)
                            [result setObject:value forKey:key]; 
                        else 
                            [result setObject:[NSNull null] forKey:key]; 
                    }
                }
            }
        }
    }
    
    return result;
}

/** 
 * Parses the query variables in the request URI. 
 * 
 * For example, if the request URI was "/search.html?q=John%20Mayer%20Trio&num=50" 
 * then this method would return the following dictionary: 
 * { 
 *   q = "John Mayer Trio" 
 *   num = "50" 
 * } 
**/ 
- (NSDictionary *)parseGetParams 
{
    if(![request isHeaderComplete]) return nil;
    
    NSDictionary *result = nil;
    
    NSURL *url = [request url];
    if(url)
    {
        NSString *query = [url query];
        if (query)
        {
            result = [self parseParams:query];
        }
    }
    
    return result; 
}

/**
 * Attempts to parse the given range header into a series of sequential non-overlapping ranges.
 * If successfull, the variables 'ranges' and 'rangeIndex' will be updated, and YES will be returned.
 * Otherwise, NO is returned, and the range request should be ignored.
 **/
- (BOOL)parseRangeRequest:(NSString *)rangeHeader withContentLength:(UInt64)contentLength
{
    HTTPLogTrace();
    
    // Examples of byte-ranges-specifier values (assuming an entity-body of length 10000):
    // 
    // - The first 500 bytes (byte offsets 0-499, inclusive):  bytes=0-499
    // 
    // - The second 500 bytes (byte offsets 500-999, inclusive): bytes=500-999
    // 
    // - The final 500 bytes (byte offsets 9500-9999, inclusive): bytes=-500
    // 
    // - Or bytes=9500-
    // 
    // - The first and last bytes only (bytes 0 and 9999):  bytes=0-0,-1
    // 
    // - Several legal but not canonical specifications of the second 500 bytes (byte offsets 500-999, inclusive):
    // bytes=500-600,601-999
    // bytes=500-700,601-999
    // 
    
    NSRange eqsignRange = [rangeHeader rangeOfString:@"="];
    
    if(eqsignRange.location == NSNotFound) return NO;
    
    NSUInteger tIndex = eqsignRange.location;
    NSUInteger fIndex = eqsignRange.location + eqsignRange.length;
    
    NSMutableString *rangeType  = [[rangeHeader substringToIndex:tIndex] mutableCopy];
    NSMutableString *rangeValue = [[rangeHeader substringFromIndex:fIndex] mutableCopy];
    
    CFStringTrimWhitespace((__bridge CFMutableStringRef)rangeType);
    CFStringTrimWhitespace((__bridge CFMutableStringRef)rangeValue);
    
    if([rangeType caseInsensitiveCompare:@"bytes"] != NSOrderedSame) return NO;
    
    NSArray *rangeComponents = [rangeValue componentsSeparatedByString:@","];
    
    if([rangeComponents count] == 0) return NO;
    
    ranges = [[NSMutableArray alloc] initWithCapacity:[rangeComponents count]];
    
    rangeIndex = 0;
    
    // Note: We store all range values in the form of DDRange structs, wrapped in NSValue objects.
    // Since DDRange consists of UInt64 values, the range extends up to 16 exabytes.
    
    NSUInteger i;
    for (i = 0; i < [rangeComponents count]; i++)
    {
        NSString *rangeComponent = [rangeComponents objectAtIndex:i];
        
        NSRange dashRange = [rangeComponent rangeOfString:@"-"];
        
        if (dashRange.location == NSNotFound)
        {
            // We're dealing with an individual byte number
            
            UInt64 byteIndex;
            if(![NSNumber parseString:rangeComponent intoUInt64:&byteIndex]) return NO;
            
            if(byteIndex >= contentLength) return NO;
            
            [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(byteIndex, 1)]];
        }
        else
        {
            // We're dealing with a range of bytes
            
            tIndex = dashRange.location;
            fIndex = dashRange.location + dashRange.length;
            
            NSString *r1str = [rangeComponent substringToIndex:tIndex];
            NSString *r2str = [rangeComponent substringFromIndex:fIndex];
            
            UInt64 r1, r2;
            
            BOOL hasR1 = [NSNumber parseString:r1str intoUInt64:&r1];
            BOOL hasR2 = [NSNumber parseString:r2str intoUInt64:&r2];
            
            if (!hasR1)
            {
                // We're dealing with a "-[#]" range
                // 
                // r2 is the number of ending bytes to include in the range
                
                if(!hasR2) return NO;
                if(r2 > contentLength) return NO;
                
                UInt64 startIndex = contentLength - r2;
                
                [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(startIndex, r2)]];
            }
            else if (!hasR2)
            {
                // We're dealing with a "[#]-" range
                // 
                // r1 is the starting index of the range, which goes all the way to the end
                
                if(r1 >= contentLength) return NO;
                
                [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(r1, contentLength - r1)]];
            }
            else
            {
                // We're dealing with a normal "[#]-[#]" range
                // 
                // Note: The range is inclusive. So 0-1 has a length of 2 bytes.
                
                if(r1 > r2) return NO;
                if(r2 >= contentLength) return NO;
                
                [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(r1, r2 - r1 + 1)]];
            }
        }
    }
    
    if([ranges count] == 0) return NO;
    
    // Now make sure none of the ranges overlap
    
    for (i = 0; i < [ranges count] - 1; i++)
    {
        DDRange range1 = [[ranges objectAtIndex:i] ddrangeValue];
        
        NSUInteger j;
        for (j = i+1; j < [ranges count]; j++)
        {
            DDRange range2 = [[ranges objectAtIndex:j] ddrangeValue];
            
            DDRange iRange = DDIntersectionRange(range1, range2);
            
            if(iRange.length != 0)
            {
                return NO;
            }
        }
    }
    
    // Sort the ranges
    
    [ranges sortUsingSelector:@selector(ddrangeCompare:)];
    
    return YES;
}

- (NSString *)requestURI
{
    if(request == nil) return nil;
    
    return [[request url] relativeString];
}

/**
 * This method is called after a full HTTP request has been received.
 * The current request is in the HTTPMessage request variable.
**/
- (void)replyToHTTPRequest
{
    HTTPLogTrace();
    
    if (httpLogLevel & DDLogFlagVerbose)
    {
        NSData *tempData = [request messageData];
        
        NSString *tempStr = [[NSString alloc] initWithData:tempData encoding:NSUTF8StringEncoding];
        HTTPLogVerbose(@"%@[%p]: Received HTTP request:\n%@", THIS_FILE, self, tempStr);
    }
    
    // Check the HTTP version
    // We only support version 1.0 and 1.1
    
    NSString *version = [request version];
    if (![version isEqualToString:HTTPVersion1_1] && ![version isEqualToString:HTTPVersion1_0])
    {
        [self handleVersionNotSupported:version];
        return;
    }
    
    // Extract requested URI
    NSString *uri = [self requestURI];
    
    // Check for WebSocket request
    if ([WebSocket isWebSocketRequest:request])
    {
        HTTPLogVerbose(@"isWebSocket");
        
        WebSocket *ws = [self webSocketForURI:uri];
        
        if (ws == nil)
        {
            [self handleResourceNotFound];
        }
        else
        {
            [ws start];
            
            [[config server] addWebSocket:ws];
            
            // The WebSocket should now be the delegate of the underlying socket.
            // But gracefully handle the situation if it forgot.
            if ([asyncSocket delegate] == self)
            {
                HTTPLogWarn(@"%@[%p]: WebSocket forgot to set itself as socket delegate", THIS_FILE, self);
                
                // Disconnect the socket.
                // The socketDidDisconnect delegate method will handle everything else.
                [asyncSocket disconnect];
            }
            else
            {
                // The WebSocket is using the socket,
                // so make sure we don't disconnect it in the dealloc method.
                asyncSocket = nil;
                
                [self die];
                
                // Note: There is a timing issue here that should be pointed out.
                // 
                // A bug that existed in previous versions happend like so:
                // - We invoked [self die]
                // - This caused us to get released, and our dealloc method to start executing
                // - Meanwhile, AsyncSocket noticed a disconnect, and began to dispatch a socketDidDisconnect at us
                // - The dealloc method finishes execution, and our instance gets freed
                // - The socketDidDisconnect gets run, and a crash occurs
                // 
                // So the issue we want to avoid is releasing ourself when there is a possibility
                // that AsyncSocket might be gearing up to queue a socketDidDisconnect for us.
                // 
                // In this particular situation notice that we invoke [asyncSocket delegate].
                // This method is synchronous concerning AsyncSocket's internal socketQueue.
                // Which means we can be sure, when it returns, that AsyncSocket has already
                // queued any delegate methods for us if it was going to.
                // And if the delegate methods are queued, then we've been properly retained.
                // Meaning we won't get released / dealloc'd until the delegate method has finished executing.
                // 
                // In this rare situation, the die method will get invoked twice.
            }
        }
        
        return;
    }
    
    // Check Authentication (if needed)
    // If not properly authenticated for resource, issue Unauthorized response
    if ([self isPasswordProtected:uri] && ![self isAuthenticated])
    {
        [self handleAuthenticationFailed];
        return;
    }
    
    // Extract the method
    NSString *method = [request method];
    
    // Note: We already checked to ensure the method was supported in onSocket:didReadData:withTag:
    
    // Respond properly to HTTP 'GET' and 'HEAD' commands
    httpResponse = [self httpResponseForMethod:method URI:uri];
    
    if (httpResponse == nil)
    {
        [self handleResourceNotFound];
        return;
    }
    
    [self sendResponseHeadersAndBody];
}

/**
 * Prepares a single-range response.
 * 
 * Note: The returned HTTPMessage is owned by the sender, who is responsible for releasing it.
**/
- (HTTPMessage *)newUniRangeResponse:(UInt64)contentLength
{
    HTTPLogTrace();
    
    // Status Code 206 - Partial Content
    HTTPMessage *response = [[HTTPMessage alloc] initResponseWithStatusCode:206 description:nil version:HTTPVersion1_1];
    
    DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
    
    NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", range.length];
    [response setHeaderField:@"Content-Length" value:contentLengthStr];
    
    NSString *rangeStr = [NSString stringWithFormat:@"%qu-%qu", range.location, DDMaxRange(range) - 1];
    NSString *contentRangeStr = [NSString stringWithFormat:@"bytes %@/%qu", rangeStr, contentLength];
    [response setHeaderField:@"Content-Range" value:contentRangeStr];
    
    return response;
}

/**
 * Prepares a multi-range response.
 * 
 * Note: The returned HTTPMessage is owned by the sender, who is responsible for releasing it.
**/
- (HTTPMessage *)newMultiRangeResponse:(UInt64)contentLength
{
    HTTPLogTrace();
    
    // Status Code 206 - Partial Content
    HTTPMessage *response = [[HTTPMessage alloc] initResponseWithStatusCode:206 description:nil version:HTTPVersion1_1];
    
    // We have to send each range using multipart/byteranges
    // So each byterange has to be prefix'd and suffix'd with the boundry
    // Example:
    // 
    // HTTP/1.1 206 Partial Content
    // Content-Length: 220
    // Content-Type: multipart/byteranges; boundary=4554d24e986f76dd6
    // 
    // 
    // --4554d24e986f76dd6
    // Content-Range: bytes 0-25/4025
    // 
    // [...]
    // --4554d24e986f76dd6
    // Content-Range: bytes 3975-4024/4025
    // 
    // [...]
    // --4554d24e986f76dd6--
    
    ranges_headers = [[NSMutableArray alloc] initWithCapacity:[ranges count]];
    
    CFUUIDRef theUUID = CFUUIDCreate(NULL);
    ranges_boundry = (__bridge_transfer NSString *)CFUUIDCreateString(NULL, theUUID);
    CFRelease(theUUID);
    
    NSString *startingBoundryStr = [NSString stringWithFormat:@"\r\n--%@\r\n", ranges_boundry];
    NSString *endingBoundryStr = [NSString stringWithFormat:@"\r\n--%@--\r\n", ranges_boundry];
    
    UInt64 actualContentLength = 0;
    
    NSUInteger i;
    for (i = 0; i < [ranges count]; i++)
    {
        DDRange range = [[ranges objectAtIndex:i] ddrangeValue];
        
        NSString *rangeStr = [NSString stringWithFormat:@"%qu-%qu", range.location, DDMaxRange(range) - 1];
        NSString *contentRangeVal = [NSString stringWithFormat:@"bytes %@/%qu", rangeStr, contentLength];
        NSString *contentRangeStr = [NSString stringWithFormat:@"Content-Range: %@\r\n\r\n", contentRangeVal];
        
        NSString *fullHeader = [startingBoundryStr stringByAppendingString:contentRangeStr];
        NSData *fullHeaderData = [fullHeader dataUsingEncoding:NSUTF8StringEncoding];
        
        [ranges_headers addObject:fullHeaderData];
        
        actualContentLength += [fullHeaderData length];
        actualContentLength += range.length;
    }
    
    NSData *endingBoundryData = [endingBoundryStr dataUsingEncoding:NSUTF8StringEncoding];
    
    actualContentLength += [endingBoundryData length];
    
    NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", actualContentLength];
    [response setHeaderField:@"Content-Length" value:contentLengthStr];
    
    NSString *contentTypeStr = [NSString stringWithFormat:@"multipart/byteranges; boundary=%@", ranges_boundry];
    [response setHeaderField:@"Content-Type" value:contentTypeStr];
    
    return response;
}

/**
 * Returns the chunk size line that must precede each chunk of data when using chunked transfer encoding.
 * This consists of the size of the data, in hexadecimal, followed by a CRLF.
**/
- (NSData *)chunkedTransferSizeLineForLength:(NSUInteger)length
{
    return [[NSString stringWithFormat:@"%lx\r\n", (unsigned long)length] dataUsingEncoding:NSUTF8StringEncoding];
}

/**
 * Returns the data that signals the end of a chunked transfer.
**/
- (NSData *)chunkedTransferFooter
{
    // Each data chunk is preceded by a size line (in hex and including a CRLF),
    // followed by the data itself, followed by another CRLF.
    // After every data chunk has been sent, a zero size line is sent,
    // followed by optional footer (which are just more headers),
    // and followed by a CRLF on a line by itself.
    
    return [@"\r\n0\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding];
}

- (void)sendResponseHeadersAndBody
{
    if ([httpResponse respondsToSelector:@selector(delayResponseHeaders)])
    {
        if ([httpResponse delayResponseHeaders])
        {
            return;
        }
    }
    
    BOOL isChunked = NO;
    
    if ([httpResponse respondsToSelector:@selector(isChunked)])
    {
        isChunked = [httpResponse isChunked];
    }
    
    // If a response is "chunked", this simply means the HTTPResponse object
    // doesn't know the content-length in advance.
    
    UInt64 contentLength = 0;
    
    if (!isChunked)
    {
        contentLength = [httpResponse contentLength];
    }
    
    // Check for specific range request
    NSString *rangeHeader = [request headerField:@"Range"];
    
    BOOL isRangeRequest = NO;
    
    // If the response is "chunked" then we don't know the exact content-length.
    // This means we'll be unable to process any range requests.
    // This is because range requests might include a range like "give me the last 100 bytes"
    
    if (!isChunked && rangeHeader)
    {
        if ([self parseRangeRequest:rangeHeader withContentLength:contentLength])
        {
            isRangeRequest = YES;
        }
    }
    
    HTTPMessage *response;
    
    if (!isRangeRequest)
    {
        // Create response
        // Default status code: 200 - OK
        NSInteger status = 200;
        
        if ([httpResponse respondsToSelector:@selector(status)])
        {
            status = [httpResponse status];
        }
        response = [[HTTPMessage alloc] initResponseWithStatusCode:status description:nil version:HTTPVersion1_1];
        
        if (isChunked)
        {
            [response setHeaderField:@"Transfer-Encoding" value:@"chunked"];
        }
        else
        {
            NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", contentLength];
            [response setHeaderField:@"Content-Length" value:contentLengthStr];
        }
    }
    else
    {
        if ([ranges count] == 1)
        {
            response = [self newUniRangeResponse:contentLength];
        }
        else
        {
            response = [self newMultiRangeResponse:contentLength];
        }
    }
    
    BOOL isZeroLengthResponse = !isChunked && (contentLength == 0);
    
    // If they issue a 'HEAD' command, we don't have to include the file
    // If they issue a 'GET' command, we need to include the file
    
    if ([[request method] isEqualToString:@"HEAD"] || isZeroLengthResponse)
    {
        NSData *responseData = [self preprocessResponse:response];
        [asyncSocket writeData:responseData withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_RESPONSE];
        
        sentResponseHeaders = YES;
    }
    else
    {
        // Write the header response
        NSData *responseData = [self preprocessResponse:response];
        [asyncSocket writeData:responseData withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_PARTIAL_RESPONSE_HEADER];
        
        sentResponseHeaders = YES;
        
        // Now we need to send the body of the response
        if (!isRangeRequest)
        {
            // Regular request
            NSData *data = [httpResponse readDataOfLength:READ_CHUNKSIZE];
            
            if ([data length] > 0)
            {
                [responseDataSizes addObject:[NSNumber numberWithUnsignedInteger:[data length]]];
                
                if (isChunked)
                {
                    NSData *chunkSize = [self chunkedTransferSizeLineForLength:[data length]];
                    [asyncSocket writeData:chunkSize withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_CHUNKED_RESPONSE_HEADER];
                    
                    [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:HTTP_CHUNKED_RESPONSE_BODY];
                    
                    if ([httpResponse isDone])
                    {
                        NSData *footer = [self chunkedTransferFooter];
                        [asyncSocket writeData:footer withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_RESPONSE];
                    }
                    else
                    {
                        NSData *footer = [GCDAsyncSocket CRLFData];
                        [asyncSocket writeData:footer withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_CHUNKED_RESPONSE_FOOTER];
                    }
                }
                else
                {
                    long tag = [httpResponse isDone] ? HTTP_RESPONSE : HTTP_PARTIAL_RESPONSE_BODY;
                    [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:tag];
                }
            }
        }
        else
        {
            // Client specified a byte range in request
            
            if ([ranges count] == 1)
            {
                // Client is requesting a single range
                DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
                
                [httpResponse setOffset:range.location];
                
                NSUInteger bytesToRead = range.length < READ_CHUNKSIZE ? (NSUInteger)range.length : READ_CHUNKSIZE;
                
                NSData *data = [httpResponse readDataOfLength:bytesToRead];
                
                if ([data length] > 0)
                {
                    [responseDataSizes addObject:[NSNumber numberWithUnsignedInteger:[data length]]];
                    
                    long tag = [data length] == range.length ? HTTP_RESPONSE : HTTP_PARTIAL_RANGE_RESPONSE_BODY;
                    [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:tag];
                }
            }
            else
            {
                // Client is requesting multiple ranges
                // We have to send each range using multipart/byteranges
                
                // Write range header
                NSData *rangeHeaderData = [ranges_headers objectAtIndex:0];
                [asyncSocket writeData:rangeHeaderData withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_PARTIAL_RESPONSE_HEADER];
                
                // Start writing range body
                DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
                
                [httpResponse setOffset:range.location];
                
                NSUInteger bytesToRead = range.length < READ_CHUNKSIZE ? (NSUInteger)range.length : READ_CHUNKSIZE;
                
                NSData *data = [httpResponse readDataOfLength:bytesToRead];
                
                if ([data length] > 0)
                {
                    [responseDataSizes addObject:[NSNumber numberWithUnsignedInteger:[data length]]];
                    
                    [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:HTTP_PARTIAL_RANGES_RESPONSE_BODY];
                }
            }
        }
    }
    
}

/**
 * Returns the number of bytes of the http response body that are sitting in asyncSocket's write queue.
 * 
 * We keep track of this information in order to keep our memory footprint low while
 * working with asynchronous HTTPResponse objects.
**/
- (NSUInteger)writeQueueSize
{
    NSUInteger result = 0;
    
    NSUInteger i;
    for(i = 0; i < [responseDataSizes count]; i++)
    {
        result += [[responseDataSizes objectAtIndex:i] unsignedIntegerValue];
    }
    
    return result;
}

/**
 * Sends more data, if needed, without growing the write queue over its approximate size limit.
 * The last chunk of the response body will be sent with a tag of HTTP_RESPONSE.
 * 
 * This method should only be called for standard (non-range) responses.
**/
- (void)continueSendingStandardResponseBody
{
    HTTPLogTrace();
    
    // This method is called when either asyncSocket has finished writing one of the response data chunks,
    // or when an asynchronous HTTPResponse object informs us that it has more available data for us to send.
    // In the case of the asynchronous HTTPResponse, we don't want to blindly grab the new data,
    // and shove it onto asyncSocket's write queue.
    // Doing so could negatively affect the memory footprint of the application.
    // Instead, we always ensure that we place no more than READ_CHUNKSIZE bytes onto the write queue.
    // 
    // Note that this does not affect the rate at which the HTTPResponse object may generate data.
    // The HTTPResponse is free to do as it pleases, and this is up to the application's developer.
    // If the memory footprint is a concern, the developer creating the custom HTTPResponse object may freely
    // use the calls to readDataOfLength as an indication to start generating more data.
    // This provides an easy way for the HTTPResponse object to throttle its data allocation in step with the rate
    // at which the socket is able to send it.
    
    NSUInteger writeQueueSize = [self writeQueueSize];
    
    if(writeQueueSize >= READ_CHUNKSIZE) return;
    
    NSUInteger available = READ_CHUNKSIZE - writeQueueSize;
    NSData *data = [httpResponse readDataOfLength:available];
    
    if ([data length] > 0)
    {
        [responseDataSizes addObject:[NSNumber numberWithUnsignedInteger:[data length]]];
        
        BOOL isChunked = NO;
        
        if ([httpResponse respondsToSelector:@selector(isChunked)])
        {
            isChunked = [httpResponse isChunked];
        }
        
        if (isChunked)
        {
            NSData *chunkSize = [self chunkedTransferSizeLineForLength:[data length]];
            [asyncSocket writeData:chunkSize withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_CHUNKED_RESPONSE_HEADER];
            
            [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:HTTP_CHUNKED_RESPONSE_BODY];
            
            if([httpResponse isDone])
            {
                NSData *footer = [self chunkedTransferFooter];
                [asyncSocket writeData:footer withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_RESPONSE];
            }
            else
            {
                NSData *footer = [GCDAsyncSocket CRLFData];
                [asyncSocket writeData:footer withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_CHUNKED_RESPONSE_FOOTER];
            }
        }
        else
        {
            long tag = [httpResponse isDone] ? HTTP_RESPONSE : HTTP_PARTIAL_RESPONSE_BODY;
            [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:tag];
        }
    }
}

/**
 * Sends more data, if needed, without growing the write queue over its approximate size limit.
 * The last chunk of the response body will be sent with a tag of HTTP_RESPONSE.
 * 
 * This method should only be called for single-range responses.
**/
- (void)continueSendingSingleRangeResponseBody
{
    HTTPLogTrace();
    
    // This method is called when either asyncSocket has finished writing one of the response data chunks,
    // or when an asynchronous response informs us that is has more available data for us to send.
    // In the case of the asynchronous response, we don't want to blindly grab the new data,
    // and shove it onto asyncSocket's write queue.
    // Doing so could negatively affect the memory footprint of the application.
    // Instead, we always ensure that we place no more than READ_CHUNKSIZE bytes onto the write queue.
    // 
    // Note that this does not affect the rate at which the HTTPResponse object may generate data.
    // The HTTPResponse is free to do as it pleases, and this is up to the application's developer.
    // If the memory footprint is a concern, the developer creating the custom HTTPResponse object may freely
    // use the calls to readDataOfLength as an indication to start generating more data.
    // This provides an easy way for the HTTPResponse object to throttle its data allocation in step with the rate
    // at which the socket is able to send it.
    
    NSUInteger writeQueueSize = [self writeQueueSize];
    
    if(writeQueueSize >= READ_CHUNKSIZE) return;
    
    DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
    
    UInt64 offset = [httpResponse offset];
    UInt64 bytesRead = offset - range.location;
    UInt64 bytesLeft = range.length - bytesRead;
    
    if (bytesLeft > 0)
    {
        NSUInteger available = READ_CHUNKSIZE - writeQueueSize;
        NSUInteger bytesToRead = bytesLeft < available ? (NSUInteger)bytesLeft : available;
        
        NSData *data = [httpResponse readDataOfLength:bytesToRead];
        
        if ([data length] > 0)
        {
            [responseDataSizes addObject:[NSNumber numberWithUnsignedInteger:[data length]]];
            
            long tag = [data length] == bytesLeft ? HTTP_RESPONSE : HTTP_PARTIAL_RANGE_RESPONSE_BODY;
            [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:tag];
        }
    }
}

/**
 * Sends more data, if needed, without growing the write queue over its approximate size limit.
 * The last chunk of the response body will be sent with a tag of HTTP_RESPONSE.
 * 
 * This method should only be called for multi-range responses.
**/
- (void)continueSendingMultiRangeResponseBody
{
    HTTPLogTrace();
    
    // This method is called when either asyncSocket has finished writing one of the response data chunks,
    // or when an asynchronous HTTPResponse object informs us that is has more available data for us to send.
    // In the case of the asynchronous HTTPResponse, we don't want to blindly grab the new data,
    // and shove it onto asyncSocket's write queue.
    // Doing so could negatively affect the memory footprint of the application.
    // Instead, we always ensure that we place no more than READ_CHUNKSIZE bytes onto the write queue.
    // 
    // Note that this does not affect the rate at which the HTTPResponse object may generate data.
    // The HTTPResponse is free to do as it pleases, and this is up to the application's developer.
    // If the memory footprint is a concern, the developer creating the custom HTTPResponse object may freely
    // use the calls to readDataOfLength as an indication to start generating more data.
    // This provides an easy way for the HTTPResponse object to throttle its data allocation in step with the rate
    // at which the socket is able to send it.
    
    NSUInteger writeQueueSize = [self writeQueueSize];
    
    if(writeQueueSize >= READ_CHUNKSIZE) return;
    
    DDRange range = [[ranges objectAtIndex:rangeIndex] ddrangeValue];
    
    UInt64 offset = [httpResponse offset];
    UInt64 bytesRead = offset - range.location;
    UInt64 bytesLeft = range.length - bytesRead;
    
    if (bytesLeft > 0)
    {
        NSUInteger available = READ_CHUNKSIZE - writeQueueSize;
        NSUInteger bytesToRead = bytesLeft < available ? (NSUInteger)bytesLeft : available;
        
        NSData *data = [httpResponse readDataOfLength:bytesToRead];
        
        if ([data length] > 0)
        {
            [responseDataSizes addObject:[NSNumber numberWithUnsignedInteger:[data length]]];
            
            [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:HTTP_PARTIAL_RANGES_RESPONSE_BODY];
        }
    }
    else
    {
        if (++rangeIndex < [ranges count])
        {
            // Write range header
            NSData *rangeHeader = [ranges_headers objectAtIndex:rangeIndex];
            [asyncSocket writeData:rangeHeader withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_PARTIAL_RESPONSE_HEADER];
            
            // Start writing range body
            range = [[ranges objectAtIndex:rangeIndex] ddrangeValue];
            
            [httpResponse setOffset:range.location];
            
            NSUInteger available = READ_CHUNKSIZE - writeQueueSize;
            NSUInteger bytesToRead = range.length < available ? (NSUInteger)range.length : available;
            
            NSData *data = [httpResponse readDataOfLength:bytesToRead];
            
            if ([data length] > 0)
            {
                [responseDataSizes addObject:[NSNumber numberWithUnsignedInteger:[data length]]];
                
                [asyncSocket writeData:data withTimeout:TIMEOUT_WRITE_BODY tag:HTTP_PARTIAL_RANGES_RESPONSE_BODY];
            }
        }
        else
        {
            // We're not done yet - we still have to send the closing boundry tag
            NSString *endingBoundryStr = [NSString stringWithFormat:@"\r\n--%@--\r\n", ranges_boundry];
            NSData *endingBoundryData = [endingBoundryStr dataUsingEncoding:NSUTF8StringEncoding];
            
            [asyncSocket writeData:endingBoundryData withTimeout:TIMEOUT_WRITE_HEAD tag:HTTP_RESPONSE];
        }
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Responses
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Returns an array of possible index pages.
 * For example: {"index.html", "index.htm"}
**/
- (NSArray *)directoryIndexFileNames
{
    HTTPLogTrace();
    
    // Override me to support other index pages.
    
    return [NSArray arrayWithObjects:@"index.html", @"index.htm", nil];
}

- (NSString *)filePathForURI:(NSString *)path
{
    return [self filePathForURI:path allowDirectory:NO];
}

/**
 * Converts relative URI path into full file-system path.
**/
- (NSString *)filePathForURI:(NSString *)path allowDirectory:(BOOL)allowDirectory
{
    HTTPLogTrace();
    
    // Override me to perform custom path mapping.
    // For example you may want to use a default file other than index.html, or perhaps support multiple types.
    
    NSString *documentRoot = [config documentRoot];
    
    // Part 0: Validate document root setting.
    // 
    // If there is no configured documentRoot,
    // then it makes no sense to try to return anything.
    
    if (documentRoot == nil)
    {
        HTTPLogWarn(@"%@[%p]: No configured document root", THIS_FILE, self);
        return nil;
    }
    
    // Part 1: Strip parameters from the url
    // 
    // E.g.: /page.html?q=22&var=abc -> /page.html
    
    NSURL *docRoot = [NSURL fileURLWithPath:documentRoot isDirectory:YES];
    if (docRoot == nil)
    {
        HTTPLogWarn(@"%@[%p]: Document root is invalid file path", THIS_FILE, self);
        return nil;
    }
    
    NSString *relativePath = [[NSURL URLWithString:path relativeToURL:docRoot] relativePath];
    
    // Part 2: Append relative path to document root (base path)
    // 
    // E.g.: relativePath="/images/icon.png"
    //       documentRoot="/Users/robbie/Sites"
    //           fullPath="/Users/robbie/Sites/images/icon.png"
    // 
    // We also standardize the path.
    // 
    // E.g.: "Users/robbie/Sites/images/../index.html" -> "/Users/robbie/Sites/index.html"
    
    NSString *fullPath = [[documentRoot stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
    
    if ([relativePath isEqualToString:@"/"])
    {
        fullPath = [fullPath stringByAppendingString:@"/"];
    }
    
    // Part 3: Prevent serving files outside the document root.
    // 
    // Sneaky requests may include ".." in the path.
    // 
    // E.g.: relativePath="../Documents/TopSecret.doc"
    //       documentRoot="/Users/robbie/Sites"
    //           fullPath="/Users/robbie/Documents/TopSecret.doc"
    // 
    // E.g.: relativePath="../Sites_Secret/TopSecret.doc"
    //       documentRoot="/Users/robbie/Sites"
    //           fullPath="/Users/robbie/Sites_Secret/TopSecret"
    
    if (![documentRoot hasSuffix:@"/"])
    {
        documentRoot = [documentRoot stringByAppendingString:@"/"];
    }
    
    if (![fullPath hasPrefix:documentRoot])
    {
        HTTPLogWarn(@"%@[%p]: Request for file outside document root", THIS_FILE, self);
        return nil;
    }
    
    // Part 4: Search for index page if path is pointing to a directory
    if (!allowDirectory)
    {
        BOOL isDir = NO;
        if ([[NSFileManager defaultManager] fileExistsAtPath:fullPath isDirectory:&isDir] && isDir)
        {
            NSArray *indexFileNames = [self directoryIndexFileNames];

            for (NSString *indexFileName in indexFileNames)
            {
                NSString *indexFilePath = [fullPath stringByAppendingPathComponent:indexFileName];

                if ([[NSFileManager defaultManager] fileExistsAtPath:indexFilePath isDirectory:&isDir] && !isDir)
                {
                    return indexFilePath;
                }
            }

            // No matching index files found in directory
            return nil;
        }
    }

    return fullPath;
}

/**
 * This method is called to get a response for a request.
 * You may return any object that adopts the HTTPResponse protocol.
 * The HTTPServer comes with two such classes: HTTPFileResponse and HTTPDataResponse.
 * HTTPFileResponse is a wrapper for an NSFileHandle object, and is the preferred way to send a file response.
 * HTTPDataResponse is a wrapper for an NSData object, and may be used to send a custom response.
**/
- (NSObject<HTTPResponse> *)httpResponseForMethod:(NSString *)method URI:(NSString *)path
{
    HTTPLogTrace();
    
    // Override me to provide custom responses.
    
    NSString *filePath = [self filePathForURI:path allowDirectory:NO];
    
    BOOL isDir = NO;
    
    if (filePath && [[NSFileManager defaultManager] fileExistsAtPath:filePath isDirectory:&isDir] && !isDir)
    {
        return [[HTTPFileResponse alloc] initWithFilePath:filePath forConnection:self];
    
        // Use me instead for asynchronous file IO.
        // Generally better for larger files.
        
    //  return [[[HTTPAsyncFileResponse alloc] initWithFilePath:filePath forConnection:self] autorelease];
    }
    
    return nil;
}

- (WebSocket *)webSocketForURI:(NSString *)path
{
    HTTPLogTrace();
    
    // Override me to provide custom WebSocket responses.
    // To do so, simply override the base WebSocket implementation, and add your custom functionality.
    // Then return an instance of your custom WebSocket here.
    // 
    // For example:
    // 
    // if ([path isEqualToString:@"/myAwesomeWebSocketStream"])
    // {
    //     return [[[MyWebSocket alloc] initWithRequest:request socket:asyncSocket] autorelease];
    // }
    // 
    // return [super webSocketForURI:path];
    
    return nil;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Uploads
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * This method is called after receiving all HTTP headers, but before reading any of the request body.
**/
- (void)prepareForBodyWithSize:(UInt64)contentLength
{
    // Override me to allocate buffers, file handles, etc.
}

/**
 * This method is called to handle data read from a POST / PUT.
 * The given data is part of the request body.
**/
- (void)processBodyData:(NSData *)postDataChunk
{
    // Override me to do something useful with a POST / PUT.
    // If the post is small, such as a simple form, you may want to simply append the data to the request.
    // If the post is big, such as a file upload, you may want to store the file to disk.
    // 
    // Remember: In order to support LARGE POST uploads, the data is read in chunks.
    // This prevents a 50 MB upload from being stored in RAM.
    // The size of the chunks are limited by the POST_CHUNKSIZE definition.
    // Therefore, this method may be called multiple times for the same POST request.
}

/**
 * This method is called after the request body has been fully read but before the HTTP request is processed.
**/
- (void)finishBody
{
    // Override me to perform any final operations on an upload.
    // For example, if you were saving the upload to disk this would be
    // the hook to flush any pending data to disk and maybe close the file.
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Errors
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Called if the HTML version is other than what is supported
**/
- (void)handleVersionNotSupported:(NSString *)version
{
    // Override me for custom error handling of unsupported http version responses
    // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
    // You can also use preprocessErrorResponse: to add an optional HTML body.
    
    HTTPLogWarn(@"HTTP Server: Error 505 - Version Not Supported: %@ (%@)", version, [self requestURI]);
    
    HTTPMessage *response = [[HTTPMessage alloc] initResponseWithStatusCode:505 description:nil version:HTTPVersion1_1];
    [response setHeaderField:@"Content-Length" value:@"0"];
    
    NSData *responseData = [self preprocessErrorResponse:response];
    [asyncSocket writeData:responseData withTimeout:TIMEOUT_WRITE_ERROR tag:HTTP_RESPONSE];
    
}

/**
 * Called if the authentication information was required and absent, or if authentication failed.
**/
- (void)handleAuthenticationFailed
{
    // Override me for custom handling of authentication challenges
    // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
    // You can also use preprocessErrorResponse: to add an optional HTML body.
    
    HTTPLogInfo(@"HTTP Server: Error 401 - Unauthorized (%@)", [self requestURI]);
        
    // Status Code 401 - Unauthorized
    HTTPMessage *response = [[HTTPMessage alloc] initResponseWithStatusCode:401 description:nil version:HTTPVersion1_1];
    [response setHeaderField:@"Content-Length" value:@"0"];
    
    if ([self useDigestAccessAuthentication])
    {
        [self addDigestAuthChallenge:response];
    }
    else
    {
        [self addBasicAuthChallenge:response];
    }
    
    NSData *responseData = [self preprocessErrorResponse:response];
    [asyncSocket writeData:responseData withTimeout:TIMEOUT_WRITE_ERROR tag:HTTP_RESPONSE];
    
}

/**
 * Called if we receive some sort of malformed HTTP request.
 * The data parameter is the invalid HTTP header line, including CRLF, as read from GCDAsyncSocket.
 * The data parameter may also be nil if the request as a whole was invalid, such as a POST with no Content-Length.
**/
- (void)handleInvalidRequest:(NSData *)data
{
    // Override me for custom error handling of invalid HTTP requests
    // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
    // You can also use preprocessErrorResponse: to add an optional HTML body.
    
    HTTPLogWarn(@"HTTP Server: Error 400 - Bad Request (%@)", [self requestURI]);
    
    // Status Code 400 - Bad Request
    HTTPMessage *response = [[HTTPMessage alloc] initResponseWithStatusCode:400 description:nil version:HTTPVersion1_1];
    [response setHeaderField:@"Content-Length" value:@"0"];
    [response setHeaderField:@"Connection" value:@"close"];
    
    NSData *responseData = [self preprocessErrorResponse:response];
    [asyncSocket writeData:responseData withTimeout:TIMEOUT_WRITE_ERROR tag:HTTP_FINAL_RESPONSE];
    
    
    // Note: We used the HTTP_FINAL_RESPONSE tag to disconnect after the response is sent.
    // We do this because we couldn't parse the request,
    // so we won't be able to recover and move on to another request afterwards.
    // In other words, we wouldn't know where the first request ends and the second request begins.
}

/**
 * Called if we receive a HTTP request with a method other than GET or HEAD.
**/
- (void)handleUnknownMethod:(NSString *)method
{
    // Override me for custom error handling of 405 method not allowed responses.
    // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
    // You can also use preprocessErrorResponse: to add an optional HTML body.
    // 
    // See also: supportsMethod:atPath:
    
    HTTPLogWarn(@"HTTP Server: Error 405 - Method Not Allowed: %@ (%@)", method, [self requestURI]);
    
    // Status code 405 - Method Not Allowed
    HTTPMessage *response = [[HTTPMessage alloc] initResponseWithStatusCode:405 description:nil version:HTTPVersion1_1];
    [response setHeaderField:@"Content-Length" value:@"0"];
    [response setHeaderField:@"Connection" value:@"close"];
    
    NSData *responseData = [self preprocessErrorResponse:response];
    [asyncSocket writeData:responseData withTimeout:TIMEOUT_WRITE_ERROR tag:HTTP_FINAL_RESPONSE];
    
    
    // Note: We used the HTTP_FINAL_RESPONSE tag to disconnect after the response is sent.
    // We do this because the method may include an http body.
    // Since we can't be sure, we should close the connection.
}

/**
 * Called if we're unable to find the requested resource.
**/
- (void)handleResourceNotFound
{
    // Override me for custom error handling of 404 not found responses
    // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
    // You can also use preprocessErrorResponse: to add an optional HTML body.
    
    HTTPLogInfo(@"HTTP Server: Error 404 - Not Found (%@)", [self requestURI]);
    
    // Status Code 404 - Not Found
    HTTPMessage *response = [[HTTPMessage alloc] initResponseWithStatusCode:404 description:nil version:HTTPVersion1_1];
    [response setHeaderField:@"Content-Length" value:@"0"];
    
    NSData *responseData = [self preprocessErrorResponse:response];
    [asyncSocket writeData:responseData withTimeout:TIMEOUT_WRITE_ERROR tag:HTTP_RESPONSE];
    
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Headers
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Gets the current date and time, formatted properly (according to RFC) for insertion into an HTTP header.
**/
- (NSString *)dateAsString:(NSDate *)date
{
    // From Apple's Documentation (Data Formatting Guide -> Date Formatters -> Cache Formatters for Efficiency):
    // 
    // "Creating a date formatter is not a cheap operation. If you are likely to use a formatter frequently,
    // it is typically more efficient to cache a single instance than to create and dispose of multiple instances.
    // One approach is to use a static variable."
    // 
    // This was discovered to be true in massive form via issue #46:
    // 
    // "Was doing some performance benchmarking using instruments and httperf. Using this single optimization
    // I got a 26% speed improvement - from 1000req/sec to 3800req/sec. Not insignificant.
    // The culprit? Why, NSDateFormatter, of course!"
    // 
    // Thus, we are using a static NSDateFormatter here.
    
    static NSDateFormatter *df;
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
        // Example: Sun, 06 Nov 1994 08:49:37 GMT
        
        df = [[NSDateFormatter alloc] init];
        [df setFormatterBehavior:NSDateFormatterBehavior10_4];
        [df setTimeZone:[NSTimeZone timeZoneWithAbbreviation:@"GMT"]];
        [df setDateFormat:@"EEE, dd MMM y HH:mm:ss 'GMT'"];
        [df setLocale:[[NSLocale alloc] initWithLocaleIdentifier:@"en_US"]];
        
        // For some reason, using zzz in the format string produces GMT+00:00
    });
    
    return [df stringFromDate:date];
}

/**
 * This method is called immediately prior to sending the response headers.
 * This method adds standard header fields, and then converts the response to an NSData object.
**/
- (NSData *)preprocessResponse:(HTTPMessage *)response
{
    HTTPLogTrace();
    
    // Override me to customize the response headers
    // You'll likely want to add your own custom headers, and then return [super preprocessResponse:response]
    
    // Add standard headers
    NSString *now = [self dateAsString:[NSDate date]];
    [response setHeaderField:@"Date" value:now];
    
    // Add server capability headers
    [response setHeaderField:@"Accept-Ranges" value:@"bytes"];
    
    // Add optional response headers
    if ([httpResponse respondsToSelector:@selector(httpHeaders)])
    {
        NSDictionary *responseHeaders = [httpResponse httpHeaders];
        
        NSEnumerator *keyEnumerator = [responseHeaders keyEnumerator];
        NSString *key;
        
        while ((key = [keyEnumerator nextObject]))
        {
            NSString *value = [responseHeaders objectForKey:key];
            
            [response setHeaderField:key value:value];
        }
    }
    
    return [response messageData];
}

/**
 * This method is called immediately prior to sending the response headers (for an error).
 * This method adds standard header fields, and then converts the response to an NSData object.
**/
- (NSData *)preprocessErrorResponse:(HTTPMessage *)response
{
    HTTPLogTrace();
    
    // Override me to customize the error response headers
    // You'll likely want to add your own custom headers, and then return [super preprocessErrorResponse:response]
    // 
    // Notes:
    // You can use [response statusCode] to get the type of error.
    // You can use [response setBody:data] to add an optional HTML body.
    // If you add a body, don't forget to update the Content-Length.
    // 
    // if ([response statusCode] == 404)
    // {
    //     NSString *msg = @"<html><body>Error 404 - Not Found</body></html>";
    //     NSData *msgData = [msg dataUsingEncoding:NSUTF8StringEncoding];
    //     
    //     [response setBody:msgData];
    //     
    //     NSString *contentLengthStr = [NSString stringWithFormat:@"%lu", (unsigned long)[msgData length]];
    //     [response setHeaderField:@"Content-Length" value:contentLengthStr];
    // }
    
    // Add standard headers
    NSString *now = [self dateAsString:[NSDate date]];
    [response setHeaderField:@"Date" value:now];
    
    // Add server capability headers
    [response setHeaderField:@"Accept-Ranges" value:@"bytes"];
    
    // Add optional response headers
    if ([httpResponse respondsToSelector:@selector(httpHeaders)])
    {
        NSDictionary *responseHeaders = [httpResponse httpHeaders];
        
        NSEnumerator *keyEnumerator = [responseHeaders keyEnumerator];
        NSString *key;
        
        while((key = [keyEnumerator nextObject]))
        {
            NSString *value = [responseHeaders objectForKey:key];
            
            [response setHeaderField:key value:value];
        }
    }
    
    return [response messageData];
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark GCDAsyncSocket Delegate
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * This method is called after the socket has successfully read data from the stream.
 * Remember that this method will only be called after the socket reaches a CRLF, or after it's read the proper length.
**/
- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData*)data withTag:(long)tag
{
    if (tag == HTTP_REQUEST_HEADER)
    {
        // Append the header line to the http message
        BOOL result = [request appendData:data];
        if (!result)
        {
            HTTPLogWarn(@"%@[%p]: Malformed request", THIS_FILE, self);
            
            [self handleInvalidRequest:data];
        }
        else if (![request isHeaderComplete])
        {
            // We don't have a complete header yet
            // That is, we haven't yet received a CRLF on a line by itself, indicating the end of the header
            if (++numHeaderLines > MAX_HEADER_LINES)
            {
                // Reached the maximum amount of header lines in a single HTTP request
                // This could be an attempted DOS attack
                [asyncSocket disconnect];
                
                // Explictly return to ensure we don't do anything after the socket disconnect
                return;
            }
            else
            {
                [asyncSocket readDataToData:[GCDAsyncSocket CRLFData]
                                withTimeout:TIMEOUT_READ_SUBSEQUENT_HEADER_LINE
                                  maxLength:MAX_HEADER_LINE_LENGTH
                                        tag:HTTP_REQUEST_HEADER];
            }
        }
        else
        {
            // We have an entire HTTP request header from the client
            
            // Extract the method (such as GET, HEAD, POST, etc)
            NSString *method = [request method];
            
            // Extract the uri (such as "/index.html")
            NSString *uri = [self requestURI];
            
            // Check for a Transfer-Encoding field
            NSString *transferEncoding = [request headerField:@"Transfer-Encoding"];
      
            // Check for a Content-Length field
            NSString *contentLength = [request headerField:@"Content-Length"];
            
            // Content-Length MUST be present for upload methods (such as POST or PUT)
            // and MUST NOT be present for other methods.
            BOOL expectsUpload = [self expectsRequestBodyFromMethod:method atPath:uri];
            
            if (expectsUpload)
            {
                if (transferEncoding && ![transferEncoding caseInsensitiveCompare:@"Chunked"])
                {
                    requestContentLength = -1;
                }
                else
                {
                    if (contentLength == nil)
                    {
                        HTTPLogWarn(@"%@[%p]: Method expects request body, but had no specified Content-Length",
                                    THIS_FILE, self);
                        
                        [self handleInvalidRequest:nil];
                        return;
                    }
                    
                    if (![NSNumber parseString:(NSString *)contentLength intoUInt64:&requestContentLength])
                    {
                        HTTPLogWarn(@"%@[%p]: Unable to parse Content-Length header into a valid number",
                                    THIS_FILE, self);
                        
                        [self handleInvalidRequest:nil];
                        return;
                    }
                }
            }
            else
            {
                if (contentLength != nil)
                {
                    // Received Content-Length header for method not expecting an upload.
                    // This better be zero...
                    
                    if (![NSNumber parseString:(NSString *)contentLength intoUInt64:&requestContentLength])
                    {
                        HTTPLogWarn(@"%@[%p]: Unable to parse Content-Length header into a valid number",
                                    THIS_FILE, self);
                        
                        [self handleInvalidRequest:nil];
                        return;
                    }
                    
                    if (requestContentLength > 0)
                    {
                        HTTPLogWarn(@"%@[%p]: Method not expecting request body had non-zero Content-Length",
                                    THIS_FILE, self);
                        
                        [self handleInvalidRequest:nil];
                        return;
                    }
                }
                
                requestContentLength = 0;
                requestContentLengthReceived = 0;
            }
            
            // Check to make sure the given method is supported
            if (![self supportsMethod:method atPath:uri])
            {
                // The method is unsupported - either in general, or for this specific request
                // Send a 405 - Method not allowed response
                [self handleUnknownMethod:method];
                return;
            }
            
            if (expectsUpload)
            {
                // Reset the total amount of data received for the upload
                requestContentLengthReceived = 0;
                
                // Prepare for the upload
                [self prepareForBodyWithSize:requestContentLength];
                
                if (requestContentLength > 0)
                {
                    // Start reading the request body
                    if (requestContentLength == -1)
                    {
                        // Chunked transfer
                        
                        [asyncSocket readDataToData:[GCDAsyncSocket CRLFData]
                                        withTimeout:TIMEOUT_READ_BODY
                                          maxLength:MAX_CHUNK_LINE_LENGTH
                                                tag:HTTP_REQUEST_CHUNK_SIZE];
                    }
                    else
                    {
                        NSUInteger bytesToRead;
                        if (requestContentLength < POST_CHUNKSIZE)
                            bytesToRead = (NSUInteger)requestContentLength;
                        else
                            bytesToRead = POST_CHUNKSIZE;
                        
                        [asyncSocket readDataToLength:bytesToRead
                                          withTimeout:TIMEOUT_READ_BODY
                                                  tag:HTTP_REQUEST_BODY];
                    }
                }
                else
                {
                    // Empty upload
                    [self finishBody];
                    [self replyToHTTPRequest];
                }
            }
            else
            {
                // Now we need to reply to the request
                [self replyToHTTPRequest];
            }
        }
    }
    else
    {
        BOOL doneReadingRequest = NO;
        
        // A chunked message body contains a series of chunks,
        // followed by a line with "0" (zero),
        // followed by optional footers (just like headers),
        // and a blank line.
        // 
        // Each chunk consists of two parts:
        // 
        // 1. A line with the size of the chunk data, in hex,
        //    possibly followed by a semicolon and extra parameters you can ignore (none are currently standard),
        //    and ending with CRLF.
        // 2. The data itself, followed by CRLF.
        // 
        // Part 1 is represented by HTTP_REQUEST_CHUNK_SIZE
        // Part 2 is represented by HTTP_REQUEST_CHUNK_DATA and HTTP_REQUEST_CHUNK_TRAILER
        // where the trailer is the CRLF that follows the data.
        // 
        // The optional footers and blank line are represented by HTTP_REQUEST_CHUNK_FOOTER.
        
        if (tag == HTTP_REQUEST_CHUNK_SIZE)
        {
            // We have just read in a line with the size of the chunk data, in hex, 
            // possibly followed by a semicolon and extra parameters that can be ignored,
            // and ending with CRLF.
            
            NSString *sizeLine = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
            
            errno = 0;  // Reset errno before calling strtoull() to ensure it is always zero on success
            requestChunkSize = (UInt64)strtoull([sizeLine UTF8String], NULL, 16);
            requestChunkSizeReceived = 0;
            
            if (errno != 0)
            {
                HTTPLogWarn(@"%@[%p]: Method expects chunk size, but received something else", THIS_FILE, self);
                
                [self handleInvalidRequest:nil];
                return;
            }
            
            if (requestChunkSize > 0)
            {
                NSUInteger bytesToRead;
                bytesToRead = (requestChunkSize < POST_CHUNKSIZE) ? (NSUInteger)requestChunkSize : POST_CHUNKSIZE;
                
                [asyncSocket readDataToLength:bytesToRead
                                  withTimeout:TIMEOUT_READ_BODY
                                          tag:HTTP_REQUEST_CHUNK_DATA];
            }
            else
            {
                // This is the "0" (zero) line,
                // which is to be followed by optional footers (just like headers) and finally a blank line.
                
                [asyncSocket readDataToData:[GCDAsyncSocket CRLFData]
                                withTimeout:TIMEOUT_READ_BODY
                                  maxLength:MAX_HEADER_LINE_LENGTH
                                        tag:HTTP_REQUEST_CHUNK_FOOTER];
            }
            
            return;
        }
        else if (tag == HTTP_REQUEST_CHUNK_DATA)
        {
            // We just read part of the actual data.
            
            requestContentLengthReceived += [data length];
            requestChunkSizeReceived += [data length];
            
            [self processBodyData:data];
            
            UInt64 bytesLeft = requestChunkSize - requestChunkSizeReceived;
            if (bytesLeft > 0)
            {
                NSUInteger bytesToRead = (bytesLeft < POST_CHUNKSIZE) ? (NSUInteger)bytesLeft : POST_CHUNKSIZE;
                
                [asyncSocket readDataToLength:bytesToRead
                                  withTimeout:TIMEOUT_READ_BODY
                                          tag:HTTP_REQUEST_CHUNK_DATA];
            }
            else
            {
                // We've read in all the data for this chunk.
                // The data is followed by a CRLF, which we need to read (and basically ignore)
                
                [asyncSocket readDataToLength:2
                                  withTimeout:TIMEOUT_READ_BODY
                                          tag:HTTP_REQUEST_CHUNK_TRAILER];
            }
            
            return;
        }
        else if (tag == HTTP_REQUEST_CHUNK_TRAILER)
        {
            // This should be the CRLF following the data.
            // Just ensure it's a CRLF.
            
            if (![data isEqualToData:[GCDAsyncSocket CRLFData]])
            {
                HTTPLogWarn(@"%@[%p]: Method expects chunk trailer, but is missing", THIS_FILE, self);
                
                [self handleInvalidRequest:nil];
                return;
            }
            
            // Now continue with the next chunk
            
            [asyncSocket readDataToData:[GCDAsyncSocket CRLFData]
                            withTimeout:TIMEOUT_READ_BODY
                              maxLength:MAX_CHUNK_LINE_LENGTH
                                    tag:HTTP_REQUEST_CHUNK_SIZE];
            
        }
        else if (tag == HTTP_REQUEST_CHUNK_FOOTER)
        {
            if (++numHeaderLines > MAX_HEADER_LINES)
            {
                // Reached the maximum amount of header lines in a single HTTP request
                // This could be an attempted DOS attack
                [asyncSocket disconnect];
                
                // Explictly return to ensure we don't do anything after the socket disconnect
                return;
            }
            
            if ([data length] > 2)
            {
                // We read in a footer.
                // In the future we may want to append these to the request.
                // For now we ignore, and continue reading the footers, waiting for the final blank line.
                
                [asyncSocket readDataToData:[GCDAsyncSocket CRLFData]
                                withTimeout:TIMEOUT_READ_BODY
                                  maxLength:MAX_HEADER_LINE_LENGTH
                                        tag:HTTP_REQUEST_CHUNK_FOOTER];
            }
            else
            {
                doneReadingRequest = YES;
            }
        }
        else  // HTTP_REQUEST_BODY
        {
            // Handle a chunk of data from the POST body
            
            requestContentLengthReceived += [data length];
            [self processBodyData:data];
            
            if (requestContentLengthReceived < requestContentLength)
            {
                // We're not done reading the post body yet...
                
                UInt64 bytesLeft = requestContentLength - requestContentLengthReceived;
                
                NSUInteger bytesToRead = bytesLeft < POST_CHUNKSIZE ? (NSUInteger)bytesLeft : POST_CHUNKSIZE;
                
                [asyncSocket readDataToLength:bytesToRead
                                  withTimeout:TIMEOUT_READ_BODY
                                          tag:HTTP_REQUEST_BODY];
            }
            else
            {
                doneReadingRequest = YES;
            }
        }
        
        // Now that the entire body has been received, we need to reply to the request
        
        if (doneReadingRequest)
        {
            [self finishBody];
            [self replyToHTTPRequest];
        }
    }
}

/**
 * This method is called after the socket has successfully written data to the stream.
**/
- (void)socket:(GCDAsyncSocket *)sock didWriteDataWithTag:(long)tag
{
    BOOL doneSendingResponse = NO;
    
    if (tag == HTTP_PARTIAL_RESPONSE_BODY)
    {
        // Update the amount of data we have in asyncSocket's write queue
        [responseDataSizes removeObjectAtIndex:0];
        
        // We only wrote a part of the response - there may be more
        [self continueSendingStandardResponseBody];
    }
    else if (tag == HTTP_CHUNKED_RESPONSE_BODY)
    {
        // Update the amount of data we have in asyncSocket's write queue.
        // This will allow asynchronous responses to continue sending more data.
        [responseDataSizes removeObjectAtIndex:0];
        
        // Don't continue sending the response yet.
        // The chunked footer that was sent after the body will tell us if we have more data to send.
    }
    else if (tag == HTTP_CHUNKED_RESPONSE_FOOTER)
    {
        // Normal chunked footer indicating we have more data to send (non final footer).
        [self continueSendingStandardResponseBody];
    }
    else if (tag == HTTP_PARTIAL_RANGE_RESPONSE_BODY)
    {
        // Update the amount of data we have in asyncSocket's write queue
        [responseDataSizes removeObjectAtIndex:0];
        
        // We only wrote a part of the range - there may be more
        [self continueSendingSingleRangeResponseBody];
    }
    else if (tag == HTTP_PARTIAL_RANGES_RESPONSE_BODY)
    {
        // Update the amount of data we have in asyncSocket's write queue
        [responseDataSizes removeObjectAtIndex:0];
        
        // We only wrote part of the range - there may be more, or there may be more ranges
        [self continueSendingMultiRangeResponseBody];
    }
    else if (tag == HTTP_RESPONSE || tag == HTTP_FINAL_RESPONSE)
    {
        // Update the amount of data we have in asyncSocket's write queue
        if ([responseDataSizes count] > 0)
        {
            [responseDataSizes removeObjectAtIndex:0];
        }
        
        doneSendingResponse = YES;
    }
    
    if (doneSendingResponse)
    {
        // Inform the http response that we're done
        if ([httpResponse respondsToSelector:@selector(connectionDidClose)])
        {
            [httpResponse connectionDidClose];
        }
        
        
        if (tag == HTTP_FINAL_RESPONSE)
        {
            // Cleanup after the last request
            [self finishResponse];
            
            // Terminate the connection
            [asyncSocket disconnect];
            
            // Explictly return to ensure we don't do anything after the socket disconnects
            return;
        }
        else
        {
            if ([self shouldDie])
            {
                // Cleanup after the last request
                // Note: Don't do this before calling shouldDie, as it needs the request object still.
                [self finishResponse];
                
                // The only time we should invoke [self die] is from socketDidDisconnect,
                // or if the socket gets taken over by someone else like a WebSocket.
                
                [asyncSocket disconnect];
            }
            else
            {
                // Cleanup after the last request
                [self finishResponse];
                
                // Prepare for the next request
                
                // If this assertion fails, it likely means you overrode the
                // finishBody method and forgot to call [super finishBody].
                NSAssert(request == nil, @"Request not properly released in finishBody");
                
                request = [[HTTPMessage alloc] initEmptyRequest];
                
                numHeaderLines = 0;
                sentResponseHeaders = NO;
                
                // And start listening for more requests
                [self startReadingRequest];
            }
        }
    }
}

/**
 * Sent after the socket has been disconnected.
**/
- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)err
{
    HTTPLogTrace();
    
    asyncSocket = nil;
    
    [self die];
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark HTTPResponse Notifications
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * This method may be called by asynchronous HTTPResponse objects.
 * That is, HTTPResponse objects that return YES in their "- (BOOL)isAsynchronous" method.
 * 
 * This informs us that the response object has generated more data that we may be able to send.
**/
- (void)responseHasAvailableData:(NSObject<HTTPResponse> *)sender
{
    HTTPLogTrace();
    
    // We always dispatch this asynchronously onto our connectionQueue,
    // even if the connectionQueue is the current queue.
    // 
    // We do this to give the HTTPResponse classes the flexibility to call
    // this method whenever they want, even from within a readDataOfLength method.
    
    dispatch_async(connectionQueue, ^{ @autoreleasepool {
        
        if (sender != httpResponse)
        {
            HTTPLogWarn(@"%@[%p]: %@ - Sender is not current httpResponse", THIS_FILE, self, THIS_METHOD);
            return;
        }
        
        if (!sentResponseHeaders)
        {
            [self sendResponseHeadersAndBody];
        }
        else
        {
            if (ranges == nil)
            {
                [self continueSendingStandardResponseBody];
            }
            else
            {
                if ([ranges count] == 1)
                    [self continueSendingSingleRangeResponseBody];
                else
                    [self continueSendingMultiRangeResponseBody];
            }
        }
    }});
}

/**
 * This method is called if the response encounters some critical error,
 * and it will be unable to fullfill the request.
**/
- (void)responseDidAbort:(NSObject<HTTPResponse> *)sender
{
    HTTPLogTrace();
    
    // We always dispatch this asynchronously onto our connectionQueue,
    // even if the connectionQueue is the current queue.
    // 
    // We do this to give the HTTPResponse classes the flexibility to call
    // this method whenever they want, even from within a readDataOfLength method.
    
    dispatch_async(connectionQueue, ^{ @autoreleasepool {
        
        if (sender != httpResponse)
        {
            HTTPLogWarn(@"%@[%p]: %@ - Sender is not current httpResponse", THIS_FILE, self, THIS_METHOD);
            return;
        }
        
        [asyncSocket disconnectAfterWriting];
    }});
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark Post Request
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * This method is called after each response has been fully sent.
 * Since a single connection may handle multiple request/responses, this method may be called multiple times.
 * That is, it will be called after completion of each response.
**/
- (void)finishResponse
{
    HTTPLogTrace();
    
    // Override me if you want to perform any custom actions after a response has been fully sent.
    // This is the place to release memory or resources associated with the last request.
    // 
    // If you override this method, you should take care to invoke [super finishResponse] at some point.
    
    request = nil;
    
    httpResponse = nil;
    
    ranges = nil;
    ranges_headers = nil;
    ranges_boundry = nil;
}

/**
 * This method is called after each successful response has been fully sent.
 * It determines whether the connection should stay open and handle another request.
**/
- (BOOL)shouldDie
{
    HTTPLogTrace();
    
    // Override me if you have any need to force close the connection.
    // You may do so by simply returning YES.
    // 
    // If you override this method, you should take care to fall through with [super shouldDie]
    // instead of returning NO.
    
    
    BOOL shouldDie = NO;
    
    NSString *version = [request version];
    if ([version isEqualToString:HTTPVersion1_1])
    {
        // HTTP version 1.1
        // Connection should only be closed if request included "Connection: close" header
        
        NSString *connection = [request headerField:@"Connection"];
        
        shouldDie = (connection && ([connection caseInsensitiveCompare:@"close"] == NSOrderedSame));
    }
    else if ([version isEqualToString:HTTPVersion1_0])
    {
        // HTTP version 1.0
        // Connection should be closed unless request included "Connection: Keep-Alive" header
        
        NSString *connection = [request headerField:@"Connection"];
        
        if (connection == nil)
            shouldDie = YES;
        else
            shouldDie = [connection caseInsensitiveCompare:@"Keep-Alive"] != NSOrderedSame;
    }
    
    return shouldDie;
}

- (void)die
{
    HTTPLogTrace();
    
    // Override me if you want to perform any custom actions when a connection is closed.
    // Then call [super die] when you're done.
    // 
    // See also the finishResponse method.
    // 
    // Important: There is a rare timing condition where this method might get invoked twice.
    // If you override this method, you should be prepared for this situation.
    
    // Inform the http response that we're done
    if ([httpResponse respondsToSelector:@selector(connectionDidClose)])
    {
        [httpResponse connectionDidClose];
    }
    
    // Release the http response so we don't call it's connectionDidClose method again in our dealloc method
    httpResponse = nil;
    
    // Post notification of dead connection
    // This will allow our server to release us from its array of connections
    [[NSNotificationCenter defaultCenter] postNotificationName:HTTPConnectionDidDieNotification object:self];
}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark -
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@implementation HTTPConfig

@synthesize server;
@synthesize documentRoot;
@synthesize queue;

- (id)initWithServer:(HTTPServer *)aServer documentRoot:(NSString *)aDocumentRoot
{
    if ((self = [super init]))
    {
        server = aServer;
        documentRoot = aDocumentRoot;
    }
    return self;
}

- (id)initWithServer:(HTTPServer *)aServer documentRoot:(NSString *)aDocumentRoot queue:(dispatch_queue_t)q
{
    if ((self = [super init]))
    {
        server = aServer;
        
        documentRoot = [aDocumentRoot stringByStandardizingPath];
        if ([documentRoot hasSuffix:@"/"])
        {
            documentRoot = [documentRoot stringByAppendingString:@"/"];
        }
        
        if (q)
        {
            queue = q;
            #if NEEDS_DISPATCH_RETAIN_RELEASE
            dispatch_retain(queue);
            #endif
        }
    }
    return self;
}

- (void)dealloc
{
    #if NEEDS_DISPATCH_RETAIN_RELEASE
    if (queue) dispatch_release(queue);
    #endif
}

@end
