Chinaunix

标题: Linux网络编程一步一步学-IPv6下网络编程步骤 [打印本页]

作者: zhoulifa 时间: 2007-01-29 13:31
标题: Linux网络编程一步一步学-IPv6下网络编程步骤
大家都知道，随着互联网上主机数量的增多，现有的32位IP地址已经不够用了，所以推出了下一代IP地址IPv6，写网络程序的要稍微改变一下现有的网络程序适应IPv6网络是相当容易的事。
对于我们来说就是IP地址变化了，所以程序里在用到IP地址的地方做相应的改变就可以了。

记住：主要是改变程序里设置IP地址和端口等部分的代码。

服务器端源代码如下：

#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>
#include <unistd.h>
#include <arpa/inet.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: ipv6-server.c
*purpose: 演示最基本的IPv6网络编程步骤，开启服务接收客户端连接并和客户端通信，互相收发消息
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-29 13:06
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
/* struct sockaddr_in my_addr, their_addr; */ // IPv4
struct sockaddr_in6 my_addr, their_addr; // IPv6
unsigned int myport, lisnum;
char buf[MAXBUF + 1];
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) { */ // IPv4
if ((sockfd = socket(PF_INET6, SOCK_STREAM, 0)) == -1) { // IPv6
perror("socket");
exit(1);
} else
printf("socket created\n");
bzero(&my_addr, sizeof(my_addr));
/* my_addr.sin_family = PF_INET; */ // IPv4
my_addr.sin6_family = PF_INET6; // IPv6
/* my_addr.sin_port = htons(myport); */ // IPv4
my_addr.sin6_port = htons(myport); // IPv6
if (argv[3])
/* my_addr.sin_addr.s_addr = inet_addr(argv[3]); */ // IPv4
inet_pton(AF_INET6, argv[3], &my_addr.sin6_addr); // IPv6
else
/* my_addr.sin_addr.s_addr = INADDR_ANY; */ // IPv4
my_addr.sin6_addr = in6addr_any; // IPv6
/* if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) */ // IPv4
if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr_in6)) // IPv6
== -1) {
perror("bind");
exit(1);
} else
printf("binded\n");
if (listen(sockfd, lisnum) == -1) {
perror("listen");
exit(1);
} else
printf("begin listen\n");
while (1) {
len = sizeof(struct sockaddr);
if ((new_fd =
accept(sockfd, (struct sockaddr *) &their_addr,
&len)) == -1) {
perror("accept");
exit(errno);
} else
printf("server: got connection from %s, port %d, socket %d\n",
/* inet_ntoa(their_addr.sin_addr), */ // IPv4
inet_ntop(AF_INET6, &their_addr.sin6_addr, buf, sizeof(buf)), // IPv6
/* ntohs(their_addr.sin_port), new_fd); */ // IPv4
their_addr.sin6_port, new_fd); // IPv6
/* 开始处理每个新连接上的数据收发 */
bzero(buf, MAXBUF + 1);
strcpy(buf,
"这是在连接建立成功后向客户端发送的第一个消息\n只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息\n");
/* 发消息给客户端 */
len = send(new_fd, buf, strlen(buf), 0);
if (len < 0) {
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buf, errno, strerror(errno));
} else
printf("消息'%s'发送成功，共发送了%d个字节！\n",
buf, len);
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
len = recv(new_fd, buf, MAXBUF, 0);
if (len > 0)
printf("接收消息成功:'%s'，共%d个字节的数据\n",
buf, len);
else
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
/* 处理每个新连接上的数据收发结束 */
}
close(sockfd);
return 0;
}

复制代码

每行程序后面的 “//IPv4” 表示这行代码是在IPv4网络里用的
而“//IPv6” 表示这行代码是在IPv6网络里用的，比较一下，会很容易看到差别的。

客户端源代码如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: ipv6-client.c
*purpose: 演示最基本的IPv6网络编程步骤，这是个客户端程序，与服务器互相收发消息
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-29 12:56
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, len;
/* struct sockaddr_in dest; */ // IPv4
struct sockaddr_in6 dest; // IPv6
char buffer[MAXBUF + 1];
if (argc != 3) {
printf
("参数格式错误！正确用法如下：\n\t\t%s IP地址端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
/* if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { */ // IPv4
if ((sockfd = socket(AF_INET6, SOCK_STREAM, 0)) < 0) { // IPv6
perror("Socket");
exit(errno);
}
printf("socket created\n");
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
/* dest.sin_family = AF_INET; */ // IPv4
dest.sin6_family = AF_INET6; // IPv6
/* dest.sin_port = htons(atoi(argv[2])); */ // IPv4
dest.sin6_port = htons(atoi(argv[2])); // IPv6
/* if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) { */ // IPv4
if ( inet_pton(AF_INET6, argv[1], &dest.sin6_addr) < 0 ) { // IPv6
perror(argv[1]);
exit(errno);
}
printf("address created\n");
/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
printf("server connected\n");
/* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
bzero(buffer, MAXBUF + 1);
/* 接收服务器来的消息 */
len = recv(sockfd, buffer, MAXBUF, 0);
if (len > 0)
printf("接收消息成功:'%s'，共%d个字节的数据\n",
buffer, len);
else
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
bzero(buffer, MAXBUF + 1);
strcpy(buffer, "这是客户端发给服务器端的消息\n");
/* 发消息给服务器 */
len = send(sockfd, buffer, strlen(buffer), 0);
if (len < 0)
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buffer, errno, strerror(errno));
else
printf("消息'%s'发送成功，共发送了%d个字节！\n",
buffer, len);
/* 关闭连接 */
close(sockfd);
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall ipv6-server.c -o ipv6server
gcc -Wall ipv6-client.c -o ipv6client

你自己的主机有IPv6地址吗？很多人会问，输入ifconfig命令看一下吧：

eth0    链路封装:以太网  硬件地址 00:14:2A:6D:5B:A5
      inet 地址:192.168.0.167  广播:192.168.0.255  掩码:255.255.255.0
      inet6 地址: fe80::214:2aff:fe6d:5ba5/64 Scope:Link
      UP BROADCAST RUNNING MULTICAST  MTU:1500  跃点数:1
      接收数据包:30507 错误:0 丢弃:0 过载:0 帧数:0
      发送数据包:26797 错误:0 丢弃:0 过载:0 载波:0
      碰撞:0 发送队列长度:1000
      接收字节:31461154 (30.0 MiB)  发送字节:4472810 (4.2 MiB)
      中断:185 基本地址:0xe400

lo       链路封装:本地环回
      inet 地址:127.0.0.1  掩码:255.0.0.0
      inet6 地址: ::1/128 Scope:Host
      UP LOOPBACK RUNNING  MTU:16436  跃点数:1
      接收数据包:13 错误:0 丢弃:0 过载:0 帧数:0
      发送数据包:13 错误:0 丢弃:0 过载:0 载波:0
      碰撞:0 发送队列长度:0
      接收字节:1178 (1.1 KiB)  发送字节:1178 (1.1 KiB)

看到“inet6 地址:”这两行了吗？后面就是你的IPv6地址
关于IPv6地址类型，可以参考一下惠普主页上的技术文档资料“IPv6地址类型”

启动服务：
./ipv6server 7838 1
或者加上IP地址启动服务：
./ipv6server 7838 1 fe80::214:2aff:fe6d:5ba5/64

启动客户端测试一下：
./ipv6client ::1/128 7838
或
./ipv6client fe80::214:2aff:fe6d:5ba5/6 7838

[ 本帖最后由 zhoulifa 于 2007-1-29 13:34 编辑 ]

作者: universes 时间: 2007-01-29 15:07
赞一个先！
本人也是搞IPV6的，不过不是开源，在公司做IPV6产品的开发。编写了公司ND（邻居发现）部分的全部代码。
另外修改了TELNET代码以适应IPV6。
感觉IPV6现在还不很成熟，有兴趣的话可以一起交流、学习！

作者: arenxl 时间: 2007-01-29 15:18
以前关注过，不过还是等以后用的时候再继续研究吧。

作者: zhoulifa 时间: 2007-01-29 17:37
to universes:
高人!
你有没有NDP协议rfc文档？还是说NDP目前没有标准，只是大家各自按自己的协议在做？
如果有，可否发一份给我？ zhoulifa@gmail.com
先谢谢了！

作者: fxyxsl 时间: 2007-01-29 17:49
这个和windows环境下有什么不同？

再请教个问题：windows XP环境下如何获取本机的IP地址（IPv6的地址)?我试了很多方法，2003下可以，XP却始终不行～

作者: converse 时间: 2007-01-29 18:13
LZ你好,我看了你发的几个帖子,感觉不错,建议你整理到一个帖子里面这样以后查找方便也便于将你的想法系列化.我给你加原创精华,谢谢.

作者: yingen2006 时间: 2007-01-29 23:00
mark

作者: 大大狗 时间: 2007-01-29 23:45
强人

作者: zhoulifa 时间: 2007-02-03 21:00

原帖由 converse 于 2007-1-29 18:13 发表
LZ你好,我看了你发的几个帖子,感觉不错,建议你整理到一个帖子里面这样以后查找方便也便于将你的想法系列化.我给你加原创精华,谢谢.

作者: converse 时间: 2007-02-03 22:32
>>还请告诉我如何将此全部发到这里。
汗，你就把帖子一个一个的贴在这个帖子里面就好了，我敢打赌会N热门的~~

作者: zw2002 时间: 2007-02-03 22:51
是啊，支持

作者: linternt 时间: 2007-02-03 23:51
现在有代码都实现IPV4和IPV6通用了，支持精神！

作者: zhoulifa 时间: 2007-02-04 12:23

原帖由 converse 于 2007-2-3 22:32 发表
>>还请告诉我如何将此全部发到这里。
汗，你就把帖子一个一个的贴在这个帖子里面就好了，我敢打赌会N热门的~~

那我就当一回搬运工了。不过我觉得这种方式比较那个，好象与咱们信息化时代不太相符哦

作者: converse 时间: 2007-02-04 12:29

原帖由 zhoulifa 于 2007-2-4 12:23 发表

那我就当一回搬运工了。不过我觉得这种方式比较那个，好象与咱们信息化时代不太相符哦

或者在某个帖子里面一次过把所有帖子的链接都放进来，我说的方案都是为了方便别人查看你的帖子罢了。

作者: zhoulifa 时间: 2007-02-04 12:30
标题: Linux网络编程一步一步学-简单客户端编写

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: simple-socket.c
*purpose: 演示最基本的网络编程步骤，这是个客户端程序
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-23 19:41:54
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd;
struct sockaddr_in dest;
char buffer[MAXBUF];
if (argc != 3) {
printf
("参数格式错误！正确用法如下：\n\t\t%s IP地址端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
/* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
bzero(buffer, MAXBUF);
recv(sockfd, buffer, sizeof(buffer), 0);
printf("%s", buffer);
/* 关闭连接 */
close(sockfd);
return 0;
}

复制代码

编译此程序使用如下命令：

gcc -Wall simple-socket.c

运行此程序使用如下命令(假设你的主机上开启了ssh服务)：

./a.out 127.0.0.1 22

其实socket客户端编程相当简单：
第1步：建立一个socket句柄，用socket()函数；
第2步：设定你要连接的服务器的IP地址和端口等信息；
第3步：与服务器建立连接，用connect函数；
第4步：收发消息，用recv(sockfd,...)/send(sockfd,...)或者read(sockfd,...)/write(sockfd,...)都可以；
第5步：通讯结束后关闭连接，用close()函数即可，当然也有人用shutdown()函数。

[ 本帖最后由 zhoulifa 于 2007-2-4 12:48 编辑 ]

作者: zhoulifa 时间: 2007-02-04 12:50
标题: Linux网络编程一步一步学-绑定IP和端口
为了服务器的安全，有些服务器要求客户端只能以指定的IP地址和特定的端口才能连接上来。这就要求我们客户端连接之前绑定IP地址和端口信息。

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: simple-bind.c
*purpose: 演示最基本的网络编程步骤，这是个客户端程序以固定 IP 和端口连接服务器
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-23 19:51:54
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd;
struct sockaddr_in dest, mine;
char buffer[MAXBUF];
if (argc != 5) {
printf
("参数格式错误！正确用法如下：\n\t\t%s 对方IP地址对方端口本机IP地址本机端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来以本机固定的端口从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
/* 初始化自己的地址和端口信息 */
bzero(&mine, sizeof(mine));
mine.sin_family = AF_INET;
mine.sin_port = htons(atoi(argv[4]));
if (inet_aton(argv[3], (struct in_addr *) &mine.sin_addr.s_addr) == 0) {
perror(argv[3]);
exit(errno);
}
/* 把自己的 IP 地址信息和端口与 socket 绑定 */
if (bind(sockfd, (struct sockaddr *) &mine, sizeof(struct sockaddr)) ==
-1) {
perror(argv[3]);
exit(errno);
}
/* 以自己特定的端口和IP连接服务器的特定端口 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
/* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
bzero(buffer, MAXBUF);
recv(sockfd, buffer, sizeof(buffer), 0);
printf("%s", buffer);
sleep(10);
/* 关闭连接 */
close(sockfd);
return 0;
}

复制代码

编译程序用此命令：

gcc -Wall simple-bind.c

运行程序用此命令：

./a.out 127.0.0.1 22 127.0.0.1 3000

同时可以用下列netstat命令查看网络连接状态：

netstat -an|grep 3000

查看到如下信息：

tcp 0 0 127.0.0.1:3000 127.0.0.1:22 ESTABLISHED

与前面一份源代码相比，这里多了设置自己的IP地址和端口信息，所以编程过程变成了：
第1步：建立一个socket句柄，用socket()函数；
第2步：设定你要连接的服务器的IP地址和端口等信息；
第x步：设定你自己的IP地址和端口等信息与socket绑定，用bind()函数； #与前面相比就是多了这一个步骤
第3步：与服务器建立连接，用connect函数；
第4步：收发消息，用recv(sockfd,...)/send(sockfd,...)或者read(sockfd,...)/write(sockfd,...)都可以；
第5步：通讯结束后关闭连接，用close()函数即可，当然也有人用shutdown()函数。

[ 本帖最后由 zhoulifa 于 2007-2-4 12:55 编辑 ]

作者: zhoulifa 时间: 2007-02-04 12:57
标题: Linux网络编程一步一步学-循环读取服务器上的数据

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAXBUF 10
/************关于本文档********************************************
*filename: simple-readall.c
*purpose: 演示最基本的网络编程，循环读取服务器上发过来的内容，直到读完为止
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-23 20:16:54
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, ret;
struct sockaddr_in dest, mine;
char buffer[MAXBUF + 1];
if (argc != 5) {
printf
("参数格式错误！正确用法如下：\n\t\t%s 对方IP地址对方端口本机IP地址本机端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来以本机固定的端口从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
/* 初始化自己的地址和端口信息 */
bzero(&mine, sizeof(mine));
mine.sin_family = AF_INET;
mine.sin_port = htons(atoi(argv[4]));
if (inet_aton(argv[3], (struct in_addr *) &mine.sin_addr.s_addr) == 0) {
perror(argv[3]);
exit(errno);
}
/* 把自己的 IP 地址信息和端口与 socket 绑定 */
if (bind(sockfd, (struct sockaddr *) &mine, sizeof(struct sockaddr)) ==
-1) {
perror(argv[3]);
exit(errno);
}
/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
/* 接收对方发过来的消息，每次最多接收 MAXBUF 个字节，直到把对方发过来的所有消息接收完毕为止 */
do {
bzero(buffer, MAXBUF + 1);
ret = recv(sockfd, buffer, MAXBUF, 0);
printf("读到%d个字节，它们是:'%s'\n", ret, buffer);
} while (ret == MAXBUF);
/* 关闭连接 */
close(sockfd);
return 0;
}

复制代码

编译程序使用如下命令：

gcc -Wall simple-readall.c

运行程序用如下命令：

./a.out 127.0.0.1 22 127.0.0.1 3000

此程序运行结果如下：

读到10个字节，它们是:'SSH-2.0-Op'
读到10个字节，它们是:'enSSH_4.3p'
读到10个字节，它们是:'2 Debian-5'
读到8个字节，它们是:'ubuntu1
'

注意：如果你运行时程序长久没有退出，请把程序的第一行：

#define MAXBUF 10

稍微改一下，比如改成下面的：

#define MAXBUF 9

再编译运行试试。
为什么？请继续看下一篇文章“设置非阻塞方式”。

作者: zhoulifa 时间: 2007-02-04 13:00
标题: Linux网络编程一步一步学-设置非阻塞方式
[code]
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>

#define MAXBUF 10
/************关于本文档********************************************
*filename: simple-nonblock.c
*purpose: 演示最基本的网络编程，循环读取服务器上发过来的内容，直到读完为止
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-23 20:46:54
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, ret, rcvtm = 0;
struct sockaddr_in dest, mine;
char buffer[MAXBUF + 1];

if (argc != 5) {
      printf
         ("参数格式错误！正确用法如下：\n\t\t%s 对方IP地址对方端口本机IP地址本机端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来以本机固定的端口从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
         argv[0], argv[0]);
      exit(0);
}

/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
      perror("Socket");
      exit(errno);
}

/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
      perror(argv[1]);
      exit(errno);
}

/* 初始化自己的地址和端口信息 */
bzero(&mine, sizeof(mine));
mine.sin_family = AF_INET;
mine.sin_port = htons(atoi(argv[4]));
if (inet_aton(argv[3], (struct in_addr *) &mine.sin_addr.s_addr) == 0) {
      perror(argv[3]);
      exit(errno);
}

/* 把自己的 IP 地址信息和端口与 socket 绑定 */
if (bind(sockfd, (struct sockaddr *) &mine, sizeof(struct sockaddr)) ==
      -1) {
      perror(argv[3]);
      exit(errno);
}

/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
      perror("Connect ");
      exit(errno);
}

/* 设置 socket 属性为非阻塞方式 */
if (fcntl(sockfd, F_SETFL, O_NONBLOCK) == -1) {
      perror("fcntl");
      exit(errno);
}

/* 接收对方发过来的消息，每次最多接收 MAXBUF 个字节，直到把对方发过来的所有消息接收完毕为止 */
do {
   _retry:
      bzero(buffer, MAXBUF + 1);
      ret = recv(sockfd, buffer, MAXBUF, 0);
      if (ret > 0)
         printf("读到%d个字节，它们是:'%s'\n", ret, buffer);

      if (ret < 0) {
         if (errno == EAGAIN) {
            if (rcvtm)
                  break;
            else {
                  printf("数据还未到达！\n");
                  usleep(100000);
                  goto _retry;
            };
         };
         printf("接收出错了！\n");
         perror("recv");
      }
      rcvtm++;
} while (ret == MAXBUF);

/* 关闭连接 */
close(sockfd);
return 0;
}
[code]
编译程序用下列命令：

gcc -Wall simple-nonblock.c

运行程序用下列命令：

./a.out 127.0.0.1 21 127.0.0.1 3000

程序运行输出结果如下：

数据还未到达！
读到10个字节，它们是:'220 (vsFTP'
读到10个字节，它们是:'d 2.0.4)
'

问题：

1、非阻塞是什么？
网络通信有阻塞和非阻塞之分，例如对于接收数据的函数recv：在阻塞方式下，没有数据到达时，即接收不到数据时，程序会停在recv函数这里等待数据的到来；而在非阻塞方式下就不会等，如果没有数据可接收就立即返回-1表示接收失败。
2、什么是errno？
errno是Linux系统下保存当前状态的一个公共变量，当前程序运行时进行系统调用如果出错，则会设置errno为某个值以告诉用户出了什么错误。可以用printf("%d %s\n", errno, strerror(errno));得到具体信息。
3、什么是EAGAIN？
man recv
当recv系统调用返回这个值时表示recv读数据时，对方没有发送数据过来。

作者: zhoulifa 时间: 2007-02-04 13:11
标题: Linux网络编程一步一步学-开启网络监听服务

#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>
#include <unistd.h>
#include <arpa/inet.h>
/************关于本文档********************************************
*filename: simple-listen.c
*purpose: 演示最基本的网络编程步骤，开启服务端的监听，等待客户端来连接
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 12:31:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd;
struct sockaddr_in my_addr;
unsigned int 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);
} else
printf("socket created\n");
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
== -1) {
perror("bind");
exit(1);
} else
printf("binded\n");
if (listen(sockfd, lisnum) == -1) {
perror("listen");
exit(1);
} else
printf("begin listen\n");
sleep(100);
close(sockfd);
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall simple-listen.c

运行程序用如下命令：

./a.out 7838 2

这将在你自己主机的所有IP地址是等待客户端连接。比如你的网卡lo的IP地址127.0.0.1，又比如你的网卡eth0的IP地址192.168.0.100
如果要指定只在某个地址是开启监听服务，可以用下面的命令：

./a.out 7838 2 127.0.0.1

这样，客户端只能通过127.0.0.1的7838端口连接你的程序。
你可以开启一个终端输入telnet 127.0.0.1 7838来测试是否能连接成功。
同时可以用netstat -an|grep 7838命令来查看网络是否连接正常

其实socket服务器端编程也是相当简单的：
第1步：建立一个socket句柄，用socket()函数；
第2步：设定自己服务器的IP地址和端口等信息，是用于让对方连接的；
第3步：把自己的IP地址和端口等信息与socket绑定，用bind()函数；
第4步：开启监听服务，用listen()函数； #至此，客户端已经能连接你这个IP地址和端口了
注：但由于我们还没有接受客户端的连接，没有建立用于消息收发的socket句柄，所以客户端还没法一客户端进行消息收发。

作者: zhoulifa 时间: 2007-02-04 13:19
标题: Linux网络编程一步一步学-接受客户端连接请求

#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>
#include <unistd.h>
#include <arpa/inet.h>
/************关于本文档********************************************
*filename: simple-accept.c
*purpose: 演示最基本的网络编程步骤，开启服务端的监听，并接收每个客户端的连接请求
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 12:41
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int 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);
} else
printf("socket created\n");
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
== -1) {
perror("bind");
exit(1);
} else
printf("binded\n");
if (listen(sockfd, lisnum) == -1) {
perror("listen");
exit(1);
} else
printf("begin listen\n");
while (1) {
len = sizeof(struct sockaddr);
if ((new_fd =
accept(sockfd, (struct sockaddr *) &their_addr,
&len)) == -1) {
perror("accept");
exit(errno);
} else
printf("server: got connection from %s, port %d, socket %d\n",
inet_ntoa(their_addr.sin_addr),
ntohs(their_addr.sin_port), new_fd);
}
close(sockfd);
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall simple-accept.c

运行程序用如下命令：

./a.out 7838 1 127.0.0.1

另外开多几个客户端程序连接上来，
程序输出结果如下：

server: got connection from 127.0.0.1, port 15949, socket 4
server: got connection from 127.0.0.1, port 15950, socket 5
server: got connection from 127.0.0.1, port 15951, socket 6
server: got connection from 127.0.0.1, port 15952, socket 7

与上一篇相比，这里只是增加了accept函数，这个函数会创建一个新的socket句柄，这个句柄才是我们真正可以用来通讯的句柄，即客户端和服务端的消息收发是通过这个accept产生的socket进行的
accpet是一个典型的阻塞函数，即程序会停止在accept函数处直到有客户端连接上来才会返回。

[ 本帖最后由 zhoulifa 于 2007-2-4 13:37 编辑 ]

作者: zhoulifa 时间: 2007-02-04 13:32
标题: Linux网络编程一步一步学-向客户端发送消息

#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>
#include <unistd.h>
#include <arpa/inet.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: simple-send.c
*purpose: 演示最基本的网络编程步骤，开启服务接收客户端连接并向客户端发送消息
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 13:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int myport, lisnum;
char buf[MAXBUF + 1];
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);
} else
printf("socket created\n");
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
== -1) {
perror("bind");
exit(1);
} else
printf("binded\n");
if (listen(sockfd, lisnum) == -1) {
perror("listen");
exit(1);
} else
printf("begin listen\n");
while (1) {
len = sizeof(struct sockaddr);
if ((new_fd =
accept(sockfd, (struct sockaddr *) &their_addr,
&len)) == -1) {
perror("accept");
exit(errno);
} else
printf("server: got connection from %s, port %d, socket %d\n",
inet_ntoa(their_addr.sin_addr),
ntohs(their_addr.sin_port), new_fd);
/* 开始处理每个新连接上的数据收发 */
bzero(buf, MAXBUF + 1);
strcpy(buf,
"这是在连接建立成功后向客户端发送的第一个消息\n只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息\n");
len = send(new_fd, buf, strlen(buf), 0);
if (len < 0) {
printf
("消息'%s'发送失败！错误代码是%d，错误消息是'%s'\n",
buf, errno, strerror(errno));
} else
printf("消息'%s'发送成功，共发送了%d个字节！\n",
buf, len);
/* 处理每个新连接上的数据收发结束 */
}
close(sockfd);
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall simple-send.c

运行程序用如下命令：

./a.out 127.0.0.1 7838 1

程序输出结果如下：

socket created
binded
begin listen
server: got connection from 127.0.0.1, port 13097, socket 4
消息'这是在连接建立成功后向客户端发送的第一个消息
只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息
'发送成功，共发送了227个字节！
server: got connection from 127.0.0.1, port 13099, socket 5
消息'这是在连接建立成功后向客户端发送的第一个消息
只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息
'发送成功，共发送了227个字节！

客户端运行如下命令：

telnet 127.0.0.1 7838

客户端得到输出如下：

Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
这是在连接建立成功后向客户端发送的第一个消息
只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息
Connection closed by foreign host.

注意：只对accpet接收连接请求产生的新的socket句柄进行读写操作！

作者: zhoulifa 时间: 2007-02-04 13:45
标题: Linux网络编程一步一步学-客户端和服务器端互相收发消息
服务器端源代码如下：

#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>
#include <unistd.h>
#include <arpa/inet.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: simple-accept.c
*purpose: 演示最基本的网络编程步骤，开启服务接收客户端连接并和客户端通信，互相收发消息
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 13:26
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int myport, lisnum;
char buf[MAXBUF + 1];
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);
} else
printf("socket created\n");
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
== -1) {
perror("bind");
exit(1);
} else
printf("binded\n");
if (listen(sockfd, lisnum) == -1) {
perror("listen");
exit(1);
} else
printf("begin listen\n");
while (1) {
len = sizeof(struct sockaddr);
if ((new_fd =
accept(sockfd, (struct sockaddr *) &their_addr,
&len)) == -1) {
perror("accept");
exit(errno);
} else
printf("server: got connection from %s, port %d, socket %d\n",
inet_ntoa(their_addr.sin_addr),
ntohs(their_addr.sin_port), new_fd);
/* 开始处理每个新连接上的数据收发 */
bzero(buf, MAXBUF + 1);
strcpy(buf,
"这是在连接建立成功后向客户端发送的第一个消息\n只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息\n");
/* 发消息给客户端 */
len = send(new_fd, buf, strlen(buf), 0);
if (len < 0) {
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buf, errno, strerror(errno));
} else
printf("消息'%s'发送成功，共发送了%d个字节！\n",
buf, len);
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
len = recv(new_fd, buf, MAXBUF, 0);
if (len > 0)
printf("接收消息成功:'%s'，共%d个字节的数据\n",
buf, len);
else
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
/* 处理每个新连接上的数据收发结束 */
}
close(sockfd);
return 0;
}

复制代码

客户端源代码如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: simple-socket.c
*purpose: 演示最基本的网络编程步骤，这是个客户端程序，与服务器互相收发消息
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 13:26
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, len;
struct sockaddr_in dest;
char buffer[MAXBUF + 1];
if (argc != 3) {
printf
("参数格式错误！正确用法如下：\n\t\t%s IP地址端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
printf("socket created\n");
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
printf("address created\n");
/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
printf("server connected\n");
/* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
bzero(buffer, MAXBUF + 1);
/* 接收服务器来的消息 */
len = recv(sockfd, buffer, MAXBUF, 0);
if (len > 0)
printf("接收消息成功:'%s'，共%d个字节的数据\n",
buffer, len);
else
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
bzero(buffer, MAXBUF + 1);
strcpy(buffer, "这是客户端发给服务器端的消息\n");
/* 发消息给服务器 */
len = send(sockfd, buffer, strlen(buffer), 0);
if (len < 0)
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buffer, errno, strerror(errno));
else
printf("消息'%s'发送成功，共发送了%d个字节！\n",
buffer, len);
/* 关闭连接 */
close(sockfd);
return 0;
}

复制代码

编译两个程序用下列命令：

gcc -Wall simple-server.c -o server
gcc -Wall simple-client.c -o client

启动服务端程序用如下命令：

./server 7838 1

启动客户端程序用如下命令：

./client 127.0.0.1 7838

服务端程序运行屏幕输出如下：

socket created
binded
begin listen
server: got connection from 127.0.0.1, port 32537, socket 4
消息'这是在连接建立成功后向客户端发送的第一个消息
只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息
'发送成功，共发送了227个字节！
接收消息成功:'这是客户端发给服务器端的消息
'，共43个字节的数据

客户端程序运行屏幕输出如下：

socket created
address created
server connected
接收消息成功:'这是在连接建立成功后向客户端发送的第一个消息
只能向new_fd这个用accept函数新建立的socket发消息，不能向sockfd这个监听socket发送消息，监听socket不能用来接收或发送消息
'，共227个字节的数据
消息'这是客户端发给服务器端的消息
'发送成功，共发送了43个字节！

注意：这里的recv函数也是一个典型的阻塞函数，如果对方没有发送数据，程序都会停在recv函数处等待直到超时出错时退出。
所以这个例子是个典型的同步通讯程序，即一端发送数据时另一端一定要接收数据，反之亦然。
所以一端是send、recv、recv、send时，另一端一定是recv、send、send、recv

[ 本帖最后由 zhoulifa 于 2007-2-4 13:47 编辑 ]

作者: zhoulifa 时间: 2007-02-04 13:53
标题: Linux网络编程一步一步学-UDP编程介绍
通常我们在说到网络编程时默认是指TCP编程，即用前面提到的socket函数创建一个socket用于TCP通讯，函数参数我们通常填为 SOCK_STREAM。即socket(PF_INET, SOCK_STREAM, 0)，这表示建立一个socket用于流式网络通讯。
通过查看socket的man手册可以看到socket函数的第一个参数的值可以为下面这些值：

Name                            Purpose
PF_UNIX, PF_LOCAL    Local communication
PF_INET                      IPv4 Internet protocols
PF_INET6                      IPv6 Internet protocols
PF_IPX                         IPX - Novell protocols
PF_NETLINK                Kernel user interface device
PF_X25                         ITU-T X.25 / ISO-8208 protocol
PF_AX25                      Amateur radio AX.25 protocol
PF_ATMPVC                   Access to raw ATM PVCs
PF_APPLETALK          Appletalk
PF_PACKET                   Low level packet interface

第二个参数支持下列几种值：

SOCK_STREAM
Provides sequenced, reliable, two-way, connection-based byte streams. An out-of-band data transmission mechanism may be sup‐
ported.

SOCK_DGRAM
Supports datagrams (connectionless, unreliable messages of a fixed maximum length).

SOCK_SEQPACKET
Provides a sequenced, reliable, two-way connection-based data transmission path for datagrams of fixed maximum length; a con‐
sumer is required to read an entire packet with each read system call.

SOCK_RAW
Provides raw network protocol access.

SOCK_RDM
Provides a reliable datagram layer that does not guarantee ordering.

SOCK_PACKET
Obsolete and should not be used in new programs; see packet(7).

从这里可以看出，SOCK_STREAM这种的特点是面向连接的，即每次收发数据之前必须通过connect建立连接，也是双向的，即任何一方都可以收发数据，协议本身提供了一些保障机制保证它是可靠的、有序的，即每个包按照发送的顺序到达接收方。
而SOCK_DGRAM 这种是User Datagram Protocol协议的网络通讯，它是无连接的，不可靠的，因为通讯双方发送数据后不知道对方是否已经收到数据，是否正常收到数据。任何一方建立一个 socket以后就可以用sendto发送数据，也可以用recvfrom接收数据。根本不关心对方是否存在，是否发送了数据。它的特点是通讯速度比较快。大家都知道TCP是要经过三次握手的，而UDP没有。
基于上述不同，UDP和TCP编程步骤也有些不同，如下：

/*********************************************************************
*filename: UDP编程介绍
*purpose: 通过比较UDP和TCP编程对二者编程步骤进行总结说明
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 20:12:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*********************************************************************/

TCP编程的服务器端一般步骤是：

1、创建一个socket，用函数socket()；
2、设置socket属性，用函数setsockopt(); * 可选
3、绑定IP地址、端口等信息到socket上，用函数bind();
4、开启监听，用函数listen()；
5、接收客户端上来的连接，用函数accept()；
6、收发数据，用函数send()和recv()，或者read()和write();
7、关闭网络连接；
8、关闭监听；

TCP编程的客户端一般步骤是：

1、创建一个socket，用函数socket()；
2、设置socket属性，用函数setsockopt();* 可选
3、绑定IP地址、端口等信息到socket上，用函数bind();* 可选
4、设置要连接的对方的IP地址和端口等属性；
5、连接服务器，用函数connect()；
6、收发数据，用函数send()和recv()，或者read()和write();
7、关闭网络连接；

与之对应的UDP编程步骤要简单许多，分别如下：

UDP编程的服务器端一般步骤是：

1、创建一个socket，用函数socket()；
2、设置socket属性，用函数setsockopt();* 可选
3、绑定IP地址、端口等信息到socket上，用函数bind();
4、循环接收数据，用函数recvfrom();
5、关闭网络连接；

UDP编程的客户端一般步骤是：

1、创建一个socket，用函数socket()；
2、设置socket属性，用函数setsockopt();* 可选
3、绑定IP地址、端口等信息到socket上，用函数bind();* 可选
4、设置对方的IP地址和端口等属性;
5、发送数据，用函数sendto();
6、关闭网络连接；

作者: zhoulifa 时间: 2007-02-04 13:59
标题: Linux网络编程一步一步学-UDP方式点对点通讯
UDP通讯服务器端源代码如下：

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <errno.h>
#include <stdlib.h>
#include <arpa/inet.h>
/*********************************************************************
*filename: simple-udpserver.c
*purpose: 基本编程步骤说明，演示了UDP编程的服务器端编程步骤
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 20:22:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
struct sockaddr_in s_addr;
struct sockaddr_in c_addr;
int sock;
socklen_t addr_len;
int len;
char buff[128];
/* 创建 socket , 关键在于这个 SOCK_DGRAM */
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("socket");
exit(errno);
} else
printf("create socket.\n\r");
memset(&s_addr, 0, sizeof(struct sockaddr_in));
/* 设置地址和端口信息 */
s_addr.sin_family = AF_INET;
if (argv[2])
s_addr.sin_port = htons(atoi(argv[2]));
else
s_addr.sin_port = htons(7838);
if (argv[1])
s_addr.sin_addr.s_addr = inet_addr(argv[1]);
else
s_addr.sin_addr.s_addr = INADDR_ANY;
/* 绑定地址和端口信息 */
if ((bind(sock, (struct sockaddr *) &s_addr, sizeof(s_addr))) == -1) {
perror("bind");
exit(errno);
} else
printf("bind address to socket.\n\r");
/* 循环接收数据 */
addr_len = sizeof(c_addr);
while (1) {
len = recvfrom(sock, buff, sizeof(buff) - 1, 0,
(struct sockaddr *) &c_addr, &addr_len);
if (len < 0) {
perror("recvfrom");
exit(errno);
}
buff[len] = '\0';
printf("收到来自%s:%d的消息:%s\n\r",
inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port), buff);
}
return 0;
}

复制代码

客户端源代码如下：

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <errno.h>
#include <stdlib.h>
#include <arpa/inet.h>
/*********************************************************************
*filename: simple-udpclient.c
*purpose: 基本编程步骤说明，演示了UDP编程的客户端编程步骤
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 21:22:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
struct sockaddr_in s_addr;
int sock;
int addr_len;
int len;
char buff[128];
/* 创建 socket , 关键在于这个 SOCK_DGRAM */
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("socket");
exit(errno);
} else
printf("create socket.\n\r");
/* 设置对方地址和端口信息 */
s_addr.sin_family = AF_INET;
if (argv[2])
s_addr.sin_port = htons(atoi(argv[2]));
else
s_addr.sin_port = htons(7838);
if (argv[1])
s_addr.sin_addr.s_addr = inet_addr(argv[1]);
else {
printf("消息必须有一个接收者！\n");
exit(0);
}
/* 发送UDP消息 */
addr_len = sizeof(s_addr);
strcpy(buff, "hello i'm here");
len = sendto(sock, buff, strlen(buff), 0,
(struct sockaddr *) &s_addr, addr_len);
if (len < 0) {
printf("\n\rsend error.\n\r");
return 3;
}
printf("send success.\n\r");
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall simple-udpserver.c -o server
gcc -Wall simple-udpclient.c -o client

运行程序用下列命令：

./server 127.0.0.1 7838
./client 127.0.0.1 7838

作者: zhoulifa 时间: 2007-02-04 14:02
标题: Linux网络编程一步一步学-UDP方式广播通讯
和前一篇文章＜Linux网络编程一步一步学-UDP方式点对点通讯＞一样，只是在客户端源代码里加一行设置socket属性为广播方式即可。
需要加的一句是：

setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &yes, sizeof(yes));

源代码变成下面的：

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <errno.h>
#include <stdlib.h>
#include <arpa/inet.h>
/*********************************************************************
*filename: broadc-udpclient.c
*purpose: 基本编程步骤说明，演示了UDP编程的广播客户端编程步骤
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-24 21:30:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
struct sockaddr_in s_addr;
int sock;
int addr_len;
int len;
char buff[128];
int yes;
/* 创建 socket */
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("socket");
exit(errno);
} else
printf("create socket.\n\r");
/* 设置通讯方式对广播，即本程序发送的一个消息，网络上所有主机均可以收到 */
yes = 1;
setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &yes, sizeof(yes));
/* 唯一变化就是这一点了 */
/* 设置对方地址和端口信息 */
s_addr.sin_family = AF_INET;
if (argv[2])
s_addr.sin_port = htons(atoi(argv[2]));
else
s_addr.sin_port = htons(7838);
if (argv[1])
s_addr.sin_addr.s_addr = inet_addr(argv[1]);
else {
printf("消息必须有一个接收者！\n");
exit(0);
}
/* 发送UDP消息 */
addr_len = sizeof(s_addr);
strcpy(buff, "hello i'm here");
len = sendto(sock, buff, strlen(buff), 0,
(struct sockaddr *) &s_addr, addr_len);
if (len < 0) {
printf("\n\rsend error.\n\r");
return 3;
}
printf("send success.\n\r");
return 0;
}

复制代码

编译这个程序用下列命令：

gcc -Wall broadc-udpclient.c -o client

运行程序用下列命令：

./client 192.168.0.255 7838

就会往192.168.0网络内所有主机发消息。
其它主机如果运行了服务端：
./server 自己的IP地址 7838
则都会收到上述客户端发的消息了。

作者: zhoulifa 时间: 2007-02-04 14:09
标题: Linux网络编程一步一步学-网络广播、组播与单播
这里以下图所示的网络为基础来说明网络通讯的各种方式：

什么是广播？

以前面的文章＜Linux网络编程一步一步学-UDP方式广播通讯＞为例：就是用下列命令在上图所示的主机192.168.100.xa上运行客户端程序：
./client 192.168.100.255 7838
则上图所示网络上的所有主机，只要其IP地址192.168.100.*与网络掩码（比如255.255.255.0）运算得到的子网（比如 192.168.100.0）与192.168.100.xa主机所在的子网是一样的，都会在自己的7838端口收到192.168.xa主机发出来的 UDP消息。消息会被复制并发到每个主机的网卡上去，网卡收到消息后提交给操作系统去处理，操作系统发现有程序在7838端口接收UDP数据则把消息转给相应的程序去处理，如果没有程序接收来自7838端口的UDP消息，则操作系统丢弃该消息。

/*********************************************************************
*filename: Linux网络编程一步一步学-网络广播、组播与单播
*purpose: 说明网络广播、组播与单播
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-25 13:10:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
广播的缺点：不管主机是否有程序接收广播消息，广播消息一定会被网卡收到并提交给操作系统去处理，所以会造成网络上流量增大，对不接收广播消息的主机造成一定的负担。

什么是单播？

以前面的文章＜Linux网络编程一步一步学-客户端和服务器端互相收发消息＞为例：就是用下列命令在上图所示的主机192.168.100.xa上运行客户端程序：
./client 192.168.100.xf 7838
则消息只会从192.168.100.xa主机发到192.168.100.xf主机上，192.168.100.xf主机的网卡收到消息后转给操作系统去处理，操作系统再把此消息转给相应程序去处理，如果没有程序处理就丢弃该包。

TCP方式和UDP方式都可以实现单播。也是大多数情况下网络通讯所采取的方式。

什么是组播？

以后面的文章＜Linux网络编程一步一步学-UDP组播＞为例：就是用下列命令在上图所示的主机192.168.100.xa上运行客户端程序：
./mcastclient 230.1.1.1 7838
则消息只会从192.168.100.xa主机发到加入了组230.1.1.1的主机的7838端口。象广播一样，组播消息一样会被复制发到网络所有主机的网卡上，但只有宣布加入230.1.1.1这个组的主机的网卡才会把数据提交给操作系统去处理。如果没有加入组，则网卡直接将数据丢弃。
要想接收组播消息的主机必须运行命令加入组，如下方式：
./mcastserver 230.1.1.1 7838

注意：按照RFC规定，组播地址范围是D类IP地址，即224.0.0.1-239.255.255.255。
组播IP地址不能用我们平时所有的C类IP地址。

作者: zhoulifa 时间: 2007-02-04 14:17
标题: Linux网络编程一步一步学-UDP组播
组播客户端代码如下：

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BUFLEN 255
/*********************************************************************
*filename: mcastclient.c
*purpose: 演示组播编程的基本步骤，其实这就是一个基本的UDP客户端程序
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-25 13:10:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
struct sockaddr_in peeraddr, myaddr;
int sockfd;
char recmsg[BUFLEN + 1];
unsigned int socklen;
/* 创建 socket 用于UDP通讯 */
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
printf("socket creating error\n");
exit(1);
}
socklen = sizeof(struct sockaddr_in);
/* 设置对方的端口和IP信息 */
memset(&peeraddr, 0, socklen);
peeraddr.sin_family = AF_INET;
if (argv[2])
peeraddr.sin_port = htons(atoi(argv[2]));
else
peeraddr.sin_port = htons(7838);
if (argv[1]) {
/* 注意这里设置的对方地址是指组播地址224.0.0.0-239.255.255.255，而不是对方的实际IP地址 */
if (inet_pton(AF_INET, argv[1], &peeraddr.sin_addr) <= 0) {
printf("wrong group address!\n");
exit(0);
}
} else {
printf("no group address!\n");
exit(0);
}
/* 设置自己的端口和IP信息 */
memset(&myaddr, 0, socklen);
myaddr.sin_family = AF_INET;
if (argv[4])
myaddr.sin_port = htons(atoi(argv[4]));
else
myaddr.sin_port = htons(23456);
if (argv[3]) {
if (inet_pton(AF_INET, argv[3], &myaddr.sin_addr) <= 0) {
printf("self ip address error!\n");
exit(0);
}
} else
myaddr.sin_addr.s_addr = INADDR_ANY;
/* 绑定自己的端口和IP信息到socket上 */
if (bind
(sockfd, (struct sockaddr *) &myaddr,
sizeof(struct sockaddr_in)) == -1) {
printf("Bind error\n");
exit(0);
}
/* 循环接受用户输入的消息发送组播消息 */
for (;;) {
/* 接受用户输入 */
bzero(recmsg, BUFLEN + 1);
if (fgets(recmsg, BUFLEN, stdin) == (char *) EOF)
exit(0);
/* 发送消息 */
if (sendto
(sockfd, recmsg, strlen(recmsg), 0,
(struct sockaddr *) &peeraddr,
sizeof(struct sockaddr_in)) < 0) {
printf("sendto error!\n");
exit(3);
}
printf("'%s' send ok\n", recmsg);
}
}

复制代码

组播服务器端程序源代码为：

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>
#define BUFLEN 255
/*********************************************************************
*filename: mcastserver.c
*purpose: 演示组播编程的基本步骤，组播服务器端，关键在于加入组
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-25 13:20:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
struct sockaddr_in peeraddr;
struct in_addr ia;
int sockfd;
char recmsg[BUFLEN + 1];
unsigned int socklen, n;
struct hostent *group;
struct ip_mreq mreq;
/* 创建 socket 用于UDP通讯 */
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
printf("socket creating err in udptalk\n");
exit(1);
}
/* 设置要加入组播的地址 */
bzero(&mreq, sizeof(struct ip_mreq));
if (argv[1]) {
if ((group = gethostbyname(argv[1])) == (struct hostent *) 0) {
perror("gethostbyname");
exit(errno);
}
} else {
printf
("you should give me a group address, 224.0.0.0-239.255.255.255\n");
exit(errno);
}
bcopy((void *) group->h_addr, (void *) &ia, group->h_length);
/* 设置组地址 */
bcopy(&ia, &mreq.imr_multiaddr.s_addr, sizeof(struct in_addr));
/* 设置发送组播消息的源主机的地址信息 */
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
/* 把本机加入组播地址，即本机网卡作为组播成员，只有加入组才能收到组播消息 */
if (setsockopt
(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq,
sizeof(struct ip_mreq)) == -1) {
perror("setsockopt");
exit(-1);
}
socklen = sizeof(struct sockaddr_in);
memset(&peeraddr, 0, socklen);
peeraddr.sin_family = AF_INET;
if (argv[2])
peeraddr.sin_port = htons(atoi(argv[2]));
else
peeraddr.sin_port = htons(7838);
if (argv[1]) {
if (inet_pton(AF_INET, argv[1], &peeraddr.sin_addr) <= 0) {
printf("Wrong dest IP address!\n");
exit(0);
}
} else {
printf("no group address given, 224.0.0.0-239.255.255.255\n");
exit(errno);
}
/* 绑定自己的端口和IP信息到socket上 */
if (bind
(sockfd, (struct sockaddr *) &peeraddr,
sizeof(struct sockaddr_in)) == -1) {
printf("Bind error\n");
exit(0);
}
/* 循环接收网络上来的组播消息 */
for (;;) {
bzero(recmsg, BUFLEN + 1);
n = recvfrom(sockfd, recmsg, BUFLEN, 0,
(struct sockaddr *) &peeraddr, &socklen);
if (n < 0) {
printf("recvfrom err in udptalk!\n");
exit(4);
} else {
/* 成功接收到数据报 */
recmsg[n] = 0;
printf("peer:%s", recmsg);
}
}
}

复制代码

编译程序用下列命令：

gcc -Wall mcastclient.c -o mcastclient
gcc -Wall mcastserver.c -o mcastserver

运行程序用如下命令：

./mcastserver 230.1.1.1 7838

客户端程序运行命令为：

./mcastclient 230.1.1.1 7838 192.168.100.1 12345

注意组播地址的不同！
不是实际的IP地址，我们的IP地址是C类IP，组播用的D类IP，而且是虚拟出来的，未绑定在任何实际网卡设备上。

作者: zhoulifa 时间: 2007-02-04 14:33
标题: Linux网络编程一步一步学-同步聊天程序
服务器端源代码如下：

#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>
#include <unistd.h>
#include <arpa/inet.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: sync-server.c
*purpose: 演示网络同步通讯，这是服务器端程序
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-25 20:26
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int myport, lisnum;
char buf[MAXBUF + 1];
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);
}
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
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) {
printf
("\n----等待新的连接到来开始新一轮聊天……\n");
len = sizeof(struct sockaddr);
if ((new_fd =
accept(sockfd, (struct sockaddr *) &their_addr,
&len)) == -1) {
perror("accept");
exit(errno);
} else
printf("server: got connection from %s, port %d, socket %d\n",
inet_ntoa(their_addr.sin_addr),
ntohs(their_addr.sin_port), new_fd);
/* 开始处理每个新连接上的数据收发 */
while (1) {
bzero(buf, MAXBUF + 1);
printf("请输入要发送给对方的消息：");
fgets(buf, MAXBUF, stdin);
if (!strncasecmp(buf, "quit", 4)) {
printf("自己请求终止聊天！\n");
break;
}
len = send(new_fd, buf, strlen(buf) - 1, 0);
if (len > 0)
printf
("消息:%s\t发送成功，共发送了%d个字节！\n",
buf, len);
else {
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buf, errno, strerror(errno));
break;
}
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
len = recv(new_fd, buf, MAXBUF, 0);
if (len > 0)
printf
("接收消息成功:'%s'，共%d个字节的数据\n",
buf, len);
else {
if (len < 0)
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
else
printf("对方退出了，聊天终止\n");
break;
}
}
close(new_fd);
/* 处理每个新连接上的数据收发结束 */
}
close(sockfd);
return 0;
}

复制代码

客户端源代码如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAXBUF 1024
/************关于本文档********************************************
// *filename: sync-client.c
*purpose: 演示网络同步通讯，这是客户端程序
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-25 20:32
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, len;
struct sockaddr_in dest;
char buffer[MAXBUF + 1];
if (argc != 3) {
printf
("参数格式错误！正确用法如下：\n\t\t%s IP地址端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
printf("socket created\n");
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
printf("address created\n");
/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
printf("server connected\n");
while (1) {
/* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
bzero(buffer, MAXBUF + 1);
/* 接收服务器来的消息 */
len = recv(sockfd, buffer, MAXBUF, 0);
if (len > 0)
printf("接收消息成功:'%s'，共%d个字节的数据\n",
buffer, len);
else {
if (len < 0)
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
else
printf("对方退出了，聊天终止！\n");
break;
}
bzero(buffer, MAXBUF + 1);
printf("请输入要发送给对方的消息：");
fgets(buffer, MAXBUF, stdin);
if (!strncasecmp(buffer, "quit", 4)) {
printf("自己请求终止聊天！\n");
break;
}
/* 发消息给服务器 */
len = send(sockfd, buffer, strlen(buffer) - 1, 0);
if (len < 0) {
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buffer, errno, strerror(errno));
break;
} else
printf
("消息：%s\t发送成功，共发送了%d个字节！\n",
buffer, len);
}
/* 关闭连接 */
close(sockfd);
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall sync-server.c -o server
gcc -Wall sync-client.c -o client

分别运行这两个程序：

./server 7838 1
./client 127.0.0.1 7838

同步聊天过程如下：

1、服务端程序开启
2、客户端程序开启（即客户端连接服务器）
3、服务器端用户输入消息并发送给客户端
4、客户端收到消息，客户端用户输入消息并发送给服务器端
5、服务器端收到消息，服务器端用户输入消息并发送给客户端
6、任何一方退出当前聊天即终止一次聊天过程
7、服务器端继续等待下一个人连接上来开始新的聊天过程

同步通讯，要求任何一方都必须按照顺序操作，一收一发或一发一收

作者: zhoulifa 时间: 2007-02-04 14:40
标题: Linux网络编程一步一步学-异步通讯聊天程序select
什么是异步通讯？
就是通讯任意一方可以任意发送消息，有消息来到时会收到系统提示去接收消息。

这里要用到select函数。使用步骤如下：

1、设置一个集合变量，用来存放所有要判断的句柄（file descriptors：即我们建立的每个socket、用open打开的每个文件等）
2、把需要判断的句柄加入到集合里
3、设置判断时间
4、开始等待，即select
5、如果在设定的时间内有任何句柄状态变化了就马上返回，并把句柄设置到集合里

服务器端源代码如下：

#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>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <sys/types.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: async-server.c
*purpose: 演示网络异步通讯，这是服务器端程序
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-25 21:22
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int myport, lisnum;
char buf[MAXBUF + 1];
fd_set rfds;
struct timeval tv;
int retval, maxfd = -1;
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);
}
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
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) {
printf
("\n----等待新的连接到来开始新一轮聊天……\n");
len = sizeof(struct sockaddr);
if ((new_fd =
accept(sockfd, (struct sockaddr *) &their_addr,
&len)) == -1) {
perror("accept");
exit(errno);
} else
printf("server: got connection from %s, port %d, socket %d\n",
inet_ntoa(their_addr.sin_addr),
ntohs(their_addr.sin_port), new_fd);
/* 开始处理每个新连接上的数据收发 */
printf
("\n准备就绪，可以开始聊天了……直接输入消息回车即可发信息给对方\n");
while (1) {
/* 把集合清空 */
FD_ZERO(&rfds);
/* 把标准输入句柄0加入到集合中 */
FD_SET(0, &rfds);
maxfd = 0;
/* 把当前连接句柄new_fd加入到集合中 */
FD_SET(new_fd, &rfds);
if (new_fd > maxfd)
maxfd = new_fd;
/* 设置最大等待时间 */
tv.tv_sec = 1;
tv.tv_usec = 0;
/* 开始等待 */
retval = select(maxfd + 1, &rfds, NULL, NULL, &tv);
if (retval == -1) {
printf("将退出，select出错！ %s", strerror(errno));
break;
} else if (retval == 0) {
/* printf
("没有任何消息到来，用户也没有按键，继续等待……\n"); */
continue;
} else {
if (FD_ISSET(0, &rfds)) {
/* 用户按键了，则读取用户输入的内容发送出去 */
bzero(buf, MAXBUF + 1);
fgets(buf, MAXBUF, stdin);
if (!strncasecmp(buf, "quit", 4)) {
printf("自己请求终止聊天！\n");
break;
}
len = send(new_fd, buf, strlen(buf) - 1, 0);
if (len > 0)
printf
("消息:%s\t发送成功，共发送了%d个字节！\n",
buf, len);
else {
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buf, errno, strerror(errno));
break;
}
}
if (FD_ISSET(new_fd, &rfds)) {
/* 当前连接的socket上有消息到来则接收对方发过来的消息并显示 */
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
len = recv(new_fd, buf, MAXBUF, 0);
if (len > 0)
printf
("接收消息成功:'%s'，共%d个字节的数据\n",
buf, len);
else {
if (len < 0)
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
else
printf("对方退出了，聊天终止\n");
break;
}
}
}
}
close(new_fd);
/* 处理每个新连接上的数据收发结束 */
printf("还要和其它连接聊天吗？(no->退出)");
fflush(stdout);
bzero(buf, MAXBUF + 1);
fgets(buf, MAXBUF, stdin);
if (!strncasecmp(buf, "no", 2)) {
printf("终止聊天！\n");
break;
}
}
close(sockfd);
return 0;
}

复制代码

客户端源代码如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#define MAXBUF 1024
/************关于本文档********************************************
// *filename: ssync-client.c
*purpose: 演示网络异步通讯，这是客户端程序
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-25 21:32
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, len;
struct sockaddr_in dest;
char buffer[MAXBUF + 1];
fd_set rfds;
struct timeval tv;
int retval, maxfd = -1;
if (argc != 3) {
printf
("参数格式错误！正确用法如下：\n\t\t%s IP地址端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
printf
("\n准备就绪，可以开始聊天了……直接输入消息回车即可发信息给对方\n");
while (1) {
/* 把集合清空 */
FD_ZERO(&rfds);
/* 把标准输入句柄0加入到集合中 */
FD_SET(0, &rfds);
maxfd = 0;
/* 把当前连接句柄sockfd加入到集合中 */
FD_SET(sockfd, &rfds);
if (sockfd > maxfd)
maxfd = sockfd;
/* 设置最大等待时间 */
tv.tv_sec = 1;
tv.tv_usec = 0;
/* 开始等待 */
retval = select(maxfd + 1, &rfds, NULL, NULL, &tv);
if (retval == -1) {
printf("将退出，select出错！ %s", strerror(errno));
break;
} else if (retval == 0) {
/* printf
("没有任何消息到来，用户也没有按键，继续等待……\n"); */
continue;
} else {
if (FD_ISSET(sockfd, &rfds)) {
/* 连接的socket上有消息到来则接收对方发过来的消息并显示 */
bzero(buffer, MAXBUF + 1);
/* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
len = recv(sockfd, buffer, MAXBUF, 0);
if (len > 0)
printf
("接收消息成功:'%s'，共%d个字节的数据\n",
buffer, len);
else {
if (len < 0)
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
else
printf("对方退出了，聊天终止！\n");
break;
}
}
if (FD_ISSET(0, &rfds)) {
/* 用户按键了，则读取用户输入的内容发送出去 */
bzero(buffer, MAXBUF + 1);
fgets(buffer, MAXBUF, stdin);
if (!strncasecmp(buffer, "quit", 4)) {
printf("自己请求终止聊天！\n");
break;
}
/* 发消息给服务器 */
len = send(sockfd, buffer, strlen(buffer) - 1, 0);
if (len < 0) {
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buffer, errno, strerror(errno));
break;
} else
printf
("消息：%s\t发送成功，共发送了%d个字节！\n",
buffer, len);
}
}
}
/* 关闭连接 */
close(sockfd);
return 0;
}

复制代码

编译用如下命令：

gcc -Wall async-server.c -o server
gcc -Wall async-client.c -o client

运行用如下命令：

./server 7838 1
./client 127.0.0.1 7838

作者: zhoulifa 时间: 2007-02-04 14:51
标题: Linux网络编程一步一步学-编写一个HTTP协议的目录浏览和文件下载服务器
服务器源代码如下：

#include <stdarg.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <resolv.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <signal.h>
#include <getopt.h>
#define DEFAULTIP "127.0.0.1"
#define DEFAULTPORT "80"
#define DEFAULTBACK "10"
#define DEFAULTDIR "/home"
#define DEFAULTLOG "/tmp/das-server.log"
void prterrmsg(char *msg);
#define prterrmsg(msg) { perror(msg); abort(); }
void wrterrmsg(char *msg);
#define wrterrmsg(msg) { fputs(msg, logfp); fputs(strerror(errno), logfp);fflush(logfp); abort(); }
void prtinfomsg(char *msg);
#define prtinfomsg(msg) { fputs(msg, stdout); }
void wrtinfomsg(char *msg);
#define wrtinfomsg(msg) { fputs(msg, logfp); fflush(logfp);}
#define MAXBUF 1024
char buffer[MAXBUF + 1];
char *host = 0;
char *port = 0;
char *back = 0;
char *dirroot = 0;
char *logdir = 0;
unsigned char daemon_y_n = 0;
FILE *logfp;
#define MAXPATH 150
/*----------------------------------------
*--- dir_up - 查找dirpath所指目录的上一级目录
*----------------------------------------
*/
char *dir_up(char *dirpath)
{
static char Path[MAXPATH];
int len;
strcpy(Path, dirpath);
len = strlen(Path);
if (len > 1 && Path[len - 1] == '/')
len--;
while (Path[len - 1] != '/' && len > 1)
len--;
Path[len] = 0;
return Path;
}
/*------------------------------------------------------
*--- AllocateMemory - 分配空间并把d所指的内容复制
*------------------------------------------------------
*/
void AllocateMemory(char **s, int l, char *d)
{
*s = malloc(l + 1);
bzero(*s, l + 1);
memcpy(*s, d, l);
}
/************关于本文档********************************************
*filename: das-server.c
*purpose: 这是在Linux下用C语言写的目录访问服务器，支持目录浏览和文件下载
*wrote by: zhoulifa([email]zhoulifa@163.com[/email]) 周立发([url]http://zhoulifa.bokee.com)[/url]
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-26 19:32
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
/*------------------------------------------------------
*--- GiveResponse - 把Path所指的内容发送到client_sock去
*-------------------如果Path是一个目录，则列出目录内容
*-------------------如果Path是一个文件，则下载文件
*------------------------------------------------------
*/
void GiveResponse(FILE * client_sock, char *Path)
{
struct dirent *dirent;
struct stat info;
char Filename[MAXPATH];
DIR *dir;
int fd, len, ret;
char *p, *realPath, *realFilename, *nport;
/* 获得实际工作目录或文件 */
len = strlen(dirroot) + strlen(Path) + 1;
realPath = malloc(len + 1);
bzero(realPath, len + 1);
sprintf(realPath, "%s/%s", dirroot, Path);
/* 获得实际工作端口 */
len = strlen(port) + 1;
nport = malloc(len + 1);
bzero(nport, len + 1);
sprintf(nport, ":%s", port);
/* 获得实际工作目录或文件的信息以判断是文件还是目录 */
if (stat(realPath, &info)) {
fprintf(client_sock,
"HTTP/1.1 200 OK\r\nServer: DAS by ZhouLifa\r\nConnection: close\r\n\r\n<html><head><title>%d - %s</title></head>"
"<body><font size=+4>Linux 下目录访问服务器</font><br><hr width=\"100%%\"><br><center>"
"<table border cols=3 width=\"100%%\">", errno,
strerror(errno));
fprintf(client_sock,
"</table><font color=\"CC0000\" size=+2>请向管理员咨询为何出现如下错误提示：\n%s %s</font></body></html>",
Path, strerror(errno));
goto out;
}
/* 处理浏览文件请求，即下载文件 */
if (S_ISREG(info.st_mode)) {
fd = open(realPath, O_RDONLY);
len = lseek(fd, 0, SEEK_END);
p = (char *) malloc(len + 1);
bzero(p, len + 1);
lseek(fd, 0, SEEK_SET);
ret = read(fd, p, len);
close(fd);
fprintf(client_sock,
"HTTP/1.1 200 OK\r\nServer: DAS by ZhouLifa\r\nConnection: keep-alive\r\nContent-type: application/*\r\nContent-Length:%d\r\n\r\n",
len);
fwrite(p, len, 1, client_sock);
free(p);
} else if (S_ISDIR(info.st_mode)) {
/* 处理浏览目录请求 */
dir = opendir(realPath);
fprintf(client_sock,
"HTTP/1.1 200 OK\r\nServer: DAS by ZhouLifa\r\nConnection: close\r\n\r\n<html><head><title>%s</title></head>"
"<body><font size=+4>Linux 下目录访问服务器</font><br><hr width=\"100%%\"><br><center>"
"<table border cols=3 width=\"100%%\">", Path);
fprintf(client_sock,
"<caption><font size=+3>目录 %s</font></caption>\n",
Path);
fprintf(client_sock,
"<tr><td>名称</td><td>大小</td><td>修改时间</td></tr>\n");
if (dir == 0) {
fprintf(client_sock,
"</table><font color=\"CC0000\" size=+2>%s</font></body></html>",
strerror(errno));
return;
}
/* 读取目录里的所有内容 */
while ((dirent = readdir(dir)) != 0) {
if (strcmp(Path, "/") == 0)
sprintf(Filename, "/%s", dirent->d_name);
else
sprintf(Filename, "%s/%s", Path, dirent->d_name);
fprintf(client_sock, "<tr>");
len = strlen(dirroot) + strlen(Filename) + 1;
realFilename = malloc(len + 1);
bzero(realFilename, len + 1);
sprintf(realFilename, "%s/%s", dirroot, Filename);
if (stat(realFilename, &info) == 0) {
if (strcmp(dirent->d_name, "..") == 0)
fprintf(client_sock,
"<td><a href=\"http://%s%s%s\">(parent)</a></td>",
host, atoi(port) == 80 ? "" : nport,
dir_up(Path));
else
fprintf(client_sock,
"<td><a href=\"http://%s%s%s\">%s</a></td>",
host, atoi(port) == 80 ? "" : nport, Filename,
dirent->d_name);
if (S_ISDIR(info.st_mode))
fprintf(client_sock, "<td>目录</td>");
else if (S_ISREG(info.st_mode))
fprintf(client_sock, "<td>%d</td>", info.st_size);
else if (S_ISLNK(info.st_mode))
fprintf(client_sock, "<td>链接</td>");
else if (S_ISCHR(info.st_mode))
fprintf(client_sock, "<td>字符设备</td>");
else if (S_ISBLK(info.st_mode))
fprintf(client_sock, "<td>块设备</td>");
else if (S_ISFIFO(info.st_mode))
fprintf(client_sock, "<td>FIFO</td>");
else if (S_ISSOCK(info.st_mode))
fprintf(client_sock, "<td>Socket</td>");
else
fprintf(client_sock, "<td>(未知)</td>");
fprintf(client_sock, "<td>%s</td>", ctime(&info.st_ctime));
}
fprintf(client_sock, "</tr>\n");
free(realFilename);
}
fprintf(client_sock, "</table></center></body></html>");
} else {
/* 既非常规文件又非目录，禁止访问 */
fprintf(client_sock,
"HTTP/1.1 200 OK\r\nServer: DAS by ZhouLifa\r\nConnection: close\r\n\r\n<html><head><title>permission denied</title></head>"
"<body><font size=+4>Linux 下目录访问服务器</font><br><hr width=\"100%%\"><br><center>"
"<table border cols=3 width=\"100%%\">");
fprintf(client_sock,
"</table><font color=\"CC0000\" size=+2>你访问的资源'%s'被禁止访问，请联系管理员解决！</font></body>< /html>",
Path);
}
out:
free(realPath);
free(nport);
}
/*------------------------------------------------------
*--- getoption - 分析取出程序的参数
*------------------------------------------------------
*/
void getoption(int argc, char **argv)
{
int c, len;
char *p = 0;
opterr = 0;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"host", 1, 0, 0},
{"port", 1, 0, 0},
{"back", 1, 0, 0},
{"dir", 1, 0, 0},
{"log", 1, 0, 0},
{"daemon", 0, 0, 0},
{0, 0, 0, 0}
};
/* 本程序支持如一些参数：
* --host IP地址或者 -H IP地址
* --port 端口或者 -P 端口
* --back 监听数量或者 -B 监听数量
* --dir 网站根目录或者 -D 网站根目录
* --log 日志存放路径或者 -L 日志存放路径
* --daemon 使程序进入后台运行模式
*/
c = getopt_long(argc, argv, "H:P:B:D:L",
long_options, &option_index);
if (c == -1 || c == '?')
break;
if(optarg) len = strlen(optarg);
else len = 0;
if ((!c && !(strcasecmp(long_options[option_index].name, "host")))
|| c == 'H')
p = host = malloc(len + 1);
else if ((!c
&&
!(strcasecmp(long_options[option_index].name, "port")))
|| c == 'P')
p = port = malloc(len + 1);
else if ((!c
&&
!(strcasecmp(long_options[option_index].name, "back")))
|| c == 'B')
p = back = malloc(len + 1);
else if ((!c
&& !(strcasecmp(long_options[option_index].name, "dir")))
|| c == 'D')
p = dirroot = malloc(len + 1);
else if ((!c
&& !(strcasecmp(long_options[option_index].name, "log")))
|| c == 'L')
p = logdir = malloc(len + 1);
else if ((!c
&&
!(strcasecmp
(long_options[option_index].name, "daemon")))) {
daemon_y_n = 1;
continue;
}
else
break;
bzero(p, len + 1);
memcpy(p, optarg, len);
}
}
int main(int argc, char **argv)
{
struct sockaddr_in addr;
int sock_fd, addrlen;
/* 获得程序工作的参数，如 IP 、端口、监听数、网页根目录、目录存放位置等 */
getoption(argc, argv);
if (!host) {
addrlen = strlen(DEFAULTIP);
AllocateMemory(&host, addrlen, DEFAULTIP);
}
if (!port) {
addrlen = strlen(DEFAULTPORT);
AllocateMemory(&port, addrlen, DEFAULTPORT);
}
if (!back) {
addrlen = strlen(DEFAULTBACK);
AllocateMemory(&back, addrlen, DEFAULTBACK);
}
if (!dirroot) {
addrlen = strlen(DEFAULTDIR);
AllocateMemory(&dirroot, addrlen, DEFAULTDIR);
}
if (!logdir) {
addrlen = strlen(DEFAULTLOG);
AllocateMemory(&logdir, addrlen, DEFAULTLOG);
}
printf
("host=%s port=%s back=%s dirroot=%s logdir=%s %s是后台工作模式(进程ID：%d)\n",
host, port, back, dirroot, logdir, daemon_y_n?"":"不", getpid());
/* fork() 两次处于后台工作模式下 */
if (daemon_y_n) {
if (fork())
exit(0);
if (fork())
exit(0);
close(0), close(1), close(2);
logfp = fopen(logdir, "a+");
if (!logfp)
exit(0);
}
/* 处理子进程退出以免产生僵尸进程 */
signal(SIGCHLD, SIG_IGN);
/* 创建 socket */
if ((sock_fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
if (!daemon_y_n) {
prterrmsg("socket()");
} else {
wrterrmsg("socket()");
}
}
/* 设置端口快速重用 */
addrlen = 1;
setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &addrlen,
sizeof(addrlen));
addr.sin_family = AF_INET;
addr.sin_port = htons(atoi(port));
addr.sin_addr.s_addr = inet_addr(host);
addrlen = sizeof(struct sockaddr_in);
/* 绑定地址、端口等信息 */
if (bind(sock_fd, (struct sockaddr *) &addr, addrlen) < 0) {
if (!daemon_y_n) {
prterrmsg("bind()");
} else {
wrterrmsg("bind()");
}
}
/* 开启临听 */
if (listen(sock_fd, atoi(back)) < 0) {
if (!daemon_y_n) {
prterrmsg("listen()");
} else {
wrterrmsg("listen()");
}
}
while (1) {
int len;
int new_fd;
addrlen = sizeof(struct sockaddr_in);
/* 接受新连接请求 */
new_fd = accept(sock_fd, (struct sockaddr *) &addr, &addrlen);
if (new_fd < 0) {
if (!daemon_y_n) {
prterrmsg("accept()");
} else {
wrterrmsg("accept()");
}
break;
}
bzero(buffer, MAXBUF + 1);
sprintf(buffer, "连接来自于: %s:%d\n",
inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
if (!daemon_y_n) {
prtinfomsg(buffer);
} else {
wrtinfomsg(buffer);
}
/* 产生一个子进程去处理请求，当前进程继续等待新的连接到来 */
if (!fork()) {
bzero(buffer, MAXBUF + 1);
if ((len = recv(new_fd, buffer, MAXBUF, 0)) > 0) {
FILE *ClientFP = fdopen(new_fd, "w");
if (ClientFP == NULL) {
if (!daemon_y_n) {
prterrmsg("fdopen()");
} else {
prterrmsg("fdopen()");
}
} else {
char Req[MAXPATH + 1] = "";
sscanf(buffer, "GET %s HTTP", Req);
bzero(buffer, MAXBUF + 1);
sprintf(buffer, "请求取文件: \"%s\"\n", Req);
if (!daemon_y_n) {
prtinfomsg(buffer);
} else {
wrtinfomsg(buffer);
}
/* 处理用户请求 */
GiveResponse(ClientFP, Req);
fclose(ClientFP);
}
}
exit(0);
}
close(new_fd);
}
close(sock_fd);
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall das-server.c -o das-server

注：das即 Dictory Access Server

以root用户启动服务程序用下列命令：

./das-server

或以普通用户启动服务程序用下列命令：

./das-server --port 7838

或

./das-server -P 7838

注：只有root用户才有权限启动1024以下的端口，所以如果想用默认的80端口就得用root来运行。

如果要想让程序在后台自动运行，即处理精灵模式下工作，在命令后面加上--daemon参数即可。

打开一个网络浏览器输入服务地址开始浏览，如下图：

下载文件如下图：

注：请不要下载较大的文件，比如文件大小超过10M的，因为程序是一次分配内存，会占用系统内存较大导致系统死掉！

[ 本帖最后由 zhoulifa 于 2007-2-4 14:52 编辑 ]

作者: zhoulifa 时间: 2007-02-04 14:56
标题: Linux网络编程一步一步学-用C自己编写一个telnet服务器
服务器源代码如下：

#include <stdarg.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <resolv.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <signal.h>
#include <getopt.h>
#define DEFAULTIP "127.0.0.1"
#define DEFAULTPORT "23"
#define DEFAULTBACK "10"
#define DEFAULTDIR "/tmp"
#define DEFAULTLOG "/tmp/telnet-server.log"
void prterrmsg(char *msg);
#define prterrmsg(msg) { perror(msg); abort(); }
void wrterrmsg(char *msg);
#define wrterrmsg(msg) { fputs(msg, logfp); fputs(strerror(errno), logfp);fflush(logfp); abort(); }
void prtinfomsg(char *msg);
#define prtinfomsg(msg) { fputs(msg, stdout); }
void wrtinfomsg(char *msg);
#define wrtinfomsg(msg) { fputs(msg, logfp); fflush(logfp);}
#define MAXBUF 1024
char buffer[MAXBUF + 1];
char *host = 0;
char *port = 0;
char *back = 0;
char *dirroot = 0;
char *logdir = 0;
unsigned char daemon_y_n = 0;
FILE *logfp;
#define MAXPATH 150
/*------------------------------------------------------
*--- AllocateMemory - 分配空间并把d所指的内容复制
*------------------------------------------------------
*/
void AllocateMemory(char **s, int l, char *d)
{
*s = malloc(l + 1);
bzero(*s, l + 1);
memcpy(*s, d, l);
}
/************关于本文档*************************************************************
*filename: telnet-server.c
*purpose: 这是在Linux下用C语言写的telnet服务器，没有用户名和密码，直接以开启服务者的身份登录系统
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-27 17:02
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
**********************************************************************************/
/*------------------------------------------------------
*--- getoption - 分析取出程序的参数
*------------------------------------------------------
*/
void getoption(int argc, char **argv)
{
int c, len;
char *p = 0;
opterr = 0;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"host", 1, 0, 0},
{"port", 1, 0, 0},
{"back", 1, 0, 0},
{"dir", 1, 0, 0},
{"log", 1, 0, 0},
{"daemon", 0, 0, 0},
{0, 0, 0, 0}
};
/* 本程序支持如一些参数：
* --host IP地址或者 -H IP地址
* --port 端口或者 -P 端口
* --back 监听数量或者 -B 监听数量
* --dir 服务默认目录或者 -D 服务默认目录
* --log 日志存放路径或者 -L 日志存放路径
* --daemon 使程序进入后台运行模式
*/
c = getopt_long(argc, argv, "H:P:B:D:L",
long_options, &option_index);
if (c == -1 || c == '?')
break;
if(optarg) len = strlen(optarg);
else len = 0;
if ((!c && !(strcasecmp(long_options[option_index].name, "host")))
|| c == 'H')
p = host = malloc(len + 1);
else if ((!c
&&
!(strcasecmp(long_options[option_index].name, "port")))
|| c == 'P')
p = port = malloc(len + 1);
else if ((!c
&&
!(strcasecmp(long_options[option_index].name, "back")))
|| c == 'B')
p = back = malloc(len + 1);
else if ((!c
&& !(strcasecmp(long_options[option_index].name, "dir")))
|| c == 'D')
p = dirroot = malloc(len + 1);
else if ((!c
&& !(strcasecmp(long_options[option_index].name, "log")))
|| c == 'L')
p = logdir = malloc(len + 1);
else if ((!c
&&
!(strcasecmp
(long_options[option_index].name, "daemon")))) {
daemon_y_n = 1;
continue;
}
else
break;
bzero(p, len + 1);
memcpy(p, optarg, len);
}
}
int main(int argc, char **argv)
{
struct sockaddr_in addr;
int sock_fd, addrlen;
/* 获得程序工作的参数，如 IP 、端口、监听数、网页根目录、目录存放位置等 */
getoption(argc, argv);
if (!host) {
addrlen = strlen(DEFAULTIP);
AllocateMemory(&host, addrlen, DEFAULTIP);
}
if (!port) {
addrlen = strlen(DEFAULTPORT);
AllocateMemory(&port, addrlen, DEFAULTPORT);
}
if (!back) {
addrlen = strlen(DEFAULTBACK);
AllocateMemory(&back, addrlen, DEFAULTBACK);
}
if (!dirroot) {
addrlen = strlen(DEFAULTDIR);
AllocateMemory(&dirroot, addrlen, DEFAULTDIR);
}
if (!logdir) {
addrlen = strlen(DEFAULTLOG);
AllocateMemory(&logdir, addrlen, DEFAULTLOG);
}
printf
("host=%s port=%s back=%s dirroot=%s logdir=%s %s是后台工作模式(进程ID：%d)\n",
host, port, back, dirroot, logdir, daemon_y_n?"":"不", getpid());
/* fork() 两次处于后台工作模式下 */
if (daemon_y_n) {
if (fork())
exit(0);
if (fork())
exit(0);
close(0), close(1), close(2);
logfp = fopen(logdir, "a+");
if (!logfp)
exit(0);
}
/* 处理子进程退出以免产生僵尸进程 */
signal(SIGCHLD, SIG_IGN);
/* 创建 socket */
if ((sock_fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
if (!daemon_y_n) {
prterrmsg("socket()");
} else {
wrterrmsg("socket()");
}
}
/* 设置端口快速重用 */
addrlen = 1;
setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &addrlen,
sizeof(addrlen));
addr.sin_family = AF_INET;
addr.sin_port = htons(atoi(port));
addr.sin_addr.s_addr = inet_addr(host);
addrlen = sizeof(struct sockaddr_in);
/* 绑定地址、端口等信息 */
if (bind(sock_fd, (struct sockaddr *) &addr, addrlen) < 0) {
if (!daemon_y_n) {
prterrmsg("bind()");
} else {
wrterrmsg("bind()");
}
}
/* 开启临听 */
if (listen(sock_fd, atoi(back)) < 0) {
if (!daemon_y_n) {
prterrmsg("listen()");
} else {
wrterrmsg("listen()");
}
}
while (1) {
int new_fd;
addrlen = sizeof(struct sockaddr_in);
/* 接受新连接请求 */
new_fd = accept(sock_fd, (struct sockaddr *) &addr, &addrlen);
if (new_fd < 0) {
if (!daemon_y_n) {
prterrmsg("accept()");
} else {
wrterrmsg("accept()");
}
break;
}
bzero(buffer, MAXBUF + 1);
sprintf(buffer, "连接来自于: %s:%d\n",
inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
if (!daemon_y_n) {
prtinfomsg(buffer);
} else {
wrtinfomsg(buffer);
}
/* 产生一个子进程去处理请求，当前进程继续等待新的连接到来 */
if (!fork()) {
/* 把socket连接作为标准输入、输出、出错句柄来用 */
dup2(new_fd, 0);
dup2(new_fd, 1);
dup2(new_fd, 2);
/* 切换到指定目录工作 */
chdir(dirroot);
/* 交互式执行shell */
execl("/bin/bash", "-l", "--login", "-i", "-r", "-s", (char *)NULL);
}
close(new_fd);
}
close(sock_fd);
return 0;
}

复制代码

用下列命令编译程序：

gcc -Wall telnet-server -o telnetd

启动telnet服务：

./telnetd --daemon #以root用户身份在23端口（即telnet默认端口服务）

或

./telnetd -P 7838 #以非root用户身份

然后开启一个新终端，telnet连接自己的服务器试试，如：

telnet 127.0.0.1

或

telnet 127.0.0.1 7838

不需要输入用户名和密码，直接以启动telnet服务的用户的身份登录系统了。
输入系统命令体验一下吧！

作者: zhoulifa 时间: 2007-02-04 15:04
标题: Linux网络编程一步一步学-网络编程函数说明-来自“永远的UNIX”
在www.fanqiang.com（永远的UNIX)网站上也有一系统文章，比较详细地介绍了网络编程的各函数，大家可以去那边看看，我就不复制过来了。

那边系列文章的目录和链接如下：
/************关于本文档*************************************************************
*filename: Linux网络编程一步一步学-网络编程函数说明-来自“永远的UNIX”
*purpose: 详细说明Linux下网络编程各函数的具体用法，当然最好的是各位自己查看在线手册man
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-27 19:22
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
**********************************************************************************/
Linux网络编程--1. Linux网络知识介绍
1.1 客户端程序和服务端程序
1.2 常用的命令
1.3 TCP/UDP介绍
Linux网络编程--2. 初等网络函数介绍（TCP）
2.1 socket
2.2 bind
2.3 listen
2.4 accept
2.5 connect
2.6 实例
2.7 总结
Linux网络编程--3. 服务器和客户机的信息函数
3.1 字节转换函数
3.2 IP和域名的转换
3.3 字符串的IP和32位的IP转换
3.4 服务信息函数
3.5 一个例子
Linux网络编程--4. 完整的读写函数
4.1 写函数write
4.2 读函数read
4.3 数据的传递
Linux网络编程--5. 用户数据报发送
5.1 两个常用的函数
5.2 一个实例
Linux网络编程--6. 高级套接字函数
6.1 recv和send
6.2 recvfrom和sendto
6.3 recvmsg和sendmsg
6.4 套接字的关闭
6.5 shutdown
Linux网络编程--7. TCP/IP协议
7.1 网络传输分层
7.2 IP协议
7.3 ICMP协议
7.4 UDP协议
7.5 TCP
7.6 TCP连接的建立
Linux网络编程--8. 套接字选项
8.1 getsockopt和setsockopt
8.2 ioctl
Linux网络编程--9. 服务器模型
9.1 循环服务器:UDP服务器
9.2 循环服务器:TCP服务器
9.3 并发服务器:TCP服务器
9.4 并发服务器:多路复用I/O
9.5 并发服务器:UDP服务器
9.6 一个并发TCP服务器实例
Linux网络编程--10. 原始套接字 --11. 后记
10. 原始套接字
10.1 原始套接字的创建
10.2 一个原始套接字的实例
10.3 总结
11. 后记

学习任何知识都不能光看不练。必须动手练习，对于这些函数，自己写个小程序测试一下其用法就会很明了了。

作者: zhoulifa 时间: 2007-02-04 15:13
标题: Linux下上网方法总结
目前大家用到的上网方法无非如下几种：电话拨号、ADSL、局域网共享上网。

下面分别说明在Linux下各种上网方法
1、电话拨号网络设置
1）打开一个命令终端，运行配置命令wvdialconf，此命令将设置拨号上网的各参数，保存在文件/etc/wvdial.conf里，文件内容如下：

[Dialer Defaults]
Init1 = ATZ
Init2 = ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0
Modem Type = Analog Modem
Baud = 115200
New PPPD = yes
Modem = /dev/modem
ISDN = 0
; Phone =
; Password =
; Username =

2）手动编辑此文件，比如用vi命令，vi /etc/wvdial.conf
把此文件的最后几行前面的注释符号去掉，后面的值改成电话拨号的几个参数（这三个参数可以打电信的客户号码问），如下：

Phone = 拨号上网的电话号码
Password = 上网的用户名
Username = 上网的密码

至此，电话拨号上网已经设置完成
3）运行命令来开始拨号，命令如下：

pon wvdial

连接成功后就可以开心上网了。

2、ADSL上网设置
运行一个ADSL配置命令pppoeconf。
按照界面提示一步步设置即可
程序将自动检测系统可用的网卡，如下图：

一般应该只出现eth0, eth1之类的，因为我装了VMware虚拟机，所以有vmnet1、vmnet8之类的虚拟网卡出现。

当然这里要选“是”以便继续设置。

系统自动检测ADSL设备。

允许程序设置一些默认参数，当然你也可以选择“否”，按照你自己的特殊参数来设置。但目前国内的ADSL可能没什么差别，所以选默认值足够了。

这里输入ADSL的帐号。

这里输入ADSL帐号对应的密码。下面的都选“是”应该可以了。

如果你只是偶尔用一下ADSL上网，那么这里可以选择“否”，如果每次都是用ADSL上网并且不限时上网（即包月上网那种），就选择“是”将会开机自动启动ADSL网络。

这里说明了以后手工启动ADSL网络的方法，看到了没？输入命令pon dsl-provider即可启动上网，poff就可以断开网络连接了。

配置完成后在/etc/ppp/目录下生成ppp相关的文件，当然/etc/ppp/peers/dsl-provider文件里记录了所有参数，你可以自己修改。
同时在/etc/init.d目录里也生成了几个文件：

/etc/init.d/pppd-dns
/etc/init.d/ppp
/etc/init.d/pppstatus-clean
/etc/init.d/pppstatus

所以你也可以用/etc/init.d/ppp start命令来启动网络。和pon dsl-provider一样。
网络启动了就可以开心上网了。
/************关于本文档********************************************
*filename: Linux下上网方法总结
*purpose: 说明了Linux下几种上网方法的设置：电话拨号、ADSL、局域网共享上网
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-28 18:02
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/

3、局域网共享上网设置
一般来说局域网里一定有一个作为路由的设备连接着互联网，其它局域网电脑只要设置好IP地址、网关、子网掩码和DNS就可以上风了。

最简单的方法就是设置网卡为DHCP动态获取方式，设置方法如下：
如果是Debian/Ubuntu系统，则修改/etc/network/interfaces文件，把里面关于eth0（这是第一块网卡，相应地，eth1代表第二块网卡）的改成如下即可：

auto eth0
iface eth0 inet dhcp

如果是Red Hat等其它的，好象是要修改/etc/sysconfig/network-scripts/ifcfg-eth0文件（太久不用这个版本了，所以记不太清楚），修改内容如下：

DEVICE=eth0
BOOTPROTO=dhcp
onBOOT=yes

另一种方法就是按照管理员的要求，每台电脑分配一个固定的IP地址，同样是要修改上面提到的文件，比如/etc/network/interfaces，文件里关于eth0的内容要改成下面的：

auto eth0
iface eth0 inet static
address 192.168.100.30
gateway 192.168.100.1
netmask 255.255.255.0

/etc/sysconfig/network-scripts/ifcfg-eth0要修改成如下方式：

DEVICE=eth0
BOOTPROTO=none
onBOOT=yes
IPADDR=192.168.100.30
NETMASK=255.255.255.0
GATEWAY=192.168.100.1

所有配置方法都有相关图形界面可以用的，比如下图：

但我是写程序的，所以比较喜欢用命令去配置或者自己动手修改配置文件。因为系统所有东西除非是写在操作系统里，否则都是在文件里，由操作系统来读取并执行的。

作者: zhoulifa 时间: 2007-02-04 15:14
标题: Linux网络编程一步一步学-利用OpenSSL提供的SSL操作函数进行加密通讯原始例子
首先，大家知道SSL这一目前“事实上的Internet加密标准” 吧？一般的网站是没有用到SSL的，所以如果你用TCPDUMP就可以很容易地看到别人上网的帐号、密码之类的，当然，现在有些已经改用安全通讯方式进行验证了，比如google的邮件服务gmail，而象银行、证券等行业，从一开始就要求用加密通讯，你在哪个银行网站上输入帐号和密码后点击提交不是通过加密方式提交的呢？事实上，SSL也正是在银行这些行业的需求下才产生的。
现在大家经常上网会上到一些https://开头的网站，那就是把SSL标准应用到HTTP上从而变成了HTTPS。另外大家可能都不用telnet这个明文传输工具来进行远程登录了，都改用ssh了，ssh正是SSL的一个实现，用来进行远程加密通讯的。

其次，要在我们现有的TCP程序上加上SSL，你得安装开发包libssl-dev，这个包的描述是这样的：

Package: libssl-dev
Priority: optional
Section: libdevel
Installed-Size: 5552
Maintainer: Debian OpenSSL Team
Architecture: i386
Source: openssl
Version: 0.9.8a-7ubuntu0.3
Depends: libssl0.9.8 (= 0.9.8a-7ubuntu0.3), zlib1g-dev
Conflicts: ssleay (<< 0.9.2b), libssl08-dev, libssl09-dev, libssl095a-dev, libssl096-dev
Filename: pool/main/o/openssl/libssl-dev_0.9.8a-7ubuntu0.3_i386.deb
Size: 2023440
MD5sum: 3c4052d07abe7d7984a774ca815ba4cf
SHA1: 29145b66372613e78c37d9ce0de6a7d1cfc7bac0
SHA256: 9e86aa1174a45e4f61e5afcb56d485ea60f90e31b0ecaf2bf31f426f7eb8c6eb
Description: SSL development libraries, header files and documentation
libssl and libcrypt development libraries, header files and manpages
.
It is part of the OpenSSL implementation of SSL.
Bugs: mailto:ubuntu-users@lists.ubuntu.com
Origin: Ubuntu

Package: libssl-dev
Priority: optional
Section: libdevel
Installed-Size: 5548
Maintainer: Debian OpenSSL Team
Architecture: i386
Source: openssl
Version: 0.9.8a-7build1
Depends: libssl0.9.8 (= 0.9.8a-7build1), zlib1g-dev
Conflicts: ssleay (<< 0.9.2b), libssl08-dev, libssl09-dev, libssl095a-dev, libssl096-dev
Filename: pool/main/o/openssl/libssl-dev_0.9.8a-7build1_i386.deb
Size: 2022142
MD5sum: c9b989aebbae4f6f5dbde67207858023
Description: SSL development libraries, header files and documentation
libssl and libcrypt development libraries, header files and manpages
.
It is part of the OpenSSL implementation of SSL.
Bugs: mailto:ubuntu-users@lists.ubuntu.com
Origin: Ubuntu

也就是说这个libssl-dev包是库函数、头文件以及相关编程说明文档的集合。

安装完成之后在/usr/share/doc/libssl-dev/demos目录下有一些编程示例。你可以参照里面的文档自己来写加密通讯程序。

/************关于本文档********************************************
*filename: Linux网络编程一步一步学-利用OpenSSL提供的SSL操作函数进行加密通讯原始例子
*purpose: 说明了如果在Linux下利用OpenSSL库函数进行SSL加密通讯程序开发
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-28 19:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/

比如/usr/share/doc/libssl-dev/demos/bio目录下提供的一个服务器端例子，代码如下：

/* NOCW */
/* demos/bio/saccept.c */
/* A minimal program to server an SSL connection.
* It uses blocking.
* saccept host:port
* host is the interface IP to use. If any interface, use *:port
* The default it *:4433
*
* cc -I../../include saccept.c -L../.. -lssl -lcrypto
*/
#include <stdio.h>
#include <signal.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#define CERT_FILE "server.pem"
BIO *in=NULL;
void close_up()
{
if (in != NULL)
BIO_free(in);
}
int main(argc,argv)
int argc;
char *argv[];
{
char *port=NULL;
BIO *ssl_bio,*tmp;
SSL_CTX *ctx;
SSL *ssl;
char buf[512];
int ret=1,i;
if (argc <= 1)
port="*:4433";
else
port=argv[1];
signal(SIGINT,close_up);
SSL_load_error_strings();
#ifdef WATT32
dbug_init();
sock_init();
#endif
/* Add ciphers and message digests */
OpenSSL_add_ssl_algorithms();
ctx=SSL_CTX_new(SSLv23_server_method());
if (!SSL_CTX_use_certificate_file(ctx,CERT_FILE,SSL_FILETYPE_PEM))
goto err;
if (!SSL_CTX_use_PrivateKey_file(ctx,CERT_FILE,SSL_FILETYPE_PEM))
goto err;
if (!SSL_CTX_check_private_key(ctx))
goto err;
/* Setup server side SSL bio */
ssl=SSL_new(ctx);
ssl_bio=BIO_new_ssl(ctx,0);
if ((in=BIO_new_accept(port)) == NULL) goto err;
/* This means that when a new connection is acceptede on 'in',
* The ssl_bio will be 'dupilcated' and have the new socket
* BIO push into it. Basically it means the SSL BIO will be
* automatically setup */
BIO_set_accept_bios(in,ssl_bio);
again:
/* The first call will setup the accept socket, and the second
* will get a socket. In this loop, the first actual accept
* will occur in the BIO_read() function. */
if (BIO_do_accept(in) <= 0) goto err;
for (;;)
{
i=BIO_read(in,buf,512);
if (i == 0)
{
/* If we have finished, remove the underlying
* BIO stack so the next time we call any function
* for this BIO, it will attempt to do an
* accept */
printf("Done\n");
tmp=BIO_pop(in);
BIO_free_all(tmp);
goto again;
}
if (i < 0) goto err;
fwrite(buf,1,i,stdout);
fflush(stdout);
}
ret=0;
err:
if (ret)
{
ERR_print_errors_fp(stderr);
}
if (in != NULL) BIO_free(in);
exit(ret);
return(!ret);
}

复制代码

对应的一个客户端例子代码如下：

/* NOCW */
/* demos/bio/sconnect.c */
/* A minimal program to do SSL to a passed host and port.
* It is actually using non-blocking IO but in a very simple manner
* sconnect host:port - it does a 'GET / HTTP/1.0'
*
* cc -I../../include sconnect.c -L../.. -lssl -lcrypto
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
extern int errno;
int main(argc,argv)
int argc;
char *argv[];
{
char *host;
BIO *out;
char buf[1024*10],*p;
SSL_CTX *ssl_ctx=NULL;
SSL *ssl;
BIO *ssl_bio;
int i,len,off,ret=1;
if (argc <= 1)
host="localhost:4433";
else
host=argv[1];
#ifdef WATT32
dbug_init();
sock_init();
#endif
/* Lets get nice error messages */
SSL_load_error_strings();
/* Setup all the global SSL stuff */
OpenSSL_add_ssl_algorithms();
ssl_ctx=SSL_CTX_new(SSLv23_client_method());
/* Lets make a SSL structure */
ssl=SSL_new(ssl_ctx);
SSL_set_connect_state(ssl);
/* Use it inside an SSL BIO */
ssl_bio=BIO_new(BIO_f_ssl());
BIO_set_ssl(ssl_bio,ssl,BIO_CLOSE);
/* Lets use a connect BIO under the SSL BIO */
out=BIO_new(BIO_s_connect());
BIO_set_conn_hostname(out,host);
BIO_set_nbio(out,1);
out=BIO_push(ssl_bio,out);
p="GET / HTTP/1.0\r\n\r\n";
len=strlen(p);
off=0;
for (;;)
{
i=BIO_write(out,&(p[off]),len);
if (i <= 0)
{
if (BIO_should_retry(out))
{
fprintf(stderr,"write DELAY\n");
sleep(1);
continue;
}
else
{
goto err;
}
}
off+=i;
len-=i;
if (len <= 0) break;
}
for (;;)
{
i=BIO_read(out,buf,sizeof(buf));
if (i == 0) break;
if (i < 0)
{
if (BIO_should_retry(out))
{
fprintf(stderr,"read DELAY\n");
sleep(1);
continue;
}
goto err;
}
fwrite(buf,1,i,stdout);
}
ret=1;
if (0)
{
err:
if (ERR_peek_error() == 0) /* system call error */
{
fprintf(stderr,"errno=%d ",errno);
perror("error");
}
else
ERR_print_errors_fp(stderr);
}
BIO_free_all(out);
if (ssl_ctx != NULL) SSL_CTX_free(ssl_ctx);
exit(!ret);
return(ret);
}

复制代码

编译程序里象一般的gcc命令一样，但需要链接ssl库，比如

gcc -Wall saccept.c -o sslserver -lssl
gcc -Wall sconnect.c -o sslclient -l ssl

【作者: 周立发】【访问统计:24】【2007年01月28日星期日 18:47】【注册】【打印】
Trackback

你可以使用这个链接引用该篇文章 http://publishblog.blogchina.com/blog/tb.b?diaryID=6074014
回复
发布人：

作者: zhoulifa 时间: 2007-02-04 15:17
标题: Linux网络编程一步一步学-IPv6下网络编程步骤
就是本贴第一篇了：
Linux网络编程一步一步学-IPv6下网络编程步骤

作者: zhoulifa 时间: 2007-02-04 15:27
标题: Linux网络编程一步一步学-HTTPS客户端程序示例
源代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <unistd.h>
#include <netinet/in.h>
#include <limits.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <openssl/crypto.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/rand.h>
#define DEBUG 1
/********************************************
功能：搜索字符串右边起的第一个匹配字符
********************************************/
char *Rstrchr(char *s, char x)
{
int i = strlen(s);
if (!(*s))
return 0;
while (s[i - 1])
if (strchr(s + (i - 1), x))
return (s + (i - 1));
else
i--;
return 0;
}
/**************************************************************
功能：从字符串src中分析出网站地址和端口，并得到用户要下载的文件
***************************************************************/
void GetHost(char *src, char *web, char *file, int *port)
{
char *pA;
char *pB;
memset(web, 0, sizeof(web));
memset(file, 0, sizeof(file));
*port = 0;
if (!(*src))
return;
pA = src;
if (!strncmp(pA, "http://", strlen("http://")))
pA = src + strlen("http://");
else if (!strncmp(pA, "https://", strlen("https://")))
pA = src + strlen("https://");
pB = strchr(pA, '/');
if (pB) {
memcpy(web, pA, strlen(pA) - strlen(pB));
if (pB + 1) {
memcpy(file, pB + 1, strlen(pB) - 1);
file[strlen(pB) - 1] = 0;
}
} else
memcpy(web, pA, strlen(pA));
if (pB)
web[strlen(pA) - strlen(pB)] = 0;
else
web[strlen(pA)] = 0;
pA = strchr(web, ':');
if (pA)
*port = atoi(pA + 1);
else
*port = 443;
}
/************关于本文档********************************************
*filename: https-client.c
*purpose: 演示HTTPS客户端编程方法
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-30 20:06
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char *argv[])
{
int sockfd, ret;
char buffer[1024];
struct sockaddr_in server_addr;
struct hostent *host;
int portnumber, nbytes;
char host_addr[256];
char host_file[1024];
char local_file[256];
FILE *fp;
char request[1024];
int send, totalsend;
int i;
char *pt;
SSL *ssl;
SSL_CTX *ctx;
if (argc != 2) {
if (DEBUG)
fprintf(stderr, "Usage:%s webpage-address\a\n", argv[0]);
exit(1);
}
if (DEBUG)
printf("parameter.1 is: %s\n", argv[1]);
GetHost(argv[1], host_addr, host_file, &portnumber); /*分析网址、端口、文件名等 */
if (DEBUG)
printf("webhost:%s\n", host_addr);
if (DEBUG)
printf("hostfile:%s\n", host_file);
if (DEBUG)
printf("portnumber:%d\n\n", portnumber);
if ((host = gethostbyname(host_addr)) == NULL) { /*取得主机IP地址 */
if (DEBUG)
fprintf(stderr, "Gethostname error, %s\n", strerror(errno));
exit(1);
}
/* 客户程序开始建立 sockfd描述符 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { /*建立SOCKET连接 */
if (DEBUG)
fprintf(stderr, "Socket Error:%s\a\n", strerror(errno));
exit(1);
}
/* 客户程序填充服务端的资料 */
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(portnumber);
server_addr.sin_addr = *((struct in_addr *) host->h_addr);
/* 客户程序发起连接请求 */
if (connect(sockfd, (struct sockaddr *) (&server_addr), sizeof(struct sockaddr)) == -1) { /*连接网站 */
if (DEBUG)
fprintf(stderr, "Connect Error:%s\a\n", strerror(errno));
exit(1);
}
/* SSL初始化 */
SSL_library_init();
SSL_load_error_strings();
ctx = SSL_CTX_new(SSLv23_client_method());
if (ctx == NULL) {
ERR_print_errors_fp(stderr);
exit(1);
}
ssl = SSL_new(ctx);
if (ssl == NULL) {
ERR_print_errors_fp(stderr);
exit(1);
}
/* 把socket和SSL关联 */
ret = SSL_set_fd(ssl, sockfd);
if (ret == 0) {
ERR_print_errors_fp(stderr);
exit(1);
}
RAND_poll();
while (RAND_status() == 0) {
unsigned short rand_ret = rand() % 65536;
RAND_seed(&rand_ret, sizeof(rand_ret));
}
ret = SSL_connect(ssl);
if (ret != 1) {
ERR_print_errors_fp(stderr);
exit(1);
}
sprintf(request, "GET /%s HTTP/1.1\r\nAccept: */*\r\nAccept-Language: zh-cn\r\n\
User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)\r\n\
Host: %s:%d\r\nConnection: Close\r\n\r\n", host_file, host_addr,
portnumber);
if (DEBUG)
printf("%s", request); /*准备request，将要发送给主机 */
/*取得真实的文件名 */
if (host_file && *host_file)
pt = Rstrchr(host_file, '/');
else
pt = 0;
memset(local_file, 0, sizeof(local_file));
if (pt && *pt) {
if ((pt + 1) && *(pt + 1))
strcpy(local_file, pt + 1);
else
memcpy(local_file, host_file, strlen(host_file) - 1);
} else if (host_file && *host_file)
strcpy(local_file, host_file);
else
strcpy(local_file, "index.html");
if (DEBUG)
printf("local filename to write:%s\n\n", local_file);
/*发送https请求request */
send = 0;
totalsend = 0;
nbytes = strlen(request);
while (totalsend < nbytes) {
send = SSL_write(ssl, request + totalsend, nbytes - totalsend);
if (send == -1) {
if (DEBUG)
ERR_print_errors_fp(stderr);
exit(0);
}
totalsend += send;
if (DEBUG)
printf("%d bytes send OK!\n", totalsend);
}
fp = fopen(local_file, "a");
if (!fp) {
if (DEBUG)
printf("create file error! %s\n", strerror(errno));
return 0;
}
if (DEBUG)
printf("\nThe following is the response header:\n");
i = 0;
/* 连接成功了，接收https响应，response */
while ((nbytes = SSL_read(ssl, buffer, 1)) == 1) {
if (i < 4) {
if (buffer[0] == '\r' || buffer[0] == '\n')
i++;
else
i = 0;
if (DEBUG)
printf("%c", buffer[0]); /*把https头信息打印在屏幕上 */
} else {
fwrite(buffer, 1, 1, fp); /*将https主体信息写入文件 */
i++;
if (i % 1024 == 0)
fflush(fp); /*每1K时存盘一次 */
}
}
fclose(fp);
/* 结束通讯 */
ret = SSL_shutdown(ssl);
if (ret != 1) {
ERR_print_errors_fp(stderr);
exit(1);
}
close(sockfd);
SSL_free(ssl);
SSL_CTX_free(ctx);
ERR_free_strings();
exit(0);
}

复制代码

编译此程序用下列命令：

gcc -Wall https-client.c -lssl -o httpsclient

运行此程序来取得HTTPS服务器上的页面，比如：

./httpsclient https://127.0.0.1/test.html

关键之处在于建立socket之后的SSL相关初始化以及中间的recv/send用SSL_read和SSL_write代替，最后记得释放SSL资源即可。
可以对比之前的文章来发现异同：
HTTP协议的C语言编程实现实例

作者: zhoulifa 时间: 2007-02-04 15:29
标题: OpenSSL体系下使用密钥数字证书等
首先得安装OpenSSL软件包openssl，安装了这个软件包之后，我们可以做这些事情：

  o  Creation of RSA, DH and DSA Key Parameters # 创建密钥 key
  o  Creation of X.509 Certificates, CSRs and CRLs # 创建证书
  o  Calculation of Message Digests             #
  o  Encryption and Decryption with Ciphers # 加密、解密
  o  SSL/TLS Client and Server Tests       # SSL 服务器端/客户端测试
  o  Handling of S/MIME signed or encrypted Mail  # 处理签名或加密了的邮件

1、生成RSA密钥的方法

openssl genrsa -des3 -out privkey.pem 2048

这个命令会生成一个2048位的密钥，同时有一个des3方法加密的密码，如果你不想要每次都输入密码，可以改成：

openssl genrsa -out privkey.pem 2048

建议用2048位密钥，少于此可能会不安全或很快将不安全。

2、生成一个证书请求

openssl req -new -key privkey.pem -out cert.csr

这个命令将会生成一个证书请求，当然，用到了前面生成的密钥privkey.pem文件
这里将生成一个新的文件cert.csr，即一个证书请求文件，你可以拿着这个文件去数字证书颁发机构（即CA）申请一个数字证书。CA会给你一个新的文件cacert.pem，那才是你的数字证书。

如果是自己做测试，那么证书的申请机构和颁发机构都是自己。就可以用下面这个命令来生成证书：

openssl req -new -x509 -key privkey.pem -out cacert.pem -days 1095

这个命令将用上面生成的密钥privkey.pem生成一个数字证书cacert.pem

3、使用数字证书和密钥
有了privkey.pem和cacert.pem文件后就可以在自己的程序中使用了，比如做一个加密通讯的服务器

作者: zhoulifa 时间: 2007-02-04 15:32
标题: Linux网络编程一步一步学-epoll同时处理海量连接的代码
如果你是做大型项目的，比如同时要求上万人在线的某种程序，比如在线游戏、在线聊天，那怕是一个最简单的支持上万人同时在线的WEB服务器。用原来的方法都比较困难实现的。
下面这段代码就可以支持9997个连接同时在线，当然你可以修改宏定义以支持更多的连接：

#define MAXEPOLLSIZE 10000

#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>
#include <unistd.h>
#include <arpa/inet.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/time.h>
#include <sys/resource.h>
#define MAXBUF 1024
#define MAXEPOLLSIZE 10000
/*
setnonblocking - 设置句柄为非阻塞方式
*/
int setnonblocking(int sockfd)
{
if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1) {
return -1;
}
return 0;
}
/*
handle_message - 处理每个 socket 上的消息收发
*/
int handle_message(int new_fd)
{
char buf[MAXBUF + 1];
int len;
/* 开始处理每个新连接上的数据收发 */
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
len = recv(new_fd, buf, MAXBUF, 0);
if (len > 0)
printf
("%d接收消息成功:'%s'，共%d个字节的数据\n",
new_fd, buf, len);
else {
if (len < 0)
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
close(new_fd);
return -1;
}
/* 处理每个新连接上的数据收发结束 */
return len;
}
/************关于本文档********************************************
*filename: epoll-server.c
*purpose: 演示epoll处理海量socket连接的方法
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-01-31 21:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int listener, new_fd, kdpfd, nfds, n, ret, curfds;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int myport, lisnum;
struct epoll_event ev;
struct epoll_event events[MAXEPOLLSIZE];
struct rlimit rt;
if (argv[1])
myport = atoi(argv[1]);
else
myport = 7838;
if (argv[2])
lisnum = atoi(argv[2]);
else
lisnum = 2;
/* 设置每个进程允许打开的最大文件数 */
rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;
if (setrlimit(RLIMIT_NOFILE, &rt) == -1) {
perror("setrlimit");
exit(1);
}
else printf("设置系统资源参数成功！\n");
/* 开启 socket 监听 */
if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
} else
printf("socket 创建成功！\n");
setnonblocking(listener);
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind
(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
== -1) {
perror("bind");
exit(1);
} else
printf("IP 地址和端口绑定成功\n");
if (listen(listener, lisnum) == -1) {
perror("listen");
exit(1);
} else
printf("开启服务成功！\n");
/* 创建 epoll 句柄，把监听 socket 加入到 epoll 集合里 */
kdpfd = epoll_create(MAXEPOLLSIZE);
len = sizeof(struct sockaddr_in);
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = listener;
if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0) {
fprintf(stderr, "epoll set insertion error: fd=%d\n", listener);
return -1;
} else
printf("监听 socket 加入 epoll 成功！\n");
curfds = 1;
while (1) {
/* 等待有事件发生 */
nfds = epoll_wait(kdpfd, events, curfds, -1);
if (nfds == -1) {
perror("epoll_wait");
break;
}
/* 处理所有事件 */
for (n = 0; n < nfds; ++n) {
if (events[n].data.fd == listener) {
new_fd = accept(listener, (struct sockaddr *) &their_addr,
&len);
if (new_fd < 0) {
perror("accept");
continue;
} else
printf("有连接来自于： %d:%d，分配的 socket 为:%d\n", inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);
setnonblocking(new_fd);
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = new_fd;
if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0) {
fprintf(stderr, "把 socket '%d' 加入 epoll 失败！%s\n",
new_fd, strerror(errno));
return -1;
}
curfds++;
} else {
ret = handle_message(events[n].data.fd);
if (ret < 1 && errno != 11) {
epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,
&ev);
curfds--;
}
}
}
}
close(listener);
return 0;
}

复制代码

编译此程序用命令：

gcc -Wall epoll-server.c -o server

运行此程序需要具有管理员权限！

sudo ./server 7838 1

通过测试这一个服务器可能同时处理10000 -3 = 9997 个连接！

如果这是一个在线服务系统，那么它可以支持9997人同时在线，比如游戏、聊天等。

作者: zhoulifa 时间: 2007-02-04 15:43
标题: Linux网络编程一步一步学-加密通讯协议SSL研究
服务器端源代码如下：

#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>
#include <unistd.h>
#include <arpa/inet.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#define MAXBUF 1024
/************关于本文档********************************************
*filename: ssl-server.c
*purpose: 演示利用 OpenSSL 库进行基于 IP层的 SSL 加密通讯的方法，这是服务器端例子
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-02-02 19:40
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int myport, lisnum;
char buf[MAXBUF + 1];
SSL_CTX *ctx;
if (argv[1])
myport = atoi(argv[1]);
else
myport = 7838;
if (argv[2])
lisnum = atoi(argv[2]);
else
lisnum = 2;
/* SSL 库初始化 */
SSL_library_init();
/* 载入所有 SSL 算法 */
OpenSSL_add_all_algorithms();
/* 载入所有 SSL 错误消息 */
SSL_load_error_strings();
/* 以 SSL V2 和 V3 标准兼容方式产生一个 SSL_CTX ，即 SSL Content Text */
ctx = SSL_CTX_new(SSLv23_server_method());
/* 也可以用 SSLv2_server_method() 或 SSLv3_server_method() 单独表示 V2 或 V3标准 */
if (ctx == NULL) {
ERR_print_errors_fp(stdout);
exit(1);
}
/* 载入用户的数字证书，此证书用来发送给客户端。证书里包含有公钥 */
if (SSL_CTX_use_certificate_file(ctx, argv[4], SSL_FILETYPE_PEM) <= 0) {
ERR_print_errors_fp(stdout);
exit(1);
}
/* 载入用户私钥 */
if (SSL_CTX_use_PrivateKey_file(ctx, argv[5], SSL_FILETYPE_PEM) <= 0) {
ERR_print_errors_fp(stdout);
exit(1);
}
/* 检查用户私钥是否正确 */
if (!SSL_CTX_check_private_key(ctx)) {
ERR_print_errors_fp(stdout);
exit(1);
}
/* 开启一个 socket 监听 */
if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
} else
printf("socket created\n");
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = PF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
== -1) {
perror("bind");
exit(1);
} else
printf("binded\n");
if (listen(sockfd, lisnum) == -1) {
perror("listen");
exit(1);
} else
printf("begin listen\n");
while (1) {
SSL *ssl;
len = sizeof(struct sockaddr);
/* 等待客户端连上来 */
if ((new_fd =
accept(sockfd, (struct sockaddr *) &their_addr,
&len)) == -1) {
perror("accept");
exit(errno);
} else
printf("server: got connection from %s, port %d, socket %d\n",
inet_ntoa(their_addr.sin_addr),
ntohs(their_addr.sin_port), new_fd);
/* 基于 ctx 产生一个新的 SSL */
ssl = SSL_new(ctx);
/* 将连接用户的 socket 加入到 SSL */
SSL_set_fd(ssl, new_fd);
/* 建立 SSL 连接 */
if (SSL_accept(ssl) == -1) {
perror("accept");
close(new_fd);
break;
}
/* 开始处理每个新连接上的数据收发 */
bzero(buf, MAXBUF + 1);
strcpy(buf, "server->client");
/* 发消息给客户端 */
len = SSL_write(ssl, buf, strlen(buf));
if (len <= 0) {
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buf, errno, strerror(errno));
goto finish;
} else
printf("消息'%s'发送成功，共发送了%d个字节！\n",
buf, len);
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
len = SSL_read(ssl, buf, MAXBUF);
if (len > 0)
printf("接收消息成功:'%s'，共%d个字节的数据\n",
buf, len);
else
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
/* 处理每个新连接上的数据收发结束 */
finish:
/* 关闭 SSL 连接 */
SSL_shutdown(ssl);
/* 释放 SSL */
SSL_free(ssl);
/* 关闭 socket */
close(new_fd);
}
/* 关闭监听的 socket */
close(sockfd);
/* 释放 CTX */
SSL_CTX_free(ctx);
return 0;
}

复制代码

客户端源代码如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#define MAXBUF 1024
void ShowCerts(SSL * ssl)
{
X509 *cert;
char *line;
cert = SSL_get_peer_certificate(ssl);
if (cert != NULL) {
printf("数字证书信息:\n");
line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
printf("证书: %s\n", line);
free(line);
line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
printf("颁发者: %s\n", line);
free(line);
X509_free(cert);
} else
printf("无证书信息！\n");
}
/************关于本文档********************************************
*filename: ssl-client.c
*purpose: 演示利用 OpenSSL 库进行基于 IP层的 SSL 加密通讯的方法，这是客户端例子
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-02-02 20:10
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
int sockfd, len;
struct sockaddr_in dest;
char buffer[MAXBUF + 1];
SSL_CTX *ctx;
SSL *ssl;
if (argc != 3) {
printf
("参数格式错误！正确用法如下：\n\t\t%s IP地址端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* SSL 库初始化，参看 ssl-server.c 代码 */
SSL_library_init();
OpenSSL_add_all_algorithms();
SSL_load_error_strings();
ctx = SSL_CTX_new(SSLv23_client_method());
if (ctx == NULL) {
ERR_print_errors_fp(stdout);
exit(1);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Socket");
exit(errno);
}
printf("socket created\n");
/* 初始化服务器端（对方）的地址和端口信息 */
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
perror(argv[1]);
exit(errno);
}
printf("address created\n");
/* 连接服务器 */
if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
perror("Connect ");
exit(errno);
}
printf("server connected\n");
/* 基于 ctx 产生一个新的 SSL */
ssl = SSL_new(ctx);
SSL_set_fd(ssl, sockfd);
/* 建立 SSL 连接 */
if (SSL_connect(ssl) == -1)
ERR_print_errors_fp(stderr);
else {
printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
ShowCerts(ssl);
}
/* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
bzero(buffer, MAXBUF + 1);
/* 接收服务器来的消息 */
len = SSL_read(ssl, buffer, MAXBUF);
if (len > 0)
printf("接收消息成功:'%s'，共%d个字节的数据\n",
buffer, len);
else {
printf
("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
goto finish;
}
bzero(buffer, MAXBUF + 1);
strcpy(buffer, "from client->server");
/* 发消息给服务器 */
len = SSL_write(ssl, buffer, strlen(buffer));
if (len < 0)
printf
("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
buffer, errno, strerror(errno));
else
printf("消息'%s'发送成功，共发送了%d个字节！\n",
buffer, len);
finish:
/* 关闭连接 */
SSL_shutdown(ssl);
SSL_free(ssl);
close(sockfd);
SSL_CTX_free(ctx);
return 0;
}

复制代码

编译程序用下列命令：

gcc -Wall ssl-client.c -o client
gcc -Wall ssl-server.c -o server

运行程序用如下命令：

./server 7838 1 cacert.pem privkey.pem
./client 127.0.0.1 7838

用下面这两个命令产生上述cacert.pem和privkey.pem文件：

openssl genrsa -out privkey.pem 2048
openssl req -new -x509 -key privkey.pem -out cacert.pem -days 1095

具体请参考 “OpenSSL体系下使用密钥数字证书等”

如果想对SSL有更深入的了解，请学习计算机安全相关的内容，尤其是非对称加密技术。
如果想对SSL库的源代码有深入学习，请去 www.openssl.org 下载源码来阅读。

或者阅读“SSL连接建立过程分析”其目录和链接如下：

SSL连接建立过程分析(1)
1. 应用程序接口
1.1 SSL初始化
1.2 建立SSL新连接
1.3 SSL通信
1.4 SSL释放
2. SSL实现分析
2.1 SSL_load_error_strings
2.2 SSLeay_add_ssl_algorithms()
2.3 SSL23_server_method()
2.4 SSL23_client_method()
2.5 SSL_CTX_new ()
SSL连接建立过程分析(2)
2.6 SSL_CTX_set_default_passwd_cb[_userdata]()
2.7 SSL_CTX_use_certificate_file()
2.8 SSL_CTX_use_PrivateKey_file()
2.9 SSL_CTX_check_private_key()
2.10 SSL_new
2.11 SSL_set_fd
SSL连接建立过程分析(3)
2.12 SSL_accept
SSL连接建立过程分析(4)
2.13 SSL_connect
SSL连接建立过程分析(5)
2.14 SSL_read
SSL连接建立过程分析(6)
2.15 SSL_write

作者: zhoulifa 时间: 2007-02-04 15:53
标题: Linux网络编程一步一步学-select详解
select系统调用是用来让我们的程序监视多个文件句柄(file descriptor)的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有某一个或多个发生了状态改变。

文件在句柄在Linux里很多，如果你man某个函数，在函数返回值部分说到成功后有一个文件句柄被创建的都是的，如man socket可以看到“On success, a file descriptor for the new socket is returned.”而man 2 open可以看到“open() and creat() return the new file descriptor”，其实文件句柄就是一个整数，看socket函数的声明就明白了：

int socket(int domain, int type, int protocol);

当然，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr，0就是stdin，1就是stdout，2就是stderr。
比如下面这两段代码都是从标准输入读入9个字节字符：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
char buf[10] = "";
read(0, buf, 9); /* 从标准输入 0 读入字符 */
fprintf(stdout, "%s\n", buf); /* 向标准输出 stdout 写字符 */
return 0;
}

复制代码

/* **上面和下面的代码都可以用来从标准输入读用户输入的9个字符** */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
char buf[10] = "";
fread(buf, 9, 1, stdin); /* 从标准输入 stdin 读入字符 */
write(1, buf, strlen(buf));
return 0;
}

复制代码

继续上面说的select，就是用来监视某个或某些句柄的状态变化的。select函数原型如下：

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

函数的最后一个参数timeout显然是一个超时时间值，其类型是struct timeval *，即一个struct timeval结构的变量的指针，所以我们在程序里要申明一个struct timeval tv;然后把变量tv的地址&tv传递给select函数。struct timeval结构如下：

struct timeval {
         long tv_sec;       /* seconds */
         long tv_usec;       /* microseconds */
      };

第2、3、4三个参数是一样的类型： fd_set *，即我们在程序里要申明几个fd_set类型的变量，比如rdfds, wtfds, exfds，然后把这个变量的地址&rdfds, &wtfds, &exfds 传递给select函数。这三个参数都是一个句柄的集合，第一个rdfds是用来保存这样的句柄的：当句柄的状态变成可读的时系统就会告诉select函数返回，同理第二个wtfds是指有句柄状态变成可写的时系统就会告诉select函数返回，同理第三个参数exfds是特殊情况，即句柄上有特殊情况发生时系统会告诉select函数返回。特殊情况比如对方通过一个socket句柄发来了紧急数据。如果我们程序里只想检测某个socket是否有数据可读，我们可以这样：

fd_set rdfds; /* 先申明一个 fd_set 集合来保存我们要检测的 socket句柄 */
struct timeval tv; /* 申明一个时间变量来保存时间 */
int ret; /* 保存返回值 */
FD_ZERO(&rdfds); /* 用select函数之前先把集合清零 */
FD_SET(socket, &rdfds); /* 把要检测的句柄socket加入到集合里 */
tv.tv_sec = 1;
tv.tv_usec = 500; /* 设置select等待的最大时间为1秒加500毫秒 */
ret = select(socket + 1, &rdfds, NULL, NULL, &tv); /* 检测我们上面设置到集合rdfds里的句柄是否有可读信息 */
if(ret < 0) perror("select");/* 这说明select函数出错 */
else if(ret == 0) printf("超时\n"); /* 说明在我们设定的时间值1秒加500毫秒的时间内，socket的状态没有发生变化 */
else { /* 说明等待时间还未到1秒加500毫秒，socket的状态发生了变化 */
printf("ret=%d\n", ret); /* ret这个返回值记录了发生状态变化的句柄的数目，由于我们只监视了socket这一个句柄，所以这里一定ret=1，如果同时有多个句柄发生变化返回的就是句柄的总和了 */
/* 这里我们就应该从socket这个句柄里读取数据了，因为select函数已经告诉我们这个句柄里有数据可读 */
if(FD_ISSET(socket, &rdfds)) { /* 先判断一下socket这外被监视的句柄是否真的变成可读的了 */
/* 读取socket句柄里的数据 */
recv(...);
}
}

注意select函数的第一个参数，是所有加入集合的句柄值的最大那个值还要加1。比如我们创建了3个句柄：
/************关于本文档********************************************
*filename: Linux网络编程一步一步学-select详解
*purpose: 详细说明select的用法
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言
*date time:2007-02-03 19:40
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to:Google
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/

int sa, sb, sc;
sa = socket(...); /* 分别创建3个句柄并连接到服务器上 */
connect(sa,...);
sb = socket(...);
connect(sb,...);
sc = socket(...);
connect(sc,...);

FD_SET(sa, &rdfds);/* 分别把3个句柄加入读监视集合里去 */
FD_SET(sb, &rdfds);
FD_SET(sc, &rdfds);

在使用select函数之前，一定要找到3个句柄中的最大值是哪个，我们一般定义一个变量来保存最大值，取得最大socket值如下：

int maxfd = 0;
if(sa > maxfd) maxfd = sa;
if(sb > maxfd) maxfd = sb;
if(sc > maxfd) maxfd = sc;

然后调用select函数：

ret = select(maxfd + 1, &rdfds, NULL, NULL, &tv); /* 注意是最大值还要加1 */

同样的道理，如果我们要检测用户是否按了键盘进行输入，我们就应该把标准输入0这个句柄放到select里来检测，如下：

FD_ZERO(&rdfds);
FD_SET(0, &rdfds);
tv.tv_sec = 1;
tv.tv_usec = 0;
ret = select(1, &rdfds, NULL, NULL, &tv); /* 注意是最大值还要加1 */
if(ret < 0) perror("select");/* 出错 */
else if(ret == 0) printf("超时\n"); /* 在我们设定的时间tv内，用户没有按键盘 */
else { /* 用户有按键盘，要读取用户的输入 */
scanf("%s", buf);
}

详细编程请参见：
Linux网络编程一步一步学-异步通讯聊天程序select

作者: marion 时间: 2007-02-05 01:21
佩服佩服！！请问Lifa兄，想学C语言，应该如何实施？谢谢！

作者: converse 时间: 2007-02-05 12:46
感谢楼主的辛苦贡献,本帖已经收录到C版置顶的版贴中,以后会有更多的看到此贴并且从中获益,再次感谢楼主.
C版版贴见:
http://bbs.chinaunix.net/viewthr ... &extra=page%3D1

收录在其中的网络编程部分.

作者: langue 时间: 2007-02-05 12:52
--

为了表彰 zhoulifa 会员对本版做出的贡献，本帖将在 C/C++ 版置顶一个月，同时帖子将被永久收录进版帖。

--

作者: gaosen2463 时间: 2007-02-05 14:45
真的好强啊

作者: zhoulifa 时间: 2007-02-05 14:54

原帖由 marion 于 2007-2-5 01:21 发表
佩服佩服！！请问Lifa兄，想学C语言，应该如何实施？谢谢！

为了回答你这个问题，我今天专门写了这篇文章：
我是这样学习Linux下C语言编程的-完全认识GNU C 语言库glibc
准备写一系列“我是这样学习Linux下C语言编程的”，你先看看，如果觉得还行、值得推荐给大家，那我再把这一系列文章搬到这里来。

作者: 1jjk 时间: 2007-02-05 15:02

原帖由 zhoulifa 于 2007-2-5 14:54 发表

为了回答你这个问题，我今天专门写了这篇文章：
我是这样学习Linux下C语言编程的-完全认识GNU C 语言库glibc
准备写一系列“我是这样学习Linux下C语言编 ...

发哥学习的精神很好啊
不过应该比这个再基础些，估计他的意思是Linux下最最基础的那种

作者: marshal97 时间: 2007-02-05 15:59
PF
强贴留名

作者: dzt_tomdu 时间: 2007-02-06 13:08
谢谢，正想用这方面的资料那。十分感谢

作者: arthasg 时间: 2007-02-22 22:40
楼主大哥,你在程序中多次使用inet_aton函数,似乎这个函数已经被inet_pton取代了呢.

作者: zgqmm 时间: 2007-02-25 09:42
强贴，正学习ing

作者: zhoulifa 时间: 2007-02-26 08:51

原帖由 arthasg 于 2007-2-22 22:40 发表
楼主大哥,你在程序中多次使用inet_aton函数,似乎这个函数已经被inet_pton取代了呢.

inet_pton是比inet_aton之类的函数要方便一些，但用inet_aton没什么不好，目前还是有不少在用的

作者: 醒目 时间: 2007-02-26 17:22
遇到高人了，收藏，慢慢看

作者: converse 时间: 2007-02-27 22:27
今天晚上花时间把大部分看过了，感觉对于初学者而言是非常不错的教程，作者手把手的一步一步给出网络编程的步骤，每一个教程都用相关的例子，赞！

作者: akei48 时间: 2007-02-28 00:58
看贴留名.

作者: akei48 时间: 2007-02-28 14:37
自己发出去的广播是不是自己捕捉不到啊?

作者: 源方 时间: 2007-03-08 10:43
做为附件传上来吧

作者: iCharlene 时间: 2007-04-08 21:53
我一直在期待附件~~~

作者: cofish 时间: 2007-04-11 15:26
已经全部收录。
谢谢

作者: aobai 时间: 2007-04-23 13:17
mark

作者: xhl 时间: 2007-04-23 14:16

原帖由 zhoulifa 于 2007-2-26 08:51 发表

inet_pton是比inet_aton之类的函数要方便一些，但用inet_aton没什么不好，目前还是有不少在用的

inet_aton 这个方法是非线程安全的，不可重入。

如果你用这个方法实现自己的threadsafe-lib的话，肯定会出问题.
不过普通的应用， inet_aton似乎比inet_pton更方便些。

作者: wrennywang 时间: 2007-06-08 17:28
学习ing,发现1个小问题
在好几段代码中有
if (argv[1])
      myport = atoi(argv[1]);
else
      myport = 7838;

if (argv[2])
      lisnum = atoi(argv[2]);
else
      lisnum = 2;
if (argv[3])
      my_addr.sin_addr.s_addr = inet_addr(argv[3]);
else
      my_addr.sin_addr.s_addr = INADDR_ANY;

按说，argv[0]应该是程序运行路径名
argv[1]是程序名后第一个参数，对应的应该是 ip.....
argv[2]是程序名后第二个参数..................................

作者: chary8088 时间: 2008-11-17 17:29
MARK，这个帖子太好了

作者: alaulong 时间: 2008-12-05 13:27
不错,学习下网络编程.

作者: c/unix 时间: 2008-12-05 14:40
提示: 作者被禁止或删除内容自动屏蔽

作者: 无花有果 时间: 2011-01-07 12:19
本来是寻找ssl的编程的，没有想到可以有参考性的那么多。不过作者貌似很久不上论坛了……

顶起！

作者: iCymbidium 时间: 2011-01-07 12:57
牛人如此多，我要多喝牛奶，也变牛人！

作者: jiangyingji 时间: 2011-01-09 19:46
学习。。。

作者: eliry 时间: 2011-01-10 10:49
楼主真有前瞻眼光，我现在打算在产品的代码里面加上IPv6支持，参阅下楼主文档，益处很多。谢谢！

作者: bzhk924 时间: 2012-05-21 19:43
if ( inet_pton(AF_INET6, argv[1], &dest.sin6_addr) < 0 ) {                // IPv6

      perror(argv[1]);

      exit(errno);

}
严谨来说，小于等于0

欢迎光临 Chinaunix (http://bbs.chinaunix.net/)