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

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

iPhone

开发平台：

Objective-C

HTTPConnection.m：源码内容
  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 of 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. // Don't start reading the HTTP request here.
  134. // We are currently running on the thread that the server's listen socket is running on.
  135. // However, the server may place us on a different thread.
  136. // We should only read/write to our socket on its proper thread.
  137. // Instead, we'll wait for the call to onSocket:didConnectToHost:port: which will be on the proper thread.
  138. }
  139. return self;
  140. }
  142. /**
  143.  * Standard Deconstructor.
  144. **/
  145. - (void)dealloc
  146. {
  147. [asyncSocket setDelegate:nil];
  148. [asyncSocket disconnect];
  149. [asyncSocket release];
  151. if(request) CFRelease(request);
  153. [nonce release];
  155. [httpResponse release];
  157. [ranges release];
  158. [ranges_headers release];
  159. [ranges_boundry release];
  161. [super dealloc];
  162. }
  164. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  165. #pragma mark Connection Control:
  166. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  168. /**
  169.  * Returns whether or not the server will accept messages of a given method
  170.  * at a particular URI.
  171. **/
  172. - (BOOL)supportsMethod:(NSString *)method atPath:(NSString *)relativePath
  173. {
  174. // Override me to support methods such as POST.
  175. // 
  176. // Things you may want to consider:
  177. // - Does the given path represent a resource that is designed to accept this method?
  178. // - If accepting an upload, is the size of the data being uploaded too big?
  179. // 
  180. // For more information, you can always access the CFHTTPMessageRef request variable.
  182. if([method isEqualToString:@"GET"])
  183. return YES;
  184. if([method isEqualToString:@"HEAD"])
  185. return YES;
  187. return NO;
  188. }
  190. /**
  191.  * Returns whether or not the server is configured to be a secure server.
  192.  * In other words, all connections to this server are immediately secured, thus only secure connections are allowed.
  193.  * This is the equivalent of having an https server, where it is assumed that all connections must be secure.
  194.  * If this is the case, then unsecure connections will not be allowed on this server, and a separate unsecure server
  195.  * would need to be run on a separate port in order to support unsecure connections.
  196.  * 
  197.  * Note: In order to support secure connections, the sslIdentityAndCertificates method must be implemented.
  198. **/
  199. - (BOOL)isSecureServer
  200. {
  201. // Override me to create an https server...
  203. return NO;
  204. }
  206. /**
  207.  * This method is expected to returns an array appropriate for use in kCFStreamSSLCertificates SSL Settings.
  208.  * It should be an array of SecCertificateRefs except for the first element in the array, which is a SecIdentityRef.
  209. **/
  210. - (NSArray *)sslIdentityAndCertificates
  211. {
  212. // Override me to provide the proper required SSL identity.
  213. // You can configure the identity for the entire server, or based on the current request
  215. return nil;
  216. }
  218. /**
  219.  * Returns whether or not the requested resource is password protected.
  220.  * In this generic implementation, nothing is password protected.
  221. **/
  222. - (BOOL)isPasswordProtected:(NSString *)path
  223. {
  224. // Override me to provide password protection...
  225. // You can configure it for the entire server, or based on the current request
  227. return NO;
  228. }
  230. /**
  231.  * Returns whether or not the authentication challenge should use digest access authentication.
  232.  * The alternative is basic authentication.
  233.  * 
  234.  * If at all possible, digest access authentication should be used because it's more secure.
  235.  * Basic authentication sends passwords in the clear and should be avoided unless using SSL/TLS.
  236. **/
  237. - (BOOL)useDigestAccessAuthentication
  238. {
  239. // Override me to use customize the authentication scheme
  240. // Make sure you understand the security consequences of using basic authentication
  242. return YES;
  243. }
  245. /**
  246.  * Returns the authentication realm.
  247.  * In this generic implmentation, a default realm is used for the entire server.
  248. **/
  249. - (NSString *)realm
  250. {
  251. // Override me to provide a custom realm...
  252. // You can configure it for the entire server, or based on the current request
  254. return @"defaultRealm@host.com";
  255. }
  257. /**
  258.  * Returns the password for the given username.
  259.  * This password will be used to generate the response hash to validate against the given response hash.
  260. **/
  261. - (NSString *)passwordForUser:(NSString *)username
  262. {
  263. // Override me to provide proper password authentication
  264. // You can configure a password for the entire server, or custom passwords for users and/or resources
  266. // Security Note:
  267. // A nil password means no access at all. (Such as for user doesn't exist)
  268. // An empty string password is allowed, and will be treated as any other password. (To support anonymous access)
  270. return nil;
  271. }
  273. /**
  274.  * Generates and returns an authentication nonce.
  275.  * A nonce is a  server-specified string uniquely generated for each 401 response.
  276.  * The default implementation uses a single nonce for each session.
  277. **/
  278. - (NSString *)generateNonce
  279. {
  280. // We use the Core Foundation UUID class to generate a nonce value for us
  281. // UUIDs (Universally Unique Identifiers) are 128-bit values guaranteed to be unique.
  282. CFUUIDRef theUUID = CFUUIDCreate(NULL);
  283. NSString *newNonce = [NSMakeCollectable(CFUUIDCreateString(NULL, theUUID)) autorelease];
  284. CFRelease(theUUID);
  286. // We have to remember that the HTTP protocol is stateless
  287. // Even though with version 1.1 persistent connections are the norm, they are not guaranteed
  288. // Thus if we generate a nonce for this connection,
  289. // it should be honored for other connections in the near future
  290. // 
  291. // In fact, this is absolutely necessary in order to support QuickTime
  292. // When QuickTime makes it's initial connection, it will be unauthorized, and will receive a nonce
  293. // It then disconnects, and creates a new connection with the nonce, and proper authentication
  294. // If we don't honor the nonce for the second connection, QuickTime will repeat the process and never connect
  296. [recentNonces addObject:newNonce];
  298. [NSTimer scheduledTimerWithTimeInterval:NONCE_TIMEOUT
  299.  target:[HTTPConnection class]
  300.    selector:@selector(removeRecentNonce:)
  301.    userInfo:newNonce
  302. repeats:NO];
  303. return newNonce;
  304. }
  306. /**
  307.  * Returns whether or not the user is properly authenticated.
  308.  * Authentication is done using Digest Access Authentication accoring to RFC 2617.
  309. **/
  310. - (BOOL)isAuthenticated
  311. {
  312. // Extract the authentication information from the Authorization header
  313. HTTPAuthenticationRequest *auth = [[[HTTPAuthenticationRequest alloc] initWithRequest:request] autorelease];
  315. if([self useDigestAccessAuthentication])
  316. {
  317. // Digest Access Authentication
  319. if(![auth isDigest])
  320. {
  321. // User didn't send proper digest access authentication credentials
  322. return NO;
  323. }
  325. if([auth username] == nil)
  326. {
  327. // The client didn't provide a username
  328. // Most likely they didn't provide any authentication at all
  329. return NO;
  330. }
  332. NSString *password = [self passwordForUser:[auth username]];
  333. if(password == nil)
  334. {
  335. // No access allowed (username doesn't exist in system)
  336. return NO;
  337. }
  339. NSString *method = [NSMakeCollectable(CFHTTPMessageCopyRequestMethod(request)) autorelease];
  341. NSURL *absoluteUrl = [NSMakeCollectable(CFHTTPMessageCopyRequestURL(request)) autorelease];
  342. NSString *url = [absoluteUrl relativeString];
  344. if(![url isEqualToString:[auth uri]])
  345. {
  346. // Requested URL and Authorization URI do not match
  347. // This could be a replay attack
  348. // IE - attacker provides same authentication information, but requests a different resource
  349. return NO;
  350. }
  352. // The nonce the client provided will most commonly be stored in our local (cached) nonce variable
  353. if(![nonce isEqualToString:[auth nonce]])
  354. {
  355. // The given nonce may be from another connection
  356. // We need to search our list of recent nonce strings that have been recently distributed
  357. if([recentNonces containsObject:[auth nonce]])
  358. {
  359. // Store nonce in local (cached) nonce variable to prevent array searches in the future
  360. [nonce release];
  361. nonce = [[auth nonce] copy];
  363. // The client has switched to using a different nonce value
  364. // This may happen if the client tries to get a file in a directory with different credentials.
  365. // The previous credentials wouldn't work, and the client would receive a 401 error
  366. // along with a new nonce value. The client then uses this new nonce value and requests the file again.
  367. // Whatever the case may be, we need to reset lastNC, since that variable is on a per nonce basis.
  368. lastNC = 0;
  369. }
  370. else
  371. {
  372. // We have no knowledge of ever distributing such a nonce
  373. // This could be a replay attack from a previous connection in the past
  374. return NO;
  375. }
  376. }
  378. long authNC = strtol([[auth nc] UTF8String], NULL, 16);
  380. if(authNC <= lastNC)
  381. {
  382. // The nc value (nonce count) hasn't been incremented since the last request
  383. // This could be a replay attack
  384. return NO;
  385. }
  386. lastNC = authNC;
  388. NSString *HA1str = [NSString stringWithFormat:@"%@:%@:%@", [auth username], [auth realm], password];
  389. NSString *HA2str = [NSString stringWithFormat:@"%@:%@", method, [auth uri]];
  391. NSString *HA1 = [[[HA1str dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
  393. NSString *HA2 = [[[HA2str dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
  395. NSString *responseStr = [NSString stringWithFormat:@"%@:%@:%@:%@:%@:%@",
  396.  HA1, [auth nonce], [auth nc], [auth cnonce], [auth qop], HA2];
  398. NSString *response = [[[responseStr dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue];
  400. return [response isEqualToString:[auth response]];
  401. }
  402. else
  403. {
  404. // Basic Authentication
  406. if(![auth isBasic])
  407. {
  408. // User didn't send proper base authentication credentials
  409. return NO;
  410. }
  412. // Decode the base 64 encoded credentials
  413. NSString *base64Credentials = [auth base64Credentials];
  415. NSData *temp = [[base64Credentials dataUsingEncoding:NSUTF8StringEncoding] base64Decoded];
  417. NSString *credentials = [[[NSString alloc] initWithData:temp encoding:NSUTF8StringEncoding] autorelease];
  419. // The credentials should be of the form "username:password"
  420. // The username is not allowed to contain a colon
  422. NSRange colonRange = [credentials rangeOfString:@":"];
  424. if(colonRange.length == 0)
  425. {
  426. // Malformed credentials
  427. return NO;
  428. }
  430. NSString *credUsername = [credentials substringToIndex:colonRange.location];
  431. NSString *credPassword = [credentials substringFromIndex:(colonRange.location + colonRange.length)];
  433. NSString *password = [self passwordForUser:credUsername];
  434. if(password == nil)
  435. {
  436. // No access allowed (username doesn't exist in system)
  437. return NO;
  438. }
  440. return [password isEqualToString:credPassword];
  441. }
  442. }
  444. /**
  445.  * Adds a digest access authentication challenge to the given response.
  446. **/
  447. - (void)addDigestAuthChallenge:(CFHTTPMessageRef)response
  448. {
  449. NSString *authFormat = @"Digest realm="%@", qop="auth", nonce="%@"";
  450. NSString *authInfo = [NSString stringWithFormat:authFormat, [self realm], [self generateNonce]];
  452. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("WWW-Authenticate"), (CFStringRef)authInfo);
  453. }
  455. /**
  456.  * Adds a basic authentication challenge to the given response.
  457. **/
  458. - (void)addBasicAuthChallenge:(CFHTTPMessageRef)response
  459. {
  460. NSString *authFormat = @"Basic realm="%@"";
  461. NSString *authInfo = [NSString stringWithFormat:authFormat, [self realm]];
  463. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("WWW-Authenticate"), (CFStringRef)authInfo);
  464. }
  466. /**
  467.  * Attempts to parse the given range header into a series of non-overlapping ranges.
  468.  * If successfull, the variables 'ranges' and 'rangeIndex' will be updated, and YES will be returned.
  469.  * Otherwise, NO is returned, and the range request should be ignored.
  470.  **/
  471. - (BOOL)parseRangeRequest:(NSString *)rangeHeader withContentLength:(UInt64)contentLength
  472. {
  473. // Examples of byte-ranges-specifier values (assuming an entity-body of length 10000):
  474. // 
  475. // - The first 500 bytes (byte offsets 0-499, inclusive):  bytes=0-499
  476. // 
  477. // - The second 500 bytes (byte offsets 500-999, inclusive): bytes=500-999
  478. // 
  479. // - The final 500 bytes (byte offsets 9500-9999, inclusive): bytes=-500
  480. // 
  481. // - Or bytes=9500-
  482. // 
  483. // - The first and last bytes only (bytes 0 and 9999):  bytes=0-0,-1
  484. // 
  485. // - Several legal but not canonical specifications of the second 500 bytes (byte offsets 500-999, inclusive):
  486. // bytes=500-600,601-999
  487. // bytes=500-700,601-999
  488. // 
  490. NSRange eqsignRange = [rangeHeader rangeOfString:@"="];
  492. if(eqsignRange.location == NSNotFound) return NO;
  494. NSUInteger tIndex = eqsignRange.location;
  495. NSUInteger fIndex = eqsignRange.location + eqsignRange.length;
  497. NSString *rangeType  = [[[rangeHeader substringToIndex:tIndex] mutableCopy] autorelease];
  498. NSString *rangeValue = [[[rangeHeader substringFromIndex:fIndex] mutableCopy] autorelease];
  500. CFStringTrimWhitespace((CFMutableStringRef)rangeType);
  501. CFStringTrimWhitespace((CFMutableStringRef)rangeValue);
  503. if([rangeType caseInsensitiveCompare:@"bytes"] != NSOrderedSame) return NO;
  505. NSArray *rangeComponents = [rangeValue componentsSeparatedByString:@","];
  507. if([rangeComponents count] == 0) return NO;
  509. [ranges release];
  510. ranges = [[NSMutableArray alloc] initWithCapacity:[rangeComponents count]];
  512. rangeIndex = 0;
  514. // Note: We store all range values in the form of NSRange structs, wrapped in NSValue objects.
  515. // Since NSRange consists of NSUInteger values, the range is limited to 4 gigs on 32-bit architectures (ppc, i386)
  517. NSUInteger i;
  518. for(i = 0; i < [rangeComponents count]; i++)
  519. {
  520. NSString *rangeComponent = [rangeComponents objectAtIndex:i];
  522. NSRange dashRange = [rangeComponent rangeOfString:@"-"];
  524. if(dashRange.location == NSNotFound)
  525. {
  526. // We're dealing with an individual byte number
  528. UInt64 byteIndex;
  529. if(![NSNumber parseString:rangeComponent intoUInt64:&byteIndex]) return NO;
  531. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(byteIndex, 1)]];
  532. }
  533. else
  534. {
  535. // We're dealing with a range of bytes
  537. tIndex = dashRange.location;
  538. fIndex = dashRange.location + dashRange.length;
  540. NSString *r1str = [rangeComponent substringToIndex:tIndex];
  541. NSString *r2str = [rangeComponent substringFromIndex:fIndex];
  543. UInt64 r1, r2;
  545. BOOL hasR1 = [NSNumber parseString:r1str intoUInt64:&r1];
  546. BOOL hasR2 = [NSNumber parseString:r2str intoUInt64:&r2];
  548. if(!hasR1)
  549. {
  550. // We're dealing with a "-[#]" range
  551. // 
  552. // r2 is the number of ending bytes to include in the range
  554. if(!hasR2) return NO;
  555. if(r2 > contentLength) return NO;
  557. UInt64 startIndex = contentLength - r2;
  559. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(startIndex, r2)]];
  560. }
  561. else if(!hasR2)
  562. {
  563. // We're dealing with a "[#]-" range
  564. // 
  565. // r1 is the starting index of the range, which goes all the way to the end
  567. if(!hasR1) return NO;
  568. if(r1 >= contentLength) return NO;
  570. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(r1, contentLength - r1)]];
  571. }
  572. else
  573. {
  574. // We're dealing with a normal "[#]-[#]" range
  575. // 
  576. // Note: The range is inclusive. So 0-1 has a length of 2 bytes.
  578. if(!hasR1) return NO;
  579. if(!hasR2) return NO;
  580. if(r1 > r2) return NO;
  582. [ranges addObject:[NSValue valueWithDDRange:DDMakeRange(r1, r2 - r1 + 1)]];
  583. }
  584. }
  585. }
  587. if([ranges count] == 0) return NO;
  589. for(i = 0; i < [ranges count] - 1; i++)
  590. {
  591. DDRange range1 = [[ranges objectAtIndex:i] ddrangeValue];
  593. NSUInteger j;
  594. for(j = i+1; j < [ranges count]; j++)
  595. {
  596. DDRange range2 = [[ranges objectAtIndex:j] ddrangeValue];
  598. DDRange iRange = DDIntersectionRange(range1, range2);
  600. if(iRange.length != 0)
  601. {
  602. return NO;
  603. }
  604. }
  605. }
  607. return YES;
  608. }
  610. /**
  611.  * Gets the current date and time, formatted properly (according to RFC) for insertion into an HTTP header.
  612. **/
  613. - (NSString *)dateAsString:(NSDate *)date
  614. {
  615. // Example: Sun, 06 Nov 1994 08:49:37 GMT
  617. NSDateFormatter *df = [[[NSDateFormatter alloc] init] autorelease];
  618. [df setFormatterBehavior:NSDateFormatterBehavior10_4];
  619. [df setTimeZone:[NSTimeZone timeZoneWithAbbreviation:@"GMT"]];
  620. [df setDateFormat:@"EEE, dd MMM y HH:mm:ss 'GMT'"];
  622. // For some reason, using zzz in the format string produces GMT+00:00
  624. return [df stringFromDate:date];
  625. }
  627. /**
  628.  * This method is called after a full HTTP request has been received.
  629.  * The current request is in the CFHTTPMessage request variable.
  630. **/
  631. - (void)replyToHTTPRequest
  632. {
  633. // Check the HTTP version - if it's anything but HTTP version 1.1, we don't support it
  634. NSString *version = [NSMakeCollectable(CFHTTPMessageCopyVersion(request)) autorelease];
  635. if(!version || ![version isEqualToString:(NSString *)kCFHTTPVersion1_1])
  636. {
  637. [self handleVersionNotSupported:version];
  638. return;
  639. }
  641. // Extract the method
  642. NSString *method = [NSMakeCollectable(CFHTTPMessageCopyRequestMethod(request)) autorelease];
  644. // Note: We already checked to ensure the method was supported in onSocket:didReadData:withTag:
  646. // Extract requested URI
  647. NSURL *uri = [NSMakeCollectable(CFHTTPMessageCopyRequestURL(request)) autorelease];
  649. // Check Authentication (if needed)
  650. // If not properly authenticated for resource, issue Unauthorized response
  651. if([self isPasswordProtected:[uri relativeString]] && ![self isAuthenticated])
  652. {
  653. [self handleAuthenticationFailed];
  654. return;
  655. }
  657. // Respond properly to HTTP 'GET' and 'HEAD' commands
  658. httpResponse = [[self httpResponseForMethod:method URI:[uri relativeString]] retain];
  660. UInt64 contentLength = httpResponse ? [httpResponse contentLength] : 0;
  662. if(contentLength == 0)
  663. {
  664. [self handleResourceNotFound];
  666. [httpResponse release];
  667. httpResponse = nil;
  669. return;
  670.     }
  672. // Check for specific range request
  673. NSString *rangeHeader = [NSMakeCollectable(CFHTTPMessageCopyHeaderFieldValue(request, CFSTR("Range"))) autorelease];
  675. BOOL isRangeRequest = NO;
  677. if(rangeHeader)
  678. {
  679. if([self parseRangeRequest:rangeHeader withContentLength:contentLength])
  680. {
  681. isRangeRequest = YES;
  682. }
  683. }
  685. CFHTTPMessageRef response;
  687. if(!isRangeRequest)
  688. {
  689. // Status Code 200 - OK
  690. response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 200, NULL, kCFHTTPVersion1_1);
  692. NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", contentLength];
  693. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  694. }
  695. else
  696. {
  697. if([ranges count] == 1)
  698. {
  699. response = [self prepareUniRangeResponse:contentLength];
  700. }
  701. else
  702. {
  703. response = [self prepareMultiRangeResponse:contentLength];
  704. }
  705. }
  706.     
  707. // If they issue a 'HEAD' command, we don't have to include the file
  708. // If they issue a 'GET' command, we need to include the file
  709. if([method isEqual:@"HEAD"])
  710. {
  711. NSData *responseData = [self preprocessResponse:response];
  712. [asyncSocket writeData:responseData withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_RESPONSE];
  713. }
  714. else
  715. {
  716. // Write the header response
  717. NSData *responseData = [self preprocessResponse:response];
  718. [asyncSocket writeData:responseData withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_HEADER];
  720. // Now we need to send the body of the response
  721. if(!isRangeRequest)
  722. {
  723. // Regular request
  724. NSData *data = [httpResponse readDataOfLength:READ_CHUNKSIZE];
  726. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_BODY];
  727. }
  728. else
  729. {
  730. // Client specified a byte range in request
  732. if([ranges count] == 1)
  733. {
  734. // Client is requesting a single range
  735. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  737. [httpResponse setOffset:range.location];
  739. unsigned int bytesToRead = range.length < READ_CHUNKSIZE ? range.length : READ_CHUNKSIZE;
  741. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  743. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:HTTP_PARTIAL_RANGE_RESPONSE_BODY];
  744. }
  745. else
  746. {
  747. // Client is requesting multiple ranges
  748. // We have to send each range using multipart/byteranges
  750. // Write range header
  751. NSData *rangeHeader = [ranges_headers objectAtIndex:0];
  752. [asyncSocket writeData:rangeHeader withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_HEADER];
  754. // Start writing range body
  755. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  757. [httpResponse setOffset:range.location];
  759. unsigned int bytesToRead = range.length < READ_CHUNKSIZE ? range.length : READ_CHUNKSIZE;
  761. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  763. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:HTTP_PARTIAL_RANGES_RESPONSE_BODY];
  764. }
  765. }
  766. }
  768. CFRelease(response);
  769. }
  771. /**
  772.  * Prepares a single-range response.
  773.  * 
  774.  * Note: The returned CFHTTPMessageRef is owned by the sender, who is responsible for releasing it.
  775. **/
  776. - (CFHTTPMessageRef)prepareUniRangeResponse:(UInt64)contentLength
  777. {
  778. // Status Code 206 - Partial Content
  779. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 206, NULL, kCFHTTPVersion1_1);
  781. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  783. NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", range.length];
  784. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  786. NSString *rangeStr = [NSString stringWithFormat:@"%qu-%qu", range.location, DDMaxRange(range) - 1];
  787. NSString *contentRangeStr = [NSString stringWithFormat:@"bytes %@/%qu", rangeStr, contentLength];
  788. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Range"), (CFStringRef)contentRangeStr);
  790. return response;
  791. }
  793. /**
  794.  * Prepares a multi-range response.
  795.  * 
  796.  * Note: The returned CFHTTPMessageRef is owned by the sender, who is responsible for releasing it.
  797. **/
  798. - (CFHTTPMessageRef)prepareMultiRangeResponse:(UInt64)contentLength
  799. {
  800. // Status Code 206 - Partial Content
  801. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 206, NULL, kCFHTTPVersion1_1);
  803. // We have to send each range using multipart/byteranges
  804. // So each byterange has to be prefix'd and suffix'd with the boundry
  805. // Example:
  806. // 
  807. // HTTP/1.1 206 Partial Content
  808. // Content-Length: 220
  809. // Content-Type: multipart/byteranges; boundary=4554d24e986f76dd6
  810. // 
  811. // 
  812. // --4554d24e986f76dd6
  813. // Content-range: bytes 0-25/4025
  814. // 
  815. // [...]
  816. // --4554d24e986f76dd6
  817. // Content-range: bytes 3975-4024/4025
  818. // 
  819. // [...]
  820. // --4554d24e986f76dd6--
  822. ranges_headers = [[NSMutableArray alloc] initWithCapacity:[ranges count]];
  824. CFUUIDRef theUUID = CFUUIDCreate(NULL);
  825. ranges_boundry = NSMakeCollectable(CFUUIDCreateString(NULL, theUUID));
  826. CFRelease(theUUID);
  828. NSString *startingBoundryStr = [NSString stringWithFormat:@"rn--%@rn", ranges_boundry];
  829. NSString *endingBoundryStr = [NSString stringWithFormat:@"rn--%@--rn", ranges_boundry];
  831. UInt64 actualContentLength = 0;
  833. unsigned i;
  834. for(i = 0; i < [ranges count]; i++)
  835. {
  836. DDRange range = [[ranges objectAtIndex:i] ddrangeValue];
  838. NSString *rangeStr = [NSString stringWithFormat:@"%qu-%qu", range.location, DDMaxRange(range) - 1];
  839. NSString *contentRangeVal = [NSString stringWithFormat:@"bytes %@/%qu", rangeStr, contentLength];
  840. NSString *contentRangeStr = [NSString stringWithFormat:@"Content-Range: %@rnrn", contentRangeVal];
  842. NSString *fullHeader = [startingBoundryStr stringByAppendingString:contentRangeStr];
  843. NSData *fullHeaderData = [fullHeader dataUsingEncoding:NSUTF8StringEncoding];
  845. [ranges_headers addObject:fullHeaderData];
  847. actualContentLength += [fullHeaderData length];
  848. actualContentLength += range.length;
  849. }
  851. NSData *endingBoundryData = [endingBoundryStr dataUsingEncoding:NSUTF8StringEncoding];
  853. actualContentLength += [endingBoundryData length];
  855. NSString *contentLengthStr = [NSString stringWithFormat:@"%qu", actualContentLength];
  856. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  858. NSString *contentTypeStr = [NSString stringWithFormat:@"multipart/byteranges; boundary=%@", ranges_boundry];
  859. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Type"), (CFStringRef)contentTypeStr);
  861. return response;
  862. }
  864. /**
  865.  * Converts relative URI path into full file-system path.
  866. **/
  867. - (NSString *)filePathForURI:(NSString *)path
  868. {
  869. // Override me to perform custom path mapping.
  870. // For example you may want to use a default file other than index.html, or perhaps support multiple types.
  872. // If there is no configured documentRoot, then it makes no sense to try to return anything
  873. if(![server documentRoot]) return nil;
  875. // Convert path to a relative path.
  876. // This essentially means trimming beginning '/' characters.
  877. // Beware of a bug in the Cocoa framework:
  878. // 
  879. // [NSURL URLWithString:@"/foo" relativeToURL:baseURL]       == @"/baseURL/foo"
  880. // [NSURL URLWithString:@"/foo%20bar" relativeToURL:baseURL] == @"/foo bar"
  881. // [NSURL URLWithString:@"/foo" relativeToURL:baseURL]       == @"/foo"
  883. NSString *relativePath = path;
  885. while([relativePath hasPrefix:@"/"] && [relativePath length] > 1)
  886. {
  887. relativePath = [relativePath substringFromIndex:1];
  888. }
  890. NSURL *url;
  892. if([relativePath hasSuffix:@"/"])
  893. {
  894. NSString *completedRelativePath = [relativePath stringByAppendingString:@"index.html"];
  895. url = [NSURL URLWithString:completedRelativePath relativeToURL:[server documentRoot]];
  896. }
  897. else
  898. {
  899. url = [NSURL URLWithString:relativePath relativeToURL:[server documentRoot]];
  900. }
  902. // Watch out for sneaky requests with ".." in the path
  903. // For example, the following request: "../Documents/TopSecret.doc"
  904. if(![[url path] hasPrefix:[[server documentRoot] path]]) return nil;
  906. return [[url path] stringByStandardizingPath];
  907. }
  909. /**
  910.  * This method is called to get a response for a request.
  911.  * You may return any object that adopts the HTTPResponse protocol.
  912.  * The HTTPServer comes with two such classes: HTTPFileResponse and HTTPDataResponse.
  913.  * HTTPFileResponse is a wrapper for an NSFileHandle object, and is the preferred way to send a file response.
  914.  * HTTPDataResponse is a wrapper for an NSData object, and may be used to send a custom response.
  915. **/
  916. - (NSObject<HTTPResponse> *)httpResponseForMethod:(NSString *)method URI:(NSString *)path
  917. {
  918. // Override me to provide custom responses.
  920. NSString *filePath = [self filePathForURI:path];
  922. if([[NSFileManager defaultManager] fileExistsAtPath:filePath])
  923. {
  924. return [[[HTTPFileResponse alloc] initWithFilePath:filePath] autorelease];
  925. }
  927. return nil;
  928. }
  930. /**
  931.  * This method is called after receiving all HTTP headers, but before reading any of the request body.
  932. **/
  933. - (void)prepareForBodyWithSize:(UInt64)contentLength
  934. {
  935. // Override me to allocate buffers, file handles, etc.
  936. }
  938. /**
  939.  * This method is called to handle data read from a POST / PUT.
  940.  * The given data is part of the request body.
  941. **/
  942. - (void)processDataChunk:(NSData *)postDataChunk
  943. {
  944. // Override me to do something useful with a POST / PUT.
  945. // If the post is small, such as a simple form, you may want to simply append the data to the request.
  946. // If the post is big, such as a file upload, you may want to store the file to disk.
  947. // 
  948. // Remember: In order to support LARGE POST uploads, the data is read in chunks.
  949. // This prevents a 50 MB upload from being stored in RAM.
  950. // The size of the chunks are limited by the POST_CHUNKSIZE definition.
  951. // Therefore, this method may be called multiple times for the same POST request.
  952. }
  954. /**
  955.  * Called if the HTML version is other than what is supported
  956. **/
  957. - (void)handleVersionNotSupported:(NSString *)version
  958. {
  959. // Override me for custom error handling of unspupported http version responses
  960. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  961. // You can also use preprocessErrorResponse: to add an optional HTML body.
  963. NSLog(@"HTTP Server: Error 505 - Version Not Supported: %@", version);
  965. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 505, NULL, kCFHTTPVersion1_1);
  966. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  967.     
  968. NSData *responseData = [self preprocessErrorResponse:response];
  969. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_RESPONSE];
  971. CFRelease(response);
  972. }
  974. /**
  975.  * Called if the authentication information was required and absent, or if authentication failed.
  976. **/
  977. - (void)handleAuthenticationFailed
  978. {
  979. // Override me for custom handling of authentication challenges
  980. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  981. // You can also use preprocessErrorResponse: to add an optional HTML body.
  983. NSLog(@"HTTP Server: Error 401 - Unauthorized");
  985. // Status Code 401 - Unauthorized
  986. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 401, NULL, kCFHTTPVersion1_1);
  987. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  989. if([self useDigestAccessAuthentication])
  990. {
  991. [self addDigestAuthChallenge:response];
  992. }
  993. else
  994. {
  995. [self addBasicAuthChallenge:response];
  996. }
  998. NSData *responseData = [self preprocessErrorResponse:response];
  999. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_RESPONSE];
  1001. CFRelease(response);
  1002. }
  1004. /**
  1005.  * Called if we receive some sort of malformed HTTP request.
  1006.  * The data parameter is the invalid HTTP header line, including CRLF, as read from AsyncSocket.
  1007.  * The data parameter may also be nil if the request as a whole was invalid, such as a POST with no Content-Length.
  1008. **/
  1009. - (void)handleInvalidRequest:(NSData *)data
  1010. {
  1011. // Override me for custom error handling of invalid HTTP requests
  1012. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1013. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1015. NSLog(@"HTTP Server: Error 400 - Bad Request");
  1017. // Status Code 400 - Bad Request
  1018. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 400, NULL, kCFHTTPVersion1_1);
  1019. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1021. NSData *responseData = [self preprocessErrorResponse:response];
  1022. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_FINAL_RESPONSE];
  1024. CFRelease(response);
  1025. }
  1027. /**
  1028.  * Called if we receive a HTTP request with a method other than GET or HEAD.
  1029. **/
  1030. - (void)handleUnknownMethod:(NSString *)method
  1031. {
  1032. // Override me to add support for methods other than GET and HEAD
  1033. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1034. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1036. NSLog(@"HTTP Server: Error 405 - Method Not Allowed: %@", method);
  1038. // Status code 405 - Method Not Allowed
  1039.     CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 405, NULL, kCFHTTPVersion1_1);
  1040. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1042. NSData *responseData = [self preprocessErrorResponse:response];
  1043. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_FINAL_RESPONSE];
  1044.     
  1045. CFRelease(response);
  1047. // Note: We used the HTTP_FINAL_RESPONSE tag to disconnect after the response is sent.
  1048. // We do this because the method may include an http body.
  1049. // Since we can't be sure, we should close the connection.
  1050. }
  1052. - (void)handleResourceNotFound
  1053. {
  1054. // Override me for custom error handling of 404 not found responses
  1055. // If you simply want to add a few extra header fields, see the preprocessErrorResponse: method.
  1056. // You can also use preprocessErrorResponse: to add an optional HTML body.
  1058. NSLog(@"HTTP Server: Error 404 - Not Found");
  1060. // Status Code 404 - Not Found
  1061. CFHTTPMessageRef response = CFHTTPMessageCreateResponse(kCFAllocatorDefault, 404, NULL, kCFHTTPVersion1_1);
  1062. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), CFSTR("0"));
  1064. NSData *responseData = [self preprocessErrorResponse:response];
  1065. [asyncSocket writeData:responseData withTimeout:WRITE_ERROR_TIMEOUT tag:HTTP_RESPONSE];
  1067. CFRelease(response);
  1068. }
  1070. /**
  1071.  * This method is called immediately prior to sending the response headers.
  1072.  * This method adds standard header fields, and then converts the response to an NSData object.
  1073. **/
  1074. - (NSData *)preprocessResponse:(CFHTTPMessageRef)response
  1075. {
  1076. // Override me to customize the response headers
  1077. // You'll likely want to add your own custom headers, and then return [super preprocessResponse:response]
  1079. // Add standard headers
  1080. NSString *now = [self dateAsString:[NSDate date]];
  1081. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Date"), (CFStringRef)now);
  1083. // Add server capability headers
  1084. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Accept-Ranges"), CFSTR("bytes"));
  1086. // Add optional response headers
  1087. if([httpResponse respondsToSelector:@selector(httpHeaders)])
  1088. {
  1089. NSDictionary *responseHeaders = [httpResponse httpHeaders];
  1091. NSEnumerator *keyEnumerator = [responseHeaders keyEnumerator];
  1092. NSString *key;
  1094. while(key = [keyEnumerator nextObject])
  1095. {
  1096. NSString *value = [responseHeaders objectForKey:key];
  1098. CFHTTPMessageSetHeaderFieldValue(response, (CFStringRef)key, (CFStringRef)value);
  1099. }
  1100. }
  1102. NSData *result = NSMakeCollectable(CFHTTPMessageCopySerializedMessage(response));
  1103. return [result autorelease];
  1104. }
  1106. /**
  1107.  * This method is called immediately prior to sending the response headers (for an error).
  1108.  * This method adds standard header fields, and then converts the response to an NSData object.
  1109. **/
  1110. - (NSData *)preprocessErrorResponse:(CFHTTPMessageRef)response;
  1111. {
  1112. // Override me to customize the error response headers
  1113. // You'll likely want to add your own custom headers, and then return [super preprocessErrorResponse:response]
  1114. // 
  1115. // Notes:
  1116. // You can use CFHTTPMessageGetResponseStatusCode(response) to get the type of error.
  1117. // You can use CFHTTPMessageSetBody() to add an optional HTML body.
  1118. // If you add a body, don't forget to update the Content-Length.
  1119. // 
  1120. // if(CFHTTPMessageGetResponseStatusCode(response) == 404)
  1121. // {
  1122. //     NSString *msg = @"<html><body>Error 404 - Not Found</body></html>";
  1123. //     NSData *msgData = [msg dataUsingEncoding:NSUTF8StringEncoding];
  1124. //     
  1125. //     CFHTTPMessageSetBody(response, (CFDataRef)msgData);
  1126. //     
  1127. //     NSString *contentLengthStr = [NSString stringWithFormat:@"%u", (unsigned)[msgData length]];
  1128. //     CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), (CFStringRef)contentLengthStr);
  1129. // }
  1131. // Add standard headers
  1132. NSString *now = [self dateAsString:[NSDate date]];
  1133. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Date"), (CFStringRef)now);
  1135. // Add server capability headers
  1136. CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Accept-Ranges"), CFSTR("bytes"));
  1138. // Add optional response headers
  1139. if([httpResponse respondsToSelector:@selector(httpHeaders)])
  1140. {
  1141. NSDictionary *responseHeaders = [httpResponse httpHeaders];
  1143. NSEnumerator *keyEnumerator = [responseHeaders keyEnumerator];
  1144. NSString *key;
  1146. while(key = [keyEnumerator nextObject])
  1147. {
  1148. NSString *value = [responseHeaders objectForKey:key];
  1150. CFHTTPMessageSetHeaderFieldValue(response, (CFStringRef)key, (CFStringRef)value);
  1151. }
  1152. }
  1154. NSData *result = NSMakeCollectable(CFHTTPMessageCopySerializedMessage(response));
  1155. return [result autorelease];
  1156. }
  1158. - (void)die
  1159. {
  1160. // Post notification of dead connection
  1161. // This will allow our server to release us from its array of connections
  1162. [[NSNotificationCenter defaultCenter] postNotificationName:HTTPConnectionDidDieNotification object:self];
  1163. }
  1165. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1166. #pragma mark AsyncSocket Delegate Methods:
  1167. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1169. /**
  1170.  * This method is called immediately prior to opening up the stream.
  1171.  * This is the time to manually configure the stream if necessary.
  1172. **/
  1173. - (BOOL)onSocketWillConnect:(AsyncSocket *)sock
  1174. {
  1175. if([self isSecureServer])
  1176. {
  1177. NSArray *certificates = [self sslIdentityAndCertificates];
  1179. if([certificates count] > 0)
  1180. {
  1181. NSLog(@"Securing connection...");
  1183. // All connections are assumed to be secure. Only secure connections are allowed on this server.
  1184. NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithCapacity:3];
  1186. // Configure this connection as the server
  1187. CFDictionaryAddValue((CFMutableDictionaryRef)settings,
  1188.  kCFStreamSSLIsServer, kCFBooleanTrue);
  1190. CFDictionaryAddValue((CFMutableDictionaryRef)settings,
  1191.  kCFStreamSSLCertificates, (CFArrayRef)certificates);
  1193. // Configure this connection to use the highest possible SSL level
  1194. CFDictionaryAddValue((CFMutableDictionaryRef)settings,
  1195.  kCFStreamSSLLevel, kCFStreamSocketSecurityLevelNegotiatedSSL);
  1197. CFReadStreamSetProperty([asyncSocket getCFReadStream],
  1198. kCFStreamPropertySSLSettings, (CFDictionaryRef)settings);
  1199. CFWriteStreamSetProperty([asyncSocket getCFWriteStream],
  1200.  kCFStreamPropertySSLSettings, (CFDictionaryRef)settings);
  1201. }
  1202. }
  1203. return YES;
  1204. }
  1206. /**
  1207.  * This method is called after the socket has been fully opened.
  1208.  * It is called on the proper thread/runloop that HTTPServer configured our socket to run on.
  1209. **/
  1210. - (void)onSocket:(AsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port
  1211. {
  1212. // The socket is up and ready, and this method is called on the socket's corresponding thread.
  1213. // We can now start reading the HTTP requests...
  1214. [asyncSocket readDataToData:[AsyncSocket CRLFData]
  1215. withTimeout:READ_TIMEOUT
  1216.   maxLength:LIMIT_MAX_HEADER_LINE_LENGTH
  1217. tag:HTTP_REQUEST_HEADER];
  1218. }
  1220. /**
  1221.  * This method is called after the socket has successfully read data from the stream.
  1222.  * Remember that this method will only be called after the socket reaches a CRLF, or after it's read the proper length.
  1223. **/
  1224. - (void)onSocket:(AsyncSocket *)sock didReadData:(NSData*)data withTag:(long)tag
  1225. {
  1226. if(tag == HTTP_REQUEST_HEADER)
  1227. {
  1228. // Append the header line to the http message
  1229. BOOL result = CFHTTPMessageAppendBytes(request, [data bytes], [data length]);
  1230. if(!result)
  1231. {
  1232. // We have a received a malformed request
  1233. [self handleInvalidRequest:data];
  1234. }
  1235. else if(!CFHTTPMessageIsHeaderComplete(request))
  1236. {
  1237. // We don't have a complete header yet
  1238. // That is, we haven't yet received a CRLF on a line by itself, indicating the end of the header
  1239. if(++numHeaderLines > LIMIT_MAX_HEADER_LINES)
  1240. {
  1241. // Reached the maximum amount of header lines in a single HTTP request
  1242. // This could be an attempted DOS attack
  1243. [asyncSocket disconnect];
  1244. }
  1245. else
  1246. {
  1247. [asyncSocket readDataToData:[AsyncSocket CRLFData]
  1248. withTimeout:READ_TIMEOUT
  1249.   maxLength:LIMIT_MAX_HEADER_LINE_LENGTH
  1250. tag:HTTP_REQUEST_HEADER];
  1251. }
  1252. }
  1253. else
  1254. {
  1255. // We have an entire HTTP request header from the client
  1257. // Extract the method (such as GET, HEAD, POST, etc)
  1258. NSString *method = [NSMakeCollectable(CFHTTPMessageCopyRequestMethod(request)) autorelease];
  1260. // Extract the uri (such as "/index.html")
  1261. NSURL *uri = [NSMakeCollectable(CFHTTPMessageCopyRequestURL(request)) autorelease];
  1263. // Check for a Content-Length field
  1264. NSString *contentLength =
  1265.     [NSMakeCollectable(CFHTTPMessageCopyHeaderFieldValue(request, CFSTR("Content-Length"))) autorelease];
  1267. // Content-Length MUST be present for upload methods (such as POST or PUT)
  1268. // and MUST NOT be present for other methods.
  1269. BOOL expectsUpload = [method isEqualToString:@"POST"] || [method isEqualToString:@"PUT"];
  1271. if(expectsUpload)
  1272. {
  1273. if(contentLength == nil)
  1274. {
  1275. // Received POST/PUT with no specified Content-Length
  1276. [self handleInvalidRequest:nil];
  1277. return;
  1278. }
  1280. if(![NSNumber parseString:(NSString *)contentLength intoUInt64:&requestContentLength])
  1281. {
  1282. // Unable to parse Content-Length header into a valid number
  1283. [self handleInvalidRequest:nil];
  1284. return;
  1285. }
  1286. }
  1287. else
  1288. {
  1289. if(contentLength != nil)
  1290. {
  1291. // Received Content-Length header for method not expecting an upload
  1292. [self handleInvalidRequest:nil];
  1293. return;
  1294. }
  1296. requestContentLength = 0;
  1297. requestContentLengthReceived = 0;
  1298. }
  1300. // Check to make sure the given method is supported
  1301. if(![self supportsMethod:method atPath:[uri relativeString]])
  1302. {
  1303. // The method is unsupported - either in general, or for this specific request
  1304. // Send a 405 - Method not allowed response
  1305. [self handleUnknownMethod:method];
  1306. return;
  1307. }
  1309. if(expectsUpload)
  1310. {
  1311. // Reset the total amount of data received for the upload
  1312. requestContentLengthReceived = 0;
  1314. // Prepare for the upload
  1315. [self prepareForBodyWithSize:requestContentLength];
  1317. // Start reading the request body
  1318. uint bytesToRead = requestContentLength < POST_CHUNKSIZE ? requestContentLength : POST_CHUNKSIZE;
  1320. [asyncSocket readDataToLength:bytesToRead withTimeout:READ_TIMEOUT tag:HTTP_REQUEST_BODY];
  1321. }
  1322. else
  1323. {
  1324. // Now we need to reply to the request
  1325. [self replyToHTTPRequest];
  1326. }
  1327. }
  1328. }
  1329. else
  1330. {
  1331. // Handle a chunk of data from the POST body
  1333. requestContentLengthReceived += [data length];
  1334. [self processDataChunk:data];
  1336. if(requestContentLengthReceived < requestContentLength)
  1337. {
  1338. // We're not done reading the post body yet...
  1339. UInt64 bytesLeft = requestContentLength - requestContentLengthReceived;
  1341. uint bytesToRead = bytesLeft < POST_CHUNKSIZE ? bytesLeft : POST_CHUNKSIZE;
  1343. [asyncSocket readDataToLength:bytesToRead withTimeout:READ_TIMEOUT tag:HTTP_REQUEST_BODY];
  1344. }
  1345. else
  1346. {
  1347. // Now we need to reply to the request
  1348. [self replyToHTTPRequest];
  1349. }
  1350. }
  1351. }
  1353. /**
  1354.  * This method is called after the socket has successfully written data to the stream.
  1355.  * Remember that this method will be called after a complete response to a request has been written.
  1356. **/
  1357. - (void)onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag
  1358. {
  1359. BOOL doneSendingResponse = NO;
  1361. if(tag == HTTP_PARTIAL_RESPONSE_BODY)
  1362. {
  1363. // We only wrote a part of the http response - there may be more.
  1364. NSData *data = [httpResponse readDataOfLength:READ_CHUNKSIZE];
  1366. if([data length] > 0)
  1367. {
  1368. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1369. }
  1370. else
  1371. {
  1372. doneSendingResponse = YES;
  1373. }
  1374. }
  1375. else if(tag == HTTP_PARTIAL_RANGE_RESPONSE_BODY)
  1376. {
  1377. // We only wrote a part of the range - there may be more.
  1378. DDRange range = [[ranges objectAtIndex:0] ddrangeValue];
  1380. UInt64 offset = [httpResponse offset];
  1381. UInt64 bytesRead = offset - range.location;
  1382. UInt64 bytesLeft = range.length - bytesRead;
  1384. if(bytesLeft > 0)
  1385. {
  1386. unsigned int bytesToRead = bytesLeft < READ_CHUNKSIZE ? bytesLeft : READ_CHUNKSIZE;
  1388. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  1390. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1391. }
  1392. else
  1393. {
  1394. doneSendingResponse = YES;
  1395. }
  1396. }
  1397. else if(tag == HTTP_PARTIAL_RANGES_RESPONSE_BODY)
  1398. {
  1399. // We only wrote part of the range - there may be more.
  1400. // Plus, there may be more ranges.
  1401. DDRange range = [[ranges objectAtIndex:rangeIndex] ddrangeValue];
  1403. UInt64 offset = [httpResponse offset];
  1404. UInt64 bytesRead = offset - range.location;
  1405. UInt64 bytesLeft = range.length - bytesRead;
  1407. if(bytesLeft > 0)
  1408. {
  1409. unsigned int bytesToRead = bytesLeft < READ_CHUNKSIZE ? bytesLeft : READ_CHUNKSIZE;
  1411. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  1413. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1414. }
  1415. else
  1416. {
  1417. if(++rangeIndex < [ranges count])
  1418. {
  1419. // Write range header
  1420. NSData *rangeHeader = [ranges_headers objectAtIndex:rangeIndex];
  1421. [asyncSocket writeData:rangeHeader withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_PARTIAL_RESPONSE_HEADER];
  1423. // Start writing range body
  1424. range = [[ranges objectAtIndex:rangeIndex] ddrangeValue];
  1426. [httpResponse setOffset:range.location];
  1428. unsigned int bytesToRead = range.length < READ_CHUNKSIZE ? range.length : READ_CHUNKSIZE;
  1430. NSData *data = [httpResponse readDataOfLength:bytesToRead];
  1432. [asyncSocket writeData:data withTimeout:WRITE_BODY_TIMEOUT tag:tag];
  1433. }
  1434. else
  1435. {
  1436. // We're not done yet - we still have to send the closing boundry tag
  1437. NSString *endingBoundryStr = [NSString stringWithFormat:@"rn--%@--rn", ranges_boundry];
  1438. NSData *endingBoundryData = [endingBoundryStr dataUsingEncoding:NSUTF8StringEncoding];
  1440. [asyncSocket writeData:endingBoundryData withTimeout:WRITE_HEAD_TIMEOUT tag:HTTP_RESPONSE];
  1441. }
  1442. }
  1443. }
  1444. else if(tag == HTTP_RESPONSE || tag == HTTP_FINAL_RESPONSE)
  1445. {
  1446. doneSendingResponse = YES;
  1447. }
  1449. if(doneSendingResponse)
  1450. {
  1451. if(tag == HTTP_FINAL_RESPONSE)
  1452. {
  1453. // Terminate the connection
  1454. [asyncSocket disconnect];
  1455. }
  1456. else
  1457. {
  1458. // Cleanup after the last request
  1459. // And start listening for the next request
  1461. // Release any resources we no longer need
  1462. [httpResponse release];
  1463. httpResponse = nil;
  1465. [ranges release];
  1466. [ranges_headers release];
  1467. [ranges_boundry release];
  1468. ranges = nil;
  1469. ranges_headers = nil;
  1470. ranges_boundry = nil;
  1472. // Release the old request, and create a new one
  1473. if(request) CFRelease(request);
  1474. request = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, YES);
  1476. numHeaderLines = 0;
  1478. // And start listening for more requests
  1479. [asyncSocket readDataToData:[AsyncSocket CRLFData]
  1480. withTimeout:READ_TIMEOUT
  1481.   maxLength:LIMIT_MAX_HEADER_LINE_LENGTH
  1482. tag:HTTP_REQUEST_HEADER];
  1483. }
  1484. }
  1485. }
  1487. /**
  1488.  * This message is sent:
  1489.  *  - if there is an connection, time out, or other i/o error.
  1490.  *  - if the remote socket cleanly disconnects.
  1491.  *  - before the local socket is disconnected.
  1492. **/
  1493. - (void)onSocket:(AsyncSocket *)sock willDisconnectWithError:(NSError *)err
  1494. {
  1495. // NSLog(@"HTTPConnection: onSocket:willDisconnectWithError: %@", err);
  1496. }
  1498. /**
  1499.  * Sent after the socket has been disconnected.
  1500. **/
  1501. - (void)onSocketDidDisconnect:(AsyncSocket *)sock
  1502. {
  1503. [self die];
  1504. }
  1506. @end