rhodes 7.4.1 → 7.6.0

data/platform/iphone/CocoaHTTPServer/Core/Responses/HTTPDynamicFileResponse.m

@@ -0,0 +1,292 @@
+#import "HTTPDynamicFileResponse.h"
+#import "HTTPConnection.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
+
+// Log levels : off, error, warn, info, verbose
+// Other flags: trace
+static const int httpLogLevel = HTTP_LOG_LEVEL_WARN; // | HTTP_LOG_FLAG_TRACE;
+
+#define NULL_FD  -1
+
+
+@implementation HTTPDynamicFileResponse
+
+- (id)initWithFilePath:(NSString *)fpath
+         forConnection:(HTTPConnection *)parent
+             separator:(NSString *)separatorStr
+ replacementDictionary:(NSDictionary *)dict
+{
+	if ((self = [super initWithFilePath:fpath forConnection:parent]))
+	{
+		HTTPLogTrace();
+		
+		separator = [separatorStr dataUsingEncoding:NSUTF8StringEncoding];
+		replacementDict = dict;
+	}
+	return self;
+}
+
+- (BOOL)isChunked
+{
+	HTTPLogTrace();
+	
+	return YES;
+}
+
+- (UInt64)contentLength
+{
+	// This method shouldn't be called since we're using a chunked response.
+	// We override it just to be safe.
+	
+	HTTPLogTrace();
+	
+	return 0;
+}
+
+- (void)setOffset:(UInt64)offset
+{
+	// This method shouldn't be called since we're using a chunked response.
+	// We override it just to be safe.
+	
+	HTTPLogTrace();
+}
+
+- (BOOL)isDone
+{
+	BOOL result = (readOffset == fileLength) && (readBufferOffset == 0);
+	
+	HTTPLogTrace2(@"%@[%p]: isDone - %@", THIS_FILE, self, (result ? @"YES" : @"NO"));
+	
+	return result;
+}
+
+- (void)processReadBuffer
+{
+	HTTPLogTrace();
+	
+	// At this point, the readBuffer has readBufferOffset bytes available.
+	// This method is in charge of updating the readBufferOffset.
+	
+	NSUInteger bufLen = readBufferOffset;
+	NSUInteger sepLen = [separator length];
+	
+	// We're going to start looking for the separator at the beginning of the buffer,
+	// and stop when we get to the point where the separator would no longer fit in the buffer.
+	
+	NSUInteger offset = 0;
+	NSUInteger stopOffset = (bufLen > sepLen) ? bufLen - sepLen + 1 : 0;
+	
+	// In order to do the replacement, we need to find the starting and ending separator.
+	// For example:
+	// 
+	// %%USER_NAME%%
+	// 
+	// Where "%%" is the separator.
+	
+	BOOL found1 = NO;
+	BOOL found2 = NO;
+	
+	NSUInteger s1 = 0;
+	NSUInteger s2 = 0;
+	
+	const void *sep = [separator bytes];
+	
+	while (offset < stopOffset)
+	{
+		const void *subBuffer = readBuffer + offset;
+		
+		if (memcmp(subBuffer, sep, sepLen) == 0)
+		{
+			if (!found1)
+			{
+				// Found the first separator
+				
+				found1 = YES;
+				s1 = offset;
+				offset += sepLen;
+				
+				HTTPLogVerbose(@"%@[%p]: Found s1 at %lu", THIS_FILE, self, (unsigned long)s1);
+			}
+			else
+			{
+				// Found the second separator
+				
+				found2 = YES;
+				s2 = offset;
+				offset += sepLen;
+				
+				HTTPLogVerbose(@"%@[%p]: Found s2 at %lu", THIS_FILE, self, (unsigned long)s2);
+			}
+			
+			if (found1 && found2)
+			{
+				// We found our separators.
+				// Now extract the string between the two separators.
+				
+				NSRange fullRange = NSMakeRange(s1, (s2 - s1 + sepLen));
+				NSRange strRange = NSMakeRange(s1 + sepLen, (s2 - s1 - sepLen));
+				
+				// Wish we could use the simple subdataWithRange method.
+				// But that method copies the bytes...
+				// So for performance reasons, we need to use the methods that don't copy the bytes.
+				
+				void *strBuf = readBuffer + strRange.location;
+				NSUInteger strLen = strRange.length;
+				
+				NSString *key = [[NSString alloc] initWithBytes:strBuf length:strLen encoding:NSUTF8StringEncoding];
+				if (key)
+				{
+					// Is there a given replacement for this key?
+					
+					id value = [replacementDict objectForKey:key];
+					if (value)
+					{
+						// Found the replacement value.
+						// Now perform the replacement in the buffer.
+						
+						HTTPLogVerbose(@"%@[%p]: key(%@) -> value(%@)", THIS_FILE, self, key, value);
+						
+						NSData *v = [[value description] dataUsingEncoding:NSUTF8StringEncoding];
+						NSUInteger vLength = [v length];
+						
+						if (fullRange.length == vLength)
+						{
+							// Replacement is exactly the same size as what it is replacing
+							
+							// memcpy(void *restrict dst, const void *restrict src, size_t n);
+							
+							memcpy(readBuffer + fullRange.location, [v bytes], vLength);
+						}
+						else // (fullRange.length != vLength)
+						{
+							NSInteger diff = (NSInteger)vLength - (NSInteger)fullRange.length;
+							
+							if (diff > 0)
+							{
+								// Replacement is bigger than what it is replacing.
+								// Make sure there is room in the buffer for the replacement.
+								
+								if (diff > (readBufferSize - bufLen))
+								{
+									NSUInteger inc = MAX(diff, 256);
+									
+									readBufferSize += inc;
+									readBuffer = reallocf(readBuffer, readBufferSize);
+								}
+							}
+							
+							// Move the data that comes after the replacement.
+							// 
+							// If replacement is smaller than what it is replacing,
+							// then we are shifting the data toward the beginning of the buffer.
+							// 
+							// If replacement is bigger than what it is replacing,
+							// then we are shifting the data toward the end of the buffer.
+							// 
+							// memmove(void *dst, const void *src, size_t n);
+							// 
+							// The memmove() function copies n bytes from src to dst.
+							// The two areas may overlap; the copy is always done in a non-destructive manner.
+							
+							void *src = readBuffer + fullRange.location + fullRange.length;
+							void *dst = readBuffer + fullRange.location + vLength;
+							
+							NSUInteger remaining = bufLen - (fullRange.location + fullRange.length);
+							
+							memmove(dst, src, remaining);
+							
+							// Now copy the replacement into its location.
+							// 
+							// memcpy(void *restrict dst, const void *restrict src, size_t n)
+							// 
+							// The memcpy() function copies n bytes from src to dst.
+							// If the two areas overlap, behavior is undefined.
+							
+							memcpy(readBuffer + fullRange.location, [v bytes], vLength);
+							
+							// And don't forget to update our indices.
+							
+							bufLen     += diff;
+							offset     += diff;
+							stopOffset += diff;
+						}
+					}
+					
+				}
+				
+				found1 = found2 = NO;
+			}
+		}
+		else
+		{
+			offset++;
+		}
+	}
+	
+	// We've gone through our buffer now, and performed all the replacements that we could.
+	// It's now time to update the amount of available data we have.
+	
+	if (readOffset == fileLength)
+	{
+		// We've read in the entire file.
+		// So there can be no more replacements.
+		
+		data = [[NSData alloc] initWithBytes:readBuffer length:bufLen];
+		readBufferOffset = 0;
+	}
+	else
+	{
+		// There are a couple different situations that we need to take into account here.
+		// 
+		// Imagine the following file:
+		// My name is %%USER_NAME%%
+		// 
+		// Situation 1:
+		// The first chunk of data we read was "My name is %%".
+		// So we found the first separator, but not the second.
+		// In this case we can only return the data that precedes the first separator.
+		// 
+		// Situation 2:
+		// The first chunk of data we read was "My name is %".
+		// So we didn't find any separators, but part of a separator may be included in our buffer.
+		
+		NSUInteger available;
+		if (found1)
+		{
+			// Situation 1
+			available = s1;
+		}
+		else
+		{
+			// Situation 2
+			available = stopOffset;
+		}
+		
+		// Copy available data
+		
+		data = [[NSData alloc] initWithBytes:readBuffer length:available];
+		
+		// Remove the copied data from the buffer.
+		// We do this by shifting the remaining data toward the beginning of the buffer.
+		
+		NSUInteger remaining = bufLen - available;
+		
+		memmove(readBuffer, readBuffer + available, remaining);
+		readBufferOffset = remaining;
+	}
+	
+	[connection responseHasAvailableData:self];
+}
+
+- (void)dealloc
+{
+	HTTPLogTrace();
+	
+	
+}
+
+@end

data/platform/iphone/CocoaHTTPServer/Core/Responses/HTTPErrorResponse.h

@@ -0,0 +1,9 @@
+#import "HTTPResponse.h"
+
+@interface HTTPErrorResponse : NSObject <HTTPResponse> {
+    NSInteger _status;
+}
+
+- (id)initWithErrorCode:(int)httpErrorCode;
+
+@end

data/platform/iphone/CocoaHTTPServer/Core/Responses/HTTPErrorResponse.m

@@ -0,0 +1,38 @@
+#import "HTTPErrorResponse.h"
+
+@implementation HTTPErrorResponse
+
+-(id)initWithErrorCode:(int)httpErrorCode
+{
+    if ((self = [super init]))
+    {
+        _status = httpErrorCode;
+    }
+
+    return self;
+}
+
+- (UInt64) contentLength {
+    return 0;
+}
+
+- (UInt64) offset {
+    return 0;
+}
+
+- (void)setOffset:(UInt64)offset {
+    ;
+}
+
+- (NSData*) readDataOfLength:(NSUInteger)length {
+    return nil;
+}
+
+- (BOOL) isDone {
+    return YES;
+}
+
+- (NSInteger) status {
+    return _status;
+}
+@end

data/platform/iphone/CocoaHTTPServer/Core/Responses/HTTPFileResponse.h

@@ -0,0 +1,25 @@
+#import <Foundation/Foundation.h>
+#import "HTTPResponse.h"
+
+@class HTTPConnection;
+
+
+@interface HTTPFileResponse : NSObject <HTTPResponse>
+{
+	HTTPConnection *connection;
+	
+	NSString *filePath;
+	UInt64 fileLength;
+	UInt64 fileOffset;
+	
+	BOOL aborted;
+	
+	int fileFD;
+	void *buffer;
+	NSUInteger bufferSize;
+}
+
+- (id)initWithFilePath:(NSString *)filePath forConnection:(HTTPConnection *)connection;
+- (NSString *)filePath;
+
+@end

data/platform/iphone/CocoaHTTPServer/Core/Responses/HTTPFileResponse.m

@@ -0,0 +1,237 @@
+#import "HTTPFileResponse.h"
+#import "HTTPConnection.h"
+#import "HTTPLogging.h"
+
+#import <unistd.h>
+#import <fcntl.h>
+
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+
+// Log levels : off, error, warn, info, verbose
+// Other flags: trace
+static const int httpLogLevel = HTTP_LOG_LEVEL_WARN; // | HTTP_LOG_FLAG_TRACE;
+
+#define NULL_FD  -1
+
+
+@implementation HTTPFileResponse
+
+- (id)initWithFilePath:(NSString *)fpath forConnection:(HTTPConnection *)parent
+{
+	if((self = [super init]))
+	{
+		HTTPLogTrace();
+		
+		connection = parent; // Parents retain children, children do NOT retain parents
+		
+		fileFD = NULL_FD;
+		filePath = [[fpath copy] stringByResolvingSymlinksInPath];
+		if (filePath == nil)
+		{
+			HTTPLogWarn(@"%@: Init failed - Nil filePath", THIS_FILE);
+			
+			return nil;
+		}
+		
+		NSDictionary *fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
+		if (fileAttributes == nil)
+		{
+			HTTPLogWarn(@"%@: Init failed - Unable to get file attributes. filePath: %@", THIS_FILE, filePath);
+			
+			return nil;
+		}
+		
+		fileLength = (UInt64)[[fileAttributes objectForKey:NSFileSize] unsignedLongLongValue];
+		fileOffset = 0;
+		
+		aborted = NO;
+		
+		// We don't bother opening the file here.
+		// If this is a HEAD request we only need to know the fileLength.
+	}
+	return self;
+}
+
+- (void)abort
+{
+	HTTPLogTrace();
+	
+	[connection responseDidAbort:self];
+	aborted = YES;
+}
+
+- (BOOL)openFile
+{
+	HTTPLogTrace();
+	
+	fileFD = open([filePath UTF8String], O_RDONLY);
+	if (fileFD == NULL_FD)
+	{
+		HTTPLogError(@"%@[%p]: Unable to open file. filePath: %@", THIS_FILE, self, filePath);
+		
+		[self abort];
+		return NO;
+	}
+	
+	HTTPLogVerbose(@"%@[%p]: Open fd[%i] -> %@", THIS_FILE, self, fileFD, filePath);
+	
+	return YES;
+}
+
+- (BOOL)openFileIfNeeded
+{
+	if (aborted)
+	{
+		// The file operation has been aborted.
+		// This could be because we failed to open the file,
+		// or the reading process failed.
+		return NO;
+	}
+	
+	if (fileFD != NULL_FD)
+	{
+		// File has already been opened.
+		return YES;
+	}
+	
+	return [self openFile];
+}
+
+- (UInt64)contentLength
+{
+	HTTPLogTrace();
+	
+	return fileLength;
+}
+
+- (UInt64)offset
+{
+	HTTPLogTrace();
+	
+	return fileOffset;
+}
+
+- (void)setOffset:(UInt64)offset
+{
+	HTTPLogTrace2(@"%@[%p]: setOffset:%llu", THIS_FILE, self, offset);
+	
+	if (![self openFileIfNeeded])
+	{
+		// File opening failed,
+		// or response has been aborted due to another error.
+		return;
+	}
+	
+	fileOffset = offset;
+	
+	off_t result = lseek(fileFD, (off_t)offset, SEEK_SET);
+	if (result == -1)
+	{
+		HTTPLogError(@"%@[%p]: lseek failed - errno(%i) filePath(%@)", THIS_FILE, self, errno, filePath);
+		
+		[self abort];
+	}
+}
+
+- (NSData *)readDataOfLength:(NSUInteger)length
+{
+	HTTPLogTrace2(@"%@[%p]: readDataOfLength:%lu", THIS_FILE, self, (unsigned long)length);
+	
+	if (![self openFileIfNeeded])
+	{
+		// File opening failed,
+		// or response has been aborted due to another error.
+		return nil;
+	}
+	
+	// Determine how much data we should read.
+	// 
+	// It is OK if we ask to read more bytes than exist in the file.
+	// It is NOT OK to over-allocate the buffer.
+	
+	UInt64 bytesLeftInFile = fileLength - fileOffset;
+	
+	NSUInteger bytesToRead = (NSUInteger)MIN(length, bytesLeftInFile);
+	
+	// Make sure buffer is big enough for read request.
+	// Do not over-allocate.
+	
+	if (buffer == NULL || bufferSize < bytesToRead)
+	{
+		bufferSize = bytesToRead;
+		buffer = reallocf(buffer, (size_t)bufferSize);
+		
+		if (buffer == NULL)
+		{
+			HTTPLogError(@"%@[%p]: Unable to allocate buffer", THIS_FILE, self);
+			
+			[self abort];
+			return nil;
+		}
+	}
+	
+	// Perform the read
+	
+	HTTPLogVerbose(@"%@[%p]: Attempting to read %lu bytes from file", THIS_FILE, self, (unsigned long)bytesToRead);
+	
+	ssize_t result = read(fileFD, buffer, bytesToRead);
+	
+	// Check the results
+	
+	if (result < 0)
+	{
+		HTTPLogError(@"%@: Error(%i) reading file(%@)", THIS_FILE, errno, filePath);
+		
+		[self abort];
+		return nil;
+	}
+	else if (result == 0)
+	{
+		HTTPLogError(@"%@: Read EOF on file(%@)", THIS_FILE, filePath);
+		
+		[self abort];
+		return nil;
+	}
+	else // (result > 0)
+	{
+		HTTPLogVerbose(@"%@[%p]: Read %ld bytes from file", THIS_FILE, self, (long)result);
+		
+		fileOffset += result;
+		
+		return [NSData dataWithBytes:buffer length:result];
+	}
+}
+
+- (BOOL)isDone
+{
+	BOOL result = (fileOffset == fileLength);
+	
+	HTTPLogTrace2(@"%@[%p]: isDone - %@", THIS_FILE, self, (result ? @"YES" : @"NO"));
+	
+	return result;
+}
+
+- (NSString *)filePath
+{
+	return filePath;
+}
+
+- (void)dealloc
+{
+	HTTPLogTrace();
+	
+	if (fileFD != NULL_FD)
+	{
+		HTTPLogVerbose(@"%@[%p]: Close fd[%i]", THIS_FILE, self, fileFD);
+		
+		close(fileFD);
+	}
+	
+	if (buffer)
+		free(buffer);
+	
+}
+
+@end

data/platform/iphone/CocoaHTTPServer/Core/Responses/HTTPRedirectResponse.h

@@ -0,0 +1,12 @@
+#import <Foundation/Foundation.h>
+#import "HTTPResponse.h"
+
+
+@interface HTTPRedirectResponse : NSObject <HTTPResponse>
+{
+	NSString *redirectPath;
+}
+
+- (id)initWithPath:(NSString *)redirectPath;
+
+@end

data/platform/iphone/CocoaHTTPServer/Core/Responses/HTTPRedirectResponse.m

@@ -0,0 +1,73 @@
+#import "HTTPRedirectResponse.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
+
+// Log levels : off, error, warn, info, verbose
+// Other flags: trace
+static const int httpLogLevel = HTTP_LOG_LEVEL_OFF; // | HTTP_LOG_FLAG_TRACE;
+
+
+@implementation HTTPRedirectResponse
+
+- (id)initWithPath:(NSString *)path
+{
+	if ((self = [super init]))
+	{
+		HTTPLogTrace();
+		
+		redirectPath = [path copy];
+	}
+	return self;
+}
+
+- (UInt64)contentLength
+{
+	return 0;
+}
+
+- (UInt64)offset
+{
+	return 0;
+}
+
+- (void)setOffset:(UInt64)offset
+{
+	// Nothing to do
+}
+
+- (NSData *)readDataOfLength:(NSUInteger)length
+{
+	HTTPLogTrace();
+	
+	return nil;
+}
+
+- (BOOL)isDone
+{
+	return YES;
+}
+
+- (NSDictionary *)httpHeaders
+{
+	HTTPLogTrace();
+	
+	return [NSDictionary dictionaryWithObject:redirectPath forKey:@"Location"];
+}
+
+- (NSInteger)status
+{
+	HTTPLogTrace();
+	
+	return 302;
+}
+
+- (void)dealloc
+{
+	HTTPLogTrace();
+	
+}
+
+@end