appjam 0.1.8.8 → 0.1.8.9

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Extensions/WebDAV/DAVConnection.h

@@ -0,0 +1,7 @@
+#import "HTTPConnection.h"
+
+@interface DAVConnection : HTTPConnection {
+	id requestContentBody;
+  NSOutputStream* requestContentStream;
+}
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Extensions/WebDAV/DAVConnection.m

@@ -0,0 +1,160 @@
+#import "DAVConnection.h"
+#import "HTTPMessage.h"
+#import "HTTPFileResponse.h"
+#import "HTTPAsyncFileResponse.h"
+#import "PUTResponse.h"
+#import "DELETEResponse.h"
+#import "DAVResponse.h"
+#import "HTTPLogging.h"
+
+#define HTTP_BODY_MAX_MEMORY_SIZE (1024 * 1024)
+#define HTTP_ASYNC_FILE_RESPONSE_THRESHOLD (16 * 1024 * 1024)
+
+static const int httpLogLevel = HTTP_LOG_LEVEL_WARN;
+
+@implementation DAVConnection
+
+- (void) dealloc {
+  [requestContentStream close];
+  
+}
+
+- (BOOL) supportsMethod:(NSString*)method atPath:(NSString*)path {
+  // HTTPFileResponse & HTTPAsyncFileResponse
+  if ([method isEqualToString:@"GET"]) return YES;
+	if ([method isEqualToString:@"HEAD"]) return YES;
+  
+  // PUTResponse
+  if ([method isEqualToString:@"PUT"]) return YES;
+  
+  // DELETEResponse
+  if ([method isEqualToString:@"DELETE"]) return YES;
+	
+  // DAVResponse
+  if ([method isEqualToString:@"OPTIONS"]) return YES;
+  if ([method isEqualToString:@"PROPFIND"]) return YES;
+  if ([method isEqualToString:@"MKCOL"]) return YES;
+  if ([method isEqualToString:@"MOVE"]) return YES;
+  if ([method isEqualToString:@"COPY"]) return YES;
+  if ([method isEqualToString:@"LOCK"]) return YES;
+  if ([method isEqualToString:@"UNLOCK"]) return YES;
+  
+  return NO;
+}
+
+- (BOOL) expectsRequestBodyFromMethod:(NSString*)method atPath:(NSString*)path {
+  // PUTResponse
+  if ([method isEqualToString:@"PUT"]) {
+    return YES;
+	}
+  
+  // DAVResponse
+  if ([method isEqual:@"PROPFIND"] || [method isEqual:@"MKCOL"]) {
+    return [request headerField:@"Content-Length"] ? YES : NO;
+  }
+  if ([method isEqual:@"LOCK"]) {
+    return YES;
+  }
+  
+  return NO;
+}
+
+- (void) prepareForBodyWithSize:(UInt64)contentLength {
+  NSAssert(requestContentStream == nil, @"requestContentStream should be nil");
+  NSAssert(requestContentBody == nil, @"requestContentBody should be nil");
+  
+  if (contentLength > HTTP_BODY_MAX_MEMORY_SIZE) {
+    requestContentBody = [[NSTemporaryDirectory() stringByAppendingString:[[NSProcessInfo processInfo] globallyUniqueString]] copy];
+    requestContentStream = [[NSOutputStream alloc] initToFileAtPath:requestContentBody append:NO];
+    [requestContentStream open];
+  } else {
+    requestContentBody = [[NSMutableData alloc] initWithCapacity:(NSUInteger)contentLength];
+    requestContentStream = nil;
+  }
+}
+
+- (void) processBodyData:(NSData*)postDataChunk {
+	NSAssert(requestContentBody != nil, @"requestContentBody should not be nil");
+  if (requestContentStream) {
+    [requestContentStream write:[postDataChunk bytes] maxLength:[postDataChunk length]];
+  } else {
+    [(NSMutableData*)requestContentBody appendData:postDataChunk];
+  }
+}
+
+- (void) finishBody {
+  NSAssert(requestContentBody != nil, @"requestContentBody should not be nil");
+  if (requestContentStream) {
+    [requestContentStream close];
+    requestContentStream = nil;
+  }
+}
+
+- (void)finishResponse {
+  NSAssert(requestContentStream == nil, @"requestContentStream should be nil");
+  requestContentBody = nil;
+  
+  [super finishResponse];
+}
+
+- (NSObject<HTTPResponse>*) httpResponseForMethod:(NSString*)method URI:(NSString*)path {
+  if ([method isEqualToString:@"HEAD"] || [method isEqualToString:@"GET"]) {
+    NSString* filePath = [self filePathForURI:path allowDirectory:NO];
+    if (filePath) {
+      NSDictionary* fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:NULL];
+      if (fileAttributes) {
+        if ([[fileAttributes objectForKey:NSFileSize] unsignedLongLongValue] > HTTP_ASYNC_FILE_RESPONSE_THRESHOLD) {
+          return [[HTTPAsyncFileResponse alloc] initWithFilePath:filePath forConnection:self];
+        } else {
+          return [[HTTPFileResponse alloc] initWithFilePath:filePath forConnection:self];
+        }
+      }
+    }
+  }
+	
+	if ([method isEqualToString:@"PUT"]) {
+    NSString* filePath = [self filePathForURI:path allowDirectory:YES];
+    if (filePath) {
+      if ([requestContentBody isKindOfClass:[NSString class]]) {
+        return [[PUTResponse alloc] initWithFilePath:filePath headers:[request allHeaderFields] bodyFile:requestContentBody];
+      } else if ([requestContentBody isKindOfClass:[NSData class]]) {
+        return [[PUTResponse alloc] initWithFilePath:filePath headers:[request allHeaderFields] bodyData:requestContentBody];
+      } else {
+        HTTPLogError(@"Internal error");
+      }
+    }
+  }
+	
+	if ([method isEqualToString:@"DELETE"]) {
+    NSString* filePath = [self filePathForURI:path allowDirectory:YES];
+    if (filePath) {
+      return [[DELETEResponse alloc] initWithFilePath:filePath];
+    }
+  }
+  
+  if ([method isEqualToString:@"OPTIONS"] || [method isEqualToString:@"PROPFIND"] || [method isEqualToString:@"MKCOL"] ||
+    [method isEqualToString:@"MOVE"] || [method isEqualToString:@"COPY"] || [method isEqualToString:@"LOCK"] || [method isEqualToString:@"UNLOCK"]) {
+    NSString* filePath = [self filePathForURI:path allowDirectory:YES];
+    if (filePath) {
+      NSString* rootPath = [config documentRoot];
+      NSString* resourcePath = [filePath substringFromIndex:([rootPath length] + 1)];
+      if (requestContentBody) {
+        if ([requestContentBody isKindOfClass:[NSString class]]) {
+          requestContentBody = [NSData dataWithContentsOfFile:requestContentBody];
+        } else if (![requestContentBody isKindOfClass:[NSData class]]) {
+          HTTPLogError(@"Internal error");
+          return nil;
+        }
+      }
+      return [[DAVResponse alloc] initWithMethod:method
+                                          headers:[request allHeaderFields]
+                                         bodyData:requestContentBody
+                                     resourcePath:resourcePath
+                                         rootPath:rootPath];
+    }
+  }
+  
+  return nil;
+}
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Extensions/WebDAV/DAVResponse.h

@@ -0,0 +1,11 @@
+#import "HTTPResponse.h"
+
+@interface DAVResponse : NSObject <HTTPResponse> {
+@private
+  UInt64 _offset;
+  NSMutableDictionary* _headers;
+  NSData* _data;
+  NSInteger _status;
+}
+- (id) initWithMethod:(NSString*)method headers:(NSDictionary*)headers bodyData:(NSData*)body resourcePath:(NSString*)resourcePath rootPath:(NSString*)rootPath;
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Extensions/WebDAV/DAVResponse.m

@@ -0,0 +1,372 @@
+#import <libxml/parser.h>
+
+#import "DAVResponse.h"
+#import "HTTPLogging.h"
+
+// WebDAV specifications: http://webdav.org/specs/rfc4918.html
+
+typedef enum {
+  kDAVProperty_ResourceType = (1 << 0),
+  kDAVProperty_CreationDate = (1 << 1),
+  kDAVProperty_LastModified = (1 << 2),
+  kDAVProperty_ContentLength = (1 << 3),
+  kDAVAllProperties = kDAVProperty_ResourceType | kDAVProperty_CreationDate | kDAVProperty_LastModified | kDAVProperty_ContentLength
+} DAVProperties;
+
+#define kXMLParseOptions (XML_PARSE_NONET | XML_PARSE_RECOVER | XML_PARSE_NOBLANKS | XML_PARSE_COMPACT | XML_PARSE_NOWARNING | XML_PARSE_NOERROR)
+
+static const int httpLogLevel = HTTP_LOG_LEVEL_WARN;
+
+@implementation DAVResponse
+
+static void _AddPropertyResponse(NSString* itemPath, NSString* resourcePath, DAVProperties properties, NSMutableString* xmlString) {
+  CFStringRef escapedPath = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, (__bridge CFStringRef)resourcePath, NULL,
+                                                                    CFSTR("<&>?+"), kCFStringEncodingUTF8);
+  if (escapedPath) {
+    NSDictionary* attributes = [[NSFileManager defaultManager] attributesOfItemAtPath:itemPath error:NULL];
+    BOOL isDirectory = [[attributes fileType] isEqualToString:NSFileTypeDirectory];
+    [xmlString appendString:@"<D:response>"];
+      [xmlString appendFormat:@"<D:href>%@</D:href>", escapedPath];
+      [xmlString appendString:@"<D:propstat>"];
+        [xmlString appendString:@"<D:prop>"];
+        
+          if (properties & kDAVProperty_ResourceType) {
+            if (isDirectory) {
+              [xmlString appendString:@"<D:resourcetype><D:collection/></D:resourcetype>"];
+            } else {
+              [xmlString appendString:@"<D:resourcetype/>"];
+            }
+          }
+          
+          if ((properties & kDAVProperty_CreationDate) && [attributes objectForKey:NSFileCreationDate]) {
+            NSDateFormatter* formatter = [[NSDateFormatter alloc] init];
+            formatter.locale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];
+            formatter.timeZone = [NSTimeZone timeZoneWithName:@"GMT"];
+            formatter.dateFormat = @"yyyy-MM-dd'T'HH:mm:ss'+00:00'";
+            [xmlString appendFormat:@"<D:creationdate>%@</D:creationdate>", [formatter stringFromDate:[attributes fileCreationDate]]];
+          }
+          
+          if ((properties & kDAVProperty_LastModified) && [attributes objectForKey:NSFileModificationDate]) {
+            NSDateFormatter* formatter = [[NSDateFormatter alloc] init];
+            formatter.locale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];
+            formatter.timeZone = [NSTimeZone timeZoneWithName:@"GMT"];
+            formatter.dateFormat = @"EEE', 'd' 'MMM' 'yyyy' 'HH:mm:ss' GMT'";
+            [xmlString appendFormat:@"<D:getlastmodified>%@</D:getlastmodified>", [formatter stringFromDate:[attributes fileModificationDate]]];
+          }
+          
+          if ((properties & kDAVProperty_ContentLength) && !isDirectory && [attributes objectForKey:NSFileSize]) {
+            [xmlString appendFormat:@"<D:getcontentlength>%qu</D:getcontentlength>", [attributes fileSize]];
+          }
+        
+        [xmlString appendString:@"</D:prop>"];
+        [xmlString appendString:@"<D:status>HTTP/1.1 200 OK</D:status>"];
+      [xmlString appendString:@"</D:propstat>"];
+    [xmlString appendString:@"</D:response>\n"];
+    CFRelease(escapedPath);
+  }
+}
+
+static xmlNodePtr _XMLChildWithName(xmlNodePtr child, const xmlChar* name) {
+  while (child) {
+    if ((child->type == XML_ELEMENT_NODE) && !xmlStrcmp(child->name, name)) {
+      return child;
+    }
+    child = child->next;
+  }
+  return NULL;
+}
+
+- (id) initWithMethod:(NSString*)method headers:(NSDictionary*)headers bodyData:(NSData*)body resourcePath:(NSString*)resourcePath rootPath:(NSString*)rootPath {
+  if ((self = [super init])) {
+    _status = 200;
+    _headers = [[NSMutableDictionary alloc] init];
+    
+    // 10.1 DAV Header
+    if ([method isEqualToString:@"OPTIONS"]) {
+      if ([[headers objectForKey:@"User-Agent"] hasPrefix:@"WebDAVFS/"]) {  // Mac OS X WebDAV support
+        [_headers setObject:@"1, 2" forKey:@"DAV"];
+      } else {
+        [_headers setObject:@"1" forKey:@"DAV"];
+      }
+    }
+    
+    // 9.1 PROPFIND Method
+    if ([method isEqualToString:@"PROPFIND"]) {
+      NSInteger depth;
+      NSString* depthHeader = [headers objectForKey:@"Depth"];
+      if ([depthHeader isEqualToString:@"0"]) {
+        depth = 0;
+      } else if ([depthHeader isEqualToString:@"1"]) {
+        depth = 1;
+      } else {
+        HTTPLogError(@"Unsupported DAV depth \"%@\"", depthHeader);
+        return nil;
+      }
+      
+      DAVProperties properties = 0;
+      xmlDocPtr document = xmlReadMemory(body.bytes, (int)body.length, NULL, NULL, kXMLParseOptions);
+      if (document) {
+        xmlNodePtr node = _XMLChildWithName(document->children, (const xmlChar*)"propfind");
+        if (node) {
+          node = _XMLChildWithName(node->children, (const xmlChar*)"prop");
+        }
+        if (node) {
+          node = node->children;
+          while (node) {
+            if (!xmlStrcmp(node->name, (const xmlChar*)"resourcetype")) {
+              properties |= kDAVProperty_ResourceType;
+            } else if (!xmlStrcmp(node->name, (const xmlChar*)"creationdate")) {
+              properties |= kDAVProperty_CreationDate;
+            } else if (!xmlStrcmp(node->name, (const xmlChar*)"getlastmodified")) {
+              properties |= kDAVProperty_LastModified;
+            } else if (!xmlStrcmp(node->name, (const xmlChar*)"getcontentlength")) {
+              properties |= kDAVProperty_ContentLength;
+            } else {
+              HTTPLogWarn(@"Unknown DAV property requested \"%s\"", node->name);
+            }
+            node = node->next;
+          }
+        } else {
+          HTTPLogWarn(@"HTTP Server: Invalid DAV properties\n%@", [[NSString alloc] initWithData:body encoding:NSUTF8StringEncoding]);
+        }
+        xmlFreeDoc(document);
+      }
+      if (!properties) {
+        properties = kDAVAllProperties;
+      }
+      
+      NSString* basePath = [rootPath stringByAppendingPathComponent:resourcePath];
+      if (![basePath hasPrefix:rootPath] || ![[NSFileManager defaultManager] fileExistsAtPath:basePath]) {
+        return nil;
+      }
+      
+      NSMutableString* xmlString = [NSMutableString stringWithString:@"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"];
+      [xmlString appendString:@"<D:multistatus xmlns:D=\"DAV:\">\n"];
+      if (![resourcePath hasPrefix:@"/"]) {
+        resourcePath = [@"/" stringByAppendingString:resourcePath];
+      }
+      _AddPropertyResponse(basePath, resourcePath, properties, xmlString);
+      if (depth == 1) {
+        if (![resourcePath hasSuffix:@"/"]) {
+          resourcePath = [resourcePath stringByAppendingString:@"/"];
+        }
+        NSDirectoryEnumerator* enumerator = [[NSFileManager defaultManager] enumeratorAtPath:basePath];
+        NSString* path;
+        while ((path = [enumerator nextObject])) {
+          _AddPropertyResponse([basePath stringByAppendingPathComponent:path], [resourcePath stringByAppendingString:path], properties, xmlString);
+          [enumerator skipDescendents];
+        }
+      }
+      [xmlString appendString:@"</D:multistatus>"];
+      
+      [_headers setObject:@"application/xml; charset=\"utf-8\"" forKey:@"Content-Type"];
+      _data = [xmlString dataUsingEncoding:NSUTF8StringEncoding];
+      _status = 207;
+    }
+    
+    // 9.3 MKCOL Method
+    if ([method isEqualToString:@"MKCOL"]) {
+      NSString* path = [rootPath stringByAppendingPathComponent:resourcePath];
+      if (![path hasPrefix:rootPath]) {
+        return nil;
+      }
+      
+      if (![[NSFileManager defaultManager] fileExistsAtPath:[path stringByDeletingLastPathComponent]]) {
+        HTTPLogError(@"Missing intermediate collection(s) at \"%@\"", path);
+        _status = 409;
+      } else if (![[NSFileManager defaultManager] createDirectoryAtPath:path withIntermediateDirectories:NO attributes:nil error:NULL]) {
+        HTTPLogError(@"Failed creating collection at \"%@\"", path);
+        _status = 405;
+      }
+    }
+    
+    // 9.8 COPY Method
+    // 9.9 MOVE Method
+    if ([method isEqualToString:@"MOVE"] || [method isEqualToString:@"COPY"]) {
+      if ([method isEqualToString:@"COPY"] && ![[headers objectForKey:@"Depth"] isEqualToString:@"infinity"]) {
+        HTTPLogError(@"Unsupported DAV depth \"%@\"", [headers objectForKey:@"Depth"]);
+        return nil;
+      }
+      
+      NSString* sourcePath = [rootPath stringByAppendingPathComponent:resourcePath];
+      if (![sourcePath hasPrefix:rootPath] || ![[NSFileManager defaultManager] fileExistsAtPath:sourcePath]) {
+        return nil;
+      }
+      
+      NSString* destination = [headers objectForKey:@"Destination"];
+      NSRange range = [destination rangeOfString:[headers objectForKey:@"Host"]];
+      if (range.location == NSNotFound) {
+        return nil;
+      }
+      NSString* destinationPath = [rootPath stringByAppendingPathComponent:
+        [[destination substringFromIndex:(range.location + range.length)] stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding]];
+      if (![destinationPath hasPrefix:rootPath] || [[NSFileManager defaultManager] fileExistsAtPath:destinationPath]) {
+        return nil;
+      }
+      
+      BOOL isDirectory;
+      if (![[NSFileManager defaultManager] fileExistsAtPath:[destinationPath stringByDeletingLastPathComponent] isDirectory:&isDirectory] || !isDirectory) {
+        HTTPLogError(@"Invalid destination path \"%@\"", destinationPath);
+        _status = 409;
+      } else {
+        BOOL existing = [[NSFileManager defaultManager] fileExistsAtPath:destinationPath];
+        if (existing && [[headers objectForKey:@"Overwrite"] isEqualToString:@"F"]) {
+          HTTPLogError(@"Pre-existing destination path \"%@\"", destinationPath);
+          _status = 412;
+        } else {
+          if ([method isEqualToString:@"COPY"]) {
+            if ([[NSFileManager defaultManager] copyItemAtPath:sourcePath toPath:destinationPath error:NULL]) {
+              _status = existing ? 204 : 201;
+            } else {
+              HTTPLogError(@"Failed copying \"%@\" to \"%@\"", sourcePath, destinationPath);
+              _status = 403;
+            }
+          } else {
+            if ([[NSFileManager defaultManager] moveItemAtPath:sourcePath toPath:destinationPath error:NULL]) {
+              _status = existing ? 204 : 201;
+            } else {
+              HTTPLogError(@"Failed moving \"%@\" to \"%@\"", sourcePath, destinationPath);
+              _status = 403;
+            }
+          }
+        }
+      }
+    }
+    
+    // 9.10 LOCK Method - TODO: Actually lock the resource
+    if ([method isEqualToString:@"LOCK"]) {
+      NSString* path = [rootPath stringByAppendingPathComponent:resourcePath];
+      if (![path hasPrefix:rootPath]) {
+        return nil;
+      }
+      
+      NSString* depth = [headers objectForKey:@"Depth"];
+      NSString* scope = nil;
+      NSString* type = nil;
+      NSString* owner = nil;
+      NSString* token = nil;
+      xmlDocPtr document = xmlReadMemory(body.bytes, (int)body.length, NULL, NULL, kXMLParseOptions);
+      if (document) {
+        xmlNodePtr node = _XMLChildWithName(document->children, (const xmlChar*)"lockinfo");
+        if (node) {
+          xmlNodePtr scopeNode = _XMLChildWithName(node->children, (const xmlChar*)"lockscope");
+          if (scopeNode && scopeNode->children && scopeNode->children->name) {
+            scope = [NSString stringWithUTF8String:(const char*)scopeNode->children->name];
+          }
+          xmlNodePtr typeNode = _XMLChildWithName(node->children, (const xmlChar*)"locktype");
+          if (typeNode && typeNode->children && typeNode->children->name) {
+            type = [NSString stringWithUTF8String:(const char*)typeNode->children->name];
+          }
+          xmlNodePtr ownerNode = _XMLChildWithName(node->children, (const xmlChar*)"owner");
+          if (ownerNode) {
+            ownerNode = _XMLChildWithName(ownerNode->children, (const xmlChar*)"href");
+            if (ownerNode && ownerNode->children && ownerNode->children->content) {
+              owner = [NSString stringWithUTF8String:(const char*)ownerNode->children->content];
+            }
+          }
+        } else {
+          HTTPLogWarn(@"HTTP Server: Invalid DAV properties\n%@", [[NSString alloc] initWithData:body encoding:NSUTF8StringEncoding]);
+        }
+        xmlFreeDoc(document);
+      } else {
+		  // No body, see if they're trying to refresh an existing lock.  If so, then just fake up the scope, type and depth so we fall
+		  // into the lock create case.
+		  NSString* lockToken;
+		  if ((lockToken = [headers objectForKey:@"If"]) != nil) {
+			  scope = @"exclusive";
+			  type = @"write";
+			  depth = @"0";
+			  token = [lockToken stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"(<>)"]];
+		  }
+	  }
+      if ([scope isEqualToString:@"exclusive"] && [type isEqualToString:@"write"] && [depth isEqualToString:@"0"] &&
+        ([[NSFileManager defaultManager] fileExistsAtPath:path] || [[NSData data] writeToFile:path atomically:YES])) {
+        NSString* timeout = [headers objectForKey:@"Timeout"];
+		if (!token) {
+          CFUUIDRef uuid = CFUUIDCreate(kCFAllocatorDefault);
+          NSString *uuidStr = (__bridge_transfer NSString *)CFUUIDCreateString(kCFAllocatorDefault, uuid);
+          token = [NSString stringWithFormat:@"urn:uuid:%@", uuidStr];
+          CFRelease(uuid);
+		}
+        
+        NSMutableString* xmlString = [NSMutableString stringWithString:@"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"];
+        [xmlString appendString:@"<D:prop xmlns:D=\"DAV:\">\n"];
+        [xmlString appendString:@"<D:lockdiscovery>\n<D:activelock>\n"];
+        [xmlString appendFormat:@"<D:locktype><D:%@/></D:locktype>\n", type];
+        [xmlString appendFormat:@"<D:lockscope><D:%@/></D:lockscope>\n", scope];
+        [xmlString appendFormat:@"<D:depth>%@</D:depth>\n", depth];
+        if (owner) {
+          [xmlString appendFormat:@"<D:owner><D:href>%@</D:href></D:owner>\n", owner];
+        }
+        if (timeout) {
+          [xmlString appendFormat:@"<D:timeout>%@</D:timeout>\n", timeout];
+        }
+        [xmlString appendFormat:@"<D:locktoken><D:href>%@</D:href></D:locktoken>\n", token];
+		NSString* lockroot = [@"http://" stringByAppendingString:[[headers objectForKey:@"Host"] stringByAppendingString:[@"/" stringByAppendingString:resourcePath]]];
+        [xmlString appendFormat:@"<D:lockroot><D:href>%@</D:href></D:lockroot>\n", lockroot];
+        [xmlString appendString:@"</D:activelock>\n</D:lockdiscovery>\n"];
+        [xmlString appendString:@"</D:prop>"];
+        
+        [_headers setObject:@"application/xml; charset=\"utf-8\"" forKey:@"Content-Type"];
+        _data = [xmlString dataUsingEncoding:NSUTF8StringEncoding];
+        _status = 200;
+        HTTPLogVerbose(@"Pretending to lock \"%@\"", resourcePath);
+      } else {
+        HTTPLogError(@"Locking request \"%@/%@/%@\" for \"%@\" is not allowed", scope, type, depth, resourcePath);
+        _status = 403;
+      }
+    }
+    
+    // 9.11 UNLOCK Method - TODO: Actually unlock the resource
+    if ([method isEqualToString:@"UNLOCK"]) {
+      NSString* path = [rootPath stringByAppendingPathComponent:resourcePath];
+      if (![path hasPrefix:rootPath] || ![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+        return nil;
+      }
+      
+      NSString* token = [headers objectForKey:@"Lock-Token"];
+      _status = token ? 204 : 400;
+      HTTPLogVerbose(@"Pretending to unlock \"%@\"", resourcePath);
+    }
+    
+  }
+  return self;
+}
+
+
+- (UInt64) contentLength {
+  return _data ? _data.length : 0;
+}
+
+- (UInt64) offset {
+  return _offset;
+}
+
+- (void) setOffset:(UInt64)offset {
+  _offset = offset;
+}
+
+- (NSData*) readDataOfLength:(NSUInteger)lengthParameter {
+  if (_data) {
+    NSUInteger remaining = _data.length - (NSUInteger)_offset;
+    NSUInteger length = lengthParameter < remaining ? lengthParameter : remaining;
+    void* bytes = (void*)(_data.bytes + _offset);
+    _offset += length;
+    return [NSData dataWithBytesNoCopy:bytes length:length freeWhenDone:NO];
+  }
+  return nil;
+}
+
+- (BOOL) isDone {
+  return _data ? _offset == _data.length : YES;
+}
+
+- (NSInteger) status {
+  return _status;
+}
+
+- (NSDictionary*) httpHeaders {
+  return _headers;
+}
+
+@end