iOS socket

在CFSocket中，TCP连接的创建为

csocket = CFSocketCreate(

                                         kCFAllocatorDefault,

                                         PF_INET,

                                        SOCK_STREAM,

                                        IPPROTO_TCP,

                                         kCFSocketReadCallBack,

                                        TCPServerConnectCallBack,

                                        &ctx);

                                   。。。。

sError = CFSocketConnectToAddress(csocket,address, -1);

这里在连接成功时回调用TCPServerConnectCallBack方法，

那么如果需要UDP传输数据的话，

csocket = CFSocketCreate(

                                         kCFAllocatorDefault,

                                         PF_INET,

                                        SOCK_DGRAM,

                                         IPPROTO_UDP,

                                        kCFSocketConnectCallBack,

                                        TCPServerConnectCallBack,

                                        &ctx);

1.TCP是有连接的，可靠的、可控制的、无边界的socket通信。

2.UDP是无连接的、不可靠的 数据报通信。但是效率高。

所以在TCP中要用回调来确定是否连接成功，而原生的socket连接成功是通过serveice发回信息来确定。UDP无连接，所以不需要回调，而不管是否发送成功。

第三部分、完整的使用方法

客户端：

导入头文件：

#import <sys/socket.h>

#import <netinet/in.h>

#import <arpa/inet.h>

#import <unistd.h>

1. 创建连接

CFSocketContext sockContext = {0, // 结构体的版本，必须为0

self,

// 一个任意指针的数据，可以用在创建时CFSocket对象相关联。这个指针被传递给所有的上下文中定义的回调。

NULL, // 一个定义在上面指针中的retain的回调， 可以为NULL

NULL, NULL};

CFSocketRef _socket = (kCFAllocatorDefault,// 为新对象分配内存，可以为nil

PF_INET, // 协议族，如果为0或者负数，则默认为PF_INET

SOCK_STREAM, // 套接字类型，如果协议族为PF_INET,则它会默认为SOCK_STREAM

IPPROTO_TCP, // 套接字协议，如果协议族是PF_INET且协议是0或者负数，它会默认为IPPROTO_TCP

kCFSocketConnectCallBack, // 触发回调函数的socket消息类型，具体见CallbackTypes

TCPServerConnectCallBack, // 上面情况下触发的回调函数

&sockContext // 一个持有CFSocket结构信息的对象，可以为nil

);

if (_socket != nil) {

   struct sockaddr_in addr4;   //IPV4

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

   addr4.sin_len = sizeof(addr4);

   addr4.sin_family = AF_INET;

   addr4.sin_port = htons(8888);

   addr4.sin_addr.s_addr = inet_addr([strAddress UTF8String]);  // 把字符串的地址转换为机器可识别的网络地址

   // 把sockaddr_in结构体中的地址转换为Data

   CFDataRef address = CFDataCreate(kCFAllocatorDefault, (UInt8*)&addr4, sizeof(addr4));

   CFSocketConnectToAddress(_socket, // 连接的socket

address, // CFDataRef类型的包含上面socket的远程地址的对象

-1 // 连接超时时间，如果为负，则不尝试连接，而是把连接放在后台进行，如果_socket消息类型为kCFSocketConnectCallBack，将会在连接成功或失败的时候在后台触发回调函数

);

   CFRunLoopRef cRunRef = CFRunLoopGetCurrent();    // 获取当前线程的循环

   // 创建一个循环，但并没有真正加如到循环中，需要调用CFRunLoopAddSource

   CFRunLoopSourceRef sourceRef = CFSocketCreateRunLoopSource(kCFAllocatorDefault,_socket, 0);

   CFRunLoopAddSource(cRunRef, // 运行循环

   sourceRef,  // 增加的运行循环源, 它会被retain一次

   kCFRunLoopCommonModes  // 增加的运行循环源的模式

   );

   CFRelease(courceRef);

}

2. 设置回调函数

// socket回调函数的格式：

static void TCPServerConnectCallBack(CFSocketRefsocket, CFSocketCallBackType type, CFDataRef address, const void *data, void*info) ｛

    if (data != NULL) {

        // 当socket为kCFSocketConnectCallBack时，失败时回调失败会返回一个错误代码指针，其他情况返回NULL

        NSLog(@"连接失败");

        return;

    }

    TCPClient *client = (TCPClient *)info;

    // 读取接收的数据

    [info performSlectorInBackground:@selector(readStream) withObject:nil];

｝

3. 接收发送数据

// 读取接收的数据

- (void)readStream {

    char buffer[1024];

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    while (recv(CFSocketGetNative(_socket), //与本机关联的Socket 如果已经失效返回－1:INVALID_SOCKET

           buffer, sizeof(buffer), 0)) {

        NSLog(@"%@", [NSString stringWithUTF8String:buffer]);

    }

}

// 发送数据

- (void)sendMessage {

     NSString*stringTosend = @"你好";

    char *data = [stringTosend UTF8String];

    send(SFSocketGetNative(_socket), data, strlen(data) + 1, 0);

}

服务器端：

CFSockteRef _socket;

CFWriteStreamRef outputStream = NULL;

int setupSocket() {

    _socket = CFSocketCreate(kCFAllocatorDefault, PF_INET, SOCK_STREAM,IPPROTO_TCP, kCFSocketAcceptCallBack, TCPServerAcceptCallBack, NULL);

    if (NULL == _socket) {

        NSLog(@"Cannot create socket!");

        return 0;

    }

    int optval = 1;

    setsockopt(CFSocketGetNative(_socket), SOL_SOCKET, SO_REUSEADDR, // 允许重用本地地址和端口

(void *)&optval, sizeof(optval));

    struct sockaddr_in addr4;

    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 = htonl(INADDR_ANY);

    CFDataRef address = CFDataCreate(kCFAllocatorDefault, (UInt8*)&addr4, sizeof(addr4));

    if (kCFSocketSuccess != CFSocketSetAddress(_socket, address)) {

        NSLog(@"Bind to address failed!");

        if (_socket)

              CFRelease(_socket);

        _socket = NULL;

        return 0;

    }

    CFRunLoopRef cfRunLoop = CFRunLoopGetCurrent();

    CFRunLoopSourceRef source = CFSocketCreateRunLoopSource(kCFAllocatorDefault,_socket, 0);

    CFRunLoopAddSource(cfRunLoop, source, kCFRunLoopCommonModes);

    CFRelease(source);

    return 1;

}

// socket回调函数，同客户端

void TCPServerAcceptCallBack(CFSocketRefsocket, CFSocketCallBackType type, CFDataRef address, const void *data, void*info) {

    if (kCFSocketAcceptCallBack == type) {

        // 本地套接字句柄

        CFSocketNativeHandle nativeSocketHandle = *(CFSocketNativeHandle *)data;

        uint8_t name[SOCK_MAXADDRLEN];     

        socklen_t nameLen = sizeof(name);

        if (0 != getpeername(nativeSocketHandle, (struct sockaddr *)name,&nameLen)) {

            NSLog(@"error");

            exit(1);

        }

        NSLog(@"%@ connected.", inet_ntoa( ((struct sockaddr_in*)name)->sin_addr )):

        CFReadStreamRef iStream;

        CFWriteStreamRef oStream;

        // 创建一个可读写的socket连接

         CFStreamCreatePairWithSocket(kCFAllocatorDefault,nativeSocketHandle, &iStream, &oStream);

        if (iStream && oStream) {

            CFStreamClientContext streamContext = {0, NULL, NULL, NULL};

            if (!CFReadStreamSetClient(iStream, kCFStreamEventHasBytesAvaiable,

                                       readStream, // 回调函数，当有可读的数据时调用

                                       &streamContext)){

                 exit(1);

            }

            if (!CFReadStreamSetClient(iStream, kCFStreamEventCanAcceptBytes,writeStream, &streamContext)){

                 exit(1);

            }

            CFReadStreamScheduleWithRunLoop(iStream, CFRunLoopGetCurrent(),kCFRunLoopCommomModes);

            CFWriteStreamScheduleWithRunLoop(wStream, CFRunLoopGetCurrent(),kCFRunLoopCommomModes);

            CFReadStreamOpen(iStream);

            CFWriteStreamOpen(wStream);

        } else {

              close(nativeSocketHandle);

        }

     }

}

// 读取数据

void readStream(CFReadStreamRef stream,CFStreamEventType eventType, void *clientCallBackInfo) {

    UInt8 buff[255];

    CFReadStreamRead(stream, buff, 255);

    printf("received: %s", buff);

}

void writeStream (CFWriteStreamRef stream, CFStreamEventTypeeventType, void *clientCallBackInfo) {

    outputStream = stream;

}

main {

    char *str = "nihao";

    if (outputStream != NULL) {

        CFWriteStreamWrite(outputStream, str, strlen(line) + 1);

    } else {

        NSLog(@"Cannot send data!");

    }

}

// 开辟一个线程线程函数中

void runLoopInThread() {

    int res = setupSocket();

    if (!res) {

        exit(1);

    }

    CFRunLoopRun();    // 运行当前线程的CFRunLoop对象

}