linux下tcp源代码:Linux下各类TCP网络服务器的实现源代码

大家都知道各类网络服务器编写步骤并且都知道网络服务器就两大类:循环服务和并发服务这里附上源代码来个小结吧

首先循环网络服务器编程实现步骤是这样:

建立(这里用到及sockopt)
|
|
\|/
把和IP地址及端口绑定(这里用到bind)
|
|
\|/
开始监听(这里用到listen)
|
|
/\
/ \
\ / \
----------------------- | 有连接|
| / \ /
| \ /
| \ /
| |
| 接受新连接(这里用到accept)
| | /___________________________________________________
| | \ |
| \|/ |
| 从连接里读取数据(这里用到recv系统当然也可以是read) |
| | |
| | |
| \|/ |
| 返回信息给连接(这里用到send系统当然也可以是write函 数) |
| | |
| | |
| /\ |
| / \ |
| / \ |
| | 还有数据 |-Y-------------------------------------------------------
| \ /
| \ /
| \ /
|________________|

这种服务器模型是典型循环服务如果不加上多进程/线程技术此种服务吞吐量有限大家都可以看到如果前个连接服务数据没有收发完毕后面连接没办法处理所以般有多进程技术对个新连接启用个新进程去处理而监听继续监听

/************有关本文档********************************************
*filename: Linux下各类TCP网络服务器实现源代码
*purpose: 记录Linux下各类tcp服务源代码
*wrote by: zhoula(zhoul[email protected]) 周立发(http://zhoula.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-04 22:00:00
*Note: 任何人可以任意复制代码并运用这些文档当然包括你商业用途
* 但请遵循GPL
*Hope:希望越来越多人贡献自己力量为科学技术发展出力
*********************************************************************/

个循环TCP服务源代码(用fork进行多进程服务了所以这种服务现实中也有用)如下:
/*----------------------源代码开始--------------------------------------------*/
# <stdio.h>
# <stdlib.h>
# <errno.h>
# <.h>
# <sys/types.h>
# <netinet/in.h>
# <sys/.h>
# <sys/wait.h>
/*********************************************************************
*filename: cycletcpserver.c
*purpose: 循环tcp服务端
*tidied by: zhoula(zhoul[email protected]) 周立发(http://zhoula.bokee.com)
Linux爱好者Linux知识传播者SOHO族开发者最擅长C语言
*date time:2006-07-04 22:00:00
*Note: 任何人可以任意复制代码并运用这些文档当然包括你商业用途
* 但请遵循GPL
*Thanks to: Google.com
*********************************************************************/
( argc, char ** argv)
{
sockfd,_fd; /* 监听: sock_fd,数据传输: _fd */
struct sockaddr_in my_addr; /* 本机地址信息*/
struct sockaddr_in their_addr; /* 客户地址信息*/
unsigned sin_size, myport, lisnum;

(argv[1]) myport = atoi(argv[1]);//端口
myport = 7838;

(argv[2]) lisnum = atoi(argv[2]);//监听套接字个数.
lisnum = 2;

((sockfd = (PF_INET, SOCK_STREAM, 0)) -1) { //申请SOCKET
perror("");
exit(1);
}
my_addr.sin_family=PF_INET;
my_addr.sin_port=htons(myport);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero), 0);
(bind(sockfd, (struct sockaddr *)&my_addr, (struct sockaddr)) -1) {//绑定IP,PORT
perror("bind");
exit(1);
}

/* listen( SOCKET s, backlog );
服务可以listen使其流套接字s处于监听状态处于监听状态流套接字s将维护个客户连接请求队列该队列最多容纳backlog个客户连接请求假如该执行成功则返回；如果执行失败则返回SOCKET_ERROR*/
(listen(sockfd, lisnum) -1) {
perror("listen");
exit(1);
}
while(1) {
sin_size = (struct sockaddr_in);
((_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) -1) {//接受请求
perror("accept");
continue;
}
prf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));
(!fork) { /* 子进程代码段*/
(send(_fd, "Hello, world!\n", 14, 0) -1) { //发送
perror("send");
close(_fd);
exit(0);
}
}
close(_fd); /*父进程不再需要该*/
waitpid(-1,NULL,WNOHANG);/*等待子进程结束清除子进程所占用资源*/
}
}
/*----------------------源代码结束--------------------------------------------*/




个测试客户端代码如下:
/*----------------------源代码开始--------------------------------------------*/
# <stdio.h>
# <stdlib.h>
# <errno.h>
# <.h>
# <netdb.h>


# <sys/types.h>
# <netinet/in.h>
# <sys/.h>
# MAXDATASIZE 100 /*每次最大数据传输量*/
/*********************************************************************
*filename: cycletcpclient.c
*purpose: 循环tcp客户端
*tidied by: zhoula(zhoul[email protected]) 周立发(http://zhoula.bokee.com)
Linux爱好者Linux知识传播者SOHO族开发者最擅长C语言
*date time:2006-07-04 22:20:00
*Note: 任何人可以任意复制代码并运用这些文档当然包括你商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多人贡献自己力量为科学技术发展出力
*********************************************************************/

( argc, char *argv)
{
sockfd, nums;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in their_addr;
unsigned myport;

(argv[2]) myport = atoi(argv[2]);
myport = 7838;

(argc != 3) {
fprf(stderr,"usage: %s hostname port\n", argv[0]);
exit(1);
}
((he=gethostbyname(argv[1]))NULL) {//服务器标识
herror("gethostbyname");
exit(1);
}
((sockfd = (PF_INET, SOCK_STREAM, 0)) -1) {//申请SOCKET
perror("");
exit(1);
}
their_addr.sin_family=PF_INET;
their_addr.sin_port=htons(myport);
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
bzero(&(their_addr.sin_zero),0);
(connect(sockfd, (struct sockaddr *)&their_addr, (struct sockaddr)) -1) {//连接服务器
perror("connect");
exit(1);
}
((nums=recv(sockfd, buf, MAXDATASIZE, 0)) -1) {
perror("recv");
exit(1);
}
buf[nums] = 0;
prf("Received: %s\n",buf);
close(sockfd);
0;
}
/*----------------------源代码结束--------------------------------------------*/

用gcc cycletcpserver.c -o tcpserver和gcc cycletcpclient.c -o tcpclient分别编译上述代码后运行情况如下:
服务端运行显示:
administrator@ubuzlf:/data/example/c$ ./tcpserver
server: got connection from 127.0.0.1
server: got connection from 127.0.0.1
server: got connection from 127.0.0.1

客户端运行显示:
administrator@ubuzlf:/data/example/c$ ./tcpclient 127.0.0.1 7838
Received: Hello, world!

administrator@ubuzlf:/data/example/c$ ./tcpclient 127.0.0.1 7838
Received: Hello, world!

administrator@ubuzlf:/data/example/c$ ./tcpclient 127.0.0.1 7838
Received: Hello, world!



不得不说个概念性问题:阻塞和非阻塞
在阻塞服务中当服务器运行到accept语句而没有客户连接服务请求到来那么会发生什么情况?这时服务器就会停止在accept语句上等待连接服务请求到来；同样当运行到接收数据语句recv时如果没有数据可以读取则同样会停止在接收语句上这种情况称为阻塞(blocking)
但如果你希望服务器仅仅注意检查是否有客户在等待连接有就接受连接;否则就继续做其他事情则可以通过将 设置为非阻塞方式来实现:非阻塞在没有客户在等待时就使accept立即返回
通过设置为非阻塞方式可以实现“轮询”若干当企图从个没有数据等待处理非阻塞读入数据时将立即返回并且返回值置为-1并且errno置为EWOULDBLOCK但是这种“轮询”会使CPU处于忙等待方式从而降低性能考虑到这种情况假设你希望服务器监听连接服务请求同时从已经建立连接读取数据你也许会想到用个accept语句和多个recv语句但是由于accept及recv都是会阻塞所以这个想法显然不会成功
非阻塞会大大地浪费系统资源而select会有效地解决这个问题它允许你把进程本身挂起来而同时使系统内核监听所要求组文件描述符任何活动只要确认在任何被监控文件描述符上出现活动select将返回指示该文件描述符已准备好信息从而实现了为进程选出随机变化而不必由进程本身对输入进行测试而浪费CPU开销

其次并发服务器在上述cycletcpserver.c中由于使用了fork技术也可以称的为并发服务器但这种服务器并不是真正意义上IO多路复用并发服务器并且由于没有处理阻塞问题实际应用有各种各样问题

个典型IO多路复用单进程并发服务器流程如下:
/*IO多路复用并发服务流程图*/


下面是个演示IO多路复用源是个端口转发但它用处相当大实际应用中各类代理软件Software或端口映射软件Software都是基于这样代码比如Windows下WinGate、WinProxy等都是在此基础上实现源代码如下:
/*----------------------源代码开始--------------------------------------------*/
# <stdlib.h>
# <stdio.h>
# <unistd.h>
# <sys/time.h>
# <sys/types.h>
# <.h>
# <signal.h>
# <sys/.h>
# <netinet/in.h>
# <arpa/inet.h>
# <errno.h>


forward_port;

#undef max
# max(x,y) ((x) > (y) ? (x) : (y))

/*************************有关本文档************************************


*filename: tcpforwardport.c
*purpose: 演示了select使用方法这是个极好代理软件Software核心专门作端口映射用
*tidied by: zhoula(zhoul[email protected]) 周立发(http://zhoula.bokee.com)
Linux爱好者Linux知识传播者SOHO族开发者最擅长C语言
*date time:2006-07-05 19:00:00
*Note: 任何人可以任意复制代码并运用这些文档当然包括你商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tutman手册里提供了这份源代码
*Hope:希望越来越多人贡献自己力量为科学技术发展出力
*********************************************************************/

listen_ ( listen_port) {
struct sockaddr_in a;
s;
yes;
((s = (AF_INET, SOCK_STREAM, 0)) < 0) {//申请SOCKET
perror ("");
-1;
}
yes = 1;
(sockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, (yes)) <
0) {
perror ("sockopt");
close (s);
-1;
}
mem (&a, 0, (a));
a.sin_port = htons (listen_port);
a.sin_family = AF_INET;
(bind(s, (struct sockaddr *) &a, (a)) < 0) { //绑定IP,PORT
perror ("bind");
close (s);
-1;
}
prf ("accepting connections _disibledevent=>perror ("");
close (s);
-1;
}

mem (&a, 0, (a));
a.sin_port = htons (connect_port);
a.sin_family = AF_INET;

(!inet_aton(address, (struct in_addr *) &a.sin_addr.s_addr)) {//检查IP格式是否
perror ("bad IP address format");
close (s);
-1;
}

(connect(s, (struct sockaddr *) &a, (a)) < 0) {//连接
perror ("connect");
shutdown (s, SHUT_RDWR);
close (s);
-1;
}
s;
}

# SHUT_FD1 { \
(fd1 >= 0) { \
shutdown (fd1, SHUT_RDWR); \
close (fd1); \
fd1 = -1; \
} \
}

# SHUT_FD2 { \
(fd2 >= 0) { \
shutdown (fd2, SHUT_RDWR); \
close (fd2); \
fd2 = -1; \
} \
}

# BUF_SIZE 1024

( argc, char **argv) {
h;
fd1 = -1, fd2 = -1;
char buf1[BUF_SIZE], buf2[BUF_SIZE];
buf1_avail, buf1_written;
buf2_avail, buf2_written;

(argc != 4) {
fprf (stderr, "Usage\n\tfwd \n");
exit (1);
}

signal (SIGPIPE, SIG_IGN);//信号

forward_port = atoi (argv[2]);//转移后端口

/*建立监听*/
h = listen_ (atoi (argv[1]));
(h < 0) exit (1);

for (;;) {
r, nfds = 0;
fd_ rd, wr, er;
FD_ZERO (&rd);//读句柄集清零
FD_ZERO (&wr);//写句柄集清零
FD_ZERO (&er);//句柄集清零
FD_SET (h, &rd);//监听SOCKET加入读检测集

/*把监听和可读 3个起放入select可读句柄列表里*/
nfds = max (nfds, h);
(fd1 > 0 && buf1_avail < BUF_SIZE) {
FD_SET (fd1, &rd);
nfds = max (nfds, fd1);
}
(fd2 > 0 && buf2_avail < BUF_SIZE) {
FD_SET (fd2, &rd);
nfds = max (nfds, fd2);
}

/*把可写两个起放入select可写句柄列表里*/
(fd1 > 0 && buf2_avail - buf2_written > 0) {
FD_SET (fd1, &wr);
nfds = max (nfds, fd1);
}
(fd2 > 0 && buf1_avail - buf1_written > 0) {
FD_SET (fd2, &wr);
nfds = max (nfds, fd2);
}

/*把有异常数据两个起放入select异常句柄列表里*/
(fd1 > 0) {
FD_SET (fd1, &er);
nfds = max (nfds, fd1);
}
(fd2 > 0) {
FD_SET (fd2, &er);
nfds = max (nfds, fd2);
}

/*开始select*/
r = select (nfds + 1, &rd, &wr, &er, NULL);

(r -1 && errno EINTR) continue;
(r < 0) {
perror ("select");
exit (1);
}

/*处理新连接*/
(FD_ISSET (h, &rd)) {//如有连接
unsigned l;
struct sockaddr_in client_address;
mem (&client_address, 0, l = (client_address));//化地址
r = accept (h, (struct sockaddr *)&client_address, &l);//接收连接
(r < 0) {
perror ("accept");
} {
/*关闭原有连接把新连接作为fd1同时连接新目标fd2*/
SHUT_FD1;//关闭读
SHUT_FD2;//关闭写
buf1_avail = buf1_written = 0;
buf2_avail = buf2_written = 0;
fd1 = r;
fd2 = connect_ (forward_port, argv[3]);//连接SOCKET


(fd2 < 0) {
SHUT_FD1;
}
prf ("connect from %s\n", inet_ntoa(client_address.sin_addr));
}
}

/* NB: read oob data before normal reads */
(fd1 > 0)
(FD_ISSET (fd1, &er)) {
char c;
errno = 0;
r = recv (fd1, &c, 1, MSG_OOB);//接收
(r < 1) {
SHUT_FD1;
}
send (fd2, &c, 1, MSG_OOB);//发送
}

(fd2 > 0)
(FD_ISSET (fd2, &er)) {
char c;
errno = 0;
r = recv (fd2, &c, 1, MSG_OOB);
(r < 1) {
SHUT_FD1;
}
send (fd1, &c, 1, MSG_OOB);
}

/* NB: read data from fd1 */
(fd1 > 0)
(FD_ISSET (fd1, &rd)) {
r = read (fd1, buf1 + buf1_avail, BUF_SIZE - buf1_avail);
(r < 1) {
SHUT_FD1;
}
buf1_avail r;
}

/* NB: read data from fd2 */
(fd2 > 0)
(FD_ISSET (fd2, &rd)) {
r = read (fd2, buf2 + buf2_avail, BUF_SIZE - buf2_avail);
(r < 1) {
SHUT_FD2;
}
buf2_avail r;
}

/* NB: write data to fd1 */
(fd1 > 0)
(FD_ISSET (fd1, &wr)) {
r = write (fd1, buf2 + buf2_written, buf2_avail - buf2_written);
(r < 1) {
SHUT_FD1;
}
buf2_written r;
}

/* NB: write data to fd1 */
(fd2 > 0)
(FD_ISSET (fd2, &wr)) {
r = write (fd2, buf1 + buf1_written, buf1_avail - buf1_written);
(r < 1) {
SHUT_FD2;
}
buf1_written r;
}

/* check write data has caught read data */
(buf1_written buf1_avail) buf1_written = buf1_avail = 0;
(buf2_written buf2_avail) buf2_written = buf2_avail = 0;

/* _disibledevent=>SHUT_FD2;
}
(fd2 < 0 && buf2_avail - buf2_written 0) {
SHUT_FD1;
}
}
0;
}
/*----------------------源代码结束--------------------------------------------*/



用gcc tcpforwardport.c -o MyProxy编译此后运行效果如下:
./MyProxy 8000 80 172.16.100.218
accepting connections _disibledevent=>timeout.tv_uec=0;
表示检测在1秒钟内是否有句柄状态发生变化
如果有句柄发生变化就可以用FD_ISSET检测各个句柄比如:
FD_ISSET (fd1, &readfds);//检测是否fd1变成可读了
FD_ISSET (fd2, &writefds);//检测是否fd2变成可写了
示意代码如下:
/*----------------------示意代码开始--------------------------------------------*/
fd1 = ;//创建个
fd2 = ;//创建个
while(1) {
FD_ZERO (&readfds);
FD_ZERO (&writefds);
FD_SET (fd1, &readfds);
FD_SET (fd2, &writefds);
timeout.tv_sec=1;
timeout.tv_uec=0;
ret = select(fd1>fd2?(fd1+1):(fd2+1), &readfds, &writefds, NULL, &timeout);
(ret < 0) {prf("系统select出错代码:%d, 信息:%s", errno, strerror(errno));}
(ret 0) {prf("select超时返回没有任何句柄状态发生变化！");}
//有句柄状态发生了变化
(FD_ISSET(fd1, &readfds)) {
fd1有数据可读;
fd1里数据被读出来;
}
(FD_ISSET(fd2, &writefds)) {
fd2可写;
fd2里发送数据给对方;
}
}
/*----------------------示意代码结束--------------------------------------------*/



经常用到几个自定义:
1、开启监听
/*----------------------源代码代码开始--------------------------------------------*/

OpenSCPServer( port, total, sendbuflen, recvbuflen, blockORnot, reuseORnot) {


/*************************有关本************************************
*function_name: OpenSCPServer
*参数介绍说明:port整数型监听端口号total整数型监听个数sendbuflen整数型发送缓冲区大小
* recvbuflen整数型接收缓冲区大小blockORnot整数型是否阻塞reuseORnot整数型是否端口重用
*purpose: 用来建立个tcp服务端
*tidied by: zhoula(zhoul[email protected]) 周立发(http://zhoula.bokee.com)
Linux爱好者Linux知识传播者SOHO族开发者最擅长C语言
*date time:2006-07-05 20:00:00
*Note: 任何人可以任意复制代码并运用这些文档当然包括你商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tutman手册里提供了这份源代码
*Hope:希望越来越多人贡献自己力量为科学技术发展出力
*Note:要使用此需要自定义个全局变量char errorMessage[1024];并包含GetCurrentTime.h头文件
*********************************************************************/
sockfd = 0, ret = 0, opt = 0, flags=1;
struct sockaddr_in laddr;

ret = sockfd = (PF_INET, SOCK_STREAM, 0);//申请SOCKET
(ret < 0) {
sprf(errorMessage, "OpenTCPServer error! :%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
-1;
}

ret = sockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuseORnot, ());
(ret < 0) {
sprf(errorMessage, "OpenTCPServer sockopt reuse error! :%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
-2;
}

ret = sockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recvbuflen, ());
( ret < 0) {
sprf(errorMessage, "OpenTCPServer sockopt recvbuf error! :%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
-3;
}

ret = sockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sendbuflen, ());
(ret < 0) {
sprf(errorMessage, "OpenTCPServer sockopt sendbuf error! :%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
-4;
}

ioctl(sockfd,FIONBIO,&blockORnot);/*block or not 设置阻塞或非*/

laddr.sin_family = PF_INET;
laddr.sin_port = htons(port);
laddr.sin_addr.s_addr = INADDR_ANY;
bzero(&(laddr.sin_zero), 8);

ret = bind(sockfd, (struct sockaddr *)&laddr, (struct sockaddr));//绑定IP PORT
(ret < 0) {
sprf(errorMessage, "OpenTCPServer bind error! :%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
close(sockfd);
-5;
}
ret = listen(sockfd, total);//监听
(ret < 0) {
sprf(errorMessage, "OpenTCPServer listen error! :%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
close(sockfd);
-6;
}
sprf(errorMessage, "OpenTCPServer opened _disibledevent=>unsigned long addr;
struct sockaddr_in sin;
struct hostent *he;

((he=gethostbyname(serverip)) 0) {
sprf(errorMessage, "ConnectSCPServer IP address '%s' error! :-1 %s", serverip, GetCurrentTime(0, 0));
-1;
}

serversock = (PF_INET, SOCK_STREAM, 0);申请SOCKET
(serversock -1) {
sprf(errorMessage, "ConnectSCPServer error! :-2, errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0, 0));
-2;
}

ioctl(serversock, FIONBIO, &blockORnot); //block or not 设置阻塞或非



mem((char*)&sin, 0, (struct sockaddr_in));
sin.sin_family = PF_INET;
sin.sin_port = htons(serverport);
sin.sin_addr = *((struct in_addr *)he->h_addr);

ret = connect(serversock, (struct sockaddr *)&sin, (sin));//连接

(ret -1) {
sprf(errorMessage, "ConnectSCPServer connect error! :-3, errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0, 0));
close(serversock);
-3;
}

serversock;
}
/*----------------------源代码代码结束--------------------------------------------*/


3、发送数据Send
/*----------------------源代码代码开始--------------------------------------------*/

Send( sock, char * buf, size_t size, flag, timeout) {
/*************************有关本************************************
*function_name: Send
*参数介绍说明:sock整数型buf待发送内容size要发送大小flag发送选项timeout超时时间值
*purpose: 用来通过个在指定时间内发送数据
*tidied by: zhoula(zhoul[email protected]) 周立发(http://zhoula.bokee.com)
Linux爱好者Linux知识传播者SOHO族开发者最擅长C语言
*date time:2006-07-05 20:58:00
*Note: 任何人可以任意复制代码并运用这些文档当然包括你商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tutman手册里提供了这份源代码
*Hope:希望越来越多人贡献自己力量为科学技术发展出力
*Note:要使用此需要自定义个全局变量char errorMessage[1024];并包含自己编写GetCurrentTime.h头文件
*********************************************************************/
i = 0, ret = 0, retry = 0;

struct timeval tival;
fd_ writefds;
maxfds = 0;

tival.tv_sec = timeout;
tival.tv_usec = 0;

FD_ZERO(&writefds); //化写

(sock > 0) {
FD_SET(sock, &writefds);
maxfds=((sock > maxfds)?sock:maxfds);
}
{
sprf(errorMessage, "Send :%d error! :-2 %s", sock, GetCurrentTime(0, 0));
-2;
}

ret = select(maxfds + 1, NULL, &writefds, NULL, &tival); //处理定时时间
(ret <= 0) {
(ret < 0) sprf(errorMessage, "Send :%d select error! :%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));
sprf(errorMessage, "Send :%d select timeout(%d)! %s", sock, timeout, GetCurrentTime(0, 0));
close(sock);
-3;
}
(!(FD_ISSET(sock, &writefds))) {
sprf(errorMessage, "Send :%d not in writefds! %s", sock, GetCurrentTime(0, 0));
close(sock);
-4;
}

while(i < size) {
ret = send(sock, buf + i, size - i, flag);//发送
(ret <= 0) {
sprf(errorMessage, "Send :%d send error! :%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));

(EINTR errno)
(retry < 10) {retry;continue;}
sprf(errorMessage, "Send :%d send error!EINTR 10 times! %s", sock, GetCurrentTime(0, 0));

close(sock);
-1;
}
i ret;
}
sprf(errorMessage, "Send :%d send OK! %d/%d s sent! %s", sock, i, size, GetCurrentTime(0, 0));
i;
}
/*----------------------源代码代码结束--------------------------------------------*/


4、接收数据Recv
/*----------------------源代码代码开始--------------------------------------------*/

Recv( sock, char * buf, size_t size, flag, timeout) {
/*************************有关本************************************
*function_name: Recv
*参数介绍说明:sock整数型buf接收数据缓冲区size要接收数据大小flag接收选项timeout超时时间值
*purpose: 用来从个在指定时间内读取数据
*tidied by: zhoula(zhoul[email protected]) 周立发(http://zhoula.bokee.com)
Linux爱好者Linux知识传播者SOHO族开发者最擅长C语言
*date time:2006-07-05 21:10:00
*Note: 任何人可以任意复制代码并运用这些文档当然包括你商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tutman手册里提供了这份源代码
*Hope:希望越来越多人贡献自己力量为科学技术发展出力
*Note:要使用此需要自定义个全局变量char errorMessage[1024];并包含自己编写GetCurrentTime.h头文件
*********************************************************************/
i = 0, ret = 0, retry = 0;

struct timeval tival;
fd_ readfds;
maxfds = 0;

tival.tv_sec = timeout;
tival.tv_usec = 0;

FD_ZERO(&readfds);

(sock > 0) {
FD_SET(sock, &readfds);
maxfds=((sock > maxfds)?sock:maxfds);
}
{
sprf(errorMessage, "Recv :%d error! :-2 %s", sock, GetCurrentTime(0, 0));


-2;
}

ret = select(maxfds + 1, &readfds, NULL, NULL, &tival); //处理定时时间
(ret <= 0) {
(ret < 0) sprf(errorMessage, "Recv :%d select error! :%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));
sprf(errorMessage, "Recv :%d select timeout(%d)! %s", sock, timeout, GetCurrentTime(0, 0));
close(sock);
-3;
}
(!(FD_ISSET(sock, &readfds))) {
sprf(errorMessage, "Recv :%d not in readfds! %s", sock, GetCurrentTime(0, 0));
close(sock);
-4;
}
while(i < size) {
ret = recv(sock, buf + i, size - i, flag);//接收
(ret <= 0){
sprf(errorMessage, "Recv :%d recv error! :%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));
(errno EINTR)
(retry < 10) {retry;continue;}
sprf(errorMessage, "Recv :%d recv error! EINTR 10 times! %s", sock, GetCurrentTime(0, 0));
close(sock);
-1;
}
i ret;
}
sprf(errorMessage, "Recv :%d recv OK! %d/%d s received! %s", sock, i, size, GetCurrentTime(0, 0));
i;
}

最后需要介绍说明是:我这里讲到源并不能实际地作为个产品来用实际情况下可能会有其它许多工作要做比如可能要建立共享队列来存放里读到消息也可能把发送消息先进行排队然后再Send还有如果不是全数字在发送前定要htonl转换为网络字节序同理接收到后定要先ntohl由网络字节序转换为主机字节序否则对方发送过来0x00000001在你这里可能是0x00010000高低位顺序区别

延伸阅读

• 2011-4-1-- tcp服务器,C#.NET 比较好用的tcp通信模板(服务器端篇)
• 2011-1-18-- tcp服务器,ESBasic 可复用的.NET类库（28） －－ TCP代理服务器 TCPProxy
• 2009-2-12-- solaris服务器:Solaris 10服务器TCP/IP配置实战
• 2009-2-12-- tcpip通信原语:TCP/IP网络重复型服务器通信软件的设计
• 2009-1-15-- vb编程实例:用VB实现客户—服务器(TCP/IP)编程例子
• 2009-2-12-- tcpip通信原语:TCP/IP网络重复型服务器通信软件的设计（c++)
• 2009-1-8-- tcp服务器:创建一个Twisted Reactor TCP服务器
• 2009-2-12-- 邮件服务器源代码:在服务器端得到可编辑Iframe的HTML源代码
• 2008-10-9-- 连接服务器失败:删除注册、连接失败的sqlserver服务器