参考
- 《TCP/IP网络编程》 尹圣雨
面向连接的服务器端和客户端的编写
理解TCP和UDP
根据数据传输方式的不同，基于网络协议的套接字一般分为TCP套接字和UDP套接字。因为TCP套接字是面向连接的，因此又称为流（stream）的套接字
TCP是Transmission Control Protocol（传输控制协议）的简写，意为“对数据传输过程的控制”
TCP/IP的协议栈
TCP/IP协议栈共分为4层，可以理解数据收发分成了4个层次化过程。（1）应用层；（2）TCP/UDP层；（3）IP层；（4）链路层。各层可能通过操作系统等软件实现，也可能同构类似NIC的硬件设备实现
把协议分成多个层次的优点：（1）协议设计更容易；（2）为了通过标准化操作设计开放式系统
链路层
链路层是物理链接领域标准化的结果，也是最基本的领域，专门定义LAN、WAN、MAN等网络标准
IP层
为了在复杂的网络中传输数据，首先需要考虑路径的选择。IP层解决向目标传输数据需要经过哪条路径，该层使用的协议就是IP
IP本身是面向消息的、不可靠的协议。每次传输数据时会帮我们选择路径，但并不一致。如果传输中发生路径错误，则选择其他路径；但如果发生数据丢失或错误，则无法解决。即，IP协议无法应对数据错误
TCP/UDP层
TCP和UDP层以IP层提供的路径信息为基础完成实际的数据传输，故该层又称为传输层（Transport）
IP层只关注1个数据包的传输过程。因此，即使传输多个数据包，每个数据包也是由IP层实际传输的，即，传输顺序及传输本身是不可靠的。若只利用IP层传输数据，则有可能导致后传输的数据包B比先传输的数据包A提早到达，也有可能某个数据包损毁。
综上，TCP和UDP存在于IP层之上，决定主机之间的数据传输方式，TCP协议确认后向不可靠的IP协议赋予可靠性
应用层
选择数据传输路径、数据确认过程都被吟唱到套接字内部，程序员无需考虑这些过程，大家只需利用套接字编出程序即可。编写软件的过程中，需要根据程序特点决定服务器端和客户端之间的数据传输规则（方式），这便是应用层协议。网络编程的大部分内容就是设计并实现应用层协议
实现基于TCP的服务器端/客户端
TCP服务器端的默认函数调用顺序
- socket()。创建套接字
- bind()。分配套接字地址
- listen()。等待连接请求状态
- accept()。允许连接
- rand()/write()。数据交换
- close()。断开连接
进入等待连接请求状态
调用listen函数进入等待连接请求状态。只有调用了listen函数，客户端才能进入可发出连接请求的状态。即，这时客户端才能调用connect函数（若提前调用将发生错误）
#include <sys/socket.h>
int listen(int sock, int backlog);
成功时返回0，失败时返回-1。sock：希望进入等待连接请求状态的套接字文件描述符，传递的描述符套接字参数成为服务器端套接字（监听套接字）；backlog：连接请求队列（Queue）的长度，若为5，则队列长度为5，表示最多使5个连接请求进入队列
listen函数的第二个参数值与服务器端的特性有关，像频繁接收请求的Web服务器端至少应为15
“服务器端处于等待连接请求状态”是指，客户端请求连接时，受理连接前一直使请求处于等待状态
受理客户端连接请求
调用listen函数后，若有新的连接请求，则应按顺序受理。受理请求意味着进入可接受数据的状态。而服务器端套接字是做门卫的，所以进入这种状态需要另一个套接字，但没必要亲自创建，由accept函数自动创建套接字，并连接到发起请求的客户端
#include <sys/socket.h>
int accept(int sock, struct sockaddr* addr, socklen_t* addrlen);
成功时返回创建的套接字文件描述符，失败时返回-1。sock：服务器套接字的文件描述符；addr：保存发起连接请求的客户端地址信息的变量地址值，调用函数后向传递来的地址变量参数填充客户端地址信息；address：第二个参数addr结构体的长度，但是存有长度的变量地址。函数调用完成后，该变量即被填入客户端地址长度
accept函数受理连接请求等待队列中待处理的客户端连接请求。函数调用成功时，accept函数内部将产生用于数据I/O的套接字，并返回其文件描述符
hello world服务器端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unisted.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);
int main(int argc, char* argv[])
{
int serv_sock;
int clnt_sock;
struct sockaddr_in serv_addr;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size;
char message[] = "Hello World!";
if (argc != 2)
{
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0); // 创建套接字，此时套接字尚非真正的服务器端套接字
if (serv_sock == -1)
{
error_handling("socket() error");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(atoi(argv[1]));
if (bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1)
{
error_handling("bind() error");
}
if (listen(serv_sock, 5) == -1) // 此时套接字才是服务器端套接字
{
error_handling("listen() error");
}
clnt_addr_size = sizeof(clnt_addr);
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size); // 从队头取1个连接请求与客户端建立连接，并返回创建的套接字文件描述符
if (clnt_sock == -1)
{
error_handling("accept() error");
}
write(clnt_sock, message, sizeof(message));
close(clnt_sock);
close(serv_sock);
return 0;
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
TCP客户端的默认函数调用顺序
- socket()。创建套接字
- connect()。请求连接
- read()/write()。交换数据
- close()。断开连接
服务器端调用listen函数后创建连接请求等待队列，之后客户端即可请求连接。使用connect函数发起连接请求
#include <sys/socket.h>
int connect(int sock, struct sockaddr* servaddr, socklen_t addrlen);
成功时返回0，失败时返回-1。sock：客户端套接字文件描述符；servaddr：保存目标服务器端地址信息的变量地址值；addrlen：以字节为单位传递已传递给第二个结构体参数servaddr的地址变量长度
客户端调用connect函数后，发生以下情况之一才会返回（完成函数调用）：
- 服务器端接收连接请求
- 发生断网等异常情况而中断连接请求
所谓的“接收连接”并不意味着服务器端调用accept函数，其实是服务器端把连接请求信息记录到等待队列。因此connect函数返回后并不立即进行数据交换
客户端套接字的地址信息
客户端实现过程中并未出现套接字地址分配，而是创建套接字后立即调用connect函数。因为客户端的IP地址和端口在调用connect函数时自动分配，无需调用标记的bind函数进行分配
何时：调用connect函数时；何地：操作系统内核中；如何：IP用计算机（主机）的IP，端口随机
Hello world客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);
int main(int argc, char* argv[])
{
int sock;
struct sockaddr_in serv_addr;
char message[30];
int str_len;
if (argc != 3)
{
printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
{
error_handling("socket() error");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
serv_addr.sin_port = htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) // 调用connect函数向服务器端发送连接请求
{
error_handling("connect() error!");
}
str_len = read(sock, message, sizeof(message) - 1); // 完成连接后，接收服务器端传输的数据
if (str_len == -1)
{
error_handling("read() error!");
}
printf("Message from server : %s \n", message);
close(sock);
return 0;
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
基于TCP的服务器端/客户端函数调用关系
服务器端创建套接字后连续调用bind、listen函数进入等待状态，客户端通过调用connect函数发起连接请求。需要注意的是，客户端只能等到服务器端调用listen函数后才能调用connect函数。同时，客户端调用connect函数前，服务器端有可能率先调用accept函数，此时服务器端在调用accept函数时进入阻塞（blocking）状态，直到客户端调用connect函数为止
实现迭代服务器端/客户端
实现迭代服务器端
如果服务器端处理完1个客户端连接请求即退出，连接请求等待队列实际没有太大意义。实际上，服务器端应该在设置好等待队列的大小后，应向所有客户端提供服务。如果想继续受理后续的客户端连接请求，最简单的办法就是插入循环语句反复调用accept函数，调用顺序如下：
调用accept函数后，紧接着调用I/O相关的read、write函数，然后调用针对客户端的close函数
迭代回声服务器端/客户端
回声（echo）服务端/客户端，即服务器端将客户端传输的字符串数据原封不动地传回客户端，就像回声一样
程序的基本运行方式：
- 服务器端在同一时刻只与一个客户端相连，并提供回声服务
- 服务器端依次向5个客户端提供服务并退出
- 客户端接收用户输入的字符串并发送到服务器端
- 服务器端将接收的字符串数据传回客户端，即“回声”
- 服务器端与客户端之间的字符串回声一直执行到客户端输入Q为止
回声服务器端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
void error_handling(char* message);
int main(int argc, char* argv[])
{
int serv_sock, clnt_sock;
char message[BUF_SIZE];
int str_len, i;
struct sockaddr_in serv_adr, clnt_adr;
socklen_t clnt_adr_sz;
if (argc != 2)
{
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
if (serv_sock == -1)
{
error_handling("socket() error");
}
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1]));
if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
{
error_handling("bind() error");
}
if (listen(serv_sock, 5) == -1)
{
error_handling("listen() error");
}
clnt_adr_sz = sizeof(clnt_adr);
for(i = 0; i < 5; i++) // 为处理5个客户端连接而添加的循环语句
{
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
if (clnt_sock == -1)
{
error_handling("accept() error");
}
else
{
printf("Connected client %d \n", i+1);
}
while ((str_len = read(clnt_sock, message, BUF_SIZE)) != 0) // 原封不动地传输读取的字符串，如果收到EOF则说明客户端断开连接，退出循环
{
write(clnt_sock, message, str_len);
}
close(clnt_sock); // 针对套接字调用close函数，向连接的相应套接字发送EOF
}
close(serv_sock);
return 0;
}
void error_handling(char* message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
回声客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
void error_handling(char* message);
int main(int argc, char* argv[])
{
int sock;
char message[BUF_SIZE];
int str_len;
struct sockaddr_in serv_adr;
if (argc != 3)
{
printf("Usage: %s <IP> <prot>\n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
{
error_handling("socket() error");
}
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
serv_adr.sin_port = htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
{
error_handling("connect() error!");
}
else
{
puts("Connected..........");
}
while(1)
{
fputs("Input message(Q to quit): ", stdout);
fgets(message, BUF_SIZE, stdin);
if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
{
break;
}
write(sock, message, strlen(message)); // 以字符串为单位传递数据
str_len = read(sock, message, BUF_SIZE-1);
message[str_len] = 0;
printf("Message from server: %s", message);
}
close(sock); // 调用close函数向相应套接字发送EOF
return 0;
}
void error_handling(char* message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
回声客户端存在的问题
每次调用read、write函数时都会以字符串为单位执行实际的I/O操作。由于TCP不存在数据边界，因此，多次调用write函数传递的字符串有可能一次性传递到服务器端。此时客户端有可能从服务器端收到多个字符串
还有可能是，服务器端希望通过1次write函数传递数据，但如果数据太大，操作系统就有可能把数据分成多个数据包发送到客户端。另外，在此过程中，客户端有可能在尚未收到全部数据包时就调用read函数
基于Windows实现
将Linux平台下的示例转化成Windows平台示例的要点：
- 通过WSAStartup、WSACleanup函数初始化并清除套接字相关库
- 把数据类型和变量名切换为Windows风格
- 数据传输中recv、send函数而非read、write函数
- 关闭套接字时用closesocket函数而非close函数
实现回声服务器端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>
#define BUF_SIZE 1024
void ErrorHandling(char* message);
int main(int argc, char* argv[])
{
WSADATA wsaData;
SOCKET hServSock, hClntSock;
char message[BUF_SIZE];
int strLen, i;
SOCKADDR_IN servAdr, clntAdr;
int clntAdrSize;
if (argc != 2)
{
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
ErrorHandling("WSAStartup() error!");
}
hServSock = socket(PF_INET, SOCK_STREAM, 0);
if (hServSock == INVALID_SOCKET)
{
ErrorHandling("socket() error");
}
memset(&servAdr, 0, sizeof(servAdr));
servAdr.sin_family = AF_INET;
servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
servAdr.sin_port = htons(atoi(argv[1]));
if (bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
{
ErrorHandling("bind() error");
}
if (listen(hServSock, 5) == SOCKET_ERROR)
{
ErrorHandling("listen() error");
}
clntAdrSize = sizeof(clntAdr);
for (i = 0; i < 5; i++)
{
hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSize);
if (hClntSock == -1)
{
ErrorHandling("accept() error");
}
else
{
printf("Connected client %d \n", i + 1);
}
while ((strLen = recv(hClntSock, message, BUF_SIZE, 0)) != 0)
{
send(hClntSock, message, strLen, 0);
}
closesocket(hClntSock);
}
closesocket(hServSock);
WSACleanup();
return 0;
}
void ErrorHandling(char* message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
实现回声客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>
#include <WS2tcpip.h>
#define BUF_SIZE 1024
void ErrorHandling(char* message);
int main(int argc, char* argv[])
{
WSADATA wsaData;
SOCKET hSocket;
char message[BUF_SIZE];
int strLen;
SOCKADDR_IN servAdr;
if (argc != 3)
{
printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
ErrorHandling("WSAStartup() error!");
}
hSocket = socket(PF_INET, SOCK_STREAM, 0);
if (hSocket == INVALID_SOCKET)
{
ErrorHandling("socket() error");
}
memset(&servAdr, 0, sizeof(servAdr));
servAdr.sin_family = AF_INET;
inet_pton(AF_INET, argv[1], &servAdr.sin_addr);
servAdr.sin_port = htons(atoi(argv[2]));
if (connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
{
ErrorHandling("connect() error!");
}
else
{
puts("Connected.............");
}
while (1)
{
fputs("Input message(Q to quit): ", stdout);
fgets(message, BUF_SIZE, stdin);
if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
{
break;
}
send(hSocket, message, strlen(message), 0);
strLen = recv(hSocket, message, BUF_SIZE - 1, 0);
message[strLen] = 0;
printf("Message from server: %s", message);
}
closesocket(hSocket);
WSACleanup();
return 0;
}
void ErrorHandling(char* message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
