TCP/TCPConnection.m
author Jens Alfke <jens@mooseyard.com>
Wed Jun 11 14:58:38 2008 -0700 (2008-06-11)
changeset 16 6f608b552b77
parent 15 f723174fbc24
child 17 70590cc555aa
permissions -rw-r--r--
* Added a timeout property to TCPConnection. Set it before calling -open, if you want a shorter timeout than the default.
* Made the utility function BLIPMakeError public.
jens@0
     1
//
jens@0
     2
//  TCPConnection.m
jens@0
     3
//  MYNetwork
jens@0
     4
//
jens@0
     5
//  Created by Jens Alfke on 5/18/08.
jens@0
     6
//  Copyright 2008 Jens Alfke. All rights reserved.
jens@0
     7
//
jens@0
     8
jens@0
     9
#import "TCP_Internal.h"
jens@0
    10
#import "IPAddress.h"
jens@0
    11
jens@1
    12
#import "Logging.h"
jens@1
    13
#import "Test.h"
jens@0
    14
#import "ExceptionUtils.h"
jens@0
    15
jens@0
    16
jens@8
    17
#if TARGET_OS_IPHONE
jens@8
    18
// SecureTransport.h is missing on iPhone, with its SSL constants:
jens@8
    19
enum{
jens@8
    20
    errSSLClosedAbort 			= -9806,	/* connection closed via error */
jens@8
    21
};
jens@8
    22
#endif
jens@8
    23
jens@8
    24
jens@8
    25
jens@0
    26
NSString* const TCPErrorDomain = @"TCP";
jens@0
    27
jens@0
    28
jens@0
    29
@interface TCPConnection ()
jens@0
    30
@property TCPConnectionStatus status;
jens@7
    31
@property (retain) IPAddress *address;
jens@0
    32
- (BOOL) _checkIfClosed;
jens@0
    33
- (void) _closed;
jens@0
    34
@end
jens@0
    35
jens@0
    36
jens@0
    37
@implementation TCPConnection
jens@0
    38
jens@0
    39
jens@0
    40
static NSMutableArray *sAllConnections;
jens@0
    41
jens@0
    42
jens@0
    43
- (Class) readerClass   {return [TCPReader class];}
jens@0
    44
- (Class) writerClass   {return [TCPWriter class];}
jens@0
    45
jens@0
    46
jens@0
    47
- (id) _initWithAddress: (IPAddress*)address
jens@0
    48
            inputStream: (NSInputStream*)input
jens@0
    49
           outputStream: (NSOutputStream*)output
jens@0
    50
{
jens@0
    51
    self = [super init];
jens@0
    52
    if (self != nil) {
jens@7
    53
        if( !input || !output ) {
jens@0
    54
            LogTo(TCP,@"Failed to create %@: addr=%@, in=%@, out=%@",
jens@0
    55
                  self.class,address,input,output);
jens@0
    56
            [self release];
jens@0
    57
            return nil;
jens@0
    58
        }
jens@0
    59
        _address = [address copy];
jens@0
    60
        _reader = [[[self readerClass] alloc] initWithConnection: self stream: input];
jens@0
    61
        _writer = [[[self writerClass] alloc] initWithConnection: self stream: output];
jens@7
    62
        LogTo(TCP,@"%@ initialized, address=%@",self,address);
jens@0
    63
    }
jens@0
    64
    return self;
jens@0
    65
}
jens@0
    66
jens@0
    67
jens@0
    68
jens@0
    69
- (id) initToAddress: (IPAddress*)address
jens@0
    70
{
jens@0
    71
    NSInputStream *input = nil;
jens@0
    72
    NSOutputStream *output = nil;
jens@8
    73
#if TARGET_OS_IPHONE
jens@8
    74
    // +getStreamsToHost: is missing for some stupid reason on iPhone. Grrrrrrrrrr.
jens@8
    75
    CFStreamCreatePairWithSocketToHost(NULL, (CFStringRef)address.hostname, address.port,
jens@8
    76
                                       (CFReadStreamRef*)&input, (CFWriteStreamRef*)&output);
jens@8
    77
    if( input )
jens@8
    78
        [(id)CFMakeCollectable(input) autorelease];
jens@8
    79
    if( output )
jens@8
    80
        [(id)CFMakeCollectable(output) autorelease];
jens@8
    81
#else
jens@0
    82
    [NSStream getStreamsToHost: [NSHost hostWithAddress: address.ipv4name]
jens@0
    83
                          port: address.port 
jens@0
    84
                   inputStream: &input 
jens@0
    85
                  outputStream: &output];
jens@8
    86
#endif
jens@0
    87
    return [self _initWithAddress: address inputStream: input outputStream: output];
jens@0
    88
}
jens@0
    89
jens@7
    90
- (id) initToNetService: (NSNetService*)service
jens@7
    91
{
jens@7
    92
    IPAddress *address = nil;
jens@7
    93
    NSInputStream *input;
jens@7
    94
    NSOutputStream *output;
jens@7
    95
    if( [service getInputStream: &input outputStream: &output] ) {
jens@7
    96
        NSArray *addresses = service.addresses;
jens@7
    97
        if( addresses.count > 0 )
jens@7
    98
            address = [[[IPAddress alloc] initWithSockAddr: [[addresses objectAtIndex: 0] bytes]] autorelease];
jens@7
    99
    } else {
jens@7
   100
        input = nil;
jens@7
   101
        output = nil;
jens@7
   102
    }
jens@7
   103
    return [self _initWithAddress: address inputStream: input outputStream: output];
jens@7
   104
}
jens@7
   105
jens@0
   106
jens@0
   107
- (id) initIncomingFromSocket: (CFSocketNativeHandle)socket
jens@0
   108
                     listener: (TCPListener*)listener
jens@0
   109
{
jens@0
   110
    CFReadStreamRef readStream = NULL;
jens@0
   111
    CFWriteStreamRef writeStream = NULL;
jens@0
   112
    CFStreamCreatePairWithSocket(kCFAllocatorDefault, socket, &readStream, &writeStream);
jens@0
   113
    self = [self _initWithAddress: [IPAddress addressOfSocket: socket] 
jens@0
   114
                      inputStream: (NSInputStream*)readStream
jens@0
   115
                     outputStream: (NSOutputStream*)writeStream];
jens@0
   116
    if( self ) {
jens@0
   117
        _isIncoming = YES;
jens@0
   118
        _server = [listener retain];
jens@0
   119
        CFReadStreamSetProperty(readStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
jens@0
   120
        CFWriteStreamSetProperty(writeStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
jens@0
   121
    }
jens@0
   122
    return self;
jens@0
   123
}    
jens@0
   124
jens@0
   125
jens@0
   126
- (void) dealloc
jens@0
   127
{
jens@0
   128
    LogTo(TCP,@"DEALLOC %@",self);
jens@0
   129
    [_reader release];
jens@0
   130
    [_writer release];
jens@0
   131
    [_address release];
jens@0
   132
    [super dealloc];
jens@0
   133
}
jens@0
   134
jens@0
   135
jens@0
   136
- (NSString*) description
jens@0
   137
{
jens@0
   138
    return $sprintf(@"%@[%@ %@]",self.class,(_isIncoming ?@"from" :@"to"),_address);
jens@0
   139
}
jens@0
   140
jens@0
   141
jens@0
   142
@synthesize address=_address, isIncoming=_isIncoming, status=_status, delegate=_delegate,
jens@16
   143
            reader=_reader, writer=_writer, server=_server, openTimeout=_openTimeout;
jens@0
   144
jens@0
   145
jens@0
   146
- (NSError*) error
jens@0
   147
{
jens@0
   148
    return _error;
jens@0
   149
}
jens@0
   150
jens@0
   151
jens@0
   152
- (NSString*) actualSecurityLevel
jens@0
   153
{
jens@0
   154
    return _reader.securityLevel;
jens@0
   155
jens@0
   156
}
jens@0
   157
jens@0
   158
- (NSArray*) peerSSLCerts
jens@0
   159
{
jens@0
   160
    return _reader.peerSSLCerts ?: _writer.peerSSLCerts;
jens@0
   161
}
jens@0
   162
jens@0
   163
jens@0
   164
- (void) _setStreamProperty: (id)value forKey: (NSString*)key
jens@0
   165
{
jens@0
   166
    [_reader setProperty: value forKey: (CFStringRef)key];
jens@0
   167
    [_writer setProperty: value forKey: (CFStringRef)key];
jens@0
   168
}
jens@0
   169
jens@0
   170
jens@0
   171
#pragma mark -
jens@0
   172
#pragma mark OPENING / CLOSING:
jens@0
   173
jens@0
   174
jens@0
   175
- (void) open
jens@0
   176
{
jens@0
   177
    if( _status<=kTCP_Closed && _reader ) {
jens@0
   178
        _reader.SSLProperties = _sslProperties;
jens@0
   179
        _writer.SSLProperties = _sslProperties;
jens@0
   180
        [_reader open];
jens@0
   181
        [_writer open];
jens@0
   182
        if( ! [sAllConnections my_containsObjectIdenticalTo: self] )
jens@0
   183
            [sAllConnections addObject: self];
jens@0
   184
        self.status = kTCP_Opening;
jens@16
   185
        if( _openTimeout > 0 )
jens@16
   186
            [self performSelector: @selector(_openTimeoutExpired) withObject: nil afterDelay: _openTimeout];
jens@16
   187
    }
jens@16
   188
}
jens@16
   189
jens@16
   190
- (void) _stopOpenTimer
jens@16
   191
{
jens@16
   192
    [NSObject cancelPreviousPerformRequestsWithTarget: self selector: @selector(_openTimeoutExpired) object: nil];
jens@16
   193
}
jens@16
   194
jens@16
   195
- (void) _openTimeoutExpired
jens@16
   196
{
jens@16
   197
    if( _status == kTCP_Opening ) {
jens@16
   198
        LogTo(TCP,@"%@: timed out waiting to open",self);
jens@16
   199
        [self _stream: _reader gotError: [NSError errorWithDomain: NSPOSIXErrorDomain
jens@16
   200
                                                             code: ETIMEDOUT userInfo: nil]];
jens@0
   201
    }
jens@0
   202
}
jens@0
   203
jens@0
   204
jens@0
   205
- (void) disconnect
jens@0
   206
{
jens@0
   207
    if( _status > kTCP_Closed ) {
jens@0
   208
        LogTo(TCP,@"%@ disconnecting",self);
jens@0
   209
        [_writer disconnect];
jens@0
   210
        setObj(&_writer,nil);
jens@0
   211
        [_reader disconnect];
jens@0
   212
        setObj(&_reader,nil);
jens@0
   213
        self.status = kTCP_Disconnected;
jens@0
   214
    }
jens@16
   215
    [self _stopOpenTimer];
jens@0
   216
}
jens@0
   217
jens@0
   218
jens@0
   219
- (void) close
jens@0
   220
{
jens@0
   221
    [self closeWithTimeout: 60.0];
jens@0
   222
}
jens@0
   223
jens@0
   224
- (void) closeWithTimeout: (NSTimeInterval)timeout
jens@0
   225
{
jens@16
   226
    [self _stopOpenTimer];
jens@0
   227
    if( _status == kTCP_Opening ) {
jens@0
   228
        LogTo(TCP,@"%@ canceling open",self);
jens@0
   229
        [self _closed];
jens@0
   230
    } else if( _status == kTCP_Open ) {
jens@0
   231
        LogTo(TCP,@"%@ closing",self);
jens@0
   232
        self.status = kTCP_Closing;
jens@0
   233
        [self retain];
jens@0
   234
        [_reader close];
jens@0
   235
        [_writer close];
jens@0
   236
        if( ! [self _checkIfClosed] ) {
jens@0
   237
            if( timeout <= 0.0 )
jens@0
   238
                [self disconnect];
jens@0
   239
            else if( timeout != INFINITY )
jens@0
   240
                [self performSelector: @selector(_closeTimeoutExpired)
jens@0
   241
                           withObject: nil afterDelay: timeout];
jens@0
   242
        }
jens@0
   243
        [self release];
jens@0
   244
    }
jens@0
   245
}
jens@0
   246
jens@0
   247
- (void) _closeTimeoutExpired
jens@0
   248
{
jens@0
   249
    if( _status==kTCP_Closing )
jens@0
   250
        [self disconnect];
jens@0
   251
}
jens@0
   252
jens@0
   253
jens@0
   254
- (BOOL) _checkIfClosed
jens@0
   255
{
jens@0
   256
    if( _status == kTCP_Closing && _writer==nil && _reader==nil ) {
jens@0
   257
        [self _closed];
jens@0
   258
        return YES;
jens@0
   259
    } else
jens@0
   260
        return NO;
jens@0
   261
}
jens@0
   262
jens@0
   263
jens@0
   264
// called by my streams when they close (after my -close is called)
jens@0
   265
- (void) _closed
jens@0
   266
{
jens@0
   267
    if( _status != kTCP_Closed && _status != kTCP_Disconnected ) {
jens@0
   268
        LogTo(TCP,@"%@ is now closed",self);
jens@15
   269
        TCPConnectionStatus prevStatus = _status;
jens@15
   270
        self.status = (prevStatus==kTCP_Closing ?kTCP_Closed :kTCP_Disconnected);
jens@15
   271
        if( prevStatus==kTCP_Opening )
jens@15
   272
            [self tellDelegate: @selector(connection:failedToOpen:) withObject: self.error];
jens@15
   273
        else
jens@15
   274
            [self tellDelegate: @selector(connectionDidClose:) withObject: nil];
jens@0
   275
    }
jens@0
   276
    [NSObject cancelPreviousPerformRequestsWithTarget: self
jens@0
   277
                                             selector: @selector(_closeTimeoutExpired)
jens@0
   278
                                               object: nil];
jens@16
   279
    [self _stopOpenTimer];
jens@0
   280
    [sAllConnections removeObjectIdenticalTo: self];
jens@0
   281
}
jens@0
   282
jens@0
   283
jens@0
   284
+ (void) closeAllWithTimeout: (NSTimeInterval)timeout
jens@0
   285
{
jens@0
   286
    NSArray *connections = [sAllConnections copy];
jens@0
   287
    for( TCPConnection *conn in connections )
jens@0
   288
        [conn closeWithTimeout: timeout];
jens@0
   289
    [connections release];
jens@0
   290
}
jens@0
   291
jens@0
   292
+ (void) waitTillAllClosed
jens@0
   293
{
jens@0
   294
    while( sAllConnections.count ) {
jens@0
   295
        if( ! [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode
jens@0
   296
                                       beforeDate: [NSDate distantFuture]] )
jens@0
   297
            break;
jens@0
   298
    }
jens@0
   299
}
jens@0
   300
jens@0
   301
jens@0
   302
#pragma mark -
jens@0
   303
#pragma mark STREAM CALLBACKS:
jens@0
   304
jens@0
   305
jens@0
   306
- (void) _streamOpened: (TCPStream*)stream
jens@0
   307
{
jens@7
   308
    if( ! _address )
jens@7
   309
        self.address = stream.peerAddress;
jens@0
   310
    if( _status==kTCP_Opening && _reader.isOpen && _writer.isOpen ) {
jens@7
   311
        LogTo(TCP,@"%@ opened; address=%@",self,_address);
jens@16
   312
        [self _stopOpenTimer];
jens@0
   313
        self.status = kTCP_Open;
jens@0
   314
        [self tellDelegate: @selector(connectionDidOpen:) withObject: nil];
jens@0
   315
    }
jens@0
   316
}
jens@0
   317
jens@0
   318
jens@0
   319
- (BOOL) _streamPeerCertAvailable: (TCPStream*)stream
jens@0
   320
{
jens@0
   321
    BOOL allow = YES;
jens@0
   322
    if( ! _checkedPeerCert ) {
jens@0
   323
        @try{
jens@0
   324
            _checkedPeerCert = YES;
jens@0
   325
            if( stream.securityLevel != nil ) {
jens@0
   326
                NSArray *certs = stream.peerSSLCerts;
jens@0
   327
                if( ! certs && ! _isIncoming )
jens@0
   328
                    allow = NO; // Server MUST have a cert!
jens@0
   329
                else {
jens@0
   330
                    SecCertificateRef cert = certs.count ?(SecCertificateRef)[certs objectAtIndex:0] :NULL;
jens@0
   331
                    LogTo(TCP,@"%@: Peer cert = %@",self,cert);
jens@0
   332
                    if( [_delegate respondsToSelector: @selector(connection:authorizeSSLPeer:)] )
jens@0
   333
                        allow = [_delegate connection: self authorizeSSLPeer: cert];
jens@0
   334
                }
jens@0
   335
            }
jens@0
   336
        }@catch( NSException *x ) {
jens@0
   337
            MYReportException(x,@"TCPConnection _streamPeerCertAvailable");
jens@0
   338
            _checkedPeerCert = NO;
jens@0
   339
            allow = NO;
jens@0
   340
        }
jens@0
   341
        if( ! allow )
jens@0
   342
            [self _stream: stream 
jens@0
   343
                 gotError: [NSError errorWithDomain: NSStreamSocketSSLErrorDomain
jens@0
   344
                                               code: errSSLClosedAbort
jens@0
   345
                                           userInfo: nil]];
jens@0
   346
    }
jens@0
   347
    return allow;
jens@0
   348
}
jens@0
   349
jens@0
   350
jens@0
   351
- (void) _stream: (TCPStream*)stream gotError: (NSError*)error
jens@0
   352
{
jens@0
   353
    LogTo(TCP,@"%@ got %@ on %@",self,error,stream.class);
jens@0
   354
    Assert(error);
jens@0
   355
    setObj(&_error,error);
jens@0
   356
    [_reader disconnect];
jens@0
   357
    setObj(&_reader,nil);
jens@0
   358
    [_writer disconnect];
jens@0
   359
    setObj(&_writer,nil);
jens@0
   360
    [self _closed];
jens@0
   361
}
jens@0
   362
jens@0
   363
- (void) _streamGotEOF: (TCPStream*)stream
jens@0
   364
{
jens@0
   365
    LogTo(TCP,@"%@ got EOF on %@",self,stream);
jens@0
   366
    if( stream == _reader ) {
jens@0
   367
        setObj(&_reader,nil);
jens@0
   368
        // This is the expected way for he peer to initiate closing the connection.
jens@0
   369
        if( _status==kTCP_Open ) {
jens@0
   370
            [self closeWithTimeout: INFINITY];
jens@0
   371
            return;
jens@0
   372
        }
jens@0
   373
    } else if( stream == _writer ) {
jens@0
   374
        setObj(&_writer,nil);
jens@0
   375
    }
jens@0
   376
    
jens@0
   377
    if( _status == kTCP_Closing ) {
jens@0
   378
        [self _checkIfClosed];
jens@0
   379
    } else {
jens@0
   380
        [self _stream: stream 
jens@0
   381
             gotError: [NSError errorWithDomain: NSPOSIXErrorDomain code: ECONNRESET userInfo: nil]];
jens@0
   382
    }
jens@0
   383
}
jens@0
   384
jens@0
   385
jens@0
   386
// Called after I called -close on a stream and it finished closing:
jens@0
   387
- (void) _streamClosed: (TCPStream*)stream
jens@0
   388
{
jens@0
   389
    LogTo(TCP,@"%@ finished closing %@",self,stream);
jens@0
   390
    if( stream == _reader )
jens@0
   391
        setObj(&_reader,nil);
jens@0
   392
    else if( stream == _writer )
jens@0
   393
        setObj(&_writer,nil);
jens@0
   394
    if( !_reader.isOpen && !_writer.isOpen )
jens@0
   395
        [self _closed];
jens@0
   396
}
jens@0
   397
jens@0
   398
jens@0
   399
@end
jens@0
   400
jens@0
   401
jens@0
   402
/*
jens@0
   403
 Copyright (c) 2008, Jens Alfke <jens@mooseyard.com>. All rights reserved.
jens@0
   404
 
jens@0
   405
 Redistribution and use in source and binary forms, with or without modification, are permitted
jens@0
   406
 provided that the following conditions are met:
jens@0
   407
 
jens@0
   408
 * Redistributions of source code must retain the above copyright notice, this list of conditions
jens@0
   409
 and the following disclaimer.
jens@0
   410
 * Redistributions in binary form must reproduce the above copyright notice, this list of conditions
jens@0
   411
 and the following disclaimer in the documentation and/or other materials provided with the
jens@0
   412
 distribution.
jens@0
   413
 
jens@0
   414
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
jens@0
   415
 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
jens@0
   416
 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRI-
jens@0
   417
 BUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
jens@0
   418
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
jens@0
   419
  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
jens@0
   420
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
jens@0
   421
 THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
jens@0
   422
 */