Linux网络编程之TCP

于 2024-07-24 12:05:54 发布
阅读量465 收藏 17
点赞数 13
分类专栏： Linux 文章标签： 网络 linux tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44121078/article/details/140659498
版权

文章目录

Linux网络编程之TCP

1、TCP协议的简单认识

  • 传输层协议

  • 有连接

  • 可靠传输

  • 面向字节流

2、TCP网络编程接口

2.1、socket

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int socket(int domain, int type, int protocol);

该接口和UDP一样，首先我们得先创建socket套接字。

用法不一样的是传入参数不同。

UDP传入的type是SOCK_DGRAM，表示无连接不可靠数据报的传输层协议。

那TCP传入的type是SOCK_STREAM，表示有序、可靠、有连接字节流的传输层协议。

2.2、bind

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

和UDP的用法一致。

绑定本地服务器信息。

2.3、listen

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int listen(int sockfd, int backlog);

这个接口是UDP没有的。

listen接口是监听是否有客户端发器连接，如果有，则给accept接口说可以建立连接。

2.4、accept

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

这个接口是UDP没有的。

accept接口是和客户端建立连接，成功建立连接则返回一个新的文件描述符！

这里举一个生活例子来说明listen和accept的关系：

假设有一家饭馆，有一个招揽客人的服务员张三，还有多个带客人进饭店某个桌子的服务员李四王五等。服务员张三只负责招揽客人，如果有客人想进来吃饭，那么张三就会叫李四王五等服务员带客人去指定桌子吃饭，然后张三再继续招揽客人，李四王五等人只管服务他们带进来的指定客人，知道他们吃完。当然客人进饭店了看了环境可能不想吃了，然后又不吃了。那么这里的张三就是listen，李四王五等人就是accept后的新文件描述符newsockfd1，newsockfd2等。

2.5、connect

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

这个接口是UDP没有的。

connect是客户端向服务器发起连接的接口。

3、简单的TCP网络程序

3.1、服务器响应程序

和UDP服务器响应程序一样，客户端发什么就回什么，只不过多了建立连接的步骤。
注意：在TcpServer.hpp文件中，有处理任务的多个版本。

  • Comm.hpp文件
#pragma once
#include "InetAddr.hpp"

enum errorcode
{
   CREATE_ERROR = 1,
   BIND_ERROR,
   LISTEN_ERROR,
   SEND_ERROR,
   RECV_ERROR,
   CONNECT_ERROR,
   FORK_ERROR,
   USAGE_ERROR
};

#define CONV(ADDR) ((struct sockaddr *)ADDR)

std::string CombineIpAndPort(InetAddr addr)
{
   return "[" + addr.Ip() + ":" + std::to_string(addr.Port()) + "] ";
}
  • InetAddr.hpp文件
#pragma once

#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>

class InetAddr
{
   void GetAddress(std::string *ip, uint16_t *port)
   {
       // char *inet_ntoa(struct in_addr in);
       *ip = inet_ntoa(_addr.sin_addr);
       *port = ntohs(_addr.sin_port);
   }

public:
   InetAddr(const struct sockaddr_in &addr) : _addr(addr)
   {
       GetAddress(&_ip, &_port);
   }

   std::string Ip()
   {
       return _ip;
   }

   uint16_t Port()
   {
       return _port;
   }
   bool operator==(InetAddr &addr)
   {
       return _ip == addr.Ip() && _port == addr.Port();
   }

   const struct sockaddr_in& GetAddr()
   {
       return _addr;
   }

   ~InetAddr() {}

private:
   struct sockaddr_in _addr;
   std::string _ip;
   uint16_t _port;
};
  • LockGuard.hpp文件
# pragma once

#include <pthread.h>


class LockGuard
{
public:
   LockGuard(pthread_mutex_t *mutex) : _mutex(mutex)
   {
       pthread_mutex_lock(_mutex); // 构造加锁
   }
   ~LockGuard()
   {
       pthread_mutex_unlock(_mutex); // 析构解锁
   }

private:
   pthread_mutex_t *_mutex;
};
  • Log.hpp文件
#pragma once

#include <string>
#include <iostream>
#include <fstream>
#include <unistd.h>
#include <stdarg.h>
#include <sys/types.h>
#include "LockGuard.hpp"

using namespace std;

bool isSave = false; // 默认向显示器打印
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
#define FILEPATH "./log.txt"

enum level
{
   DEBUG = 0,
   INFO,
   WARNING,
   ERROR,
   FATAL
};

void SaveToFile(const string &message)
{
   ofstream out(FILEPATH, ios_base::app);
   if (!out.is_open())
       return;
   out << message;
   out.close();
}

std::string LevelToString(int level)
{
   switch (level)
   {
   case DEBUG:
       return "Debug";
   case INFO:
       return "Info";
   case WARNING:
       return "Warning";
   case ERROR:
       return "Error";
   case FATAL:
       return "Fatal";
   default:
       return "Unknow";
   }
}

std::string GetTimeString()
{
   time_t curr_time = time(nullptr);
   struct tm *format_time = localtime(&curr_time);
   if (format_time == nullptr)
       return "None";
   char buff[1024];
   snprintf(buff, sizeof(buff), "%d-%d-%d %d:%d:%d",
            format_time->tm_year + 1900,
            format_time->tm_mon + 1,
            format_time->tm_mday,
            format_time->tm_hour,
            format_time->tm_min,
            format_time->tm_sec);
   return buff;
}

void LogMessage(const std::string filename, int line, bool issave, int level, const char *format, ...)
{
   std::string levelstr = LevelToString(level);
   std::string timestr = GetTimeString();
   pid_t pid = getpid();

   char buff[1024];
   va_list arg;
   // int vsnprintf(char *str, size_t size, const char *format, va_list ap); // 使用可变参数
   va_start(arg, format);
   vsnprintf(buff, sizeof(buff), format, arg);
   va_end(arg);

   LockGuard lock(&mutex);
   std::string message = "[" + timestr + "]" + "[" + levelstr + "]" + "[pid:" + std::to_string(pid) + "]" + "[" + filename + "]" + "[" + std::to_string(line) + "] " + buff + '\n';
   if (issave == false)
       std::cout << message;
   else
       SaveToFile(message);
}

// 固定文件名和行数
#define LOG(level, format, ...)                                               \
   do                                                                        \
   {                                                                         \
       LogMessage(__FILE__, __LINE__, isSave, level, format, ##__VA_ARGS__); \
   } while (0)

#define EnableScreen()  \
   do                  \
   {                   \
       isSave = false; \
   } while (0)

#define EnableFile()   \
   do                 \
   {                  \
       isSave = true; \
   } while (0)

void Test(int num, ...)
{
   va_list arg;
   va_start(arg, num);
   while (num--)
   {
       int data = va_arg(arg, int);
       std::cout << data << " ";
   }
   std::cout << std::endl;
   va_end(arg);
}
  • Main.cc文件
#include <iostream>
#include <memory>
#include "TcpServer.hpp"

void Usage()
{
   // printf("./udp_server serverip serverport\n");
   printf("Usage : ./udp_server serverport\n"); // ip 已经设置为0
}

int main(int argc, char *argv[])
{
   // if (argc != 3)
   if (argc != 2)
   {
       Usage();
       exit(USAGE_ERROR);
   }

   uint16_t serverport = std::stoi(argv[1]);
   std::unique_ptr<TcpServer> tsvr = std::make_unique<TcpServer>(serverport);
   tsvr->InitServer();
   tsvr->Start();

   return 0;
}
  • Makefile文件
.PHONY:all
all:tcp_client tcp_server

tcp_client:TcpClient.cc
	g++ -o $@ $^ -std=c++14 -lpthread
tcp_server:Main.cc
	g++ -o $@ $^ -std=c++14 -lpthread

.PHONY:clean
clean:
	rm -f tcp_server tcp_client
  • TcpClient.cc文件
#include <iostream>

#include <strings.h>
#include <string.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "Comm.hpp"
#include "Log.hpp"

void Usage()
{
   printf("Usage : ./udp_client serverip serverport\n");
}
int main(int argc, char *argv[])
{
   if (argc != 3)
   {
       Usage();
       exit(USAGE_ERROR);
   }
   std::string serverip = argv[1];
   uint16_t serverport = std::stoi(argv[2]);

   int sockfd = socket(AF_INET, SOCK_STREAM, 0);
   if (sockfd < 0)
   {
       LOG(FATAL, "create sockfd error, error code : %d, error string : %s", errno, strerror(errno));
       exit(CREATE_ERROR);
   }
   LOG(INFO, "create sockfd success");

   struct sockaddr_in local;
   bzero(&local, sizeof(local));
   local.sin_family = AF_INET;
   local.sin_port = htons(serverport);
   local.sin_addr.s_addr = inet_addr(serverip.c_str());

   // 发起连接
   int n = ::connect(sockfd, CONV(&local), sizeof(local));
   if (n < 0)
   {
       LOG(WARNING, "create connect error, error code : %d, error string : %s", errno, strerror(errno));
       exit(CONNECT_ERROR);
   }
   LOG(INFO, "create connect success");

   // 发收数据
   while (true)
   {
       std::cout << "Please Enter# ";
       // 发送数据
       std::string message;
       std::getline(cin, message);

       int ret = ::send(sockfd, message.c_str(), message.size(), 0);
       if (ret < 0)
       {
           LOG(FATAL, "send message error, error code : %d, error string : %s", errno, strerror(errno));
           exit(SEND_ERROR);
       }

       char buff[1024];
       // 接收数据
       int m = ::recv(sockfd, buff, sizeof(buff) - 1, 0);
       if (m > 0)
       {
           buff[m] = 0;
           std::cout << "Server Echo$ " << buff << std::endl;
       }
   }
}
  • TcpServer.hpp文件
#pragma once

#include <sys/types.h> /* See NOTES */
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include <error.h>
#include <string.h>
#include <pthread.h>
#include <functional>

#include "Log.hpp"
#include "InetAddr.hpp"
#include "Comm.hpp"
#include "Threadpool.hpp"

const int defaultsockfd = -1;
int gbacklog = 16; // 暂时先用

using task_t = std::function<void()>;

// 声明
class TcpServer;

class ThreadData
{
public:
   ThreadData(int sockfd, InetAddr addr, TcpServer *self)
       : _sockfd(sockfd), _addr(addr), _self(self) {}
   ~ThreadData() = default;

public:
   int _sockfd;
   InetAddr _addr;
   TcpServer *_self;
};

class TcpServer
{
public:
   TcpServer(uint16_t port) : _port(port), _listensock(defaultsockfd), _isrunning(false)
   {
   }

   void InitServer()
   {
       // 创建
       _listensock = socket(AF_INET, SOCK_STREAM, 0); // 这个就是文件描述符
       if (_listensock < 0)
       {
           LOG(FATAL, "create sockfd error, error code : %d, error string : %s", errno, strerror(errno));
           exit(CREATE_ERROR);
       }
       LOG(INFO, "create sockfd success");

       struct sockaddr_in local;
       bzero(&local, sizeof(local));
       local.sin_family = AF_INET;
       local.sin_port = htons(_port);
       local.sin_addr.s_addr = INADDR_ANY;
       // 绑定
       int n = ::bind(_listensock, CONV(&local), sizeof(local));
       if (n < 0)
       {
           LOG(FATAL, "bind sockfd error, error code : %d, error string : %s", errno, strerror(errno));
           exit(BIND_ERROR);
       }
       LOG(INFO, "bind sockfd success");
   }

   void Service(int sockfd, InetAddr client)
   {
       while (true)
       {
           // TCP是字节流（可以使用write和read接口），UDP是数据报
           char buff[1024];
           // 接收消息
           int n = ::read(sockfd, buff, sizeof(buff)); // bug，接收数据可能收到的不完整，比如1+100，可能先收到1+1，再收到00 -- 按序到达
           std::string clientAddr = CombineIpAndPort(client);

           if (n > 0)
           {
               buff[n] = 0;
               std::string message = clientAddr + buff;
               LOG(INFO, "get message : \n %s", message.c_str());

               // 发送消息
               int m = ::write(sockfd, buff, strlen(buff)); 
               if (m < 0)
               {
                   LOG(FATAL, "send message error ,error code : %d , error string : %s", errno, strerror(errno));
                   exit(SEND_ERROR);
               }
           }
           else if (n == 0)
           {
               // 发送端不发送数据了
               LOG(INFO, "%s quit", clientAddr.c_str());
               break;
           }
           else
           {
               LOG(FATAL, "recv message error ,error code : %d , error string : %s", errno, strerror(errno));
               exit(RECV_ERROR);
           }
       }
       ::close(sockfd); // 服务结束，关闭文件描述符，避免文件描述符泄漏
   }

   static void *HandlerService(void *args)
   {
       pthread_detach(pthread_self()); // 分离线程
       ThreadData *td = static_cast<ThreadData *>(args);
       td->_self->Service(td->_sockfd, td->_addr);
       delete td;
       return nullptr;
   }

   void Start()
   {
       _isrunning = true;
       while (_isrunning)
       {
           // 监听
           int ret = ::listen(_listensock, gbacklog);
           if (ret < 0)
           {
               LOG(FATAL, "listen error, error code : %d , error string : %s", errno, strerror(errno));
               exit(LISTEN_ERROR);
           }
           LOG(INFO, "listen success!");

           struct sockaddr_in peer;
           socklen_t len = sizeof(peer);
           // 获取新连接
           int sockfd = accept(_listensock, CONV(&peer), &len); // 建立连接成功，创建新文件描述符进行通信
           if (sockfd < 0)
           {
               LOG(WARNING, "accept error, error code : %d , error string : %s", errno, strerror(errno));
               continue;
           }
           LOG(INFO, "accept success! new sockfd : %d", sockfd);

           InetAddr addr(peer); // 给后面提供传入的ip、port
           // 服务 -- 发送和接收数据
           // V0 -- 单进程
           // Service(sockfd, addr); // 这里是while死循环，没有运行完就一直运行，下一个请求来的时候得这个while退出才能执行

           // v1 -- 多进程
           // int id = fork();
           // if (id == 0)
           // {
           //     // 子进程
           //     ::close(_listensock); // 子进程对监听文件描述符不关心
           //     if (fork() > 0)
           //         exit(0);           // 子进程创建进程后退出，孙子进程被系统领养，不用等待
           //     Service(sockfd, addr); // 孙子进程执行任务
           //     exit(0);
           // }
           // else if (id > 0)
           // {
           //     ::close(sockfd); // 这里每次关闭的文件描述符都是4，使得每次accept创建的文件描述符都是4，这个4是留个各个子进程（子进程再给孙子进程）的（互不影响）
           //     // 父进程
           //     pid_t rid = waitpid(id, nullptr, 0); // 虽然是阻塞等待，但是子进程是刚创建就退出来了，让孙子进程（孤儿进程）执行任务，接下来继续监听和建立连接
           //     if (rid == id)
           //     {
           //         LOG(INFO, "wait child process success");
           //     }
           // }
           // else
           // {
           //     // 异常
           //     LOG(FATAL, "fork error ,error code : %d , error string : %s", errno, strerror(errno));
           //     exit(FORK_ERROR);
           // }

           // v2 -- 多线程
           // pthread_t tid;
           // ThreadData *td = new ThreadData(sockfd, addr, this); // 传指针
           // pthread_create(&tid, nullptr, HandlerService, td); // 这里创建线程后，线程去做执行任务，主线程继续向下执行 , 并且线程不能关闭sockf，线程和进程共享文件描述符表

           // v3 -- 线程池
           task_t t = std::bind(&TcpServer::Service, this, sockfd, addr);
           Threadpool<task_t>::GetInstance()->Enqueue(t);

           // v4 -- 进程池 -- 不推荐，需要传递文件描述符！
       }
       _isrunning = false;
   }

   ~TcpServer()
   {
       if (_listensock > defaultsockfd)
           ::close(_listensock); // 不用了关闭监听
   }

private:
   uint16_t _port;
   int _listensock;
   bool _isrunning;
};
  • Thread.hpp文件
#ifndef __THREAD_HPP__
#define __THREAD_HPP__

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

using namespace std;

// 封装Linux线程
namespace ThreadModule
{
   using func_t = function<void(string &)>;
   class Thread
   {
   public:
       // /* ThreadData* */Thread(func_t<T> func, T data, const string& name = "default name") : _func(func), _data(data), _threadname(name), _stop(true) {}
       Thread(func_t func, const string &name = "default name") : _func(func), _threadname(name), _stop(true) {}

       void Execute()
       {
           _func(_threadname);

           // _func(_data);
       }

       //  隐含this
       static void *threadroutine(void *arg)
       {
           Thread *self = static_cast<Thread *>(arg);
           self->Execute(); // static 访问不了成员变量
           return nullptr;
       }
       bool Start()
       {
           int n = pthread_create(&_tid, nullptr, threadroutine, this);
           if (!n)
           {
               _stop = false;
               return true;
           }
           else
           {
               return false;
           }
       }

       void Detach()
       {
           if (!_stop)
           {
               pthread_detach(_tid);
           }
       }

       void Join()
       {
           if (!_stop)
           {
               pthread_join(_tid, nullptr);
           }
       }

       string name()
       {
           return _threadname;
       }

       void Stop()
       {
           _stop = true;
       }
       // ~Thread() {}

   private:
       pthread_t _tid;
       string _threadname;
       func_t _func;
       bool _stop;
   };

} // namespace ThreadModule

#endif
  • Threadpool.hpp文件
#pragma once

#include <vector>
#include <queue>
#include <queue>
#include "Thread.hpp"
#include <pthread.h>
#include "LockGuard.hpp"

using namespace ThreadModule;

const int NUM = 3;

template <typename T>
class Threadpool
{
   void LockQueue(pthread_mutex_t &mutex)
   {
       pthread_mutex_lock(&mutex);
   }

   void UnLockQueue(pthread_mutex_t &mutex)
   {
       pthread_mutex_unlock(&mutex);
   }

   void SleepThread(pthread_cond_t &cond, pthread_mutex_t &mutex)
   {
       pthread_cond_wait(&cond, &mutex);
   }
   void WakeUpThread(pthread_cond_t &cond)
   {
       pthread_cond_signal(&cond);
   }
   void WakeUpAll(pthread_cond_t &cond)
   {
       pthread_cond_broadcast(&_cond);
   }
   Threadpool(const int threadnum = NUM) : _threadnum(threadnum), _waitnum(0), _isrunning(false)
   {
       pthread_mutex_init(&_mutex, nullptr);
       pthread_cond_init(&_cond, nullptr);
       LOG(INFO, "Threadpool Constructor successful ! ");
   }

   void TaskHandler(string &name)
   {
       // sleep(1);
       // cout  << name << " : hh " << endl;
       // sleep(1);
       LOG(DEBUG, "%s is running", name.c_str());
       while (true)
       {
           LockQueue(_mutex);
           while (_task_queue.empty() && _isrunning)
           {
               // 等待
               ++_waitnum;
               SleepThread(_cond, _mutex);
               --_waitnum;
           }
           // 此时一定大于一个线程没有休眠
           if (_task_queue.empty() && !_isrunning)
           {
               // 此时任务队列已经没有内容，且此时线程池已经停止
               UnLockQueue(_mutex);
               cout << name << " quit ... " << endl;
               break;
           }
           LOG(DEBUG, "%s get task sucessful !", name.c_str());
           //  其他情况就得处理任务
           T t = _task_queue.front();
           _task_queue.pop();
           UnLockQueue(_mutex);

           // 处理任务
           t();
           // cout << name << " : " << t.stringResult() << endl;
           // LOG(DEBUG, "%s handler task sucessful ! Result is %s", name.c_str(), t.stringResult().c_str());
           sleep(1);
       }
   }
   void InitThreadPool()
   {
       for (int i = 0; i < _threadnum; ++i)
       {
           string name = "Thread - " + to_string(i + 1);
           _threads.emplace_back(bind(&Threadpool::TaskHandler, this, placeholders::_1), name);
       }
       _isrunning = true;
       LOG(INFO, "Init Threadpool successful !");
   }

public:
   static Threadpool<T> *GetInstance(int threadnum = NUM)
   {

       if (_instance == nullptr)
       {
           LockGuard lockguard(&_lock);
           if (_instance == nullptr)
           {
               // pthread_mutex_lock(&_lock);
               // 第一次创建线程池
               _instance = new Threadpool<T>(threadnum);
               _instance->InitThreadPool();
               _instance->Start();
               LOG(DEBUG, "第一次创建线程池");
               // pthread_mutex_unlock(&_lock);
               return _instance;
           }
       }

       LOG(DEBUG, "获取线程池");
       return _instance;
   }

   bool Enqueue(const T &in)
   {
       bool ret = false;
       LockQueue(_mutex);
       if (_isrunning)
       {
           _task_queue.push(in);
           if (_waitnum > 0)
               WakeUpThread(_cond);
           LOG(DEBUG, "enqueue sucessful...");
           ret = true;
       }

       UnLockQueue(_mutex);
       return ret;
   }

   void Stop()
   {
       LockQueue(_mutex);
       _isrunning = false;
       if (_waitnum > 0)
           WakeUpAll(_cond);
       UnLockQueue(_mutex);
   }

   void Start()
   {
       for (auto &thread : _threads)
       {
           thread.Start();
           LOG(INFO, "%s is start sucessful...", thread.name().c_str());
       }
   }

   void Wait()
   {
       for (auto &thread : _threads)
       {
           thread.Join();
           LOG(INFO, "%s is quit...", thread.name().c_str());
       }
   }
   ~Threadpool()
   {
       pthread_mutex_destroy(&_mutex);
       pthread_cond_destroy(&_cond);
       LOG(INFO, "delete mutex sucessful !");
   }

private:
   vector<Thread> _threads;
   queue<T> _task_queue;
   int _threadnum;
   int _waitnum;

   pthread_mutex_t _mutex; // 互斥访问任务队列
   pthread_cond_t _cond;

   bool _isrunning;

   // 懒汉模式
   static Threadpool<T> *_instance;
   static pthread_mutex_t _lock;
};

template <typename T>
Threadpool<T> *Threadpool<T>::_instance = nullptr;
template <typename T>
pthread_mutex_t Threadpool<T>::_lock = PTHREAD_MUTEX_INITIALIZER;
  • 运行结果：

3.2、服务器执行命令行

  • Comm.hpp文件
#pragma once
#include "InetAddr.hpp"

enum errorcode
{
   CREATE_ERROR = 1,
   BIND_ERROR,
   LISTEN_ERROR,
   SEND_ERROR,
   RECV_ERROR,
   CONNECT_ERROR,
   FORK_ERROR,
   USAGE_ERROR
};

#define CONV(ADDR) ((struct sockaddr *)ADDR)

std::string CombineIpAndPort(InetAddr addr)
{
   return "[" + addr.Ip() + ":" + std::to_string(addr.Port()) + "] ";
}
  • CommandExecute.hpp文件
#pragma once

#include <stdio.h>
#include <string>
#include <vector>

bool CheckCommand(std::string command)
{
   std::vector<std::string> cmd = {
       "kill",
       "rm",
       "dd",
       "top",
       "reboot",
       "shutdown",
       "mv",
       "cp",
       "halt",
       "unlink",
       "exit",
       "chmod"};
   for (auto &e : cmd)
   {
       if (command.find(e) != std::string::npos)
           return false;
   }

   return true;
}

std::string OnCommand(std::string command)
{
   if (!CheckCommand(command))
   {
       return "bad man!";
   }
   // FILE *popen(const char *command, const char *type);
   FILE *pp = popen(command.c_str(), "r");
   if (!pp)
   {
       return "popen error!";
   }

   std::string response;
   char buff[1024];
   while (true)
   {
       // char *fgets(char *s, int size, FILE *stream);
       char *s = fgets(buff, sizeof(buff), pp);
       if (!s)
           break;
       else
           response += buff;
   }
   pclose(pp);
   return response.empty() ? "not command" : response;
}
  • InetAddr.hpp文件
#pragma once

#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>

class InetAddr
{
   void GetAddress(std::string *ip, uint16_t *port)
   {
       // char *inet_ntoa(struct in_addr in);
       *ip = inet_ntoa(_addr.sin_addr);
       *port = ntohs(_addr.sin_port);
   }

public:
   InetAddr(const struct sockaddr_in &addr) : _addr(addr)
   {
       GetAddress(&_ip, &_port);
   }

   std::string Ip()
   {
       return _ip;
   }

   uint16_t Port()
   {
       return _port;
   }
   bool operator==(InetAddr &addr)
   {
       return _ip == addr.Ip() && _port == addr.Port();
   }

   const struct sockaddr_in& GetAddr()
   {
       return _addr;
   }

   ~InetAddr() {}

private:
   struct sockaddr_in _addr;
   std::string _ip;
   uint16_t _port;
};
  • LockGuard.hpp文件
# pragma once

#include <pthread.h>


class LockGuard
{
public:
   LockGuard(pthread_mutex_t *mutex) : _mutex(mutex)
   {
       pthread_mutex_lock(_mutex); // 构造加锁
   }
   ~LockGuard()
   {
       pthread_mutex_unlock(_mutex); // 析构解锁
   }

private:
   pthread_mutex_t *_mutex;
};
  • Log.hpp文件
#pragma once

#include <string>
#include <iostream>
#include <fstream>
#include <unistd.h>
#include <stdarg.h>
#include <sys/types.h>
#include "LockGuard.hpp"

using namespace std;

bool isSave = false; // 默认向显示器打印
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
#define FILEPATH "./log.txt"

enum level
{
   DEBUG = 0,
   INFO,
   WARNING,
   ERROR,
   FATAL
};

void SaveToFile(const string &message)
{
   ofstream out(FILEPATH, ios_base::app);
   if (!out.is_open())
       return;
   out << message;
   out.close();
}

std::string LevelToString(int level)
{
   switch (level)
   {
   case DEBUG:
       return "Debug";
   case INFO:
       return "Info";
   case WARNING:
       return "Warning";
   case ERROR:
       return "Error";
   case FATAL:
       return "Fatal";
   default:
       return "Unknow";
   }
}

std::string GetTimeString()
{
   time_t curr_time = time(nullptr);
   struct tm *format_time = localtime(&curr_time);
   if (format_time == nullptr)
       return "None";
   char buff[1024];
   snprintf(buff, sizeof(buff), "%d-%d-%d %d:%d:%d",
            format_time->tm_year + 1900,
            format_time->tm_mon + 1,
            format_time->tm_mday,
            format_time->tm_hour,
            format_time->tm_min,
            format_time->tm_sec);
   return buff;
}

void LogMessage(const std::string filename, int line, bool issave, int level, const char *format, ...)
{
   std::string levelstr = LevelToString(level);
   std::string timestr = GetTimeString();
   pid_t pid = getpid();

   char buff[1024];
   va_list arg;
   // int vsnprintf(char *str, size_t size, const char *format, va_list ap); // 使用可变参数
   va_start(arg, format);
   vsnprintf(buff, sizeof(buff), format, arg);
   va_end(arg);

   LockGuard lock(&mutex);
   std::string message = "[" + timestr + "]" + "[" + levelstr + "]" + "[pid:" + std::to_string(pid) + "]" + "[" + filename + "]" + "[" + std::to_string(line) + "] " + buff + '\n';
   if (issave == false)
       std::cout << message;
   else
       SaveToFile(message);
}

// 固定文件名和行数
#define LOG(level, format, ...)                                               \
   do                                                                        \
   {                                                                         \
       LogMessage(__FILE__, __LINE__, isSave, level, format, ##__VA_ARGS__); \
   } while (0)

#define EnableScreen()  \
   do                  \
   {                   \
       isSave = false; \
   } while (0)

#define EnableFile()   \
   do                 \
   {                  \
       isSave = true; \
   } while (0)

void Test(int num, ...)
{
   va_list arg;
   va_start(arg, num);
   while (num--)
   {
       int data = va_arg(arg, int);
       std::cout << data << " ";
   }
   std::cout << std::endl;
   va_end(arg);
}
  • Main.cc文件
#include <iostream>
#include <memory>

#include "TcpServer.hpp"
#include "CommandExecute.hpp"

void Usage()
{
   // printf("./udp_server serverip serverport\n");
   printf("Usage : ./udp_server serverport\n"); // ip 已经设置为0
}

int main(int argc, char *argv[])
{
   // if (argc != 3)
   if (argc != 2)
   {
       Usage();
       exit(USAGE_ERROR);
   }

   uint16_t serverport = std::stoi(argv[1]);
   std::unique_ptr<TcpServer> tsvr = std::make_unique<TcpServer>(serverport, OnCommand);
   tsvr->InitServer();
   tsvr->Start();

   return 0;
}
  • Makefile文件
.PHONY:all
all:tcp_client tcp_server

tcp_client:TcpClient.cc
	g++ -o $@ $^ -std=c++14 -lpthread
tcp_server:Main.cc
	g++ -o $@ $^ -std=c++14 -lpthread

.PHONY:clean
clean:
	rm -f tcp_server tcp_client
  • TcpClient.cc文件
#include <iostream>

#include <strings.h>
#include <string.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "Comm.hpp"
#include "Log.hpp"

void Usage()
{
   printf("Usage : ./udp_client serverip serverport\n");
}
int main(int argc, char *argv[])
{
   if (argc != 3)
   {
       Usage();
       exit(USAGE_ERROR);
   }
   std::string serverip = argv[1];
   uint16_t serverport = std::stoi(argv[2]);

   int sockfd = socket(AF_INET, SOCK_STREAM, 0);
   if (sockfd < 0)
   {
       LOG(FATAL, "create sockfd error, error code : %d, error string : %s", errno, strerror(errno));
       exit(CREATE_ERROR);
   }
   LOG(INFO, "create sockfd success");

   struct sockaddr_in local;
   bzero(&local, sizeof(local));
   local.sin_family = AF_INET;
   local.sin_port = htons(serverport);
   local.sin_addr.s_addr = inet_addr(serverip.c_str());

   // 发起连接
   int n = ::connect(sockfd, CONV(&local), sizeof(local));
   if (n < 0)
   {
       LOG(WARNING, "create connect error, error code : %d, error string : %s", errno, strerror(errno));
       exit(CONNECT_ERROR);
   }
   LOG(INFO, "create connect success");

   // 发收数据
   while (true)
   {
       std::cout << "Please Enter# ";
       // 发送数据
       std::string message;
       std::getline(cin, message);

       int ret = ::send(sockfd, message.c_str(), message.size(), 0);
       if (ret < 0)
       {
           LOG(FATAL, "send message error, error code : %d, error string : %s", errno, strerror(errno));
           exit(SEND_ERROR);
       }

       char buff[1024];
       // 接收数据
       int m = ::recv(sockfd, buff, sizeof(buff) - 1, 0);
       if (m > 0)
       {
           buff[m] = 0;
           std::cout << "Server Echo$ " << buff << std::endl;
       }
   }
}
  • TcpServer.hpp文件
#pragma once

#include <sys/types.h> /* See NOTES */
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include <error.h>
#include <string.h>
#include <pthread.h>
#include <functional>

#include "Log.hpp"
#include "InetAddr.hpp"
#include "Comm.hpp"


const int defaultsockfd = -1;
int gbacklog = 16; // 暂时先用

using callback_t = std::function<std::string(std::string)>;

// 声明
class TcpServer;

class ThreadData
{
public:
   ThreadData(int sockfd, InetAddr addr, TcpServer *self)
       : _sockfd(sockfd), _addr(addr), _self(self) {}
   ~ThreadData() = default;

public:
   int _sockfd;
   InetAddr _addr;
   TcpServer *_self;
};

class TcpServer
{
public:
   TcpServer(uint16_t port, callback_t cb) : _port(port), _listensock(defaultsockfd), _isrunning(false), _cb(cb)
   {
   }

   void InitServer()
   {
       // 创建
       _listensock = socket(AF_INET, SOCK_STREAM, 0); // 这个就是文件描述符
       if (_listensock < 0)
       {
           LOG(FATAL, "create sockfd error, error code : %d, error string : %s", errno, strerror(errno));
           exit(CREATE_ERROR);
       }
       LOG(INFO, "create sockfd success");

       struct sockaddr_in local;
       bzero(&local, sizeof(local));
       local.sin_family = AF_INET;
       local.sin_port = htons(_port);
       local.sin_addr.s_addr = INADDR_ANY;
       // 绑定
       int n = ::bind(_listensock, CONV(&local), sizeof(local));
       if (n < 0)
       {
           LOG(FATAL, "bind sockfd error, error code : %d, error string : %s", errno, strerror(errno));
           exit(BIND_ERROR);
       }
       LOG(INFO, "bind sockfd success");
   }

   void Service(int sockfd, InetAddr client)
   {
       while (true)
       {
           // TCP是字节流（可以使用write和read接口），UDP是数据报
           char buff[1024];
           // 接收消息
           int n = ::read(sockfd, buff, sizeof(buff)); // bug，接收数据可能收到的不完整，比如1+100，可能先收到1+1，再收到00 -- 按序到达
           std::string clientAddr = CombineIpAndPort(client);

           if (n > 0)
           {
               buff[n] = 0;
               std::string message = clientAddr + buff;
               LOG(INFO, "get message : \n %s", message.c_str());

               // 发送消息
               std::string response = _cb(buff); // 回调
               int m = ::write(sockfd, response.c_str(), response.size());
               if (m < 0)
               {
                   LOG(FATAL, "send message error ,error code : %d , error string : %s", errno, strerror(errno));
                   exit(SEND_ERROR);
               }
           }
           else if (n == 0)
           {
               // 发送端不发送数据了
               LOG(INFO, "%s quit", clientAddr.c_str());
               break;
           }
           else
           {
               LOG(FATAL, "recv message error ,error code : %d , error string : %s", errno, strerror(errno));
               exit(RECV_ERROR);
           }
       }
       ::close(sockfd); // 服务结束，关闭文件描述符，避免文件描述符泄漏
   }

   static void *HandlerService(void *args)
   {
       pthread_detach(pthread_self()); // 分离线程
       ThreadData *td = static_cast<ThreadData *>(args);
       td->_self->Service(td->_sockfd, td->_addr);
       delete td;
       return nullptr;
   }

   void Start()
   {
       _isrunning = true;
       while (_isrunning)
       {
           // 监听
           int ret = ::listen(_listensock, gbacklog);
           if (ret < 0)
           {
               LOG(FATAL, "listen error, error code : %d , error string : %s", errno, strerror(errno));
               exit(LISTEN_ERROR);
           }
           LOG(INFO, "listen success!");

           struct sockaddr_in peer;
           socklen_t len = sizeof(peer);
           // 获取新连接
           int sockfd = accept(_listensock, CONV(&peer), &len); // 建立连接成功，创建新文件描述符进行通信
           if (sockfd < 0)
           {
               LOG(WARNING, "accept error, error code : %d , error string : %s", errno, strerror(errno));
               continue;
           }
           LOG(INFO, "accept success! new sockfd : %d", sockfd);

           InetAddr addr(peer); // 给后面提供传入的ip、port
           // 服务 -- 发送和接收数据

           // v2 -- 多线程
           pthread_t tid;
           ThreadData *td = new ThreadData(sockfd, addr, this); // 传指针
           pthread_create(&tid, nullptr, HandlerService, td);   // 这里创建线程后，线程去做执行任务，主线程继续向下执行 , 并且线程不能关闭sockf，线程和进程共享文件描述符表
       }
       _isrunning = false;
   }

   ~TcpServer()
   {
       if (_listensock > defaultsockfd)
           ::close(_listensock); // 不用了关闭监听
   }

private:
   uint16_t _port;
   int _listensock;
   bool _isrunning;

   callback_t _cb;
};
  • 运行结果：

4、TCP客户端connect断线重连

这里是服务器响应程序的断线重连的实现细节：TCP客户端connect断线重连

5、应用层自定义协议以及序列化和反序列化

这里是应用层自定义协议以及序列化和反序列化的实现细节：应用层自定义协议以及序列化和反序列化

里面还包含复杂的TCP网络程序：服务器网络计算器

OKOK，Linux网络编程之TCP就到这里，如果你对Linux和C++也感兴趣的话，可以看看我的主页哦。下面是我的github主页，里面记录了我的学习代码和leetcode的一些题的题解，有兴趣的可以看看。

Xpccccc的github主页

Xpccccc
关注
  • 13
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Linux网络编程之TCP/IP通信基础以及例程分享
qq_58288010的博客
12-19 1244
TCP/IP网络协议栈分为应用层（Application）、传输层（Transport）、网络层（Network）和链路层（Link）四层。应用层（Application Layer）：应用层是最靠近用户的一层，它提供了用户与网络之间的接口。在应用层，应用程序可以通过使用各种协议（如HTTP、FTP、SMTP等）来进行通信。应用层的主要任务是处理应用程序之间的通信和数据交换。传输层（Transport Layer）：传输层负责在网络中的两个主机之间提供可靠的端到端数据传输。
LINUX 网络编程(TCP)
11-20
LINUX 网络编程(TCP)
Linux网络编程之TCP编程
qq_54402650的博客
09-17 2373
socket网络编程 ;TCP提供面向连接的，一对一的可靠传输的协议;UDP提供不可靠，无连接的传输协议,实现TCP多进程和多线程的并发服务器，冲冲冲！
linux网络编程之tcp
m0_57678852的博客
12-04 626
相关函数 参数： domain： AF_INET AF_INET6 AF_UNIX,AF_LOCAL AF_NETLINK AF_PACKET type： SOCK_STREAM: 流式套接字，唯一对应于TCP SOCK_DGRAM:数据报套接字，唯一对应着UDP SOCK_RAW:原始套接字 protocol： 一般填0，原始套接字编程时需填充 返回值 成功返回文件描述符 出错返回-1 如果是IPV6编程，要使用struct sockddr_in6结构体（man 7 IPV6）,通常使用struct so
Linux网络编程——TCP编程
weixin_52109967的博客
08-10 1097
TCP编程的主要函数
Linux网络编程 | TCP详解
大柳_的博客。
06-01 3362
总结TCP相关问题TCP是一种面向链接的，可靠的，流式服务。TCP 字节流的特点，发送端执行的写操作次数和接收端执行的读操作次数之间没有任何数量关系，应用程序对数据的发送和接收是没有边界限制的。 此时可以看到 此时可以看到，发送端分别发送了hello world linux，而在接收端一次性收取完成，无法有效区分出三个单词，这就造成粘包问题 解决方法： 1.发送端每次发送之后要收到接收端的回复再进行下一次发送 2.制定协议，比如长宽高分别用【长】【宽】【高】表示。可靠性： 超时重传，应答确认，乱序重排流量控
Linux网络编程系列之TCP协议编程
AABond的博客
10-06 1103
Linux网络编程系列之TCP，TCP的简单介绍和使用
linux网络编程之TCP接口详解
topgunliu的专栏
06-26 3804
对于linux网络编程基于TCP的API做了详细的描述
linux系统下的TCP网络编程
qq_44971750的博客
10-03 1290
linux系统下面的tcp网络编程学习记录
Linux网络编程：TCP通信
weixin_44788175的博客
04-28 1358
一、TCP流程图 二、TCP通信流程1、服务器端 2、客户端 三、套接字函数1、头文件2、socket 函数3、bind 函数4、listen函数5、accept函数6、connect函数7、write 和 read 函数
linux网络基础和网络编程
09-17
Linux网络基础和网络编程是IT领域中的重要组成部分，特别是在服务器端开发中不可或缺。本文将深入探讨这个主题，从Linux网络的基础知识开始，逐步讲解到Socket编程以及如何实现高并发服务器。 1. Linux网络基础： ...
linux网络编程之TCP和UDP_PDF版
10-31
全文总共就只12页，是他人学习的个人总结，转载至此。
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
Linux-网络编程之TCP.doc
07-19
编程
MarkTool之TCP服务端
最新发布
Qt学视觉
07-24 113
MarkTool之TCP服务端
【ROS2】演示:为有损网络使用服务质量设置
cxyhjl的博客
07-22 708
目录背景先决条件运行演示命令行选项添加网络流量背景请阅读有关 QoS 设置的文档页面，以获取有关 ROS 2 中可用支持的背景信息。在这个演示中，我们将生成一个发布相机图像的节点和另一个订阅图像并在屏幕上显示图像的节点。然后，我们将模拟它们之间的丢包网络连接，并展示不同的服务质量设置如何处理不良链接。先决条件本教程假设您已安装并运行 ROS 2 和 OpenCV。有关安装说明，请...
网络编程套接字socket
安权_code的博客
07-23 539
网络编程中的套接字（socket）是实现网络通信的关键，换句话来说，套接字像两个端点，而发送方与接收方就是通过这两个端点进行通信的，socket的意思是插座，表示插头和插座连接上后，即发送方和接收方连接上了，然后把电流通过插座流向插头对标发送方与接收方建立了链接。
DNS域名管理系统、搭建DNS服务
十四的博客
07-23 756
DNS概述。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Xpccccc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值