OS X/IOS 网络编程

之前在os x和ios上都写过一些简单的网络通信程序，都是用的基于c的bsd socket，因为之前在linux，windows上写过很多网络通信程序，都是用的c语言版本的socket，所以os x／ios上也用这套东西了。用基本的bsd socket，比较灵活，但是相对也比较难控制一点，需要关注很多细节，也比较繁琐。其实每个平台上面，都有一些封装好的类库，比如windows上有mfc，甚至boost，当然boost是跨平台的，linux上也可以用。os x／ios上则有cfnetwork，还有cocoa的stream等等。昨天下午突然有兴趣，就看了一下cfnetwork和stream，写了个简单的测试程序。

服务端

服务端采用cfnetwork写的，结合了run－loop。先看看监听socket的创建，整体步骤跟c语言的差不多，了不起就是用不同的函数。

- (BOOL)createServer{    //// PART 1: Create a socket that can accept connections        // Socket context    //  struct CFSocketContext {    //   CFIndex version;    //   void *info;    //   CFAllocatorRetainCallBack retain;    //   CFAllocatorReleaseCallBack release;    //   CFAllocatorCopyDescriptionCallBack copyDescription;    //  };    CFSocketContext socketContext = {0, self, NULL, NULL, NULL};        listeningSocket = CFSocketCreate(     kCFAllocatorDefault,     PF_INET,        // The protocol family for the socket     SOCK_STREAM,    // The socket type to create     IPPROTO_TCP,    // The protocol for the socket. TCP vs UDP.     kCFSocketAcceptCallBack,  // New connections will be automatically accepted and the callback is called with the data argument being a pointer to a CFSocketNativeHandle of the child socket.     (CFSocketCallBack)&serverAcceptCallback,     &socketContext );        // Previous call might have failed    if ( listeningSocket == NULL ) {    status = @"listeningSocket Not Created";    return FALSE;    }    else {    status = @"listeningSocket Created";    int existingValue = 1;                // Make sure that same listening socket address gets reused after every connection        setsockopt( CFSocketGetNative(listeningSocket),                   SOL_SOCKET, SO_REUSEADDR, (void *)&existingValue,                   sizeof(existingValue));                        //// PART 2: Bind our socket to an endpoint.        // We will be listening on all available interfaces/addresses.        // Port will be assigned automatically by kernel.        struct sockaddr_in socketAddress;        memset(&socketAddress, 0, sizeof(socketAddress));        socketAddress.sin_len = sizeof(socketAddress);        socketAddress.sin_family = AF_INET;   // Address family (IPv4 vs IPv6)        socketAddress.sin_port = 0;           // Actual port will get assigned automatically by kernel        socketAddress.sin_addr.s_addr = htonl(INADDR_ANY);    // We must use "network byte order" format (big-endian) for the value here                // Convert the endpoint data structure into something that CFSocket can use        NSData *socketAddressData =        [NSData dataWithBytes:&socketAddress length:sizeof(socketAddress)];                // Bind our socket to the endpoint. Check if successful.        if ( CFSocketSetAddress(listeningSocket, (CFDataRef)socketAddressData) != kCFSocketSuccess ) {            // Cleanup            if ( listeningSocket != NULL ) {                status = @"Socket Not Binded";                CFRelease(listeningSocket);                listeningSocket = NULL;            }                        return FALSE;        }        status = @"Socket Binded";                //// PART 3: Find out what port kernel assigned to our socket        // We need it to advertise our service via Bonjour        NSData *socketAddressActualData = [(NSData *)CFSocketCopyAddress(listeningSocket) autorelease];                // Convert socket data into a usable structure        struct sockaddr_in socketAddressActual;        memcpy(&socketAddressActual, [socketAddressActualData bytes],               [socketAddressActualData length]);                port = ntohs(socketAddressActual.sin_port);           //     char* ip = inet_ntoa(socketAddressActual.sin_addr);                        //// PART 4: Hook up our socket to the current run loop        CFRunLoopRef currentRunLoop = CFRunLoopGetCurrent();        CFRunLoopSourceRef runLoopSource = CFSocketCreateRunLoopSource(kCFAllocatorDefault, listeningSocket, 0);        CFRunLoopAddSource(currentRunLoop, runLoopSource, kCFRunLoopCommonModes);        CFRelease(runLoopSource);                KAppDelegate* d = (KAppDelegate*)[self delegate];        [d ShowLog:[NSString stringWithFormat:@"Create server socket successfully, port: %d", port]];                return TRUE;    }}

基本步骤就是：

1. 创建一个监听socket

2. 绑定本地地址和端口

3. 绑定run－loop

注意：在CFSocketCreate中的参数kCFSocketAcceptCallBack，这里就是设置了一个回调，当有客户端连上来的时候，当前线程的run－loop将会被调用这个回调。

看看这个回调函数：

static void serverAcceptCallback(CFSocketRef socket, CFSocketCallBackType type, CFDataRef address, const void *data, void *info) {        // We can only process "connection accepted" calls here    if ( type != kCFSocketAcceptCallBack ) {    return;    }        // for an AcceptCallBack, the data parameter is a pointer to a CFSocketNativeHandle    CFSocketNativeHandle nativeSocketHandle = *(CFSocketNativeHandle*)data;        KServer *server = (KServer*)info;    [server handleNewNativeSocket:nativeSocketHandle];}

这个回调函数里面就是简单的调用另外一个函数：

// Handle new connections- (void)handleNewNativeSocket:(CFSocketNativeHandle)nativeSocketHandle {    ClientSocket* c = [[[ClientSocket alloc] init] autorelease];    c.sock = nativeSocketHandle;    [m_AllClients addObject:c];        uint8_t name[SOCK_MAXADDRLEN];    socklen_t nameLen = sizeof(name);    if (0 != getpeername(nativeSocketHandle, (struct sockaddr *)name, &nameLen)) {        NSLog(@"error");        exit(1);    }        KAppDelegate* d = (KAppDelegate*)[self delegate];    struct sockaddr_in* addr = (struct sockaddr_in *)name;    [d ShowLog:[NSString stringWithFormat:@"connected, client: %s, %d", inet_ntoa(addr->sin_addr), ntohs(addr->sin_port)]];        //写一些数据给客户端    CFReadStreamRef iStream;    CFWriteStreamRef oStream;    // 创建一个可读写的socket连接    CFStreamCreatePairWithSocket(kCFAllocatorDefault, nativeSocketHandle, &iStream, &oStream);    if (iStream && oStream) {        CFStreamClientContext streamContext = {0, self, NULL, NULL};        if (!CFReadStreamSetClient(iStream, kCFStreamEventHasBytesAvailable,                                   readStream, // 回调函数，当有可读的数据时调用                                   &streamContext)){            exit(1);        }                if (!CFWriteStreamSetClient(oStream, kCFStreamEventCanAcceptBytes, writeStream, &streamContext)){            exit(1);        }                CFReadStreamScheduleWithRunLoop(iStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);   //     CFWriteStreamScheduleWithRunLoop(oStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);        CFReadStreamOpen(iStream);   //     CFWriteStreamOpen(oStream);                NSString *stringTosend = @"Welcome CFSocker server";        [self SendData:stringTosend];    } else {        close(nativeSocketHandle);    }}

在这里，我们简单的读取了一下client的ip和端口，并且显示。

然后给新生成的用于处理远程client的socket创建一个readstream，并且集成到run－loop中，这样client有数据发过来的时候，run－loop就会触发一个响应。这个例子里面一旦有client连上，就先给client发一些信息。另外，我还将每个处理client的socket放到了一个array中。
看一下读取信息的回调函数

// 读取数据void readStream(CFReadStreamRef stream, CFStreamEventType eventType, void *clientCallBackInfo) {    UInt8 buff[255];    CFReadStreamRead(stream, buff, 255);  //  printf("received: %s", buff);    KServer* context = (KServer*)clientCallBackInfo;    [context ShowLog:[NSString stringWithFormat:@"recv: %s", buff]];}

收取数据后，打印一下。

哈哈，这个简单的server，基本就是这个样子。

其实，这个server例子只是用最最简单的cfnetwork函数创建了一个最最简单的server，这些代码还有很多问题，比如：

1. 各种网络错误处理，如果断线等

2. 并发性的问题

3. 甚至一些可能的内存泄漏

等等，还有很多其他的问题。anyway，这段代码只是用来演示基本的cfnetwork函数调用。

客户端

有了服务端，在创建一个客户端。客户端也可以用cfnetwork。

如：

-(void) CreateSocketClient: (NSString*) serverIP PORT: (in_port_t) port{    CFSocketContext sockContext = {0, // 结构体的版本，必须为0        self,  // 一个任意指针的数据，可以用在创建时CFSocket对象相关联。这个指针被传递给所有的上下文中定义的回调。        NULL, // 一个定义在上面指针中的retain的回调， 可以为NULL        NULL, NULL};        _client = CFSocketCreate(                   kCFAllocatorDefault,                   PF_INET,        // The protocol family for the socket                   SOCK_STREAM,    // The socket type to create                   IPPROTO_TCP,    // The protocol for the socket. TCP vs UDP.                   kCFSocketConnectCallBack,  // New connections will be automatically accepted and the callback is called with the data argument being a pointer to a CFSocketNativeHandle of the child socket.                   (CFSocketCallBack)&TCPServerConnectCallBack,                   &sockContext );            if (_client != nil) {        int existingValue = 1;                // Make sure that same listening socket address gets reused after every connection        setsockopt( CFSocketGetNative(_client),                   SOL_SOCKET, SO_REUSEADDR, (void *)&existingValue,                   sizeof(existingValue));                struct sockaddr_in addr4;   // IPV4        memset(&addr4, 0, sizeof(addr4));        addr4.sin_len = sizeof(addr4);        addr4.sin_family = AF_INET;        addr4.sin_port = htons(port);        addr4.sin_addr.s_addr = inet_addr([serverIP UTF8String]);  // 把字符串的地址转换为机器可识别的网络地址                // 把sockaddr_in结构体中的地址转换为Data        CFDataRef address = CFDataCreate(kCFAllocatorDefault, (UInt8 *)&addr4, sizeof(addr4));        CFSocketConnectToAddress(_client, // 连接的socket                                 address, // CFDataRef类型的包含上面socket的远程地址的对象                                 -1  // 连接超时时间，如果为负，则不尝试连接，而是把连接放在后台进行，如果_socket消息类型为kCFSocketConnectCallBack，将会在连接成功或失败的时候在后台触发回调函数                                 );                CFRunLoopRef cRunRef = CFRunLoopGetCurrent();    // 获取当前线程的循环        // 创建一个循环，但并没有真正加如到循环中，需要调用CFRunLoopAddSource        CFRunLoopSourceRef sourceRef = CFSocketCreateRunLoopSource(kCFAllocatorDefault, _client, 0);        CFRunLoopAddSource(cRunRef, // 运行循环                           sourceRef,  // 增加的运行循环源, 它会被retain一次                           kCFRunLoopCommonModes  // 增加的运行循环源的模式                           );        CFRelease(sourceRef);                            }       }

基本过程就是：

1. 创建一个socket

2. connect服务器

注意这次在CFSocketCreate里面，我们使用了kCFSocketConnectCallback的回调，这样当client的connect动作完成的时候，都会调用这个回调（无论成功与否）。

// socket回调函数的格式：static void TCPServerConnectCallBack(CFSocketRef socket, CFSocketCallBackType type, CFDataRef address, const void *data, void *info){    if (data != NULL) {        // 当socket为kCFSocketConnectCallBack时，失败时回调失败会返回一个错误代码指针，其他情况返回NULL        NSLog(@"连接失败");        return;    }        KClient *client = (KClient *)info;        CFReadStreamRef iStream;        CFSocketNativeHandle h = CFSocketGetNative(socket);    CFStreamCreatePairWithSocket(kCFAllocatorDefault, h, &iStream, nil);    //   CFStreamCreatePairWithSocket(kCFAllocatorDefault, socket, &iStream, nil);    if (iStream) {        CFStreamClientContext streamContext = {0, NULL, NULL, NULL};        if (!CFReadStreamSetClient(iStream, kCFStreamEventHasBytesAvailable |                                   kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,                                   readStream, // 回调函数，当有可读的数据时调用                                   &streamContext)){            exit(1);        }                CFReadStreamScheduleWithRunLoop(iStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);  //      CFReadStreamOpen(iStream);                //       size_t sent = send(CFSocketGetNative(socket), "client sent", 11, 0);                char buf[100] = {0};        //    recv(CFSocketGetNative(socket), buf, 100, 0);                printf("recv: %s", buf);    }    }

在这个回调里面如果使用recv可以接收到服务端发过来的信息，但是使用ReadStream好象收不到，我也不知道为什么，我没有花太多时间去研究它。如果哪位大哥能够指出错误的话，将不胜感激。

其实apple公司在Cocoa里面还提供了一些其他的用于网络通信的接口，比如NSStream，这个是基于objective-c语言的。使用也是相当的方便。

写了几行测试代码：

- (void)work_thread:(NSURL *)url{    NSInputStream * readStream;    NSOutputStream* writeStream;        NSString* strHost = [url host]; //   strHost = @"127.0.0.1";    int port = [[url port] integerValue];       [NSStream getStreamsToHostNamed:strHost port: port inputStream:&readStream outputStream:&writeStream];            [readStream setDelegate:self];    [readStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];    [readStream open];        [writeStream open];    [writeStream write:"abcd" maxLength:4];    [[NSRunLoop currentRunLoop] run];}

这次我们将通信程序放到一个线程里面。上面就是一个线程函数，在这个函数里面，指定了服务端的ip和端口，并且创建了2个stream，一个input，一个output。然后集成到这个线程的run－loop里面。

为了接收nsstream的响应，必须给nsstream指定一个delegate，并且实现stream函数。

@interface KAppDelegate : NSObject <NSApplicationDelegate, NSStreamDelegate>

实现：

- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode{    NSLog(@" >> NSStreamDelegate in Thread %@", [NSThread currentThread]);        switch (eventCode) {        case NSStreamEventHasBytesAvailable: {                                    uint8_t buf[100] = {0};            int numBytesRead = [(NSInputStream *)stream read:buf maxLength:100];                        NSString* str = [NSString stringWithFormat:@"recv: %s", buf];            [self performSelectorOnMainThread:@selector(ShowLog:) withObject:str waitUntilDone:YES];                        break;        }                    case NSStreamEventErrorOccurred: {                       break;        }                    case NSStreamEventEndEncountered: {                                               break;        }                    default:            break;    }}

真的是相当的简单，在stream函数里面可以处理各种事件。

最后只要启动这个线程就可以了，如：

    NSURL * url = [NSURL URLWithString:[NSString stringWithFormat:@"http://%@:%@",  [self TextIP].stringValue, [self TextPort].stringValue]];        NSThread * backgroundThread = [[NSThread alloc] initWithTarget:self                                                          selector:@selector(work_thread:)                                                            object:url];    [backgroundThread start];

这个线程启动后，就会在线程函数里面创建inputstream和outputstream，这样就可以发送和读取数据了，使用NSStream，真的可以很轻松的实现网络通信，我们所要做的就是：

1. 创建发送和读取stream；

2. 实现一个delegate，用于处理各种网络事件。

所以，我们在写os x／ios网络程序的时候，应该尽量使用NSStream等这种高级的工具，因为apple公司已经帮我们处理了很多细节问题，可以节省很多的时间。

另外有一个需要注意的就是：NSStream并没有提供连接服务端的基于字符串的函数，没有关系，我们可以扩展一个，如下：

@implementation NSStream(StreamsToHost)+ (void)getStreamsToHostNamed:(NSString *)hostName                         port:(NSInteger)port                  inputStream:(out NSInputStream **)inputStreamPtr                 outputStream:(out NSOutputStream **)outputStreamPtr{    CFReadStreamRef     readStream;    CFWriteStreamRef    writeStream;        assert(hostName != nil);    assert( (port > 0) && (port < 65536) );    assert( (inputStreamPtr != NULL) || (outputStreamPtr != NULL) );        readStream = NULL;    writeStream = NULL;        CFStreamCreatePairWithSocketToHost(                                       NULL,                                       (__bridge CFStringRef) hostName,                                       port,                                       ((inputStreamPtr  != NULL) ? &readStream : NULL),                                       ((outputStreamPtr != NULL) ? &writeStream : NULL)                                       );        if (inputStreamPtr != NULL) {        *inputStreamPtr  = CFBridgingRelease(readStream);    }        if (outputStreamPtr != NULL) {        *outputStreamPtr = CFBridgingRelease(writeStream);    }}@end

通过这个函数，我们可以方便地通过字符串表示的ip和端口来连接服务端。

例子使用的OS X，其实在IOS里面也是类似的做法。

 

代码：http://download.csdn.net/detail/zj510/5388471