【计算机网络】Linux环境中的TCP网络编程
文章目录
- 前言
- 一、TCP Socket API
-
- 1. socket
- 2. bind
- 3. listen
- 4. accept
- 5. connect
- 二、封装TCPSocket
- 三、服务端的实现
-
- 1. 封装TCP通用服务器
- 2. 封装任务对象
- 3. 实现转换功能的服务器
- 四、客户端的实现
-
- 1. 封装TCP通用客户端
- 2. 实现转换功能的客户端
- 五、结果演示
- 六、多进程版服务器
- 七、线程池版服务器
前言
TCP和UDP都是工作在传输层，用于程序之间传输数据。二者之间的区别是TCP是面向连接的，而UDP是面向数据报的。那就意味着，TCP能够进行可靠的数据传输，而UDP进行不可靠的数据传输。关于TCP协议和UDP协议的详细内容可见博主的后续文章，本文的主要内容是关于TCP socket的网络编程。
接下来我们将基于TCP网络编程实现一个将小写字母转换成大写字母的网络服务器。
一、TCP Socket API
以下是关于使用TCP协议用到的socket API，这些函数都包含在头文件sys/socket.h中。
1. socket
函数定义：
NAME
//socket - create an endpoint for communication
SYNOPSIS
#include 功能：
socket()会打开一个网络通信端口，如果打开成功，则像open()函数一样返回一个文件描述符，如果失败则返回 -1。这样网络应用程序就可以像读写文件那样使用read/write在网络上读取和发送数据。
参数详解：
-
第一个参数
domain用于设置网络通信的域，函数socket()根据这个参数选择通信协议的族。对于IPv4，domain参数指定为AF_INET，而IPv6则是AF_INET6。并且AF_INET和PFINET的值是一致的。 -
第二个参数
type用于设置通信协议的族，这些族也在文件sys/socket.h中定义，包含如下表所示的值。
| 类型 | 说明 |
|---|---|
| SOCK_STREAM | 用于TCP连接，提供序列化、可靠的、双向连接的字节流 |
| SOCK_DGRAM | 用于UDP连接（无连接状态的消息） |
| SOCK_SEQPACKET | 序列化包，提供一个序列化的、可靠的、双向的基于连接的数据传输通道，数据长度定长。每次调用读系统调用时数据需要将全部数据读出 |
| SOCK_RAW | RAW类型，提供原始网络协议访问 |
| SOCK_RDM | 提供可靠的数据报文，不过可能数据会有乱序 |
| SOCK_PACKET | 这是一个专用类型，不能在通用程序中使用，用于直接从设备驱动接收数据 |
【补充说明】
- 类型为
SOCK_STREAM的套接字表示一个双向的字节流，与管道类似。流式的套接字在进行数据收发之前必须已经连接，连接使用connet()函数进行。一旦连接，可以使用read/write函数进行数据的传输。流式通信方式保证数据不会丢失或者重复接收，当数据在一段时间内仍然没有接收完毕，可以将这个连接认为已经断开。SOCK_DGRAM和SOCK_RAW这两种套接字可以使用函数sendto()来发送数据，使用recvfrom()函数接收数据，recvfrom()接收来自指定IP地址的发送方的数据。
- 第三个参数
protocol用于指定某个协议的特定类型，即type类型中的某个类型。通常某个协议中只有一种特定类型，这样protocol参数仅能设置为0，但是有些协议有多种类型，就需要设置这个参数来选择特定的类型。
2. bind
函数定义：
NAME
//bind - bind a name to a socket
SYNOPSIS
#include 因为服务器程序所监听的网络地址和端口号通常都是固定不变的，客户端得知了服务器程序的地址和端口号后就可以向服务器发起连接，而服务器需要绑定一个固定的网络地址和端口号。因此bind()的作用是将参数sockfd和myaddr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听sockaddr所描述的地址和端口号。绑定成功返回0，失败则返回-1。
博主的上一篇文章【网络套接字编程】中提到过，struct sockaddr *是一个通用指针类型，myaddr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。
在程序中myaddr的定义及初始化如下：
struct sockaddr_in myaddr;
bzero(&myaddr, sizeof(myaddr));
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
myaddr.sin_port = htons(SERV_PORT);
- 定义
myaddr - 使用
bzero函数将整个结构体清零 - 设置网络通信的域为
AF_INET - 将网络地址设置为
INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP 地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP 地址 - 最后填充端口号
虽然bind()中的第二个参数类型是sockaddr，但是我们真正填充信息使用的数据结构是sockaddr_in，这个结构里主要有三部分信息：地址类型、端口号、IP地址。最后在进行函数传参的时候只需要将sockaddr_in*强制类型转换成sockaddr即可。
3. listen
函数定义：
NAME
//listen - listen for socket connections and limit the queue of incoming connections
SYNOPSIS
#include listen()函数用于声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接等待状态，如果接收到更多的连接请求就忽略。（详细内容可见博主的后续文章【TCP协议】）。listen()函数调用成功返回0，调用失败则返回 -1。
4. accept
函数定义：
NAME
accept - accept a new connection on a socket
SYNOPSIS
#include accept()函数的作用是，当客户端与服务端的三次握手完成后，服务器调用accept()函数接受连接。如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端请求连接。
返回值：
- 调用成功则返回客户端
socket()返回的文件描述符，调用失败则返回 -1。
参数：
- 第一个参数
socket即是调用socket()函数返回的文件描述符。 - 第二个参数
restrict_address是输出型参数，用于获取客户端的网络地址和端口号，如果该参数为空，则表示当前服务端不关心客户端的地址。 - 第三个参数
restrict_address_len也是输出型参数，它表示的是缓冲区restrict_address的长度，以避免缓冲区溢出问题，最后传出客户端地址结构体的实际长度。
accept()函数在服务器程序中的使用结构如下：
while (true)
{
sockaddr_in peer_addr;
socklen_t len = sizeof(peer_addr);
int peer_sock = accept(_fd, (sockaddr *)&peer_addr, &len);
ssize_t read_size = read(peer_sock, buf, sizeof(buf));
. . .
close(peer_sock);
}
5. connect
函数定义：
NAME
//connect - connect a socket
SYNOPSIS
#include 作用与参数说明：
connect函数用于客户端连接服务器。其参数与bind()函数的参数一致，区别在于bind()函数绑定的参数是自己的地址，而connect()函数的连接是服务器的地址。
返回值：
- 调用成功返回0，调用失败则返回 -1。
二、封装TCPSocket
#pragma once
#include 三、服务端的实现
1. 封装TCP通用服务器
#include "TcpSocket.hpp"
#include "Task.hpp"
typedef std::function<void(TcpSocket, const std::string &, uint16_t)> Handler;
// void transServer(TcpSocket sock, const std::string &ip, uint16_t port)
// {
// std::string inbuf;
// while (true)
// {
// if (!sock.Recv(&inbuf))
// {
// // 如果读取失败，结束循环
// printf("[client %s:%d] disconnect!\n", ip.c_str(), port);
// break;
// }
// if (strcasecmp(inbuf.c_str(), "quit") == 0)
// {
// printf("[client %s:%d] quit!\n", ip.c_str(), port);
// break;
// }
// printf("transform before: %s[%d]--> %s\n", ip.c_str(), port, inbuf.c_str());
// fflush(stdout);
// for (int i = 0; i < inbuf.size(); ++i)
// {
// if (isalpha(inbuf[i]) && islower(inbuf[i]))
// {
// inbuf[i] = toupper(inbuf[i]);
// }
// }
// printf("transform after: %s[%d]--> %s\n", ip.c_str(), port, inbuf.c_str());
// fflush(stdout);
// sock.Send(inbuf);
// }
// sock.Close();
// }
class TcpServer
{
public:
TcpServer(int port, const std::string &ip = "")
: _port(port), _ip(ip)
{
_sock.Socket();
}
~TcpServer() {}
public:
bool Start(Handler handler)
{
// 绑定IP和端口号
CHECK_RET(_sock.Bind(_ip, _port));
// 监听
CHECK_RET(_sock.Listen(5));
// 进入循环
while (true)
{
// 进行accept
TcpSocket peer_sock;
std::string ip;
uint16_t port = 0;
if (!_sock.Accept(&peer_sock, &ip, &port))
{
continue;
}
printf("[client %s:%d] connect!\n", ip.c_str(), port);
// 执行任务
// TODO
Task task(peer_sock, ip, port, handler);
task();
}
}
private:
// tcp socket对象
TcpSocket _sock;
// 端口号
uint16_t _port;
// ip地址
std::string _ip;
};
2. 封装任务对象
#include 3. 实现转换功能的服务器
#include 四、客户端的实现
1. 封装TCP通用客户端
#include "TcpSocket.hpp"
class TcpClient
{
public:
TcpClient(const std::string& ip, uint16_t port)
:_ip(ip), _port(port)
{
_sock.Socket();
}
~TcpClient()
{
_sock.Close();
}
public:
bool Connect()
{
return _sock.Connect(_ip, _port);
}
bool Recv(std::string* buf)
{
return _sock.Recv(buf);
}
bool Send(const std::string& buf)
{
_sock.Send(buf);
}
int GetFd()
{
return _sock.GetFd();
}
private:
TcpSocket _sock;
std::string _ip;
uint16_t _port;
};
2. 实现转换功能的客户端
#include 五、结果演示
启动服务端：
启动客户端：
客户端连接服务端成功，此时服务端状态：
测试样例：
客户端输入样例，发现转换成功。
存在的问题：
此时，启动又一个客户端连接服务器，在此输入时，我们会发现输入的内容会卡住显示屏上。
此时我们关闭第一个客户端后发现有得出转换后的结果。
原因在于当前的服务器是单进程版本的，只能够同时为一个客户端服务，所以再来一个客户端会阻塞等待服务器结束对上一个客户端的服务。以下的改进的多进程和多线程版本的服务器。
六、多进程版服务器
改进思想是，父进程为每个客户端的请求都创建一个子进程去处理任务，父进程不做任何工作，但要注意的是父进程中要关闭不断创建的客户端的peer_sock，避免内存泄漏。子进程执行客户端的请求，在请求结束后调用exit函数退出，但不必单独释放_sock对象，因为会自动调用其析构函数。同时设置signal函数，对SIGCHLD做忽略动作，使得父进程不必等待子进程，只处理自己的任务。
#pragma once
#include "TcpSocket.hpp"
#include "Task.hpp"
#include 结果：
此时服务器便可以为多个客户端同时进行服务。
七、线程池版服务器
实现线程池：
#pragma once
#include 线程池版服务器：
#pragma once
#include "TcpSocket.hpp"
#include "Task.hpp"
#include "ThreadPool.hpp"
typedef std::function<void(TcpSocket, const std::string &, uint16_t)> Handler;
class TcpThreadPoolServer
{
public:
TcpThreadPoolServer(int port, const std::string &ip = "")
: _port(port), _ip(ip)
{
_sock.Socket();
_tp.start();
}
~TcpThreadPoolServer() {}
public:
bool Start(Handler handler)
{
// 绑定IP和端口号
CHECK_RET(_sock.Bind(_ip, _port));
// 监听
CHECK_RET(_sock.Listen(5));
// 进入循环
while (true)
{
// 进行accept
TcpSocket peer_sock;
std::string ip;
uint16_t port = 0;
if (!_sock.Accept(&peer_sock, &ip, &port))
{
continue;
}
printf("[client %s:%d] connect!\n", ip.c_str(), port);
// 执行任务
// TODO
Task task(peer_sock, ip, port, handler);
_tp.push(task);
}
}
private:
// tcp socket对象
TcpSocket _sock;
// 端口号
uint16_t _port;
// ip地址
std::string _ip;
// 线程池
ThreadPool<Task> _tp;
};
结果
