开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > iPhone > 查看源码
HTTPConnection.m.svn-base
资源名称：iPhoneHTTPServer3.zip　[点击查看]
上传用户：kc0325
上传日期：2020-06-20
资源大小：204k
文件大小：54k
源码类别：

iPhone

开发平台：

Objective-C

HTTPConnection.m.svn-base：源码内容
  1. #import "AsyncSocket.h"
  2. #import "HTTPServer.h"
  3. #import "HTTPConnection.h"
  4. #import "HTTPResponse.h"
  5. #import "HTTPAuthenticationRequest.h"
  6. #import "DDNumber.h"
  7. #import "DDRange.h"
  8. #import "DDData.h"
  10. // Define chunk size used to read in data for responses
  11. // This is how much data will be read from disk into RAM at a time
  12. #if TARGET_OS_IPHONE
  13.   #define READ_CHUNKSIZE  (1024 * 128)
  14. #else
  15.   #define READ_CHUNKSIZE  (1024 * 512)
  16. #endif
  18. // Define chunk size used to read in POST upload data
  19. #if TARGET_OS_IPHONE
  20.   #define POST_CHUNKSIZE  (1024 * 32)
  21. #else
  22.   #define POST_CHUNKSIZE  (1024 * 128)
  23. #endif
  25. // Define the various timeouts (in seconds) for various parts of the HTTP process
  26. #define READ_TIMEOUT          -1
  27. #define WRITE_HEAD_TIMEOUT    30
  28. #define WRITE_BODY_TIMEOUT    -1
  29. #define WRITE_ERROR_TIMEOUT   30
  30. #define NONCE_TIMEOUT        300
  32. // Define the various limits
  33. // LIMIT_MAX_HEADER_LINE_LENGTH: Max length (in bytes) of any single line in a header (including rn)
  34. // LIMIT_MAX_HEADER_LINES      : Max number of lines in a single header (including first GET line)
  35. #define LIMIT_MAX_HEADER_LINE_LENGTH  8190
  36. #define LIMIT_MAX_HEADER_LINES         100
  38. // Define the various tags we'll use to differentiate what it is we're currently doing
  39. #define HTTP_REQUEST_HEADER                15
  40. #define HTTP_REQUEST_BODY                  16
  41. #define HTTP_PARTIAL_RESPONSE              24
  42. #define HTTP_PARTIAL_RESPONSE_HEADER       25
  43. #define HTTP_PARTIAL_RESPONSE_BODY         26
  44. #define HTTP_PARTIAL_RANGE_RESPONSE_BODY   28
  45. #define HTTP_PARTIAL_RANGES_RESPONSE_BODY  29
  46. #define HTTP_RESPONSE                      30
  47. #define HTTP_FINAL_RESPONSE                45
  49. // A quick note about the tags:
  50. // 
  51. // The HTTP_RESPONSE and HTTP_FINAL_RESPONSE are designated tags signalling that the response is completely sent.
  52. // That is, in the onSocket:didWriteDataWithTag: method, if the tag is HTTP_RESPONSE or HTTP_FINAL_RESPONSE,
  53. // it is assumed that the response is now completely sent.
  54. // Use HTTP_RESPONSE if it's the end a response, and you want to start reading more requests afterwards.
  55. // Use HTTP_FINAL_RESPONSE if you wish to terminate the connection after sending the response.
  56. // 
  57. // If you are sending multiple data segments in a custom response, make sure that only the last segment has
  58. // the HTTP_RESPONSE tag. For all other segments prior to the last segment use HTTP_PARTIAL_RESPONSE, or some other
  59. // tag of your own invention.
  61. @interface HTTPConnection (PrivateAPI)
  62. - (CFHTTPMessageRef)prepareUniRangeResponse:(UInt64)contentLength;
  63. - (CFHTTPMessageRef)prepareMultiRangeResponse:(UInt64)contentLength;
  64. @end
  66. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  67. #pragma mark -
  68. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  70. @implementation HTTPConnection
  72. static NSMutableArray *recentNonces;
  74. /**
  75.  * This method is automatically called (courtesy of Cocoa) before the first instantiation of this class.
  76.  * We use it to initialize any static variables.
  77. **/
  78. + (void)initialize
  79. {
  80. static BOOL initialized = NO;
  81. if(!initialized)
  82. {
  83. // Initialize class variables
  84. recentNonces = [[NSMutableArray alloc] initWithCapacity:5];
  86. initialized = YES;
  87. }
  88. }
  90. /**
  91.  * This method is designed to be called by a scheduled timer, and will remove a nonce from the recent nonce list.
  92.  * The nonce to remove should be set as the timer's userInfo.
  93. **/
  94. + (void)removeRecentNonce:(NSTimer *)aTimer
  95. {
  96. [recentNonces removeObject:[aTimer userInfo]];
  97. }
  99. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  100. #pragma mark Init, Dealloc:
  101. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  103. /**
  104.  * Sole Constructor.
  105.  * Associates this new HTTP connection with the given AsyncSocket.
  106.  * This HTTP connection object will become the socket's delegate and take over responsibility for the socket.
  107. **/
  108. - (id)initWithAsyncSocket:(AsyncSocket *)newSocket forServer:(HTTPServer *)myServer
  109. {
  110. if(self = [super init])
  111. {
  112. // Take over ownership of the socket
  113. asyncSocket = [newSocket retain];
  114. [asyncSocket setDelegate:self];
  116. // Enable pre-buffering on the socket to improve readDataToData performance
  117. [asyncSocket enablePreBuffering];
  119. // Store reference to server
  120. // Note that we do not retain the server. Parents retain their children, children do not retain their parents.
  121. server = myServer;
  123. // Initialize lastNC (last nonce count)
  124. // These must increment for each request from the client
  125. lastNC = 0;
  127. // Create a new HTTP message
  128. // Note the second parameter is YES, because it will be used for HTTP requests from the client
  129. request = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, YES);
  131. numHeaderLines = 0;
  133. // And now that we own the socket, and we have our CFHTTPMessage object (for requests) ready,
  134. // we can start reading the HTTP requests...
  135. [asyncSocket readDataToData:[AsyncSocket CRLFData]
  136. withTimeout:READ_TIMEOUT
  137.   maxLength:LIMIT_MAX_HEADER_LINE_LENGTH
  138. tag:HTTP_REQUEST_HEADER];
  139. }
  140. return self;
  141. }
  143. /**
  144.  * Standard Deconstructor.
  145. **/
  146. - (void)dealloc
  147. {
  148. [asyncSocket setDelegate:nil];
  149. [asyncSocket disconnect];
  150. [asyncSocket release];
  152. if(request) CFRelease(request);
  154. [nonce release];
  156. [httpResponse release];
  158. [ranges release];
  159. [ranges_headers release];
  160. [ranges_boundry release];
  162. [super dealloc];
  163. }
  165. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  166. #pragma mark Connection Control:
  167. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  169. /**
  170.  * Returns whether or not the server will accept POSTs.
  171.  * That is, whether the server will accept uploaded data for the given URI.
  172. **/
  173. - (BOOL)supportsPOST:(NSString *)path withSize:(UInt64)contentLength
  174. {
  175. //NSLog(@"file: %@", path);
  177. dataStartIndex = 0;
  178. multipartData = [[NSMutableArray new] retain];
  179. postHeaderOK = FALSE;
  181. // Override me to support POST uploads.
  182. // Things to consider:
  183. // - Does the given path represent a resource that is designed to accept POST data?
  184. // - Is the size of the data being uploaded too big?
  185. // 
  186. // For more information, you can always access the CFHTTPMessageRef request variable.
  188. return YES;
  189. }
  191. /**
  192.  * Returns whether or not the server is configured to be a secure server.
  193.  * In other words, all connections to this server are immediately secured, thus only secure connections are allowed.
  194.  * This is the equivalent of having an https server, where it is assumed that all connections must be secure.
  195.  * If this is the case, then unsecure connections will not be allowed on this server, and a separate unsecure server
  196.  * would need to be run on a separate port in order to support unsecure connections.
  197.  * 
  198.  * Note: In order to support secure connections, the sslIdentityAndCertificates method must be implemented.
  199. **/
  200. - (BOOL)isSecureServer
  201. {
  202. // Override me to create an https server...
  204. return NO;
  205. }
  207. /**
  208.  * This method is expected to returns an array appropriate for use in kCFStreamSSLCertificates SSL Settings.
  209.  * It should be an array of SecCertificateRefs except for the first element in the array, which is a SecIdentityRef.
  210. **/
  211. - (NSArray *)sslIdentityAndCertificates
  212. {
  213. // Override me to provide the proper required SSL identity.
  214. // You can configure the identity for the entire server, or based on the current request
  216. return nil;
  217. }
  219. /**
  220.  * Returns whether or not the requested resource is brwoseable.
  221.  **/
  222. - (BOOL)isBrowseable:(NSString *)path
  223. {
  224. // Override me to provide custom configuration...
  225. // You can configure it for the entire server, or based on the current request
  227. return YES;
  228. }
  230. /**
  231.  * Returns whether or not the requested resource is password protected.
  232.  * In this generic implementation, nothing is password protected.
  233. **/
  234. - (BOOL)isPasswordProtected:(NSString *)path
  235. {
  236. // Override me to provide password protection...
  237. // You can configure it for the entire server, or based on the current request
  239. return NO;
  240. }
  242. /**
  243.  * Returns whether or not the authentication challenge should use digest access authentication.
  244.  * The alternative is basic authentication.
  245.  * 
  246.  * If at all possible, digest access authentication should be used because it's more secure.
  247.  * Basic authentication sends passwords in the clear and should be avoided unless using SSL/TLS.
  248. **/
  249. - (BOOL)useDigestAccessAuthentication
  250. {
  251. // Override me to use customize the authentication scheme
  252. // Make sure you understand the security consequences of using basic authentication
  254. return YES;
  255. }
  257. /**
  258.  * Returns the authentication realm.
  259.  * In this generic implmentation, a default realm is used for the entire server.
  260. **/
  261. - (NSString *)realm
  262. {
  263. // Override me to provide a custom realm...
  264. // You can configure it for the entire server, or based on the current request
  266. return @"defaultRealm@host.com";
  267. }
  269. /**
  270.  * Returns the password for the given username.
  271.  * This password will be used to generate the response hash to validate against the given response hash.
  272. **/
  273. - (NSString *)passwordForUser:(NSString *)username
  274. {
  275. // Override me to provide proper password authentication
  276. // You can configure a password for the entire server, or custom passwords for users and/or resources
  278. // Note: A password of nil, or a zero-length password is considered the equivalent of no password
  280. return nil;
  281. }
  283. /**
  284.  * Generates and returns an authentication nonce.
  285.  * A nonce is a  server-specified string uniquely generated for each 401 response.
  286.  * The default implementation uses a single nonce for each session.
  287. **/
  288. - (NSString *)generateNonce
  289. {
  290. // We use the Core Foundation UUID class to generate a nonce value for us
  291. // UUIDs (Universally Unique Identifiers) are 128-bit values guaranteed to be unique.
  292. CFUUIDRef theUUID = CFUUIDCreate(NULL);
  293.     NSString *newNonce = [(NSString *)CFUUIDCreateString(NULL, theUUID) autorelease];
  294.     CFRelease(theUUID);
  296. // We have to remember that the HTTP protocol is stateless
  297. // Even though with version 1.1 persistent connections are the norm, they are not guaranteed
  298. // Thus if we generate a nonce for this connection,
  299. // it should be honored for other connections in the near future
  300. // 
  301. // In fact, this is absolutely necessary in order to support QuickTime
  302. // When QuickTime makes it's initial connection, it will be unauthorized, and will receive a nonce
  303. // It then disconnects, and creates a new connection with the nonce, and proper authentication
  304. // If we don't honor the nonce for the second connection, QuickTime will repeat the process and never connect
  306. [recentNonces addObject:newNonce];
  308. [NSTimer scheduledTimerWithTimeInterval:NONCE_TIMEOUT
  309.  target:[HTTPConnection class]
  310.    selector:@selector(removeRecentNonce:)
  311.    userInfo:newNonce
  312. repeats:NO];
  313. return newNonce;
  314. }
  316. /**
  317.  * Returns whether or not the user is properly authenticated.
  318.  * Authentication is done using Digest Access Authentication accoring to RFC 2617.
  319. **/
  320. - (BOOL)isAuthenticated
  321. {
  322. // Extract the authentication information from the Authorization header
  323. HTTPAuthenticationRequest *auth = [[[HTTPAuthenticationRequest alloc] initWithRequest:request] autorelease];
  325. if([self useDigestAccessAuthentication])
  326. {
  327. // Digest Access Authentication
  329. if(![auth isDigest])
  330. {
  331. // User didn't send proper digest access authentication credentials
  332. return NO;
  333. }
  335. if([auth username] == nil)
  336. {
  337. // The client didn't provide a username
  338. // Most likely they didn't provide any authentication at all
  339. return NO;
  340. }
  342. NSString *password = [self passwordForUser:[auth username]];
  343. if((password == nil) || ([password length] == 0))
  344. {
  345. // There is no password set, or the password is an empty string
  346. // We can consider this the equivalent of not using password protection
  347. return YES;
  348. }
  350. NSString *method = [(NSString *)CFHTTPMessageCopyRequestMethod(request) autorelease];
  352. NSURL *absoluteUrl = [(NSURL *)CFHTTPMessageCopyRequestURL(request) autorelease];
  353. NSString *url = [(NSURL *)absoluteUrl relativeString];
  355. if(![url isEqualToString:[auth uri]])
  356. {
  357. // Requested URL and Authorization URI do not match
  358. // This could be a replay attack
  359. // IE - attacker provides same authentication information, but requests a different resource
  360. return NO;
  361. }
  363. // The nonce the client provided will most commonly be stored in our local (cached) nonce variable
  364. if(![nonce isEqualToString:[auth nonce]])
  365. {
  366. // The given nonce may be from another connection
  367. // We need to search our list of recent nonce strings that have been recently distributed
  368. if([recentNonces containsObject:[auth nonce]])
  369. {
  370. // Store nonce in local (cached) nonce variable to prevent array searches in the future
  371. [nonce release];
  372. nonce = [[auth nonce] copy];
  374. // The client has switched to using a different nonce value
  375. // This may happen if the client tries to get a file in a directory with different credentials.
  376. // The previous credentials wouldn't work, and the client would receive a 401 error
  377. // along with a new nonce value. The client then uses this new nonce value and requests the file again.
  378. // Whatever the case may be, we need to reset lastNC, since that variable is on a per nonce basis.
  379. lastNC = 0;
  380. }
  381. else
  382. {
  383. // We have no knowledge of ever distributing such a nonce
  384. // This could be a replay attack from a previous connection in the past
  385. return NO;
  386. }
  387. }
  389. if([[auth nc] intValue] <= lastNC)
  390. {
  391. // The nc value (nonce count) hasn't been incremented since the last request
  392. // This could be a replay attack
  393. return NO;
  394. }
  395. lastNC = [[auth nc] intValue];
  397. NSString *HA1str = [NSString stringWithFormat:@"%@:%@:%@", [auth username], [auth realm], password];
  398. NSString *HA2str = [NSString stringWithFormat:@"%@:%@", method, [auth uri]];
  400. NSString *HA1 = [[[HA1str dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
  402. NSString *HA2 = [[[HA2str dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
  404. NSString *responseStr = [NSString stringWithFormat:@"%@:%@:%@:%@:%@:%@",
  405.  HA1, [auth nonce], [auth nc], [auth cnonce], [auth qop], HA2];
  407. NSString *response = [[[responseStr dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
  409. return [response isEqualToString:[auth response]];
  410. }
  411. else
  412. {
  413. // Basic Authentication
  415. if(![auth isBasic])
  416. {
  417. // User didn't send proper base authentication credentials
  418. return NO;
  419. }
  421. // Decode the base 64 encoded credentials
  422. NSString *base64Credentials = [auth base64Credentials];
  424. NSData *temp = [[base64Credentials dataUsingEncoding:NSUTF8StringEncoding] base64Decoded];
  426. NSString *credentials = [[[NSString alloc] initWithData:temp encoding:NSUTF8StringEncoding] autorelease];
  428. // The credentials should be of the form "username:password"
  429. // The username is not allowed to contain a colon
  431. NSRange colonRange = [credentials rangeOfString:@":"];
  433. if(colonRange.length == 0)
  434. {
  435. // Malformed credentials
  436. return NO;
  437. }
  439. NSString *credUsername = [credentials substringToIndex:colonRange.location];
  440. NSString *credPassword = [credentials substringFromIndex:(colonRange.location + colonRange.length)];
  442. NSString *password = [self passwordForUser:credUsername];
  443. if((password == nil) || ([password length] == 0))
  444. {
  445. // There is no password set, or the password is an empty string
  446. // We can consider this the equivalent of not using password protection
  447. return YES;
  448. }
  450. return [password isEqualToString:credPassword];
  451. }
  452. }
  454. /**
  455.  * Adds a digest access authentication challenge to the given response.
  456. **/
  457. - (void)addDigestAuthChallenge:(CFHTTPMessageRef)response
  458. {
  459. NSString *authFormat = @"Digest realm="%@", qop="auth", nonce="%@"";
  460. NSString *authInfo = [NSString stringWithFormat:authFormat, [self realm], [self generateNonce]];
  462. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("WWW-Authenticate"), (CFStringRef)authInfo);
  463. }
  465. /**
  466.  * Adds a basic authentication challenge to the given response.
  467. **/
  468. - (void)addBasicAuthChallenge:(CFHTTPMessageRef)response
  469. {
  470. NSString *authFormat = @"Basic realm="%@"";
  471. NSString *authInfo = [NSString stringWithFormat:authFormat, [self realm]];
  473. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("WWW-Authenticate"), (CFStringRef)authInfo);
  474. }
  476. /**
  477.  * Attempts to parse the given range header into a series of non-overlapping ranges.
  478.  * If successfull, the variables 'ranges' and 'rangeIndex' will be updated, and YES will be returned.
  479.  * Otherwise, NO is returned, and the range request should be ignored.
  480.  **/
  481. - (BOOL)parseRangeRequest:(NSString *)rangeHeader withContentLength:(UInt64)contentLength
  482. {
  483. // Examples of byte-ranges-specifier values (assuming an entity-body of length 10000):
  484. // 
  485. // - The first 500 bytes (byte offsets 0-499, inclusive):  bytes=0-499
  486. // 
  487. // - The second 500 bytes (byte offsets 500-999, inclusive): bytes=500-999
  488. // 
  489. // - The final 500 bytes (byte offsets 9500-9999, inclusive): bytes=-500
  490. // 
  491. // - Or bytes=9500-
  492. // 
  493. // - The first and last bytes only (bytes 0 and 9999):  bytes=0-0,-1
  494. // 
  495. // - Several legal but not canonical specifications of the second 500 bytes (byte offsets 500-999, inclusive):
  496. // bytes=500-600,601-999
  497. // bytes=500-700,601-999
  498. // 
  500. NSRange eqsignRange = [rangeHeader rangeOfString:@"="];
  502. if(eqsignRange.location == NSNotFound) return NO;
  504. NSUInteger tIndex = eqsignRange.location;
  505. NSUInteger fIndex = eqsignRange.location + eqsignRange.length;
  507. NSString *rangeType  = [[[rangeHeader substringToIndex:tIndex] mutableCopy] autorelease];
  508. NSString *rangeValue = [[[rangeHeader substringFromIndex:fIndex] mutableCopy] autorelease];
  510. CFStringTrimWhitespace((CFMutableStringRef)rangeType);
  511. CFStringTrimWhitespace((CFMutableStringRef)rangeValue);
  513. if([rangeType caseInsensitiveCompare:@"bytes"] != NSOrderedSame) return NO;
  515. NSArray *rangeComponents = [rangeValue componentsSeparatedByString:@","];
  517. if([rangeComponents count] == 0) return NO;
  519. [ranges release];
  520. ranges = [[NSMutableArray alloc] initWithCapacity:[rangeComponents count]];
  522. rangeIndex = 0;
  524. // Note: We store all range values in the form of NSRange structs, wrapped in NSValue objects.
  525. // Since NSRange consists of NSUInteger values, the range is limited to 4 gigs on 32-bit architectures (ppc, i386)
  527. NSUInteger i;
  528. for(i = 0; i < [rangeComponents count]; i++)
  529. {
  530. NSString *rangeComponent = [rangeComponents objectAtIndex:i];
  532. NSRange dashRange = [rangeComponent rangeOfString:@"-"];
  534. if(dashRange.location == NSNotFound)
  535. {
  536. // We're dealing with an individual byte number
  538. UInt64 byteIndex;
  539. if(![NSNumber parseString:rangeComponent intoUInt64:&byteIndex]) return NO;
  541. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(byteIndex, 1)]];
  542. }
  543. else
  544. {
  545. // We're dealing with a range of bytes
  547. tIndex = dashRange.location;
  548. fIndex = dashRange.location + dashRange.length;
  550. NSString *r1str = [rangeComponent substringToIndex:tIndex];
  551. NSString *r2str = [rangeComponent substringFromIndex:fIndex];
  553. UInt64 r1, r2;
  555. BOOL hasR1 = [NSNumber parseString:r1str intoUInt64:&r1];
  556. BOOL hasR2 = [NSNumber parseString:r2str intoUInt64:&r2];
  558. if(!hasR1)
  559. {
  560. // We're dealing with a "-[#]" range
  561. // 
  562. // r2 is the number of ending bytes to include in the range
  564. if(!hasR2) return NO;
  565. if(r2 > contentLength) return NO;
  567. UInt64 startIndex = contentLength - r2;
  569. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(startIndex, r2)]];
  570. }
  571. else if(!hasR2)
  572. {
  573. // We're dealing with a "[#]-" range
  574. // 
  575. // r1 is the starting index of the range, which goes all the way to the end
  577. if(!hasR1) return NO;
  578. if(r1 >= contentLength) return NO;
  580. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(r1, contentLength - r1)]];
  581. }
  582. else
  583. {
  584. // We're dealing with a normal "[#]-[#]" range
  585. // 
  586. // Note: The range is inclusive. So 0-1 has a length of 2 bytes.
  588. if(!hasR1) return NO;
  589. if(!hasR2) return NO;
  590. if(r1 > r2) return NO;
  592. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(r1, r2 - r1 + 1)]];
  593. }
  594. }
  595. }
  597. if([ranges count] == 0) return NO;
  599. for(i = 0; i < [ranges count] - 1; i++)
  600. {
  601. DDRange range1 = [[ranges objectAtIndex:i] ddrangeValue];
  603. NSUInteger j;
  604. for(j = i+1; j < [ranges count]; j++)
  605. {
  606. DDRange range2 = [[ranges objectAtIndex:j] ddrangeValue];
  608. DDRange iRange = DDIntersectionRange(range1, range2);
  610. if(iRange.length != 0)
  611. {
  612. return NO;
  613. }
  614. }
  615. }
  617. return YES;
  618. }
  620. /**
  621.  * Gets the current date and time, formatted properly (according to RFC) for insertion into an HTTP header.
  622. **/
  623. - (NSString *)dateAsString:(NSDate *)date
  624. {
  625. // Example: Sun, 06 Nov 1994 08:49:37 GMT
  627. NSDateFormatter *df = [[[NSDateFormatter alloc] init] autorelease];
  628. [df setFormatterBehavior:NSDateFormatterBehavior10_4];
  629. [df setTimeZone:[NSTimeZone timeZoneWithAbbreviation:@"GMT"]];
  630. [df setDateFormat:@"EEE, dd MMM y hh:mm:ss 'GMT'"];
  632. // For some reason, using zzz in the format string produces GMT+00:00
  634. return [df stringFromDate:date];
  635. }
  637. /**
  638.  * This method is called after a full HTTP request has been received.
  639.  * The current request is in the CFHTTPMessage request variable.
  640.  **/
  641. - (void)replyToHTTPRequest
  642. {
  643. // Check the HTTP version - if it's anything but HTTP version 1.1, we don't support it
  644. NSString *version = [(NSString *)CFHTTPMessageCopyVersion(request) autorelease];
  645. if(!version || ![version isEqualToString:(NSString *)kCFHTTPVersion1_1])
  646. {
  647. [self handleVersionNotSupported:version];
  648. return;
  649. }
  651. // Check HTTP method
  652. NSString *method = [(NSString *)CFHTTPMessageCopyRequestMethod(request) autorelease];
  653.     if(![method isEqualToString:@"GET"] && ![method isEqualToString:@"HEAD"] && ![method isEqualToString:@"POST"])
  654. {
  655. [self handleUnknownMethod:method];
  656.         return;
  657.     }
  659. // Extract requested URI
  660. NSURL *uri = [(NSURL *)CFHTTPMessageCopyRequestURL(request) autorelease];
  662. // Check Authentication (if needed)
  663. // If not properly authenticated for resource, issue Unauthorized response
  664. if([self isPasswordProtected:[uri relativeString]] && ![self isAuthenticated])
  665. {
  666. [self handleAuthenticationFailed];
  667. return;
  668. }
  670. // Respond properly to HTTP 'GET' and 'HEAD' commands
  671. httpResponse = [[self httpResponseForURI:[uri relativeString]] retain];
  673. UInt64 contentLength = [httpResponse contentLength];
  675. if(contentLength == 0)
  676. {
  677. [self handleResourceNotFound];
  679. [httpResponse release];
  680. httpResponse = nil;
  682. return;
  683.     }
  685. // Check for specific range request
  686. NSString *rangeHeader = [(NSString *)CFHTTPMessageCopyHeaderFieldValue(request, CFSTR("Range")) autorelease];
  688. BOOL isRangeRequest = NO;
  690. if(rangeHeader)
  691. {
  692. if([self parseRangeRequest:rangeHeader withContentLength:contentLength])
  693. {
  694. isRangeRequest = YES;
  695. }
  696. }
  698. CFHTTPMessageRef response;
  700. if(!isRangeRequest)
  701. {
  702. // Status Code 200 - OK
  703. response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 200, NULL, kCFHTTPVersion1_1);
  705. NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", contentLength];
  706. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  707. }
  708. else
  709. {
  710. if([ranges count] == 1)
  711. {
  712. response = [self prepareUniRangeResponse:contentLength];
  713. }
  714. else
  715. {
  716. response = [self prepareMultiRangeResponse:contentLength];
  717. }
  718. }
  719.     
  720. // If they issue a 'HEAD' command, we don't have to include the file
  721. // If they issue a 'GET' command, we need to include the file
  722. if([method isEqual:@"HEAD"])
  723. {
  724. NSData *responseData = [self preprocessResponse:response];
  725. [asyncSocket writeData:responseData withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_RESPONSE];
  726. }
  727. else
  728. {
  729. // Write the header response
  730. NSData *responseData = [self preprocessResponse:response];
  731. [asyncSocket writeData:responseData withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_HEADER];
  733. // Now we need to send the body of the response
  734. if(!isRangeRequest)
  735. {
  736. // Regular request
  737. NSData *data = [httpResponse readDataOfLength:READ_CHUNKSIZE];
  739. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_BODY];
  740. }
  741. else
  742. {
  743. // Client specified a byte range in request
  745. if([ranges count] == 1)
  746. {
  747. // Client is requesting a single range
  748. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  750. [httpResponse setOffset:range.location];
  752. unsigned int bytesToRead = range.length < READ_CHUNKSIZE ? range.length : READ_CHUNKSIZE;
  754. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  756. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:HTTP_PARTIAL_RANGE_RESPONSE_BODY];
  757. }
  758. else
  759. {
  760. // Client is requesting multiple ranges
  761. // We have to send each range using multipart/byteranges
  763. // Write range header
  764. NSData *rangeHeader = [ranges_headers objectAtIndex:0];
  765. [asyncSocket writeData:rangeHeader withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_HEADER];
  767. // Start writing range body
  768. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  770. [httpResponse setOffset:range.location];
  772. unsigned int bytesToRead = range.length < READ_CHUNKSIZE ? range.length : READ_CHUNKSIZE;
  774. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  776. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:HTTP_PARTIAL_RANGES_RESPONSE_BODY];
  777. }
  778. }
  779. }
  781. CFRelease(response);
  782. }
  784. /**
  785.  * Prepares a single-range response.
  786.  * 
  787.  * Note: The returned CFHTTPMessageRef is owned by the sender, who is responsible for releasing it.
  788. **/
  789. - (CFHTTPMessageRef)prepareUniRangeResponse:(UInt64)contentLength
  790. {
  791. // Status Code 206 - Partial Content
  792. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 206, NULL, kCFHTTPVersion1_1);
  794. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  796. NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", range.length];
  797. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  799. NSString *rangeStr = [NSString stringWithFormat:@"%qu-%qu", range.location, DDMaxRange(range) - 1];
  800. NSString *contentRangeStr = [NSString stringWithFormat:@"bytes %@/%qu", rangeStr, contentLength];
  801. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Range"), (CFStringRef)contentRangeStr);
  803. return response;
  804. }
  806. /**
  807.  * Prepares a multi-range response.
  808.  * 
  809.  * Note: The returned CFHTTPMessageRef is owned by the sender, who is responsible for releasing it.
  810. **/
  811. - (CFHTTPMessageRef)prepareMultiRangeResponse:(UInt64)contentLength
  812. {
  813. // Status Code 206 - Partial Content
  814. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 206, NULL, kCFHTTPVersion1_1);
  816. // We have to send each range using multipart/byteranges
  817. // So each byterange has to be prefix'd and suffix'd with the boundry
  818. // Example:
  819. // 
  820. // HTTP/1.1 206 Partial Content
  821. // Content-Length: 220
  822. // Content-Type: multipart/byteranges; boundary=4554d24e986f76dd6
  823. // 
  824. // 
  825. // --4554d24e986f76dd6
  826. // Content-range: bytes 0-25/4025
  827. // 
  828. // [...]
  829. // --4554d24e986f76dd6
  830. // Content-range: bytes 3975-4024/4025
  831. // 
  832. // [...]
  833. // --4554d24e986f76dd6--
  835. ranges_headers = [[NSMutableArray alloc] initWithCapacity:[ranges count]];
  837. CFUUIDRef theUUID = CFUUIDCreate(NULL);
  838. ranges_boundry = (NSString *)CFUUIDCreateString(NULL, theUUID);
  839. CFRelease(theUUID);
  841. NSString *startingBoundryStr = [NSString stringWithFormat:@"rn--%@rn", ranges_boundry];
  842. NSString *endingBoundryStr = [NSString stringWithFormat:@"rn--%@--rn", ranges_boundry];
  844. UInt64 actualContentLength = 0;
  846. unsigned i;
  847. for(i = 0; i < [ranges count]; i++)
  848. {
  849. DDRange range = [[ranges objectAtIndex:i] ddrangeValue];
  851. NSString *rangeStr = [NSString stringWithFormat:@"%qu-%qu", range.location, DDMaxRange(range) - 1];
  852. NSString *contentRangeVal = [NSString stringWithFormat:@"bytes %@/%qu", rangeStr, contentLength];
  853. NSString *contentRangeStr = [NSString stringWithFormat:@"Content-Range: %@rnrn", contentRangeVal];
  855. NSString *fullHeader = [startingBoundryStr stringByAppendingString:contentRangeStr];
  856. NSData *fullHeaderData = [fullHeader dataUsingEncoding:NSUTF8StringEncoding];
  858. [ranges_headers addObject:fullHeaderData];
  860. actualContentLength += [fullHeaderData length];
  861. actualContentLength += range.length;
  862. }
  864. NSData *endingBoundryData = [endingBoundryStr dataUsingEncoding:NSUTF8StringEncoding];
  866. actualContentLength += [endingBoundryData length];
  868. NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", actualContentLength];
  869. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  871. NSString *contentTypeStr = [NSString stringWithFormat:@"multipart/byteranges; boundary=%@", ranges_boundry];
  872. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Type"), (CFStringRef)contentTypeStr);
  874. return response;
  875. }
  877. /**
  878.  * Converts relative URI path into full file-system path.
  879. **/
  880. - (NSString *)filePathForURI:(NSString *)path
  881. {
  882. // Override me to perform custom path mapping.
  883. // For example you may want to use a default file other than index.html, or perhaps support multiple types.
  885. // If there is no configured documentRoot, then it makes no sense to try to return anything
  886. if(![server documentRoot]) return nil;
  888. // Convert path to a relative path.
  889. // This essentially means trimming beginning '/' characters.
  890. // Beware of a bug in the Cocoa framework:
  891. // 
  892. // [NSURL URLWithString:@"/foo" relativeToURL:baseURL]       == @"/baseURL/foo"
  893. // [NSURL URLWithString:@"/foo%20bar" relativeToURL:baseURL] == @"/foo bar"
  894. // [NSURL URLWithString:@"/foo" relativeToURL:baseURL]       == @"/foo"
  896. NSString *relativePath = path;
  898. while([relativePath hasPrefix:@"/"] && [relativePath length] > 1)
  899. {
  900. relativePath = [relativePath substringFromIndex:1];
  901. }
  903. NSURL *url;
  905. if([relativePath hasSuffix:@"/"])
  906. {
  907. NSString *completedRelativePath = [relativePath stringByAppendingString:@"index.html"];
  908. url = [NSURL URLWithString:completedRelativePath relativeToURL:[server documentRoot]];
  909. }
  910. else
  911. {
  912. url = [NSURL URLWithString:relativePath relativeToURL:[server documentRoot]];
  913. }
  915. // Watch out for sneaky requests with ".." in the path
  916. // For example, the following request: "../Documents/TopSecret.doc"
  917. if(![[url path] hasPrefix:[[server documentRoot] path]]) return nil;
  919. return [[url path] stringByStandardizingPath];
  920. }
  922. /**
  923.  * This method creates a html browseable page.
  924.  * Customize to fit your needs
  925.  **/
  926. - (NSString *) createBrowseableIndex:(NSString *)path
  927. {
  928.     NSArray *array = [[NSFileManager defaultManager] directoryContentsAtPath:path];
  929.     
  930.     NSMutableString *outdata = [NSMutableString new];
  931. [outdata appendString:@"<html><head>"];
  932. [outdata appendFormat:@"<title>Files from %@</title>", server.name];
  933.     [outdata appendString:@"<style>html {background-color:#eeeeee} body { background-color:#FFFFFF; font-family:Tahoma,Arial,Helvetica,sans-serif; font-size:18x; margin-left:15%; margin-right:15%; border:3px groove #006600; padding:15px; } </style>"];
  934.     [outdata appendString:@"</head><body>"];
  935. [outdata appendFormat:@"<h1>Files from %@</h1>", server.name];
  936.     [outdata appendString:@"<bq>The following files are hosted live from the iPhone's Docs folder.</bq>"];
  937.     [outdata appendString:@"<p>"];
  938. [outdata appendFormat:@"<a href="..">..</a><br />n"];
  939.     for (NSString *fname in array)
  940.     {
  941.         NSDictionary *fileDict = [[NSFileManager defaultManager] fileAttributesAtPath:[path stringByAppendingPathComponent:fname] traverseLink:NO];
  942. //NSLog(@"fileDict: %@", fileDict);
  943.         NSString *modDate = [[fileDict objectForKey:NSFileModificationDate] description];
  944. if ([[fileDict objectForKey:NSFileType] isEqualToString: @"NSFileTypeDirectory"]) fname = [fname stringByAppendingString:@"/"];
  945. [outdata appendFormat:@"<a href="%@">%@</a> (%8.1f Kb, %@)<br />n", fname, fname, [[fileDict objectForKey:NSFileSize] floatValue] / 1024, modDate];
  946.     }
  947.     [outdata appendString:@"</p>"];
  949. if ([self supportsPOST:path withSize:0])
  950. {
  951. [outdata appendString:@"<form action="" method="post" enctype="multipart/form-data" name="form1" id="form1">"];
  952. [outdata appendString:@"<label>upload file"];
  953. [outdata appendString:@"<input type="file" name="file" id="file" />"];
  954. [outdata appendString:@"</label>"];
  955. [outdata appendString:@"<label>"];
  956. [outdata appendString:@"<input type="submit" name="button" id="button" value="Submit" />"];
  957. [outdata appendString:@"</label>"];
  958. [outdata appendString:@"</form>"];
  959. }
  961. [outdata appendString:@"</body></html>"];
  962.     
  963. //NSLog(@"outData: %@", outdata);
  964.     return [outdata autorelease];
  965. }
  968. /**
  969.  * This method is called to get a response for a request.
  970.  * You may return any object that adopts the HTTPResponse protocol.
  971.  * The HTTPServer comes with two such classes: HTTPFileResponse and HTTPDataResponse.
  972.  * HTTPFileResponse is a wrapper for an NSFileHandle object, and is the preferred way to send a file response.
  973.  * HTTPDataResopnse is a wrapper for an NSData object, and may be used to send a custom response.
  974. **/
  975. - (NSObject<HTTPResponse> *)httpResponseForURI:(NSString *)path
  976. {
  977. //NSLog(@"httpResponseForURI: %@", path);
  979. if (postContentLength > 0) //process POST data
  980. {
  981. NSLog(@"processing post data: %i", postContentLength);
  983. UInt16 separatorBytes = 0x0A0D;
  984. NSMutableData* separatorData = [NSMutableData dataWithBytes:&separatorBytes length:2];
  985. [separatorData appendData:[multipartData objectAtIndex:0]];
  986. int l = [separatorData length];
  987. int count = 2; //number of times the separator shows up at the end of file data
  989. NSFileHandle* dataToTrim = [multipartData lastObject];
  990. NSLog(@"data: %@", dataToTrim);
  992. for (unsigned long long i = [dataToTrim offsetInFile] - l; i > 0; i--)
  993. {
  994. [dataToTrim seekToFileOffset:i];
  995. if ([[dataToTrim readDataOfLength:l] isEqualToData:separatorData])
  996. {
  997. [dataToTrim truncateFileAtOffset:i];
  998. i -= l;
  999. if (--count == 0) break;
  1000. }
  1001. }
  1002. NSLog(@"NewFileUploaded");
  1003. //Set up notification, u can use [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(refresh) name:@"NewFileUploaded" object:nil] from anywhere to receive the notfication
  1004. [[NSNotificationCenter defaultCenter] postNotificationName:@"NewFileUploaded" object:nil];
  1006. for (int n = 1; n < [multipartData count] - 1; n++)
  1007. NSLog(@"%@", [[NSString alloc] initWithBytes:[[multipartData objectAtIndex:n] bytes] length:[[multipartData objectAtIndex:n] length] encoding:NSUTF8StringEncoding]);
  1009. [multipartData release];
  1010. postContentLength = 0;
  1011. }
  1013. NSString *filePath = [self filePathForURI:path];
  1015. if([[NSFileManager defaultManager] fileExistsAtPath:filePath])
  1016. {
  1017. return [[[HTTPFileResponse alloc] initWithFilePath:filePath] autorelease];
  1018. }
  1019. else //no 
  1020. {
  1021. NSString *folder = [path isEqualToString:@"/"] ? [[server documentRoot] path] : [NSString stringWithFormat: @"%@%@", [[server documentRoot] path], path];
  1022. if ([self isBrowseable:folder])
  1023. {
  1024. //NSLog(@"folder: %@", folder);
  1025. NSData *browseData = [[self createBrowseableIndex:folder] dataUsingEncoding:NSUTF8StringEncoding];
  1026. return [[[HTTPDataResponse alloc] initWithData:browseData] autorelease];
  1027. }
  1028. }
  1030. return nil;
  1031. }
  1033. /**
  1034.  * This method is called to handle data read from a POST.
  1035.  * The given data is part of the POST body.
  1036. **/
  1037. - (void)processPostDataChunk:(NSData *)postDataChunk
  1038. {
  1039. //NSLog(@"processPostDataChunk");
  1041. if (!postHeaderOK)
  1042. {
  1043. UInt16 separatorBytes = 0x0A0D;
  1044. NSData* separatorData = [NSData dataWithBytes:&separatorBytes length:2];
  1046. int l = [separatorData length];
  1047. for (int i = 0; i < [postDataChunk length] - l; i++)
  1048. {
  1049. NSRange searchRange = {i, l};
  1050. if ([[postDataChunk subdataWithRange:searchRange] isEqualToData:separatorData])
  1051. {
  1052. NSRange newDataRange = {dataStartIndex, i - dataStartIndex};
  1053. dataStartIndex = i + l;
  1054. i += l - 1;
  1055. NSData *newData = [postDataChunk subdataWithRange:newDataRange];
  1056. if ([newData length])
  1057. {
  1058. [multipartData addObject:newData];
  1060. }
  1061. else
  1062. {
  1063. postHeaderOK = TRUE;
  1065. NSString* postInfo = [[NSString alloc] initWithBytes:[[multipartData objectAtIndex:1] bytes] length:[[multipartData objectAtIndex:1] length] encoding:NSUTF8StringEncoding];
  1066. NSArray* postInfoComponents = [postInfo componentsSeparatedByString:@"; filename="];
  1067. postInfoComponents = [[postInfoComponents lastObject] componentsSeparatedByString:@"""];
  1068. postInfoComponents = [[postInfoComponents objectAtIndex:1] componentsSeparatedByString:@"\"];
  1069. NSString* filename = [[[server documentRoot] path] stringByAppendingPathComponent:[postInfoComponents lastObject]];
  1070. NSRange fileDataRange = {dataStartIndex, [postDataChunk length] - dataStartIndex};
  1072. [[NSFileManager defaultManager] createFileAtPath:filename contents:[postDataChunk subdataWithRange:fileDataRange] attributes:nil];
  1073. NSFileHandle *file = [[NSFileHandle fileHandleForUpdatingAtPath:filename] retain];
  1074. [file seekToEndOfFile];
  1076. [multipartData addObject:file];
  1077. [postInfo release];
  1079. /*
  1080. NSRange fileDataRange = {dataStartIndex, [postDataChunk length] - dataStartIndex};
  1081. NSMutableData *fileData = [NSMutableData dataWithData:[postDataChunk subdataWithRange:fileDataRange]];
  1082. [multipartData addObject:fileData];
  1083.  */
  1085. break;
  1086. }
  1087. }
  1088. }
  1089. }
  1090. else
  1091. {
  1092. NSLog(@"file: %@", [multipartData lastObject]);
  1093. [(NSFileHandle*)[multipartData lastObject] writeData:postDataChunk];
  1094. //[[multipartData lastObject] appendData:postDataChunk];
  1095. }
  1096. // Override me to do something useful with a POST.
  1097. // If the post is small, such as a simple form, you may want to simply append the data to the request.
  1098. // If the post is big, such as a file upload, you may want to store the file to disk.
  1099. // 
  1100. // Remember: In order to support LARGE POST uploads, the data is read in chunks.
  1101. // This prevents a 50 MB upload from being stored in RAM.
  1102. // The size of the chunks are limited by the POST_CHUNKSIZE definition.
  1103. // Therefore, this method may be called multiple times for the same POST request.
  1104. }
  1106. /**
  1107.  * Called if the HTML version is other than what is supported
  1108. **/
  1109. - (void)handleVersionNotSupported:(NSString *)version
  1110. {
  1111. // Override me for custom error handling of unspupported http version responses
  1112. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1113. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1115. //NSLog(@"HTTP Server: Error 505 - Version Not Supported: %@", version);
  1117. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 505, NULL, (CFStringRef)version);
  1118. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1119.     
  1120. NSData *responseData = [self preprocessErrorResponse:response];
  1121. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_RESPONSE];
  1123. CFRelease(response);
  1124. }
  1126. /**
  1127.  * Called if the authentication information was required and absent, or if authentication failed.
  1128. **/
  1129. - (void)handleAuthenticationFailed
  1130. {
  1131. // Override me for custom handling of authentication challenges
  1132. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1133. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1135. //NSLog(@"HTTP Server: Error 401 - Unauthorized");
  1137. // Status Code 401 - Unauthorized
  1138. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 401, NULL, kCFHTTPVersion1_1);
  1139. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1141. if([self useDigestAccessAuthentication])
  1142. {
  1143. [self addDigestAuthChallenge:response];
  1144. }
  1145. else
  1146. {
  1147. [self addBasicAuthChallenge:response];
  1148. }
  1150. NSData *responseData = [self preprocessErrorResponse:response];
  1151. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_RESPONSE];
  1153. CFRelease(response);
  1154. }
  1156. /**
  1157.  * Called if we receive some sort of malformed HTTP request.
  1158.  * The data parameter is the invalid HTTP header line, including CRLF, as read from AsyncSocket.
  1159.  * The data parameter may also be nil if the request as a whole was invalid, such as a POST with no Content-Length.
  1160. **/
  1161. - (void)handleInvalidRequest:(NSData *)data
  1162. {
  1163. // Override me for custom error handling of invalid HTTP requests
  1164. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1165. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1167. //NSLog(@"HTTP Server: Error 400 - Bad Request");
  1169. // Status Code 400 - Bad Request
  1170. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 400, NULL, kCFHTTPVersion1_1);
  1171. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1173. NSData *responseData = [self preprocessErrorResponse:response];
  1174. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_FINAL_RESPONSE];
  1176. CFRelease(response);
  1177. }
  1179. /**
  1180.  * Called if we receive a HTTP request with a method other than GET or HEAD.
  1181. **/
  1182. - (void)handleUnknownMethod:(NSString *)method
  1183. {
  1184. // Override me to add support for methods other than GET and HEAD
  1185. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1186. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1188. //NSLog(@"HTTP Server: Error 405 - Method Not Allowed: %@", method);
  1190. // Status code 405 - Method Not Allowed
  1191.     CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 405, NULL, kCFHTTPVersion1_1);
  1192. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1194. NSData *responseData = [self preprocessErrorResponse:response];
  1195. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_FINAL_RESPONSE];
  1196.     
  1197. CFRelease(response);
  1199. // Note: We used the HTTP_FINAL_RESPONSE tag to disconnect after the response is sent.
  1200. // We do this because the method may include an http body.
  1201. // Since we can't be sure, we should close the connection.
  1202. }
  1204. - (void)handleResourceNotFound
  1205. {
  1206. // Override me for custom error handling of 404 not found responses
  1207. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1208. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1210. //NSLog(@"HTTP Server: Error 404 - Not Found");
  1212. // Status Code 404 - Not Found
  1213. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 404, NULL, kCFHTTPVersion1_1);
  1214. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1216. NSData *responseData = [self preprocessErrorResponse:response];
  1217. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_RESPONSE];
  1219. CFRelease(response);
  1220. }
  1222. /**
  1223.  * This method is called immediately prior to sending the response headers.
  1224.  * This method adds standard header fields, and then converts the response to an NSData object.
  1225. **/
  1226. - (NSData *)preprocessResponse:(CFHTTPMessageRef)response
  1227. {
  1228. // Override me to customize the response headers
  1229. // You'll likely want to add your own custom headers, and then return [super preprocessResponse:response]
  1231. NSString *now = [self dateAsString:[NSDate date]];
  1232. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Date"), (CFStringRef)now);
  1234. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Accept-Ranges"), CFSTR("bytes"));
  1236. NSData *result = (NSData *)CFHTTPMessageCopySerializedMessage(response);
  1237. return [result autorelease];
  1238. }
  1240. /**
  1241.  * This method is called immediately prior to sending the response headers (for an error).
  1242.  * This method adds standard header fields, and then converts the response to an NSData object.
  1243. **/
  1244. - (NSData *)preprocessErrorResponse:(CFHTTPMessageRef)response;
  1245. {
  1246. // Override me to customize the error response headers
  1247. // You'll likely want to add your own custom headers, and then return [super preprocessErrorResponse:response]
  1248. // 
  1249. // Notes:
  1250. // You can use CFHTTPMessageGetResponseStatusCode(response) to get the type of error.
  1251. // You can use CFHTTPMessageSetBody() to add an optional HTML body.
  1252. // If you add a body, don't forget to update the Content-Length.
  1253. // 
  1254. // if(CFHTTPMessageGetResponseStatusCode(response) == 404)
  1255. // {
  1256. //     NSString *msg = @"<html><body>Error 404 - Not Found</body></html>";
  1257. //     NSData *msgData = [msg dataUsingEncoding:NSUTF8StringEncoding];
  1258. //     
  1259. //     CFHTTPMessageSetBody(response, (CFDataRef)msgData);
  1260. //     
  1261. //     NSString *contentLengthStr = [NSString stringWithFormat:@"%u", (unsigned)[msgData length]];
  1262. //     CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  1263. // }
  1265. NSString *now = [self dateAsString:[NSDate date]];
  1266. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Date"), (CFStringRef)now);
  1268. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Accept-Ranges"), CFSTR("bytes"));
  1270. NSData *result = (NSData *)CFHTTPMessageCopySerializedMessage(response);
  1271. return [result autorelease];
  1272. }
  1274. - (void)die
  1275. {
  1276. // Post notification of dead connection
  1277. // This will allow our server to release us from its array of connections
  1278. [[NSNotificationCenter defaultCenter] postNotificationName:HTTPConnectionDidDieNotification object:self];
  1279. }
  1281. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1282. #pragma mark AsyncSocket Delegate Methods:
  1283. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1285. /**
  1286.  * This method is called immediately prior to opening up the stream.
  1287.  * This is the time to manually configure the stream if necessary.
  1288. **/
  1289. - (BOOL)onSocketWillConnect:(AsyncSocket *)sock
  1290. {
  1291. if([self isSecureServer])
  1292. {
  1293. NSArray *certificates = [self sslIdentityAndCertificates];
  1295. if([certificates count] > 0)
  1296. {
  1297. //NSLog(@"Securing connection...");
  1299. // All connections are assumed to be secure. Only secure connections are allowed on this server.
  1300. NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithCapacity:3];
  1302. // Configure this connection as the server
  1303. CFDictionaryAddValue((CFMutableDictionaryRef)settings,
  1304.  kCFStreamSSLIsServer, kCFBooleanTrue);
  1306. CFDictionaryAddValue((CFMutableDictionaryRef)settings,
  1307.  kCFStreamSSLCertificates, (CFArrayRef)certificates);
  1309. // Configure this connection to use the highest possible SSL level
  1310. CFDictionaryAddValue((CFMutableDictionaryRef)settings,
  1311.  kCFStreamSSLLevel, kCFStreamSocketSecurityLevelNegotiatedSSL);
  1313. CFReadStreamSetProperty([asyncSocket getCFReadStream],
  1314. kCFStreamPropertySSLSettings, (CFDictionaryRef)settings);
  1315. CFWriteStreamSetProperty([asyncSocket getCFWriteStream],
  1316.  kCFStreamPropertySSLSettings, (CFDictionaryRef)settings);
  1317. }
  1318. }
  1319. return YES;
  1320. }
  1322. /**
  1323.  * This method is called after the socket has successfully read data from the stream.
  1324.  * Remember that this method will only be called after the socket reaches a CRLF, or after it's read the proper length.
  1325. **/
  1326. - (void)onSocket:(AsyncSocket *)sock didReadData:(NSData*)data withTag:(long)tag
  1327. {
  1328. if(tag == HTTP_REQUEST_HEADER)
  1329. {
  1330. // Append the header line to the http message
  1331. BOOL result = CFHTTPMessageAppendBytes(request, [data bytes], [data length]);
  1332. if(!result)
  1333. {
  1334. // We have a received a malformed request
  1335. [self handleInvalidRequest:data];
  1336. }
  1337. else if(!CFHTTPMessageIsHeaderComplete(request))
  1338. {
  1339. // We don't have a complete header yet
  1340. // That is, we haven't yet received a CRLF on a line by itself, indicating the end of the header
  1341. if(++numHeaderLines > LIMIT_MAX_HEADER_LINES)
  1342. {
  1343. // Reached the maximum amount of header lines in a single HTTP request
  1344. // This could be an attempted DOS attack
  1345. [asyncSocket disconnect];
  1346. }
  1347. else
  1348. {
  1349. [asyncSocket readDataToData:[AsyncSocket CRLFData]
  1350. withTimeout:READ_TIMEOUT
  1351.   maxLength:LIMIT_MAX_HEADER_LINE_LENGTH
  1352. tag:HTTP_REQUEST_HEADER];
  1353. }
  1354. }
  1355. else
  1356. {
  1357. // We have an entire HTTP request header from the client
  1359. // Check to see if it's a POST (upload) request
  1360. NSString *method = [(NSString *)CFHTTPMessageCopyRequestMethod(request) autorelease];
  1361. if([method isEqualToString:@"POST"])
  1362. {
  1363. NSURL *uri = [(NSURL *)CFHTTPMessageCopyRequestURL(request) autorelease];
  1365. NSString *contentLengthStr =
  1366.     [(NSString *)CFHTTPMessageCopyHeaderFieldValue(request, CFSTR("Content-Length")) autorelease];
  1368. if(contentLengthStr == nil)
  1369. {
  1370. // Received POST with no specified Content-Length
  1371. [self handleInvalidRequest:nil];
  1372. return;
  1373. }
  1375. if(![NSNumber parseString:(NSString *)contentLengthStr intoUInt64:&postContentLength])
  1376. {
  1377. // Unable to parse Content-Length header into a valid number
  1378. [self handleInvalidRequest:nil];
  1379. return;
  1380. }
  1382. if(![self supportsPOST:[uri relativeString] withSize:postContentLength])
  1383. {
  1384. // POST is unsupported - either in general, or for this specific request
  1385. // Send a 405 - Method not allowed response
  1386. [self handleUnknownMethod:method];
  1387. return;
  1388. }
  1390. // Reset the total amount of data received for the POST
  1391. postTotalBytesReceived = 0;
  1393. // Start reading the POST body
  1394. unsigned int bytesToRead = postContentLength < POST_CHUNKSIZE ? postContentLength : POST_CHUNKSIZE;
  1396. [asyncSocket readDataToLength:bytesToRead withTimeout:READ_TIMEOUT tag:HTTP_REQUEST_BODY];
  1397. }
  1398. else
  1399. {
  1400. // Now we need to reply to the request
  1401. [self replyToHTTPRequest];
  1402. }
  1403. }
  1404. }
  1405. else
  1406. {
  1407. // Handle a chunk of data from the POST body
  1409. postTotalBytesReceived += [data length];
  1410. [self processPostDataChunk:data];
  1412. if(postTotalBytesReceived < postContentLength)
  1413. {
  1414. // We're not done reading the post body yet...
  1415. UInt64 bytesLeft = postContentLength - postTotalBytesReceived;
  1417. unsigned int bytesToRead = bytesLeft < POST_CHUNKSIZE ? bytesLeft : POST_CHUNKSIZE;
  1419. [asyncSocket readDataToLength:bytesToRead withTimeout:READ_TIMEOUT tag:HTTP_REQUEST_BODY];
  1420. }
  1421. else
  1422. {
  1423. // Now we need to reply to the request
  1424. [self replyToHTTPRequest];
  1425. }
  1426. }
  1427. }
  1429. /**
  1430.  * This method is called after the socket has successfully written data to the stream.
  1431.  * Remember that this method will be called after a complete response to a request has been written.
  1432. **/
  1433. - (void)onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag
  1434. {
  1435. BOOL doneSendingResponse = NO;
  1437. if(tag == HTTP_PARTIAL_RESPONSE_BODY)
  1438. {
  1439. // We only wrote a part of the http response - there may be more.
  1440. NSData *data = [httpResponse readDataOfLength:READ_CHUNKSIZE];
  1442. if([data length] > 0)
  1443. {
  1444. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1445. }
  1446. else
  1447. {
  1448. doneSendingResponse = YES;
  1449. }
  1450. }
  1451. else if(tag == HTTP_PARTIAL_RANGE_RESPONSE_BODY)
  1452. {
  1453. // We only wrote a part of the range - there may be more.
  1454. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  1456. UInt64 offset = [httpResponse offset];
  1457. UInt64 bytesRead = offset - range.location;
  1458. UInt64 bytesLeft = range.length - bytesRead;
  1460. if(bytesLeft > 0)
  1461. {
  1462. unsigned int bytesToRead = bytesLeft < READ_CHUNKSIZE ? bytesLeft : READ_CHUNKSIZE;
  1464. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  1466. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1467. }
  1468. else
  1469. {
  1470. doneSendingResponse = YES;
  1471. }
  1472. }
  1473. else if(tag == HTTP_PARTIAL_RANGES_RESPONSE_BODY)
  1474. {
  1475. // We only wrote part of the range - there may be more.
  1476. // Plus, there may be more ranges.
  1477. DDRange range = [[ranges objectAtIndex:rangeIndex] ddrangeValue];
  1479. UInt64 offset = [httpResponse offset];
  1480. UInt64 bytesRead = offset - range.location;
  1481. UInt64 bytesLeft = range.length - bytesRead;
  1483. if(bytesLeft > 0)
  1484. {
  1485. unsigned int bytesToRead = bytesLeft < READ_CHUNKSIZE ? bytesLeft : READ_CHUNKSIZE;
  1487. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  1489. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1490. }
  1491. else
  1492. {
  1493. if(++rangeIndex < [ranges count])
  1494. {
  1495. // Write range header
  1496. NSData *rangeHeader = [ranges_headers objectAtIndex:rangeIndex];
  1497. [asyncSocket writeData:rangeHeader withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_HEADER];
  1499. // Start writing range body
  1500. range = [[ranges objectAtIndex:rangeIndex] ddrangeValue];
  1502. [httpResponse setOffset:range.location];
  1504. unsigned int bytesToRead = range.length < READ_CHUNKSIZE ? range.length : READ_CHUNKSIZE;
  1506. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  1508. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1509. }
  1510. else
  1511. {
  1512. // We're not done yet - we still have to send the closing boundry tag
  1513. NSString *endingBoundryStr = [NSString stringWithFormat:@"rn--%@--rn", ranges_boundry];
  1514. NSData *endingBoundryData = [endingBoundryStr dataUsingEncoding:NSUTF8StringEncoding];
  1516. [asyncSocket writeData:endingBoundryData withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_RESPONSE];
  1517. }
  1518. }
  1519. }
  1520. else if(tag == HTTP_RESPONSE || tag == HTTP_FINAL_RESPONSE)
  1521. {
  1522. doneSendingResponse = YES;
  1523. }
  1525. if(doneSendingResponse)
  1526. {
  1527. if(tag == HTTP_FINAL_RESPONSE)
  1528. {
  1529. // Terminate the connection
  1530. [asyncSocket disconnect];
  1531. }
  1532. else
  1533. {
  1534. // Cleanup after the last request
  1535. // And start listening for the next request
  1537. // Release any resources we no longer need
  1538. [httpResponse release];
  1539. httpResponse = nil;
  1541. [ranges release];
  1542. [ranges_headers release];
  1543. [ranges_boundry release];
  1544. ranges = nil;
  1545. ranges_headers = nil;
  1546. ranges_boundry = nil;
  1548. // Release the old request, and create a new one
  1549. if(request) CFRelease(request);
  1550. request = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, YES);
  1552. numHeaderLines = 0;
  1554. // And start listening for more requests
  1555. [asyncSocket readDataToData:[AsyncSocket CRLFData]
  1556. withTimeout:READ_TIMEOUT
  1557.   maxLength:LIMIT_MAX_HEADER_LINE_LENGTH
  1558. tag:HTTP_REQUEST_HEADER];
  1559. }
  1560. }
  1561. }
  1563. /**
  1564.  * This message is sent:
  1565.  *  - if there is an connection, time out, or other i/o error.
  1566.  *  - if the remote socket cleanly disconnects.
  1567.  *  - before the local socket is disconnected.
  1568. **/
  1569. - (void)onSocket:(AsyncSocket *)sock willDisconnectWithError:(NSError *)err
  1570. {
  1571. // //NSLog(@"HTTPConnection: onSocket:willDisconnectWithError: %@", err);
  1572. }
  1574. /**
  1575.  * Sent after the socket has been disconnected.
  1576. **/
  1577. - (void)onSocketDidDisconnect:(AsyncSocket *)sock
  1578. {
  1579. [self die];
  1580. }
  1582. @end