http://www.linuxeden.com/forum/t146870.html

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

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

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

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

一个循环TCP服务源代码（因为用fork进行多进程服务了，所以这种服务现实中也有用）如下：

/*----------------------源代码开始--------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
/*********************************************************************
*filename: cycletcpserver.c
*purpose: 循环tcp服务端程序
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-04 22:00:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*********************************************************************/
int main(int argc, char ** argv)
{
int sockfd,new_fd; /* 监听socket: sock_fd,数据传输socket: new_fd */
struct sockaddr_in my_addr; /* 本机地址信息 */
struct sockaddr_in their_addr; /* 客户地址信息 */
unsigned int sin_size, myport, lisnum;
if(argv[1])  myport = atoi(argv[1]);
else myport = 7838;
if(argv[2])  lisnum = atoi(argv[2]);
else lisnum = 2;
if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
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);
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
perror("bind");
exit(1);
}
if (listen(sockfd, lisnum) == -1) {
perror("listen");
exit(1);
}
while(1) {
sin_size = sizeof(struct sockaddr_in);
if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
perror("accept");
continue;
}
printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));
if (!fork()) { /* 子进程代码段 */
if (send(new_fd, "Hello, world!\n", 14, 0) == -1) {
perror("send");
close(new_fd);
exit(0);
}
}
close(new_fd); /*父进程不再需要该socket*/
waitpid(-1,NULL,WNOHANG);/*等待子进程结束，清除子进程所占用资源*/
}
}
/*----------------------源代码结束--------------------------------------------*/

一个测试客户端代码如下：

/*----------------------源代码开始--------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define MAXDATASIZE 100 /*每次最大数据传输量 */
/*********************************************************************
*filename: cycletcpclient.c
*purpose: 循环tcp客户端程序
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-04 22:20:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*********************************************************************/
int main(int argc, char *argv[])
{
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in their_addr;
unsigned int myport;
if(argv[2]) myport = atoi(argv[2]);
else myport = 7838;
if (argc != 3) {
fprintf(stderr,"usage: %s hostname port\n", argv[0]);
exit(1);
}
if((he=gethostbyname(argv[1]))==NULL) {
herror("gethostbyname");
exit(1);
}
if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
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);
if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) {
perror("connect");
exit(1);
}
if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1) {
perror("recv");
exit(1);
}
buf[numbytes] = 0;
printf("Received: %s\n",buf);
close(sockfd);
return 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)。
但如果你希望服务器仅仅注意检查是否有客户在等待连接，有就接受连接;否则就继续做其他事情，则可以通过将 socket设置为非阻塞方式来实现:非阻塞socket在没有客户在等待时就使accept调用立即返回 。
通过设置socket为非阻塞方式，可以实现“轮询”若干socket。当企图从一个没有数据等待处理的非阻塞socket读入数据时，函数将立即返回，并且返回值置为-1，并且errno置为EWOULDBLOCK。但是这种“轮询”会使CPU处于忙等待方式，从而降低性能。考虑到这种情况，假设你希望服务器监听连接服务请求的同时从已经建立的连接读取数据，你也许会想到用一个accept语句和多个recv()语句，但是由于accept及recv都是会阻塞的，所以这个想法显然不会成功。
调用非阻塞的socket会大大地浪费系统资源。而调用select()会有效地解决这个问题，它允许你把进程本身挂起来，而同时使系统内核监听所要求的一组文件描述符的任何活动，只要确认在任何被监控的文件描述符上出现活动，select()调用将返回指示该文件描述符已准备好的信息，从而实现了为进程选出随机的变化，而不必由进程本身对输入进行测试而浪费CPU开销。

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

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

下面是一个演示IO多路复用的源程序，是一个端口转发程序，但它的用处相当大，实际应用中的各类代理软件或端口映射软件都是基于这样的代码的，比如Windows下的WinGate、WinProxy等都是在此基础上实现的。源代码如下：

/*----------------------源代码开始--------------------------------------------*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <string.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
static int forward_port;
#undef max
#define max(x,y) ((x) > (y) ? (x) : (y))
/*************************关于本文档************************************
*filename: tcpforwardport.c
*purpose: 演示了select的用法，这是一个极好的代理软件核心，专门作端口映射用
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 19:00:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*********************************************************************/
static int listen_socket (int listen_port) {
struct sockaddr_in a;
int s;
int yes;
if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
return -1;
}
yes = 1;
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof (yes)) <
0) {
perror ("setsockopt");
close (s);
return -1;
}
memset (&a, 0, sizeof (a));
a.sin_port = htons (listen_port);
a.sin_family = AF_INET;
if (bind(s, (struct sockaddr *) &a, sizeof (a)) < 0) {
perror ("bind");
close (s);
return -1;
}
printf ("accepting connections on port %d\n", (int) listen_port);
listen (s, 10);
return s;
}
static int connect_socket (int connect_port, char *address) {
struct sockaddr_in a;
int s;
if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
close (s);
return -1;
}
memset (&a, 0, sizeof (a));
a.sin_port = htons (connect_port);
a.sin_family = AF_INET;
if (!inet_aton(address, (struct in_addr *) &a.sin_addr.s_addr)) {
perror ("bad IP address format");
close (s);
return -1;
}
if (connect(s, (struct sockaddr *) &a, sizeof (a)) < 0) {
perror ("connect()");
shutdown (s, SHUT_RDWR);
close (s);
return -1;
}
return s;
}
#define SHUT_FD1 { \
if (fd1 >= 0) {   \
shutdown (fd1, SHUT_RDWR);  \
close (fd1);  \
fd1 = -1;     \
}   \
}
#define SHUT_FD2 { \
if (fd2 >= 0) {   \
shutdown (fd2, SHUT_RDWR);  \
close (fd2);  \
fd2 = -1;     \
}   \
}
#define BUF_SIZE 1024
int main (int argc, char **argv) {
int h;
int fd1 = -1, fd2 = -1;
char buf1[BUF_SIZE], buf2[BUF_SIZE];
int buf1_avail, buf1_written;
int buf2_avail, buf2_written;
if (argc != 4) {
fprintf (stderr, "Usage\n\tfwd   \n");
exit (1);
}
signal (SIGPIPE, SIG_IGN);
forward_port = atoi (argv[2]);
/*建立监听socket*/
h = listen_socket (atoi (argv[1]));
if (h < 0) exit (1);
for (;;) {
int r, nfds = 0;
fd_set rd, wr, er;
FD_ZERO (&rd);
FD_ZERO (&wr);
FD_ZERO (&er);
FD_SET (h, &rd);
/*把监听socket和可读socket三个一起放入select的可读句柄列表里*/
nfds = max (nfds, h);
if (fd1 > 0 && buf1_avail < BUF_SIZE) {
FD_SET (fd1, &rd);
nfds = max (nfds, fd1);
}
if (fd2 > 0 && buf2_avail < BUF_SIZE) {
FD_SET (fd2, &rd);
nfds = max (nfds, fd2);
}
/*把可写socket两个一起放入select的可写句柄列表里*/
if (fd1 > 0 && buf2_avail - buf2_written > 0) {
FD_SET (fd1, &wr);
nfds = max (nfds, fd1);
}
if (fd2 > 0 && buf1_avail - buf1_written > 0) {
FD_SET (fd2, &wr);
nfds = max (nfds, fd2);
}
/*把有异常数据的socket两个一起放入select的异常句柄列表里*/
if (fd1 > 0) {
FD_SET (fd1, &er);
nfds = max (nfds, fd1);
}
if (fd2 > 0) {
FD_SET (fd2, &er);
nfds = max (nfds, fd2);
}
/*开始select*/
r = select (nfds + 1, &rd, &wr, &er, NULL);
if (r == -1 && errno == EINTR) continue;
if (r < 0) {
perror ("select()");
exit (1);
}
/*处理新连接*/
if (FD_ISSET (h, &rd)) {
unsigned int l;
struct sockaddr_in client_address;
memset (&client_address, 0, l = sizeof (client_address));
r = accept (h, (struct sockaddr *)&client_address, &l);
if (r < 0) {
perror ("accept()");
} else {
/*关闭原有连接，把新连接作为fd1，同时连接新的目标fd2*/
SHUT_FD1;
SHUT_FD2;
buf1_avail = buf1_written = 0;
buf2_avail = buf2_written = 0;
fd1 = r;
fd2 = connect_socket (forward_port, argv[3]);
if (fd2 < 0) {
SHUT_FD1;
} else
printf ("connect from %s\n", inet_ntoa(client_address.sin_addr));
}
}
/* NB: read oob data before normal reads */
if (fd1 > 0)
if (FD_ISSET (fd1, &er)) {
char c;
errno = 0;
r = recv (fd1, &c, 1, MSG_OOB);
if (r < 1) {
SHUT_FD1;
} else
send (fd2, &c, 1, MSG_OOB);
}
if (fd2 > 0)
if (FD_ISSET (fd2, &er)) {
char c;
errno = 0;
r = recv (fd2, &c, 1, MSG_OOB);
if (r < 1) {
SHUT_FD1;
} else
send (fd1, &c, 1, MSG_OOB);
}
/* NB: read data from fd1 */
if (fd1 > 0)
if (FD_ISSET (fd1, &rd)) {
r = read (fd1, buf1 + buf1_avail, BUF_SIZE - buf1_avail);
if (r < 1) {
SHUT_FD1;
} else
buf1_avail += r;
}
/* NB: read data from fd2 */
if (fd2 > 0)
if (FD_ISSET (fd2, &rd)) {
r = read (fd2, buf2 + buf2_avail, BUF_SIZE - buf2_avail);
if (r < 1) {
SHUT_FD2;
} else
buf2_avail += r;
}
/* NB: write data to fd1 */
if (fd1 > 0)
if (FD_ISSET (fd1, &wr)) {
r = write (fd1, buf2 + buf2_written, buf2_avail - buf2_written);
if (r < 1) {
SHUT_FD1;
} else
buf2_written += r;
}
/* NB: write data to fd1 */
if (fd2 > 0)
if (FD_ISSET (fd2, &wr)) {
r = write (fd2, buf1 + buf1_written, buf1_avail - buf1_written);
if (r < 1) {
SHUT_FD2;
} else
buf1_written += r;
}
/* check if write data has caught read data */
if (buf1_written == buf1_avail) buf1_written = buf1_avail = 0;
if (buf2_written == buf2_avail) buf2_written = buf2_avail = 0;
/* one side has closed the connection, keep writing to the other side until empty */
if (fd1 < 0 && buf1_avail - buf1_written == 0) {
SHUT_FD2;
}
if (fd2 < 0 && buf2_avail - buf2_written == 0) {
SHUT_FD1;
}
}
return 0;
}
/*----------------------源代码结束--------------------------------------------*/

用gcc tcpforwardport.c -o MyProxy编译此程序后运行效果如下：

./MyProxy 8000 80 172.16.100.218
accepting connections on port 8000
connect from 127.0.0.1

当有用户访问本机的8000端口时，MyProxy程序将把此请求转发到172.16.100.218主机的80端口，即实现了一个http代理。

关于select函数：
其函数原型为：
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
此函数的功能是由内核检测在timeout时间内，是否有readfds，writefds，exceptfds三个句柄集(file descriptors)里的某个句柄（file descriptor)的状态符合寻求，即readfds句柄集里有句柄可读或writefds句柄集里有可写或exceptfds句柄集里有例外发生，任何一个有变化函数就立即返回，返回值为timeout发生状态变化的句柄个数。
n是所有readfds，writefds，exceptfds三个句柄集(file descriptors)里编号最大值加1。比如：要检测两个socket句柄fd1和fd2在timeout时间内是否分别可读和可写就可以这样：
先把两个句柄集(file descriptors)清零：
        FD_ZERO (&readfds);
        FD_ZERO (&writefds);
然后把fd1加入读检测集：
        FD_SET (fd1, &readfds);
然后把fd2加入写检测集：
        FD_SET (fd2, &writefds);
再给timeout设置值，timeout是这样的一个结构：
              struct timeval {
                  long    tv_sec;         /* seconds */
                  long    tv_usec;        /* microseconds */
              };
你可以这样赋值：
        timeout.tv_sec=1;
        timeout.tv_uec=0;
表示检测在1秒钟内是否有句柄状态发生变化。
如果有句柄发生变化，就可以用FD_ISSET检测各个句柄，比如：
                FD_ISSET (fd1, &readfds);//检测是否fd1变成可读的了
                FD_ISSET (fd2, &writefds);//检测是否fd2变成可写的了
示意程序代码如下：

/*----------------------示意代码开始--------------------------------------------*/
fd1 = socket();//创建一个socket
fd2 = socket();//创建一个socket
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);
if(ret < 0) {printf("系统错误，select出错，错误代码：%d, 错误信息：%s", errno, strerror(errno));}
else if(ret == 0) {printf("select超时返回，没有任何句柄状态发生变化！");}
//有句柄状态发生了变化
if(FD_ISSET(fd1, &readfds)) {
fd1有数据可读;
fd1里的数据被读出来;
}
if(FD_ISSET(fd2, &writefds)) {
fd2可写;
fd2里发送数据给对方;
}
}
/*----------------------示意代码结束--------------------------------------------*/

用gcc tcpforwardport.c -o MyProxy编译此程序后运行效果如下：

./MyProxy 8000 80 172.16.100.218
accepting connections on port 8000
connect from 127.0.0.1

当有用户访问本机的8000端口时，MyProxy程序将把此请求转发到172.16.100.218主机的80端口，即实现了一个http代理。

关于select函数：
其函数原型为：
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
此函数的功能是由内核检测在timeout时间内，是否有readfds，writefds，exceptfds三个句柄集(file descriptors)里的某个句柄（file descriptor)的状态符合寻求，即readfds句柄集里有句柄可读或writefds句柄集里有可写或exceptfds句柄集里有例外发生，任何一个有变化函数就立即返回，返回值为timeout发生状态变化的句柄个数。
n是所有readfds，writefds，exceptfds三个句柄集(file descriptors)里编号最大值加1。比如：要检测两个socket句柄fd1和fd2在timeout时间内是否分别可读和可写就可以这样：
先把两个句柄集(file descriptors)清零：
        FD_ZERO (&readfds);
        FD_ZERO (&writefds);
然后把fd1加入读检测集：
        FD_SET (fd1, &readfds);
然后把fd2加入写检测集：
        FD_SET (fd2, &writefds);
再给timeout设置值，timeout是这样的一个结构：
              struct timeval {
                  long    tv_sec;         /* seconds */
                  long    tv_usec;        /* microseconds */
              };
你可以这样赋值：
        timeout.tv_sec=1;
        timeout.tv_uec=0;
表示检测在1秒钟内是否有句柄状态发生变化。
如果有句柄发生变化，就可以用FD_ISSET检测各个句柄，比如：
                FD_ISSET (fd1, &readfds);//检测是否fd1变成可读的了
                FD_ISSET (fd2, &writefds);//检测是否fd2变成可写的了
示意程序代码如下：

/*----------------------示意代码开始--------------------------------------------*/
fd1 = socket();//创建一个socket
fd2 = socket();//创建一个socket
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);
if(ret < 0) {printf("系统错误，select出错，错误代码：%d, 错误信息：%s", errno, strerror(errno));}
else if(ret == 0) {printf("select超时返回，没有任何句柄状态发生变化！");}
//有句柄状态发生了变化
if(FD_ISSET(fd1, &readfds)) {
fd1有数据可读;
fd1里的数据被读出来;
}
if(FD_ISSET(fd2, &writefds)) {
fd2可写;
fd2里发送数据给对方;
}
}
/*----------------------示意代码结束--------------------------------------------*/

经常用到的几个自定义函数：
1、开启监听的函数

/*----------------------源代码代码开始--------------------------------------------*/
int
OpenSCPServer(int port, int total, int sendbuflen, int recvbuflen, int blockORnot, int reuseORnot)    {
/*************************关于本函数************************************
*function_name: OpenSCPServer
*参数说明：port整数型监听端口号，total整数型监听个数，sendbuflen整数型发送缓冲区大小
*          recvbuflen整数型接收缓冲区大小，blockORnot整数型是否阻塞，reuseORnot整数型是否端口重用
*purpose: 用来建立一个tcp服务端socket
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 20:00:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含GetCurrentTime.h头文件
*********************************************************************/
int    sockfd = 0, ret = 0, opt = 0, flags=1;
struct sockaddr_in    laddr;
ret = sockfd = socket(PF_INET, SOCK_STREAM, 0);
if(ret < 0)    {
sprintf(errorMessage, "OpenTCPServer socket() error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
return -1;
}
ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuseORnot, sizeof(int));
if(ret < 0)    {
sprintf(errorMessage, "OpenTCPServer setsockopt() reuse error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
return -2;
}
ret = setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recvbuflen, sizeof(int));
if ( ret < 0)    {
sprintf(errorMessage, "OpenTCPServer setsockopt() recvbuf error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
return -3;
}
ret = setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sendbuflen, sizeof(int));
if (ret < 0)    {
sprintf(errorMessage, "OpenTCPServer setsockopt() sendbuf error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
return -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, sizeof(struct sockaddr));
if(ret < 0)    {
sprintf(errorMessage, "OpenTCPServer bind() error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
close(sockfd);
return -5;
}
ret = listen(sockfd, total);
if(ret < 0)    {
sprintf(errorMessage, "OpenTCPServer listen() error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));
close(sockfd);
return -6;
}
sprintf(errorMessage, "OpenTCPServer opened on port.%d(%d) OK, socket(%d), buf(%d:%d)! %s", port, total, sockfd, sendbuflen, recvbuflen, GetCurrentTime(0, 0));
return sockfd;
}
/*----------------------源代码代码结束--------------------------------------------*/

2、连接服务器的函数

/*----------------------源代码代码开始--------------------------------------------*/
int
ConnectSCPServer(char * serverip, int serverport, int blockORnot)    {
/*************************关于本函数************************************
*function_name: ConnectSCPServer
*参数说明：serverip服务器IP地址或主机名，serverport服务器端口，blockORnot整数型是否阻塞
*purpose: 用来建立一个tcp客户端socket
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 20:40:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件
*********************************************************************/
int    serversock = 0, ret = 0;
unsigned long    addr;
struct sockaddr_in    sin;
struct hostent *he;
if((he=gethostbyname(serverip))== 0) {
sprintf(errorMessage, "ConnectSCPServer IP address '%s' error! return:-1 %s", serverip, GetCurrentTime(0, 0));
return -1;
}
serversock = socket(PF_INET, SOCK_STREAM, 0);
if(serversock == -1)    {
sprintf(errorMessage, "ConnectSCPServer socket() error! return:-2, errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0, 0));
return -2;
}
ioctl(serversock, FIONBIO, &blockORnot);  //block or not
memset((char*)&sin, 0, sizeof(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, sizeof(sin));
if(ret == -1)    {
sprintf(errorMessage, "ConnectSCPServer connect() error! return:-3, errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0, 0));
close(serversock);
return -3;
}
return serversock;
}
/*----------------------源代码代码结束--------------------------------------------*/

发送数据函数Send

/*----------------------源代码代码开始--------------------------------------------*/
int
Send(int sock, char * buf, size_t size, int flag, int timeout)    {
/*************************关于本函数************************************
*function_name: Send
*参数说明：sock整数型socket，buf待发送的内容，size要发送的大小，flag发送选项，timeout超时时间值
*purpose: 用来通过一个socket在指定时间内发送数据
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 20:58:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件
*********************************************************************/
int i = 0, ret = 0, intretry = 0;
struct timeval tival;
fd_set writefds;
int maxfds = 0;
tival.tv_sec = timeout;
tival.tv_usec = 0;
FD_ZERO(&writefds);
if(sock > 0) {
FD_SET(sock, &writefds);
maxfds=((sock > maxfds)?sock:maxfds);
}
else    {
sprintf(errorMessage, "Send socket:%d error! return:-2 %s", sock, GetCurrentTime(0, 0));
return -2;
}
ret = select(maxfds + 1, NULL, &writefds, NULL, &tival);
if(ret <= 0) {
if(ret < 0)    sprintf(errorMessage, "Send socket:%d select() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));
else sprintf(errorMessage, "Send socket:%d select timeout(%d)! %s", sock, timeout, GetCurrentTime(0, 0));
close(sock);
return -3;
}
if(!(FD_ISSET(sock, &writefds)))    {
sprintf(errorMessage, "Send socket:%d not in writefds! %s", sock, GetCurrentTime(0, 0));
close(sock);
return -4;
}
while(i < size)    {
ret = send(sock, buf + i, size - i, flag);
if(ret <= 0)    {
sprintf(errorMessage, "Send socket:%d send() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));
if (EINTR == errno)
if(intretry < 10)  {intretry++;continue;}
else sprintf(errorMessage, "Send socket:%d send() error!EINTR 10 times! %s", sock, GetCurrentTime(0, 0));
close(sock);
return -1;
}
else i += ret;
}
sprintf(errorMessage, "Send socket:%d send() OK! %d/%d bytes sent! %s", sock, i, size, GetCurrentTime(0, 0));
return i;
}
/*----------------------源代码代码结束--------------------------------------------*/

4、接收数据函数Recv

/*----------------------源代码代码开始--------------------------------------------*/
int
Recv(int sock, char * buf, size_t size, int flag, int timeout)    {
/*************************关于本函数************************************
*function_name: Recv
*参数说明：sock整数型socket，buf接收数据的缓冲区，size要接收数据的大小，flag接收选项，timeout超时时间值
*purpose: 用来从一个socket在指定时间内读取数据
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-05 21:10:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件
*********************************************************************/
int i = 0, ret = 0, intretry = 0;
struct timeval tival;
fd_set readfds;
int maxfds = 0;
tival.tv_sec = timeout;
tival.tv_usec = 0;
FD_ZERO(&readfds);
if(sock > 0) {
FD_SET(sock, &readfds);
maxfds=((sock > maxfds)?sock:maxfds);
}
else    {
sprintf(errorMessage, "Recv socket:%d error! return:-2 %s", sock, GetCurrentTime(0, 0));
return -2;
}
ret = select(maxfds + 1, &readfds, NULL, NULL, &tival);
if(ret <= 0) {
if(ret < 0)    sprintf(errorMessage, "Recv socket:%d select() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));
else sprintf(errorMessage, "Recv socket:%d select timeout(%d)! %s", sock, timeout, GetCurrentTime(0, 0));
close(sock);
return -3;
}
if(!(FD_ISSET(sock, &readfds)))    {
sprintf(errorMessage, "Recv socket:%d not in readfds! %s", sock, GetCurrentTime(0, 0));
close(sock);
return -4;
}
while(i < size)    {
ret = recv(sock, buf + i, size - i, flag);
if(ret <= 0){
sprintf(errorMessage, "Recv socket:%d recv() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));
if(errno == EINTR)
if(intretry < 10)  {intretry++;continue;}
else sprintf(errorMessage, "Recv socket:%d recv() error! EINTR 10 times! %s", sock, GetCurrentTime(0, 0));
close(sock);
return -1;
}
else i += ret;
}
sprintf(errorMessage, "Recv socket:%d recv() OK! %d/%d bytes received! %s", sock, i, size, GetCurrentTime(0, 0));
return i;
}

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

Linux下各类TCP网络服务器的实现源代码相关推荐

  1. linux 网络服务器 源码下载,linux下 各类tcp网络服务器的实现源代码.doc

    linux下 各类tcp网络服务器的实现源代码.doc 还剩 25页未读, 继续阅读 下载文档到电脑,马上远离加班熬夜! 亲,喜欢就下载吧,价低环保! 内容要点: %s", sock, Ge ...

  2. Linux下各类TCP网络服务器的实现源代码 转

    大家都知道各类网络服务器程序的编写步骤,并且都知道网络服务器就两大类:循环服务和并发服务.这里附上源代码来个小结吧. 首先,循环网络服务器编程实现的步骤是这样的: 这种服务器模型是典型循环服务,如果不 ...

  3. Linux 下搭建NFS网络服务器 Win7 下访问挂载

    1. Ubuntu 安装 NFS 服务. apt-get install nfs-kernel-server 2. 修改 NFS 配置文件 #vi /etc/exports 在最后一行添加: /srv ...

  4. Linux下两种TCP网络服务器实现方式：循环服务并发服务

    转载声明:this article is writen by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 以上博客已失效,所以 ...

  5. 1 linux下tcp并发服务器的几种设计的模式套路,Linux下几种并发服务器的实现模式(详解)...

    1>单线程或者单进程 相当于短链接,当accept之后,就开始数据的接收和数据的发送,不接受新的连接,即一个server,一个client 不存在并发. 2>循环服务器和并发服务器 1.循 ...

  6. Linux下简单的邮件服务器搭建

    Linux下简单的邮件服务器搭建 电子邮件服务简介 电子邮件是因特网上最为流行的应用之一,而邮件服务器是一种用来负责电子邮件收发管理的设备,它构成了电子邮件系统的核心. 电子邮件系统的组成  MUA( ...

  7. linux守护进程中多线程实现,Linux下实现多线程客户/服务器

    在传统的Unix模型中,当一个进程需要由另一个实体执行某件事时,该进程派生(fork)一个子进程,让子进程去进行处理. Unix下的大多数网络服务器程序都是这么编写的,即父进程接受连接,派生子进程,子 ...

  8. linux下构建Zabbix网络监控平台

    linux下构建Zabbix网络监控平台 由于图片过多,本人不想一张一张上传,请下载我的详细文章: linux下构建zabbix网络监控平台[技术文档](河南-清小小)-下载地址: http://do ...

  9. Linux下基于TCP的简易文件传输（socket编程）

    Linux下基于TCP的简易文件传输(socket编程) OSI和TCP/IP: 关于TCP/IP协议 关于TCP协议 TCP编程的一般步骤[^2] TCP文件传输实现 功能概述 服务器编程 客户端编 ...

最新文章

  1. 还原软件实施更安全防护机器狗
  2. js基础---object对象
  3. mysql物理优化_mysql物理优化器代价模型分析【原创】
  4. MySQL—事务及其特征
  5. cognos10 安装部署
  6. 简单选择排序验证性实验
  7. C语言回调函数callback
  8. 图解：如何在LINUX中安装VM-Tools
  9. kafka生产者发送消息提升效率策略设置
  10. 2017会考计算机知识点,高中物理会考知识点考点归纳2017
  11. 抖音康辉机器人_新闻联播主持康辉玩抖音，卖萌耍宝样样精通，观众为其点赞...
  12. bat脚本执行sql脚本
  13. 小米9/9 SE于3月19日开放购买!雷军：螺丝刀已备好，百万出货
  14. 解决vps上的ssh掉线------tmux
  15. 区块链开发之BTC离线签名
  16. Win7高级应用技巧
  17. 测试时代新推出《测试员》特刊之软件测试基础
  18. Java在Quant应用_GitHub - tigerfintech/tiger_quant: Java 实盘量化框架
  19. 淘宝新店引流方法在这里！
  20. symfony入门学习资料之十六：Symfony框架启动过程介绍

热门文章

  1. jsp java乱码转换_Java Web 编码问题一：jsp的编码问题
  2. pythonclass全局变量_Python-多处理全局变量更新未返回给父级
  3. 从0到1 html5 canvas,Html5 Canvas学习之路（五）
  4. 4蓝图遍历actor_【虚幻4笔记15】浮动平台
  5. Linux 进程及进程之间的通信机制——管道
  6. C语言实现大数运算（长整数的加、减、乘、除）
  7. linux查看流量开源,Linux流量监控工具 - iftop
  8. 剑指offer：面试题06. 从尾到头打印链表
  9. 基于mybatis声明SQL Session对象
  10. 关于hp惠普笔记本电脑清洗（真的要水洗哟）