Tcp_socket

Tcp不保证报文完整性（面向字节流）

所以我们需要在应用层指定协议，确保报文完整性

// {json} -> len\r\n{json}\r\n
bool Encode(std::string &message)
{if(message.size() == 0) return false;std::string package = std::to_string(message.size()) + Sep + message + Sep;message = package;return true;
}

OSI与TCP/IP

为什么tcp四层协议，IOS七层协议？

虽然IOS七层协议很完善，但实际实现时，有些层次被合并。

将IOS与实际情况相结合
tcp中，把上三层归为应用层
最后二层归为网卡层

Tcp与Udp区别

tcp需要握手后建立连接才可以开始服务
使用listen握手

[listen]声明：

       int listen(int sockfd, int backlog);

[accept]声明：

SYNOPSIS#include <sys/types.h>          /* See NOTES */#include <sys/socket.h>int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

[connect声明]

SYNOPSIS#include <sys/types.h>          /* See NOTES */#include <sys/socket.h>int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

listen返回的fd是给accept使用的，不可用来I/O
我们应对accept 返回的fd进行I/O

Tcp的 accept 返回的fd更像是文件，可以用read读取，因为Tcp是面向字节流
Udp的recvfrom返回的fd不可read等操作，因为Udp不是面向字节流

和Udp一样，Tcp也是全双工通信的（可同时读写）

telnet [域名] 端口号

远程登陆

struct sockaddr

struct sockaddr 基类
struct sockaddr_in，inet，网络间通信
struct sockaddr_un，unix，本机通信
这三个struct前2字节都是16位地址类型（C语言实现多态）

与Tcp协议server交流时，client应先connect，connect成功后才可以write/read
到client与server段开链接时，server中的read会立即返回0，表示与client失去连接

fd & 多进程

子进程继承父进程的文件描述符表。两张，父子各一张（可以理解为子进程浅拷贝父进程fd表，表中fd指向与父进程相同）

父子进程共享的fd中，如果其中一个进程关闭fd，另一个进程中对应fd不受影响，因为fd指向文件具有引用计数，只有引用数为0时，fd指向文件才会真正关闭

将子进程与父进程脱离的方法
signal（SIGCHLD，SIG_IGN），会使系统自动回收子进程
在子进程中生成孙子进程，之后关闭子进程，孙子进程就变为孤儿进程，由系统自动回收。

和进程不同，父子线程共享一张fd表，所以子线程中不用也不能关闭fd。

recv /send 与 read/write

使用recv & send 代替read & write
后者可能导致数据不完整，所以建议前者

[recv]

       #include <sys/types.h>#include <sys/socket.h>ssize_t recv(int sockfd, void *buf, size_t len, int flags);

[send]

 #include <sys/types.h>#include <sys/socket.h>ssize_t send(int sockfd, const void *buf, size_t len, int flags);

tips：

fd是有用的有限的资源，fd周期随进程。如果不关闭fd，会造成fd泄漏

类静态函数成员

类的静态成员函数不能直接访问类的实例成员（非静态成员），但可以访问类的静态成员。
这是因为静态成员函数与类的实力无关（可能使用静态成员函数时，类还没有实例化）

非静态成员函数可以访问静态成员函数（因为后者实例化一定比前者早）

server类中调用pthread_thread_creat时其函数参数的对应函数（void*（void*））不能接收类内普通自定义参数（因为其只能传递server的this），
只能使server类的静态函数成员作为pthread_thread_creat的函数参数。
通过想类的静态函数成员传递包含有线程所需data＋server的this指针，在静态成员函数中通过this调用server类的普通成员函数（同时传递data），实现传参。

popen & pclose

封装了pipe 与 fork / exec

#include <stdio.h>FILE *popen(const char *command, const char *type);int pclose(FILE *stream);

板书笔记

无

TcpEchoShell_code

code/lesson35/1. EchoServer · whb-helloworld/112 - 码云 - 开源中国

TcpServer.cc

#include "TcpServer.hpp"
#include "CommandExec.hpp"
#include <functional>
#include <memory>using task_t = function<std::string (std::string)>;
// using namespace 
int main()
{ENABLE_CONSOLE_LOG();Command cmd;task_t task = [&cmd](std::string cmdstr){return cmd.Execute(cmdstr);};std::unique_ptr<TcpServer> tsvr = std::make_unique<TcpServer>(task);tsvr->InitServer();tsvr->Start();return 0;
}

TcpServer.hpp

#pragma once#include <iostream>
#include <cstring>
#include <string>
#include <cerrno>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <pthread.h>
#include <functional>#include "Log.hpp"
#include "Common.hpp"
#include "InetAddr.hpp"
#include "ThreadPool.hpp"#define BACKLOG 8// using namespace LogModule;
using namespace ThreadPoolModule;
static const uint16_t gport = 8080;
using handler_t = std::function<std::string(std::string)>;class TcpServer
{using task_t = std::function<void()>;struct ThreadData{int sockfd;TcpServer *self;};
public:TcpServer(handler_t handler, int port = gport):_handler(handler), _port(port),_isrunning(false){}void InitServer(){// 先监听_listensockfd = ::socket(AF_INET, SOCK_STREAM, 0);if(_listensockfd < 0){LOG(LogLevel::FATAL)<<"socket error";Die(SOCKET_ERR);}LOG(LogLevel::INFO)<<"socket create success, _listensocked is "<<_listensockfd;// 后bindstruct sockaddr_in local;// 网络通信用sockaddr_in, 本地用sockaddr_unmemset(&local, 0, sizeof local);local.sin_family = AF_INET;local.sin_port = htons(_port);local.sin_addr.s_addr = INADDR_ANY;int n = ::bind(_listensockfd, CONV(&local), sizeof(local));if(n < 0){LOG(LogLevel::FATAL)<<"bind error";Die(BIND_ERR);}LOG(LogLevel::INFO) << "bind success, sockfd is: "<<_listensockfd;// 设置为监听状态n = listen(_listensockfd, BACKLOG);if(n < 0){LOG(LogLevel::FATAL)<<"listen error";Die(LISTEN_ERR);}LOG(LogLevel::INFO)<<"listen success, socked is:"<<_listensockfd;// 此处可使用::signal(SIGCHLD, SIG_IGN)来将父子进程解绑}void HandlerRequest(int sockfd){LOG(LogLevel::INFO)<<"HandlerRequest, sockfd is:"<<sockfd;char inbuffer[4096];while(true){ssize_t n = recv(sockfd, inbuffer, sizeof inbuffer, 0);inbuffer[n] = 0;LOG(LogLevel::INFO)<<"server recived:"<<inbuffer;if(n > 0){inbuffer[n] = 0;std::string cmd_result = _handler(inbuffer);// 回调::send(sockfd, cmd_result.c_str(), cmd_result.size(), 0);LOG(LogLevel::INFO)<<"server sent:"<<cmd_result;}else if(n == 0){LOG(LogLevel::INFO)<<"client quit"<<sockfd;break;}else{break;}}::close(sockfd);// 防止fd泄露}static void *ThreadEntry(void *args)// 设为静态函数就不用传递this{// 当使用多线程（不是封装好的线程池）， pthread_thread_create的函数只能接收一个参数pthread_detach(pthread_self());ThreadData *data = (ThreadData *)args;data->self->HandlerRequest(data->sockfd);return nullptr;}void Start(){_isrunning = true;while(_isrunning){struct sockaddr_in peer;socklen_t peerlen = sizeof(peer);LOG(LogLevel::DEBUG)<<"accepting...";int sockfd = ::accept(_listensockfd, CONV(&peer), &peerlen);if(sockfd < 0){LOG(LogLevel::WARNING)<<"accept error:"<<strerror(errno);continue;}// 连接成功LOG(LogLevel::INFO)<<"accept success, sockfd is:"<<sockfd;InetAddr addr(peer);LOG(LogLevel::INFO)<<"client info:"<<addr.Addr();// 使用线程池实现ThreadPool<task_t>::getInstance()->Equeue([this, sockfd](){this->HandlerRequest(sockfd);});}   }~TcpServer(){}private:int _listensockfd;// 监听socketuint16_t _port;bool _isrunning;// 处理上层任务入口handler_t _handler;
};

TcpClient.cc

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <arpa/inet.h>// #include "Common.hpp"int main(int argc, char *argv[])
{if(argc != 3){std::cout<<"Usage:./client_tcp [server_ip] [server_port]"<<std::endl;return 1;}std::string server_ip = argv[1];int server_port = std::stoi(argv[2]);int sockfd = ::socket(AF_INET, SOCK_STREAM, 0);if(sockfd < 0){std::cout<<"create socket failed"<<std::endl;return 2;}struct sockaddr_in server_addr;memset(&server_addr, 0, sizeof(server_addr));server_addr.sin_family = AF_INET;server_addr.sin_port = htons(server_port);server_addr.sin_addr.s_addr = inet_addr(server_ip.c_str());// client 不需要显示进行 bind， tcp是面向连接的， connect底层自动bindint n = ::connect(sockfd, (struct sockaddr*)(&server_addr), sizeof(server_addr));if(n < 0){std::cout<<"connet falied"<<std::endl;return 3;}std::cout<<"connet 成功\n"<<std::endl;std::string message;while(true){  char inbuffer[1024];std::cout<<"input message: ";std::getline(std::cin, message);n = ::write(sockfd, message.c_str(), message.size());if(n > 0){int m = read(sockfd, inbuffer, sizeof(inbuffer));if(m > 0){inbuffer[m] = 0;std::cout<<inbuffer<<std::endl;}else break;}else break;}::close(sockfd);return 0;
}

CommadExec.hpp

#pragma once #include <iostream>
#include <string>class Command
{
public:std::string Execute(std::string cmdstr){return std::string("命令执行完毕\n");}
};

Common.hpp

#pragma once 
#include <iostream>
#define Die(code) do{exit(code);}while(0)
#define CONV(v) (struct sockaddr *)(v)enum
{USAGE_ERR = 1, SOCKET_ERR,BIND_ERR,LISTEN_ERR
};bool SplitString(std::string &in, std::string *key, std::string *val, std::string gap)
{size_t pos = in.find(gap);if (pos == std::string::npos) return false;*key = in.substr(0, pos);*val = in.substr(pos + gap.size());if(key->empty() || val->empty()) return false;return true;
}