Socket通信(C++)

已于 2024-07-29 11:28:20 修改
阅读量1.2k 收藏 20
点赞数 25
分类专栏： Default 计算机网络 文章标签： c++ 开发语言 Socket
于 2024-07-29 11:25:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42482078/article/details/140766885
版权

文章目录

什么是Socket

Socket是用于计算机之间进行网络通信的端口的抽象。提供了应用进程利用底层网络协议交换数据的机制。

通过TCP/IP协议栈进行网络通信的过程中，每个设备都需要唯一的IP地址信息进行标识，Socket允许应用程序通过IP地址进行通信，而不需要关心底层TCP/IP协议的具体实现，在这个过程中，可以将Socket理解为对TCP/IP的进一步封装。

同时，Socket也可以在本地进程之间通信，Socket允许应用绑定本地Socket文件，通过Socket文件进行进程之间数据的交换。

Socket通信过程

Socket通信

  • 服务端：
    1. 创建Socket
    2. 绑定Socket: Socket支持绑定本地Socket或者IP端口
    3. 服务端开始监听客户端连接请求，当监听到连接请求后，调用accept()接收连接请求，建立服务端客户端连接
    4. 服务端客户端开始通信
      • send(): 通过send接口发送数据
      • receive(): 通过receive接口接收数据
    5. 服务端客户端处理通信异常信息
    6. 服务端主动关闭连接，或监听到客户端异常断开后，关闭连接
  • 客户端：
    1. 创建Socket
    2. 请求连接服务端Socket
    3. 服务端客户端开始通信
      • send(): 通过send接口发送数据
      • receive(): 通过receive接口接收数据
    4. 服务端客户端处理通信异常信息
    5. 客户端主动关闭连接，或监听到服务端异常断开后，关闭连接

C++ Socket通信API

C++在进行Socket通信时，通常有以下常用接口：

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

以下参数信息为常用参数信息，更多内容参考man socket

  • int socket(int domain, int type, int protocol)：用于创建Socket
  • 头文件：
    • #include <sys/types.h>
    • #include <sys/socket.h>
  • 参数：
    • domain：网络连接协议簇的标识
      • AF_INET：IPv4协议簇
      • AF_INET6：IPv6协议簇
      • AF_UNIX/AF_LOCAL：本地Socket
    • type：Socket通信的语义类型
      • SOCK_STREAM：提供有序、可靠、双向、基于连接的字节流。可以支持带外数据传输机制（TCP通信常用）
      • SOCK_DGRAM：支持数据报（固定最大长度的无连接、不可靠的消息）（UDP通信常用）。
    • protocol：与Socket通信语义相匹配的协议类型，注意，protocol的选择需要和语义类型匹配，不可以随意组合
      • 0：根据type自动匹配protocol
      • IPPROTO_TCP：TCP协议
      • IPPROTO_UDP：UDP协议
  • 返回值：
    • 成功：返回Socket文件描述符ID
    • 失败：返回-1，并设置errno

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

  • int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)：socket()创建socket指定其协议类型后，我们还需要把socket绑定到具体的地址上才可以使用
  • 头文件：
    • #include <sys/types.h>
    • #include <sys/socket.h>
  • 参数：
    • sockfd：上述通过socket()函数创建的socketID信息
    • addr：socket绑定的协议地址，该参数需要与socket创建时指定的协议类型相关联
    • addrlen：addr结构的字节大小
  • 返回值：
    • 成功：返回0
    • 失败：返回-1，并设置errno

struct sockaddr

#include <sys/types.h>
#include <sys/socket.h>

struct sockaddr {
    sa_family_t sa_family;      // socket addr family
    char        sa_data[14];    // socket addr data
}

在sockaddr结构体中，数据信息混合在了一起，针对TCP/UDP这种包含IP和Port等多个数据的类型时，不是很好区分，所以一般情况下通过定义对应协议的addr信息，然后通过类型转换为soctaddr结构体

struct sockaddr_un

#include <sys/socket.h>
#include <sys/un.h>

struct sockaddr_un {
    sa_family_t sun_family;     // AF_UNIX
    char        sun_path[108];  // 本地Socket路径
};

struct sockaddr_in / struct sockaddr_in6

#include <netinet/in.h>

struct sockaddr_in {
    sa_family_t     sin_family;     // AF_INET
    in_port_t       sin_port;       // Port: 端口号
    struct in_addr  sin_addr;       // IPv4地址信息
};

struct sockaddr_in6 {
    sa_family_t     sin6_family;    // AF_INET6
    in_port_t       sin6_port;      // Port: 端口号
    uint32_t        sin6_flowinfo;  // IPv6流标识符，用于标识特定的数据流，在发送数据时附加到数据包头部
    struct in6_addr sin6_addr;      // IPv6地址信息
    uint32_t        sin6_scope_id;  // Scope Id：用于确定IPv6地址的使用范围和权限
};

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

  • int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)：客户端向服务端发送连接请求，等待连接
  • 头文件：
    • #include <sys/types.h>
    • #include <sys/socket.h>
  • 参数：
    • sockfd：上述通过socket()函数创建的socketID信息，该sockfd为客户端向服务端发起请求的socket
    • addr：socket绑定的协议地址，该参数需要与socket创建时指定的协议类型相关联
    • addrlen：addr结构的字节大小
  • 返回值：
    • 成功：返回0
    • 失败：返回-1，并设置errno

int listen(int sockfd, int backlog);

  • int listen(int sockfd, int backlog)：设置socket队列，监听socket请求，以处理客户端的连接、断开操作
  • 头文件：
    • #include <sys/types.h>
    • #include <sys/socket.h>
  • 参数：
    • sockfd：上述通过socket()函数创建的socketID信息
    • backlog: socket监听可能的最大连接长度，若队列已满，新的客户端连接请求会收到ECONNREFUSED错误
  • 返回值：
    • 成功：返回0
    • 失败：返回-1，并设置errno

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

  • int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)：监听sockfd队列的第一个连接请求，创建连接socket，并返回引用该socket的文件描述符
  • 头文件：
    • #include <sys/types.h>
    • #include <sys/socket.h>
  • 参数：
    • sockfd：上述通过socket()函数创建的socketID信息，该sockfd为客户端向服务端发起请求的socket
    • addr：socket绑定的协议地址，该参数需要与socket创建时指定的协议类型相关联
    • addrlen：addr结构的字节大小
  • 返回值：
    • 成功：返回socket文件描述符ID
    • 失败：返回-1，并设置errno

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

socket 数据的常用发送接收还有read(),write()和其他方法。

read()和write()方法在遇到\0类型数据时会终止，所以通过该方法发送数据是受限的，这里不做介绍

  • ssize_t send(int sockfd, const void *buf, size_t len, int flags)：发送指定长度的数据
  • 头文件：
    • #include <sys/types.h>
    • #include <sys/socket.h>
  • 参数：
    • sockfd：客户端和服务端已建立的socketID文件描述符信息
    • buf：需要发送的数据内容
    • len: buffer数据长度
    • flags: 消息发送或运算的特性，默认可为0
  • 返回值：
    • 成功：成功发送数据的字节数
    • 失败：返回-1，并设置errno

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

  • ssize_t recv(int sockfd, void *buf, size_t len, int flags)：接收指定长度的数据
  • 头文件：
    • #include <sys/types.h>
    • #include <sys/socket.h>
  • 参数：
    • sockfd：客户端和服务端已建立的socketID文件描述符信息
    • buf：接收数据的地址
    • len: buffer数据长度
    • flags: 消息接收或运算的特性，默认可为0
  • 返回值：
    • 成功：成功发送数据的字节数
    • 失败：返回-1，并设置errno

int close(int fd);

  • int close(int fd)：关闭socket连接
  • 头文件：
    • #include <unistd.h>
  • 参数：
    • fd：已连接的文件描述符ID
  • 返回值：
    • 成功：0
    • 失败：返回-1，并设置errno

C++ Socket通信

若要使用IPv4-TCP通信，请注释UNIX，取消注释IPv4

本示例不对IPv6通信进行说明

服务端

// socket
#include <sys/types.h>
#include <sys/socket.h>

// socket addr
#include <sys/un.h>
#include <netinet/in.h>

// file close
#include <unistd.h>

// htons
#include <arpa/inet.h>

#include <iostream>


int main() {
    // 1. 创建服务端Socket
    // IPv4
    // int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    // UNIX
    int server_socket = socket(AF_UNIX, SOCK_STREAM, 0);

    if (server_socket < 0) {
        std::cerr << "socket error: 创建失败" << std::endl;
        throw std::runtime_error("socket error: 创建失败");
    } else {
        std::cout << "socket 创建成功，socketId：" << server_socket << std::endl;
    }

    // 2. 绑定Socket
    // IPv4
    // struct sockaddr_in server_addr;
    // server_addr.sin_family = AF_INET;
    // // INADDR_ANY: 0.0.0.0(绑定到本机的所有网卡上)
    // server_addr.sin_addr.s_addr = INADDR_ANY;
    // // htons: 将 unsigned short 转换为网络字节序
    // server_addr.sin_port = htons(8888);

    // UNIX
    struct sockaddr_un server_addr;
    server_addr.sun_family = AF_UNIX;
    strcpy(server_addr.sun_path, "/var/tmp/socket_test");

    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "socket bind error: 绑定套接字失败，请检查本地套接字是否被占用" << std::endl;
        throw std::runtime_error("socket bind error: 绑定套接字失败，请检查本地套接字是否被占用");
    }

    // 3. 创建socket监听队列，并开始监听
    int listen_ret = listen(server_socket, 2048);
    if (listen_ret < 0) {
        std::cerr << "socket listen error: Socket监听失败" << std::endl;
        throw std::runtime_error("socket listen error: Socket监听失败");
    } 

    // 4. 接收客户端连接请求
    // IPv4
    // struct sockaddr_in client_addr;
    // UNIX
    struct sockaddr_un client_addr;
    
    int client_addr_len = sizeof(client_addr);
    int client_socket = accept(server_socket, (struct sockaddr*)&client_addr, (socklen_t *) &client_addr_len);
    if (client_socket < 0) {
        std::cerr << "socket client accpet error: Socket监听失败" << std::endl;
        throw std::runtime_error("socket listen error: Socket监听失败");
    }

    // 5. 接收客户端发送信息
    int recv_data_length = 15;
    char recv_data[recv_data_length];
    if (recv(client_socket, recv_data, recv_data_length, 0) < 0) {
        std::cerr << "socket recv error: 接收数据失败" << std::endl;
        throw std::runtime_error("socket recv error: 接收数据失败");
    } else {
        std::cout << "socket recv data: " << recv_data << std::endl;
    }

    // 6. 关闭socket
    close(server_socket);
    close(client_socket);

    return 0;
}

客户端

// socket
#include <sys/types.h>
#include <sys/socket.h>

// socket addr
#include <sys/un.h>
#include <netinet/in.h>

// file close
#include <unistd.h>

// htons
#include <arpa/inet.h>

#include <iostream>
#include <string.h>


int main() {
    // 1. 创建客户端Socket
    // IPv4
    // int client_socket = socket(AF_INET, SOCK_STREAM, 0);
    // UNIX
    int client_socket = socket(AF_UNIX, SOCK_STREAM, 0);

    if (client_socket < 0) {
        std::cerr << "socket error: 创建失败" << std::endl;
        throw std::runtime_error("socket error: 创建失败");
    } else {
        std::cout << "socket 创建成功，socketId：" << client_socket << std::endl;
    }

    // 2. 绑定Socket
    // IPv4
    // struct sockaddr_in client_addr;
    // client_addr.sin_family = AF_INET;
    // // INADDR_ANY: 0.0.0.0(绑定到本机的所有网卡上)
    // client_addr.sin_addr.s_addr = INADDR_ANY;
    // // htons: 将 unsigned short 转换为网络字节序
    // client_addr.sin_port = htons(8888);

    // UNIX
    struct sockaddr_un client_addr;
    client_addr.sun_family = AF_UNIX;
    strcpy(client_addr.sun_path, "/var/tmp/socket_test");

    if (connect(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0) {
        std::cerr << "socket connect error: 连接服务端socket失败" << std::endl;
        throw std::runtime_error("socket connect error: 连接服务端socket失败");
    }

    // 3. 客户端发送信息
    std::string send_data = "Hello, Focus!!!";
    if (send(client_socket, send_data.c_str(), send_data.length(), 0) < 0) {
        std::cerr << "socket send error: 发送数据失败" << std::endl;
        throw std::runtime_error("socket send error: 发送数据失败");
    } 

    // 4. 关闭socket
    close(client_socket);

    return 0;
}

C++ Socket通信改进

以上代码可以实现简单的Socket通信流程，但是存在问题：

  • 服务端在第一次启动时，会创建本地Socket套接字文件，在以IP协议进行通信的Socket网络通信中，Socket关闭会释放端口，但是以UNIX本地Socket进行通信的Socket网络通信在关闭后，不会主动删除创建的Socket文件。在再次通信的过程中，会绑定失败
    • 解决方案：在程序第一次绑定时，判断文件是否存在，存在则删除
  • 在Socket通信过程中，send,recv,accept,connect等函数为阻塞函数，所以一旦调用此类方法，程序阻塞，就不能接收其他连接和处理了
    • 解决方案1：采用非阻塞模型进行Socket通信
    • 解决方案2：采用线程的方式，当新的socket连接建立后，将socket通信的过程放在线程中执行，线程结束释放该socket通信，这样可以通过accept方法以阻塞的方式一直等待新的客户端连接
    • 这里采用方案2进行改进
  • Socket通信过程中，采用send，recv方法虽然解决了write，read方法不能发送\0的问题，但是存在的问题是，通过send，recv传输数据需要已知数据大小，在数据大小确定的情况下，该方案很符合场景需要，但是在数据大小不确定的情况下。
    • 解决方案1: 确定"大"数据长度，数据长度不足后面补标志位、
    • 解决方案2：在传输数据前，先发送数据大小，然后初始化buffer接收数据
    • 这里采用方案2进行改进

在以下改进中，统一采用UNIX模型进行通信，IP模型请自行替换

UNIX socket文件已存在

#include <unistd.h>

#include <iostream>
#include <string.h>


void make_sure_socket_path(char *socket_path) {
    // F_OK：判断文件是否可读，若文件不存在则不可读
    if (access(socket_path, F_OK) == 0) {
        // unlink：删除文件
        if (unlink(socket_path) < 0) {
            std::cerr << "删除 socket：" << socket_path << " 失败" << std::endl;
            throw std::runtime_error("socket error: 创建失败");
        }
    }
}

子线程通信

头文件：

// socket
#include <sys/types.h>
#include <sys/socket.h>

// socket addr
#include <sys/un.h>
#include <netinet/in.h>

#include <pthread.h>

#include <unistd.h>

// htons
#include <arpa/inet.h>

#include <iostream>

class UnixSocketServer {
    private:
        std::string socket_path;

        // 记录服务端socket配置
        int socket_id;

        // 客户端最大连接数
        int max_client = 5;

        static void *thread_working(void *args);

    public:
        UnixSocketServer(std::string socket_path);

        ~UnixSocketServer();

        void run();
};

#include "socket.h"

UnixSocketServer::UnixSocketServer(std::string socket_path) {
    this->socket_path = socket_path;

    if (access(this->socket_path.c_str(), F_OK) == 0) {
        // unlink：删除文件
        if (unlink(this->socket_path.c_str()) < 0) {
            std::cerr << "删除 socket：" << this->socket_path << " 失败" << std::endl;
            throw std::runtime_error("socket error: 创建失败");
        }
    }

    // 1. 创建服务端socket
    this->socket_id = socket(AF_UNIX, SOCK_STREAM, 0);
    if (this->socket_id < 0) {
        std::cerr << "socket error: 创建失败" << std::endl;
        throw std::runtime_error("socket error: 创建失败");
    } else {
        std::cout << "socket 创建成功，socketId：" << this->socket_id << std::endl;
    }
    
    // 2. 绑定Socket
    struct sockaddr_un server_addr;
    server_addr.sun_family = AF_UNIX;
    strcpy(server_addr.sun_path, this->socket_path.c_str());

    if (bind(this->socket_id, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "socket bind error: 绑定套接字失败，请检查本地套接字是否被占用" << std::endl;
        throw std::runtime_error("socket bind error: 绑定套接字失败，请检查本地套接字是否被占用");
    }

    // 3. 创建socket监听队列，并开始监听
    int listen_ret = listen(this->socket_id, this->max_client);
    if (listen_ret < 0) {
        std::cerr << "socket listen error: Socket监听失败" << std::endl;
        throw std::runtime_error("socket listen error: Socket监听失败");
    } 
}

UnixSocketServer::~UnixSocketServer() {
    close(this->socket_id);
    unlink(this->socket_path.c_str());
}

void *UnixSocketServer::thread_working(void *args) {
   
}

void UnixSocketServer::run() {
    while(true) {

        struct sockaddr_un client_addr;
    
        int client_addr_len = sizeof(client_addr);
        int client_id = accept(this->socket_id, (struct sockaddr*)&client_addr, (socklen_t *) &client_addr_len);
        if (client_id < 0) {
            std::cerr << "socket client accpet error: Socket监听失败" << std::endl;
            throw std::runtime_error("socket listen error: Socket监听失败");
        } else {
            std::cout << "socket client accpet success: 客户端：" << client_id << "连接成功" << std::endl;
        }

        pthread_t thread_id = client_id;
        pthread_create(&thread_id, NULL, this->thread_working, (void *) &client_id);
        pthread_detach(thread_id);
    }
}

int main() {
    UnixSocketServer *unixSocketServer = new UnixSocketServer("/var/tmp/socket_test");

    unixSocketServer->run();

    return 0;
}

Socket通信流程改进

服务端

核心代码
void *UnixSocketServer::thread_working(void *args) {
    int client_id = *(int *) args;

    while (true) {
        // 1. 接收数据长度
        // 注意这里不能采用 size_t 等类型定义，该类型会导致在不同架构编译器生成的 sizeof 大小不一致
        int receive_data_length;
        
        if (recv(client_id, &receive_data_length, sizeof(receive_data_length), 0) <= 0) {
            std::cerr << "socket communication error: 接收客户端数据长度失败" << std::endl;
            break;
        } else {
            std::cout << "socket communication success: 客户端原始数据长度：" << receive_data_length << std::endl;
        }

        // 2. 接收数据
        char receive_data[receive_data_length];
        if (recv(client_id, &receive_data, receive_data_length, 0) <= 0) {
            std::cerr << "socket communication error: 接收客户端数据失败" << std::endl;
            break;
        } else { 
            // 这里通过 std::string 构造函数初始化接收数据
            // 接收数据长度没有 `\0`，C/C++在输出 char 时，遇到 `\0` 才会停止
            std::cout << "socket communication success: 客户端原始数据：" << std::string(receive_data, receive_data_length) << std::endl;
        }

        // 3. 发送数据长度
        std::string send_data = "Hello, Focus!!!";
        int send_data_length = send_data.length();

        if (send(client_id, &send_data_length, sizeof(send_data_length), 0) < 0) {
            std::cerr << "socket communication error: 发送客户端数据长度失败" << std::endl;
            break;
        }

        // 4. 发送数据
        if (send(client_id, send_data.c_str(), send_data_length, 0) < 0) {
            std::cerr << "socket communication error: 发送客户端数据失败" << std::endl;
            break;
        } 
    }

    std::cout << "socket client close：客户端 " << client_id << " 已断开连接" << std::endl;
    close(client_id);
}
头文件
// socket
#include <sys/types.h>
#include <sys/socket.h>

// socket addr
#include <sys/un.h>
#include <netinet/in.h>

#include <pthread.h>

#include <unistd.h>

// htons
#include <arpa/inet.h>

#include <iostream>

class UnixSocketServer {
    private:
        std::string socket_path;

        // 记录服务端socket配置
        int socket_id;

        // 客户端最大连接数
        int max_client = 5;

        static void *thread_working(void *args);

    public:
        UnixSocketServer(std::string socket_path);

        ~UnixSocketServer();

        void run();
};
全代码
#include "socket.h"

UnixSocketServer::UnixSocketServer(std::string socket_path) {
    this->socket_path = socket_path;

    if (access(this->socket_path.c_str(), F_OK) == 0) {
        // unlink：删除文件
        if (unlink(this->socket_path.c_str()) < 0) {
            std::cerr << "删除 socket：" << this->socket_path << " 失败" << std::endl;
            throw std::runtime_error("socket error: 创建失败");
        }
    }

    // 1. 创建服务端socket
    this->socket_id = socket(AF_UNIX, SOCK_STREAM, 0);
    if (this->socket_id < 0) {
        std::cerr << "socket error: 创建失败" << std::endl;
        throw std::runtime_error("socket error: 创建失败");
    } else {
        std::cout << "socket 创建成功，socketId：" << this->socket_id << std::endl;
    }
    
    // 2. 绑定Socket
    struct sockaddr_un server_addr;
    server_addr.sun_family = AF_UNIX;
    strcpy(server_addr.sun_path, this->socket_path.c_str());

    if (bind(this->socket_id, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "socket bind error: 绑定套接字失败，请检查本地套接字是否被占用" << std::endl;
        throw std::runtime_error("socket bind error: 绑定套接字失败，请检查本地套接字是否被占用");
    }

    // 3. 创建socket监听队列，并开始监听
    int listen_ret = listen(this->socket_id, this->max_client);
    if (listen_ret < 0) {
        std::cerr << "socket listen error: Socket监听失败" << std::endl;
        throw std::runtime_error("socket listen error: Socket监听失败");
    } 
}

UnixSocketServer::~UnixSocketServer() {
    close(this->socket_id);
    unlink(this->socket_path.c_str());
}

void *UnixSocketServer::thread_working(void *args) {
    int client_id = *(int *) args;

    while (true) {
        // 1. 接收数据长度
        // 注意这里不能采用 size_t 等类型定义，该类型会导致在不同架构编译器生成的 sizeof 大小不一致
        int receive_data_length;
        
        if (recv(client_id, &receive_data_length, sizeof(receive_data_length), 0) <= 0) {
            std::cerr << "socket communication error: 接收客户端数据长度失败" << std::endl;
            break;
        } else {
            std::cout << "socket communication success: 客户端原始数据长度：" << receive_data_length << std::endl;
        }

        // 2. 接收数据
        char receive_data[receive_data_length];
        if (recv(client_id, &receive_data, receive_data_length, 0) <= 0) {
            std::cerr << "socket communication error: 接收客户端数据失败" << std::endl;
            break;
        } else { 
            // 这里通过 std::string 构造函数初始化接收数据
            // 接收数据长度没有 `\0`，C/C++在输出 char 时，遇到 `\0` 才会停止
            std::cout << "socket communication success: 客户端原始数据：" << std::string(receive_data, receive_data_length) << std::endl;
        }

        // 3. 发送数据长度
        std::string send_data = "Hello, Focus!!!";
        int send_data_length = send_data.length();

        if (send(client_id, &send_data_length, sizeof(send_data_length), 0) < 0) {
            std::cerr << "socket communication error: 发送客户端数据长度失败" << std::endl;
            break;
        }

        // 4. 发送数据
        if (send(client_id, send_data.c_str(), send_data_length, 0) < 0) {
            std::cerr << "socket communication error: 发送客户端数据失败" << std::endl;
            break;
        } 
    }

    std::cout << "socket client close：客户端 " << client_id << " 已断开连接" << std::endl;
    close(client_id);
}

void UnixSocketServer::run() {
    while(true) {

        struct sockaddr_un client_addr;
    
        int client_addr_len = sizeof(client_addr);
        int client_id = accept(this->socket_id, (struct sockaddr*)&client_addr, (socklen_t *) &client_addr_len);
        if (client_id < 0) {
            std::cerr << "socket client accpet error: Socket监听失败" << std::endl;
            throw std::runtime_error("socket listen error: Socket监听失败");
        } else {
            std::cout << "socket client accpet success: 客户端：" << client_id << "连接成功" << std::endl;
        }

        pthread_t thread_id = client_id;
        pthread_create(&thread_id, NULL, this->thread_working, (void *) &client_id);
        pthread_detach(thread_id);
    }
}

int main() {
    UnixSocketServer *unixSocketServer = new UnixSocketServer("/var/tmp/socket_test");

    unixSocketServer->run();

    return 0;
}

客户端

// socket
#include <sys/types.h>
#include <sys/socket.h>

// socket addr
#include <sys/un.h>
#include <netinet/in.h>

// file close
#include <unistd.h>

// htons
#include <arpa/inet.h>

#include <iostream>
#include <string.h>

int socket_connect(const char *socket_path) {
    // 1. 创建客户端Socket
    int client_socket = socket(AF_UNIX, SOCK_STREAM, 0);

    if (client_socket < 0) {
        std::cerr << "socket error: 创建失败" << std::endl;
        throw std::runtime_error("socket error: 创建失败");
    } else {
        std::cout << "socket 创建成功，socketId：" << client_socket << std::endl;
    }

    // 2. 绑定Socket
    struct sockaddr_un client_addr;
    client_addr.sun_family = AF_UNIX;
    strcpy(client_addr.sun_path, socket_path);

    if (connect(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0) {
        std::cerr << "socket connect error: 连接服务端socket失败" << std::endl;
        throw std::runtime_error("socket connect error: 连接服务端socket失败");
    }
    return client_socket;
}

int socket_close(int client_socket) {
    close(client_socket);
}

void socket_communication(const char *socket_path, std::string send_data) {
    int client_socket = socket_connect(socket_path);

    // 1. 发送数据长度
    int send_data_length = send_data.length();

    if (send(client_socket, &send_data_length, sizeof(send_data_length), 0) < 0) {
        std::cerr << "socket communication error: 发送客户端数据长度失败" << std::endl;
    }

    // 2. 发送数据
    if (send(client_socket, send_data.c_str(), send_data_length, 0) < 0) {
        std::cerr << "socket communication error: 发送客户端数据失败" << std::endl;
    } 

    // 3. 接收数据长度
    int receive_data_length;
        
    if (recv(client_socket, &receive_data_length, sizeof(receive_data_length), 0) <= 0) {
        std::cerr << "socket communication error: 接收客户端数据长度失败" << std::endl;
    } else {
        std::cout << "socket communication success: 客户端原始数据长度：" << receive_data_length << std::endl;
    }

    // 2. 接收数据
    char receive_data[receive_data_length];
    if (recv(client_socket, &receive_data, receive_data_length, 0) <= 0) {
        std::cerr << "socket communication error: 接收客户端数据失败" << std::endl;
    } else {
        std::cout << "socket communication success: 客户端原始数据：" << receive_data << std::endl;
    }

    socket_close(client_socket);
}

int main() {
    std::string data = R"({"args":null,"function":"select_all_algorithm_log","module":"dal","package":"log"})";

    socket_communication("/var/tmp/socket_test", data);
    return 0;
}
北溪入江流
关注
专栏目录
C++实现简单Socket通信
11-22
C++实现简单Socket通信，最基本的代码。可以作为初始学习socket功能使用，仅供参考...................
c++实现socket通信
11-03
c++实现SOCKET通信Demo，供TCP/IP通信进行测试。vc6.0、vs2010都支持，下载可编译。
学懂C++（三十八）：深入详解C++网络编程：套接字（Socket）开发技术
martian665的专栏
08-19 3462
深入详解C++网络编程：套接字（Socket）开发技术
【Windows】 C++实现 Socket 通讯
最新发布
m0_51005282的博客
10-03 1448
【Windows】 C++实现 Socket 通讯
【C++】使用C++实现基于Socket的通信
kewaqi618的博客
07-10 2962
Socket是一种网络通信接口，它提供了端到端的通信服务。Socket分为TCP（Transmission Control Protocol，传输控制协议）和UDP（User Datagram Protocol，用户数据报协议）两种类型。TCP是面向连接的、可靠的、基于字节流的传输层通信协议，而UDP则是无连接的、不可靠的、基于数据报的传输层通信协议。// Type部分，通常使用16位整型// Length部分，也是16位整型// Value部分，使用字节向量存储。
Socket通信c++实现
nanchengyu的博客
09-28 921
Socket C++/C编程实现   #pragma指令：设定编译器的状态或者指示编译器完成一些特定的动作 运用socket时要预处理文件：#include 在codeblocks里面编译链接时会报错 undefined reference to WSAStartup等 解决方法如下： 在project------->build options------->linker setti
简单的socket通信C++版
09-18
"简单的socket通信C++版"是一个入门级的学习项目，旨在教授如何使用C++语言进行基本的Socket编程，实现客户端与服务器之间的数据交换。在这个项目中，我们有两个主要的文件：`simpleSocket_server`和`simpleSocket_...
Unity与C++之间进行socket通信
01-02
VC和Unity之间使用socket的TCP协议进行网络通信。以C#作为Unity脚本为例与C++进行通信，所以实质上是C#与C++之间进行socket通信。C#与C++都提供了socket类，这样就使得这两种语言之间可以相互发送并接受消息。
c++Socket通信框架
04-24
C++ Socket通信框架是网络编程中的重要组成部分，它允许程序通过网络进行数据交换。在Windows平台上，使用C++实现Socket通信通常涉及到Windows Socket API（也称为Winsock）。本框架“HP-Socket”专为Windows环境...
C++写的服务器与Java写的客户端通过Socket通信C++代码
01-10
在IT行业中，网络通信是至关重要的一个领域，特别是...总之，C++和Java的Socket通信是多语言开发中的一种常见实践，它利用TCP/IP协议进行可靠的数据交换。通过理解上述知识点，开发者可以构建起自己的跨平台网络应用。
c++ Windows Socket实现最简单的C/S网络通信（TCP）
09-18
这是一个C++语言基于windos平台socket编写的C/S结构的网络通信程序。 代码里面有具体的注释，很方便阅读。此源码只适合新手。
简易Socket编程（C++版）
11-21
C++基于socket编程实现简单服务端（基于Tcp连接的代码实现）
一个简单的vs c++ socket通讯程序
05-11
一个简单的socket通讯程序, 包括服务端和客户端程序。建立客户端和客户端c++空项目，分别添加socketClient.cpp和sockServer.cpp, 根据注释配置，编译生成后就可以执行。客户端程序在visual studio 2015和2013上编译通过，服务端程序在visual studio 2015和2008上编译通过。网上的一些程序在编译时会出错，或者运行时会中断，希望这个程序对你会有所帮助。
C++与android通过socket通信
10-18
C++编写的服务器端跟android上编写的手机客户端进行socket通信，传动多种数据。用VC6.0直接打开C++ Server，用eclipse直接打开android socketTest。注意修改一下安卓代码中的IP地址。程序中java和C++的通信的内容...
Socket通信总结（附C++实现）
冷月宫主的专栏
10-13 5555
文章目录 [隐藏] 一、Socket是什么 二、一些基本概念 三、java socket建立连接的过程   四、Socket 通信示例 五、建立通信链路 六、服务端代码： 七、客户端代码 测试图例：        因为项目需要，服务端需要一个SOCKET来接收客户端的请求，好吧，没办法度娘哇，结果很多都是linux的例子，功夫不负有心人啊
C++:实现socket通信
无知亦乐
05-17 613
原博客地址，嗯~~，感觉别人已经写得很好了，这里还是尊重别人劳动成果，大家可以看一下原博客，我这里只把代码贴出来了。 原博客地址：https://blog.csdn.net/qq_27923041/article/details/83857964 我是在VS2019下跑的，能跑通 server端代码 #include "pch.h" #include<iostream> #include<winsock.h> #pragma comment(lib,"ws2_32.lib") usi
c++ socket通信
maizaozao的专栏
06-20 584
首先是打开vc6.0, 点击文件新建 选择如图所示:     输入一个工程名   然后新建一个C++文件   如图所示:   Server端代码: [cpp] view plaincopy #include    #include    #pragma comment(lib
C++网络通信socket
m0_60259116的博客
07-21 1348
C++网络通信socket
socket通信C语言
10-01
在C语言中，Socket通信通常是指通过套接字（socket）来进行网络编程的一种技术。套接字是一种轻量级的进程间通信机制，用于在应用程序之间建立连接，尤其适合于分布式系统中的数据交换。 以下是基本步骤： 1. **创建套接字**：使用`socket()`函数创建一个新的套接字，并指定协议类型（如TCP或UDP）和域（如AF_INET表示IPv4）。 ```c int socket_id = socket(AF_INET, SOCK_STREAM, 0); ``` 2. **设置服务器地址**：如果是服务器端，使用`bind()`将套接字绑定到特定的IP地址和端口号。 ```c struct sockaddr_in server_addr; //...填充server_addr结构体... bind(socket_id, (struct sockaddr *)&server_addr, sizeof(server_addr)); ``` 3. **监听连接**：对于服务器端，使用`listen()`开始监听新连接。 ```c listen(socket_id, SOMAXCONN); ``` 4. **接受客户端连接**：使用`accept()`等待并接收客户端的连接请求，返回一个新的套接字。 5. **发送和接收数据**：对于客户端和服务器，可以使用`send()`和`recv()`函数分别发送和接收数据。 ```c ssize_t send_size = send(client_socket, data, strlen(data), 0); char received_data[1024]; ssize_t recv_size = recv(socket_id, received_data, sizeof(received_data), 0); ``` 6. **关闭套接字**：完成通信后，记得关闭套接字释放资源。 ```c close(socket_id); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北溪入江流

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

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

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

打赏作者

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

抵扣说明：

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

余额充值