//

 //  TCPStream.m

 //  MYNetwork

 //

 //  Created by Jens Alfke on 5/10/08.

 //  Copyright 2008 Jens Alfke. All rights reserved.

 //

 #import "TCPStream.h"

 #import "TCP_Internal.h"

 #import "IPAddress.h"

 #import "Logging.h"

 #import "Test.h"

 extern const CFStringRef _kCFStreamPropertySSLClientSideAuthentication; // in CFNetwork

 static NSError* fixStreamError( NSError *error );

 @implementation TCPStream

 - (id) initWithConnection: (TCPConnection*)conn stream: (NSStream*)stream

 {

     self = [super init];

     if (self != nil) {

         _conn = [conn retain];

         _stream = [stream retain];

         _stream.delegate = self;

         [_stream scheduleInRunLoop: [NSRunLoop currentRunLoop] forMode: NSRunLoopCommonModes];

         LogTo(TCPVerbose,@"%@ initialized; status=%i", self,_stream.streamStatus);

     }

     return self;

 }

 - (void) dealloc

 {

     LogTo(TCP,@"DEALLOC %@",self);

     if( _stream )

         [self disconnect];

     [super dealloc];

 }

 - (id) propertyForKey: (CFStringRef)cfStreamProperty

 {

     return [_stream propertyForKey: (NSString*)cfStreamProperty];

 }

 - (void) setProperty: (id)value forKey: (CFStringRef)cfStreamProperty

 {

     if( ! [_stream setProperty: value forKey: (NSString*)cfStreamProperty] )

         Warn(@"Failed to set property %@ on %@",cfStreamProperty,self);

 }

 - (IPAddress*) peerAddress

 {

     const CFSocketNativeHandle *socketPtr = [[self propertyForKey: kCFStreamPropertySocketNativeHandle] bytes];

     return socketPtr ?[IPAddress addressOfSocket: *socketPtr] :nil;

 }

 #pragma mark -

 #pragma mark SSL:

 - (NSString*) securityLevel                 {return [_stream propertyForKey: NSStreamSocketSecurityLevelKey];}

 - (NSDictionary*) SSLProperties             {return [self propertyForKey: kCFStreamPropertySSLSettings];}

 - (void) setSSLProperties: (NSDictionary*)p

 {

     LogTo(TCPVerbose,@"%@ SSL settings := %@",self,p);

     [self setProperty: p forKey: kCFStreamPropertySSLSettings];

     id clientAuth = [p objectForKey: kTCPPropertySSLClientSideAuthentication];

     if( clientAuth )

         [self setProperty: clientAuth forKey: _kCFStreamPropertySSLClientSideAuthentication];

 }

 - (NSArray*) peerSSLCerts

 {

     Assert(self.isOpen);

     return [self propertyForKey: kCFStreamPropertySSLPeerCertificates];

 }

 #pragma mark -

 #pragma mark OPENING/CLOSING:

 - (void) open

 {

     Assert(_stream);

     AssertEq(_stream.streamStatus,NSStreamStatusNotOpen);

     LogTo(TCP,@"Opening %@",self);

     [_stream open];

 }

 - (void) disconnect

 {

     if( _stream ) {

         LogTo(TCP,@"Disconnect %@",self);

         _stream.delegate = nil;

         [_stream close];

         setObj(&_stream,nil);

     }

     if( _conn ) {

         [self retain];

         [_conn _streamDisconnected: self];

         setObj(&_conn,nil);

         [self release];

     }

 }

 - (BOOL) close

 {

     _shouldClose = YES;

     if( self.isBusy ) {

         return NO;

     } else {

         LogTo(TCP,@"Request to close %@",self);

         [[self retain] autorelease];        // don't let myself be dealloced in the midst of this

         [_conn _streamCanClose: self];

         return YES;

     }

 }

 - (BOOL) isOpen

 {

     NSStreamStatus status = _stream.streamStatus;

     return status >= NSStreamStatusOpen && status < NSStreamStatusAtEnd;

 }

 - (BOOL) isBusy

 {

     return NO;  // abstract

 }

 - (BOOL) isActive

 {

     return !_shouldClose || self.isBusy;

 }

 - (void) _opened

 {

     [_conn _streamOpened: self];

 }

 - (void) _canRead

 {

     // abstract

 }

 - (void) _canWrite

 {

     // abstract

 }

 - (void) _gotEOF

 {

     [_conn _streamGotEOF: self];

 }

 - (BOOL) _gotError: (NSError*)error

 {

     [_conn _stream: self gotError: fixStreamError(error)];

     return NO;

 }

 - (BOOL) _gotError

 {

     NSError *error = _stream.streamError;

     if( ! error )

         error = [NSError errorWithDomain: NSPOSIXErrorDomain code: EIO userInfo: nil]; //fallback

     return [self _gotError: error];

 }

 - (void) stream: (NSStream*)stream handleEvent: (NSStreamEvent)streamEvent 

 {

     [[self retain] autorelease];

     switch(streamEvent) {

         case NSStreamEventOpenCompleted:

             LogTo(TCPVerbose,@"%@ opened",self);

             [self _opened];

             break;

         case NSStreamEventHasBytesAvailable:

             if( ! [_conn _streamPeerCertAvailable: self] )

                 return;

             LogTo(TCPVerbose,@"%@ can read",self);

             [self _canRead];

             break;

         case NSStreamEventHasSpaceAvailable:

             if( ! [_conn _streamPeerCertAvailable: self] )

                 return;

             LogTo(TCPVerbose,@"%@ can write",self);

             [self _canWrite];

             break;

         case NSStreamEventErrorOccurred:

             LogTo(TCPVerbose,@"%@ got error",self);

             [self _gotError];

             break;

         case NSStreamEventEndEncountered:

             LogTo(TCPVerbose,@"%@ got EOF",self);

             [self _gotEOF];

             break;

         default:

             Warn(@"%@: unknown NSStreamEvent %i",self,streamEvent);

             break;

     }

     // If I was previously asked to close, try again in case I'm no longer busy

     if( _shouldClose )

         [self close];

 }

 @end

 @implementation TCPReader

 - (TCPWriter*) writer

 {

     return _conn.writer;

 }

 - (NSInteger) read: (void*)dst maxLength: (NSUInteger)maxLength

 {

     NSInteger bytesRead = [(NSInputStream*)_stream read:dst maxLength: maxLength];

     if( bytesRead < 0 )

         [self _gotError];

     return bytesRead;

 }

 @end

 static NSError* fixStreamError( NSError *error )

 {

     // NSStream incorrectly returns SSL errors without the correct error domain:

     if( $equal(error.domain,@"NSUnknownErrorDomain") ) {

         int code = error.code;

         if( -9899 <= code && code <= -9800 ) {

             NSMutableDictionary *userInfo = error.userInfo.mutableCopy;

             if( ! [userInfo objectForKey: NSLocalizedFailureReasonErrorKey] ) {

                 // look up error message:

                 NSBundle *secBundle = [NSBundle bundleWithPath: @"/System/Library/Frameworks/Security.framework"];

                 NSString *message = [secBundle localizedStringForKey: $sprintf(@"%i",code)

                                                                value: nil

                                                                table: @"SecErrorMessages"];

                 if( message ) {

                     if( ! userInfo ) userInfo = $mdict();

                     [userInfo setObject: message forKey: NSLocalizedFailureReasonErrorKey];

                 }

             }

             error = [NSError errorWithDomain: NSStreamSocketSSLErrorDomain

                                         code: code userInfo: userInfo];

         } else

             Warn(@"NSStream returned error with unknown domain: %@",error);

     }

     return error;

 }

 /*

  Copyright (c) 2008, Jens Alfke <jens@mooseyard.com>. All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, are permitted

  provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list of conditions

  and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions

  and the following disclaimer in the documentation and/or other materials provided with the

  distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR

  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 

  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRI-

  BUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 

   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 

  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  */