前文:Socket套接字编程
TCP的特点
- 面向连接:TCP 在发送数据之前,必须先建立连接。
- 可靠性:TCP 提供了数据传输的可靠性。
- 面向字节流:TCP 是一个面向字节流的协议,这意味着 TCP 将应用程序交下来的数据看成是一连串的无结构的字节流。
TcpServer.hpp
创建一个Tcp服务端
代码
#pragma once
#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<cstring>
#include<arpa/inet.h>
#include<unistd.h>
#include <sys/wait.h>
#include<functional>
#include<pthread.h>
#include"InetAddr.hpp"
#include"Log.hpp"
#include"Threadpool.hpp"
enum
{
SOCKET_ERROR = 1,
BIND_ERROR,
LISTEN_ERROR,
USAGE_ERROR
};
const static int defaultsockfd = -1;//默认文件描述符
const static int gbacklog = 16;//默认最大连接数
using task_t=std::function<void*()>; //任务函数的类型(V3)
class TcpServer;
//线程类型数据
class ThreadData
{
public:
ThreadData(int fd,InetAddr addr,TcpServer* s)
:sockfd(fd),
clientaddr(addr),
self(s)
{}
public:
int sockfd;//文件描述符
InetAddr clientaddr;//客户端地址
TcpServer* self;//服务端
};
class TcpServer
{
public:
TcpServer(int port)
:_port(port),
_listensock(defaultsockfd),
_isrunning(false)
{}
void InitServer()
{
//1.创建字节流套接字
_listensock=socket(AF_INET,SOCK_STREAM,0);
if(_listensock<0)
{
LOG(FATAL, "socket error");
exit(SOCKET_ERROR);
}
LOG(DEBUG, "socket create success, sockfd is : %d\n", _listensock);
//2.bind
struct sockaddr_in local;
memset(&local,0,sizeof(local));
local.sin_family=AF_INET;
local.sin_port=htons(_port);
local.sin_addr.s_addr=INADDR_ANY;
int n= ::bind(_listensock,(struct sockaddr*)&local,sizeof(local));
if(n<0)
{
LOG(FATAL, "bind error\n");
exit(BIND_ERROR);
}
LOG(DEBUG, "bind success, sockfd is : %d\n", _listensock);
//3.监听客户端,等待被连接
n=listen(_listensock,gbacklog);
if(n<0)
{
LOG(FATAL, "listen error");
exit(LISTEN_ERROR);
}
LOG(DEBUG, "listen success, sockfd is : %d\n", _listensock);
}
//将接收到的数据进行处理,完成对应服务
void Service(int sockfd,InetAddr client)
{
LOG(DEBUG, "get a new link, info %s %d ,fd: %d \n ",client.Ip().c_str(),client.Port(),sockfd);
std::string clientaddr = "[" + client.Ip() + ":" + std::to_string(client.Port()) + "]# ";
while(true)
{
char inbuffer[1024];
ssize_t n = read(sockfd,inbuffer,sizeof(inbuffer)-1);//读取数据
if(n>0)
{
inbuffer[n]=0;
std::cout<<clientaddr<<inbuffer<<std::endl;//打印对应的数据
std::string echo_string = "[server echo]# ";
echo_string+=inbuffer;
write(sockfd,echo_string.c_str(),echo_string.size());//返回给客户端
}
else if(n==0) //client退出并且关闭连接了
{
LOG(INFO, "%s quit\n", clientaddr.c_str());
break;
}
else
{
LOG(ERROR, "read error\n");
break;
}
}
close(sockfd);
}
//线程的处理函数
static void* HandlerSock(void* args)
{
pthread_detach(pthread_self());//线程分离
ThreadData* td=static_cast<ThreadData*>(args);//创建对应线程数据类型
td->self->Service(td->sockfd,td->clientaddr);
delete td;
return nullptr;
}
//服务器循环运行着
void Loop()
{
_isrunning=true;
while(_isrunning)
{
struct sockaddr_in peer;//sock地址peer
socklen_t len=sizeof(peer);
//要先通过连接才能够进行通信
int sockfd=::accept(_listensock,(struct sockaddr *)&peer,&len);//这里的监听sock和sockfd是不同的
if(sockfd<0)
{
LOG(WARNING, "accept error\n");
continue;
}
//Version0 这种版本只能接收一次需求,无法多客户端连接
// Service(sockfd,InetAddr(peer));
//Version1 多进程
// pid_t id=fork();
// if(id>0)
// {
// //子进程负责连接,父进程负责监听,
// close(_listensock);
// if(fork()>0) exit(0);
// //孙进程负责服务,由于子进程连接之后,子进程会进行回收,因此孙进程称为孤儿进程,之后不受子进程的影响
// //类似线程分离,是独立的,之后受系统进行回收
// Service(sockfd,InetAddr(peer));
// exit(0);
// }
// //父进程只负责监听,不需要进行连接
// close(sockfd);
// waitpid(id,nullptr,0);
//Version2:采用多线程
pthread_t t;
ThreadData* td=new ThreadData(sockfd,peer,this);
pthread_create(&t,nullptr,HandlerSock,td);//将线程分离
//Version3:线程池
//task_t t = std::bind(&TcpServer::Service,this,sockfd,InetAddr(peer));
//ThreadPool<task_t>::GetInstance()->Enqueue(t);
}
_isrunning=false;
}
~TcpServer()
{
if(_listensock>defaultsockfd)
{
close(_listensock);
}
}
private:
uint16_t _port;//端口号
int _listensock;//监听的文件描述符
bool _isrunning;//启动
};
解释
初始化服务端,主要完成套接字的创建绑定,已经完成对应的监听客户端,因为Tcp是有连接的,所以需要监听客户端是否有请求连接的需求;
SOCK_STREAM
表示字节流
gbacklog
:这个参数定义了内核应该为相应套接字排队的最大连接数。这个值至少为0;其实际值由系统限制,可以通过sysctl命令的net.core.somaxconn参数查看和设置。需要注意的是,这个值并不是指系统能处理的并发连接数,而是内核中等待accept(处理的连接队列的最大长度。
启动服务器之后,通过循环让服务端不断运行着,在循环里面,服务端可能接收到多个客户端请求的连接,所以accpet要在循环中不断接收看是否有对应的连接;
连接完之后通过Service服务函数完成双方的通信
在Loop中,循环表示接收多个客户端,而Service中,循环表示每个服务端与客户端的通信保持;
由于tcp是面向字节流的,所以可以利用文件描述符的性质,运用read函数,读取对应的发送端数据.
当n大于0时,表示对方有数据发送,处理完信息后反馈给对方;
当n==0,表示sockfd被关闭了,也就是连接被断开了;
当n小于0时,表示出现错误;
如果一直没有发送数据,那么会在read函数这里发生阻塞;
而对于服务的处理,这里有多种方法,如果直接使用Service函数的话,是不可行的,因为这样无法多客户端连接:
通过多进程的方法,让父进程只负责监听,子进程负责连接,孙进程负责服务,由于孙进程是孤儿进程,相当于线程分离,这样处理服务时就不会受到父子进程的影响了;也就能完成多客户端的通信了;
直接通过多线程的方法,将创建的线程进行分离,完成对应的服务任务
main.cc
#include"TcpServer.hpp"
#include<memory>
void Usage(std::string proc)
{
std::cout << "Usage:\n\t" << proc << " local_port\n" << std::endl;
}
// ./main.cc 8080
int main(int argc,char* argv[])
{
if(argc!=2)
{
Usage(argv[0]);
return 1;
}
EnableScreen();//打印到屏幕
uint16_t port=std::stoi(argv[1]);//获取端口号
std::unique_ptr<TcpServer> tsvr=std::make_unique<TcpServer>(port);//服务端的指针
tsvr->InitServer();//初始化
tsvr->Loop();//循环运行
return 0;
}
TcpClient.cc
#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<unistd.h>
#include<cstring>
void Usage(std::string proc)
{
std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
<< std::endl;
}
// ./TcpClient.cc 127.0.0.1 8080
int main(int argc,char* argv[])
{
if(argc!=3)
{
Usage(argv[0]);
exit(1);
}
std::string serverip=argv[1];//服务端ip
uint16_t serverport=std::stoi(argv[2]);//服务端端口号
int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
if (sockfd < 0)
{
std::cerr << "socket error" << std::endl;
exit(2);
}
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(serverport);
server.sin_addr.s_addr=inet_addr(serverip.c_str());
//连接服务端
int n=connect(sockfd,(struct sockaddr*)&server,sizeof(server));
if(n<0)
{
std::cerr << "connect error" << std::endl;
exit(3);
}
while(true)
{
std::cout<<"Please Enter# ";
std::string outstring;
getline(std::cin,outstring);
//发送对应数据
ssize_t s=send(sockfd,outstring.c_str(),outstring.size(),0);
if(s>0)
{
char inbuffer[1024];
ssize_t m=recv(sockfd,inbuffer,sizeof(inbuffer)-1,0);//接收对应数据
if(m>0)
{
inbuffer[m]=0;
std::cout<<inbuffer<<std::endl;
}
else
{
break;
}
}
else
{
break;
}
}
close(sockfd);
return 0;
}