实现原理

首先我们要有个客户端和一个服务器，客户端向服务器传递命令。而服务器收到命令后创建一个管道，并fork一个子进程。随后子进程解析命令，再把标准输出换成管道文件，因为命令行命令是自动输出到显示器的，所以我们要把命令的结果重定向到管道文件。然后服务器主进程等待子进程返回的结果，并把结果返回给客户端。

客户端需要做的事情：

1. 读取用户输入的命令

2. 把输入的命令发送给服务器

3. 读取服务器返回的结果并回显显示器

服务器需要做的事情：

1. 读取客户端发来的命令

2. 创建一个管道

3. 创建一个子进程

4. 关闭管道的写端(管道是单向通信的)

5. 等待子进程的返回结果(返回结果会在管道中)

6. 把结果发送给客户端

服务器的子进程需要做的事情

1. 关闭管道读端(管道会继承自父进程)

2. 把字符串拆分，例如： ls -a -l 拆分成ls,a,l这样的单个字符串

3. 把标准输出替换成管道的写端(这种行为也叫重定向)

4. 把拆分的字符串组织起来进行进程替换

server端代码

我们明白了shell的实现原理之后，那么我们先来编写服务器。服务器负责接收客户端发来的命令把把命令递交给子进程，由子进程进行程序替换来返回结果。子进程的返回结果本来会返回到显示器上，但是我们修改了子进程的标准输出，那么就会重定向到管道中。

server.cc代码：

#include "server.hpp"
#include <memory>
#include <unistd.h>
#include <fcntl.h>
#include <vector>
#include <sys/wait.h>
#include <cstring>

//请求处理函数
void CommandMessage(int sockfd,std::string ip , uint16_t port, std::string message)
{
    //1创建管道
    int fds[2];

    if(pipe(fds) != 0)
    {
        std::cerr << "input pipe failed in " << ip << "-" << port << std::endl;
        return;
    }
    int pid = fork();
    if(pid > 0)
    {
        //父进程关闭写
        close(fds[1]);
        char buff[1024 * 4] = {0};
        waitpid(pid,nullptr,0);
        int n = read(fds[0],buff,sizeof buff - 1);
        std::cout << buff << std::endl;
        //把返回的结果发给客户端
        struct sockaddr_in client; 
        client.sin_addr.s_addr = inet_addr(ip.c_str());
        client.sin_port = htons(port);
        client.sin_family = AF_INET;
        sendto(sockfd,buff,strlen(buff),0,(struct sockaddr*)&client,sizeof client);

    }else if(pid == 0)
    {
        //子进程关闭读
        close(fds[0]); 
        char buff[1024] = {0};
        
        //解析命令行
        int idx = 0 ;
        std::vector<std::string> cmds;
        //把命令行参数分解到cmds中
        while(true)
        {
            int pos = message.find(" ",idx); 
            if(pos == std::string::npos) 
            {
            // std::cout<< message << pos << std::endl;
                cmds.push_back(message.substr(idx,pos - idx)); 
                break;
            }
            if(idx != pos) 
            {
                cmds.push_back(message.substr(idx,pos - idx)); 
            }
            idx = pos + 1;   
        }
        const char* ev[128] = {0};  //存储所有的参数

        //把cmds中所有的参数放进ev中
        for(int i = 0; i < cmds.size() ;i++){ ev[i] = cmds[i].c_str(); }
        dup2(fds[1],1);// 相当于close(1) -> close(fds[1]) -> open(fds[1])
        execvp(ev[0],(char* const *)ev); //程序替换
        exit(1);
    } 
}


int main(int argc , char* argv[])
{
    if(argc != 2) //命令行参数不为2就退出
    {
        std::cout << "Usage : " << argv[0] << "   bindport" << std::endl;  //打印使用手册
        exit(1);
    }
    uint16_t port = atoi(argv[1]); //命令行传的端口转换成16位整形
    std::unique_ptr<UdpServer> s(new UdpServer(port,CommandMessage)); //创建UDP服务器，并传入一个回调函数处理请求
    s->init(); //初始化服务器，创建 + 绑定
    s->start(); //运行服务器
}

server.hpp代码：

#pragma once
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <iostream>
#include <unistd.h>
#include <arpa/inet.h>
#include <functional>

typedef std::function<void(int,std::string,uint16_t,std::string)> func_t;

class UdpServer
{
private:
    int _sock; 
    uint16_t _port;
    func_t _callback;
public:
    UdpServer(uint16_t port,func_t callback): _port(port) ,_callback(callback){ }
    ~UdpServer() { close(_sock); }
    void init()
    {
        _sock = socket(AF_INET,SOCK_DGRAM,0);  //创建套接字
        if(_sock < 0)
        {
            //创建失败
            std::cout << "create socket failed...." << std::endl;
            abort();
        }
        //绑定 
        struct sockaddr_in ser; 
        ser.sin_port = htons(_port);  //填入端口
        ser.sin_family = AF_INET; // 填入域
        ser.sin_addr.s_addr = INADDR_ANY; //填入IP地址
        if(bind(_sock,(sockaddr*)&ser,sizeof ser) != 0) //绑定
        {
            //绑定失败
            std::cout << "bind socket failed...." << std::endl;
            abort();
        }
    }

    void start()
    {
        struct sockaddr_in peer; //对端
        socklen_t peer_len = sizeof peer;
        char buff[1024] = {0};   
        while(1)
        {
            int n = recvfrom(_sock,buff,1023,0,(struct sockaddr*)&peer,&peer_len); 
            buff[n] = 0;
            if(read == 0)
            {
                std::cout << "one client quit..." << std::endl;
                continue;
            }else if(read < 0)
            {
                 std::cout << "read error..." << std::endl;
                 break;
            }
            //获取客户端的端口和IP
            std::string clientip = inet_ntoa(peer.sin_addr);
            uint16_t clientport = ntohs(peer.sin_port);
            std::cout << buff << std::endl; //回显客户端信息
            //调用回调函数处理数据
            _callback(_sock,clientip,clientport,buff);
        }
    } 
};

client端代码

client端必须是先给服务端发送数据的，不过首先要先输入命令，然后把命令发给服务器。之后只需要等待服务器传回的结果，再把结果打印到显示器即可。

client.cc代码：

#include "client.hpp"
#include <memory>

int main(int argc , char* argv[])
{
    if(argc != 3) //必须 ./client 服务器ip  服务器端口  才能成功运行客户端
    {
        std::cout << "Usage : " << argv[0] << "   serverip  serverport" << std::endl; 
        exit(1);
    }
    uint16_t port = atoi(argv[2]); //提取服务器的端口
    std::string ip = argv[1]; //提取服务器的ip
    std::unique_ptr<UdpClient> cli(new UdpClient(port,ip));  //创建客户端
    cli->init(); //客户端初始化
    cli->start(); //客户端启动！
}

client.hpp代码：

#pragma once
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <iostream>
#include <arpa/inet.h>
#include <cstdio>
#include <cstring>

class UdpClient
{
public: 
    UdpClient(uint16_t port , const std::string& ip) : _port(port), _svr_ip(ip){}
    ~UdpClient(){ close(_sock); }

    void init()
    {
         _sock = socket(AF_INET,SOCK_DGRAM,0); 
        if(_sock < 0)
        {
            std::cout << "create socket failed...." << std::endl;
            abort();
        }   
        svr.sin_port = htons(_port); 
        svr.sin_addr.s_addr = inet_addr(_svr_ip.c_str()); 
        svr.sin_family = AF_INET;

    }
    void start()
    {
        int i = 1; 
        char sendbuff[1024] = {0};
        while(1)
        {
            //输入命令行
            std::cout << "[XXXX@abcdefg]$ ";
            fgets(sendbuff,sizeof sendbuff -1 , stdin); 
            sendbuff[strlen(sendbuff) - 1] = 0;
            std::string message = sendbuff;   
            //发送命令信息
            sendto(_sock,message.c_str(),message.size(),0,(struct sockaddr*)&svr,sizeof svr);
            //收服务器请求
            char recvbuff[1024 * 4] = {0};
            recvfrom(_sock,recvbuff,sizeof recvbuff - 1,0,nullptr,nullptr);
            //打印回收到的消息
            std::cout << recvbuff;
        }
    }

private: 
    int _sock;
    uint16_t _port;
    std::string _svr_ip;  
    struct sockaddr_in svr;

};

接下来我们可以看看运行结果：

我们先启动服务器，并且为服务器绑定端口号8080

然后我们启动客户端，输入服务器的ip和对应的端口号8080

然后在客户端中执行各种命令

无论是增加文件还是删除文件，都是可以进行操作的。所以这就实现了我们的一个远程mini版shell。

代码的git地址：