【QNX】Socket Server&Client 源代码

【生活经历分享】华师国培 华师伴学 合同都是坑 消费者付款后无法退款和华师国培签合同需小心，合同中都是保护华师的条款，没有保护消费者的条款。
收到钱，就算你因对培训质量不满意，也不能退款。因合同消费者维权肯定十分艰难。
华师伴学的授课方式是看录制的视频，不是真人现场教学。是否是您和孩子想要的学习方式？
各位打算报名的，交费要谨慎！
其他人在小红书上发的，转：

深圳市华师国培教育科技有限公司，黑心机构，大家擦亮眼睛，别被骗了，消费欺诈，虚假承诺，签合同各种坑，收到钱了不履行承诺不退款，乱扣费，维权艰难！ - 小红书

 

1 Socket Server 源代码

服务端计划只启动一个线程，所以功能实现时使用了一些全局变量。

int32_t skt_s_listen_fd{-1};
pthread_t thr_server;
struct sockaddr_un srv_addr;
struct sockaddr_un cli_addr;
std::vector<int32_t> com_fd_vec;

void *serverSocketThd(void *arg)
{
    SLOG_I("Start receive - server.");

    // listen sockfd
    int32_t ret = listen(skt_s_listen_fd, 1);
    if(ret == -1) 
    {
        SLOG_E("cannot listen the client connect request: %d - %s", errno, strerror(errno));
        close(skt_s_listen_fd);
        unlink(SOCK_PATH);
        return NULL;
    }
    const char *ready_flag = "LeoTest";
    while(1)
    {
        //have connect request use accept
        socklen_t len = sizeof(cli_addr);
        //accept the client
        int32_t com_fd = accept(skt_s_listen_fd, (struct sockaddr*)(&cli_addr), &len);

        if(com_fd < 0) 
        {
            SLOG_E("cannot accept client connect request: %d - %s", errno, strerror(errno));
            close(skt_s_listen_fd);
            unlink(SOCK_PATH);
            return NULL;
        }
    
        char buf[64] = {0};
        int32_t recv_size(0);

        recv_size = read(com_fd, buf, 10);
        SLOG_I("Socket readed [%d] info: %s", com_fd, buf);
        if (0 == strncmp(buf, ready_flag, 7))
        {
            com_fd_vec.push_back(com_fd);
        }
    }

    return NULL;
}

void socket_server_init()
{
    int32_t ret;
    SLOG_I("Init socket start[%s].", SOCK_PATH);
 
    skt_s_listen_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if(skt_s_listen_fd < 0) {
        SLOG_E("cannot create communication socket: %d - %s", errno, strerror(errno));
        return ;
    }

    // set server addr_param
    srv_addr.sun_family = AF_UNIX;
    strcpy(srv_addr.sun_path, SOCK_PATH);
    unlink(SOCK_PATH);

    // bind sockfd & addr
    ret = bind(skt_s_listen_fd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));
    if(ret == -1) {
        SLOG_E("cannot bind server socket[%s]: %d - %s", SOCK_PATH, errno, strerror(errno));
        close(skt_s_listen_fd);
        unlink(SOCK_PATH);
        return ;
    }
    // scheduler_ = new std::thread(&serverSocketThd, nullptr);
    if (EOK != pthread_create(&thr_server, NULL, serverSocketThd, nullptr)) {
        SLOG_E("create connect thread failed: %d - %s", errno, strerror(errno));
    }
    else {
    }

    SLOG_I("Init socket end.");
}

 

2 Socket Client 源代码

客户端计划启动多个（如：30个）线程，所以客户端实现时没有使用全局变量，尽量做到线程无关。

void socket_client_init(int *enter);

int sendMsg_client_ready(int fd)
{
    char buf_send[] = "LeoTest";
    SLOG_I("send LeoTest to server.");
    return write(fd, buf_send, sizeof(buf_send));
}

// recv message
void *recv_client_thread(void *arg)
{
    if (NULL == arg)
    {
        SLOG_E("[recv_client_thread]param is not allow NULL.");
        return NULL;
    }
    SLOG_I("[recv_client_thread]receive thread starting<tid=%lu>...", pthread_self());
    RecvModel *model = (RecvModel *)arg;
    ssize_t flag = 0;
    unsigned char buf_recv[64] = {0};
    ssize_t length = 0;
    usleep(300);
    
    SLOG_D("create communication send data");
    sendMsg_client_ready(model->st);
    SLOG_D("create communication send data end");

    while(true)
    {
        flag = recv(model->st, buf_recv, sizeof(buf_recv), 0);
        if (0 == flag)
        {   // 需要考虑重连机制
            SLOG_E("[recv_client_thread]remote already close connect.");
            break;
        }
        else if (-1 == flag)
        {   // 需要考虑重连机制
            SLOG_E("[recv_client_thread]recv failed. error message : %s", strerror(errno));
            break;
        }
        
        length = flag;
        SLOG_D("receive data(length: %d): %s", length, buf_recv);

        memset(buf_recv, 0, sizeof(buf_recv));
    }

    close(model->st);
    return NULL;
}


void *client_connect_thread(void *arg)
{
    SLOG_I("[client_connect_thread]enter: 0x%x", arg);
    if(NULL != arg) {
        int *enter = (int *)arg;
        SLOG_I("[client_connect_thread]enter[%d]...", *enter);
        
        int connect_fd;
        int ret;
        int count_connect = 0;

        static struct sockaddr_un srv_addr;
        // char sock_path_str[128] = {0};
    
        SLOG_I("create communication socket...");
        // create unix socket
        connect_fd = socket(PF_UNIX, SOCK_STREAM, 0);
        if(connect_fd < 0) {
            SLOG_E("cannot create communication socket");
            return NULL;
        }
        SLOG_D("create communication socket end");
        srv_addr.sun_family = AF_UNIX;
        // sprintf(sock_path_str, SOCK_PATH, count);
        strcpy(srv_addr.sun_path, SOCK_PATH);
        // connect server
        ret = connect(connect_fd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));
        SLOG_I("create communication connect end: %d", ret);
        while(-1 == ret) {
            count_connect++;
            SLOG_W("connect to the server failed, trying no. %d", count_connect);
            sleep(1);
            
            ret = connect(connect_fd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));
        }

        RecvModel model;
        model.st = connect_fd;
        model.addr = &srv_addr;
        // 开启线程--接收线程
        pthread_t thr_recv;
        if (pthread_create(&thr_recv, NULL, recv_client_thread, &model) != 0)
        {
            SLOG_E("create recv thread failed");
        }
        else
        {
            SLOG_I("create communication pthread join");
            pthread_join(thr_recv, NULL);
            SLOG_W("create communication pthread join end");
        }
    }
}

void socket_client_init(int *enter)
{
    pthread_t thr_connect;

    SLOG_I("* * * * * * * * * * * * * * * * * * [socket_client_init]starting[%d]...", *enter);
    {
        if (EOK != pthread_create(&thr_connect, NULL, client_connect_thread, (void *)enter))
        {
            SLOG_E("create connect thread failed");
        }
        else
        {
            // pthread_join(thr_connect, NULL);     // PTHREAD_CREATE_JOINABLE 属性(默认值)需要调用此函数 - 此函数会阻塞直到线程退出
        }
    }
}

 

3 调用示例代码

因为测试代码是写在同一个应用中，所以使用命令行参数进行区分【将命令行参数转化为控制变量: isSktFlag】

    if(2 == isSktFlag) {
        // socket client: connect to server
        for(int i = 0; i < 30; i++) {
            SLOG_D("[socket] client start %d...", i);
            socket_client_init(&i);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(1000 * 1000));    // 因为后面还有其它测试代码, 所以增加此行延时
    }
    else if(1 == isSktFlag) {
        SLOG_D("[socket] server start...");
        socket_server_init();
        std::this_thread::sleep_for(std::chrono::milliseconds(1000 * 1000));    // 因为后面还有其它测试代码, 所以增加此行延时
    }
    

 

 

只运行 Server 时查看 uds 信息如下：

 

再运行 client 后查看 uds 信息如下：