免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
最近访问板块 发新帖
楼主: zhoulifa
打印 上一主题 下一主题

Linux网络编程一步一步学-IPv6下网络编程步骤 [复制链接]

论坛徽章:
0
31 [报告]
发表于 2007-02-04 14:56 |只看该作者

Linux网络编程一步一步学-用C自己编写一个telnet服务器

服务器源代码如下:

  1. #include <stdarg.h>
  2. #include <errno.h>
  3. #include <stdio.h>
  4. #include <fcntl.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <time.h>
  8. #include <sys/types.h>
  9. #include <sys/stat.h>
  10. #include <dirent.h>
  11. #include <errno.h>
  12. #include <netinet/in.h>
  13. #include <sys/socket.h>
  14. #include <resolv.h>
  15. #include <arpa/inet.h>
  16. #include <stdlib.h>
  17. #include <signal.h>
  18. #include <getopt.h>

  19. #define DEFAULTIP "127.0.0.1"
  20. #define DEFAULTPORT "23"
  21. #define DEFAULTBACK "10"
  22. #define DEFAULTDIR "/tmp"
  23. #define DEFAULTLOG "/tmp/telnet-server.log"

  24. void prterrmsg(char *msg);
  25. #define prterrmsg(msg)        { perror(msg); abort(); }
  26. void wrterrmsg(char *msg);
  27. #define wrterrmsg(msg)        { fputs(msg, logfp); fputs(strerror(errno), logfp);fflush(logfp); abort(); }

  28. void prtinfomsg(char *msg);
  29. #define prtinfomsg(msg)        { fputs(msg, stdout);  }
  30. void wrtinfomsg(char *msg);
  31. #define wrtinfomsg(msg)        {  fputs(msg, logfp); fflush(logfp);}

  32. #define MAXBUF        1024

  33. char buffer[MAXBUF + 1];
  34. char *host = 0;
  35. char *port = 0;
  36. char *back = 0;
  37. char *dirroot = 0;
  38. char *logdir = 0;
  39. unsigned char daemon_y_n = 0;
  40. FILE *logfp;

  41. #define MAXPATH        150

  42. /*------------------------------------------------------
  43. *--- AllocateMemory - 分配空间并把d所指的内容复制
  44. *------------------------------------------------------
  45. */
  46. void AllocateMemory(char **s, int l, char *d)
  47. {
  48.     *s = malloc(l + 1);
  49.     bzero(*s, l + 1);
  50.     memcpy(*s, d, l);
  51. }
  52. /************关于本文档*************************************************************
  53. *filename: telnet-server.c
  54. *purpose: 这是在Linux下用C语言写的telnet服务器,没有用户名和密码,直接以开启服务者的身份登录系统
  55. *wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
  56. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
  57. *date time:2007-01-27 17:02
  58. *Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
  59. * 但请遵循GPL
  60. *Thanks to: Google.com
  61. *Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
  62. * 科技站在巨人的肩膀上进步更快!感谢有开源前辈的贡献!
  63. **********************************************************************************/

  64. /*------------------------------------------------------
  65. *--- getoption - 分析取出程序的参数
  66. *------------------------------------------------------
  67. */
  68. void getoption(int argc, char **argv)
  69. {
  70.     int c, len;
  71.     char *p = 0;

  72.     opterr = 0;
  73.     while (1) {
  74.         int option_index = 0;
  75.         static struct option long_options[] = {
  76.             {"host", 1, 0, 0},
  77.             {"port", 1, 0, 0},
  78.             {"back", 1, 0, 0},
  79.             {"dir", 1, 0, 0},
  80.             {"log", 1, 0, 0},
  81.             {"daemon", 0, 0, 0},
  82.             {0, 0, 0, 0}
  83.         };
  84.         /* 本程序支持如一些参数:
  85.          * --host IP地址 或者 -H IP地址
  86.          * --port 端口 或者 -P 端口
  87.          * --back 监听数量 或者 -B 监听数量
  88.          * --dir 服务默认目录 或者 -D 服务默认目录
  89.          * --log 日志存放路径 或者 -L 日志存放路径
  90.          * --daemon 使程序进入后台运行模式
  91.          */
  92.         c = getopt_long(argc, argv, "H:P:B:D:L",
  93.                         long_options, &option_index);
  94.         if (c == -1 || c == '?')
  95.             break;

  96.         if(optarg)        len = strlen(optarg);
  97.         else        len = 0;

  98.         if ((!c && !(strcasecmp(long_options[option_index].name, "host")))
  99.             || c == 'H')
  100.             p = host = malloc(len + 1);
  101.         else if ((!c
  102.                   &&
  103.                   !(strcasecmp(long_options[option_index].name, "port")))
  104.                  || c == 'P')
  105.             p = port = malloc(len + 1);
  106.         else if ((!c
  107.                   &&
  108.                   !(strcasecmp(long_options[option_index].name, "back")))
  109.                  || c == 'B')
  110.             p = back = malloc(len + 1);
  111.         else if ((!c
  112.                   && !(strcasecmp(long_options[option_index].name, "dir")))
  113.                  || c == 'D')
  114.             p = dirroot = malloc(len + 1);
  115.         else if ((!c
  116.                   && !(strcasecmp(long_options[option_index].name, "log")))
  117.                  || c == 'L')
  118.             p = logdir = malloc(len + 1);
  119.         else if ((!c
  120.                   &&
  121.                   !(strcasecmp
  122.                     (long_options[option_index].name, "daemon")))) {
  123.             daemon_y_n = 1;
  124.             continue;
  125.         }
  126.         else
  127.             break;
  128.         bzero(p, len + 1);
  129.         memcpy(p, optarg, len);
  130.     }
  131. }

  132. int main(int argc, char **argv)
  133. {
  134.     struct sockaddr_in addr;
  135.     int sock_fd, addrlen;

  136.     /* 获得程序工作的参数,如 IP 、端口、监听数、网页根目录、目录存放位置等 */
  137.     getoption(argc, argv);

  138.     if (!host) {
  139.         addrlen = strlen(DEFAULTIP);
  140.         AllocateMemory(&host, addrlen, DEFAULTIP);
  141.     }
  142.     if (!port) {
  143.         addrlen = strlen(DEFAULTPORT);
  144.         AllocateMemory(&port, addrlen, DEFAULTPORT);
  145.     }
  146.     if (!back) {
  147.         addrlen = strlen(DEFAULTBACK);
  148.         AllocateMemory(&back, addrlen, DEFAULTBACK);
  149.     }
  150.     if (!dirroot) {
  151.         addrlen = strlen(DEFAULTDIR);
  152.         AllocateMemory(&dirroot, addrlen, DEFAULTDIR);
  153.     }
  154.     if (!logdir) {
  155.         addrlen = strlen(DEFAULTLOG);
  156.         AllocateMemory(&logdir, addrlen, DEFAULTLOG);
  157.     }

  158.     printf
  159.         ("host=%s port=%s back=%s dirroot=%s logdir=%s %s是后台工作模式(进程ID:%d)\n",
  160.          host, port, back, dirroot, logdir, daemon_y_n?"":"不", getpid());

  161.     /* fork() 两次处于后台工作模式下 */
  162.     if (daemon_y_n) {
  163.         if (fork())
  164.             exit(0);
  165.         if (fork())
  166.             exit(0);
  167.         close(0), close(1), close(2);
  168.         logfp = fopen(logdir, "a+");
  169.         if (!logfp)
  170.             exit(0);
  171.     }

  172.     /* 处理子进程退出以免产生僵尸进程 */
  173.     signal(SIGCHLD, SIG_IGN);

  174.     /* 创建 socket */
  175.     if ((sock_fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
  176.         if (!daemon_y_n) {
  177.             prterrmsg("socket()");
  178.         } else {
  179.             wrterrmsg("socket()");
  180.         }
  181.     }

  182.     /* 设置端口快速重用 */
  183.     addrlen = 1;
  184.     setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &addrlen,
  185.                sizeof(addrlen));

  186.     addr.sin_family = AF_INET;
  187.     addr.sin_port = htons(atoi(port));
  188.     addr.sin_addr.s_addr = inet_addr(host);
  189.     addrlen = sizeof(struct sockaddr_in);
  190.     /* 绑定地址、端口等信息 */
  191.     if (bind(sock_fd, (struct sockaddr *) &addr, addrlen) < 0) {
  192.         if (!daemon_y_n) {
  193.             prterrmsg("bind()");
  194.         } else {
  195.             wrterrmsg("bind()");
  196.         }
  197.     }

  198.     /* 开启临听 */
  199.     if (listen(sock_fd, atoi(back)) < 0) {
  200.         if (!daemon_y_n) {
  201.             prterrmsg("listen()");
  202.         } else {
  203.             wrterrmsg("listen()");
  204.         }
  205.     }
  206.     while (1) {
  207.         int new_fd;
  208.         addrlen = sizeof(struct sockaddr_in);
  209.         /* 接受新连接请求 */
  210.         new_fd = accept(sock_fd, (struct sockaddr *) &addr, &addrlen);
  211.         if (new_fd < 0) {
  212.             if (!daemon_y_n) {
  213.                 prterrmsg("accept()");
  214.             } else {
  215.                 wrterrmsg("accept()");
  216.             }
  217.             break;
  218.         }
  219.         bzero(buffer, MAXBUF + 1);
  220.         sprintf(buffer, "连接来自于: %s:%d\n",
  221.                 inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
  222.         if (!daemon_y_n) {
  223.             prtinfomsg(buffer);
  224.         } else {
  225.             wrtinfomsg(buffer);
  226.         }
  227.         /* 产生一个子进程去处理请求,当前进程继续等待新的连接到来 */
  228.         if (!fork()) {
  229.             /* 把socket连接作为标准输入、输出、出错句柄来用 */
  230.             dup2(new_fd, 0);
  231.             dup2(new_fd, 1);
  232.             dup2(new_fd, 2);
  233.             /* 切换到指定目录工作 */
  234.             chdir(dirroot);
  235.             /* 交互式执行shell */
  236.             execl("/bin/bash", "-l", "--login", "-i", "-r", "-s", (char *)NULL);
  237.         }
  238.         close(new_fd);
  239.     }
  240.     close(sock_fd);
  241.     return 0;
  242. }
复制代码

用下列命令编译程序:
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服务的用户的身份登录系统了。
输入系统命令体验一下吧!

论坛徽章:
0
32 [报告]
发表于 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. 后记


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

论坛徽章:
0
33 [报告]
发表于 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

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

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

论坛徽章:
0
34 [报告]
发表于 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目录下提供的一个服务器端例子,代码如下:

  1. /* NOCW */
  2. /* demos/bio/saccept.c */

  3. /* A minimal program to server an SSL connection.
  4. * It uses blocking.
  5. * saccept host:port
  6. * host is the interface IP to use.  If any interface, use *:port
  7. * The default it *:4433
  8. *
  9. * cc -I../../include saccept.c -L../.. -lssl -lcrypto
  10. */

  11. #include <stdio.h>
  12. #include <signal.h>
  13. #include <openssl/err.h>
  14. #include <openssl/ssl.h>

  15. #define CERT_FILE    "server.pem"

  16. BIO *in=NULL;

  17. void close_up()
  18.     {
  19.     if (in != NULL)
  20.         BIO_free(in);
  21.     }

  22. int main(argc,argv)
  23. int argc;
  24. char *argv[];
  25.     {
  26.     char *port=NULL;
  27.     BIO *ssl_bio,*tmp;
  28.     SSL_CTX *ctx;
  29.     SSL *ssl;
  30.     char buf[512];
  31.     int ret=1,i;

  32.         if (argc <= 1)
  33.         port="*:4433";
  34.     else
  35.         port=argv[1];

  36.     signal(SIGINT,close_up);

  37.     SSL_load_error_strings();

  38. #ifdef WATT32
  39.     dbug_init();
  40.     sock_init();
  41. #endif

  42.     /* Add ciphers and message digests */
  43.     OpenSSL_add_ssl_algorithms();

  44.     ctx=SSL_CTX_new(SSLv23_server_method());
  45.     if (!SSL_CTX_use_certificate_file(ctx,CERT_FILE,SSL_FILETYPE_PEM))
  46.         goto err;
  47.     if (!SSL_CTX_use_PrivateKey_file(ctx,CERT_FILE,SSL_FILETYPE_PEM))
  48.         goto err;
  49.     if (!SSL_CTX_check_private_key(ctx))
  50.         goto err;

  51.     /* Setup server side SSL bio */
  52.     ssl=SSL_new(ctx);
  53.     ssl_bio=BIO_new_ssl(ctx,0);

  54.     if ((in=BIO_new_accept(port)) == NULL) goto err;

  55.     /* This means that when a new connection is acceptede on 'in',
  56.      * The ssl_bio will be 'dupilcated' and have the new socket
  57.      * BIO push into it.  Basically it means the SSL BIO will be
  58.      * automatically setup */
  59.     BIO_set_accept_bios(in,ssl_bio);

  60. again:
  61.     /* The first call will setup the accept socket, and the second
  62.      * will get a socket.  In this loop, the first actual accept
  63.      * will occur in the BIO_read() function. */

  64.     if (BIO_do_accept(in) <= 0) goto err;

  65.     for (;;)
  66.         {
  67.         i=BIO_read(in,buf,512);
  68.         if (i == 0)
  69.             {
  70.             /* If we have finished, remove the underlying
  71.              * BIO stack so the next time we call any function
  72.              * for this BIO, it will attempt to do an
  73.              * accept */
  74.             printf("Done\n");
  75.             tmp=BIO_pop(in);
  76.             BIO_free_all(tmp);
  77.             goto again;
  78.             }
  79.         if (i < 0) goto err;
  80.         fwrite(buf,1,i,stdout);
  81.         fflush(stdout);
  82.         }

  83.     ret=0;
  84. err:
  85.     if (ret)
  86.         {
  87.         ERR_print_errors_fp(stderr);
  88.         }
  89.     if (in != NULL) BIO_free(in);
  90.     exit(ret);
  91.     return(!ret);
  92.     }
复制代码

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

  1. /* NOCW */
  2. /* demos/bio/sconnect.c */

  3. /* A minimal program to do SSL to a passed host and port.
  4. * It is actually using non-blocking IO but in a very simple manner
  5. * sconnect host:port - it does a 'GET / HTTP/1.0'
  6. *
  7. * cc -I../../include sconnect.c -L../.. -lssl -lcrypto
  8. */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <unistd.h>
  12. #include <openssl/err.h>
  13. #include <openssl/ssl.h>

  14. extern int errno;

  15. int main(argc,argv)
  16. int argc;
  17. char *argv[];
  18.     {
  19.     char *host;
  20.     BIO *out;
  21.     char buf[1024*10],*p;
  22.     SSL_CTX *ssl_ctx=NULL;
  23.     SSL *ssl;
  24.     BIO *ssl_bio;
  25.     int i,len,off,ret=1;

  26.     if (argc <= 1)
  27.         host="localhost:4433";
  28.     else
  29.         host=argv[1];

  30. #ifdef WATT32
  31.     dbug_init();
  32.     sock_init();
  33. #endif

  34.     /* Lets get nice error messages */
  35.     SSL_load_error_strings();

  36.     /* Setup all the global SSL stuff */
  37.     OpenSSL_add_ssl_algorithms();
  38.     ssl_ctx=SSL_CTX_new(SSLv23_client_method());

  39.     /* Lets make a SSL structure */
  40.     ssl=SSL_new(ssl_ctx);
  41.     SSL_set_connect_state(ssl);

  42.     /* Use it inside an SSL BIO */
  43.     ssl_bio=BIO_new(BIO_f_ssl());
  44.     BIO_set_ssl(ssl_bio,ssl,BIO_CLOSE);

  45.     /* Lets use a connect BIO under the SSL BIO */
  46.     out=BIO_new(BIO_s_connect());
  47.     BIO_set_conn_hostname(out,host);
  48.     BIO_set_nbio(out,1);
  49.     out=BIO_push(ssl_bio,out);

  50.     p="GET / HTTP/1.0\r\n\r\n";
  51.     len=strlen(p);

  52.     off=0;
  53.     for (;;)
  54.         {
  55.         i=BIO_write(out,&(p[off]),len);
  56.         if (i <= 0)
  57.             {
  58.             if (BIO_should_retry(out))
  59.                 {
  60.                 fprintf(stderr,"write DELAY\n");
  61.                 sleep(1);
  62.                 continue;
  63.                 }
  64.             else
  65.                 {
  66.                 goto err;
  67.                 }
  68.             }
  69.         off+=i;
  70.         len-=i;
  71.         if (len <= 0) break;
  72.         }

  73.     for (;;)
  74.         {
  75.         i=BIO_read(out,buf,sizeof(buf));
  76.         if (i == 0) break;
  77.         if (i < 0)
  78.             {
  79.             if (BIO_should_retry(out))
  80.                 {
  81.                 fprintf(stderr,"read DELAY\n");
  82.                 sleep(1);
  83.                 continue;
  84.                 }
  85.             goto err;
  86.             }
  87.         fwrite(buf,1,i,stdout);
  88.         }

  89.     ret=1;

  90.     if (0)
  91.         {
  92. err:
  93.         if (ERR_peek_error() == 0) /* system call error */
  94.             {
  95.             fprintf(stderr,"errno=%d ",errno);
  96.             perror("error");
  97.             }
  98.         else
  99.             ERR_print_errors_fp(stderr);
  100.         }
  101.     BIO_free_all(out);
  102.     if (ssl_ctx != NULL) SSL_CTX_free(ssl_ctx);
  103.     exit(!ret);
  104.     return(ret);
  105.     }
复制代码

编译程序里象一般的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
回复
发布人:

论坛徽章:
0
35 [报告]
发表于 2007-02-04 15:17 |只看该作者

Linux网络编程一步一步学-IPv6下网络编程步骤

论坛徽章:
0
36 [报告]
发表于 2007-02-04 15:27 |只看该作者

Linux网络编程一步一步学-HTTPS客户端程序示例

源代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <errno.h>
  7. #include <unistd.h>
  8. #include <netinet/in.h>
  9. #include <limits.h>
  10. #include <netdb.h>
  11. #include <arpa/inet.h>
  12. #include <ctype.h>
  13. #include <openssl/crypto.h>
  14. #include <openssl/ssl.h>
  15. #include <openssl/err.h>
  16. #include <openssl/rand.h>

  17. #define DEBUG 1

  18. /********************************************
  19. 功能:搜索字符串右边起的第一个匹配字符
  20. ********************************************/
  21. char *Rstrchr(char *s, char x)
  22. {
  23.     int i = strlen(s);
  24.     if (!(*s))
  25.         return 0;
  26.     while (s[i - 1])
  27.         if (strchr(s + (i - 1), x))
  28.             return (s + (i - 1));
  29.         else
  30.             i--;
  31.     return 0;
  32. }

  33. /**************************************************************
  34. 功能:从字符串src中分析出网站地址和端口,并得到用户要下载的文件
  35. ***************************************************************/
  36. void GetHost(char *src, char *web, char *file, int *port)
  37. {
  38.     char *pA;
  39.     char *pB;
  40.     memset(web, 0, sizeof(web));
  41.     memset(file, 0, sizeof(file));
  42.     *port = 0;
  43.     if (!(*src))
  44.         return;
  45.     pA = src;
  46.     if (!strncmp(pA, "http://", strlen("http://")))
  47.         pA = src + strlen("http://");
  48.     else if (!strncmp(pA, "https://", strlen("https://")))
  49.         pA = src + strlen("https://");
  50.     pB = strchr(pA, '/');
  51.     if (pB) {
  52.         memcpy(web, pA, strlen(pA) - strlen(pB));
  53.         if (pB + 1) {
  54.             memcpy(file, pB + 1, strlen(pB) - 1);
  55.             file[strlen(pB) - 1] = 0;
  56.         }
  57.     } else
  58.         memcpy(web, pA, strlen(pA));
  59.     if (pB)
  60.         web[strlen(pA) - strlen(pB)] = 0;
  61.     else
  62.         web[strlen(pA)] = 0;
  63.     pA = strchr(web, ':');
  64.     if (pA)
  65.         *port = atoi(pA + 1);
  66.     else
  67.         *port = 443;
  68. }

  69. /************关于本文档********************************************
  70. *filename: https-client.c
  71. *purpose: 演示HTTPS客户端编程方法
  72. *wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
  73. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
  74. *date time:2007-01-30 20:06
  75. *Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
  76. * 但请遵循GPL
  77. *Thanks to:Google
  78. *Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
  79. * 科技站在巨人的肩膀上进步更快!感谢有开源前辈的贡献!
  80. *********************************************************************/

  81. int main(int argc, char *argv[])
  82. {
  83.     int sockfd, ret;
  84.     char buffer[1024];
  85.     struct sockaddr_in server_addr;
  86.     struct hostent *host;
  87.     int portnumber, nbytes;
  88.     char host_addr[256];
  89.     char host_file[1024];
  90.     char local_file[256];
  91.     FILE *fp;
  92.     char request[1024];
  93.     int send, totalsend;
  94.     int i;
  95.     char *pt;
  96.     SSL *ssl;
  97.     SSL_CTX *ctx;

  98.     if (argc != 2) {
  99.         if (DEBUG)
  100.             fprintf(stderr, "Usage:%s webpage-address\a\n", argv[0]);
  101.         exit(1);
  102.     }
  103.     if (DEBUG)
  104.         printf("parameter.1 is: %s\n", argv[1]);

  105.     GetHost(argv[1], host_addr, host_file, &portnumber);        /*分析网址、端口、文件名等 */
  106.     if (DEBUG)
  107.         printf("webhost:%s\n", host_addr);
  108.     if (DEBUG)
  109.         printf("hostfile:%s\n", host_file);
  110.     if (DEBUG)
  111.         printf("portnumber:%d\n\n", portnumber);

  112.     if ((host = gethostbyname(host_addr)) == NULL) {        /*取得主机IP地址 */
  113.         if (DEBUG)
  114.             fprintf(stderr, "Gethostname error, %s\n", strerror(errno));
  115.         exit(1);
  116.     }

  117.     /* 客户程序开始建立 sockfd描述符 */
  118.     if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {        /*建立SOCKET连接 */
  119.         if (DEBUG)
  120.             fprintf(stderr, "Socket Error:%s\a\n", strerror(errno));
  121.         exit(1);
  122.     }

  123.     /* 客户程序填充服务端的资料 */
  124.     bzero(&server_addr, sizeof(server_addr));
  125.     server_addr.sin_family = AF_INET;
  126.     server_addr.sin_port = htons(portnumber);
  127.     server_addr.sin_addr = *((struct in_addr *) host->h_addr);

  128.     /* 客户程序发起连接请求 */
  129.     if (connect(sockfd, (struct sockaddr *) (&server_addr), sizeof(struct sockaddr)) == -1) {        /*连接网站 */
  130.         if (DEBUG)
  131.             fprintf(stderr, "Connect Error:%s\a\n", strerror(errno));
  132.         exit(1);
  133.     }

  134.     /* SSL初始化 */
  135.     SSL_library_init();
  136.     SSL_load_error_strings();
  137.     ctx = SSL_CTX_new(SSLv23_client_method());
  138.     if (ctx == NULL) {
  139.         ERR_print_errors_fp(stderr);
  140.         exit(1);
  141.     }

  142.     ssl = SSL_new(ctx);
  143.     if (ssl == NULL) {
  144.         ERR_print_errors_fp(stderr);
  145.         exit(1);
  146.     }

  147.     /* 把socket和SSL关联 */
  148.     ret = SSL_set_fd(ssl, sockfd);
  149.     if (ret == 0) {
  150.         ERR_print_errors_fp(stderr);
  151.         exit(1);
  152.     }

  153.     RAND_poll();
  154.     while (RAND_status() == 0) {
  155.         unsigned short rand_ret = rand() % 65536;
  156.         RAND_seed(&rand_ret, sizeof(rand_ret));
  157.     }

  158.     ret = SSL_connect(ssl);
  159.     if (ret != 1) {
  160.         ERR_print_errors_fp(stderr);
  161.         exit(1);
  162.     }

  163.     sprintf(request, "GET /%s HTTP/1.1\r\nAccept: */*\r\nAccept-Language: zh-cn\r\n\
  164. User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)\r\n\
  165. Host: %s:%d\r\nConnection: Close\r\n\r\n", host_file, host_addr,
  166.             portnumber);
  167.     if (DEBUG)
  168.         printf("%s", request);        /*准备request,将要发送给主机 */

  169.     /*取得真实的文件名 */
  170.     if (host_file && *host_file)
  171.         pt = Rstrchr(host_file, '/');
  172.     else
  173.         pt = 0;

  174.     memset(local_file, 0, sizeof(local_file));
  175.     if (pt && *pt) {
  176.         if ((pt + 1) && *(pt + 1))
  177.             strcpy(local_file, pt + 1);
  178.         else
  179.             memcpy(local_file, host_file, strlen(host_file) - 1);
  180.     } else if (host_file && *host_file)
  181.         strcpy(local_file, host_file);
  182.     else
  183.         strcpy(local_file, "index.html");
  184.     if (DEBUG)
  185.         printf("local filename to write:%s\n\n", local_file);

  186.     /*发送https请求request */
  187.     send = 0;
  188.     totalsend = 0;
  189.     nbytes = strlen(request);
  190.     while (totalsend < nbytes) {
  191.         send = SSL_write(ssl, request + totalsend, nbytes - totalsend);
  192.         if (send == -1) {
  193.             if (DEBUG)
  194.                 ERR_print_errors_fp(stderr);
  195.             exit(0);
  196.         }
  197.         totalsend += send;
  198.         if (DEBUG)
  199.             printf("%d bytes send OK!\n", totalsend);
  200.     }

  201.     fp = fopen(local_file, "a");
  202.     if (!fp) {
  203.         if (DEBUG)
  204.             printf("create file error! %s\n", strerror(errno));
  205.         return 0;
  206.     }
  207.     if (DEBUG)
  208.         printf("\nThe following is the response header:\n");
  209.     i = 0;
  210.     /* 连接成功了,接收https响应,response */
  211.     while ((nbytes = SSL_read(ssl, buffer, 1)) == 1) {
  212.         if (i < 4) {
  213.             if (buffer[0] == '\r' || buffer[0] == '\n')
  214.                 i++;
  215.             else
  216.                 i = 0;
  217.             if (DEBUG)
  218.                 printf("%c", buffer[0]);        /*把https头信息打印在屏幕上 */
  219.         } else {
  220.             fwrite(buffer, 1, 1, fp);        /*将https主体信息写入文件 */
  221.             i++;
  222.             if (i % 1024 == 0)
  223.                 fflush(fp);        /*每1K时存盘一次 */
  224.         }
  225.     }
  226.     fclose(fp);
  227.     /* 结束通讯 */
  228.     ret = SSL_shutdown(ssl);
  229.     if (ret != 1) {
  230.         ERR_print_errors_fp(stderr);
  231.         exit(1);
  232.     }
  233.     close(sockfd);
  234.     SSL_free(ssl);
  235.     SSL_CTX_free(ctx);
  236.     ERR_free_strings();
  237.     exit(0);
  238. }
复制代码

编译此程序用下列命令:
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语言编程实现实例

论坛徽章:
0
37 [报告]
发表于 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文件后就可以在自己的程序中使用了,比如做一个加密通讯的服务器

论坛徽章:
0
38 [报告]
发表于 2007-02-04 15:32 |只看该作者

Linux网络编程一步一步学-epoll同时处理海量连接的代码

如果你是做大型项目的,比如同时要求上万人在线的某种程序,比如在线游戏、在线聊天,那怕是一个最简单的支持上万人同时在线的WEB服务器。用原来的方法都比较困难实现的。
下面这段代码就可以支持9997个连接同时在线,当然你可以修改宏定义以支持更多的连接:
#define MAXEPOLLSIZE 10000

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <errno.h>
  4. #include <string.h>
  5. #include <sys/types.h>
  6. #include <netinet/in.h>
  7. #include <sys/socket.h>
  8. #include <sys/wait.h>
  9. #include <unistd.h>
  10. #include <arpa/inet.h>
  11. #include <openssl/ssl.h>
  12. #include <openssl/err.h>
  13. #include <fcntl.h>
  14. #include <sys/epoll.h>
  15. #include <sys/time.h>
  16. #include <sys/resource.h>


  17. #define MAXBUF 1024
  18. #define MAXEPOLLSIZE 10000

  19. /*
  20. setnonblocking - 设置句柄为非阻塞方式
  21. */
  22. int setnonblocking(int sockfd)
  23. {
  24.     if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1) {
  25.         return -1;
  26.     }
  27.     return 0;
  28. }

  29. /*
  30. handle_message - 处理每个 socket 上的消息收发
  31. */
  32. int handle_message(int new_fd)
  33. {
  34.     char buf[MAXBUF + 1];
  35.     int len;
  36.     /* 开始处理每个新连接上的数据收发 */
  37.     bzero(buf, MAXBUF + 1);
  38.     /* 接收客户端的消息 */
  39.     len = recv(new_fd, buf, MAXBUF, 0);
  40.     if (len > 0)
  41.         printf
  42.             ("%d接收消息成功:'%s',共%d个字节的数据\n",
  43.              new_fd, buf, len);
  44.     else {
  45.         if (len < 0)
  46.             printf
  47.                 ("消息接收失败!错误代码是%d,错误信息是'%s'\n",
  48.                  errno, strerror(errno));
  49.         close(new_fd);
  50.         return -1;
  51.     }
  52.     /* 处理每个新连接上的数据收发结束 */
  53.     return len;
  54. }
  55. /************关于本文档********************************************
  56. *filename: epoll-server.c
  57. *purpose: 演示epoll处理海量socket连接的方法
  58. *wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
  59. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
  60. *date time:2007-01-31 21:00
  61. *Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
  62. * 但请遵循GPL
  63. *Thanks to:Google
  64. *Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
  65. * 科技站在巨人的肩膀上进步更快!感谢有开源前辈的贡献!
  66. *********************************************************************/
  67. int main(int argc, char **argv)
  68. {
  69.     int listener, new_fd, kdpfd, nfds, n, ret, curfds;
  70.     socklen_t len;
  71.     struct sockaddr_in my_addr, their_addr;
  72.     unsigned int myport, lisnum;
  73.     struct epoll_event ev;
  74.     struct epoll_event events[MAXEPOLLSIZE];
  75.     struct rlimit rt;

  76.     if (argv[1])
  77.         myport = atoi(argv[1]);
  78.     else
  79.         myport = 7838;

  80.     if (argv[2])
  81.         lisnum = atoi(argv[2]);
  82.     else
  83.         lisnum = 2;

  84.     /* 设置每个进程允许打开的最大文件数 */
  85.     rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;
  86.     if (setrlimit(RLIMIT_NOFILE, &rt) == -1) {
  87.         perror("setrlimit");
  88.         exit(1);
  89.     }
  90.     else printf("设置系统资源参数成功!\n");

  91.     /* 开启 socket 监听 */
  92.     if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
  93.         perror("socket");
  94.         exit(1);
  95.     } else
  96.         printf("socket 创建成功!\n");

  97.     setnonblocking(listener);

  98.     bzero(&my_addr, sizeof(my_addr));
  99.     my_addr.sin_family = PF_INET;
  100.     my_addr.sin_port = htons(myport);
  101.     if (argv[3])
  102.         my_addr.sin_addr.s_addr = inet_addr(argv[3]);
  103.     else
  104.         my_addr.sin_addr.s_addr = INADDR_ANY;

  105.     if (bind
  106.         (listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
  107.         == -1) {
  108.         perror("bind");
  109.         exit(1);
  110.     } else
  111.         printf("IP 地址和端口绑定成功\n");

  112.     if (listen(listener, lisnum) == -1) {
  113.         perror("listen");
  114.         exit(1);
  115.     } else
  116.         printf("开启服务成功!\n");

  117.     /* 创建 epoll 句柄,把监听 socket 加入到 epoll 集合里 */
  118.     kdpfd = epoll_create(MAXEPOLLSIZE);
  119.     len = sizeof(struct sockaddr_in);
  120.     ev.events = EPOLLIN | EPOLLET;
  121.     ev.data.fd = listener;
  122.     if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0) {
  123.         fprintf(stderr, "epoll set insertion error: fd=%d\n", listener);
  124.         return -1;
  125.     } else
  126.         printf("监听 socket 加入 epoll 成功!\n");
  127.     curfds = 1;
  128.     while (1) {
  129.         /* 等待有事件发生 */
  130.         nfds = epoll_wait(kdpfd, events, curfds, -1);
  131.         if (nfds == -1) {
  132.             perror("epoll_wait");
  133.             break;
  134.         }
  135.         /* 处理所有事件 */
  136.         for (n = 0; n < nfds; ++n) {
  137.             if (events[n].data.fd == listener) {
  138.                 new_fd = accept(listener, (struct sockaddr *) &their_addr,
  139.                                 &len);
  140.                 if (new_fd < 0) {
  141.                     perror("accept");
  142.                     continue;
  143.                 } else
  144.                     printf("有连接来自于: %d:%d, 分配的 socket 为:%d\n", inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);

  145.                 setnonblocking(new_fd);
  146.                 ev.events = EPOLLIN | EPOLLET;
  147.                 ev.data.fd = new_fd;
  148.                 if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0) {
  149.                     fprintf(stderr, "把 socket '%d' 加入 epoll 失败!%s\n",
  150.                             new_fd, strerror(errno));
  151.                     return -1;
  152.                 }
  153.                 curfds++;
  154.             } else {
  155.                 ret = handle_message(events[n].data.fd);
  156.                 if (ret < 1 && errno != 11) {
  157.                     epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,
  158.                               &ev);
  159.                     curfds--;
  160.                 }
  161.             }
  162.         }
  163.     }
  164.     close(listener);
  165.     return 0;
  166. }
复制代码

编译此程序用命令:
gcc -Wall epoll-server.c -o server

运行此程序需要具有管理员权限!
sudo ./server 7838 1

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

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

论坛徽章:
0
39 [报告]
发表于 2007-02-04 15:43 |只看该作者

Linux网络编程一步一步学-加密通讯协议SSL研究

服务器端源代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <errno.h>
  4. #include <string.h>
  5. #include <sys/types.h>
  6. #include <netinet/in.h>
  7. #include <sys/socket.h>
  8. #include <sys/wait.h>
  9. #include <unistd.h>
  10. #include <arpa/inet.h>
  11. #include <openssl/ssl.h>
  12. #include <openssl/err.h>

  13. #define MAXBUF 1024
  14. /************关于本文档********************************************
  15. *filename: ssl-server.c
  16. *purpose: 演示利用 OpenSSL 库进行基于 IP层的 SSL 加密通讯的方法,这是服务器端例子
  17. *wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
  18. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
  19. *date time:2007-02-02 19:40
  20. *Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
  21. * 但请遵循GPL
  22. *Thanks to:Google
  23. *Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
  24. * 科技站在巨人的肩膀上进步更快!感谢有开源前辈的贡献!
  25. *********************************************************************/
  26. int main(int argc, char **argv)
  27. {
  28.     int sockfd, new_fd;
  29.     socklen_t len;
  30.     struct sockaddr_in my_addr, their_addr;
  31.     unsigned int myport, lisnum;
  32.     char buf[MAXBUF + 1];
  33.     SSL_CTX *ctx;

  34.     if (argv[1])
  35.         myport = atoi(argv[1]);
  36.     else
  37.         myport = 7838;

  38.     if (argv[2])
  39.         lisnum = atoi(argv[2]);
  40.     else
  41.         lisnum = 2;

  42.     /* SSL 库初始化 */
  43.     SSL_library_init();
  44.     /* 载入所有 SSL 算法 */
  45.     OpenSSL_add_all_algorithms();
  46.     /* 载入所有 SSL 错误消息 */
  47.     SSL_load_error_strings();
  48.     /* 以 SSL V2 和 V3 标准兼容方式产生一个 SSL_CTX ,即 SSL Content Text */
  49.     ctx = SSL_CTX_new(SSLv23_server_method());
  50.     /* 也可以用 SSLv2_server_method() 或 SSLv3_server_method() 单独表示 V2 或 V3标准 */
  51.     if (ctx == NULL) {
  52.         ERR_print_errors_fp(stdout);
  53.         exit(1);
  54.     }
  55.     /* 载入用户的数字证书, 此证书用来发送给客户端。 证书里包含有公钥 */
  56.     if (SSL_CTX_use_certificate_file(ctx, argv[4], SSL_FILETYPE_PEM) <= 0) {
  57.         ERR_print_errors_fp(stdout);
  58.         exit(1);
  59.     }
  60.     /* 载入用户私钥 */
  61.     if (SSL_CTX_use_PrivateKey_file(ctx, argv[5], SSL_FILETYPE_PEM) <= 0) {
  62.         ERR_print_errors_fp(stdout);
  63.         exit(1);
  64.     }
  65.     /* 检查用户私钥是否正确 */
  66.     if (!SSL_CTX_check_private_key(ctx)) {
  67.         ERR_print_errors_fp(stdout);
  68.         exit(1);
  69.     }

  70.     /* 开启一个 socket 监听 */
  71.     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
  72.         perror("socket");
  73.         exit(1);
  74.     } else
  75.         printf("socket created\n");

  76.     bzero(&my_addr, sizeof(my_addr));
  77.     my_addr.sin_family = PF_INET;
  78.     my_addr.sin_port = htons(myport);
  79.     if (argv[3])
  80.         my_addr.sin_addr.s_addr = inet_addr(argv[3]);
  81.     else
  82.         my_addr.sin_addr.s_addr = INADDR_ANY;

  83.     if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
  84.         == -1) {
  85.         perror("bind");
  86.         exit(1);
  87.     } else
  88.         printf("binded\n");

  89.     if (listen(sockfd, lisnum) == -1) {
  90.         perror("listen");
  91.         exit(1);
  92.     } else
  93.         printf("begin listen\n");

  94.     while (1) {
  95.         SSL *ssl;
  96.         len = sizeof(struct sockaddr);
  97.         /* 等待客户端连上来 */
  98.         if ((new_fd =
  99.              accept(sockfd, (struct sockaddr *) &their_addr,
  100.                     &len)) == -1) {
  101.             perror("accept");
  102.             exit(errno);
  103.         } else
  104.             printf("server: got connection from %s, port %d, socket %d\n",
  105.                    inet_ntoa(their_addr.sin_addr),
  106.                    ntohs(their_addr.sin_port), new_fd);

  107.         /* 基于 ctx 产生一个新的 SSL */
  108.         ssl = SSL_new(ctx);
  109.         /* 将连接用户的 socket 加入到 SSL */
  110.         SSL_set_fd(ssl, new_fd);
  111.         /* 建立 SSL 连接 */
  112.         if (SSL_accept(ssl) == -1) {
  113.             perror("accept");
  114.             close(new_fd);
  115.             break;
  116.         }

  117.         /* 开始处理每个新连接上的数据收发 */
  118.         bzero(buf, MAXBUF + 1);
  119.         strcpy(buf, "server->client");
  120.         /* 发消息给客户端 */
  121.         len = SSL_write(ssl, buf, strlen(buf));

  122.         if (len <= 0) {
  123.             printf
  124.                 ("消息'%s'发送失败!错误代码是%d,错误信息是'%s'\n",
  125.                  buf, errno, strerror(errno));
  126.             goto finish;
  127.         } else
  128.             printf("消息'%s'发送成功,共发送了%d个字节!\n",
  129.                    buf, len);

  130.         bzero(buf, MAXBUF + 1);
  131.         /* 接收客户端的消息 */
  132.         len = SSL_read(ssl, buf, MAXBUF);
  133.         if (len > 0)
  134.             printf("接收消息成功:'%s',共%d个字节的数据\n",
  135.                    buf, len);
  136.         else
  137.             printf
  138.                 ("消息接收失败!错误代码是%d,错误信息是'%s'\n",
  139.                  errno, strerror(errno));
  140.         /* 处理每个新连接上的数据收发结束 */
  141.       finish:
  142.         /* 关闭 SSL 连接 */
  143.         SSL_shutdown(ssl);
  144.         /* 释放 SSL */
  145.         SSL_free(ssl);
  146.         /* 关闭 socket */
  147.         close(new_fd);
  148.     }

  149.     /* 关闭监听的 socket */
  150.     close(sockfd);
  151.     /* 释放 CTX */
  152.     SSL_CTX_free(ctx);
  153.     return 0;
  154. }
复制代码

客户端源代码如下:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <errno.h>
  4. #include <sys/socket.h>
  5. #include <resolv.h>
  6. #include <stdlib.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9. #include <unistd.h>
  10. #include <openssl/ssl.h>
  11. #include <openssl/err.h>

  12. #define MAXBUF 1024

  13. void ShowCerts(SSL * ssl)
  14. {
  15.     X509 *cert;
  16.     char *line;

  17.     cert = SSL_get_peer_certificate(ssl);
  18.     if (cert != NULL) {
  19.         printf("数字证书信息:\n");
  20.         line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
  21.         printf("证书: %s\n", line);
  22.         free(line);
  23.         line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
  24.         printf("颁发者: %s\n", line);
  25.         free(line);
  26.         X509_free(cert);
  27.     } else
  28.         printf("无证书信息!\n");
  29. }
  30. /************关于本文档********************************************
  31. *filename: ssl-client.c
  32. *purpose: 演示利用 OpenSSL 库进行基于 IP层的 SSL 加密通讯的方法,这是客户端例子
  33. *wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
  34. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
  35. *date time:2007-02-02 20:10
  36. *Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途
  37. * 但请遵循GPL
  38. *Thanks to:Google
  39. *Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力
  40. * 科技站在巨人的肩膀上进步更快!感谢有开源前辈的贡献!
  41. *********************************************************************/
  42. int main(int argc, char **argv)
  43. {
  44.     int sockfd, len;
  45.     struct sockaddr_in dest;
  46.     char buffer[MAXBUF + 1];
  47.     SSL_CTX *ctx;
  48.     SSL *ssl;

  49.     if (argc != 3) {
  50.         printf
  51.             ("参数格式错误!正确用法如下:\n\t\t%s IP地址 端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个 IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
  52.              argv[0], argv[0]);
  53.         exit(0);
  54.     }

  55.     /* SSL 库初始化,参看 ssl-server.c 代码 */
  56.     SSL_library_init();
  57.     OpenSSL_add_all_algorithms();
  58.     SSL_load_error_strings();
  59.     ctx = SSL_CTX_new(SSLv23_client_method());
  60.     if (ctx == NULL) {
  61.         ERR_print_errors_fp(stdout);
  62.         exit(1);
  63.     }

  64.     /* 创建一个 socket 用于 tcp 通信 */
  65.     if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  66.         perror("Socket");
  67.         exit(errno);
  68.     }
  69.     printf("socket created\n");

  70.     /* 初始化服务器端(对方)的地址和端口信息 */
  71.     bzero(&dest, sizeof(dest));
  72.     dest.sin_family = AF_INET;
  73.     dest.sin_port = htons(atoi(argv[2]));
  74.     if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
  75.         perror(argv[1]);
  76.         exit(errno);
  77.     }
  78.     printf("address created\n");

  79.     /* 连接服务器 */
  80.     if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
  81.         perror("Connect ");
  82.         exit(errno);
  83.     }
  84.     printf("server connected\n");

  85.     /* 基于 ctx 产生一个新的 SSL */
  86.     ssl = SSL_new(ctx);
  87.     SSL_set_fd(ssl, sockfd);
  88.     /* 建立 SSL 连接 */
  89.     if (SSL_connect(ssl) == -1)
  90.         ERR_print_errors_fp(stderr);
  91.     else {
  92.         printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
  93.         ShowCerts(ssl);
  94.     }

  95.     /* 接收对方发过来的消息,最多接收 MAXBUF 个字节 */
  96.     bzero(buffer, MAXBUF + 1);
  97.     /* 接收服务器来的消息 */
  98.     len = SSL_read(ssl, buffer, MAXBUF);
  99.     if (len > 0)
  100.         printf("接收消息成功:'%s',共%d个字节的数据\n",
  101.                buffer, len);
  102.     else {
  103.         printf
  104.             ("消息接收失败!错误代码是%d,错误信息是'%s'\n",
  105.              errno, strerror(errno));
  106.         goto finish;
  107.     }
  108.     bzero(buffer, MAXBUF + 1);
  109.     strcpy(buffer, "from client->server");
  110.     /* 发消息给服务器 */
  111.     len = SSL_write(ssl, buffer, strlen(buffer));
  112.     if (len < 0)
  113.         printf
  114.             ("消息'%s'发送失败!错误代码是%d,错误信息是'%s'\n",
  115.              buffer, errno, strerror(errno));
  116.     else
  117.         printf("消息'%s'发送成功,共发送了%d个字节!\n",
  118.                buffer, len);

  119.   finish:
  120.     /* 关闭连接 */
  121.     SSL_shutdown(ssl);
  122.     SSL_free(ssl);
  123.     close(sockfd);
  124.     SSL_CTX_free(ctx);
  125.     return 0;
  126. }
复制代码

编译程序用下列命令:
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

论坛徽章:
0
40 [报告]
发表于 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个字节字符:

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

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

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

继续上面说的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
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP