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

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

iPhone

开发平台：

Objective-C

AsyncSocket.m.svn-base：源码内容
  1. //
  2. //  AsyncSocket.m
  3. //  
  4. //  This class is in the public domain.
  5. //  Originally created by Dustin Voss on Wed Jan 29 2003.
  6. //  Updated and maintained by Deusty Designs and the Mac development community.
  7. //
  8. //  http://code.google.com/p/cocoaasyncsocket/
  9. //
  11. #import "AsyncSocket.h"
  12. #import <sys/socket.h>
  13. #import <netinet/in.h>
  14. #import <arpa/inet.h>
  15. #import <netdb.h>
  17. #if TARGET_OS_IPHONE
  18. // Note: You may need to add the CFNetwork Framework to your project
  19. #import <CFNetwork/CFNetwork.h>
  20. #endif
  22. #pragma mark Declarations
  24. #define READQUEUE_CAPACITY 5           // Initial capacity
  25. #define WRITEQUEUE_CAPACITY 5           // Initial capacity
  26. #define READALL_CHUNKSIZE 256         // Incremental increase in buffer size
  27. #define WRITE_CHUNKSIZE    (1024 * 4)   // Limit on size of each write pass
  29. NSString *const AsyncSocketException = @"AsyncSocketException";
  30. NSString *const AsyncSocketErrorDomain = @"AsyncSocketErrorDomain";
  32. // This is a mutex lock used by all instances of AsyncSocket, to protect getaddrinfo.
  33. // The man page says it is not thread-safe. (As of Mac OS X 10.4.7, and possibly earlier)
  34. static NSString *getaddrinfoLock = @"lock";
  36. enum AsyncSocketFlags
  37. {
  38. kEnablePreBuffering   = 1 << 0,   // If set, pre-buffering is enabled.
  39. kDidCallConnectDeleg  = 1 << 1,   // If set, connect delegate has been called.
  40. kDidPassConnectMethod = 1 << 2,   // If set, disconnection results in delegate call.
  41. kForbidReadsWrites    = 1 << 3,   // If set, no new reads or writes are allowed.
  42. kDisconnectSoon       = 1 << 4,   // If set, disconnect as soon as nothing is queued.
  43. kClosingWithError     = 1 << 5,   // If set, the socket is being closed due to an error.
  44. };
  46. @interface AsyncSocket (Private)
  48. // Socket Implementation
  49. - (CFSocketRef) createAcceptSocketForAddress:(NSData *)addr error:(NSError **)errPtr;
  50. - (BOOL) createSocketForAddress:(NSData *)remoteAddr error:(NSError **)errPtr;
  51. - (BOOL) attachSocketsToRunLoop:(NSRunLoop *)runLoop error:(NSError **)errPtr;
  52. - (BOOL) configureSocketAndReturnError:(NSError **)errPtr;
  53. - (BOOL) connectSocketToAddress:(NSData *)remoteAddr error:(NSError **)errPtr;
  54. - (void) doAcceptWithSocket:(CFSocketNativeHandle)newSocket;
  55. - (void) doSocketOpen:(CFSocketRef)sock withCFSocketError:(CFSocketError)err;
  57. // Stream Implementation
  58. - (BOOL) createStreamsFromNative:(CFSocketNativeHandle)native error:(NSError **)errPtr;
  59. - (BOOL) createStreamsToHost:(NSString *)hostname onPort:(UInt16)port error:(NSError **)errPtr;
  60. - (BOOL) attachStreamsToRunLoop:(NSRunLoop *)runLoop error:(NSError **)errPtr;
  61. - (BOOL) configureStreamsAndReturnError:(NSError **)errPtr;
  62. - (BOOL) openStreamsAndReturnError:(NSError **)errPtr;
  63. - (void) doStreamOpen;
  64. - (BOOL) setSocketFromStreamsAndReturnError:(NSError **)errPtr;
  66. // Disconnect Implementation
  67. - (void) closeWithError:(NSError *)err;
  68. - (void) recoverUnreadData;
  69. - (void) emptyQueues;
  70. - (void) close;
  72. // Errors
  73. - (NSError *) getErrnoError;
  74. - (NSError *) getAbortError;
  75. - (NSError *) getStreamError;
  76. - (NSError *) getSocketError;
  77. - (NSError *) getReadMaxedOutError;
  78. - (NSError *) getReadTimeoutError;
  79. - (NSError *) getWriteTimeoutError;
  80. - (NSError *) errorFromCFStreamError:(CFStreamError)err;
  82. // Diagnostics
  83. - (BOOL) isSocketConnected;
  84. - (BOOL) areStreamsConnected;
  85. - (NSString *) connectedHost: (CFSocketRef)socket;
  86. - (UInt16) connectedPort: (CFSocketRef)socket;
  87. - (NSString *) localHost: (CFSocketRef)socket;
  88. - (UInt16) localPort: (CFSocketRef)socket;
  89. - (NSString *) addressHost: (CFDataRef)cfaddr;
  90. - (UInt16) addressPort: (CFDataRef)cfaddr;
  92. // Reading
  93. - (void) doBytesAvailable;
  94. - (void) completeCurrentRead;
  95. - (void) endCurrentRead;
  96. - (void) scheduleDequeueRead;
  97. - (void) maybeDequeueRead;
  98. - (void) doReadTimeout:(NSTimer *)timer;
  100. // Writing
  101. - (void) doSendBytes;
  102. - (void) completeCurrentWrite;
  103. - (void) endCurrentWrite;
  104. - (void) scheduleDequeueWrite;
  105. - (void) maybeDequeueWrite;
  106. - (void) maybeScheduleDisconnect;
  107. - (void) doWriteTimeout:(NSTimer *)timer;
  109. // Callbacks
  110. - (void) doCFCallback:(CFSocketCallBackType)type forSocket:(CFSocketRef)sock withAddress:(NSData *)address withData:(const void *)pData;
  111. - (void) doCFReadStreamCallback:(CFStreamEventType)type forStream:(CFReadStreamRef)stream;
  112. - (void) doCFWriteStreamCallback:(CFStreamEventType)type forStream:(CFWriteStreamRef)stream;
  114. @end
  116. static void MyCFSocketCallback (CFSocketRef, CFSocketCallBackType, CFDataRef, const void *, void *);
  117. static void MyCFReadStreamCallback (CFReadStreamRef stream, CFStreamEventType type, void *pInfo);
  118. static void MyCFWriteStreamCallback (CFWriteStreamRef stream, CFStreamEventType type, void *pInfo);
  120. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  121. #pragma mark -
  122. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  124. /**
  125.  * The AsyncReadPacket encompasses the instructions for a current read.
  126.  * The content of a read packet allows the code to determine if we're:
  127.  * reading to a certain length, reading to a certain separator, or simply reading the first chunk of data.
  128. **/
  129. @interface AsyncReadPacket : NSObject
  130. {
  131. @public
  132. NSMutableData *buffer;
  133. CFIndex bytesDone;
  134. NSTimeInterval timeout;
  135. CFIndex maxLength;
  136. long tag;
  137. NSData *term;
  138. BOOL readAllAvailableData;
  139. }
  140. - (id)initWithData:(NSMutableData *)d
  141.    timeout:(NSTimeInterval)t
  142.    tag:(long)i
  143.   readAllAvailable:(BOOL)a
  144. terminator:(NSData *)e
  145.     maxLength:(CFIndex)m;
  147. - (unsigned)readLengthForTerm;
  149. - (unsigned)prebufferReadLengthForTerm;
  150. - (CFIndex)searchForTermAfterPreBuffering:(CFIndex)numBytes;
  152. - (void)dealloc;
  153. @end
  155. @implementation AsyncReadPacket
  157. - (id)initWithData:(NSMutableData *)d
  158.    timeout:(NSTimeInterval)t
  159.    tag:(long)i
  160.   readAllAvailable:(BOOL)a
  161. terminator:(NSData *)e
  162.          maxLength:(CFIndex)m
  163. {
  164. if(self = [super init])
  165. {
  166. buffer = [d retain];
  167. timeout = t;
  168. tag = i;
  169. readAllAvailableData = a;
  170. term = [e copy];
  171. bytesDone = 0;
  172. maxLength = m;
  173. }
  174. return self;
  175. }
  177. /**
  178.  * For read packets with a set terminator, returns the safe length of data that can be read
  179.  * without going over a terminator, or the maxLength.
  180.  * 
  181.  * It is assumed the terminator has not already been read.
  182. **/
  183. - (unsigned)readLengthForTerm
  184. {
  185. NSAssert(term != nil, @"Searching for term in data when there is no term.");
  187. // What we're going to do is look for a partial sequence of the terminator at the end of the buffer.
  188. // If a partial sequence occurs, then we must assume the next bytes to arrive will be the rest of the term,
  189. // and we can only read that amount.
  190. // Otherwise, we're safe to read the entire length of the term.
  192. unsigned result = [term length];
  194. // i = index within buffer at which to check data
  195. // j = length of term to check against
  197. // Note: Beware of implicit casting rules
  198. // This could give you -1: MAX(0, (0 - [term length] + 1));
  200. CFIndex i = MAX(0, (CFIndex)(bytesDone - [term length] + 1));
  201. CFIndex j = MIN([term length] - 1, bytesDone);
  203. while(i < bytesDone)
  204. {
  205. const void *subBuffer = [buffer bytes] + i;
  207. if(memcmp(subBuffer, [term bytes], j) == 0)
  208. {
  209. result = [term length] - j;
  210. break;
  211. }
  213. i++;
  214. j--;
  215. }
  217. if(maxLength > 0)
  218. return MIN(result, (maxLength - bytesDone));
  219. else
  220. return result;
  221. }
  223. /**
  224.  * Assuming pre-buffering is enabled, returns the amount of data that can be read
  225.  * without going over the maxLength.
  226. **/
  227. - (unsigned)prebufferReadLengthForTerm
  228. {
  229. if(maxLength > 0)
  230. return MIN(READALL_CHUNKSIZE, (maxLength - bytesDone));
  231. else
  232. return READALL_CHUNKSIZE;
  233. }
  235. /**
  236.  * For read packets with a set terminator, scans the packet buffer for the term.
  237.  * It is assumed the terminator had not been fully read prior to the new bytes.
  238.  * 
  239.  * If the term is found, the number of excess bytes after the term are returned.
  240.  * If the term is not found, this method will return -1.
  241.  * 
  242.  * Note: A return value of zero means the term was found at the very end.
  243. **/
  244. - (CFIndex)searchForTermAfterPreBuffering:(CFIndex)numBytes
  245. {
  246. NSAssert(term != nil, @"Searching for term in data when there is no term.");
  248. // We try to start the search such that the first new byte read matches up with the last byte of the term.
  249. // We continue searching forward after this until the term no longer fits into the buffer.
  251. // Note: Beware of implicit casting rules
  252. // This could give you -1: MAX(0, 1 - 1 - [term length] + 1);
  254. CFIndex i = MAX(0, (CFIndex)(bytesDone - numBytes - [term length] + 1));
  256. while(i + [term length] <= bytesDone)
  257. {
  258. const void *subBuffer = [buffer bytes] + i;
  260. if(memcmp(subBuffer, [term bytes], [term length]) == 0)
  261. {
  262. return bytesDone - (i + [term length]);
  263. }
  265. i++;
  266. }
  268. return -1;
  269. }
  271. - (void)dealloc
  272. {
  273. [buffer release];
  274. [term release];
  275. [super dealloc];
  276. }
  278. @end
  280. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  281. #pragma mark -
  282. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  284. @interface AsyncWritePacket : NSObject
  285. {
  286. @public
  287. NSData *buffer;
  288. CFIndex bytesDone;
  289. long tag;
  290. NSTimeInterval timeout;
  291. }
  292. - (id)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i;
  293. - (void)dealloc;
  294. @end
  296. @implementation AsyncWritePacket
  298. - (id)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i;
  299. {
  300. if(self = [super init])
  301. {
  302. buffer = [d retain];
  303. timeout = t;
  304. tag = i;
  305. bytesDone = 0;
  306. }
  307. return self;
  308. }
  310. - (void)dealloc
  311. {
  312. [buffer release];
  313. [super dealloc];
  314. }
  316. @end
  318. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  319. #pragma mark -
  320. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  322. @implementation AsyncSocket
  324. - (id)init
  325. {
  326. return [self initWithDelegate:nil userData:0];
  327. }
  329. - (id)initWithDelegate:(id)delegate
  330. {
  331. return [self initWithDelegate:delegate userData:0];
  332. }
  334. // Designated initializer.
  335. - (id)initWithDelegate:(id)delegate userData:(long)userData
  336. {
  337. if(self = [super init])
  338. {
  339. theFlags = 0x00;
  340. theDelegate = delegate;
  341. theUserData = userData;
  343. theSocket = NULL;
  344. theSource = NULL;
  345. theSocket6 = NULL;
  346. theSource6 = NULL;
  347. theRunLoop = NULL;
  348. theReadStream = NULL;
  349. theWriteStream = NULL;
  351. theReadQueue = [[NSMutableArray alloc] initWithCapacity:READQUEUE_CAPACITY];
  352. theCurrentRead = nil;
  353. theReadTimer = nil;
  355. partialReadBuffer = [[NSMutableData alloc] initWithCapacity:READALL_CHUNKSIZE];
  357. theWriteQueue = [[NSMutableArray alloc] initWithCapacity:WRITEQUEUE_CAPACITY];
  358. theCurrentWrite = nil;
  359. theWriteTimer = nil;
  361. // Socket context
  362. NSAssert(sizeof(CFSocketContext) == sizeof(CFStreamClientContext), @"CFSocketContext != CFStreamClientContext");
  363. theContext.version = 0;
  364. theContext.info = self;
  365. theContext.retain = nil;
  366. theContext.release = nil;
  367. theContext.copyDescription = nil;
  368. }
  369. return self;
  370. }
  372. // The socket may been initialized in a connected state and auto-released, so this should close it down cleanly.
  373. - (void)dealloc
  374. {
  375. [self close];
  376. [theReadQueue release];
  377. [theWriteQueue release];
  378. [NSObject cancelPreviousPerformRequestsWithTarget:theDelegate selector:@selector(onSocketDidDisconnect:) object:self];
  379. [NSObject cancelPreviousPerformRequestsWithTarget:self];
  380. [super dealloc];
  381. }
  383. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  384. #pragma mark Accessors
  385. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  387. - (long)userData
  388. {
  389. return theUserData;
  390. }
  392. - (void)setUserData:(long)userData
  393. {
  394. theUserData = userData;
  395. }
  397. - (id)delegate
  398. {
  399. return theDelegate;
  400. }
  402. - (void)setDelegate:(id)delegate
  403. {
  404. theDelegate = delegate;
  405. }
  407. - (BOOL)canSafelySetDelegate
  408. {
  409. return ([theReadQueue count] == 0 && [theWriteQueue count] == 0 && theCurrentRead == nil && theCurrentWrite == nil);
  410. }
  412. - (CFSocketRef)getCFSocket
  413. {
  414. if(theSocket)
  415. return theSocket;
  416. else
  417. return theSocket6;
  418. }
  420. - (CFReadStreamRef)getCFReadStream
  421. {
  422. return theReadStream;
  423. }
  425. - (CFWriteStreamRef)getCFWriteStream
  426. {
  427. return theWriteStream;
  428. }
  430. - (float)progressOfReadReturningTag:(long *)tag bytesDone:(CFIndex *)done total:(CFIndex *)total
  431. {
  432. // Check to make sure we're actually reading something right now
  433. if (!theCurrentRead) return NAN;
  435. // It's only possible to know the progress of our read if we're reading to a certain length
  436. // If we're reading to data, we of course have no idea when the data will arrive
  437. // If we're reading to timeout, then we have no idea when the next chunk of data will arrive.
  438. BOOL hasTotal = (theCurrentRead->readAllAvailableData == NO && theCurrentRead->term == nil);
  440. CFIndex d = theCurrentRead->bytesDone;
  441. CFIndex t = hasTotal ? [theCurrentRead->buffer length] : 0;
  442. if (tag != NULL)   *tag = theCurrentRead->tag;
  443. if (done != NULL)  *done = d;
  444. if (total != NULL) *total = t;
  445. float ratio = (float)d/(float)t;
  446. return isnan(ratio) ? 1.0 : ratio; // 0 of 0 bytes is 100% done.
  447. }
  449. - (float)progressOfWriteReturningTag:(long *)tag bytesDone:(CFIndex *)done total:(CFIndex *)total
  450. {
  451. if (!theCurrentWrite) return NAN;
  452. CFIndex d = theCurrentWrite->bytesDone;
  453. CFIndex t = [theCurrentWrite->buffer length];
  454. if (tag != NULL)   *tag = theCurrentWrite->tag;
  455. if (done != NULL)  *done = d;
  456. if (total != NULL) *total = t;
  457. return (float)d/(float)t;
  458. }
  460. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  461. #pragma mark Configuration
  462. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  464. /**
  465.  * See the header file for a full explanation of pre-buffering.
  466. **/
  467. - (void)enablePreBuffering
  468. {
  469. theFlags |= kEnablePreBuffering;
  470. }
  472. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  473. #pragma mark Connection
  474. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  476. - (BOOL)acceptOnPort:(UInt16)port error:(NSError **)errPtr
  477. {
  478. return [self acceptOnAddress:nil port:port error:errPtr];
  479. }
  481. /**
  482.  * To accept on a certain address, pass the address to accept on.
  483.  * To accept on any address, pass nil or an empty string.
  484.  * To accept only connections from localhost pass "localhost" or "loopback".
  485. **/
  486. - (BOOL)acceptOnAddress:(NSString *)hostaddr port:(UInt16)port error:(NSError **)errPtr
  487. {
  488. if (theDelegate == NULL)
  489. [NSException raise:AsyncSocketException format:@"Attempting to accept without a delegate. Set a delegate first."];
  491. if (theSocket != NULL || theSocket6 != NULL)
  492. [NSException raise:AsyncSocketException format:@"Attempting to accept while connected or accepting connections. Disconnect first."];
  494. // Set up the listen sockaddr structs if needed.
  496. NSData *address = nil, *address6 = nil;
  497. if(hostaddr == nil || ([hostaddr length] == 0))
  498. {
  499. // Accept on ANY address
  500. struct sockaddr_in nativeAddr;
  501. nativeAddr.sin_len         = sizeof(struct sockaddr_in);
  502. nativeAddr.sin_family      = AF_INET;
  503. nativeAddr.sin_port        = htons(port);
  504. nativeAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  505. memset(&(nativeAddr.sin_zero), 0, sizeof(nativeAddr.sin_zero));
  507. struct sockaddr_in6 nativeAddr6;
  508. nativeAddr6.sin6_len       = sizeof(struct sockaddr_in6);
  509. nativeAddr6.sin6_family    = AF_INET6;
  510. nativeAddr6.sin6_port      = htons(port);
  511. nativeAddr6.sin6_flowinfo  = 0;
  512. nativeAddr6.sin6_addr      = in6addr_any;
  513. nativeAddr6.sin6_scope_id  = 0;
  515. // Wrap the native address structures for CFSocketSetAddress.
  516. address = [NSData dataWithBytes:&nativeAddr length:sizeof(nativeAddr)];
  517. address6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)];
  518. }
  519. else if([hostaddr isEqualToString:@"localhost"] || [hostaddr isEqualToString:@"loopback"])
  520. {
  521. // Accept only on LOOPBACK address
  522. struct sockaddr_in nativeAddr;
  523. nativeAddr.sin_len         = sizeof(struct sockaddr_in);
  524. nativeAddr.sin_family      = AF_INET;
  525. nativeAddr.sin_port        = htons(port);
  526. nativeAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  527. memset(&(nativeAddr.sin_zero), 0, sizeof(nativeAddr.sin_zero));
  529. struct sockaddr_in6 nativeAddr6;
  530. nativeAddr6.sin6_len       = sizeof(struct sockaddr_in6);
  531. nativeAddr6.sin6_family    = AF_INET6;
  532. nativeAddr6.sin6_port      = htons(port);
  533. nativeAddr6.sin6_flowinfo  = 0;
  534. nativeAddr6.sin6_addr      = in6addr_loopback;
  535. nativeAddr6.sin6_scope_id  = 0;
  537. // Wrap the native address structures for CFSocketSetAddress.
  538. address = [NSData dataWithBytes:&nativeAddr length:sizeof(nativeAddr)];
  539. address6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)];
  540. }
  541. else
  542. {
  543. NSString *portStr = [NSString stringWithFormat:@"%hu", port];
  545. @synchronized (getaddrinfoLock)
  546. {
  547. struct addrinfo hints, *res, *res0;
  549. memset(&hints, 0, sizeof(hints));
  550. hints.ai_family   = PF_UNSPEC;
  551. hints.ai_socktype = SOCK_STREAM;
  552. hints.ai_protocol = IPPROTO_TCP;
  553. hints.ai_flags    = AI_PASSIVE;
  555. int error = getaddrinfo([hostaddr UTF8String], [portStr UTF8String], &hints, &res0);
  557. if(error)
  558. {
  559. if(errPtr)
  560. {
  561. NSString *errMsg = [NSString stringWithCString:gai_strerror(error) encoding:NSASCIIStringEncoding];
  562. NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey];
  564. *errPtr = [NSError errorWithDomain:@"kCFStreamErrorDomainNetDB" code:error userInfo:info];
  565. }
  566. }
  568. for(res = res0; res; res = res->ai_next)
  569. {
  570. if(!address && (res->ai_family == AF_INET))
  571. {
  572. // Found IPv4 address
  573. // Wrap the native address structures for CFSocketSetAddress.
  574. address = [NSData dataWithBytes:res->ai_addr length:res->ai_addrlen];
  575. }
  576. else if(!address6 && (res->ai_family == AF_INET6))
  577. {
  578. // Found IPv6 address
  579. // Wrap the native address structures for CFSocketSetAddress.
  580. address6 = [NSData dataWithBytes:res->ai_addr length:res->ai_addrlen];
  581. }
  582. }
  583. freeaddrinfo(res0);
  584. }
  586. if(!address && !address6) return NO;
  587. }
  589. // Create the sockets.
  591. if (address)
  592. {
  593. theSocket = [self createAcceptSocketForAddress:address error:errPtr];
  594. if (theSocket == NULL) goto Failed;
  595. }
  597. if (address6)
  598. {
  599. theSocket6 = [self createAcceptSocketForAddress:address6 error:errPtr];
  601. // Note: The iPhone doesn't currently support IPv6
  603. #if !TARGET_OS_IPHONE
  604. if (theSocket6 == NULL) goto Failed;
  605. #endif
  606. }
  608. // Attach the sockets to the run loop so that callback methods work
  610. [self attachSocketsToRunLoop:nil error:nil];
  612. // Set the SO_REUSEADDR flags.
  614. int reuseOn = 1;
  615. if (theSocket) setsockopt(CFSocketGetNative(theSocket), SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));
  616. if (theSocket6) setsockopt(CFSocketGetNative(theSocket6), SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));
  618. // Set the local bindings which causes the sockets to start listening.
  620. CFSocketError err;
  621. if (theSocket)
  622. {
  623. err = CFSocketSetAddress (theSocket, (CFDataRef)address);
  624. if (err != kCFSocketSuccess) goto Failed;
  626. //NSLog(@"theSocket4: %hu", [self localPort:theSocket]);
  627. }
  629. if(port == 0 && theSocket && theSocket6)
  630. {
  631. // The user has passed in port 0, which means he wants to allow the kernel to choose the port for them
  632. // However, the kernel will choose a different port for both theSocket and theSocket6
  633. // So we grab the port the kernel choose for theSocket, and set it as the port for theSocket6
  634. UInt16 chosenPort = [self localPort:theSocket];
  636. struct sockaddr_in6 *pSockAddr6 = (struct sockaddr_in6 *)[address6 bytes];
  637. pSockAddr6->sin6_port = htons(chosenPort);
  638.     }
  640. if (theSocket6)
  641. {
  642. err = CFSocketSetAddress (theSocket6, (CFDataRef)address6);
  643. if (err != kCFSocketSuccess) goto Failed;
  645. //NSLog(@"theSocket6: %hu", [self localPort:theSocket6]);
  646. }
  648. theFlags |= kDidPassConnectMethod;
  649. return YES;
  651. Failed:;
  652. if(errPtr) *errPtr = [self getSocketError];
  653. if(theSocket != NULL)
  654. {
  655. CFSocketInvalidate(theSocket);
  656. CFRelease(theSocket);
  657. theSocket = NULL;
  658. }
  659. if(theSocket6 != NULL)
  660. {
  661. CFSocketInvalidate(theSocket6);
  662. CFRelease(theSocket6);
  663. theSocket6 = NULL;
  664. }
  665. return NO;
  666. }
  668. /**
  669.  * This method creates an initial CFReadStream and CFWriteStream to the given host on the given port.
  670.  * The connection is then opened, and the corresponding CFSocket will be extracted after the connection succeeds.
  671.  *
  672.  * Thus the delegate will have access to the CFReadStream and CFWriteStream prior to connection,
  673.  * specifically in the onSocketWillConnect: method.
  674. **/
  675. - (BOOL)connectToHost:(NSString*)hostname onPort:(UInt16)port error:(NSError **)errPtr
  676. {
  677. if(theDelegate == NULL)
  678. {
  679. NSString *message = @"Attempting to connect without a delegate. Set a delegate first.";
  680. [NSException raise:AsyncSocketException format:message];
  681. }
  683. if(theSocket != NULL || theSocket6 != NULL)
  684. {
  685. NSString *message = @"Attempting to connect while connected or accepting connections. Disconnect first.";
  686. [NSException raise:AsyncSocketException format:message];
  687. }
  689. BOOL pass = YES;
  691. if(pass && ![self createStreamsToHost:hostname onPort:port error:errPtr]) pass = NO;
  692. if(pass && ![self attachStreamsToRunLoop:nil error:errPtr])               pass = NO;
  693. if(pass && ![self configureStreamsAndReturnError:errPtr])                 pass = NO;
  694. if(pass && ![self openStreamsAndReturnError:errPtr])                      pass = NO;
  696. if(pass)
  697. theFlags |= kDidPassConnectMethod;
  698. else
  699. [self close];
  701. return pass;
  702. }
  704. /**
  705.  * This method creates an initial CFSocket to the given address.
  706.  * The connection is then opened, and the corresponding CFReadStream and CFWriteStream will be
  707.  * created from the low-level sockets after the connection succeeds.
  708.  *
  709.  * Thus the delegate will have access to the CFSocket and CFSocketNativeHandle (BSD socket) prior to connection,
  710.  * specifically in the onSocketWillConnect: method.
  711.  * 
  712.  * Note: The NSData parameter is expected to be a sockaddr structure. For example, an NSData object returned from
  713.  * NSNetservice addresses method.
  714.  * If you have an existing struct sockaddr you can convert it to an NSData object like so:
  715.  * struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
  716.  * struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
  717. **/
  718. - (BOOL)connectToAddress:(NSData *)remoteAddr error:(NSError **)errPtr
  719. {
  720. if (theDelegate == NULL)
  721. {
  722. NSString *message = @"Attempting to connect without a delegate. Set a delegate first.";
  723. [NSException raise:AsyncSocketException format:message];
  724. }
  726. if (theSocket != NULL || theSocket6 != NULL)
  727. {
  728. NSString *message = @"Attempting to connect while connected or accepting connections. Disconnect first.";
  729. [NSException raise:AsyncSocketException format:message];
  730. }
  732. BOOL pass = YES;
  734. if(pass && ![self createSocketForAddress:remoteAddr error:errPtr])   pass = NO;
  735. if(pass && ![self attachSocketsToRunLoop:nil error:errPtr])          pass = NO;
  736. if(pass && ![self configureSocketAndReturnError:errPtr])             pass = NO;
  737. if(pass && ![self connectSocketToAddress:remoteAddr error:errPtr])   pass = NO;
  739. if(pass)
  740. theFlags |= kDidPassConnectMethod;
  741. else
  742. [self close];
  744. return pass;
  745. }
  747. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  748. #pragma mark Socket Implementation:
  749. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  751. /**
  752.  * Creates the accept sockets.
  753.  * Returns true if either IPv4 or IPv6 is created.
  754.  * If either is missing, an error is returned (even though the method may return true).
  755. **/
  756. - (CFSocketRef)createAcceptSocketForAddress:(NSData *)addr error:(NSError **)errPtr
  757. {
  758. struct sockaddr *pSockAddr = (struct sockaddr *)[addr bytes];
  759. int addressFamily = pSockAddr->sa_family;
  761. CFSocketRef socket = CFSocketCreate(kCFAllocatorDefault,
  762. addressFamily,
  763. SOCK_STREAM,
  764. 0,
  765. kCFSocketAcceptCallBack,                // Callback flags
  766. (CFSocketCallBack)&MyCFSocketCallback,  // Callback method
  767. &theContext);
  769. if(socket == NULL)
  770. {
  771. if(errPtr) *errPtr = [self getSocketError];
  772. }
  774. return socket;
  775. }
  777. - (BOOL)createSocketForAddress:(NSData *)remoteAddr error:(NSError **)errPtr
  778. {
  779. struct sockaddr *pSockAddr = (struct sockaddr *)[remoteAddr bytes];
  781. if(pSockAddr->sa_family == AF_INET)
  782. {
  783. theSocket = CFSocketCreate(NULL,                                   // Default allocator
  784.    PF_INET,                                // Protocol Family
  785.    SOCK_STREAM,                            // Socket Type
  786.    IPPROTO_TCP,                            // Protocol
  787.    kCFSocketConnectCallBack,               // Callback flags
  788.    (CFSocketCallBack)&MyCFSocketCallback,  // Callback method
  789.    &theContext);                           // Socket Context
  791. if(theSocket == NULL)
  792. {
  793. if (errPtr) *errPtr = [self getSocketError];
  794. return NO;
  795. }
  796. }
  797. else if(pSockAddr->sa_family == AF_INET6)
  798. {
  799. theSocket6 = CFSocketCreate(NULL,                                   // Default allocator
  800.     PF_INET6,                               // Protocol Family
  801.     SOCK_STREAM,                            // Socket Type
  802.     IPPROTO_TCP,                            // Protocol
  803.     kCFSocketConnectCallBack,               // Callback flags
  804.     (CFSocketCallBack)&MyCFSocketCallback,  // Callback method
  805.     &theContext);                           // Socket Context
  807. if(theSocket6 == NULL)
  808. {
  809. if (errPtr) *errPtr = [self getSocketError];
  810. return NO;
  811. }
  812. }
  813. else
  814. {
  815. if (errPtr) *errPtr = [self getSocketError];
  816. return NO;
  817. }
  819. return YES;
  820. }
  822. /**
  823.  * Adds the CFSocket's to the run-loop so that callbacks will work properly.
  824. **/
  825. - (BOOL)attachSocketsToRunLoop:(NSRunLoop *)runLoop error:(NSError **)errPtr
  826. {
  827. // Get the CFRunLoop to which the socket should be attached.
  828. theRunLoop = (runLoop == nil) ? CFRunLoopGetCurrent() : [runLoop getCFRunLoop];
  830. if(theSocket)
  831. {
  832. theSource  = CFSocketCreateRunLoopSource (kCFAllocatorDefault, theSocket, 0);
  833. CFRunLoopAddSource (theRunLoop, theSource, kCFRunLoopDefaultMode);
  834. }
  836. if(theSocket6)
  837. {
  838. theSource6 = CFSocketCreateRunLoopSource (kCFAllocatorDefault, theSocket6, 0);
  839. CFRunLoopAddSource (theRunLoop, theSource6, kCFRunLoopDefaultMode);
  840. }
  842. return YES;
  843. }
  845. /**
  846.  * Allows the delegate method to configure the CFSocket or CFNativeSocket as desired before we connect.
  847.  * Note that the CFReadStream and CFWriteStream will not be available until after the connection is opened.
  848. **/
  849. - (BOOL)configureSocketAndReturnError:(NSError **)errPtr
  850. {
  851. // Call the delegate method for further configuration.
  852. if([theDelegate respondsToSelector:@selector(onSocketWillConnect:)])
  853. {
  854. if([theDelegate onSocketWillConnect:self] == NO)
  855. {
  856. if (errPtr) *errPtr = [self getAbortError];
  857. return NO;
  858. }
  859. }
  860. return YES;
  861. }
  863. - (BOOL)connectSocketToAddress:(NSData *)remoteAddr error:(NSError **)errPtr
  864. {
  865. // Start connecting to the given address in the background
  866. // The MyCFSocketCallback method will be called when the connection succeeds or fails
  867. if(theSocket)
  868. {
  869. CFSocketError err = CFSocketConnectToAddress(theSocket, (CFDataRef)remoteAddr, -1);
  870. if(err != kCFSocketSuccess)
  871. {
  872. if (errPtr) *errPtr = [self getSocketError];
  873. return NO;
  874. }
  875. }
  876. else if(theSocket6)
  877. {
  878. CFSocketError err = CFSocketConnectToAddress(theSocket6, (CFDataRef)remoteAddr, -1);
  879. if(err != kCFSocketSuccess)
  880. {
  881. if (errPtr) *errPtr = [self getSocketError];
  882. return NO;
  883. }
  884. }
  886. return YES;
  887. }
  889. /**
  890.  * Attempt to make the new socket.
  891.  * If an error occurs, ignore this event.
  892. **/
  893. - (void)doAcceptWithSocket:(CFSocketNativeHandle)newNative
  894. {
  895. AsyncSocket *newSocket = [[[[self class] alloc] initWithDelegate:theDelegate] autorelease];
  897. // Note: We use [self class] to support subclassing AsyncSocket.
  899. if(newSocket)
  900. {
  901. if ([theDelegate respondsToSelector:@selector(onSocket:didAcceptNewSocket:)])
  902. [theDelegate onSocket:self didAcceptNewSocket:newSocket];
  904. NSRunLoop *runLoop = nil;
  905. if ([theDelegate respondsToSelector:@selector(onSocket:wantsRunLoopForNewSocket:)])
  906. runLoop = [theDelegate onSocket:self wantsRunLoopForNewSocket:newSocket];
  908. BOOL pass = YES;
  910. if(pass && ![newSocket createStreamsFromNative:newNative error:nil]) pass = NO;
  911. if(pass && ![newSocket attachStreamsToRunLoop:runLoop error:nil])    pass = NO;
  912. if(pass && ![newSocket configureStreamsAndReturnError:nil])          pass = NO;
  913. if(pass && ![newSocket openStreamsAndReturnError:nil])               pass = NO;
  915. if(pass)
  916. newSocket->theFlags |= kDidPassConnectMethod;
  917. else {
  918. // No NSError, but errors will still get logged from the above functions.
  919. [newSocket close];
  920. }
  922. }
  923. }
  925. /**
  926.  * Description forthcoming...
  927. **/
  928. - (void)doSocketOpen:(CFSocketRef)sock withCFSocketError:(CFSocketError)socketError
  929. {
  930. NSParameterAssert ((sock == theSocket) || (sock == theSocket6));
  932. if(socketError == kCFSocketTimeout || socketError == kCFSocketError)
  933. {
  934. [self closeWithError:[self getSocketError]];
  935. return;
  936. }
  938. // Get the underlying native (BSD) socket
  939. CFSocketNativeHandle nativeSocket = CFSocketGetNative(sock);
  941. // Setup the socket so that invalidating the socket will not close the native socket
  942. CFSocketSetSocketFlags(sock, 0);
  944. // Invalidate and release the CFSocket - All we need from here on out is the nativeSocket
  945. // Note: If we don't invalidate the socket (leaving the native socket open)
  946. // then theReadStream and theWriteStream won't function properly.
  947. // Specifically, their callbacks won't work, with the exception of kCFStreamEventOpenCompleted.
  948. // I'm not entirely sure why this is, but I'm guessing that events on the socket fire to the CFSocket we created,
  949. // as opposed to the CFReadStream/CFWriteStream.
  951. CFSocketInvalidate(sock);
  952. CFRelease(sock);
  953. theSocket = NULL;
  954. theSocket6 = NULL;
  956. NSError *err;
  957. BOOL pass = YES;
  959. if(pass && ![self createStreamsFromNative:nativeSocket error:&err]) pass = NO;
  960. if(pass && ![self attachStreamsToRunLoop:nil error:&err])           pass = NO;
  961. if(pass && ![self openStreamsAndReturnError:&err])                  pass = NO;
  963. if(!pass)
  964. {
  965. [self closeWithError:err];
  966. }
  967. }
  969. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  970. #pragma mark Stream Implementation:
  971. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  973. /**
  974.  * Creates the CFReadStream and CFWriteStream from the given native socket.
  975.  * The CFSocket may be extracted from either stream after the streams have been opened.
  976.  * 
  977.  * Note: The given native socket must already be connected!
  978. **/
  979. - (BOOL)createStreamsFromNative:(CFSocketNativeHandle)native error:(NSError **)errPtr
  980. {
  981. // Create the socket & streams.
  982. CFStreamCreatePairWithSocket(kCFAllocatorDefault, native, &theReadStream, &theWriteStream);
  983. if (theReadStream == NULL || theWriteStream == NULL)
  984. {
  985. NSError *err = [self getStreamError];
  986. NSLog (@"AsyncSocket %p couldn't create streams from accepted socket: %@", self, err);
  987. if (errPtr) *errPtr = err;
  988. return NO;
  989. }
  991. // Ensure the CF & BSD socket is closed when the streams are closed.
  992. CFReadStreamSetProperty(theReadStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
  993. CFWriteStreamSetProperty(theWriteStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
  995. return YES;
  996. }
  998. /**
  999.  * Creates the CFReadStream and CFWriteStream from the given hostname and port number.
  1000.  * The CFSocket may be extracted from either stream after the streams have been opened.
  1001. **/
  1002. - (BOOL)createStreamsToHost:(NSString *)hostname onPort:(UInt16)port error:(NSError **)errPtr
  1003. {
  1004. // Create the socket & streams.
  1005. CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, (CFStringRef)hostname, port, &theReadStream, &theWriteStream);
  1006. if (theReadStream == NULL || theWriteStream == NULL)
  1007. {
  1008. if (errPtr) *errPtr = [self getStreamError];
  1009. return NO;
  1010. }
  1012. // Ensure the CF & BSD socket is closed when the streams are closed.
  1013. CFReadStreamSetProperty(theReadStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
  1014. CFWriteStreamSetProperty(theWriteStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
  1016. return YES;
  1017. }
  1019. - (BOOL)attachStreamsToRunLoop:(NSRunLoop *)runLoop error:(NSError **)errPtr
  1020. {
  1021. // Get the CFRunLoop to which the socket should be attached.
  1022. theRunLoop = (runLoop == nil) ? CFRunLoopGetCurrent() : [runLoop getCFRunLoop];
  1024. // Make read stream non-blocking.
  1025. if (!CFReadStreamSetClient (theReadStream,
  1026. kCFStreamEventHasBytesAvailable | kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered | kCFStreamEventOpenCompleted,
  1027. (CFReadStreamClientCallBack)&MyCFReadStreamCallback,
  1028. (CFStreamClientContext *)(&theContext) ))
  1029. {
  1030. NSError *err = [self getStreamError];
  1032. NSLog (@"AsyncSocket %p couldn't attach read stream to run-loop,", self);
  1033. NSLog (@"Error: %@", err);
  1035. if (errPtr) *errPtr = err;
  1036. return NO;
  1037. }
  1038. CFReadStreamScheduleWithRunLoop (theReadStream, theRunLoop, kCFRunLoopDefaultMode);
  1040. // Make write stream non-blocking.
  1041. if (!CFWriteStreamSetClient (theWriteStream,
  1042. kCFStreamEventCanAcceptBytes | kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered | kCFStreamEventOpenCompleted,
  1043. (CFWriteStreamClientCallBack)&MyCFWriteStreamCallback,
  1044. (CFStreamClientContext *)(&theContext) ))
  1045. {
  1046. NSError *err = [self getStreamError];
  1048. NSLog (@"AsyncSocket %p couldn't attach write stream to run-loop,", self);
  1049. NSLog (@"Error: %@", err);
  1051. if (errPtr) *errPtr = err;
  1052. return NO;
  1054. }
  1055. CFWriteStreamScheduleWithRunLoop (theWriteStream, theRunLoop, kCFRunLoopDefaultMode);
  1057. return YES;
  1058. }
  1060. /**
  1061.  * Allows the delegate method to configure the CFReadStream and/or CFWriteStream as desired before we connect.
  1062.  * Note that the CFSocket and CFNativeSocket will not be available until after the connection is opened.
  1063. **/
  1064. - (BOOL)configureStreamsAndReturnError:(NSError **)errPtr
  1065. {
  1066. // Call the delegate method for further configuration.
  1067. if([theDelegate respondsToSelector:@selector(onSocketWillConnect:)])
  1068. {
  1069. if([theDelegate onSocketWillConnect:self] == NO)
  1070. {
  1071. if (errPtr) *errPtr = [self getAbortError];
  1072. return NO;
  1073. }
  1074. }
  1075. return YES;
  1076. }
  1078. - (BOOL)openStreamsAndReturnError:(NSError **)errPtr
  1079. {
  1080. BOOL pass = YES;
  1082. if(pass && !CFReadStreamOpen (theReadStream))
  1083. {
  1084. NSLog (@"AsyncSocket %p couldn't open read stream,", self);
  1085. pass = NO;
  1086. }
  1088. if(pass && !CFWriteStreamOpen (theWriteStream))
  1089. {
  1090. NSLog (@"AsyncSocket %p couldn't open write stream,", self);
  1091. pass = NO;
  1092. }
  1094. if(!pass)
  1095. {
  1096. if (errPtr) *errPtr = [self getStreamError];
  1097. }
  1099. return pass;
  1100. }
  1102. /**
  1103.  * Called when read or write streams open.
  1104.  * When the socket is connected and both streams are open, consider the AsyncSocket instance to be ready.
  1105. **/
  1106. - (void)doStreamOpen
  1107. {
  1108. NSError *err = nil;
  1109. if ([self areStreamsConnected] && !(theFlags & kDidCallConnectDeleg))
  1110. {
  1111. // Get the socket.
  1112. if (![self setSocketFromStreamsAndReturnError: &err])
  1113. {
  1114. NSLog (@"AsyncSocket %p couldn't get socket from streams, %@. Disconnecting.", self, err);
  1115. [self closeWithError:err];
  1116. return;
  1117. }
  1119. // Call the delegate.
  1120. theFlags |= kDidCallConnectDeleg;
  1121. if ([theDelegate respondsToSelector:@selector(onSocket:didConnectToHost:port:)])
  1122. {
  1123. [theDelegate onSocket:self didConnectToHost:[self connectedHost] port:[self connectedPort]];
  1124. }
  1126. // Immediately deal with any already-queued requests.
  1127. [self maybeDequeueRead];
  1128. [self maybeDequeueWrite];
  1129. }
  1130. }
  1132. - (BOOL)setSocketFromStreamsAndReturnError:(NSError **)errPtr
  1133. {
  1134. // Get the CFSocketNativeHandle from theReadStream
  1135. CFSocketNativeHandle native;
  1136. CFDataRef nativeProp = CFReadStreamCopyProperty(theReadStream, kCFStreamPropertySocketNativeHandle);
  1137. if(nativeProp == NULL)
  1138. {
  1139. if (errPtr) *errPtr = [self getStreamError];
  1140. return NO;
  1141. }
  1143. CFDataGetBytes(nativeProp, CFRangeMake(0, CFDataGetLength(nativeProp)), (UInt8 *)&native);
  1144. CFRelease(nativeProp);
  1146. CFSocketRef socket = CFSocketCreateWithNative(kCFAllocatorDefault, native, 0, NULL, NULL);
  1147. if(socket == NULL)
  1148. {
  1149. if (errPtr) *errPtr = [self getSocketError];
  1150. return NO;
  1151. }
  1153. // Determine whether the connection was IPv4 or IPv6
  1154. CFDataRef peeraddr = CFSocketCopyPeerAddress(socket);
  1155. struct sockaddr *sa = (struct sockaddr *)CFDataGetBytePtr(peeraddr);
  1157. if(sa->sa_family == AF_INET)
  1158. {
  1159. theSocket = socket;
  1160. }
  1161. else
  1162. {
  1163. theSocket6 = socket;
  1164. }
  1166. CFRelease(peeraddr);
  1168. return YES;
  1169. }
  1171. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1172. #pragma mark Disconnect Implementation:
  1173. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1175. // Sends error message and disconnects
  1176. - (void)closeWithError:(NSError *)err
  1177. {
  1178. theFlags |= kClosingWithError;
  1180. if (theFlags & kDidPassConnectMethod)
  1181. {
  1182. // Try to salvage what data we can.
  1183. [self recoverUnreadData];
  1185. // Let the delegate know, so it can try to recover if it likes.
  1186. if ([theDelegate respondsToSelector:@selector(onSocket:willDisconnectWithError:)])
  1187. {
  1188. [theDelegate onSocket:self willDisconnectWithError:err];
  1189. }
  1190. }
  1191. [self close];
  1192. }
  1194. // Prepare partially read data for recovery.
  1195. - (void)recoverUnreadData
  1196. {
  1197. if((theCurrentRead != nil) && (theCurrentRead->bytesDone > 0))
  1198. {
  1199. // We never finished the current read.
  1200. // We need to move its data into the front of the partial read buffer.
  1202. [partialReadBuffer replaceBytesInRange:NSMakeRange(0, 0)
  1203.  withBytes:[theCurrentRead->buffer bytes]
  1204. length:theCurrentRead->bytesDone];
  1205. }
  1207. [self emptyQueues];
  1208. }
  1210. - (void)emptyQueues
  1211. {
  1212. if (theCurrentRead != nil) [self endCurrentRead];
  1213. if (theCurrentWrite != nil) [self endCurrentWrite];
  1214. [theReadQueue removeAllObjects];
  1215. [theWriteQueue removeAllObjects];
  1216. [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(maybeDequeueRead) object:nil];
  1217. [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(maybeDequeueWrite) object:nil];
  1218. }
  1220. // Disconnects. This is called for both error and clean disconnections.
  1221. - (void)close
  1222. {
  1223. // Empty queues.
  1224. [self emptyQueues];
  1225. [partialReadBuffer release];
  1226. partialReadBuffer = nil;
  1227. [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(disconnect) object:nil];
  1229. // Close streams.
  1230. if (theReadStream != NULL)
  1231. {
  1232. CFReadStreamSetClient(theReadStream, kCFStreamEventNone, NULL, NULL);
  1233. CFReadStreamUnscheduleFromRunLoop (theReadStream, theRunLoop, kCFRunLoopDefaultMode);
  1234. CFReadStreamClose (theReadStream);
  1235. CFRelease (theReadStream);
  1236. theReadStream = NULL;
  1237. }
  1238. if (theWriteStream != NULL)
  1239. {
  1240. CFWriteStreamSetClient(theWriteStream, kCFStreamEventNone, NULL, NULL);
  1241. CFWriteStreamUnscheduleFromRunLoop (theWriteStream, theRunLoop, kCFRunLoopDefaultMode);
  1242. CFWriteStreamClose (theWriteStream);
  1243. CFRelease (theWriteStream);
  1244. theWriteStream = NULL;
  1245. }
  1247. // Close sockets.
  1248. if (theSocket != NULL)
  1249. {
  1250. CFSocketInvalidate (theSocket);
  1251. CFRelease (theSocket);
  1252. theSocket = NULL;
  1253. }
  1254. if (theSocket6 != NULL)
  1255. {
  1256. CFSocketInvalidate (theSocket6);
  1257. CFRelease (theSocket6);
  1258. theSocket6 = NULL;
  1259. }
  1260. if (theSource != NULL)
  1261. {
  1262. CFRunLoopRemoveSource (theRunLoop, theSource, kCFRunLoopDefaultMode);
  1263. CFRelease (theSource);
  1264. theSource = NULL;
  1265. }
  1266. if (theSource6 != NULL)
  1267. {
  1268. CFRunLoopRemoveSource (theRunLoop, theSource6, kCFRunLoopDefaultMode);
  1269. CFRelease (theSource6);
  1270. theSource6 = NULL;
  1271. }
  1272. theRunLoop = NULL;
  1274. // If the client has passed the connect/accept method, then the connection has at least begun.
  1275. // Notify delegate that it is now ending.
  1276. if (theFlags & kDidPassConnectMethod)
  1277. {
  1278. // Delay notification to give him freedom to release without returning here and core-dumping.
  1279. if ([theDelegate respondsToSelector: @selector(onSocketDidDisconnect:)])
  1280. {
  1281. [theDelegate performSelector:@selector(onSocketDidDisconnect:) withObject:self afterDelay:0];
  1282. }
  1283. }
  1285. // Clear flags.
  1286. theFlags = 0x00;
  1287. }
  1289. /**
  1290.  * Disconnects immediately. Any pending reads or writes are dropped.
  1291. **/
  1292. - (void)disconnect
  1293. {
  1294. [self close];
  1295. }
  1297. /**
  1298.  * Disconnects after all pending writes have completed.
  1299.  * After calling this, the read and write methods (including "readDataWithTimeout:tag:") will do nothing.
  1300.  * The socket will disconnect even if there are still pending reads.
  1301. **/
  1302. - (void)disconnectAfterWriting
  1303. {
  1304. theFlags |= kForbidReadsWrites;
  1305. theFlags |= kDisconnectSoon;
  1306. [self maybeScheduleDisconnect];
  1307. }
  1309. /**
  1310.  * In the event of an error, this method may be called during onSocket:willDisconnectWithError: to read
  1311.  * any data that's left on the socket.
  1312. **/
  1313. - (NSData *)unreadData
  1314. {
  1315. // Ensure this method will only return data in the event of an error
  1316. if(!(theFlags & kClosingWithError)) return nil;
  1318. if(theReadStream == NULL) return nil;
  1320. CFIndex totalBytesRead = [partialReadBuffer length];
  1321. BOOL error = NO;
  1322. while(!error && CFReadStreamHasBytesAvailable(theReadStream))
  1323. {
  1324. [partialReadBuffer increaseLengthBy:READALL_CHUNKSIZE];
  1326. // Number of bytes to read is space left in packet buffer.
  1327. CFIndex bytesToRead = [partialReadBuffer length] - totalBytesRead;
  1329. // Read data into packet buffer
  1330. UInt8 *packetbuf = (UInt8 *)( [partialReadBuffer mutableBytes] + totalBytesRead );
  1331. CFIndex bytesRead = CFReadStreamRead(theReadStream, packetbuf, bytesToRead);
  1333. // Check results
  1334. if(bytesRead < 0)
  1335. {
  1336. error = YES;
  1337. }
  1338. else
  1339. {
  1340. totalBytesRead += bytesRead;
  1341. }
  1342. }
  1344. [partialReadBuffer setLength:totalBytesRead];
  1346. return partialReadBuffer;
  1347. }
  1349. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1350. #pragma mark Errors
  1351. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1353. /**
  1354.  * Returns a standard error object for the current errno value.
  1355.  * Errno is used for low-level BSD socket errors.
  1356. **/
  1357. - (NSError *)getErrnoError
  1358. {
  1359. NSString *errorMsg = [NSString stringWithUTF8String:strerror(errno)];
  1360. NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errorMsg forKey:NSLocalizedDescriptionKey];
  1362. return [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:userInfo];
  1363. }
  1365. /**
  1366.  * Returns a standard error message for a CFSocket error.
  1367.  * Unfortunately, CFSocket offers no feedback on its errors.
  1368. **/
  1369. - (NSError *)getSocketError
  1370. {
  1371. NSString *errMsg = NSLocalizedStringWithDefaultValue(@"AsyncSocketCFSocketError",
  1372.  @"AsyncSocket", [NSBundle mainBundle],
  1373.  @"General CFSocket error", nil);
  1375. NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey];
  1377. return [NSError errorWithDomain:AsyncSocketErrorDomain code:AsyncSocketCFSocketError userInfo:info];
  1378. }
  1380. - (NSError *) getStreamError
  1381. {
  1382. CFStreamError err;
  1383. if (theReadStream != NULL)
  1384. {
  1385. err = CFReadStreamGetError (theReadStream);
  1386. if (err.error != 0) return [self errorFromCFStreamError: err];
  1387. }
  1389. if (theWriteStream != NULL)
  1390. {
  1391. err = CFWriteStreamGetError (theWriteStream);
  1392. if (err.error != 0) return [self errorFromCFStreamError: err];
  1393. }
  1395. return nil;
  1396. }
  1398. /**
  1399.  * Returns a standard AsyncSocket abort error.
  1400. **/
  1401. - (NSError *)getAbortError
  1402. {
  1403. NSString *errMsg = NSLocalizedStringWithDefaultValue(@"AsyncSocketCanceledError",
  1404.  @"AsyncSocket", [NSBundle mainBundle],
  1405.  @"Connection canceled", nil);
  1407. NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey];
  1409. return [NSError errorWithDomain:AsyncSocketErrorDomain code:AsyncSocketCanceledError userInfo:info];
  1410. }
  1412. - (NSError *)getReadMaxedOutError
  1413. {
  1414. NSString *errMsg = NSLocalizedStringWithDefaultValue(@"AsyncSocketReadMaxedOutError",
  1415.  @"AsyncSocket", [NSBundle mainBundle],
  1416.  @"Read operation reached set maximum length", nil);
  1418. NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey];
  1420. return [NSError errorWithDomain:AsyncSocketErrorDomain code:AsyncSocketReadMaxedOutError userInfo:info];
  1421. }
  1423. /**
  1424.  * Returns a standard AsyncSocket read timeout error.
  1425. **/
  1426. - (NSError *)getReadTimeoutError
  1427. {
  1428. NSString *errMsg = NSLocalizedStringWithDefaultValue(@"AsyncSocketReadTimeoutError",
  1429.  @"AsyncSocket", [NSBundle mainBundle],
  1430.  @"Read operation timed out", nil);
  1432. NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey];
  1434. return [NSError errorWithDomain:AsyncSocketErrorDomain code:AsyncSocketReadTimeoutError userInfo:info];
  1435. }
  1437. /**
  1438.  * Returns a standard AsyncSocket write timeout error.
  1439. **/
  1440. - (NSError *)getWriteTimeoutError
  1441. {
  1442. NSString *errMsg = NSLocalizedStringWithDefaultValue(@"AsyncSocketWriteTimeoutError",
  1443.  @"AsyncSocket", [NSBundle mainBundle],
  1444.  @"Write operation timed out", nil);
  1446. NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey];
  1448. return [NSError errorWithDomain:AsyncSocketErrorDomain code:AsyncSocketWriteTimeoutError userInfo:info];
  1449. }
  1451. - (NSError *)errorFromCFStreamError:(CFStreamError)err
  1452. {
  1453. if (err.domain == 0 && err.error == 0) return nil;
  1455. // Can't use switch; these constants aren't int literals.
  1456. NSString *domain = @"CFStreamError (unlisted domain)";
  1457. NSString *message = nil;
  1459. if(err.domain == kCFStreamErrorDomainPOSIX) {
  1460. domain = NSPOSIXErrorDomain;
  1461. }
  1462. else if(err.domain == kCFStreamErrorDomainMacOSStatus) {
  1463. domain = NSOSStatusErrorDomain;
  1464. }
  1465. else if(err.domain == kCFStreamErrorDomainMach) {
  1466. domain = NSMachErrorDomain;
  1467. }
  1468. else if(err.domain == kCFStreamErrorDomainNetDB)
  1469. {
  1470. domain = @"kCFStreamErrorDomainNetDB";
  1471. message = [NSString stringWithCString:gai_strerror(err.error) encoding:NSASCIIStringEncoding];
  1472. }
  1473. else if(err.domain == kCFStreamErrorDomainNetServices) {
  1474. domain = @"kCFStreamErrorDomainNetServices";
  1475. }
  1476. else if(err.domain == kCFStreamErrorDomainSOCKS) {
  1477. domain = @"kCFStreamErrorDomainSOCKS";
  1478. }
  1479. else if(err.domain == kCFStreamErrorDomainSystemConfiguration) {
  1480. domain = @"kCFStreamErrorDomainSystemConfiguration";
  1481. }
  1482. else if(err.domain == kCFStreamErrorDomainSSL) {
  1483. domain = @"kCFStreamErrorDomainSSL";
  1484. }
  1486. NSDictionary *info = nil;
  1487. if(message != nil)
  1488. {
  1489. info = [NSDictionary dictionaryWithObject:message forKey:NSLocalizedDescriptionKey];
  1490. }
  1491. return [NSError errorWithDomain:domain code:err.error userInfo:info];
  1492. }
  1494. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1495. #pragma mark Diagnostics
  1496. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1498. - (BOOL)isConnected
  1499. {
  1500. return [self isSocketConnected] && [self areStreamsConnected];
  1501. }
  1503. - (NSString *)connectedHost
  1504. {
  1505. if(theSocket)
  1506. return [self connectedHost:theSocket];
  1507. else
  1508. return [self connectedHost:theSocket6];
  1509. }
  1511. - (UInt16)connectedPort
  1512. {
  1513. if(theSocket)
  1514. return [self connectedPort:theSocket];
  1515. else
  1516. return [self connectedPort:theSocket6];
  1517. }
  1519. - (NSString *)localHost
  1520. {
  1521. if(theSocket)
  1522. return [self localHost:theSocket];
  1523. else
  1524. return [self localHost:theSocket6];
  1525. }
  1527. - (UInt16)localPort
  1528. {
  1529. if(theSocket)
  1530. return [self localPort:theSocket];
  1531. else
  1532. return [self localPort:theSocket6];
  1533. }
  1535. - (NSString *)connectedHost:(CFSocketRef)socket
  1536. {
  1537. if (socket == NULL) return nil;
  1538. CFDataRef peeraddr;
  1539. NSString *peerstr = nil;
  1541. if(socket && (peeraddr = CFSocketCopyPeerAddress(socket)))
  1542. {
  1543. peerstr = [self addressHost:peeraddr];
  1544. CFRelease (peeraddr);
  1545. }
  1547. return peerstr;
  1548. }
  1550. - (UInt16)connectedPort:(CFSocketRef)socket
  1551. {
  1552. if (socket == NULL) return 0;
  1553. CFDataRef peeraddr;
  1554. UInt16 peerport = 0;
  1556. if(socket && (peeraddr = CFSocketCopyPeerAddress(socket)))
  1557. {
  1558. peerport = [self addressPort:peeraddr];
  1559. CFRelease (peeraddr);
  1560. }
  1562. return peerport;
  1563. }
  1565. - (NSString *)localHost:(CFSocketRef)socket
  1566. {
  1567. if (socket == NULL) return nil;
  1568. CFDataRef selfaddr;
  1569. NSString *selfstr = nil;
  1571. if(socket && (selfaddr = CFSocketCopyAddress(socket)))
  1572. {
  1573. selfstr = [self addressHost:selfaddr];
  1574. CFRelease (selfaddr);
  1575. }
  1577. return selfstr;
  1578. }
  1580. - (UInt16)localPort:(CFSocketRef)socket
  1581. {
  1582. if (socket == NULL) return 0;
  1583. CFDataRef selfaddr;
  1584. UInt16 selfport = 0;
  1586. if (socket && (selfaddr = CFSocketCopyAddress(socket)))
  1587. {
  1588. selfport = [self addressPort:selfaddr];
  1589. CFRelease (selfaddr);
  1590. }
  1592. return selfport;
  1593. }
  1595. - (BOOL)isSocketConnected
  1596. {
  1597. if(theSocket != NULL)
  1598. return CFSocketIsValid(theSocket);
  1599. else if(theSocket6 != NULL)
  1600. return CFSocketIsValid(theSocket6);
  1601. else
  1602. return NO;
  1603. }
  1605. - (BOOL)areStreamsConnected
  1606. {
  1607. CFStreamStatus s;
  1609. if (theReadStream != NULL)
  1610. {
  1611. s = CFReadStreamGetStatus (theReadStream);
  1612. if ( !(s == kCFStreamStatusOpen || s == kCFStreamStatusReading || s == kCFStreamStatusError) )
  1613. return NO;
  1614. }
  1615. else return NO;
  1617. if (theWriteStream != NULL)
  1618. {
  1619. s = CFWriteStreamGetStatus (theWriteStream);
  1620. if ( !(s == kCFStreamStatusOpen || s == kCFStreamStatusWriting || s == kCFStreamStatusError) )
  1621. return NO;
  1622. }
  1623. else return NO;
  1625. return YES;
  1626. }
  1628. - (NSString *)addressHost:(CFDataRef)cfaddr
  1629. {
  1630. if (cfaddr == NULL) return nil;
  1632. char addrBuf[ MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) ];
  1633. struct sockaddr *pSockAddr = (struct sockaddr *) CFDataGetBytePtr (cfaddr);
  1634. struct sockaddr_in  *pSockAddrV4 = (struct sockaddr_in *) pSockAddr;
  1635. struct sockaddr_in6 *pSockAddrV6 = (struct sockaddr_in6 *)pSockAddr;
  1637. const void *pAddr = (pSockAddr->sa_family == AF_INET) ?
  1638. (void *)(&(pSockAddrV4->sin_addr)) :
  1639. (void *)(&(pSockAddrV6->sin6_addr));
  1641. const char *pStr = inet_ntop (pSockAddr->sa_family, pAddr, addrBuf, sizeof(addrBuf));
  1642. if (pStr == NULL) [NSException raise: NSInternalInconsistencyException
  1643.   format: @"Cannot convert address to string."];
  1645. return [NSString stringWithCString:pStr encoding:NSASCIIStringEncoding];
  1646. }
  1648. - (UInt16)addressPort:(CFDataRef)cfaddr
  1649. {
  1650. if (cfaddr == NULL) return 0;
  1651. struct sockaddr_in *pAddr = (struct sockaddr_in *) CFDataGetBytePtr (cfaddr);
  1652. return ntohs (pAddr->sin_port);
  1653. }
  1655. - (BOOL)isIPv4
  1656. {
  1657. return (theSocket != NULL);
  1658. }
  1660. - (BOOL)isIPv6
  1661. {
  1662. return (theSocket6 != NULL);
  1663. }
  1665. - (NSString *)description
  1666. {
  1667. static const char *statstr[] = { "not open", "opening", "open", "reading", "writing", "at end", "closed", "has error" };
  1668. CFStreamStatus rs = (theReadStream != NULL) ? CFReadStreamGetStatus (theReadStream) : 0;
  1669. CFStreamStatus ws = (theWriteStream != NULL) ? CFWriteStreamGetStatus (theWriteStream) : 0;
  1670. NSString *peerstr, *selfstr;
  1671. CFDataRef peeraddr = NULL, peeraddr6 = NULL, selfaddr = NULL, selfaddr6 = NULL;
  1673. if (theSocket || theSocket6)
  1674. {
  1675. if (theSocket)  peeraddr  = CFSocketCopyPeerAddress(theSocket);
  1676. if (theSocket6) peeraddr6 = CFSocketCopyPeerAddress(theSocket6);
  1678. if(theSocket6 && theSocket)
  1679. {
  1680. peerstr = [NSString stringWithFormat: @"%@/%@ %u", [self addressHost:peeraddr], [self addressHost:peeraddr6], [self addressPort:peeraddr]];
  1681. }
  1682. else if(theSocket6)
  1683. {
  1684. peerstr = [NSString stringWithFormat: @"%@ %u", [self addressHost:peeraddr6], [self addressPort:peeraddr6]];
  1685. }
  1686. else
  1687. {
  1688. peerstr = [NSString stringWithFormat: @"%@ %u", [self addressHost:peeraddr], [self addressPort:peeraddr]];
  1689. }
  1691. if(peeraddr)  CFRelease(peeraddr);
  1692. if(peeraddr6) CFRelease(peeraddr6);
  1693. peeraddr = NULL;
  1694. peeraddr6 = NULL;
  1695. }
  1696. else peerstr = @"nowhere";
  1698. if (theSocket || theSocket6)
  1699. {
  1700. if (theSocket)  selfaddr  = CFSocketCopyAddress (theSocket);
  1701. if (theSocket6) selfaddr6 = CFSocketCopyAddress (theSocket6);
  1703. if (theSocket6 && theSocket)
  1704. {
  1705. selfstr = [NSString stringWithFormat: @"%@/%@ %u", [self addressHost:selfaddr], [self addressHost:selfaddr6], [self addressPort:selfaddr]];
  1706. }
  1707. else if (theSocket6)
  1708. {
  1709. selfstr = [NSString stringWithFormat: @"%@ %u", [self addressHost:selfaddr6], [self addressPort:selfaddr6]];
  1710. }
  1711. else
  1712. {
  1713. selfstr = [NSString stringWithFormat: @"%@ %u", [self addressHost:selfaddr], [self addressPort:selfaddr]];
  1714. }
  1716. if(selfaddr)  CFRelease(selfaddr);
  1717. if(selfaddr6) CFRelease(selfaddr6);
  1718. selfaddr = NULL;
  1719. selfaddr6 = NULL;
  1720. }
  1721. else selfstr = @"nowhere";
  1723. NSMutableString *ms = [[NSMutableString alloc] init];
  1724. [ms appendString: [NSString stringWithFormat:@"<AsyncSocket %p", self]];
  1725. [ms appendString: [NSString stringWithFormat:@" local %@ remote %@ ", selfstr, peerstr]];
  1726. [ms appendString: [NSString stringWithFormat:@"has queued %d reads %d writes, ", [theReadQueue count], [theWriteQueue count] ]];
  1728. if (theCurrentRead == nil)
  1729. [ms appendString: @"no current read, "];
  1730. else
  1731. {
  1732. int percentDone;
  1733. if ([theCurrentRead->buffer length] != 0)
  1734. percentDone = (float)theCurrentRead->bytesDone /
  1735.   (float)[theCurrentRead->buffer length] * 100.0;
  1736. else
  1737. percentDone = 100;
  1739. [ms appendString: [NSString stringWithFormat:@"currently read %u bytes (%d%% done), ",
  1740. [theCurrentRead->buffer length],
  1741. theCurrentRead->bytesDone ? percentDone : 0]];
  1742. }
  1744. if (theCurrentWrite == nil)
  1745. [ms appendString: @"no current write, "];
  1746. else
  1747. {
  1748. int percentDone;
  1749. if ([theCurrentWrite->buffer length] != 0)
  1750. percentDone = (float)theCurrentWrite->bytesDone /
  1751.   (float)[theCurrentWrite->buffer length] * 100.0;
  1752. else
  1753. percentDone = 100;
  1755. [ms appendString: [NSString stringWithFormat:@"currently written %u (%d%%), ",
  1756. [theCurrentWrite->buffer length],
  1757. theCurrentWrite->bytesDone ? percentDone : 0]];
  1758. }
  1760. [ms appendString: [NSString stringWithFormat:@"read stream %p %s, write stream %p %s", theReadStream, statstr [rs], theWriteStream, statstr [ws] ]];
  1761. if (theFlags & kDisconnectSoon) [ms appendString: @", will disconnect soon"];
  1762. if (![self isConnected]) [ms appendString: @", not connected"];
  1764. [ms appendString: @">"];
  1766. return [ms autorelease];
  1767. }
  1769. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1770. #pragma mark Reading
  1771. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1773. - (void)readDataToLength:(CFIndex)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
  1774. {
  1775. if(length == 0) return;
  1776. if(theFlags & kForbidReadsWrites) return;
  1778. NSMutableData *buffer = [[NSMutableData alloc] initWithLength:length];
  1779. AsyncReadPacket *packet = [[AsyncReadPacket alloc] initWithData:buffer
  1780. timeout:timeout
  1781. tag:tag
  1782.    readAllAvailable:NO
  1783.  terminator:nil
  1784.   maxLength:length];
  1786. [theReadQueue addObject:packet];
  1787. [self scheduleDequeueRead];
  1789. [packet release];
  1790. [buffer release];
  1791. }
  1793. - (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag
  1794. {
  1795. [self readDataToData:data withTimeout:timeout maxLength:-1 tag:tag];
  1796. }
  1798. - (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout maxLength:(CFIndex)length tag:(long)tag
  1799. {
  1800. if(data == nil || [data length] == 0) return;
  1801. if(length >= 0 && length < [data length]) return;
  1802. if(theFlags & kForbidReadsWrites) return;
  1804. NSMutableData *buffer = [[NSMutableData alloc] initWithLength:0];
  1805. AsyncReadPacket *packet = [[AsyncReadPacket alloc] initWithData:buffer
  1806. timeout:timeout
  1807. tag:tag 
  1808.    readAllAvailable:NO 
  1809.  terminator:data
  1810.   maxLength:length];
  1812. [theReadQueue addObject:packet];
  1813. [self scheduleDequeueRead];
  1815. [packet release];
  1816. [buffer release];
  1817. }
  1819. - (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag
  1820. {
  1821. if (theFlags & kForbidReadsWrites) return;
  1823. NSMutableData *buffer = [[NSMutableData alloc] initWithLength:0];
  1824. AsyncReadPacket *packet = [[AsyncReadPacket alloc] initWithData:buffer
  1825. timeout:timeout
  1826. tag:tag
  1827.    readAllAvailable:YES
  1828.  terminator:nil
  1829.   maxLength:-1];
  1831. [theReadQueue addObject:packet];
  1832. [self scheduleDequeueRead];
  1834. [packet release];
  1835. [buffer release];
  1836. }
  1838. /**
  1839.  * Puts a maybeDequeueRead on the run loop. 
  1840.  * An assumption here is that selectors will be performed consecutively within their priority.
  1841. **/
  1842. - (void)scheduleDequeueRead
  1843. {
  1844. [self performSelector:@selector(maybeDequeueRead) withObject:nil afterDelay:0];
  1845. }
  1847. /**
  1848.  * This method starts a new read, if needed.
  1849.  * It is called when a user requests a read,
  1850.  * or when a stream opens that may have requested reads sitting in the queue, etc.
  1851. **/
  1852. - (void)maybeDequeueRead
  1853. {
  1854. // If we're not currently processing a read AND
  1855. // we have read requests sitting in the queue AND we have actually have a read stream
  1856. if(theCurrentRead == nil && [theReadQueue count] != 0 && theReadStream != NULL)
  1857. {
  1858. // Get new current read AsyncReadPacket.
  1859. AsyncReadPacket *newPacket = [theReadQueue objectAtIndex:0];
  1860. theCurrentRead = [newPacket retain];
  1861. [theReadQueue removeObjectAtIndex:0];
  1863. // Start time-out timer.
  1864. if(theCurrentRead->timeout >= 0.0)
  1865. {
  1866. theReadTimer = [NSTimer scheduledTimerWithTimeInterval:theCurrentRead->timeout
  1867. target:self 
  1868.   selector:@selector(doReadTimeout:)
  1869.   userInfo:nil
  1870.    repeats:NO];
  1871. }
  1873. // Immediately read, if possible.
  1874. [self doBytesAvailable];
  1875. }
  1876. }
  1878. /**
  1879.  * Call this method in doBytesAvailable instead of CFReadStreamHasBytesAvailable().
  1880.  * This method supports pre-buffering properly.
  1881. **/
  1882. - (BOOL)hasBytesAvailable
  1883. {
  1884. return ([partialReadBuffer length] > 0) || CFReadStreamHasBytesAvailable(theReadStream);
  1885. }
  1887. /**
  1888.  * Call this method in doBytesAvailable instead of CFReadStreamRead().
  1889.  * This method support pre-buffering properly.
  1890. **/
  1891. - (CFIndex)readIntoBuffer:(UInt8 *)buffer maxLength:(CFIndex)length
  1892. {
  1893. if([partialReadBuffer length] > 0)
  1894. {
  1895. // Determine the maximum amount of data to read
  1896. CFIndex bytesToRead = MIN(length, [partialReadBuffer length]);
  1898. // Copy the bytes from the buffer
  1899. memcpy(buffer, [partialReadBuffer bytes], bytesToRead);
  1901. // Remove the copied bytes from the buffer
  1902. [partialReadBuffer replaceBytesInRange:NSMakeRange(0, bytesToRead) withBytes:NULL length:0];
  1904. return bytesToRead;
  1905. }
  1906. else
  1907. {
  1908. return CFReadStreamRead(theReadStream, buffer, length);
  1909. }
  1910. }
  1912. /**
  1913.  * This method is called when a new read is taken from the read queue or when new data becomes available on the stream.
  1914. **/
  1915. - (void)doBytesAvailable
  1916. {
  1917. // If data is available on the stream, but there is no read request, then we don't need to process the data yet.
  1918. // Also, if there is a read request, but no read stream setup yet, we can't process any data yet.
  1919. if(theCurrentRead != nil && theReadStream != NULL)
  1920. {
  1921. CFIndex totalBytesRead = 0;
  1923. BOOL done = NO;
  1924. BOOL socketError = NO;
  1925. BOOL maxoutError = NO;
  1927. while(!done && !socketError && !maxoutError && [self hasBytesAvailable])
  1928. {
  1929. BOOL didPreBuffer = NO;
  1931. // If reading all available data, make sure there's room in the packet buffer.
  1932. if(theCurrentRead->readAllAvailableData == YES)
  1933. {
  1934. // Make sure there is at least READALL_CHUNKSIZE bytes available.
  1935. // We don't want to increase the buffer any more than this or we'll waste space.
  1936. // With prebuffering it's possible to read in a small chunk on the first read.
  1938. unsigned buffInc = READALL_CHUNKSIZE - ([theCurrentRead->buffer length] - theCurrentRead->bytesDone);
  1939. [theCurrentRead->buffer increaseLengthBy:buffInc];
  1940. }
  1942. // If reading until data, we may only want to read a few bytes.
  1943. // Just enough to ensure we don't go past our term or over our max limit.
  1944. // Unless pre-buffering is enabled, in which case we may want to read in a larger chunk.
  1945. if(theCurrentRead->term != nil)
  1946. {
  1947. // If we already have data pre-buffered, we obviously don't want to pre-buffer it again.
  1948. // So in this case we'll just read as usual.
  1950. if(([partialReadBuffer length] > 0) || !(theFlags & kEnablePreBuffering))
  1951. {
  1952. unsigned maxToRead = [theCurrentRead readLengthForTerm];
  1954. unsigned bufInc = maxToRead - ([theCurrentRead->buffer length] - theCurrentRead->bytesDone);
  1955. [theCurrentRead->buffer increaseLengthBy:bufInc];
  1956. }
  1957. else
  1958. {
  1959. didPreBuffer = YES;
  1960. unsigned maxToRead = [theCurrentRead prebufferReadLengthForTerm];
  1962. unsigned buffInc = maxToRead - ([theCurrentRead->buffer length] - theCurrentRead->bytesDone);
  1963. [theCurrentRead->buffer increaseLengthBy:buffInc];
  1965. }
  1966. }
  1968. // Number of bytes to read is space left in packet buffer.
  1969. CFIndex bytesToRead = [theCurrentRead->buffer length] - theCurrentRead->bytesDone;
  1971. // Read data into packet buffer
  1972. UInt8 *subBuffer = (UInt8 *)([theCurrentRead->buffer mutableBytes] + theCurrentRead->bytesDone);
  1973. CFIndex bytesRead = [self readIntoBuffer:subBuffer maxLength:bytesToRead];
  1975. // Check results
  1976. if(bytesRead < 0)
  1977. {
  1978. socketError = YES;
  1979. }
  1980. else
  1981. {
  1982. // Update total amound read for the current read
  1983. theCurrentRead->bytesDone += bytesRead;
  1985. // Update total amount read in this method invocation
  1986. totalBytesRead += bytesRead;
  1987. }
  1989. // Is packet done?
  1990. if(theCurrentRead->readAllAvailableData != YES)
  1991. {
  1992. if(theCurrentRead->term != nil)
  1993. {
  1994. if(didPreBuffer)
  1995. {
  1996. // Search for the terminating sequence within the big chunk we just read.
  1997. CFIndex overflow = [theCurrentRead searchForTermAfterPreBuffering:bytesRead];
  1999. if(overflow > 0)
  2000. {
  2001. // Copy excess data into partialReadBuffer
  2002. NSMutableData *buffer = theCurrentRead->buffer;
  2003. const void *overflowBuffer = [buffer bytes] + theCurrentRead->bytesDone - overflow;
  2005. [partialReadBuffer appendBytes:overflowBuffer length:overflow];
  2007. // Update the bytesDone variable.
  2008. // Note: The completeCurrentRead method will trim the buffer for us.
  2009. theCurrentRead->bytesDone -= overflow;
  2010. }
  2012. done = (overflow >= 0);
  2013. }
  2014. else
  2015. {
  2016. // Search for the terminating sequence at the end of the buffer
  2017. int termlen = [theCurrentRead->term length];
  2018. if(theCurrentRead->bytesDone >= termlen)
  2019. {
  2020. const void *buf = [theCurrentRead->buffer bytes] + (theCurrentRead->bytesDone - termlen);
  2021. const void *seq = [theCurrentRead->term bytes];
  2022. done = (memcmp (buf, seq, termlen) == 0);
  2023. }
  2024. }
  2026. if(!done && theCurrentRead->maxLength >= 0 && theCurrentRead->bytesDone >= theCurrentRead->maxLength)
  2027. {
  2028. // There's a set maxLength, and we've reached that maxLength without completing the read
  2029. maxoutError = YES;
  2030. }
  2031. }
  2032. else
  2033. {
  2034. // Done when (sized) buffer is full.
  2035. done = ([theCurrentRead->buffer length] == theCurrentRead->bytesDone);
  2036. }
  2037. }
  2038. // else readAllAvailable doesn't end until all readable is read.
  2039. }
  2041. if(theCurrentRead->readAllAvailableData && theCurrentRead->bytesDone > 0)
  2042. done = YES; // Ran out of bytes, so the "read-all-data" type packet is done
  2044. if(done)
  2045. {
  2046. [self completeCurrentRead];
  2047. if (!socketError) [self scheduleDequeueRead];
  2048. }
  2049. else if(theCurrentRead->bytesDone > 0)
  2050. {
  2051. // We're not done with the readToLength or readToData yet, but we have read in some bytes
  2052. if ([theDelegate respondsToSelector:@selector(onSocket:didReadPartialDataOfLength:tag:)])
  2053. {
  2054. [theDelegate onSocket:self didReadPartialDataOfLength:totalBytesRead tag:theCurrentRead->tag];
  2055. }
  2056. }
  2058. if(socketError)
  2059. {
  2060. CFStreamError err = CFReadStreamGetError(theReadStream);
  2061. [self closeWithError:[self errorFromCFStreamError:err]];
  2062. return;
  2063. }
  2064. if(maxoutError)
  2065. {
  2066. [self closeWithError:[self getReadMaxedOutError]];
  2067. return;
  2068. }
  2069. }
  2070. }
  2072. // Ends current read and calls delegate.
  2073. - (void)completeCurrentRead
  2074. {
  2075. NSAssert (theCurrentRead, @"Trying to complete current read when there is no current read.");
  2077. [theCurrentRead->buffer setLength:theCurrentRead->bytesDone];
  2078. if([theDelegate respondsToSelector:@selector(onSocket:didReadData:withTag:)])
  2079. {
  2080. [theDelegate onSocket:self didReadData:theCurrentRead->buffer withTag:theCurrentRead->tag];
  2081. }
  2083. if (theCurrentRead != nil) [self endCurrentRead]; // Caller may have disconnected.
  2084. }
  2086. // Ends current read.
  2087. - (void)endCurrentRead
  2088. {
  2089. NSAssert (theCurrentRead, @"Trying to end current read when there is no current read.");
  2091. [theReadTimer invalidate];
  2092. theReadTimer = nil;
  2094. [theCurrentRead release];
  2095. theCurrentRead = nil;
  2096. }
  2098. - (void)doReadTimeout:(NSTimer *)timer
  2099. {
  2100. if (timer != theReadTimer) return; // Old timer. Ignore it.
  2101. if (theCurrentRead != nil)
  2102. {
  2103. [self endCurrentRead];
  2104. }
  2105. [self closeWithError:[self getReadTimeoutError]];
  2106. }
  2108. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  2109. #pragma mark Writing
  2110. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  2112. - (void)writeData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
  2113. {
  2114. if (data == nil || [data length] == 0) return;
  2115. if (theFlags & kForbidReadsWrites) return;
  2117. AsyncWritePacket *packet = [[AsyncWritePacket alloc] initWithData:data timeout:timeout tag:tag];
  2119. [theWriteQueue addObject:packet];
  2120. [self scheduleDequeueWrite];
  2122. [packet release];
  2123. }
  2125. - (void)scheduleDequeueWrite
  2126. {
  2127. [self performSelector:@selector(maybeDequeueWrite) withObject:nil afterDelay:0];
  2128. }
  2130. // Start a new write.
  2131. - (void)maybeDequeueWrite
  2132. {
  2133. if (theCurrentWrite == nil && [theWriteQueue count] != 0 && theWriteStream != NULL)
  2134. {
  2135. // Get new current write AsyncWritePacket.
  2136. AsyncWritePacket *newPacket = [theWriteQueue objectAtIndex:0];
  2137. theCurrentWrite = [newPacket retain];
  2138. [theWriteQueue removeObjectAtIndex:0];
  2140. // Start time-out timer.
  2141. if (theCurrentWrite->timeout >= 0.0)
  2142. {
  2143. theWriteTimer = [NSTimer scheduledTimerWithTimeInterval:theCurrentWrite->timeout
  2144.                                                  target:self
  2145.                                                selector:@selector(doWriteTimeout:)
  2146.                                                userInfo:nil
  2147.                                                 repeats:NO];
  2148. }
  2150. // Immediately write, if possible.
  2151. [self doSendBytes];
  2152. }
  2153. }
  2155. - (void)doSendBytes
  2156. {
  2157. if (theCurrentWrite != nil && theWriteStream != NULL)
  2158. {
  2159. BOOL done = NO, error = NO;
  2160. while (!done && !error && CFWriteStreamCanAcceptBytes (theWriteStream))
  2161. {
  2162. // Figure out what to write.
  2163. CFIndex bytesRemaining = [theCurrentWrite->buffer length] - theCurrentWrite->bytesDone;
  2164. CFIndex bytesToWrite = (bytesRemaining < WRITE_CHUNKSIZE) ? bytesRemaining : WRITE_CHUNKSIZE;
  2165. UInt8 *writestart = (UInt8 *)([theCurrentWrite->buffer bytes] + theCurrentWrite->bytesDone);
  2167. // Write.
  2168. CFIndex bytesWritten = CFWriteStreamWrite (theWriteStream, writestart, bytesToWrite);
  2170. // Check results.
  2171. if (bytesWritten < 0)
  2172. {
  2173. bytesWritten = 0;
  2174. error = YES;
  2175. }
  2177. // Is packet done?
  2178. theCurrentWrite->bytesDone += bytesWritten;
  2179. done = ([theCurrentWrite->buffer length] == theCurrentWrite->bytesDone);
  2180. }
  2182. if(done)
  2183. {
  2184. [self completeCurrentWrite];
  2185. if (!error) [self scheduleDequeueWrite];
  2186. }
  2188. if(error)
  2189. {
  2190. CFStreamError err = CFWriteStreamGetError (theWriteStream);
  2191. [self closeWithError: [self errorFromCFStreamError:err]];
  2192. return;
  2193. }
  2194. }
  2195. }
  2197. // Ends current write and calls delegate.
  2198. - (void)completeCurrentWrite
  2199. {
  2200. NSAssert (theCurrentWrite, @"Trying to complete current write when there is no current write.");
  2202. if ([theDelegate respondsToSelector:@selector(onSocket:didWriteDataWithTag:)])
  2203. {
  2204. [theDelegate onSocket:self didWriteDataWithTag:theCurrentWrite->tag];
  2205. }
  2207. if (theCurrentWrite != nil) [self endCurrentWrite]; // Caller may have disconnected.
  2208. }
  2210. // Ends current write.
  2211. - (void)endCurrentWrite
  2212. {
  2213. NSAssert (theCurrentWrite, @"Trying to complete current write when there is no current write.");
  2215. [theWriteTimer invalidate];
  2216. theWriteTimer = nil;
  2218. [theCurrentWrite release];
  2219. theCurrentWrite = nil;
  2221. [self maybeScheduleDisconnect];
  2222. }
  2224. // Checks to see if all writes have been completed for disconnectAfterWriting.
  2225. - (void)maybeScheduleDisconnect
  2226. {
  2227. if(theFlags & kDisconnectSoon)
  2228. {
  2229. if(([theWriteQueue count] == 0) && (theCurrentWrite == nil))
  2230. {
  2231. [self performSelector:@selector(disconnect) withObject:nil afterDelay:0];
  2232. }
  2233. }
  2234. }
  2236. - (void)doWriteTimeout:(NSTimer *)timer
  2237. {
  2238. if (timer != theWriteTimer) return; // Old timer. Ignore it.
  2239. if (theCurrentWrite != nil)
  2240. {
  2241. [self endCurrentWrite];
  2242. }
  2243. [self closeWithError:[self getWriteTimeoutError]];
  2244. }
  2246. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  2247. #pragma mark CF Callbacks
  2248. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  2250. - (void)doCFSocketCallback:(CFSocketCallBackType)type
  2251.  forSocket:(CFSocketRef)sock
  2252.    withAddress:(NSData *)address
  2253.   withData:(const void *)pData
  2254. {
  2255. NSParameterAssert ((sock == theSocket) || (sock == theSocket6));
  2257. switch (type)
  2258. {
  2259. case kCFSocketConnectCallBack:
  2260. // The data argument is either NULL or a pointer to an SInt32 error code, if the connect failed.
  2261. if(pData)
  2262. [self doSocketOpen:sock withCFSocketError:kCFSocketError];
  2263. else
  2264. [self doSocketOpen:sock withCFSocketError:kCFSocketSuccess];
  2265. break;
  2266. case kCFSocketAcceptCallBack:
  2267. [self doAcceptWithSocket: *((CFSocketNativeHandle *)pData)];
  2268. break;
  2269. default:
  2270. NSLog (@"AsyncSocket %p received unexpected CFSocketCallBackType %d.", self, type);
  2271. break;
  2272. }
  2273. }
  2275. - (void)doCFReadStreamCallback:(CFStreamEventType)type forStream:(CFReadStreamRef)stream
  2276. {
  2277. NSParameterAssert(theReadStream != NULL);
  2279. CFStreamError err;
  2280. switch (type)
  2281. {
  2282. case kCFStreamEventOpenCompleted:
  2283. [self doStreamOpen];
  2284. break;
  2285. case kCFStreamEventHasBytesAvailable:
  2286. [self doBytesAvailable];
  2287. break;
  2288. case kCFStreamEventErrorOccurred:
  2289. case kCFStreamEventEndEncountered:
  2290. err = CFReadStreamGetError (theReadStream);
  2291. [self closeWithError: [self errorFromCFStreamError:err]];
  2292. break;
  2293. default:
  2294. NSLog (@"AsyncSocket %p received unexpected CFReadStream callback, CFStreamEventType %d.", self, type);
  2295. }
  2296. }
  2298. - (void)doCFWriteStreamCallback:(CFStreamEventType)type forStream:(CFWriteStreamRef)stream
  2299. {
  2300. NSParameterAssert(theWriteStream != NULL);
  2302. CFStreamError err;
  2303. switch (type)
  2304. {
  2305. case kCFStreamEventOpenCompleted:
  2306. [self doStreamOpen];
  2307. break;
  2308. case kCFStreamEventCanAcceptBytes:
  2309. [self doSendBytes];
  2310. break;
  2311. case kCFStreamEventErrorOccurred:
  2312. case kCFStreamEventEndEncountered:
  2313. err = CFWriteStreamGetError (theWriteStream);
  2314. [self closeWithError: [self errorFromCFStreamError:err]];
  2315. break;
  2316. default:
  2317. NSLog (@"AsyncSocket %p received unexpected CFWriteStream callback, CFStreamEventType %d.", self, type);
  2318. }
  2319. }
  2321. /**
  2322.  * This is the callback we setup for CFSocket.
  2323.  * This method does nothing but forward the call to it's Objective-C counterpart
  2324. **/
  2325. static void MyCFSocketCallback (CFSocketRef sref, CFSocketCallBackType type, CFDataRef address, const void *pData, void *pInfo)
  2326. {
  2327. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
  2329. AsyncSocket *socket = [[(AsyncSocket *)pInfo retain] autorelease];
  2330. [socket doCFSocketCallback:type forSocket:sref withAddress:(NSData *)address withData:pData];
  2332. [pool release];
  2333. }
  2335. /**
  2336.  * This is the callback we setup for CFReadStream.
  2337.  * This method does nothing but forward the call to it's Objective-C counterpart
  2338. **/
  2339. static void MyCFReadStreamCallback (CFReadStreamRef stream, CFStreamEventType type, void *pInfo)
  2340. {
  2341. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
  2343. AsyncSocket *socket = [[(AsyncSocket *)pInfo retain] autorelease];
  2344. [socket doCFReadStreamCallback:type forStream:stream];
  2346. [pool release];
  2347. }
  2349. /**
  2350.  * This is the callback we setup for CFWriteStream.
  2351.  * This method does nothing but forward the call to it's Objective-C counterpart
  2352. **/
  2353. static void MyCFWriteStreamCallback (CFWriteStreamRef stream, CFStreamEventType type, void *pInfo)
  2354. {
  2355. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
  2357. AsyncSocket *socket = [[(AsyncSocket *)pInfo retain] autorelease];
  2358. [socket doCFWriteStreamCallback:type forStream:stream];
  2360. [pool release];
  2361. }
  2363. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  2364. #pragma mark Class Methods
  2365. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  2367. // Return line separators.
  2368. + (NSData *)CRLFData
  2369. {
  2370. return [NSData dataWithBytes:"x0Dx0A" length:2];
  2371. }
  2373. + (NSData *)CRData
  2374. {
  2375. return [NSData dataWithBytes:"x0D" length:1];
  2376. }
  2378. + (NSData *)LFData
  2379. {
  2380. return [NSData dataWithBytes:"x0A" length:1];
  2381. }
  2383. + (NSData *)ZeroData
  2384. {
  2385. return [NSData dataWithBytes:"" length:1];
  2386. }
  2388. @end