appjam 0.1.8.8 → 0.1.8.9

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Core/Mime/MultipartFormDataParser.h

@@ -0,0 +1,65 @@
+
+#import "MultipartMessageHeader.h"
+
+/* 
+Part one: http://tools.ietf.org/html/rfc2045 (Format of Internet Message Bodies)
+Part two: http://tools.ietf.org/html/rfc2046 (Media Types)
+Part three: http://tools.ietf.org/html/rfc2047 (Message Header Extensions for Non-ASCII Text)
+Part four: http://tools.ietf.org/html/rfc4289 (Registration Procedures) 
+Part five: http://tools.ietf.org/html/rfc2049 (Conformance Criteria and Examples) 
+ 
+Internet message format:  http://tools.ietf.org/html/rfc2822
+
+Multipart/form-data http://tools.ietf.org/html/rfc2388
+*/
+
+@class MultipartFormDataParser;
+
+//-----------------------------------------------------------------
+// protocol MultipartFormDataParser
+//-----------------------------------------------------------------
+
+@protocol MultipartFormDataParserDelegate <NSObject> 
+@optional
+- (void) processContent:(NSData*) data WithHeader:(MultipartMessageHeader*) header;
+- (void) processEndOfPartWithHeader:(MultipartMessageHeader*) header;
+- (void) processPreambleData:(NSData*) data;
+- (void) processEpilogueData:(NSData*) data;
+- (void) processStartOfPartWithHeader:(MultipartMessageHeader*) header;
+@end
+
+//-----------------------------------------------------------------
+// interface MultipartFormDataParser
+//-----------------------------------------------------------------
+
+@interface MultipartFormDataParser : NSObject {
+NSMutableData*						pendingData;
+    NSData*							boundaryData;
+    MultipartMessageHeader*			currentHeader;
+
+	BOOL							waitingForCRLF;
+	BOOL							reachedEpilogue;
+	BOOL							processedPreamble;
+	BOOL							checkForContentEnd;
+
+#if __has_feature(objc_arc_weak)
+	__weak id<MultipartFormDataParserDelegate>                  delegate;
+#else
+	__unsafe_unretained id<MultipartFormDataParserDelegate>     delegate;
+#endif	
+	int									currentEncoding;
+	NSStringEncoding					formEncoding;
+}
+
+- (BOOL) appendData:(NSData*) data;
+
+- (id) initWithBoundary:(NSString*) boundary formEncoding:(NSStringEncoding) formEncoding;
+
+#if __has_feature(objc_arc_weak)
+    @property(weak, readwrite) id delegate;
+#else
+    @property(unsafe_unretained, readwrite) id delegate;
+#endif
+@property(readwrite) NSStringEncoding	formEncoding;
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Core/Mime/MultipartFormDataParser.m

@@ -0,0 +1,529 @@
+
+#import "MultipartFormDataParser.h"
+#import "DDData.h"
+#import "HTTPLogging.h"
+
+#pragma mark log level
+
+#ifdef DEBUG
+static const int httpLogLevel = HTTP_LOG_LEVEL_WARN;
+#else
+static const int httpLogLevel = HTTP_LOG_LEVEL_WARN;
+#endif
+
+#ifdef __x86_64__
+#define FMTNSINT "li"
+#else
+#define FMTNSINT "i"
+#endif
+
+
+//-----------------------------------------------------------------
+// interface MultipartFormDataParser (private)
+//-----------------------------------------------------------------
+
+
+@interface MultipartFormDataParser (private)
++ (NSData*) decodedDataFromData:(NSData*) data encoding:(int) encoding;
+
+- (int) findHeaderEnd:(NSData*) workingData fromOffset:(int) offset;
+- (int) findContentEnd:(NSData*) data fromOffset:(int) offset;
+
+- (int) numberOfBytesToLeavePendingWithData:(NSData*) data length:(NSUInteger) length encoding:(int) encoding;
+- (int) offsetTillNewlineSinceOffset:(int) offset inData:(NSData*) data;
+
+- (int) processPreamble:(NSData*) workingData;
+
+@end
+
+
+//-----------------------------------------------------------------
+// implementation MultipartFormDataParser
+//-----------------------------------------------------------------
+
+
+@implementation MultipartFormDataParser 
+@synthesize delegate,formEncoding;
+
+- (id) initWithBoundary:(NSString*) boundary formEncoding:(NSStringEncoding) _formEncoding {
+    if( nil == (self = [super init]) ){
+        return self;
+    }
+	if( nil == boundary ) {
+		HTTPLogWarn(@"MultipartFormDataParser: init with zero boundary");
+		return nil;
+	}
+    boundaryData = [[@"\r\n--" stringByAppendingString:boundary] dataUsingEncoding:NSASCIIStringEncoding];
+
+    pendingData = [[NSMutableData alloc] init];
+    currentEncoding = contentTransferEncoding_binary;
+	currentHeader = nil;
+
+	formEncoding = _formEncoding;
+	reachedEpilogue = NO;
+	processedPreamble = NO;
+
+    return self;
+}
+
+
+- (BOOL) appendData:(NSData *)data { 
+    // Can't parse without boundary;
+    if( nil == boundaryData ) {
+		HTTPLogError(@"MultipartFormDataParser: Trying to parse multipart without specifying a valid boundary");
+		assert(false);
+        return NO;
+    }
+    NSData* workingData = data;
+
+    if( pendingData.length ) {
+        [pendingData appendData:data];
+        workingData = pendingData;
+    }
+
+	// the parser saves parse stat in the offset variable, which indicates offset of unhandled part in 
+	// currently received chunk. Before returning, we always drop all data up to offset, leaving 
+	// only unhandled for the next call
+
+    int offset = 0;
+
+	// don't parse data unless its size is greater then boundary length, so we couldn't
+	// misfind the boundary, if it got split into different data chunks
+	NSUInteger sizeToLeavePending = boundaryData.length;
+
+	if( !reachedEpilogue && workingData.length <= sizeToLeavePending )  {
+		// not enough data even to start parsing.
+		// save to pending data.
+		if( !pendingData.length ) {
+			[pendingData appendData:data];
+		}
+		if( checkForContentEnd ) {
+			if(	pendingData.length >= 2 ) {
+				if( *(uint16_t*)(pendingData.bytes + offset) == 0x2D2D ) {
+					// we found the multipart end. all coming next is an epilogue.
+					HTTPLogVerbose(@"MultipartFormDataParser: End of multipart message");
+					waitingForCRLF = YES;
+					reachedEpilogue = YES;
+					offset+= 2;
+				}
+				else {
+					checkForContentEnd = NO;
+					waitingForCRLF = YES;
+					return YES;
+				}
+			} else {
+				return YES;
+			}
+			
+		}
+		else {
+			return YES;
+		}
+	}
+	while( true ) {
+		if( checkForContentEnd ) {
+			// the flag will be raised to check if the last part was the last one.
+			if( offset < workingData.length -1 ) {
+				char* bytes = (char*) workingData.bytes;
+				if( *(uint16_t*)(bytes + offset) == 0x2D2D ) {
+					// we found the multipart end. all coming next is an epilogue.
+					HTTPLogVerbose(@"MultipartFormDataParser: End of multipart message");
+					checkForContentEnd = NO;
+					reachedEpilogue = YES;
+					// still wait for CRLF, that comes after boundary, but before epilogue.
+					waitingForCRLF = YES;
+					offset += 2;
+				}
+				else {
+					// it's not content end, we have to wait till separator line end before next part comes
+					waitingForCRLF = YES;
+					checkForContentEnd = NO;
+				}
+			}
+			else {
+				// we haven't got enough data to check for content end.
+				// save current unhandled data (it may be 1 byte) to pending and recheck on next chunk received
+				if( offset < workingData.length ) {
+					[pendingData setData:[NSData dataWithBytes:workingData.bytes + workingData.length-1 length:1]];
+				}
+				else {
+					// there is no unhandled data now, wait for more chunks
+					[pendingData setData:[NSData data]];
+				}
+				return YES;
+			}
+		}
+		if( waitingForCRLF ) {
+
+			// the flag will be raised in the code below, meaning, we've read the boundary, but
+			// didnt find the end of boundary line yet.
+
+			offset = [self offsetTillNewlineSinceOffset:offset inData:workingData];
+			if( -1 == offset ) {
+				// didnt find the endl again.
+				if( offset ) {
+					// we still have to save the unhandled data (maybe it's 1 byte CR)
+					if( *((char*)workingData.bytes + workingData.length -1) == '\r' ) {
+						[pendingData setData:[NSData dataWithBytes:workingData.bytes + workingData.length-1 length:1]];
+					}
+					else {
+						// or save nothing if it wasnt 
+						[pendingData setData:[NSData data]];
+					}
+				}
+				return YES;
+			}
+			waitingForCRLF = NO;
+		}
+		if( !processedPreamble ) {
+			// got to find the first boundary before the actual content begins.
+			offset = [self processPreamble:workingData];
+			// wait for more data for preamble
+			if( -1 == offset ) 
+				return YES;
+			// invoke continue to skip newline after boundary.
+			continue;
+		}
+
+		if( reachedEpilogue ) {
+			// parse all epilogue data to delegate.
+			if( [delegate respondsToSelector:@selector(processEpilogueData:)] ) {
+				NSData* epilogueData = [NSData dataWithBytesNoCopy: (char*) workingData.bytes + offset length: workingData.length - offset freeWhenDone:NO];
+				[delegate processEpilogueData: epilogueData];
+			}
+			return YES;
+		}
+
+		if( nil == currentHeader ) {
+			// nil == currentHeader is a state flag, indicating we are waiting for header now.
+			// whenever part is over, currentHeader is set to nil.
+
+			// try to find CRLFCRLF bytes in the data, which indicates header end.
+			// we won't parse header parts, as they won't be too large.
+			int headerEnd = [self findHeaderEnd:workingData fromOffset:offset];
+			if( -1 == headerEnd ) {
+				// didn't recieve the full header yet.
+				if( !pendingData.length) {
+					// store the unprocessed data till next chunks come
+					[pendingData appendBytes:data.bytes + offset length:data.length - offset];
+				}
+				else {
+					if( offset ) {
+						// save the current parse state; drop all handled data and save unhandled only.
+						pendingData = [[NSMutableData alloc] initWithBytes: (char*) workingData.bytes + offset length:workingData.length - offset];
+					}
+				}
+				return  YES;
+			}
+			else {
+
+				// let the header parser do it's job from now on.
+				NSData * headerData = [NSData dataWithBytesNoCopy: (char*) workingData.bytes + offset length:headerEnd + 2 - offset freeWhenDone:NO];
+				currentHeader = [[MultipartMessageHeader alloc] initWithData:headerData formEncoding:formEncoding];
+
+				if( nil == currentHeader ) {
+					// we've found the data is in wrong format.
+					HTTPLogError(@"MultipartFormDataParser: MultipartFormDataParser: wrong input format, coulnd't get a valid header");
+					return NO;
+				}
+                if( [delegate respondsToSelector:@selector(processStartOfPartWithHeader:)] ) {
+                    [delegate processStartOfPartWithHeader:currentHeader];
+                }
+
+				HTTPLogVerbose(@"MultipartFormDataParser: MultipartFormDataParser: Retrieved part header.");
+			}
+			// skip the two trailing \r\n, in addition to the whole header.
+			offset = headerEnd + 4;	
+		}
+		// after we've got the header, we try to
+		// find the boundary in the data.
+		int contentEnd = [self findContentEnd:workingData fromOffset:offset];
+		
+		if( contentEnd == -1 ) {
+
+			// this case, we didn't find the boundary, so the data is related to the current part.
+			// we leave the sizeToLeavePending amount of bytes to make sure we don't include 
+			// boundary part in processed data.
+			NSUInteger sizeToPass = workingData.length - offset - sizeToLeavePending;
+
+			// if we parse BASE64 encoded data, or Quoted-Printable data, we will make sure we don't break the format
+			int leaveTrailing = [self numberOfBytesToLeavePendingWithData:data length:sizeToPass encoding:currentEncoding];
+			sizeToPass -= leaveTrailing;
+			
+			if( sizeToPass <= 0 ) {
+				// wait for more data!
+				if( offset ) {
+					[pendingData setData:[NSData dataWithBytes:(char*) workingData.bytes + offset length:workingData.length - offset]];
+				}
+				return YES;
+			}
+			// decode the chunk and let the delegate use it (store in a file, for example)
+			NSData* decodedData = [MultipartFormDataParser decodedDataFromData:[NSData dataWithBytesNoCopy:(char*)workingData.bytes + offset length:workingData.length - offset - sizeToLeavePending freeWhenDone:NO] encoding:currentEncoding];
+			
+			if( [delegate respondsToSelector:@selector(processContent:WithHeader:)] ) {
+				HTTPLogVerbose(@"MultipartFormDataParser: Processed %"FMTNSINT" bytes of body",sizeToPass);
+
+				[delegate processContent: decodedData WithHeader:currentHeader];
+			}
+
+			// store the unprocessed data till the next chunks come.
+			[pendingData setData:[NSData dataWithBytes:(char*)workingData.bytes + workingData.length - sizeToLeavePending length:sizeToLeavePending]];
+			return YES;
+		}
+		else {
+
+			// Here we found the boundary.
+			// let the delegate process it, and continue going to the next parts.
+			if( [delegate respondsToSelector:@selector(processContent:WithHeader:)] ) {
+				[delegate processContent:[NSData dataWithBytesNoCopy:(char*) workingData.bytes + offset length:contentEnd - offset freeWhenDone:NO] WithHeader:currentHeader];
+			}
+
+			if( [delegate respondsToSelector:@selector(processEndOfPartWithHeader:)] ){
+				[delegate processEndOfPartWithHeader:currentHeader];
+				HTTPLogVerbose(@"MultipartFormDataParser: End of body part");
+			}
+			currentHeader = nil;
+
+			// set up offset to continue with the remaining data (if any)
+            // cast to int because above comment suggests a small number
+			offset = contentEnd + (int)boundaryData.length;
+			checkForContentEnd = YES;
+			// setting the flag tells the parser to skip all the data till CRLF
+		}
+	}
+    return YES;
+}
+
+
+//-----------------------------------------------------------------
+#pragma mark private methods
+
+- (int) offsetTillNewlineSinceOffset:(int) offset inData:(NSData*) data {
+	char* bytes = (char*) data.bytes;
+	NSUInteger length = data.length;
+	if( offset >= length - 1 ) 
+		return -1;
+
+	while ( *(uint16_t*)(bytes + offset) != 0x0A0D ) {
+		// find the trailing \r\n after the boundary. The boundary line might have any number of whitespaces before CRLF, according to rfc2046
+
+		// in debug, we might also want to know, if the file is somehow misformatted.
+#ifdef DEBUG
+		if( !isspace(*(bytes+offset)) ) {
+			HTTPLogWarn(@"MultipartFormDataParser: Warning, non-whitespace character '%c' between boundary bytes and CRLF in boundary line",*(bytes+offset) );
+		}
+		if( !isspace(*(bytes+offset+1)) ) {
+			HTTPLogWarn(@"MultipartFormDataParser: Warning, non-whitespace character '%c' between boundary bytes and CRLF in boundary line",*(bytes+offset+1) );
+		}
+#endif
+		offset++;
+		if( offset >= length ) {
+			// no endl found within current data
+			return -1;
+		}
+	}
+
+	offset += 2;
+	return offset;
+}
+
+
+- (int) processPreamble:(NSData*) data {
+	int offset = 0;
+	
+	char* boundaryBytes = (char*) boundaryData.bytes + 2; // the first boundary won't have CRLF preceding.
+    char* dataBytes = (char*) data.bytes;
+    NSUInteger boundaryLength = boundaryData.length - 2;
+    NSUInteger dataLength = data.length;
+    
+	// find the boundary without leading CRLF.
+    while( offset < dataLength - boundaryLength +1 ) {
+        int i;
+        for( i = 0;i < boundaryLength; i++ ) {
+            if( boundaryBytes[i] != dataBytes[offset + i] )
+                break;
+        }
+        if( i == boundaryLength ) {
+            break;
+        }
+		offset++;
+    }
+ 	
+	if( offset == dataLength ) {
+		// the end of preamble wasn't found in this chunk
+		NSUInteger sizeToProcess = dataLength - boundaryLength;
+		if( sizeToProcess > 0) {
+			if( [delegate respondsToSelector:@selector(processPreambleData:)] ) {
+				NSData* preambleData = [NSData dataWithBytesNoCopy: (char*) data.bytes length: data.length - offset - boundaryLength freeWhenDone:NO];
+				[delegate processPreambleData:preambleData];
+				HTTPLogVerbose(@"MultipartFormDataParser: processed preamble");
+			}
+			pendingData = [NSMutableData dataWithBytes: data.bytes + data.length - boundaryLength length:boundaryLength];
+		}
+		return -1;
+	}
+	else {
+		if ( offset && [delegate respondsToSelector:@selector(processPreambleData:)] ) {
+			NSData* preambleData = [NSData dataWithBytesNoCopy: (char*) data.bytes length: offset freeWhenDone:NO];
+			[delegate processPreambleData:preambleData];
+		}
+		offset +=boundaryLength;
+		// tells to skip CRLF after the boundary.
+		processedPreamble = YES;
+		waitingForCRLF = YES;
+	}
+	return offset;
+}
+
+
+
+- (int) findHeaderEnd:(NSData*) workingData fromOffset:(int)offset {
+    char* bytes = (char*) workingData.bytes; 
+    NSUInteger inputLength = workingData.length;
+    uint16_t separatorBytes = 0x0A0D;
+
+	while( true ) {
+		if(inputLength < offset + 3 ) {
+			// wait for more data
+			return -1;
+		}
+        if( (*((uint16_t*) (bytes+offset)) == separatorBytes) && (*((uint16_t*) (bytes+offset)+1) == separatorBytes) ) {
+			return offset;
+        }
+        offset++;
+    }
+    return -1;
+}
+
+
+- (int) findContentEnd:(NSData*) data fromOffset:(int) offset {
+    char* boundaryBytes = (char*) boundaryData.bytes;
+    char* dataBytes = (char*) data.bytes;
+    NSUInteger boundaryLength = boundaryData.length;
+    NSUInteger dataLength = data.length;
+    
+    while( offset < dataLength - boundaryLength +1 ) {
+        int i;
+        for( i = 0;i < boundaryLength; i++ ) {
+            if( boundaryBytes[i] != dataBytes[offset + i] )
+                break;
+        }
+        if( i == boundaryLength ) {
+            return offset;
+        }
+		offset++;
+    }
+    return -1;
+}
+
+
+- (int) numberOfBytesToLeavePendingWithData:(NSData*) data length:(int) length encoding:(int) encoding {
+	// If we have BASE64 or Quoted-Printable encoded data, we have to be sure
+	// we don't break the format.
+	int sizeToLeavePending = 0;
+	
+	if( encoding == contentTransferEncoding_base64 ) {	
+		char* bytes = (char*) data.bytes;
+		int i;
+		for( i = length - 1; i > 0; i++ ) {
+			if( * (uint16_t*) (bytes + i) == 0x0A0D ) {
+				break;
+			}
+		}
+		// now we've got to be sure that the length of passed data since last line
+		// is multiplier of 4.
+		sizeToLeavePending = (length - i) & ~0x11; // size to leave pending = length-i - (length-i) %4;
+		return sizeToLeavePending;
+	}
+	
+	if( encoding == contentTransferEncoding_quotedPrintable ) {
+		// we don't pass more less then 3 bytes anyway.
+		if( length <= 2 ) 
+			return length;
+		// check the last bytes to be start of encoded symbol.
+		const char* bytes = data.bytes + length - 2;
+		if( bytes[0] == '=' )
+			return 2;
+		if( bytes[1] == '=' )
+			return 1;
+		return 0;
+	}
+	return 0;
+}
+
+
+//-----------------------------------------------------------------
+#pragma mark decoding
+
+
++ (NSData*) decodedDataFromData:(NSData*) data encoding:(int) encoding {
+	switch (encoding) {
+		case contentTransferEncoding_base64: {
+			return [data base64Decoded]; 
+		} break;
+
+		case contentTransferEncoding_quotedPrintable: {
+			return [self decodedDataFromQuotedPrintableData:data];
+		} break;
+
+		default: {
+			return data;
+		} break;
+	}
+}
+
+
++ (NSData*) decodedDataFromQuotedPrintableData:(NSData *)data {
+//	http://tools.ietf.org/html/rfc2045#section-6.7
+
+	const char hex []  = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', };
+
+	NSMutableData* result = [[NSMutableData alloc] initWithLength:data.length];
+	const char* bytes = (const char*) data.bytes;
+	int count = 0;
+	NSUInteger length = data.length;
+	while( count < length ) {
+		if( bytes[count] == '=' ) {
+			[result appendBytes:bytes length:count];
+			bytes = bytes + count + 1;
+			length -= count + 1;
+			count = 0;
+
+			if( length < 3 ) {
+				HTTPLogWarn(@"MultipartFormDataParser: warning, trailing '=' in quoted printable data");
+			}
+			// soft newline
+			if( bytes[0] == '\r' ) {
+				bytes += 1;
+				if(bytes[1] == '\n' ) {
+					bytes += 2;
+				}
+				continue;
+			}
+			char encodedByte = 0;
+
+			for( int i = 0; i < sizeof(hex); i++ ) {
+				if( hex[i] == bytes[0] ) {
+					encodedByte += i << 4;
+				}
+				if( hex[i] == bytes[1] ) {
+					encodedByte += i;
+				}
+			}
+			[result appendBytes:&encodedByte length:1];
+			bytes += 2;
+		}
+
+#ifdef DEBUG
+		if( (unsigned char) bytes[count] > 126 ) {
+			HTTPLogWarn(@"MultipartFormDataParser: Warning, character with code above 126 appears in quoted printable encoded data");
+		}
+#endif
+		
+		count++;
+	}
+	return result;
+}
+
+
+@end