在UNIX系统中,万物皆文件(Everything is a file)。所有的IO操作都可以看作对文件的IO操作，都遵循着这样的操作模式:打开 -> 读/写 -> 关闭，打开操作（如open函数）获取“文件”使用权，返回文件描述符，后继的操作都通过这个文件描述符来进行。很多系统调用都依赖于文件描述符,它是一个无符号整数，每一个用户进程都对应着一个文件描述符表，通过文件描述符就可以找到对应文件的信息。
在类UNIX平台上，对于控制台的标准输入输出以及标准错误输出都有对应的文件描述符，分别为0,1,2。它们定义在 unistd.h中
UNIX内核加入TCP/IP协议的时候，便在系统中引入了一种新的IO操作，只不过由于网络连接的不可靠性，所以网络IO比本地设备的IO复杂很多。这一系列的接口叫做BSD Socket API,当初由伯克利大学研发，最终成为网络开发接口的标准。
网络通信从本质上讲也是进程间通信，只是这两个进程一般在网络中不同计算机上。当然Socket API其实也提供了专门用于本地IPC的使用方式：UNIX Domain Socket，这个这里就不细说了。本文所讲的Socket如无例外，均是说的Internet Socket。
在本地的进程中，每一个进程都可以通过PID来标识，对于网络上的一个计算机中的进程如何标识呢？网络中的计算机可以通过一个IP地址进行标识，一个计算机中的某个进程则可以通过一个无符号整数（端口号）来标识，所以一个网络中的进程可以通过IP地址+端口号的方式进行标识。
####5.网络编程模型
网络存在的本质其实就是网络中个体之间的在某个领域的信息存在不对等性，所以一般情况下总有一些个体为另一些个体提供服务。提供服务器的我们把它叫做服务器，接受服务的叫做客户端。所以在网络编程中，也存在服务器端和客户端之分。
服务器端 客户端
创建Socket -
将Socket和本地的地址端口绑定 -
开始进行侦听 创建一个Socket和服务器的地址并通过它们向服务器发送连接请求
握手成功，接受请求，得到一个新的Socket，通过它可以和客户端进行通信 连接成功，客户端的Socket会绑定到系统分配的一个端口上，并可以通过它和服务器端进行通信
</table>
###三.BSD Socket编程详解
下面的例子是一个简单的一对一聊天的程序，分服务器和客户端，且发送消息和接受消息次序固定。
####Server端代码
#include <stdio.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
int main ( int argc , const char * argv [])
{
struct sockaddr_in server_addr ;
server_addr . sin_len = sizeof ( struct sockaddr_in );
server_addr . sin_family = AF_INET ; //Address families AF_INET互联网地址簇
server_addr . sin_port = htons ( 11332 );
server_addr . sin_addr . s_addr = inet_addr ( "127.0.0.1" );
bzero ( & ( server_addr . sin_zero ), 8 );
//创建socket
int server_socket = socket ( AF_INET , SOCK_STREAM , 0 ); //SOCK_STREAM 有连接
if ( server_socket == - 1 ) {
perror ( "socket error" );
return 1 ;
}
//绑定socket：将创建的socket绑定到本地的IP地址和端口，此socket是半相关的，只是负责侦听客户端的连接请求，并不能用于和客户端通信
int bind_result = bind ( server_socket , ( struct sockaddr * ) & server_addr , sizeof ( server_addr ));
if ( bind_result == - 1 ) {
perror ( "bind error" );
return 1 ;
}
//listen侦听 第一个参数是套接字，第二个参数为等待接受的连接的队列的大小，在connect请求过来的时候,完成三次握手后先将连接放到这个队列中，直到被accept处理。如果这个队列满了，且有新的连接的时候，对方可能会收到出错信息。
if ( listen ( server_socket , 5 ) == - 1 ) {
perror ( "listen error" );
return 1 ;
}
struct sockaddr_in client_address ;
socklen_t address_len ;
int client_socket = accept ( server_socket , ( struct sockaddr * ) & client_address , & address_len );
//返回的client_socket为一个全相关的socket，其中包含client的地址和端口信息，通过client_socket可以和客户端进行通信。
if ( client_socket == - 1 ) {
perror ( "accept error" );
return - 1 ;
}
char recv_msg [ 1024 ];
char reply_msg [ 1024 ];
while ( 1 ) {
bzero ( recv_msg , 1024 );
bzero ( reply_msg , 1024 );
printf ( "reply:" );
scanf ( "%s" , reply_msg );
send ( client_socket , reply_msg , 1024 , 0 );
long byte_num = recv ( client_socket , recv_msg , 1024 , 0 );
recv_msg [ byte_num ] = '\0' ;
printf ( "client said:%s \n " , recv_msg );
}
return 0 ;
} #include <stdio.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
int main ( int argc , const char * argv [])
{
struct sockaddr_in server_addr ;
server_addr . sin_len = sizeof ( struct sockaddr_in );
server_addr . sin_family = AF_INET ;
server_addr . sin_port = htons ( 11332 );
server_addr . sin_addr . s_addr = inet_addr ( "127.0.0.1" );
bzero ( & ( server_addr . sin_zero ), 8 );
int server_socket = socket ( AF_INET , SOCK_STREAM , 0 );
if ( server_socket == - 1 ) {
perror ( "socket error" );
return 1 ;
}
char recv_msg [ 1024 ];
char reply_msg [ 1024 ];
if ( connect ( server_socket , ( struct sockaddr * ) & server_addr , sizeof ( struct sockaddr_in )) == 0 ) {
//connect 成功之后，其实系统将你创建的socket绑定到一个系统分配的端口上，且其为全相关，包含服务器端的信息，可以用来和服务器端进行通信。
while ( 1 ) {
bzero ( recv_msg , 1024 );
bzero ( reply_msg , 1024 );
long byte_num = recv ( server_socket , recv_msg , 1024 , 0 );
recv_msg [ byte_num ] = '\0' ;
printf ( "server said:%s \n " , recv_msg );
printf ( "reply:" );
scanf ( "%s" , reply_msg );
if ( send ( server_socket , reply_msg , 1024 , 0 ) == - 1 ) {
perror ( "send error" );
}
}
}
// insert code here...
printf ( "Hello, World! \n " );
return 0 ;
} #include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#define BACKLOG 5 //完成三次握手但没有accept的队列的长度
#define CONCURRENT_MAX 8 //应用层同时可以处理的连接
#define SERVER_PORT 11332
#define BUFFER_SIZE 1024
#define QUIT_CMD ".quit"
int client_fds [ CONCURRENT_MAX ];
int main ( int argc , const char * argv [])
{
char input_msg [ BUFFER_SIZE ];
char recv_msg [ BUFFER_SIZE ];
//本地地址
struct sockaddr_in server_addr ;
server_addr . sin_len = sizeof ( struct sockaddr_in );
server_addr . sin_family = AF_INET ;
server_addr . sin_port = htons ( SERVER_PORT );
server_addr . sin_addr . s_addr = inet_addr ( "127.0.0.1" );
bzero ( & ( server_addr . sin_zero ), 8 );
//创建socket
int server_sock_fd = socket ( AF_INET , SOCK_STREAM , 0 );
if ( server_sock_fd == - 1 ) {
perror ( "socket error" );
return 1 ;
}
//绑定socket
int bind_result = bind ( server_sock_fd , ( struct sockaddr * ) & server_addr , sizeof ( server_addr ));
if ( bind_result == - 1 ) {
perror ( "bind error" );
return 1 ;
}
//listen
if ( listen ( server_sock_fd , BACKLOG ) == - 1 ) {
perror ( "listen error" );
return 1 ;
}
//fd_set
fd_set server_fd_set ;
int max_fd = - 1 ;
struct timeval tv ;
tv . tv_sec = 20 ;
tv . tv_usec = 0 ;
while ( 1 ) {
FD_ZERO ( & server_fd_set );
//标准输入
FD_SET ( STDIN_FILENO , & server_fd_set );
if ( max_fd < STDIN_FILENO ) {
max_fd = STDIN_FILENO ;
}
//服务器端socket
FD_SET ( server_sock_fd , & server_fd_set );
if ( max_fd < server_sock_fd ) {
max_fd = server_sock_fd ;
}
//客户端连接
for ( int i = 0 ; i < CONCURRENT_MAX ; i ++ ) {
if ( client_fds [ i ] != 0 ) {
FD_SET ( client_fds [ i ], & server_fd_set );
if ( max_fd < client_fds [ i ]) {
max_fd = client_fds [ i ];
}
}
}
int ret = select ( max_fd + 1 , & server_fd_set , NULL , NULL , & tv );
if ( ret < 0 ) {
perror ( "select 出错 \n " );
continue ;
} else if ( ret == 0 ){
printf ( "select 超时 \n " );
continue ;
} else {
//ret为未状态发生变化的文件描述符的个数
if ( FD_ISSET ( STDIN_FILENO , & server_fd_set )) {
//标准输入
bzero ( input_msg , BUFFER_SIZE );
fgets ( input_msg , BUFFER_SIZE , stdin );
//输入 ".quit" 则退出服务器
if ( strcmp ( input_msg , QUIT_CMD ) == 0 ) {
exit ( 0 );
}
for ( int i = 0 ; i < CONCURRENT_MAX ; i ++ ) {
if ( client_fds [ i ] != 0 ) {
send ( client_fds [ i ], input_msg , BUFFER_SIZE , 0 );
}
}
}
if ( FD_ISSET ( server_sock_fd , & server_fd_set )) {
//有新的连接请求
struct sockaddr_in client_address ;
socklen_t address_len ;
int client_socket_fd = accept ( server_sock_fd , ( struct sockaddr * ) & client_address , & address_len );
if ( client_socket_fd > 0 ) {
int index = - 1 ;
for ( int i = 0 ; i < CONCURRENT_MAX ; i ++ ) {
if ( client_fds [ i ] == 0 ) {
index = i ;
client_fds [ i ] = client_socket_fd ;
break ;
}
}
if ( index >= 0 ) {
printf ( "新客户端(%d)加入成功 %s:%d \n " , index , inet_ntoa ( client_address . sin_addr ), ntohs ( client_address . sin_port ));
} else {
bzero ( input_msg , BUFFER_SIZE );
strcpy ( input_msg , "服务器加入的客户端数达到最大值,无法加入! \n " );
send ( client_socket_fd , input_msg , BUFFER_SIZE , 0 );
printf ( "客户端连接数达到最大值，新客户端加入失败 %s:%d \n " , inet_ntoa ( client_address . sin_addr ), ntohs ( client_address . sin_port ));
}
}
}
for ( int i = 0 ; i < CONCURRENT_MAX ; i ++ ) {
if ( client_fds [ i ] != 0 ) {
if ( FD_ISSET ( client_fds [ i ], & server_fd_set )) {
//处理某个客户端过来的消息
bzero ( recv_msg , BUFFER_SIZE );
long byte_num = recv ( client_fds [ i ], recv_msg , BUFFER_SIZE , 0 );
if ( byte_num > 0 ) {
if ( byte_num > BUFFER_SIZE ) {
byte_num = BUFFER_SIZE ;
}
recv_msg [ byte_num ] = '\0' ;
printf ( "客户端(%d):%s \n " , i , recv_msg );
} else if ( byte_num < 0 ){
printf ( "从客户端(%d)接受消息出错. \n " , i );
} else {
FD_CLR ( client_fds [ i ], & server_fd_set );
client_fds [ i ] = 0 ;
printf ( "客户端(%d)退出了 \n " , i );
}
}
}
}
}
}
return 0 ;
} #include <stdio.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#define BUFFER_SIZE 1024
int main ( int argc , const char * argv [])
{
struct sockaddr_in server_addr ;
server_addr . sin_len = sizeof ( struct sockaddr_in );
server_addr . sin_family = AF_INET ;
server_addr . sin_port = htons ( 11332 );
server_addr . sin_addr . s_addr = inet_addr ( "127.0.0.1" );
bzero ( & ( server_addr . sin_zero ), 8 );
int server_sock_fd = socket ( AF_INET , SOCK_STREAM , 0 );
if ( server_sock_fd == - 1 ) {
perror ( "socket error" );
return 1 ;
}
char recv_msg [ BUFFER_SIZE ];
char input_msg [ BUFFER_SIZE ];
if ( connect ( server_sock_fd , ( struct sockaddr * ) & server_addr , sizeof ( struct sockaddr_in )) == 0 ) {
fd_set client_fd_set ;
struct timeval tv ;
tv . tv_sec = 20 ;
tv . tv_usec = 0 ;
while ( 1 ) {
FD_ZERO ( & client_fd_set );
FD_SET ( STDIN_FILENO , & client_fd_set );
FD_SET ( server_sock_fd , & client_fd_set );
int ret = select ( server_sock_fd + 1 , & client_fd_set , NULL , NULL , & tv );
if ( ret < 0 ) {
printf ( "select 出错! \n " );
continue ;
} else if ( ret == 0 ){
printf ( "select 超时! \n " );
continue ;
} else {
if ( FD_ISSET ( STDIN_FILENO , & client_fd_set )) {
bzero ( input_msg , BUFFER_SIZE );
fgets ( input_msg , BUFFER_SIZE , stdin );
if ( send ( server_sock_fd , input_msg , BUFFER_SIZE , 0 ) == - 1 ) {
perror ( "发送消息出错! \n " );
}
}
if ( FD_ISSET ( server_sock_fd , & client_fd_set )) {
bzero ( recv_msg , BUFFER_SIZE );
long byte_num = recv ( server_sock_fd , recv_msg , BUFFER_SIZE , 0 );
if ( byte_num > 0 ) {
if ( byte_num > BUFFER_SIZE ) {
byte_num = BUFFER_SIZE ;
}
recv_msg [ byte_num ] = '\0' ;
printf ( "服务器:%s \n " , recv_msg );
} else if ( byte_num < 0 ){
printf ( "接受消息出错! \n " );
} else {
printf ( "服务器端退出! \n " );
exit ( 0 );
}
}
}
}
}
return 0 ;
} //sys/_structs.h
#define __DARWIN_FD_SETSIZE 1024
/////////////////////////////////////////////
//Kernel.framework sys/select.h
#define FD_SETSIZE __DARWIN_FD_SETSIZE #include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/event.h>
#include <sys/types.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#define BACKLOG 5 //完成三次握手但没有accept的队列的长度
#define CONCURRENT_MAX 8 //应用层同时可以处理的连接
#define SERVER_PORT 11332
#define BUFFER_SIZE 1024
#define QUIT_CMD ".quit"
int client_fds [ CONCURRENT_MAX ];
struct kevent events [ 10 ]; //CONCURRENT_MAX + 2
int main ( int argc , const char * argv [])
{
char input_msg [ BUFFER_SIZE ];
char recv_msg [ BUFFER_SIZE ];
//本地地址
struct sockaddr_in server_addr ;
server_addr . sin_len = sizeof ( struct sockaddr_in );
server_addr . sin_family = AF_INET ;
server_addr . sin_port = htons ( SERVER_PORT );
server_addr . sin_addr . s_addr = inet_addr ( "127.0.0.1" );
bzero ( & ( server_addr . sin_zero ), 8 );
//创建socket
int server_sock_fd = socket ( AF_INET , SOCK_STREAM , 0 );
if ( server_sock_fd == - 1 ) {
perror ( "socket error" );
return 1 ;
}
//绑定socket
int bind_result = bind ( server_sock_fd , ( struct sockaddr * ) & server_addr , sizeof ( server_addr ));
if ( bind_result == - 1 ) {
perror ( "bind error" );
return 1 ;
}
//listen
if ( listen ( server_sock_fd , BACKLOG ) == - 1 ) {
perror ( "listen error" );
return 1 ;
}
struct timespec timeout = { 10 , 0 };
//kqueue
int kq = kqueue ();
if ( kq == - 1 ) {
perror ( "创建kqueue出错! \n " );
exit ( 1 );
}
struct kevent event_change ;
EV_SET ( & event_change , STDIN_FILENO , EVFILT_READ , EV_ADD , 0 , 0 , NULL );
kevent ( kq , & event_change , 1 , NULL , 0 , NULL );
EV_SET ( & event_change , server_sock_fd , EVFILT_READ , EV_ADD , 0 , 0 , NULL );
kevent ( kq , & event_change , 1 , NULL , 0 , NULL );
while ( 1 ) {
int ret = kevent ( kq , NULL , 0 , events , 10 , & timeout );
if ( ret < 0 ) {
printf ( "kevent 出错! \n " );
continue ;
} else if ( ret == 0 ){
printf ( "kenvent 超时! \n " );
continue ;
} else {
//ret > 0 返回事件放在events中
for ( int i = 0 ; i < ret ; i ++ ) {
struct kevent current_event = events [ i ];
//kevent中的ident就是文件描述符
if ( current_event . ident == STDIN_FILENO ) {
//标准输入
bzero ( input_msg , BUFFER_SIZE );
fgets ( input_msg , BUFFER_SIZE , stdin );
//输入 ".quit" 则退出服务器
if ( strcmp ( input_msg , QUIT_CMD ) == 0 ) {
exit ( 0 );
}
for ( int i = 0 ; i < CONCURRENT_MAX ; i ++ ) {
if ( client_fds [ i ] != 0 ) {
send ( client_fds [ i ], input_msg , BUFFER_SIZE , 0 );
}
}
} else if ( current_event . ident == server_sock_fd ){
//有新的连接请求
struct sockaddr_in client_address ;
socklen_t address_len ;
int client_socket_fd = accept ( server_sock_fd , ( struct sockaddr * ) & client_address , & address_len );
if ( client_socket_fd > 0 ) {
int index = - 1 ;
for ( int i = 0 ; i < CONCURRENT_MAX ; i ++ ) {
if ( client_fds [ i ] == 0 ) {
index = i ;
client_fds [ i ] = client_socket_fd ;
break ;
}
}
if ( index >= 0 ) {
EV_SET ( & event_change , client_socket_fd , EVFILT_READ , EV_ADD , 0 , 0 , NULL );
kevent ( kq , & event_change , 1 , NULL , 0 , NULL );
printf ( "新客户端(fd = %d)加入成功 %s:%d \n " , client_socket_fd , inet_ntoa ( client_address . sin_addr ), ntohs ( client_address . sin_port ));
} else {
bzero ( input_msg , BUFFER_SIZE );
strcpy ( input_msg , "服务器加入的客户端数达到最大值,无法加入! \n " );
send ( client_socket_fd , input_msg , BUFFER_SIZE , 0 );
printf ( "客户端连接数达到最大值，新客户端加入失败 %s:%d \n " , inet_ntoa ( client_address . sin_addr ), ntohs ( client_address . sin_port ));
}
}
} else {
//处理某个客户端过来的消息
bzero ( recv_msg , BUFFER_SIZE );
long byte_num = recv (( int ) current_event . ident , recv_msg , BUFFER_SIZE , 0 );
if ( byte_num > 0 ) {
if ( byte_num > BUFFER_SIZE ) {
byte_num = BUFFER_SIZE ;
}
recv_msg [ byte_num ] = '\0' ;
printf ( "客户端(fd = %d):%s \n " ,( int ) current_event . ident , recv_msg );
} else if ( byte_num < 0 ){
printf ( "从客户端(fd = %d)接受消息出错. \n " ,( int ) current_event . ident );
} else {
EV_SET ( & event_change , current_event . ident , EVFILT_READ , EV_DELETE , 0 , 0 , NULL );
kevent ( kq , & event_change , 1 , NULL , 0 , NULL );
close (( int ) current_event . ident );
for ( int i = 0 ; i < CONCURRENT_MAX ; i ++ ) {
if ( client_fds [ i ] == ( int ) current_event . ident ) {
client_fds [ i ] = 0 ;
break ;
}
}
printf ( "客户端(fd = %d)退出了 \n " ,( int ) current_event . ident );
}
}
}
}
}
return 0 ;
} - ( BOOL ) run :( NSError ** ) error {
BOOL successful = YES ;
CFSocketContext socketCtxt = { 0 , self , NULL , NULL , NULL };
_socket = CFSocketCreate ( kCFAllocatorDefault , PF_INET , SOCK_STREAM ,
IPPROTO_TCP ,
kCFSocketAcceptCallBack ,
( CFSocketCallBack ) & SocketConnectionAcceptedCallBack ,
& socketCtxt );
if ( NULL == _socket ) {
if ( nil != error ) {
* error = [[ NSError alloc ]
initWithDomain : ServerErrorDomain
code : kServerNoSocketsAvailable
userInfo: nil ];
}
successful = NO ;
}
if ( YES == successful ) {
// enable address reuse
int yes = 1 ;
setsockopt ( CFSocketGetNative ( _socket ),
SOL_SOCKET , SO_REUSEADDR ,
( void * ) & yes , sizeof ( yes ));
uint8_t packetSize = 128 ;
setsockopt ( CFSocketGetNative ( _socket ),
SOL_SOCKET , SO_SNDBUF ,
( void * ) & packetSize , sizeof ( packetSize ));
setsockopt ( CFSocketGetNative ( _socket ),
SOL_SOCKET , SO_RCVBUF ,
( void * ) & packetSize , sizeof ( packetSize ));
struct sockaddr_in addr4 ;
memset ( & addr4 , 0 , sizeof ( addr4 ));
addr4 . sin_len = sizeof ( addr4 );
addr4 . sin_family = AF_INET ;
addr4 . sin_port = htons ( CHAT_SERVER_PORT );
addr4 . sin_addr . s_addr = htonl ( INADDR_ANY );
NSData * address4 = [ NSData dataWithBytes : & addr4 length : sizeof ( addr4 )];
if ( kCFSocketSuccess != CFSocketSetAddress ( _socket , ( CFDataRef ) address4 )) {
if ( error ) * error = [[ NSError alloc ]
initWithDomain : ServerErrorDomain
code : kServerCouldNotBindToIPv4Address
userInfo: nil ];
if ( _socket ) CFRelease ( _socket );
_socket = NULL ;
successful = NO ;
} else {
// now that the binding was successful, we get the port number
NSData * addr = [( NSData * ) CFSocketCopyAddress ( _socket ) autorelease ];
memcpy ( & addr4 , [ addr bytes ], [ addr length ]);
self . port = ntohs ( addr4 . sin_port );
// 将socket 输入源加入到当前的runloop
CFRunLoopRef cfrl = CFRunLoopGetCurrent ();
CFRunLoopSourceRef source4 = CFSocketCreateRunLoopSource ( kCFAllocatorDefault , _socket , 0 );
CFRunLoopAddSource ( cfrl , source4 , kCFRunLoopDefaultMode );
CFRelease ( source4 );
//标准输入，当在命令行中输入时，回调函数便会被调用
CFFileDescriptorContext context = { 0 , self , NULL , NULL , NULL };
CFFileDescriptorRef stdinFDRef = CFFileDescriptorCreate ( kCFAllocatorDefault , STDIN_FILENO , true , FileDescriptorCallBack , & context );
CFFileDescriptorEnableCallBacks ( stdinFDRef , kCFFileDescriptorReadCallBack );
CFRunLoopSourceRef stdinSource = CFFileDescriptorCreateRunLoopSource ( kCFAllocatorDefault , stdinFDRef , 0 );
CFRunLoopAddSource ( cfrl , stdinSource , kCFRunLoopDefaultMode );
CFRelease ( stdinSource );
CFRelease ( stdinFDRef );
CFRunLoopRun ();
}
}
return successful ;
} static void SocketConnectionAcceptedCallBack ( CFSocketRef socket ,
CFSocketCallBackType type ,
CFDataRef address ,
const void * data , void * info ) {
ChatServer * theChatServer = ( ChatServer * ) info ;
if ( kCFSocketAcceptCallBack == type ) {
// 摘自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. This callback is usable only with listening sockets.
CFSocketNativeHandle nativeSocketHandle = * ( CFSocketNativeHandle * ) data ;
// create the read and write streams for the connection to the other process
CFReadStreamRef readStream = NULL ;
CFWriteStreamRef writeStream = NULL ;
CFStreamCreatePairWithSocket ( kCFAllocatorDefault , nativeSocketHandle ,
& readStream , & writeStream );
if ( NULL != readStream && NULL != writeStream ) {
CFReadStreamSetProperty ( readStream ,
kCFStreamPropertyShouldCloseNativeSocket ,
kCFBooleanTrue );
CFWriteStreamSetProperty ( writeStream ,
kCFStreamPropertyShouldCloseNativeSocket ,
kCFBooleanTrue );
NSInputStream * inputStream = ( NSInputStream * ) readStream ; //toll-free bridging
NSOutputStream * outputStream = ( NSOutputStream * ) writeStream ; //toll-free bridging
inputStream . delegate = theChatServer ;
[ inputStream scheduleInRunLoop :[ NSRunLoop currentRunLoop ] forMode : NSDefaultRunLoopMode ];
[ inputStream open ];
outputStream . delegate = theChatServer ;
[ outputStream scheduleInRunLoop :[ NSRunLoop currentRunLoop ] forMode : NSDefaultRunLoopMode ];
[ outputStream open ];
Client * aClient = [[ Client alloc ] init ];
aClient . inputStream = inputStream ;
aClient . outputStream = outputStream ;
aClient . sock_fd = nativeSocketHandle ;
[ theChatServer . clients setValue : aClient
forKey :[ NSString stringWithFormat : @"%d" , inputStream ]];
NSLog ( @"有新客户端(sock_fd=%d)加入" , nativeSocketHandle );
} else {
close ( nativeSocketHandle );
}
if ( readStream ) CFRelease ( readStream );
if ( writeStream ) CFRelease ( writeStream );
}
}
- ( void ) stream :( NSStream * ) stream handleEvent :( NSStreamEvent ) eventCode {
switch ( eventCode ) {
case NSStreamEventOpenCompleted : {
break ;
}
case NSStreamEventHasBytesAvailable : {
Client * client = [ self . clients objectForKey :[ NSString stringWithFormat : @"%d" , stream ]];
NSMutableData * data = [ NSMutableData data ];
uint8_t * buf = calloc ( 128 , sizeof ( uint8_t ));
NSUInteger len = 0 ;
while ([( NSInputStream * ) stream hasBytesAvailable ]) {
len = [( NSInputStream * ) stream read : buf maxLength : 128 ];
if ( len > 0 ) {
[ data appendBytes : buf length : len ];
}
}
free ( buf );
if ([ data length ] == 0 ) {
//客户端退出
NSLog ( @"客户端(sock_fd=%d)退出" , client . sock_fd );
[ self . clients removeObjectForKey :[ NSString stringWithFormat : @"%d" , stream ]];
close ( client . sock_fd );
} else {
NSLog ( @"收到客户端(sock_fd=%d)消息:%@" , client . sock_fd ,[[[ NSString alloc ] initWithData : data encoding : NSUTF8StringEncoding ] autorelease ]);
}
break ;
}
case NSStreamEventHasSpaceAvailable : {
break ;
}
case NSStreamEventEndEncountered : {
break ;
}
case NSStreamEventErrorOccurred : {
break ;
}
default:
break ;
}
} static void FileDescriptorCallBack ( CFFileDescriptorRef f ,
CFOptionFlags callBackTypes ,
void * info ){
int fd = CFFileDescriptorGetNativeDescriptor ( f );
ChatServer * theChatServer = ( ChatServer * ) info ;
if ( fd == STDIN_FILENO ) {
NSData * inputData = [[ NSFileHandle fileHandleWithStandardInput ] availableData ];
NSString * inputString = [[[ NSString alloc ] initWithData : inputData encoding : NSUTF8StringEncoding ] autorelease ];
NSLog ( @"准备发送消息:%@" , inputString );
for ( Client * client in [ theChatServer . clients allValues ]) {
[ client . outputStream write :[ inputData bytes ] maxLength :[ inputData length ]];
}
//处理完数据之后必须重新Enable 回调函数
CFFileDescriptorEnableCallBacks ( f , kCFFileDescriptorReadCallBack );
}
}
