【网络\Linux】Linux网络编程-TCP,UDP套接字编程及代码示范
这里写目录标题
- UDP类
-
- UDP服务端单执行流
- UDP客户端
- TCP类
-
- TCP单执行流服务器
- TCP客户端
- TCP多执行流(线程)
- TCP多执行流(进程)
本文我们分为TCP和UDP协议网络程序的编写：
他们的区别如下：
| 项目 | 特点 |
|---|---|
| UDP | 用户数据报协议，无需连接，不可靠，面向数据报，其实时性>可靠性（典型的就是视频传输） |
| TCP | 传输控制协议，面向连接，可靠，面向字节流，其可靠性>实时性（文件传输） |
UDP类
1 #include <cstdio>
2 #include <iostream>
3 #include <string>
4 #include <unistd.h>
5 #include <arpa/inet.h>
6 #include <netinet/in.h>
7 #include <sys/socket.h>
8 //dup网络协议类
9 //需要实现5个接口，
10 //1.创建套接字
11 //2.绑定地址信息（一般是服务器端需要）
12 //3.发送数据
13 //4.接受数据
14 class UDPSocket{
15 //套接字的成员变量就是套接字操作句柄
16 private:
17 int _sockfd;
18
19 public:
20
21 UDPSocket()
22 :_sockfd(-1){
}
23 //创建套接字
24 //socket（地址域类型，套接字类型，本次通信协议）
25 bool Socket(){
26 _sockfd=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
27 if(_sockfd<0){
28 perror("socket error");
29 return false;
30 }
31 return true;
32 }
33
34
35 //绑定地址信息（套接字操作句柄，addr结构体地址信息指针，地址信息长度）
36 //不同的通讯协议地址信息大小不同
37 //统一的接口是sockaddr（为了接口规范）16字节
38 //ipv4是sockaddr_in 16字节
39 //封装的接口需要ip地址和port值
40 bool Bind(const std::string &ip,uint16_t port){
41 struct sockaddr_in addr;
42 addr.sin_family=AF_INET;
43 addr.sin_port=htons(port);
44 addr.sin_addr.s_addr=inet_addr(ip.c_str());
45 socklen_t len=sizeof(struct sockaddr_in);
46 int ret;
47 //第二参数要穿地址！！
48 ret=bind(_sockfd,(struct sockaddr*)&addr,len);
49 if(ret<0){
50 perror("bind error");
51 return false;
52 }
53 return true;
54 }
55
56
57 //发送数据接口
58 //（套接字操作句柄，发送空间首地址，数据长度，0阻塞，对端地址信息，对端地址结构长度）
59 //封装的接口要数据的地址信息，对端ip和port
60 //注意ip是const，可以直接以"192.0.0.0"格式发送，否则只能是string类型
61 //因为"192.0.0.0"是常量字符串
62 bool Send(std::string& data,const std::string &ip,u_int16_t port){
63 struct sockaddr_in addr;
64 addr.sin_family=AF_INET;
65 addr.sin_port=htons(port);
66 addr.sin_addr.s_addr=inet_addr(ip.c_str());
67 socklen_t len=sizeof(struct sockaddr_in);
68 int ret=sendto(_sockfd,data.c_str(),data.size(),0,(sockaddr*)&addr,len);
69 if(ret<0){
70 perror("sendto error");
71 return false;
72 }
73 return true;
74 }
75
76 //接受数据（操作句柄，接受空间地址，接收数据长度，0阻塞，（输出参数）发送源端地址信息，（输入输出型参数）指定接收的地质结构大小，返回实际的大小）
77 ///封装的接口是接受地址，接收发送方ip和port的地址（一般情况可以不接受，指定为NULL表示不需要直到发送方的信息）
78 bool Recv(std::string * buf,std::string* ip=NULL,int * port=NULL){
79 struct sockaddr_in addr;
80 socklen_t len=sizeof(struct sockaddr_in);
81 char tmp[1024]={
0};
82 int ret=recvfrom(_sockfd,tmp,1024,0,(sockaddr*)&addr,&len);
83 if(ret<0){
84 perror("sendto error");
85 return false;
86 }
87 //ret为世界接收到的数据长度
88 buf->assign(tmp,ret);
89
90 if(ip!=NULL){
91 *ip=inet_ntoa(addr.sin_addr);
92 }
93 if(port!=NULL){
94 *port=ntohs(addr.sin_port);
95 }
96 return true;
97 }
98
99 //关闭套接字
100 bool Close(){
101 if(_sockfd!=-1){
102 close(_sockfd);
103 }
104 return true;
105 }
106
107 };
UDP服务端单执行流
1 #include"classudp.hpp"
2
3 #define CHECK_RET(q) if((q)==false){
return -1;}
4 //服务端需要做的步骤：
5 //1.创建套接字
6 //2.绑定地址信息
7 //3.接收数据，（如果需要反馈给客户端则需要记录地址信息）
8 //4.发送数据
9 int main(){
10 UDPSocket ssock;
11 CHECK_RET(ssock.Socket());
12 CHECK_RET(ssock.Bind("192.168.107.128",9000));
13 while(1){
14 std::string buf;
15 int cliport;
16 std::string clip;
17 CHECK_RET(ssock.Recv(&buf,&clip,&cliport));
18 std::cout<<"client say: "<<buf<<std::endl;
19 buf.clear();//清空缓冲区
20 std::cout<<"server say: ";
21 std::cin>>buf;
22 CHECK_RET(ssock.Send(buf,clip,cliport));
23 }
24 ssock.Close();
25 return 0;
26 }
UDP客户端
1 #include "classudp.hpp"
2
3 #define CHECK_RET(q) if((q)==false){
return -1;}
4 //客户端的任务流程
5 //1.创建套接字
6 //2.绑定地址结构
7 //3.发送数据
8 //4.接受数据
9 //5.关闭套接字
10 int main(){
11 //1.
12 UDPSocket sock;
13 CHECK_RET(sock.Socket());
14 //2.
15 //3.
16 while(1){
17 std::cout<<"client saY：";
18 std::string buf;
19 std::cin>>buf;
20 CHECK_RET(sock.Send(buf,"192.168.107.128",9000));
21
22
23 //4.
24 buf.clear();//不用的缓冲区清空
25 CHECK_RET(sock.Recv(&buf));//用发送缓冲区接收，不接收源端信息就不写
26 std::cout<<"server say: "<<buf<<std::endl;
27 }
28 //5.
29 sock.Close();
30 return 0;
31 }
TCP类
1 #include <cstdio>
2 #include <iostream>
3 #include <string>
4 #include <unistd.h>
5 #include <arpa/inet.h>
6 #include <netinet/in.h>
7 #include <sys/socket.h>
8
9 #define LISTEN_MAX 5
10 #define CHECK_RET(q) if((q)==false){
return -1;}
11 //tcp的流程大致如下“
12 //客户端：创建套接字，不推荐绑定地址信息，向服务器发送链接请求，收发数据，关闭套接字
13 //服务端：创建套接字，绑定地址信息，开始监听，获取新建连接，收发数据，关闭套接字
14 class TCPSocket{
15 private:
16 int _sockfd;
17 public:
18 TCPSocket():_sockfd(-1){
}
19 //创建套接字
20 //socket(地址域类型，套接字类型，通信协议)
21 //封装的接口需要获取操作句柄
22 bool Socket(){
23 _sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
24 if(_sockfd<0){
25 perror("socket error");
26 return false;
27 }
28 return true;
29 }
30
31 //绑定地址信息
32 //接口（句柄，规范接口struct结构体，结构体大小）、
33 //封装的接口（ip地址，port信息）
34 bool Bind(const std::string &ip,const uint16_t port){
35 sockaddr_in addr;
36 addr.sin_family = AF_INET;//16位地址类型
37 addr.sin_port = htons(port);
38
39 //这两种都能拿到ip内容（str的首地址）
40 addr.sin_addr.s_addr = inet_addr(&ip[0]);
41 //addr.sin_addr.s_addr = inet_addr(ip.c_str());
42
43 socklen_t len = sizeof(sockaddr_in);
44 int ret=bind(_sockfd,(struct sockaddr*)&addr,len);
45
46 if (ret < 0) {
47 perror("bind error");
48 return false;
49 }
50 return true;
51
52 }
53
54
55 //监听接口（操作句柄，最大连接数）
56 //封装接口（最大连接数）
W> 57 bool Listen(int big =LISTEN_MAX){
58 int ret=listen(_sockfd,LISTEN_MAX);
59 if(ret<0){
60 return false;
61 }
62 return true;
63 }
64
65
66
67 //申请链接（操作句柄，服务端的地址，地址长度）
68 //封装的接口（服务器ip，服务器port）
69 bool Connect(const std::string &ip,uint16_t port){
70 sockaddr_in addr;
71 addr.sin_family = AF_INET;
72 addr.sin_port = htons(port);
73 addr.sin_addr.s_addr = inet_addr(&ip[0]);
74 socklen_t len = sizeof(sockaddr_in);
75 int ret = connect(_sockfd, (sockaddr*)&addr, len);
76 if (ret < 0) {
77 perror("connect error");
78 return false;
79 }
80 return true;
81 }
82
83 //封装的接口：
84 //注意三个都是输出型参数（因为是处理请求的接口，所以不需要输入什么信息，只需要获得）
85 //服务器同意链接接口（新的套接字地址，客户端的地址结构指针，地址结构大小指针）
86 //注意这个的前提是客户端发送请求了，所以后两个数输出结构，用来获取请求的客户端的地址信息，当然可以不获取
87
88 //原始的的接口（监听套接字，获取客户端的ip，客户端的port地址）
89 //返回值是一个新的套接字，专门用来服务客户端，所以监听套接字相当于门迎~
90 //将返回值放到封装的接口参数1，原始接口2是输出参数，分开封装到封装接口的23
91 bool Accept(TCPSocket *sock,std::string *ip=NULL,uint16_t *port=NULL){
92 //建立一个结构体用来存客户端的地址信息
93 sockaddr_in addr;
94 socklen_t len = sizeof(sockaddr_in);
95
96 //注意这个len是输出型参数，所以是取地址！！！！
97 int newfd=accept(_sockfd,(sockaddr*)&addr,&len);
98 if (newfd < 0) {
99 perror("accept error");
100 return false;
101 }
102
103 //将输出型参数1填复制的句柄
104 sock->_sockfd = newfd;
105 if (ip != NULL) {
106 *ip = inet_ntoa(addr.sin_addr);
107 }
108 if (port != NULL) {
109 *port = ntohs(addr.sin_port);
110 }
111 return true;
112
113 }
114
115
116 //接收数据（操作句柄，接收缓冲区，接收数据长度，0阻塞）
117 //封装的接口（接收缓冲区）
118 //注意返回值小于0错误
119 //等于0连接断开
120 //大于0，实际大小
121 bool Recv(std::string *buf){
122 char tmp[1024]={
0};
123 int ret=recv(_sockfd,tmp,1024,0);
124 if (ret < 0) {
125 perror("recv error");
126 return false;
127 }
128 else if (ret == 0) {
129
130 printf("peer shutdown");
131 return false;
132 }
133 //把缓冲区的内容放入真正的缓冲区
134 //因为原始接口需要指定一次接受的数据大小
135 //而直接用缓冲区接收不能确定大小
136 buf->assign(tmp, ret);
137 return true;
138 }
139
140 //发送数据(描述符，数据，长度，标志位0阻塞)
141 //封装的接口（要发送数据）
142 //返回实际的长度
143 //这里需要考虑一次发送不完全部数据该怎么办
144 bool Send(const std::string &data){
145 int total;
W>146 while(total < data.size()){
147
148 int ret = send(_sockfd, &data[0] + total,data.size() - total, 0);
149 if(ret<0){
150
151 perror("send error");
152 return false;
153 }
154 total+=ret;
155 }
156 return true;
157 }
158
159 bool Close(){
160 if (_sockfd != -1) {
161 close(_sockfd);
162 }
163 return true;
164 }
165
166 };
TCP单执行流服务器
1 #include<iostream>
2 #include<string>
3 #include"classtcp.hpp"
4 #define CHECK_RET(q) if((q)==false){
return -1;}
5 //我们用程序运行参数来直接绑定服务器的地址信息
6 //argv[0]就是这个程序的运行 argv[1]ip地址 argv[2]port号
7 int main(int argc,char *argv[]){
8 if (argc != 3) {
9 printf("error\n");
10 return -1;
11 }
12 //0.取出服务器的ip和port
13 std::string sip=argv[1];
14 //stoi把字符串转int
15 uint16_t srvport = atoi(argv[2]);
16 //1.创建套接字
17 TCPSocket listen_sockfd;
18 CHECK_RET(listen_sockfd.Socket());
19 //2.绑定地址信息
20 CHECK_RET(listen_sockfd.Bind(sip,srvport));
21 //3.开始监听
22 CHECK_RET(listen_sockfd.Listen());
23 while(1){
24 //4.新建连接
25 //注意要放到循环里，否则只会接受一次请求
26 //开始写接受连接的三个输入参数
27 TCPSocket clisock;
28 std::string cliip;
29 uint16_t cliport;
30 bool ret = listen_sockfd.Accept(&clisock, &cliip,&cliport);
31 //注意要失败写continue，因为服务端可不能关闭
32 if (ret == false) {
33 continue;
34 }
35 //打印客户端的地址演示
36 std::cout<<"get newconn:"<< cliip<<"-"<<cliport<<"\n";
37
38
39 //5.收发数据
40 std::string buf;
41 ret = clisock.Recv(&buf);
42 if (ret == false) {
43 //注意走到这里套接字已经产生，注意销毁！！
44 clisock.Close();
45 continue;
46 }
47 std::cout << "client say: " << buf << std::endl;
48
49 buf.clear();//清空缓冲区
50 std::cout << "server say: ";
51 std::cin >> buf;
52 ret = clisock.Send(buf);
53 if (ret == false) {
54 clisock.Close();
55 }
56 }
57 //6.关闭监听套接字
58 listen_sockfd.Close();
59
60
61 }
TCP客户端
1 #include "classtcp.hpp"
2
3 int main(int argc, char *argv[])
4 {
5 //通过参数传入要连接的服务器服务端的地址信息
6 if (argc != 3) {
7 printf("error\n");
8 return -1;
9 }
10 //存放需要访问的服务器的地址信息
11 std::string srvip = argv[1];
12 //字符串转数字
13 uint16_t srvport = std::stoi(argv[2]);
14
15 //建立监听套接字
16 TCPSocket cli_sock;
17 //1. 创建套接字
18 CHECK_RET(cli_sock.Socket());
19 //2. 绑定地址信息（不推荐）
20 //3. 向服务端发起连接
21 CHECK_RET(cli_sock.Connect(srvip, srvport));
22 while(1) {
23 //4. 收发数据
24 std::string buf;
25 std::cout << "client say: ";
26 std::cin >> buf;
27 CHECK_RET(cli_sock.Send(buf));
28
29 buf.clear();
30 CHECK_RET(cli_sock.Recv(&buf));
31 std::cout << "server say: " << buf << std::endl;
32 }
33 //5. 关闭套接字
34 CHECK_RET(cli_sock.Close());
35 return 0;
36 }
TCP多执行流(线程)
1 #include"classtcp.hpp"
2 #include<pthread.h>
3 #define CHECK_RET(q) if((q)==false){
return -1;}
4
5 //多线程版本就是把数据的收发分配给线程独立处理
6 //在线程的入口函数中，需要把处理客户端请求套接字转成指针发送过来，并且再转换成tcp套接字类型用指针处理函数。
7 //注意相比于普通版本，在入口函数退出时不能使用continue，需要把动态申请的空间释放，并退出（因为是单线程处理任务请求）
8 void *thr_entry(void *arg){
9 bool ret;
10 TCPSocket* clisock=(TCPSocket*)arg;
11 while(1){
12
13 std::string buf;
14 //5.收发数据
15 ret = clisock->Recv(&buf);
16 if (ret == false) {
17 //注意走到这里套接字已经产生，注意销毁！！
18 clisock->Close();
19 delete clisock;
20 return NULL;
21 //continue;
22 }
23 std::cout << "client say: " << buf << std::endl;
24
25 buf.clear();//清空缓冲区
26 std::cout << "server say: ";
27 std::cin >> buf;
28 ret = clisock->Send(buf);
29 if (ret == false) {
30 clisock->Close();
31 delete clisock;
32 return NULL;
33 }
34
35 }
36 clisock->Close();
37 delete clisock;
38 return NULL;
39 }
40
41 //我们用程序运行参数来直接绑定
42 //argv[0]就是这个程序的运行 argv[1]ip地址 argv[2]port号
43 int main(int argc,char *argv[]){
44 if (argc != 3) {
45 printf("error\n");
46 return -1;
47 }
48 //0.取出服务器的ip和port
49 std::string sip=argv[1];
50 //stoi把字符串转int
51 uint16_t srvport = atoi(argv[2]);
52 //1.创建套接字
53 TCPSocket listen_sockfd;
54 CHECK_RET(listen_sockfd.Socket());
55 //2.绑定地址信息
56 CHECK_RET(listen_sockfd.Bind(sip,srvport));
57 //3.开始监听
58 CHECK_RET(listen_sockfd.Listen());
59 while(1){
60 //4.新建连接
61 //注意要放到循环里，否则只会接受一次请求
62 //开始写接受连接的三个输入参数
63
64 //这里不一样（线程）
65 TCPSocket *clisock = new TCPSocket();
66 //TCPSocket clisock;
67 std::string cliip;
68 uint16_t cliport;
69 //没有新建连接就阻塞在这里
70 //变成指针这里要去掉取地址,因为我们要把这个套接字的指针传到函数里
71 bool ret = listen_sockfd.Accept(clisock, &cliip,&cliport);
72 //bool ret = listen_sockfd.Accept(&clisock, &cliip,&cliport);
73 //注意要失败写continue，因为服务端可不能关闭
74 if (ret == false) {
75 continue;
76 }
77 //打印客户端的地址演示
78 std::cout<<"get newconn:"<< cliip<<"-"<<cliport<<"\n";
79
80 //此时已经创建了新套接字，开始用线程交互
81 //从这里开始进入线程
82 pthread_t tid;
83 //pthread_create(&tid, NULL, thr_entry, &clisock);
84 //这里传递的是地址，随着while1的结束，栈变量会被释放
85 //所以我们要new一个新的套接字，堆空间不会被释放，因为需要手动释放
86 pthread_create(&tid, NULL, thr_entry, (void*)clisock);
87 pthread_detach(tid);
88 //clisock.Close();
89 //注意这个不能随意释放，因为全部线程共享，某一个关闭就都不能用了
90 //当某一个线程从入口函数出来不能释放！！
91
92
93 }//6要写到while1外面！！！！
94 //6.关闭监听套接字
95 listen_sockfd.Close();
96
97
98 }
TCP多执行流(进程)
1 #include"classtcp.hpp"
2 #include <signal.h>
3 #include <sys/wait.h>
4
W> 5 void sigcb(int no){
6 while(waitpid(-1,NULL,WNOHANG)>0);
7
8 }
9
10 void worker(TCPSocket &clisock){
11 bool ret;
12
13 while(1){
14
15 //5.收发数据
16 std::string buf;
17 ret = clisock.Recv(&buf);
18 if (ret == false) {
19 //注意走到这里套接字已经产生，注意销毁！！
20 clisock.Close();
21 exit(0);
22 //continue;
23 }
24 std::cout << "client say: " << buf << std::endl;
25
26 buf.clear();//清空缓冲区
27 std::cout << "server say: ";
28 std::cin >> buf;
29 ret = clisock.Send(buf);
30 if (ret == false) {
31 clisock.Close();//释放子进程里的clisock
32 exit(0);
33 }
34 }
35 clisock.Close();//释放子进程里的clisock
36 exit(0);
37 }
38
39 //我们用程序运行参数来直接绑定服务器的地址信息
40 //argv[0]就是这个程序的运行 argv[1]ip地址 argv[2]port号
41 int main(int argc,char *argv[]){
42 if (argc != 3) {
43 printf("error\n");
44 return -1;
45 }
46
47 //法1
48 //避免产生
49 //signal(SIGCHLD,SIG_IGN);
50 //忽略子进程退出的信号
51
52 //法2
53 //写一个毁掉函数
54 signal(SIGCHLD,sigcb);
55
56
57
58 //0.取出服务器的ip和port
59 std::string sip=argv[1];
60 //stoi把字符串转int
61 uint16_t srvport = atoi(argv[2]);
62 //1.创建套接字
63 TCPSocket listen_sockfd;
64 CHECK_RET(listen_sockfd.Socket());
65 //2.绑定地址信息
66 CHECK_RET(listen_sockfd.Bind(sip,srvport));
67 //3.开始监听
68 CHECK_RET(listen_sockfd.Listen());
69 while(1){
70 //4.新建连接
71 //注意要放到循环里，否则只会接受一次请求
72 //开始写接受连接的三个输入参数
73 TCPSocket clisock;
74 std::string cliip;
75 uint16_t cliport;
76 bool ret = listen_sockfd.Accept(&clisock, &cliip,&cliport);
77 //注意要失败写continue，因为服务端可不能关闭
78 if (ret == false) {
79 continue;
80 }
81 //打印客户端的地址演示
82 std::cout<<"get newconn:"<< cliip<<"-"<<cliport<<"\n";
83
84 //创建进程
85 pid_t pid=fork();
86 if(pid<0){
87 clisock.Close();
88 continue;//主进程继续去处理其他业务
89 }else if(pid==0){
90 //子进程
91 worker(clisock);
92 }
93 //释放父进程里的clisock，因为子复制父进程，子进程的clisock去工作了而父进程的没工作，每次循环都创建了。
94 clisock.Close();
95 }
96 // wait(NULL);//进程等待，但父进程不能卡在这里
97
98 //6.关闭监听套接字
99 listen_sockfd.Close();
100
101
102 }