
平台论坛博客文库

论坛徽章:: 0

21楼 [报告]

发表于 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句柄进行读写操作！

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

zhoulifa

丰衣足食

论坛徽章:: 0

22楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

23楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

24楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

25楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

26楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

27楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

28楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

29楼 [报告]

发表于 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

丰衣足食

论坛徽章:: 0

30楼 [报告]

发表于 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 编辑 ]

1 234 5 6 7 / 7 页下一页

返回列表

Chinaunix › 论坛 › 程序设计 › C/C++ › Linux网络编程一步一步学-IPv6下网络编程步骤

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

Linux网络编程一步一步学-向客户端发送消息

Linux网络编程一步一步学-客户端和服务器端互相收发消息

Linux网络编程一步一步学-UDP编程介绍

Linux网络编程一步一步学-UDP方式点对点通讯

Linux网络编程一步一步学-UDP方式广播通讯

Linux网络编程一步一步学-网络广播、组播与单播

Linux网络编程一步一步学-UDP组播

Linux网络编程一步一步学-同步聊天程序

Linux网络编程一步一步学-异步通讯聊天程序select

Linux网络编程一步一步学-编写一个HTTP协议的目录浏览和文件下载服务器