【计算机网络_应用层】TCP应用与相关API&&守护进程

已于 2024-03-01 13:07:25 修改
阅读量1.1k 收藏 17
点赞数 22
分类专栏： 计算机网络 文章标签： linux tcp/ip 运维
于 2024-02-26 10:18:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63249832/article/details/136292850
版权

需要云服务器等云产品来学习Linux的同学可以移步/–>腾讯云<–/官网，轻量型云服务器低至112元/年，优惠多多。（联系我有折扣哦）

文章目录

1. 相关使用接口

tcp协议和udp协议的接口基本相似。使用逻辑也是：1. 创建对应的socket文件套接字对象； 2. bind自己的网络信息；3. 进行相关通信

只是由于tcp协议的相关特性，所以tcp通信方式有一些不同点。

1. 对于服务端

在创建对应socket文件套接字对象并bind完成后需要设置sockfd为监听状态，使用listen系统调用。

头文件:
	#include <sys/types.h>
	#include <sys/socket.h>
函数原型:
	int listen(int sockfd, int backlog);
参数解释:
	sockfd:要设置的文件套接字对象
	backlog:最多允许这么多个客户端处于连接等待状态, 如果接收到更多的连接请求就忽略, 这里设置不会太大(一般是5), 
函数描述:
	将sockfd文件套接对象设置为监听状态
返回值:
	调用成功返回0，失败返回-1同时设置错误码

在设置sockfd为监听状态之后，在底层进行”三次握手“之后，服务端需要调用accept接受客户端的连接。

头文件:
	#include <sys/types.h>
	#include <sys/socket.h>
函数原型:
	int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
参数解释:
	sockfd:要设置的文件套接字对象（这里传的是监听的sockfd）
	addr:接受的连接对应的相关网络属性
	addrlen:addr对应的对象的大小
函数描述:
	服务端调用accept接受客户端的连接。如果服务器调用accept()时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来
返回值:
	调用成功返回一个新的文件套接字，用于进行本次的客户端和服务端通信，调用失败返回-1同时设置错误码

2. 对于客户端

同样在初始化的时候需要创建socket文件套接字，同样的不需要程序员显示bind。也不需要listen和accept。接下来需要做的事情就是发送连接请求，使用connect系统调用

头文件:
	#include <sys/types.h>
	#include <sys/socket.h>
函数原型:
	int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
参数解释:
	sockfd:发送链接请求的文件套接字对象
	addr:连接对应的相关网络属性
	addrlen:addr对应的对象的大小
函数描述:
	客户端使用sockfd向指定服务器的指定端口发起TCP链接请求
返回值:
	调用成功返回0，调用失败返回-1同时设置错误码

2. 代码实现

2.1 日志组件

一般来说，服务器在运行的时候，不会在当前shell输出相关的运行结果，而是在日志中输出，所以，这里我们现在封装一个日志的小组件

1. 组件需求

  1. 使用logMessage函数可以将相关日志信息写入预设的文件中（在当前目录创建对应文件）
  2. 每条日志信息都会有相关的日志等级，不同等级在不同文件中
  3. 日志内容支持format和可变参数

2. 代码实现

#include <unistd.h>
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cstdarg>

// 这里是日志等级对应的宏
#define DEBUG (1 << 0)
#define NORMAL (1 << 1)
#define WARNING (1 << 2)
#define ERROR (1 << 3)
#define FATAL (1 << 4)

#define NUM 1024 // 日志行缓冲区大小
#define LOG_NORMAL "log.txt" // 日志存放的文件名
#define LOG_ERR    "err.txt"

const char *logLevel(int level) // 把日志等级转变为对应的字符串
{
    switch (level)
    {
    case DEBUG:
        return "DEBUG";
    case NORMAL:
        return "NORMAL";
    case WARNING:
        return "WARNING";
    case ERROR:
        return "ERROR";
    case FATAL:
        return "FATAL";
    default:
        return "UNKNOW";
    }
}
//[日志等级][时间][pid]日志内容
void logMessage(int level, const char *format, ...) // 核心调用
{
    char logprefix[NUM]; // 存放日志相关信息
    time_t now_ = time(nullptr);
    struct tm *now = localtime(&now_);
    snprintf(logprefix, sizeof(logprefix), "[%s][%d年%d月%d日%d时%d分%d秒][pid:%d]",
             logLevel(level), now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec, getpid());

    char logcontent[NUM];
    va_list arg; // 声明一个变量arg指向可变参数列表的对象
    va_start(arg, format); // 使用va_start宏来初始化arg，将它指向可变参数列表的起始位置。
    // format是可变参数列表中的最后一个固定参数，用于确定可变参数列表从何处开始
    vsnprintf(logcontent, sizeof(logcontent), format, arg); // 将可变参数列表中的数据格式化为字符串，并将结果存储到logcontent中

    FILE *log =  fopen(LOG_NORMAL, "a");
    FILE *err = fopen(LOG_ERR, "a");
    if(log != nullptr && err != nullptr)
    {
        FILE *curr = nullptr;
        if(level == DEBUG || level == NORMAL || level == WARNING) curr = log;
        if(level == ERROR || level == FATAL) curr = err;
        if(curr) fprintf(curr, "%s%s\n", logprefix, logcontent);

        fclose(log);
        fclose(err);
    }
}

2.2 Server端

/* tcpServer.hpp */
#pragma once

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <string>

#include "log.hpp"

namespace Server
{
    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR
    };

    static const uint16_t gport = 8080;
    static const int gbacklog = 5;

    void serviceIO(int sock) // 服务端调用
    {
        char buffer[1024];
        while (true)
        {
            ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
            if (n > 0)
            {
                // 目前我们把读到的数据当成字符串, 截止目前
                buffer[n] = 0;
                std::cout << "recv message: " << buffer << std::endl;

                std::string outbuffer = buffer;
                outbuffer += " server[echo]";

                write(sock, outbuffer.c_str(), outbuffer.size()); // 这里再把结果写进sock中，意为返回给客户端
            }
            else if (n == 0)
            {
                // 代表client退出
                logMessage(NORMAL, "client quit, me too!");
                break;
            }
        }
        close(sock);
    }

    class tcpServer
    {
    public:
        tcpServer(uint16_t &port) : _port(port)
        {
        }
        void initServer()
        {
            // 1. 创建socket文件套接字对象
            _listensock = socket(AF_INET, SOCK_STREAM, 0);
            if (_listensock == -1)
            {
                logMessage(FATAL, "create socket error");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success:%d", _listensock);
            // 2.bind自己的网络信息
            sockaddr_in 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 == -1)
            {
                logMessage(FATAL, "bind socket error");
                exit(BIND_ERR);
            }
            logMessage(NORMAL, "bind socket success");
            // 3. 设置socket为监听状态
            if (listen(_listensock, gbacklog) != 0) // listen 函数
            {
                logMessage(FATAL, "listen socket error");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL, "listen socket success");
        }
        void start()
        {
            while (true)
            {
                struct sockaddr_in peer;
                socklen_t len = sizeof peer;
                int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
                if (sock < 0)
                {
                    logMessage(ERROR, "accept error, next");
                    continue;
                }

                serviceIO(sock); // 使用

                close(sock); // 使用之后要关闭，否则会造成文件描述符泄露
            }
        }
        ~tcpServer() {}

    private:
        uint16_t _port;
        int _listensock;
    };

} // namespace Server

/* tcpServer.cc */
#include <iostream>
#include <memory>

#include "tcpServer.hpp"

using namespace Server;

static void Usage(const char *proc)
{
    std::cout << "\n\tUsage:" << proc << " local_port\n";
}

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<tcpServer> tsvr(new tcpServer(port));
    tsvr->initServer();
    tsvr->start();
    return 0;
}

2.3 Client端

/* tcpClient.hpp */
#pragma once
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include <string>

#include "log.hpp"

namespace Client
{
    class tcpClient
    {
    public:
        tcpClient(uint16_t &port, std::string &IP) : _serverPort(port), _serverIP(IP), _sockfd(-1) {}

        void initClient()
        {
            // 1. 创建socket
            _sockfd = socket(AF_INET, SOCK_STREAM, 0);
            if(_sockfd == -1)
            {
                std::cerr << "create socket error" << std::endl;
                exit(2);
            }

        }

        void run()
        {
            struct sockaddr_in server;
            server.sin_family = AF_INET;
            server.sin_port = htons(_serverPort);
            server.sin_addr.s_addr = inet_addr(_serverIP.c_str());

            if(connect(_sockfd, (struct sockaddr*)&server, sizeof server) != 0)
            {
                // 链接失败
                std::cerr << "socket connect error" << std::endl;
            }
            else
            {
                std::string msg;
                while(true)
                {
                    std::cout << "Please Enter# ";
                    std::getline(std::cin, msg);
                    write(_sockfd, msg.c_str(), msg.size());

                    char buffer[NUM];
                    int n = read(_sockfd, buffer, sizeof(buffer) - 1); // 按照字符串的形式读取
                    if(n > 0)
                    {
                        // 目前先把读到的数据当作字符串处理
                        buffer[n] = 0;
                        std::cout << "Server 回显# " << buffer << std::endl;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }

        ~tcpClient()
        {
            if(_sockfd >= 0) close(_sockfd); // 使用完关闭，防止文件描述符泄露（当然这里也可以不写，当进程结束之后一切资源都将被回收）
        }

    private:
        uint16_t _serverPort;
        std::string _serverIP;
        int _sockfd;
    };

} // namespace Client
/* tcpClient.cc */
#include <memory>
#include <string>

#include "tcpClient.hpp"
using namespace Client;

static void Usage(const char *proc)
{
    std::cout << "\n\tUsage:" << proc << " server_ip server_port\n";
}

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string IP = argv[1];
    uint16_t port = atoi(argv[2]);
    std::unique_ptr<tcpClient> tclt(new tcpClient(port, IP));
    tclt->initClient();
    tclt->run();

    return 0;
}

image-20240226002443205

2.3 bug解决

这里会出现一个问题：在此时如果再有另一个客户端进行通信，就会出现其他客户端被阻塞的问题

image-20240226002542298

这是因为我们在服务端的serviceIO中的执行没有结束，而且由于实现的是死循环，所以也不可能结束，这就造成了服务端一直在阻塞的情况。那么如何解决呢？

1. 实现多进程版本

多进程的实现思想就是：每次收到新请求的时候，都创建一个子进程，让子进程来执行对应任务，父进程继续监听，但是由于创建的子进程需要被父进程等待回收，否则就会出现僵尸进程。那么这里的解决方案就是：让子进程再创建一个子进程，最终让孙子进程来执行本次请求对应的任务，父进程直接exit，爷爷进程等待父进程结束后继续监听。此时孙子进程就变成了孤儿进程，由OS直接接收管理。

这里需要更改的就只有tcpServer.hpp文件中的start函数，这里附上更改后的代码

void start()
{
    while (true)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof peer;
        int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
        if (sock < 0)
        {
            logMessage(ERROR, "accept error, next");
            continue;
        }
        pid_t id = fork();
        if (id == 0)
        {
            close(_listensock); // 子进程不会使用监听socket，但是创建子进程的时候写时拷贝会拷贝，这里先关掉
            // 子进程再创建子进程
            if (fork() > 0)
                exit(0); // 父进程退出
            // 走到当前位置的就是子进程
            serviceIO(sock); // 使用
            close(sock); // 关闭对应的通信socket（这里也可以不关闭，因为此进程在下个语句就会退出）
            exit(0); // 孙子进程退出
        }
        // 走到这里的是监听进程（爷爷进程）
        pid_t n = waitpid(id, nullptr, 0);
        if(n > 0)
        {
            logMessage(NORMAL, "wait success pid:%d", n);
        }
        close(sock); // 使用之后要关闭，否则会造成文件描述符泄露
    }
}

image-20240226082008918

现在再测试，服务器就能够同时处理多个客户端的请求。

2. 实现多线程版本

但是，我们知道OS在创建线程的时候，需要的成本是非常高的，但是线程就非常轻量级，所以使用线程来处理服务器请求是更加合理的，所以这里实现一下多线程的版本

void start()
{
    while (true)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof peer;
        int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
        if (sock < 0)
        {
            logMessage(ERROR, "accept error, next");
            continue;
        }
        // version 3:多线程版本
        pthread_t tid;
        pthread_create(&tid, nullptr, routine, new ThreadData(this, sock)); // 创建新线程，让新线程调用routine然后去执行serviceIO
    }
}        
static void *routine(void *arg)
{
    // 由于不能让主线程等待新线程执行完毕，所以这里进行线程分离
    pthread_detach(pthread_self());
    ThreadData* args = static_cast<ThreadData*>(arg);
    serviceIO(args->_sock);
    close(args->_sock); // 使用完之后回收sock
    delete args; // 回收空间
    return nullptr;
}

image-20240226083955051

3. 实现线程池版本

当然，上述的两种实现方式是具有一些优化空间的，因为每次在创建子进程/新线程的时候都会有消耗，这样会降低效率，而且当突然出现很多长时间的请求的时候，服务器就会同时接收到很多请求，会一直创建子进程/新线程，可能会导致服务器崩溃，所以可以使用我们之前写过的一个小组件线程池来改写

void start()
{
    ThreadPool<Task>::getInstance()->run(); // 初始化线程池,让他跑起来
    logMessage(NORMAL, "init thread pool success");

    while (true)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof peer;
        int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
        if (sock < 0)
        {
            logMessage(ERROR, "accept error, next");
            continue;
        }
        // version 4:线程池版本
        ThreadPool<Task>::getInstance()->push(Task(sock, serviceIO));
    }
}

/* 小组件 */
// Task.hpp
#pragma once

#include <string>
#include <iostream>
#include <functional>


class Task
{
public:
    using func_t = std::function<void(int)>;

public:
    Task() {}
    Task(int sock, func_t func)
        : _sock(sock), _callback(func)
    {
    }
    void operator()()
    {
        _callback(_sock);
    }

private:
    int _sock;
    func_t _callback;
};
// Thread.hpp
#pragma once

#include <iostream>
#include <string>
#include <functional>
#include <pthread.h>
#include <cassert>

class Thread
{
public:
    using func_t = std::function<void *(void *)>; // 定义func_t类型
    static int number;                            // 线程编号，按照一次运行时的调用次数计数
public:
    Thread()
    {
        char *buffer = new char[64];
        name_ = "thread-" + std::to_string(++number);
    }
    static void *start_routine(void *args)
    {
        Thread *_this = static_cast<Thread *>(args);
        void *ret = _this->run(_this->args_);
        return ret;
    }
    void *run(void *arg)
    {
        return func_(arg);
    }
    void start(func_t func, void *args)
    {
        func_ = func;
        args_ = args;
        int n = pthread_create(&tid_, nullptr, start_routine, this);
        assert(n == 0);
        (void)n;
    }
    void join()
    {
        int n = pthread_join(tid_, nullptr);
        assert(n == 0);
        (void)n;
    }
    std::string GetTaskName()
    {
        return name_;
    }
    ~Thread() {}

private:
    std::string name_; // 线程名
    pthread_t tid_;    // 线程id
    func_t func_;      // 线程调用的函数
    void *args_;       // 线程调用函数的参数
};
int Thread::number = 0;
// ThreadPool.hpp
#pragma once
#include "LockGuard.hpp"
#include "Thread.hpp"
#include <vector>
#include <queue>
#include <string>
#include <iostream>
#include <mutex>

const int gnum = 5; // 线程池中默认的线程个数

template <class T>
class ThreadPool; // 线程池类的声明

/* 线程数据类，保存线程对应的内容包括线程池对象的指针和线程名 */
template <class T>
class ThreadData
{
public:
    ThreadData(ThreadPool<T> *tp, const std::string &n) : threadpool(tp), name(n){};

public:
    ThreadPool<T> *threadpool;
    std::string name;
};

/* 线程池类的实现 */
template <class T>
class ThreadPool
{
public:
    static void *handleTask(void *args) // 线程需要执行的回调函数
    {
        ThreadData<T> *td = static_cast<ThreadData<T> *>(args);
        while (true)
        {
            T t; // 构建任务对象
            {
                LockGuard lockGuard(td->threadpool->mutex()); // 上锁
                while (td->threadpool->isQueueEmpty())
                {
                    // 如果任务队列为空，线程挂起，等待队列中被填充任务
                    td->threadpool->threadWait();
                }
                t = td->threadpool->pop(); // 如果队列中有任务，就拿出任务
            }
            // 任务在锁外执行
            t();
        }
        delete td;
        return nullptr;
    }

public: // 给handleTask调用的外部接口
    pthread_mutex_t *mutex() { return &_mutex; }
    bool isQueueEmpty() { return _task_queue.empty(); }
    void threadWait() { pthread_cond_wait(&_cond, &_mutex); }
    T pop() // 获取线程池中任务队列里需要执行的下一个任务
    {
        T t = _task_queue.front();
        _task_queue.pop();
        return t;
    }

public:                               // 需要暴露给外部的接口

    void run() // 为所有线程对象创建真正的执行流，并执行对应的回调函数
    {
        for (const auto &thread : _threads)
        {
            ThreadData<T> *td = new ThreadData<T>(this, thread->GetTaskName()); // 构造handleTask的参数对象
            thread->start(handleTask, td);                                      // 调用该线程的start函数，创建新线程执行指定的handleTask任务
            // std::cout << thread->GetTaskName() << " start..." << std::endl;
        }
    }
    void push(const T &in) // 将指定任务push到队列中
    {
        // 加锁
        LockGuard lockGuard(&_mutex); // 自动加锁，在当前代码段结束之后调用LockGuard的析构函数解锁
        _task_queue.push(in);
        pthread_cond_signal(&_cond); // 发送信号表示此时task_queue中有值，让消费者可以使用
    }
    ~ThreadPool() // 析构函数，销毁互斥量和条件变量，delete所有thread对象指针，自动调用thread对象的析构函数
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
        for (auto &thread : _threads)
        {
            delete thread;
        }
    }

    static ThreadPool<T> *getInstance()
    {
        if(nullptr == tp)
        {
            std::lock_guard<std::mutex> lck(_singletonlock);
            if(nullptr == tp)
            {
                tp = new ThreadPool<T> ();
            }
        }
        return tp;
    }
private: // 单例模式需要私有化的接口
    ThreadPool(const int &num = gnum) // 构造函数，初始化互斥量和条件变量，构建指定个数的Thread对象
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);
        for (int i = 0; i < num; ++i)
        {
            _threads.push_back(new Thread());
        }
    }
    //delete拷贝构造和析构函数
    ThreadPool(const ThreadPool<T> &) = delete;
    ThreadPool<T> *operator=(const ThreadPool<T> &) = delete;

private:
    std::vector<Thread *> _threads; // 保存所有线程对象的指针
    std::queue<T> _task_queue;      // 需要被分配的任务队列
    pthread_mutex_t _mutex;         // 任务队列需要被互斥的访问
    pthread_cond_t _cond;           // 生产任务和消费任务之间需要进行同步

    static ThreadPool<T> *tp; // 静态成员，存放ThreadPool指针
    static std::mutex _singletonlock; // 创建线程安全的单例对象要加的锁
};
template<class T>
ThreadPool<T> *ThreadPool<T>::tp = nullptr;
template<class T>
std::mutex ThreadPool<T>::_singletonlock;

image-20240226085928431

3. 守护进程

3.1 守护进程是什么

在我们之前实现的代码中，所有的Server端在运行的时候都会占用前台的Shell，当这个Shell退出之后，对应的进程也就会退出

image-20240226091312689

但是我们知道：在实际的应用环境中，是不会出现这种情况的，这是因为在实际部署服务的时候，会将对应的服务守护进程化，所谓的守护进程化就是让对应的进程不受当前会话的影响

守护进程的理解

我们是使用远程命令行工具来连接我们的云服务器的，这个工具在Windows下会使用Xshell，macOS下使用自带的终端或者iTerm，或者会使用VScode远程连接带有的shell…

在我们登录成功之后，OS在内部会创建一个会话，在此会话内部创建一个前台进程bash进行命令行解释，此时我们就可以想bash中输入命令，OS帮我们执行。

在一个会话（session）中，同一时间只能有一个前台进程但是可以有任意个后台进程的存在

当这个会话结束之后，会话内所有的进程都将会退出，这也就是为什么我们的服务不能长久的在服务器中运行

3.2 守护进程相关的使用

1. &和jobs

&可以让一个命令在后台运行

jobs可以查看当前会话的所有作业（现在可以理解成进程）

image-20240226092835820

  • 作业前面的[]内部的数字就是作业号

为什么这个服务运行起来后还能够输入命令？

这是因为这个服务变成后台作业了，一个会话在同一时刻有且只有一个前台进程

  • 通过PGID可以确定同一个进程组
  • 通过SID可以确定同一个会话

image-20240226093227728

  • fg+作业号：把对应作业放在前台
  • CTRL+z：暂停作业（一个任务在前台如果暂停了会立马放在后台）
  • bg+作业号：启动作业

image-20240226093745860

2. daemon

OS提供了一个守护进程化的接口，但是我们不建议使用，因为这个接口会产生一些未定义行为，所以我们自己封装一个小组件用于守护进程化。

image-20240226094239043

3.3 守护进程化的实现原理

守护进程化的实现原理就是：让这个进程自己成为一个会话组，独立出来就可以不受当前会话的影响

头文件:
	#include <unistd.h>
函数原型:
	pid_t setsid();
函数解释:
	对于一个非会话组组长的进程，使其成为一个新的会话组，并且调用进程成为组长
返回值:
	如果调用成功，返回一个新的SID（SID就是当前会话组的组长的pid）；调用失败返回-1同时设置错误码

守护进程化组件的实现

// daemon.hpp
#pragma once

#include <unistd.h>
#include <signal.h>
#include <cstdlib>
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define DEV "/dev/null" // 这个路径是一个“黑洞”，写入的所有数据都会被“吃掉”，不会被读取

void deamonSelf(const char *curPath = nullptr) // 可选参数，如果传入非空，就更改“当前路径”
{
    // 1. 让调用进程忽略掉所有异常信号
    signal(SIGPIPE, SIG_IGN);
    // 2. 让当前进程成为非组长进程
    if (fork() > 0)
        exit(0); // 创建子进程，然后将父进程退出确保调用setsid的进程是非组长进程

    // 3. 调用setsid创建新的会话组
    pid_t n = setsid();
    assert(n != -1);

    // 4. 守护进程是脱离终端的，需要关闭或者重定向以前进程默认打开的文件，这里我们采用重定向的方法更安全
    int fd = open(DEV, O_RDWR);
    if(fd > 0)
    {
        dup2(fd, 0);
        dup2(fd, 1);
        dup2(fd, 2);
        close(fd);
    }
    else
    {
        close(0);
        close(1);
        close(2);
    }
    // 5. 可选：是否更改当前路径
    if (curPath != nullptr)
        chdir(curPath);
}

#include <iostream>
#include <memory>

#include "tcpServer.hpp"
#include "daemon.hpp"

using namespace Server;

static void Usage(const char *proc)
{
    std::cout << "\n\tUsage:" << proc << " local_port\n";
}

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<tcpServer> tsvr(new tcpServer(port));
    tsvr->initServer();
    deamonSelf(); // 当前进程守护进程化
    tsvr->start();
    return 0;
}

image-20240226100859218

本节完…

凌云志.
关注
  • 22
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
failed to start daemon at tcp:5037
qq_15653601的博客
12-12 3642
adb出现daemon启动失败： >adb devices * daemon not running; starting now at tcp:5037 could not read ok from ADB Server * failed to start daemon adb.exe: failed to check server version: cannot connect to daemon 这个算是老生常谈的问题了，但见到的博客似乎没有有效解决我的问题。启动失败可能是我有其它的adb进程
实验3 传输层与应用层协议.docx
02-06
1、捕获TCP三次握手的过程，说明其原理。 2、捕获HTTP工作过程，分析HTTP协议。 3、捕获UDP协议包，写出其格式。 4、捕获DNS数据包，写出DNS工作原理。
linux x z model 协议,tcpdaemon: tcpdaemon是类似于xinetd的TCP守护，负责特定进程模型下的TCP连接管理，与客户定制的通讯数据协议层和应用处理层模块的链接时或...
weixin_42492211的博客
05-15 152
tcpdaemon0.快速开始老师交给小明一个开发任务，实现一个TCP网络迭代并发服务器，用于回射任何接收到的通讯数据。小明很懒，他在开源中国项目库里搜到了开源库tcpdaemon来帮助他快速完成任务。首先他安装好tcpdaemon，然后写了一个C程序文件test_callback_echo.c$ vi test_callback_echo.c#include "tcpdaemon.h"_WIND...
tcp文件服务器编码,tcpdaemon: tcpdaemon是一个TCP通讯服务端平台/库，它封装了众多常见服务端进程/线程管理和TCP连接管理模型（Forking、Leader-Follow、IO...
weixin_39872123的博客
08-10 116
tcpdaemon0.快速开始老师交给小明一个开发任务，实现一个TCP网络迭代并发服务器，用于回射任何接收到的通讯数据。小明很懒，他在开源中国项目库里搜到了开源库tcpdaemon来帮助他快速完成任务。首先他安装好tcpdaemon，然后写了一个C程序文件test_callback_echo.c$ vi test_callback_echo.c#include "tcpdaemon.h"_WIND...
tcp服务器用户管理,tcpdaemon: tcpdaemon是一个TCP通讯服务端平台/库，它封装了众多常见服务端进程/线程管理和TCP连接管理模型（Forking、Leader-Follow、IO...
weixin_35214794的博客
08-03 194
tcpdaemon0.快速开始老师交给小明一个开发任务，实现一个TCP网络迭代并发服务器，用于回射任何接收到的通讯数据。小明很懒，他在开源中国项目库里搜到了开源库tcpdaemon来帮助他快速完成任务。首先他安装好tcpdaemon，然后写了一个C程序文件test_callback_echo.c$ vi test_callback_echo.c#include "tcpdaemon.h"_WIND...
socket套接字——TCP协议
qq_65285898的博客
09-16 1709
每次这个logmessage函数都把格式化的信息达到屏幕上，告诉我们程序的状态，当然我们也可以把它同时写到文件中，这也是它的一个简单的日志。由于网络的操作步骤多，查找bug困难，所以我们在程序运行到某一个阶段时都告诉我们当前的操作是完成了还是没完成，新建一个log.hpp。启动服务器需要使用accept函数等待客户端的连接，无连接请求会阻塞等待，出现连接请求则会返回一个用于通信的文件描述符。下面的代码包括了所有类型的实现，通过注释不同的字段，就可以实现不同的版本。（现在的为线程池版本）
计算机网络 | 应用层
光看不点赞的博客
06-23 548
2.进程通信 对于本地的进程 对于进程处于不同的主机 2.1 分布式进程之间的通信 注意：在看此节之前，应先阅读第三节关于socket的讲解 分布式进程需要解决的三个问题：对于使用面向连接服务（TCP）的应用而言，套接字是4元组的一个具有本地意义的标示需要在本地维护如下图所示的一张表 对于使用无连接服务（UDP）的应用而言，套接字是2元组的一个具有本地意义的标示URL（通用资源定位符）格式：我们通过URL来进行对每个对象的引用访问大部分状态码作用：不访问原始服务器，就满足客户的请求缓存是为了
计算机网络(自顶而下)——应用层及常见协议
weixin_52315708的博客
07-10 311
进程：在主机上运行的应用程序：在哪个地址(IP)、端口。
自顶向下计算机网络学习 第二章 应用层
qq_45351128的博客
02-26 2582
应用层一、应用层协议原理1.网络应用的体系结构1.1 客户-服务器(C/S) 体系结构1.2 对等体(P2P)体系结构1.3 混合体：客户 - 服务器和对等体系结构2.应用进程间的通信2.1 分布式进程需要解决的问题2.1.1 进程标示和寻址问题2.1.2 传输层 - 应用层提供服务是如何2.1.3 传输层提供的服务 - 需要穿过层间的信息2.1.4 传输层提供的服务 - 层间信息的代表 一、应用层协议原理 1.网络应用的体系结构 1.1 客户-服务器(C/S) 体系结构 我们平时在百度上搜索知识，我们的
【计算机网络习题集1】应用习题应用层基本概念
Qingxian_01的博客
03-23 768
应用层基本概念和DNS的习题
网络转发器 .rar_应用层_网段_网络转发器_转发_转发 socket
07-15
网络转发器 (说明书和代码与文档) 用于运行在可以跨两个网段的机器上用来作为一个TCP应用层的一个桥，当然也可以用来在应用层截获数据和分析数据
TCP&UDP测试工具_tcp&udp_TCP/UDP测试工具_TCP工具_
10-02
TCP/UDP测试工具，建立服务器和客户端，便可实现模拟通信
tcp&UDP DEMO.rar_DEMO_socket_tcp udp的cdemo_tcp&udp
09-21
C\C++编写的tcp\udp客户端及服务器程序
TCP.rar_TCP程序_tcp_tcp api_visual c
09-20
一个简单的TCP聊天程序，使用winsock api实现。
Linux - 磁盘管理1
最新发布
weixin_45735487的博客
05-27 734
逻辑分区只能在拓展分区上划分，编号5-15。拓展分区编号1-4，拓展分区不能格式化。rescue 恢复分区,对于误删的分区进行恢复,语法: rescue 起始 结束。rm 删除分区,后接要删除的分区编号。（L） 在主分区和拓展分区划分完之后，默认提示划分逻辑分区。n 进行磁盘分区，这里会默认MBR标签。（p） msdos下，会默认选择先划分主分区。
【Linux】升级GCC（版本9.3），补充：binutils
yannan20190313的博客
05-27 791
【Linux】升级GCC（版本9.3），补充：binutils
Linux echo命令（在终端输出文本）
Dontla的博客
05-22 872
echo是Linux和Unix系统中常用的一个命令行工具，主要用于在终端输出文本。该命令非常简单，但是它在脚本编程和日常系统管理中扮演着重要的角色。
【Linux】中常见的重要指令（下）以及重要的几个热键
2401_84568462的博客
05-27 1180
find指令查找的文件不能当前路径下（可以这样理解：如果要查找当前路径下可以使用ls指令，就不麻烦find指令了），必须查找当前路径下的目录里的文件。1.能被打包压缩的一定是由多个文件组成的，打包压缩后将文件变为一个整体，在传递给其他用户时不容易缺失。.tar打包后缀 .gz压缩后缀 XXX.tar.gz ----->XXX.tgz。功能：在系统特定的路径下查找，及可以找到可执行程序，有可以找到手册，安装包和压缩包等。命令在目录结构中搜索文件，并执行指定的操作。功能：在指令路径下搜索指令文件。
传输层TCP和应用层TCP区别
07-28
传输层TCP是计算机网络中的传输层协议，位于网络层和应用层之间。它提供了可靠的、面向连接的数据传输服务。TCP使用一种称为三次握手的机制来建立和维护通信双方之间的连接，确保数据的可靠性和顺序性。它还提供拥塞...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凌云志.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值