first commit

CocoaHTTPServer/Categories/DDData.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+@interface NSData (DDData)
+
+- (NSData *)md5Digest;
+
+- (NSData *)sha1Digest;
+
+- (NSString *)hexStringValue;
+
+- (NSString *)base64Encoded;
+- (NSData *)base64Decoded;
+
+@end

CocoaHTTPServer/Categories/DDData.m

@@ -0,0 +1,158 @@
+#import "DDData.h"
+#import <CommonCrypto/CommonDigest.h>
+
+
+@implementation NSData (DDData)
+
+static char encodingTable[64] = {
+'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
+'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
+'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
+'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/' };
+
+- (NSData *)md5Digest
+{
+	unsigned char result[CC_MD5_DIGEST_LENGTH];
+
+    CC_MD5([self bytes], (CC_LONG)[self length], result);
+    return [NSData dataWithBytes:result length:CC_MD5_DIGEST_LENGTH];
+}
+
+- (NSData *)sha1Digest
+{
+	unsigned char result[CC_SHA1_DIGEST_LENGTH];
+
+	CC_SHA1([self bytes], (CC_LONG)[self length], result);
+    return [NSData dataWithBytes:result length:CC_SHA1_DIGEST_LENGTH];
+}
+
+- (NSString *)hexStringValue
+{
+	NSMutableString *stringBuffer = [NSMutableString stringWithCapacity:([self length] * 2)];
+
+    const unsigned char *dataBuffer = [self bytes];
+    int i;
+
+    for (i = 0; i < [self length]; ++i)
+	{
+        [stringBuffer appendFormat:@"%02x", (unsigned int)dataBuffer[i]];
+	}
+
+    return [stringBuffer copy];
+}
+
+- (NSString *)base64Encoded
+{
+	const unsigned char	*bytes = [self bytes];
+	NSMutableString *result = [NSMutableString stringWithCapacity:[self length]];
+	unsigned long ixtext = 0;
+	unsigned long lentext = [self length];
+	long ctremaining = 0;
+	unsigned char inbuf[3], outbuf[4];
+	unsigned short i = 0;
+	unsigned short charsonline = 0, ctcopy = 0;
+	unsigned long ix = 0;
+
+	while( YES )
+	{
+		ctremaining = lentext - ixtext;
+		if( ctremaining <= 0 ) break;
+
+		for( i = 0; i < 3; i++ ) {
+			ix = ixtext + i;
+			if( ix < lentext ) inbuf[i] = bytes[ix];
+			else inbuf [i] = 0;
+		}
+
+		outbuf [0] = (inbuf [0] & 0xFC) >> 2;
+		outbuf [1] = ((inbuf [0] & 0x03) << 4) | ((inbuf [1] & 0xF0) >> 4);
+		outbuf [2] = ((inbuf [1] & 0x0F) << 2) | ((inbuf [2] & 0xC0) >> 6);
+		outbuf [3] = inbuf [2] & 0x3F;
+		ctcopy = 4;
+
+		switch( ctremaining )
+		{
+			case 1:
+				ctcopy = 2;
+				break;
+			case 2:
+				ctcopy = 3;
+				break;
+		}
+
+		for( i = 0; i < ctcopy; i++ )
+			[result appendFormat:@"%c", encodingTable[outbuf[i]]];
+
+		for( i = ctcopy; i < 4; i++ )
+			[result appendString:@"="];
+
+		ixtext += 3;
+		charsonline += 4;
+	}
+
+	return [NSString stringWithString:result];
+}
+
+- (NSData *)base64Decoded
+{
+	const unsigned char	*bytes = [self bytes];
+	NSMutableData *result = [NSMutableData dataWithCapacity:[self length]];
+
+	unsigned long ixtext = 0;
+	unsigned long lentext = [self length];
+	unsigned char ch = 0;
+	unsigned char inbuf[4] = {0, 0, 0, 0};
+	unsigned char outbuf[3] = {0, 0, 0};
+	short i = 0, ixinbuf = 0;
+	BOOL flignore = NO;
+	BOOL flendtext = NO;
+
+	while( YES )
+	{
+		if( ixtext >= lentext ) break;
+		ch = bytes[ixtext++];
+		flignore = NO;
+
+		if( ( ch >= 'A' ) && ( ch <= 'Z' ) ) ch = ch - 'A';
+		else if( ( ch >= 'a' ) && ( ch <= 'z' ) ) ch = ch - 'a' + 26;
+		else if( ( ch >= '0' ) && ( ch <= '9' ) ) ch = ch - '0' + 52;
+		else if( ch == '+' ) ch = 62;
+		else if( ch == '=' ) flendtext = YES;
+		else if( ch == '/' ) ch = 63;
+		else flignore = YES;
+
+		if( ! flignore )
+		{
+			short ctcharsinbuf = 3;
+			BOOL flbreak = NO;
+
+			if( flendtext )
+			{
+				if( ! ixinbuf ) break;
+				if( ( ixinbuf == 1 ) || ( ixinbuf == 2 ) ) ctcharsinbuf = 1;
+				else ctcharsinbuf = 2;
+				ixinbuf = 3;
+				flbreak = YES;
+			}
+
+			inbuf [ixinbuf++] = ch;
+
+			if( ixinbuf == 4 )
+			{
+				ixinbuf = 0;
+				outbuf [0] = ( inbuf[0] << 2 ) | ( ( inbuf[1] & 0x30) >> 4 );
+				outbuf [1] = ( ( inbuf[1] & 0x0F ) << 4 ) | ( ( inbuf[2] & 0x3C ) >> 2 );
+				outbuf [2] = ( ( inbuf[2] & 0x03 ) << 6 ) | ( inbuf[3] & 0x3F );
+
+				for( i = 0; i < ctcharsinbuf; i++ )
+					[result appendBytes:&outbuf[i] length:1];
+			}
+
+			if( flbreak )  break;
+		}
+	}
+
+	return [NSData dataWithData:result];
+}
+
+@end

CocoaHTTPServer/Categories/DDNumber.h

@@ -0,0 +1,12 @@
+#import <Foundation/Foundation.h>
+
+
+@interface NSNumber (DDNumber)
+
++ (BOOL)parseString:(NSString *)str intoSInt64:(SInt64 *)pNum;
++ (BOOL)parseString:(NSString *)str intoUInt64:(UInt64 *)pNum;
+
++ (BOOL)parseString:(NSString *)str intoNSInteger:(NSInteger *)pNum;
++ (BOOL)parseString:(NSString *)str intoNSUInteger:(NSUInteger *)pNum;
+
+@end

CocoaHTTPServer/Categories/DDNumber.m

@@ -0,0 +1,88 @@
+#import "DDNumber.h"
+
+
+@implementation NSNumber (DDNumber)
+
++ (BOOL)parseString:(NSString *)str intoSInt64:(SInt64 *)pNum
+{
+	if(str == nil)
+	{
+		*pNum = 0;
+		return NO;
+	}
+
+	errno = 0;
+
+	// On both 32-bit and 64-bit machines, long long = 64 bit
+
+	*pNum = strtoll([str UTF8String], NULL, 10);
+
+	if(errno != 0)
+		return NO;
+	else
+		return YES;
+}
+
++ (BOOL)parseString:(NSString *)str intoUInt64:(UInt64 *)pNum
+{
+	if(str == nil)
+	{
+		*pNum = 0;
+		return NO;
+	}
+
+	errno = 0;
+
+	// On both 32-bit and 64-bit machines, unsigned long long = 64 bit
+
+	*pNum = strtoull([str UTF8String], NULL, 10);
+
+	if(errno != 0)
+		return NO;
+	else
+		return YES;
+}
+
++ (BOOL)parseString:(NSString *)str intoNSInteger:(NSInteger *)pNum
+{
+	if(str == nil)
+	{
+		*pNum = 0;
+		return NO;
+	}
+
+	errno = 0;
+
+	// On LP64, NSInteger = long = 64 bit
+	// Otherwise, NSInteger = int = long = 32 bit
+
+	*pNum = strtol([str UTF8String], NULL, 10);
+
+	if(errno != 0)
+		return NO;
+	else
+		return YES;
+}
+
++ (BOOL)parseString:(NSString *)str intoNSUInteger:(NSUInteger *)pNum
+{
+	if(str == nil)
+	{
+		*pNum = 0;
+		return NO;
+	}
+
+	errno = 0;
+
+	// On LP64, NSUInteger = unsigned long = 64 bit
+	// Otherwise, NSUInteger = unsigned int = unsigned long = 32 bit
+
+	*pNum = strtoul([str UTF8String], NULL, 10);
+
+	if(errno != 0)
+		return NO;
+	else
+		return YES;
+}
+
+@end

CocoaHTTPServer/Categories/DDRange.h

@@ -0,0 +1,56 @@
+/**
+ * DDRange is the functional equivalent of a 64 bit NSRange.
+ * The HTTP Server is designed to support very large files.
+ * On 32 bit architectures (ppc, i386) NSRange uses unsigned 32 bit integers.
+ * This only supports a range of up to 4 gigabytes.
+ * By defining our own variant, we can support a range up to 16 exabytes.
+ * 
+ * All effort is given such that DDRange functions EXACTLY the same as NSRange.
+**/
+
+#import <Foundation/NSValue.h>
+#import <Foundation/NSObjCRuntime.h>
+
+@class NSString;
+
+typedef struct _DDRange {
+    UInt64 location;
+    UInt64 length;
+} DDRange;
+
+typedef DDRange *DDRangePointer;
+
+NS_INLINE DDRange DDMakeRange(UInt64 loc, UInt64 len) {
+    DDRange r;
+    r.location = loc;
+    r.length = len;
+    return r;
+}
+
+NS_INLINE UInt64 DDMaxRange(DDRange range) {
+    return (range.location + range.length);
+}
+
+NS_INLINE BOOL DDLocationInRange(UInt64 loc, DDRange range) {
+    return (loc - range.location < range.length);
+}
+
+NS_INLINE BOOL DDEqualRanges(DDRange range1, DDRange range2) {
+    return ((range1.location == range2.location) && (range1.length == range2.length));
+}
+
+FOUNDATION_EXPORT DDRange DDUnionRange(DDRange range1, DDRange range2);
+FOUNDATION_EXPORT DDRange DDIntersectionRange(DDRange range1, DDRange range2);
+FOUNDATION_EXPORT NSString *DDStringFromRange(DDRange range);
+FOUNDATION_EXPORT DDRange DDRangeFromString(NSString *aString);
+
+NSInteger DDRangeCompare(DDRangePointer pDDRange1, DDRangePointer pDDRange2);
+
+@interface NSValue (NSValueDDRangeExtensions)
+
++ (NSValue *)valueWithDDRange:(DDRange)range;
+- (DDRange)ddrangeValue;
+
+- (NSInteger)ddrangeCompare:(NSValue *)ddrangeValue;
+
+@end