套接字编程
《TCP/IP Sockets in C》第二版 from 覃辉
# Sockets 基础
说白了,一组用于网络通信的 API
# 网络分组与协议
网络是由主机、路由器和信道构成的图
- 主机(host),是运行应用程序的计算机,是网络的真正“用户”
- 路由器(router),也成网关(gateway),其职责是将信息从一条通信信道转发到另一条通信信道,通常不会运行应用程序
- 通信信道(communication channel),是把字节序列从主机转送到另一台主机的通道,可以是有线的以太网,也可是无线的 WIFI
地址和域名
- 地址:
IP:端口 - IP 地址:IPv4 / IPv6
- 端口号:1 ~ 65535
特殊地址
- 本机地址:
127.0.0.1 / 0:0:0:0:0:0:0:1 - 特殊用途预留
域名(www.baidu.com):Internet 协议处理的是地址,而非域名,所以接收到域名时,要首先解析为地址,再进行处理,这个额外步骤是值得的,因为便于记忆,并提供意义
什么是 URL(Universal Resource Locator)资源定位器,与域名的区别是什么?URL 中总是包含域名
如何解析域名?
- DNS:Domain Name System
- 本地配置数据库代理
# 客户与服务器
就像打电话。客户程序发起通信,服务器程序被动等待,然后相应它的客户,二者共同构成应用程序
使用 Sockets API 与其对应方建立通信的的一般形式决定该程序是充当客户还是服务器
二者的区别还是很明显的,如打电话的一方(客户)需要知道被打电话一方(服务器)的手机号(地址),而被打电话的一方不需要,但在通信建立后,如果需要,也可以获取打电话一方的手机号。需要注意的是,一旦连接建立,服务器和客户之间的区别的就消失了
- 总结来说,客户与服务器的区别只在于谁建立初始连接和谁等待连接
服务器的端口分配遵循 IANA 的分配方式(Internet Assigned Number Authority,Internet编号授权委员会),如 80 分给 HTTP,443 分给 HTTPS,应答协议端口 7
# Sockets 套接字
套接字(Sockets),应用程序发送和接收数据的 API,它允许应用程序插入到网络中并与插入到同一个网络的其他应用程序进行通信
套接字是一个抽象层,是一组 API,应用程序通过这组 API 在计算机端口上进行一系列数据交换
- 需要注意的是,一个应用程序可以连接多个套接字,多个应用程序也可以连接同一个套接字(很少但存在),即同时有一对一、一对多、多对一的连接模式存在
其过程基本为,机 A 通过套接字程序将信息写入套接字服务器 W,机 B 从套接字服务器 W 获取机 A 写入的数据
套接字类型:流套接字(stream socket)和数据报套接字(datagram socket),分别对应 TCP 和 UDP 协议
# TCP 套接字
# IPv4 TCP C/S
IPv4 TCP 客户端
Practical.h
#include "DieWithMessage.c"
#include "SocketAddrUtility.c"
#include "TCPServerUtility.c"
#include "TCPClientUtility.c"
2
3
4
DieWithMessage.c
#include <stdio.h>
#include <stdlib.h>
void DieWithUserMessage(const char *msg, const char *detail){
fputs(msg, stderr);
fputs(": ", stderr);
fputs(detail, stderr);
fputc('\n', stderr);
exit(1);
}
void DieWithSystemMessage(const char *msg){
perror(msg);
exit(1);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
TCPEchoClient4.c:创建套接字,建立连接,发送字符串,接收服务器应答,关闭套接字
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Practical.h"
int main(int argc, char *argv[]){
// printf("hahaha");
// argc = 3;
// argv[1] = "127.0.0.1";
// argv[2] = "hello";
if(argc<3 || argc>4){
DieWithUserMessage("Parameter(s)", "<Server Address> <Echo Word> [<Server Port>]");
}
char *servIP = argv[1];
char *echoString = argv[2];
// cout << servIP << endl << echoString << endl;
in_port_t servPort = (argc==4) ? atoi(argv[3]):7;
// cout << servPort;
int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(sock < 0){
DieWithSystemMessage("socket() failed");
}
struct sockaddr_in servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
int rtnVal = inet_pton(AF_INET, servIP, &servAddr.sin_addr.s_addr);
if(rtnVal == 0){
DieWithUserMessage("inet_pton() failed", "invalid address string");
} else if(rtnVal < 0){
DieWithSystemMessage("inet_pton() failed");
}
servAddr.sin_port = htons(servPort);
if(connect(sock, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0){
DieWithSystemMessage("connect() failed");
}
size_t echoStringLen = strlen(echoString);
ssize_t numBytes = send(sock, echoString, echoStringLen, 0);
if(numBytes < 0){
DieWithSystemMessage("send() failed");
} else if(numBytes != echoStringLen){
DieWithUserMessage("send()", "send unexpedted number of bytes");
}
unsigned int totalBytesRcvd = 0;
fputs("Received: ", stdout);
while(totalBytesRcvd < echoStringLen){
// printf("hahaha");
char buffer[BUFSIZ];
numBytes = recv(sock, buffer, BUFSIZ-1, 0);
if(numBytes < 0){
DieWithSystemMessage("recv() failed");
} else if(numBytes == 0){
DieWithUserMessage("recv()", "connection closed prematurely");
}
totalBytesRcvd += numBytes;
buffer[numBytes] = '\0';
fputs(buffer, stdout);
}
fputc('\n', stdout);
close(sock);
exit(0);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
在运行时传入参数 IP 、数据以及端口,如
./TCPEchoClient4 127.0.0.1 "Hello" 10086
IPv4 TCP 服务器:处理服务器接收到的数据,当通信建立之后,客户和服务器的区分将变得模糊
TCPServerUtility.c
#include <unistd.h> //close
void HandleTCPClient(int clntSocket){
char buffer[BUFSIZ];
ssize_t numBytesRcvd = recv(clntSocket, buffer, BUFSIZ, 0);
if(numBytesRcvd < 0){
DieWithSystemMessage("recv() failed");
}
while(numBytesRcvd > 0){
ssize_t numBytesSent = send(clntSocket, buffer, numBytesRcvd, 0);
if(numBytesSent < 0){
DieWithSystemMessage("send() failed");
} else if(numBytesRcvd != numBytesSent){
DieWithUserMessage("send()", "sent unexpected number of bytes");
}
numBytesRcvd = recv(clntSocket, buffer, BUFSIZ, 0);
if(numBytesRcvd < 0){
DieWithSystemMessage("recv() failed");
}
}
close(clntSocket);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
TCPEchoServer4.c:创建套接字服务端口,绑定套接字,监听套接字,定义处理逻辑
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Practical.h"
static const int MAXPENDING = 5;
int main(int argc, char *argv[]){
if(argc != 2){
DieWithUserMessage("Parameter(s)", "<Server Port>");
}
in_port_t servPort = atoi(argv[1]);
int servSock;
if((servSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
DieWithSystemMessage("socket() failed");
}
struct sockaddr_in servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
servAddr.sin_port = htons(servPort);
if(bind(servSock, (struct sockaddr*) &servAddr, sizeof(servAddr)) < 0){
DieWithSystemMessage("bind() failed");
}
if(listen(servSock, MAXPENDING) < 0){
DieWithSystemMessage("listen() failed");
}
// while(1)
for(;;){
struct sockaddr_in clntAddr;
socklen_t clntAddrLen = sizeof(clntAddr);
int clntSock = accept(servSock, (struct sockaddr*) &clntAddr, &clntAddrLen);
if(clntSock < 0){
DieWithSystemMessage("accept() failed");
}
char clntName[INET_ADDRSTRLEN];
if(inet_ntop(AF_INET, &clntAddr.sin_addr.s_addr, clntName, sizeof(clntName)) != NULL){
printf("Handling client %s:%d\n", clntName, ntohs(clntAddr.sin_port));
} else {
puts("Unable to get client address");
}
HandleTCPClient(clntSock);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
指定端口运行 Server
./TCPEchoServer4 10086
# IPv6 TCP C/S
IPv6 TCP 客户,仅有少许不同
TCPEchoClient6.c
int sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
struct sockaddr_in6 servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin6_family = AF_INET6;
int rtnVal = inet_pton(AF_INET6, servIP, &servAddr.sin6_addr);
servAddr.sin6_port = htons(servPort);
2
3
4
5
6
7
# 八个数
./TCPEchoClient6 0:0:0:0:0:0:0:1 "hello" 9999
2
IPv6 TCP 服务器(bind() failed: Address family not supported by protocol)
TCPEchoServer4.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Practical.h"
static const int MAXPENDING = 5;
int main(int argc, char *argv[]){
if(argc != 2){
DieWithUserMessage("Parameter(s)", "<Server Port>");
}
in_port_t servPort = atoi(argv[1]);
int servSock;
if((servSock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP)) < 0){
DieWithSystemMessage("socket() failed");
}
struct sockaddr_in6 servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin6_family = AF_INET6;
servAddr.sin6_addr = in6addr_any;
servAddr.sin6_port = htons(servPort);
if(bind(servSock, (struct sockaddr*) &servAddr, sizeof(servAddr)) < 0){
DieWithSystemMessage("bind() failed");
}
if(listen(servSock, MAXPENDING) < 0){
DieWithSystemMessage("listen() failed");
}
// while(1)
for(;;){
struct sockaddr_in6 clntAddr;
socklen_t clntAddrLen = sizeof(clntAddr);
int clntSock = accept(servSock, (struct sockaddr*) &clntAddr, &clntAddrLen);
if(clntSock < 0){
DieWithSystemMessage("accept() failed");
}
char clntName[INET6_ADDRSTRLEN];
if(inet_ntop(AF_INET6, &clntAddr.sin6_addr, clntName, sizeof(clntName)) != NULL){
printf("Handling client %s:%d\n", clntName, ntohs(clntAddr.sin6_port));
} else {
puts("Unable to get client address");
}
HandleTCPClient(clntSock);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
和 TCPEchoServer4 很像,修改的地方有 serverSocket 要指定使用 IPv6 地址
int servSock;
if((servSock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP)) < 0){
DieWithSystemMessage("socket() failed");
}
2
3
4
servAddr 的构造,使用 IPv6 协议族
struct sockaddr_in6 servAddr;
memset(&servAddr, 0, sizeof(servAddr));
servAddr.sin6_family = AF_INET6;
servAddr.sin6_addr = in6addr_any;
servAddr.sin6_port = htons(servPort);
2
3
4
5
同理,接收到的 socket 地址传参也要相应改变
for(;;){
struct sockaddr_in6 clntAddr;
//...
char clntName[INET6_ADDRSTRLEN];
if(inet_ntop(AF_INET6, &clntAddr.sin6_addr, clntName, sizeof(clntName)) != NULL){
printf("Handling client %s:%d\n", clntName, ntohs(clntAddr.sin6_port));
} else {
puts("Unable to get client address");
}
}
2
3
4
5
6
7
8
9
10
这里的端口仍为十进制,懂?只有 IP 地址区分 IPv4 和IPv6,端口仍是1-65535
./TCPEchoServer6 9999
# 域名和协议
# 域名地址映射
addrinfo 的结构如下
struct addrinfo{
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr * ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
2
3
4
5
6
7
8
9
10
打印地址信息结构体 socketaddr
struct sockaddr
{
__SOCKADDR_COMMON (sa_); /* Common data: address family and length. */
char sa_data[14]; /* Address data. */
};
#define __SOCKADDR_COMMON(sa_prefix) sa_family_t sa_prefix##family
2
3
4
5
6
7
将根据 socketaddr.sa_family 判断是 IPv4/IPv6,并作出不同处理,给空指针 numericAddress 赋予不同类型的值
void PrintSocketAddress(const struct sockaddr *address, FILE *stream){
if(address == NULL || stream == NULL){
return;
}
void *numericAddress;
char addrBuffer[INET6_ADDRSTRLEN];
in_port_t port;
switch(address->sa_family){
case AF_INET:
numericAddress = &((struct sockaddr_in *) address)->sin_addr;
port = ntohs(((struct sockaddr_in *) address)->sin_port);
break;
case AF_INET6:
numericAddress = &((struct sockaddr_in6 *) address)->sin6_addr;
port = ntohs(((struct sockaddr_in6 *) address) -> sin6_port);
break;
default:
fputs("[unknown type]", stream);
return;
}
if(inet_ntop(address->sa_family, numericAddress, addrBuffer, sizeof(addrBuffer)) == NULL){
fputs("[invalid address]", stream);
} else {
fprintf(stream, "%s", addrBuffer);
if(port != 0){
fprintf(stream, "-%u", port);
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
GetAddrInfo.c 获取地址信息
- 其实很简单,就是调用 netdb 库中 getaddrInfo() 函数获取
IP/域名+端口/服务信息,传入参数依次为 IP/域名、端口/服务、用于储存当前信息的结构体 addrinfo、用于储存所有信息的链表 addrinfo - PrintSocketAddress() 用以打印获取到的地址信息
include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../util/Practical.h"
int main(int argc, char *argv[]){
// 检查参数长度
if(argc != 3){
DieWithUserMessage("Parameter(s)", "<Address/Name> <Port/Service>");
}
char *addrString = argv[1];
char *portString = argv[2];
struct addrinfo addrCriteria;
memset(&addrCriteria, 0, sizeof(addrCriteria));
addrCriteria.ai_family = AF_UNSPEC;
addrCriteria.ai_socktype = SOCK_STREAM;
addrCriteria.ai_protocol = IPPROTO_TCP;
// printf("hahaha\n");
struct addrinfo *addrList;
int rtnVal = getaddrinfo(addrString, portString, &addrCriteria, &addrList);
if(rtnVal != 0){
DieWithUserMessage("getaddrinfo() failed", gai_strerror(rtnVal));
}
for(struct addrinfo *addr=addrList; addr!=NULL; addr=addr->ai_next){
PrintSocketAddress(addr->ai_addr, stdout);
fputc('\n', stdout);
}
freeaddrinfo(addrList);
exit(0);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
./GetAddrInfo 127.0.0.1 time
127.0.0.1-37
./GetAddrInfo www.baidu.com time
183.232.231.174-37
183.232.231.172-37
./GetAddrInfo www.bilibili.com time
117.169.96.198-37
117.169.96.199-37
111.48.57.44-37
111.48.57.46-37
111.48.57.45-37
117.169.96.200-37
2409:8c38:c40:100::243-37
2409:8c38:c40:100::242-37
2409:8c4c:c00:9::23-37
2409:8c4c:c00:9::22-37
2409:8c4c:c00:9::24-37
2409:8c38:c40:100::241-37
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
从数字获取名称:与 getaddrinfo() 相反,提供有函数 getnameinfo()
int getnameinfo(const struct sockaddr *address, socklen_t addressLength, char *node, socklen_t nodeLength, char *service, socklen_t serviceLength, int flags)
# TCP 客户端
通用指地址通用,什么是地址通用?如以上的 PrintSocketAddress() 函数就是一个 IPv4 和 IPv6 通用的代码,他会根据进入 socketaddr 的协议族判断其地址类型并作出相应反应
接下来,我们将重写 TCP 协议下的 Socket 客户和服务器,使之地址通用,拥有自选共能
TCPClientUtility.c
- 实现 SetupTCPClientSocket 方法,传入主机名(IP/域名)和服务(服务名/端口号),与之建立连接,返回建立好的 socket 套接字编号
- 这里会持续搜索服务器端口直到建立连接或全部搜索完,失败将返回 -1
int SetupTCPClientSocket(const char *host, const char *service){
struct addrinfo addrCriteria;
memset(&addrCriteria, 0, sizeof(addrCriteria));
addrCriteria.ai_family = AF_UNSPEC;
addrCriteria.ai_socktype = SOCK_STREAM;
addrCriteria.ai_protocol = IPPROTO_TCP;
struct addrinfo *servAddr;
int rtnVal = getaddrinfo(host, service, &addrCriteria, &servAddr);
if(rtnVal != 0){
DieWithUserMessage("getaddrinfo() failed", gai_strerror(rtnVal));
}
int sock = -1;
for(struct addrinfo *addr = servAddr; addr != NULL; addr = addr->ai_next){
sock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
if(sock < 0){
continue;
}
// connet 返回 0 表示 socket 创建成功,返回 socket 编码
if(connect(sock, addr->ai_addr, addr->ai_addrlen) == 0){
break;
}
close(sock);
sock = -1;
}
freeaddrinfo(servAddr);
return sock;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
TCPEchoClient.c
- 与特定客户中建立 socket 的方法不一样,其余完全保持一致
- 在原先的 TCPEchoClient4.c 中,是先建立一个空的 socket,然后填充服务器信息,最后使用 connect 函数对 socket 和服务器进行连接
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include "../util/Practical.h"
int main(int argc, char *argv[]){
if(argc<3 || argc>4){
DieWithUserMessage("Parameter(s)", "<Server Address> <Echo Word> [<Server Port>]");
}
char *server = argv[1];
char *echoString = argv[2];
// cout << servIP << endl << echoString << endl;
// echo 应答程序的端口默认为7
char *service;
if(argc == 4){
service = argv[3];
} else {
service = "echo";
}
int sock = SetupTCPClientSocket(server, service);
if(sock < 0){
DieWithUserMessage("SetupTCPClientSocket() failed", "unable to connect");
}
size_t echoStringLen = strlen(echoString);
ssize_t numBytes = send(sock, echoString, echoStringLen, 0);
if(numBytes < 0){
DieWithSystemMessage("send() failed");
} else if(numBytes != echoStringLen){
DieWithUserMessage("send()", "send unexpedted number of bytes");
}
unsigned int totalBytesRcvd = 0;
fputs("Received: ", stdout);
while(totalBytesRcvd < echoStringLen){
// printf("hahaha");
char buffer[BUFSIZ];
numBytes = recv(sock, buffer, BUFSIZ-1, 0);
if(numBytes < 0){
DieWithSystemMessage("recv() failed");
} else if(numBytes == 0){
DieWithUserMessage("recv()", "connection closed prematurely");
}
totalBytesRcvd += numBytes;
buffer[numBytes] = '\0';
fputs(buffer, stdout);
}
fputc('\n', stdout);
close(sock);
exit(0);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# TCP 服务器
在 TCPServerUtility.c 中添加两个函数(原有 HandleTCPClient)
SetupTCPServerSocket(const char *service) 根据传入的服务或接口建立一个 TCP Socket 服务器并开始监听该端口
封装了 socket() bind() listen() 三个步骤
AcceptTCPConnection(int servSock) 在服务端口上接收连接,封装了 accept() 函数
#include <unistd.h> //close
#include <stdio.h>
#include <netdb.h>
#include <string.h>
static const int MAXPENDING = 5;
int SetupTCPServerSocket(const char *service){
struct addrinfo addrCriteria;
memset(&addrCriteria, 0, sizeof(addrCriteria));
addrCriteria.ai_family = AF_UNSPEC;
addrCriteria.ai_flags = AI_PASSIVE;
addrCriteria.ai_socktype = SOCK_STREAM;
addrCriteria.ai_protocol = IPPROTO_TCP;
struct addrinfo *servAddr;
int rtnVal = getaddrinfo(NULL, service, &addrCriteria, &servAddr);
if(rtnVal != 0){
DieWithUserMessage("getaddrinfo() failed", gai_strerror(rtnVal));
}
int servSock = -1;
for(struct addrinfo *addr = servAddr; addr != NULL; addr = addr->ai_next){
servSock = socket(servAddr->ai_family, servAddr->ai_socktype, servAddr->ai_protocol);
if(servSock < 0){
continue;
}
int bindRtn = bind(servSock, servAddr->ai_addr, servAddr->ai_addrlen);
int listRtn = listen(servSock, MAXPENDING);
if(bindRtn == 0 && listRtn == 0){
struct sockaddr_storage localAddr;
socklen_t addrSize = sizeof(localAddr);
if(getsockname(servSock, (struct sockaddr *)&localAddr, &addrSize) < 0){
DieWithSystemMessage("getsockname() failed");
}
fputs("Binding to ", stdout);
PrintSocketAddress((struct sockaddr *) &localAddr, stdout);
fputc('\n', stdout);
break;
}
close(servSock);
servSock = -1;
}
freeaddrinfo(servAddr);
return servSock;
}
int AcceptTCPConnection(int servSock){
struct sockaddr_storage clntAddr;
socklen_t clntAddrLen = sizeof(clntAddr);
int clntSock = accept(servSock, (struct sockaddr *)&clntAddr, &clntAddrLen);
if(clntSock < 0){
DieWithSystemMessage("accept() failed");
}
fputs("Handling client ", stdout);
PrintSocketAddress((struct sockaddr *) &clntAddr, stdout);
fputc('\n', stdout);
return clntSock;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
TCPEchoServer.c
- socket() 创建、bind() 绑定、listen() 监听服务器端口
- accept 接收连接(阻塞)
#include <stdio.h>
#include <unistd.h>
#include "../util/Practical.h"
int main(int argc, char *argv[]){
if(argc != 2){
DieWithUserMessage("Parameter(s)", "<>Server Port/Service");
}
char *service = argv[1];
int servSock = SetupTCPServerSocket(service);
if(servSock < 0){
DieWithUserMessage("SetupTCPServerSocket() failed", service);
}
for(;;){
int clntSock = AcceptTCPConnection(servSock);
HandleTCPClient(clntSock);
close(clntSock);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# UDP 套接字
TCP 像是打电话,在通信前需要连接(三次握手 connect),通信后需要断开连接(四次挥手 close),而 UDP 像是发送邮件,既不需要连接更不需要断开连接,通过 sendto() 函数直接发送到某一个 UDP 服务器/客户,通过 recvfrom() 函数直接接收某一个客户/服务器发送的信息
另外,UDP 套接字提供的通信传输是一种尽力而为的服务(点到点),它不保证通过 UDP 套接字发送的信息将会到达目的地,这意味着 UDP 套接字程序需要准备处理消息的丢失和重排
网络模型
- OIS 七层模型
- TCP/IP 四层模型
- TCP/IP 五层模型
OSI 模型与 TCP/IP 模型对照
点到点、端到端服务:在TCP/IP协议中,数据网络层(网际网层/IP层)及以下提供点到点服务,传输层提供端到端服务。端到端与点到点是针对网络中传输的两端设备间的关系而言的
end to end:指的是在数据传输前,经过各种各样的交换设备,在两端设备问建立一条链路,就僚它们是直接相连的一样,链路建立后,发送端就可以发送数据,直至数据发送完毕,接收端确认接收成功。TCP 属于端到端协议
- 优点:链路建立后,发送端知道接收设备一定能收到,而且经过中间交换设备时不需要进行存储转发,因此传输延迟小
- 缺点
- 直到接收端收到数据为止,发送端的设备一直要参与传输。如果整个传输的延迟很长,那么对发送端的设备造成很大的浪费
- 如果接收设备关机或故障,那么端到端传输不可能实现
point to point:指的是发送端把数据传给与它直接相连的设备,这台设备在合适的时候又把数据传给与之直接相连的下一台设备,通过一台一台直接相连的设备,把数据传到接收端
- 优点
- 发送端设备送出数据后,它的任务已经完成,不需要参与整个传输过程,这样不会浪费发送端设备的资源
- 即使接收端设备关机或故障,点到点传输也可以采用存储转发技术进行缓冲
- 缺点:发送端发出数据后,不知道接收端能否收到或何时能收到数据,比如 UDP
# UDP 客户
UDPEchoClient.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>
#include "../util/Practical.h"
#define MAXSTRINGLENGTH 1024
int main(int argc, char *argv[]){
if(argc < 3 || argc > 4){
DieWithUserMessage("Parameter(s)",
"<Server Address/Name> <Echo Word> [<Server Port/Service>]");
}
char *server = argv[1];
char *echoString = argv[2];
size_t echoStringLen = strlen(echoString);
if(echoStringLen > MAXSTRINGLENGTH){
DieWithUserMessage("echoString", "string too long");
}
char *serverPort;
if(argc == 4){
serverPort = argv[3];
} else {
serverPort = "echo";
}
struct addrinfo addrCriteria;
memset(&addrCriteria, 0, sizeof(addrCriteria));
addrCriteria.ai_family = AF_UNSPEC; // 任意IP地址
addrCriteria.ai_socktype = SOCK_DGRAM; // datagram 报文套接字,并非流式
addrCriteria.ai_protocol = IPPROTO_UDP;
struct addrinfo *servAddr;
int rtnVal = getaddrinfo(server, serverPort, &addrCriteria, &servAddr);
if(rtnVal != 0){
DieWithUserMessage("getaddrinfo() failed", gai_strerror(rtnVal));
}
int sock = socket(servAddr->ai_family, servAddr->ai_socktype, servAddr->ai_protocol); // UDP
if(sock < 0){
DieWithSystemMessage("socket() failed");
}
ssize_t numBytes = sendto(sock, echoString, echoStringLen, 0,
servAddr->ai_addr, servAddr->ai_addrlen);
if(numBytes < 0){
DieWithSystemMessage("sendto() failed");
} else if(numBytes != echoStringLen){
DieWithUserMessage("sendto() error", "sent unexpected number of bytes");
}
struct sockaddr_storage fromAddr;
socklen_t fromAddrLen = sizeof(fromAddr);
char buffer[MAXSTRINGLENGTH+1];
numBytes = recvfrom(sock, buffer, MAXSTRINGLENGTH, 0,
(struct sockaddr *) &fromAddr, &fromAddrLen);
if(numBytes < 0){
DieWithSystemMessage("recvfrom() failed");
} else if(numBytes != echoStringLen){
DieWithUserMessage("recvfrom() error", "received unexpected number of bytes");
}
if(!SockAddrsEqual(servAddr->ai_addr, (struct sockaddr *) &fromAddr)){
DieWithUserMessage("recvfrom()", "recvived a packet from unknown source");
}
freeaddrinfo(servAddr);
buffer[echoStringLen] = '\0';
printf("Recvived: %s\n", buffer);
close(sock);
exit(0);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# UDP 服务器
UDPEchoServer.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "../util/Practical.h"
#define MAXSTRINGLENGTH 1024
int main(int argc, char *argv[]){
if(argc != 2){
DieWithUserMessage("Parameter(s)", "<Server Port>");
}
char *service = argv[1];
int servSock;
if((servSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
DieWithSystemMessage("socket() failed");
}
struct addrinfo addrCriteria;
memset(&addrCriteria, 0, sizeof(addrCriteria));
addrCriteria.ai_family = AF_UNSPEC; // 任意地址族
addrCriteria.ai_socktype = SOCK_DGRAM; // datagram 报文套接字,并非流式
addrCriteria.ai_protocol = IPPROTO_UDP;
addrCriteria.ai_flags = AI_PASSIVE;
struct addrinfo *servAddr;
int rtnVal = getaddrinfo(NULL, service, &addrCriteria, &servAddr);
if(rtnVal != 0){
DieWithUserMessage("getaddrinfo() failed", gai_strerror(rtnVal));
}
int sock = socket(servAddr->ai_family, servAddr->ai_socktype, servAddr->ai_protocol);
if(sock < 0){
DieWithSystemMessage("socket() failed");
}
if(bind(sock, servAddr->ai_addr, servAddr->ai_addrlen) < 0){
DieWithSystemMessage("bing() failed");
}
freeaddrinfo(servAddr);
// while(1)
for(;;){
struct sockaddr_storage clntAddr;
socklen_t clntAddrLen = sizeof(clntAddr);
char buffer[MAXSTRINGLENGTH];
ssize_t numBytesRcvd = recvfrom(sock, buffer, MAXSTRINGLENGTH, 0,
(struct sockaddr *) &clntAddr, &clntAddrLen);
if(numBytesRcvd < 0){
DieWithSystemMessage("recvfrom() failed");
}
fputs("Handling client ", stdout);
PrintSocketAddress((struct sockaddr *) &clntAddr, stdout);
fputc('\n', stdout);
ssize_t numBytesSent = sendto(sock, buffer, numBytesRcvd, 0,
(struct sockaddr *) &clntAddr, sizeof(clntAddr));
if(numBytesSent < 0){
DieWithSystemMessage("sendto() failed");
} else if(numBytesRcvd != numBytesSent){
DieWithUserMessage("sendto() ", "sent unexpected number of bytes");
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
# 数据封装
协议:关于在通信信道上交换的信息(数据)的形式和含义的协定
TCP/IP 协议在传输用户数据的字节时,将不会检查或修改它们,但信息必须以块的形式发送和接收,这些块的长度是 8 的倍数,因此我们将消息视作字节(byte)的序列
整数编码:在某种意义上,所有类型的信息最终都将被编码乘固定大小的整数
Sizing.c
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <cstdint>
int main(){
printf("CHAR_BIT is %d\n\n", CHAR_BIT); //char数据字节大小
printf("sizeof char is %d\n\n", sizeof(char));
printf("sizeof short is %d\n\n", sizeof(short));
printf("sizeof int is %d\n\n", sizeof(int));
printf("sizeof long is %d\n\n", sizeof(long));
printf("sizeof long long is %d\n\n", sizeof(long long));
printf("sizeof int8_t is %d\n\n", sizeof(int8_t));
printf("sizeof int16_t is %d\n\n", sizeof(int16_t));
printf("sizeof int32_t is %d\n\n", sizeof(int32_t));
printf("sizeof int64_t is %d\n\n", sizeof(int64_t));
printf("sizeof uint8_t is %d\n\n", sizeof(uint8_t));
printf("sizeof uint16_t is %d\n\n", sizeof(uint16_t));
printf("sizeof uint32_t is %d\n\n", sizeof(uint32_t));
printf("sizeof uint64_t is %d\n\n", sizeof(uint64_t));
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
CHAR_BIT is 8
sizeof char is 1
sizeof short is 2
sizeof int is 4
sizeof long is 8
sizeof long long is 8
sizeof int8_t is 1
sizeof int16_t is 2
sizeof int32_t is 4
sizeof int64_t is 8
sizeof uint8_t is 1
sizeof uint16_t is 2
sizeof uint32_t is 4
sizeof uint64_t is 8
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
字节排序:大端顺序和小端顺序,例如对于字节序列 AB(十六进制)
- 大端顺序:1011
- 小端顺序:1110
Internet 中大多数都使用大端顺序,于是大端顺序也被称为网络字节顺序;由硬件使用的字节顺序(可能大端可能小端),被称为本机字节顺序。在进行信息传递时,必须保证客户和服务器采用同种字节顺序,这里就涉及到了字节顺序的转换
在 Socket API 中提供了类似与 htons()/htonl() 的字节顺序转换函数,并且总是统一使用网络字节顺序,即大端顺序
- hton() 意为 host to network short,htonl() 意为 host to network long
- 相对应有 ntohs()/ntohl(),network to host
超越基本的套接字编程
- 套接字选项
- 信号
- 非阻塞 I/O
- 多任务处理
- 多路复用
- 多个接收者
# WebSocket 编程
# WS Java 服务器
Maven 依赖
<dependencies>
<!--WebSocket-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
</dependencies>
2
3
4
5
6
7
配置单例,注入 bean
WebsocketConfig.java
@Configuration
public class WebSocketConfig {
/**
* WebSocket 服务器节点
*
* 如果使用独立的servlet容器,而不是直接使用springboot的内置容器,就不要注入ServerEndpointExporter,因为它将由容器自己提供和管理
* @return
*/
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
服务器实现
WebSocketServer.java
@Component
@Slf4j
@Service
@ServerEndpoint("/chat/{sid}")
public class WebSocketServer {
//静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
private static int onlineCount = 0;
//concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。
private static final CopyOnWriteArraySet<WebSocketServer> webSocketSet = new CopyOnWriteArraySet<WebSocketServer>();
//与某个客户端的连接会话,需要通过它来给客户端发送数据
private Session session;
//接收sid
private String sid = "";
/**
* 连接建立成功调用的方法
*/
@OnOpen
public void onOpen(Session session, @PathParam("sid") String sid) {
this.session = session;
this.sid = sid;
webSocketSet.add(this); //加入set中
addOnlineCount(); //在线数加1
try {
sendMessage("Connection Test Message");
log.info("有新窗口开始监听:" + sid + ", 当前总共在线人数为:" + getOnlineCount());
} catch (IOException e) {
log.error("websocket IO Exception");
}
}
/**
* 连接关闭调用的方法
*/
@OnClose
public void onClose() {
webSocketSet.remove(this); //从set中删除
subOnlineCount(); //在线数减1
//断开连接情况下,更新主板占用情况为释放
log.info("释放的sid为:" + sid);
//这里写你 释放的时候,要处理的业务
log.info("有一连接关闭!当前在线人数为" + getOnlineCount());
}
/**
* 收到客户端消息后调用的方法
* @ Param message 客户端发送过来的消息
*/
// 全双工通信,服务器接收到客户端的消息后进行处理,可以是分发,可以是其他
// 这里是将信息发送给 sid 相同的所有连接
@OnMessage
public void onMessage(String message, Session session) {
log.info("收到来自窗口 " + sid + " 的信息:" + message);
//群发消息
for (WebSocketServer item : webSocketSet) {
if(item.sid.equals(sid)){
try {
item.sendMessage(message);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* @ Param session
* @ Param error
*/
@OnError
public void onError(Session session, Throwable error) {
log.error("发生错误");
error.printStackTrace();
}
/**
* 实现服务器主动推送
*/
public void sendMessage(String message) throws IOException {
this.session.getBasicRemote().sendText(message);
}
/**
* 群发自定义消息
*/
public static void sendInfo(String message, @PathParam("sid") String sid) throws IOException {
log.info("推送消息到窗口" + sid + ",推送内容:" + message);
for (WebSocketServer item : webSocketSet) {
try {
//这里可以设定只推送给这个sid的,为null则全部推送
if (sid == null) {
item.sendMessage(message);
} else if (item.sid.equals(sid)) {
item.sendMessage(message);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static synchronized int getOnlineCount() {
return onlineCount;
}
public static synchronized void addOnlineCount() {
WebSocketServer.onlineCount++;
}
public static synchronized void subOnlineCount() {
WebSocketServer.onlineCount--;
}
public static CopyOnWriteArraySet<WebSocketServer> getWebSocketSet() {
return webSocketSet;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
在 Spring 启动类上加入注解,允许 WebSocket 服务器运行
@EnableWebSocket
# WS JS 客户端
全双工通信
- 客户端可以主动向服务器发送信息,即前端调用
WebSocket.send()函数 - 后端编写的 WebSocketServer 将处理接收到的客户端信息,通过 set 中存储的一个个 session,将收到的消息根据 sid 群发出去,客户端由于 session 和 websocket 的工作机制,将时刻监听这个消息,同时在前端作出相应反应
前端代码示例
<h2 class="major">共有<strong th:text="${count}"></strong>人在公共聊天室</h2>
<p id="user" th:text="${name}" style="display: none"></p>
<p id="login" th:text="${login}" style="display: none"></p>
<p id="room" th:text="${room}" style="display: none"></p>
<script>
let user = document.getElementById("user").innerText;
let login = document.getElementById("login").innerText;
console.log(name);
// 连接 websocket 服务器
let websocket = null;
let room = document.getElementById("room").innerText;
//判断当前浏览器是否支持WebSocket
if(room === "null"){
throw SyntaxError();
} else if('WebSocket' in window) {
//改成你的地址http
websocket = new WebSocket("ws://fx35xt.natappfree.cc/chat/"+room);
} else {
alert('当前浏览器 Not support websocket')
}
//连接发生错误的回调方法
websocket.onerror = function() {
setMessageInnerHTML("WebSocket 连接发生错误");
};
//连接成功建立的回调方法
websocket.onopen = function() {
setMessageInnerHTML("WebSocket 连接成功");
}
//let U01data, Uidata, Usdata;
//接收到消息的回调方法
websocket.onmessage = function(event) {
console.log(event);
setMessageInnerHTML(event.data);
//setechart()
}
//连接关闭的回调方法
websocket.onclose = function() {
setMessageInnerHTML("WebSocket 连接关闭");
}
//监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。
window.onbeforeunload = function() {
closeWebSocket();
}
//将消息显示在网页上
function setMessageInnerHTML(innerHTML) {
while(innerHTML.length > 32){
document.getElementById('message').innerHTML += innerHTML.substring(0, 32) + '<br/>';
innerHTML = innerHTML.substring(32);
}
document.getElementById('message').innerHTML += innerHTML + '<br/><br/>';
}
//关闭WebSocket连接
function closeWebSocket() {
websocket.close();
}
//发送消息
function send() {
let message = document.getElementById('text').value;
websocket.send(message);
document.getElementById("text").value = "";
// websocket.send('{"msg":"' + message + '"}');
// setMessageInnerHTML(message + " ");
}
</script>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74