/*

    File:       UDPEcho.m

    Contains:   A class that implements a UDP echo protocol client and server.

    Written by: DTS

    Copyright:  Copyright (c) 2010-12 Apple Inc. All Rights Reserved.

    Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Inc.

                ("Apple") in consideration of your agreement to the following

                terms, and your use, installation, modification or

                redistribution of this Apple software constitutes acceptance of

                these terms.  If you do not agree with these terms, please do

                not use, install, modify or redistribute this Apple software.

                In consideration of your agreement to abide by the following

                terms, and subject to these terms, Apple grants you a personal,

                non-exclusive license, under Apple's copyrights in this

                original Apple software (the "Apple Software"), to use,

                reproduce, modify and redistribute the Apple Software, with or

                without modifications, in source and/or binary forms; provided

                that if you redistribute the Apple Software in its entirety and

                without modifications, you must retain this notice and the

                following text and disclaimers in all such redistributions of

                the Apple Software. Neither the name, trademarks, service marks

                or logos of Apple Inc. may be used to endorse or promote

                products derived from the Apple Software without specific prior

                written permission from Apple.  Except as expressly stated in

                this notice, no other rights or licenses, express or implied,

                are granted by Apple herein, including but not limited to any

                patent rights that may be infringed by your derivative works or

                by other works in which the Apple Software may be incorporated.

                The Apple Software is provided by Apple on an "AS IS" basis. 

                APPLE MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING

                WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT,

                MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING

                THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN

                COMBINATION WITH YOUR PRODUCTS.

                IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT,

                INCIDENTAL OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

                TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

                DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY

                OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION

                OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY

                OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR

                OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF

                SUCH DAMAGE.

*/

#if ! defined(UDPECHO_IPV4_ONLY)

    #define UDPECHO_IPV4_ONLY 0

#endif

#import "UDPEcho.h"

#include <sys/socket.h>

#include <netinet/in.h>

#include <fcntl.h>

#include <unistd.h>

@interface UDPEcho ()

// redeclare as readwrite for private use

@property (nonatomic, copy,   readwrite) NSString *             hostName;

@property (nonatomic, copy,   readwrite) NSData *               hostAddress;

@property (nonatomic, assign, readwrite) NSUInteger             port;

// forward declarations

- (void)stopHostResolution;

- (void)stopWithError:(NSError *)error;

- (void)stopWithStreamError:(CFStreamError)streamError;

@end

@implementation UDPEcho

{

    CFHostRef               _cfHost;

    CFSocketRef             _cfSocket;

}

@synthesize delegate    = _delegate;

@synthesize hostName    = _hostName;

@synthesize hostAddress = _hostAddress;

@synthesize port        = _port;

- (id)init

{

    self = [super init];

    if (self != nil) {

        // do nothing

    }

    return self;

}

- (void)dealloc

{

    [self stop];

}

- (BOOL)isServer

{

    return self.hostName == nil;

}

- (void)sendData:(NSData *)data toAddress:(NSData *)addr

    // Called by both -sendData: and the server echoing code to send data 

    // via the socket.  addr is nil in the client case, whereupon the 

    // data is automatically sent to the hostAddress by virtue of the fact 

    // that the socket is connected to that address.

{

    int                     err;

    int                     sock;

    ssize_t                 bytesWritten;

    const struct sockaddr * addrPtr;

    socklen_t               addrLen;

    assert(data != nil);

    assert( (addr != nil) == self.isServer );

    assert( (addr == nil) || ([addr length] <= sizeof(struct sockaddr_storage)) );

    sock = CFSocketGetNative(self->_cfSocket);

    assert(sock >= 0);

    if (addr == nil) {

        addr = self.hostAddress;

        assert(addr != nil);

        addrPtr = NULL;

        addrLen = 0;

    } else {

        addrPtr = [addr bytes];

        addrLen = (socklen_t) [addr length];

    }

    bytesWritten = sendto(sock, [data bytes], [data length], 0, addrPtr, addrLen);

    if (bytesWritten < 0) {

        err = errno;

    } else  if (bytesWritten == 0) {

        err = EPIPE;                    

    } else {

        // We ignore any short writes, which shouldn't happen for UDP anyway.

        assert( (NSUInteger) bytesWritten == [data length] );

        err = 0;

    }

    if (err == 0) {

        if ( (self.delegate != nil) && [self.delegate respondsToSelector:@selector(echo:didSendData:toAddress:)] ) {

            [self.delegate echo:self didSendData:data toAddress:addr];

        }

    } else {

        if ( (self.delegate != nil) && [self.delegate respondsToSelector:@selector(echo:didFailToSendData:toAddress:error:)] ) {

            [self.delegate echo:self didFailToSendData:data toAddress:addr error:[NSError errorWithDomain:NSPOSIXErrorDomain code:err userInfo:nil]];

        }

    }

}

- (void)readData

    // Called by the CFSocket read callback to actually read and process data 

    // from the socket.

{

    int                     err;

    int                     sock;

    struct sockaddr_storage addr;

    socklen_t               addrLen;

    uint8_t                 buffer[65536];

    ssize_t                 bytesRead;

    sock = CFSocketGetNative(self->_cfSocket);

    assert(sock >= 0);

    addrLen = sizeof(addr);

    bytesRead = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr *) &addr, &addrLen);

    if (bytesRead < 0) {

        err = errno;

    } else if (bytesRead == 0) {

        err = EPIPE;

    } else {

        NSData *    dataObj;

        NSData *    addrObj;

        err = 0;

        dataObj = [NSData dataWithBytes:buffer length:(NSUInteger) bytesRead];

        assert(dataObj != nil);

        addrObj = [NSData dataWithBytes:&addr  length:addrLen  ];

        assert(addrObj != nil);

        // Tell the delegate about the data.

        if ( (self.delegate != nil) && [self.delegate respondsToSelector:@selector(echo:didReceiveData:fromAddress:)] ) {

            [self.delegate echo:self didReceiveData:dataObj fromAddress:addrObj];

        }

        // Echo the data back to the sender.

        if (self.isServer) {

            [self sendData:dataObj toAddress:addrObj];

        }

    }

    // If we got an error, tell the delegate.

    if (err != 0) {

        if ( (self.delegate != nil) && [self.delegate respondsToSelector:@selector(echo:didReceiveError:)] ) {

            [self.delegate echo:self didReceiveError:[NSError errorWithDomain:NSPOSIXErrorDomain code:err userInfo:nil]];

        }

    }

}

static void SocketReadCallback(CFSocketRef s, CFSocketCallBackType type, CFDataRef address, const void *data, void *info)

    // This C routine is called by CFSocket when there's data waiting on our 

    // UDP socket.  It just redirects the call to Objective-C code.

{

    UDPEcho *       obj;

    obj = (__bridge UDPEcho *) info;

    assert([obj isKindOfClass:[UDPEcho class]]);

    #pragma unused(s)

    assert(s == obj->_cfSocket);

    #pragma unused(type)

    assert(type == kCFSocketReadCallBack);

    #pragma unused(address)

    assert(address == nil);

    #pragma unused(data)

    assert(data == nil);

    [obj readData];

}

#if UDPECHO_IPV4_ONLY

    - (BOOL)setupSocketConnectedToAddress:(NSData *)address port:(NSUInteger)port error:(NSError **)errorPtr

        // Sets up the CFSocket in either client or server mode.  In client mode, 

        // address contains the address that the socket should be connected to. 

        // The address contains zero port number, so the port parameter is used instead. 

        // In server mode, address is nil and the socket is bound to the wildcard 

        // address on the specified port.

    {

        int                     err;

        int                     junk;

        int                     sock;

        const CFSocketContext   context = { 0, (__bridge void *)(self), NULL, NULL, NULL };

        CFRunLoopSourceRef      rls;

        assert( (address == nil) == self.isServer );

        assert( (address == nil) || ([address length] <= sizeof(struct sockaddr_storage)) );

        assert(port < 65536);

        assert(self->_cfSocket == NULL);

        // Create the UDP socket itself.

        err = 0;

        sock = socket(AF_INET, SOCK_DGRAM, 0);

        if (sock < 0) {

            err = errno;

        }

        // Bind or connect the socket, depending on whether we're in server or client mode.

        if (err == 0) {

            struct sockaddr_in      addr;

            memset(&addr, 0, sizeof(addr));

            if (address == nil) {

                // Server mode.  Set up the address based on the socket family of the socket 

                // that we created, with the wildcard address and the caller-supplied port number.

                addr.sin_len         = sizeof(addr);

                addr.sin_family      = AF_INET;

                addr.sin_port        = htons(port);

                addr.sin_addr.s_addr = INADDR_ANY;

                err = bind(sock, (const struct sockaddr *) &addr, sizeof(addr));

            } else {

                // Client mode.  Set up the address on the caller-supplied address and port 

                // number.

                if ([address length] > sizeof(addr)) {

                    assert(NO);         // very weird

                    [address getBytes:&addr length:sizeof(addr)];

                } else {

                    [address getBytes:&addr length:[address length]];

                }

                assert(addr.sin_family == AF_INET);

                addr.sin_port = htons(port);

                err = connect(sock, (const struct sockaddr *) &addr, sizeof(addr));

            }

            if (err < 0) {

                err = errno;

            }

        }

        // From now on we want the socket in non-blocking mode to prevent any unexpected 

        // blocking of the main thread.  None of the above should block for any meaningful 

        // amount of time.

        if (err == 0) {

            int flags;

            flags = fcntl(sock, F_GETFL);

            err = fcntl(sock, F_SETFL, flags | O_NONBLOCK);

            if (err < 0) {

                err = errno;

            }

        }

        // Wrap the socket in a CFSocket that's scheduled on the runloop.

        if (err == 0) {

            self->_cfSocket = CFSocketCreateWithNative(NULL, sock, kCFSocketReadCallBack, SocketReadCallback, &context);

            // The socket will now take care of cleaning up our file descriptor.

            assert( CFSocketGetSocketFlags(self->_cfSocket) & kCFSocketCloseOnInvalidate );

            sock = -1;

            rls = CFSocketCreateRunLoopSource(NULL, self->_cfSocket, 0);

            assert(rls != NULL);

            CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);

            CFRelease(rls);

        }

        // Handle any errors.

        if (sock != -1) {

            junk = close(sock);

            assert(junk == 0);

        }

        assert( (err == 0) == (self->_cfSocket != NULL) );

        if ( (self->_cfSocket == NULL) && (errorPtr != NULL) ) {

            *errorPtr = [NSError errorWithDomain:NSPOSIXErrorDomain code:err userInfo:nil];

        }

        return (err == 0);

    }

#else   // ! UDPECHO_IPV4_ONLY

    - (BOOL)setupSocketConnectedToAddress:(NSData *)address port:(NSUInteger)port error:(NSError **)errorPtr

        // Sets up the CFSocket in either client or server mode.  In client mode, 

        // address contains the address that the socket should be connected to. 

        // The address contains zero port number, so the port parameter is used instead. 

        // In server mode, address is nil and the socket is bound to the wildcard 

        // address on the specified port.

    {

        sa_family_t             socketFamily;

        int                     err;

        int                     junk;

        int                     sock;

        const CFSocketContext   context = { 0, (__bridge void *) (self), NULL, NULL, NULL };

        CFRunLoopSourceRef      rls;

        assert( (address == nil) == self.isServer );

        assert( (address == nil) || ([address length] <= sizeof(struct sockaddr_storage)) );

        assert(port < 65536);

        assert(self->_cfSocket == NULL);

        // Create the UDP socket itself.  First try IPv6 and, if that's not available, revert to IPv6. 

        //

        // IMPORTANT: Even though we're using IPv6 by default, we can still work with IPv4 due to the 

        // miracle of IPv4-mapped addresses.

        err = 0;

        sock = socket(AF_INET6, SOCK_DGRAM, 0);

        if (sock >= 0) {

            socketFamily = AF_INET6;

        } else {

            sock = socket(AF_INET, SOCK_DGRAM, 0);

            if (sock >= 0) {

                socketFamily = AF_INET;

            } else {

                err = errno;

                socketFamily = 0;       // quietens a warning from the compiler

                assert(err != 0);       // Obvious, but it quietens a warning from the static analyser.

            }

        }

        // Bind or connect the socket, depending on whether we're in server or client mode.

        if (err == 0) {

            struct sockaddr_storage addr;

            struct sockaddr_in *    addr4;

            struct sockaddr_in6 *   addr6;

            addr4 = (struct sockaddr_in * ) &addr;

            addr6 = (struct sockaddr_in6 *) &addr;

            memset(&addr, 0, sizeof(addr));

            if (address == nil) {

                // Server mode.  Set up the address based on the socket family of the socket 

                // that we created, with the wildcard address and the caller-supplied port number.

                addr.ss_family = socketFamily;

                if (socketFamily == AF_INET) {

                    addr4->sin_len         = sizeof(*addr4);

                    addr4->sin_port        = htons(port);

                    addr4->sin_addr.s_addr = INADDR_ANY;

                } else {

                    assert(socketFamily == AF_INET6);

                    addr6->sin6_len         = sizeof(*addr6);

                    addr6->sin6_port        = htons(port);

                    addr6->sin6_addr        = in6addr_any;

                }

            } else {

                // Client mode.  Set up the address on the caller-supplied address and port 

                // number.  Also, if the address is IPv4 and we created an IPv6 socket, 

                // convert the address to an IPv4-mapped address.

                if ([address length] > sizeof(addr)) {

                    assert(NO);         // very weird

                    [address getBytes:&addr length:sizeof(addr)];

                } else {

                    [address getBytes:&addr length:[address length]];

                }

                if (addr.ss_family == AF_INET) {

                    if (socketFamily == AF_INET6) {

                        struct  in_addr ipv4Addr;

                        // Convert IPv4 address to IPv4-mapped-into-IPv6 address.

                        ipv4Addr = addr4->sin_addr;

                        addr6->sin6_len         = sizeof(*addr6);

                        addr6->sin6_family      = AF_INET6;

                        addr6->sin6_port        = htons(port);

                        addr6->sin6_addr.__u6_addr.__u6_addr32[0] = 0;

                        addr6->sin6_addr.__u6_addr.__u6_addr32[1] = 0;

                        addr6->sin6_addr.__u6_addr.__u6_addr16[4] = 0;

                        addr6->sin6_addr.__u6_addr.__u6_addr16[5] = 0xffff;

                        addr6->sin6_addr.__u6_addr.__u6_addr32[3] = ipv4Addr.s_addr;

                    } else {

                        addr4->sin_port = htons(port);

                    }

                } else {

                    assert(addr.ss_family == AF_INET6);

                    addr6->sin6_port        = htons(port);

                }

                if ( (addr.ss_family == AF_INET) && (socketFamily == AF_INET6) ) {

                    addr6->sin6_len         = sizeof(*addr6);

                    addr6->sin6_port        = htons(port);

                    addr6->sin6_addr        = in6addr_any;

                }

            }

            if (address == nil) {

                err = bind(sock, (const struct sockaddr *) &addr, addr.ss_len);

            } else {

                err = connect(sock, (const struct sockaddr *) &addr, addr.ss_len);

            }

            if (err < 0) {

                err = errno;

            }

        }

        // From now on we want the socket in non-blocking mode to prevent any unexpected 

        // blocking of the main thread.  None of the above should block for any meaningful 

        // amount of time.

        if (err == 0) {

            int flags;

            flags = fcntl(sock, F_GETFL);

            err = fcntl(sock, F_SETFL, flags | O_NONBLOCK);

            if (err < 0) {

                err = errno;

            }

        }

        // Wrap the socket in a CFSocket that's scheduled on the runloop.

        if (err == 0) {

            self->_cfSocket = CFSocketCreateWithNative(NULL, sock, kCFSocketReadCallBack, SocketReadCallback, &context);

            // The socket will now take care of cleaning up our file descriptor.

            assert( CFSocketGetSocketFlags(self->_cfSocket) & kCFSocketCloseOnInvalidate );

            sock = -1;

            rls = CFSocketCreateRunLoopSource(NULL, self->_cfSocket, 0);

            assert(rls != NULL);

            CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);

            CFRelease(rls);

        }

        // Handle any errors.

        if (sock != -1) {

            junk = close(sock);

            assert(junk == 0);

        }

        assert( (err == 0) == (self->_cfSocket != NULL) );

        if ( (self->_cfSocket == NULL) && (errorPtr != NULL) ) {

            *errorPtr = [NSError errorWithDomain:NSPOSIXErrorDomain code:err userInfo:nil];

        }

        return (err == 0);

    }

#endif  // ! UDPECHO_IPV4_ONLY

- (void)startServerOnPort:(NSUInteger)port

    // See comment in header.

{

    assert( (port > 0) && (port < 65536) );

    assert(self.port == 0);     // don't try and start a started object

    if (self.port == 0) {

        BOOL        success;

        NSError *   error;

        // Create a fully configured socket.

        success = [self setupSocketConnectedToAddress:nil port:port error:&error];

        // If we can create the socket, we're good to go.  Otherwise, we report an error 

        // to the delegate.

        if (success) {

            self.port = port;

            if ( (self.delegate != nil) && [self.delegate respondsToSelector:@selector(echo:didStartWithAddress:)] ) {

                CFDataRef   localAddress;

                localAddress = CFSocketCopyAddress(self->_cfSocket);

                assert(localAddress != NULL);

                [self.delegate echo:self didStartWithAddress:(__bridge NSData *) localAddress];

                CFRelease(localAddress);

            }

        } else {

            [self stopWithError:error];

        }

    }

}

- (void)hostResolutionDone

    // Called by our CFHost resolution callback (HostResolveCallback) when host 

    // resolution is complete.  We find the best IP address and create a socket 

    // connected to that.

{

    NSError *           error;

    Boolean             resolved;

    NSArray *           resolvedAddresses;

    assert(self.port != 0);

    assert(self->_cfHost != NULL);

    assert(self->_cfSocket == NULL);

    assert(self.hostAddress == nil);

    error = nil;

    // Walk through the resolved addresses looking for one that we can work with.

    resolvedAddresses = (__bridge NSArray *) CFHostGetAddressing(self->_cfHost, &resolved);

    if ( resolved && (resolvedAddresses != nil) ) {

        for (NSData * address in resolvedAddresses) {

            BOOL                    success;

            const struct sockaddr * addrPtr;

            NSUInteger              addrLen;

            addrPtr = (const struct sockaddr *) [address bytes];

            addrLen = [address length];

            assert(addrLen >= sizeof(struct sockaddr));

            // Try to create a connected CFSocket for this address.  If that fails, 

            // we move along to the next address.  If it succeeds, we're done.

            success = NO;

            if ( 

                (addrPtr->sa_family == AF_INET) 

#if ! UDPECHO_IPV4_ONLY

             || (addrPtr->sa_family == AF_INET6) 

#endif

               ) {

                success = [self setupSocketConnectedToAddress:address port:self.port error:&error];

                if (success) {

                    CFDataRef   hostAddress;

                    hostAddress = CFSocketCopyPeerAddress(self->_cfSocket);

                    assert(hostAddress != NULL);

                    self.hostAddress = (__bridge NSData *) hostAddress;

                    CFRelease(hostAddress);

                }

            }

            if (success) {

                break;

            }

        }

    }

    // If we didn't get an address and didn't get an error, synthesise a host not found error.

    if ( (self.hostAddress == nil) && (error == nil) ) {

        error = [NSError errorWithDomain:(NSString *)kCFErrorDomainCFNetwork code:kCFHostErrorHostNotFound userInfo:nil];

    }

    if (error == nil) {

        // We're done resolving, so shut that down.

        [self stopHostResolution];

        // Tell the delegate that we're up.

        if ( (self.delegate != nil) && [self.delegate respondsToSelector:@selector(echo:didStartWithAddress:)] ) {

            [self.delegate echo:self didStartWithAddress:self.hostAddress];

        }

    } else {

        [self stopWithError:error];

    }

}

static void HostResolveCallback(CFHostRef theHost, CFHostInfoType typeInfo, const CFStreamError *error, void *info)

    // This C routine is called by CFHost when the host resolution is complete. 

    // It just redirects the call to the appropriate Objective-C method.

{

    UDPEcho *    obj;

    obj = (__bridge UDPEcho *) info;

    assert([obj isKindOfClass:[UDPEcho class]]);

    #pragma unused(theHost)

    assert(theHost == obj->_cfHost);

    #pragma unused(typeInfo)

    assert(typeInfo == kCFHostAddresses);

    if ( (error != NULL) && (error->domain != 0) ) {

        [obj stopWithStreamError:*error];

    } else {

        [obj hostResolutionDone];

    }

}

- (void)startConnectedToHostName:(NSString *)hostName port:(NSUInteger)port

    // See comment in header.

{

    assert(hostName != nil);

    assert( (port > 0) && (port < 65536) );

    assert(self.port == 0);     // don't try and start a started object

    if (self.port == 0) {

        Boolean             success;

        CFHostClientContext context = {0, (__bridge void *)(self), NULL, NULL, NULL};

        CFStreamError       streamError;

        assert(self->_cfHost == NULL);

        self->_cfHost = CFHostCreateWithName(NULL, (__bridge CFStringRef) hostName);

        assert(self->_cfHost != NULL);

        CFHostSetClient(self->_cfHost, HostResolveCallback, &context);

        CFHostScheduleWithRunLoop(self->_cfHost, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);

        success = CFHostStartInfoResolution(self->_cfHost, kCFHostAddresses, &streamError);

        if (success) {

            self.hostName = hostName;

            self.port = port;

            // ... continue in HostResolveCallback

        } else {

            [self stopWithStreamError:streamError];

        }

    }

}

- (void)sendData:(NSData *)data

    // See comment in header.

{

    // If you call -sendData: on a object in server mode or an object in client mode 

    // that's not fully set up (hostAddress is nil), we just ignore you.

    if (self.isServer || (self.hostAddress == nil) ) {

        assert(NO);

    } else {

        [self sendData:data toAddress:nil];

    }

}

- (void)stopHostResolution

    // Called to stop the CFHost part of the object, if it's still running.

{

    if (self->_cfHost != NULL) {

        CFHostSetClient(self->_cfHost, NULL, NULL);

        CFHostCancelInfoResolution(self->_cfHost, kCFHostAddresses);

        CFHostUnscheduleFromRunLoop(self->_cfHost, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);

        CFRelease(self->_cfHost);

        self->_cfHost = NULL;

    }

}

- (void)stop

    // See comment in header.

{

    self.hostName = nil;

    self.hostAddress = nil;

    self.port = 0;

    [self stopHostResolution];

    if (self->_cfSocket != NULL) {

        CFSocketInvalidate(self->_cfSocket);

        CFRelease(self->_cfSocket);

        self->_cfSocket = NULL;

    }

}

- (void)noop

{

}

- (void)stopWithError:(NSError *)error

    // Stops the object, reporting the supplied error to the delegate.

{

    assert(error != nil);

    [self stop];

    if ( (self.delegate != nil) && [self.delegate respondsToSelector:@selector(echo:didStopWithError:)] ) {

        // The following line ensures that we don't get deallocated until the next time around the 

        // run loop.  This is important if our delegate holds the last reference to us and 

        // this callback causes it to release that reference.  At that point our object (self) gets 

        // deallocated, which causes problems if any of the routines that called us reference self. 

        // We prevent this problem by performing a no-op method on ourself, which keeps self alive 

        // until the perform occurs.

        [self performSelector:@selector(noop) withObject:nil afterDelay:0.0];

        [self.delegate echo:self didStopWithError:error];

    }

}

- (void)stopWithStreamError:(CFStreamError)streamError

    // Stops the object, reporting the supplied error to the delegate.

{

    NSDictionary *  userInfo;

    NSError *       error;

    if (streamError.domain == kCFStreamErrorDomainNetDB) {

        userInfo = [NSDictionary dictionaryWithObjectsAndKeys:

            [NSNumber numberWithInteger:streamError.error], kCFGetAddrInfoFailureKey,

            nil

        ];

    } else {

        userInfo = nil;

    }

    error = [NSError errorWithDomain:(NSString *)kCFErrorDomainCFNetwork code:kCFHostErrorUnknown userInfo:userInfo];

    assert(error != nil);

    [self stopWithError:error];

}

@end