datetime:2022/12/28 14:37
author:nzb

程序封装成类

_cmpublic.h

#ifndef _cmpublic_H
#define _cmpublic_H

#include <stdio.h>
#include <utime.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <time.h>
#include <math.h>
#include <stdarg.h>
#include <errno.h>
#include <signal.h>
#include <netdb.h>
#include <locale.h>
#include <dirent.h>
#include <termios.h>
#include <pthread.h>
#include <semaphore.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <list>
#include <vector>
#include <deque>
#include <algorithm>

// 采用stl标准库的命名空间std
using namespace std;

#endif

Writen()函数和Readn()函数

_freecplus.h

// 从已经准备好的socket中读取数据。
// sockfd：已经准备好的socket连接。
// buffer：接收数据缓冲区的地址。
// n：本次接收数据的字节数。
// 返回值：成功接收到n字节的数据后返回true，socket连接不可用返回false。
bool Readn(const int sockfd,char *buffer,const size_t n);

// 向已经准备好的socket中写入数据。
// sockfd：已经准备好的socket连接。
// buffer：待发送数据缓冲区的地址。
// n：待发送数据的字节数。
// 返回值：成功发送完n字节的数据后返回true，socket连接不可用返回false。
bool Writen(const int sockfd,const char *buffer,const size_t n);

_freecplus.cpp

bool Readn(const int sockfd, char *buffer, const size_t n) {
    int nLeft, nread, idx;

    nLeft = n;
    idx = 0;

    while (nLeft > 0) {
        if ((nread = recv(sockfd, buffer + idx, nLeft, 0)) <= 0) return false;

        idx += nread;
        nLeft -= nread;
    }

    return true;
}

bool Writen(const int sockfd, const char *buffer, const size_t n) {
    int nLeft, idx, nwritten;
    nLeft = n;
    idx = 0;
    while (nLeft > 0) {
        if ((nwritten = send(sockfd, buffer + idx, nLeft, 0)) <= 0) return false;

        nLeft -= nwritten;
        idx += nwritten;
    }

    return true;
}

TcpWrite()函数和TcpRead()函数

_freecplus.h

// 接收socket的对端发送过来的数据。
// sockfd：可用的socket连接。
// buffer：接收数据缓冲区的地址。
// ibuflen：本次成功接收数据的字节数。
// itimeout：接收等待超时的时间，单位：秒，缺省值是0-无限等待。
// 返回值：true-成功；false-失败，失败有两种情况：1）等待超时；2）socket连接已不可用。
bool TcpRead(const int sockfd,char *buffer,int *ibuflen,const int itimeout=0);

// 向socket的对端发送数据。
// sockfd：可用的socket连接。
// buffer：待发送数据缓冲区的地址。
// ibuflen：待发送数据的字节数，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
// 返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
bool TcpWrite(const int sockfd,const char *buffer,const int ibuflen=0);

_freecplus.cpp

bool TcpRead(const int sockfd, char *buffer, int *ibuflen, const int itimeout) {
    if (sockfd == -1) return false;

    if (itimeout > 0) {
        fd_set tmpfd;

        FD_ZERO(&tmpfd);
        FD_SET(sockfd, &tmpfd);

        struct timeval timeout;
        timeout.tv_sec = itimeout;
        timeout.tv_usec = 0;

        int i;
        if ((i = select(sockfd + 1, &tmpfd, 0, 0, &timeout)) <= 0) return false;
    }

    (*ibuflen) = 0;

    if (Readn(sockfd, (char *) ibuflen, 4) == false) return false;

    (*ibuflen) = ntohl(*ibuflen);  // 把网络字节序转换为主机字节序。

    if (Readn(sockfd, buffer, (*ibuflen)) == false) return false;

    return true;
}

bool TcpWrite(const int sockfd, const char *buffer, const int ibuflen) {
    if (sockfd == -1) return false;

    fd_set tmpfd;

    FD_ZERO(&tmpfd);
    FD_SET(sockfd, &tmpfd);

    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;

    if (select(sockfd + 1, 0, &tmpfd, 0, &timeout) <= 0) return false;

    int ilen = 0;

    // 如果长度为0，就采用字符串的长度
    if (ibuflen == 0) ilen = strlen(buffer);
    else ilen = ibuflen;

    int ilenn = htonl(ilen);  // 转换为网络字节序。

    char strTBuffer[ilen + 4];
    memset(strTBuffer, 0, sizeof(strTBuffer));
    memcpy(strTBuffer, &ilenn, 4);   // memcpy 既能处理文本数据和二进制数据，strcpy只能处理文本数据
    memcpy(strTBuffer + 4, buffer, ilen);

    if (Writen(sockfd, strTBuffer, ilen + 4) == false) return false;

    return true;
}

服务端CTcpServer类

_freecplus.h

// socket通信的服务端类
class CTcpServer {
private:
    int m_socklen;                    // 结构体struct sockaddr_in的大小。
    struct sockaddr_in m_clientaddr;  // 客户端的地址信息。
    struct sockaddr_in m_servaddr;    // 服务端的地址信息。
public:
    int m_listenfd;   // 服务端用于监听的socket。
    int m_connfd;     // 客户端连接上来的socket。
    bool m_btimeout;   // 调用Read和Write方法时，失败的原因是否是超时：true-超时，false-未超时。
    int m_buflen;     // 调用Read方法后，接收到的报文的大小，单位：字节。

    CTcpServer();  // 构造函数。

    // 服务端初始化。
    // port：指定服务端用于监听的端口。
    // 返回值：true-成功；false-失败，一般情况下，只要port设置正确，没有被占用，初始化都会成功。
    bool InitServer(const unsigned int port);

    // 阻塞等待客户端的连接请求。
    // 返回值：true-有新的客户端已连接上来，false-失败，Accept被中断，如果Accept失败，可以重新Accept。
    bool Accept();

    // 获取客户端的ip地址。
    // 返回值：客户端的ip地址，如"192.168.1.100"。
    char *GetIP();

    // 接收客户端发送过来的数据。
    // buffer：接收数据缓冲区的地址，数据的长度存放在m_buflen成员变量中。
    // itimeout：等待数据的超时时间，单位：秒，缺省值是0-无限等待。
    // 返回值：true-成功；false-失败，失败有两种情况：1）等待超时，成员变量m_btimeout的值被设置为true；2）socket连接已不可用。
    bool Read(char *buffer, const int itimeout = 0);

    // 向客户端发送数据。
    // buffer：待发送数据缓冲区的地址。
    // ibuflen：待发送数据的大小，单位：字节，缺省值为0，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
    // 返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
    bool Write(const char *buffer, const int ibuflen = 0);

    // 关闭监听的socket，即m_listenfd，常用于多进程服务程序的子进程代码中。
    void CloseListen();

    // 关闭客户端的socket，即m_connfd，常用于多进程服务程序的父进程代码中。
    void CloseClient();

    ~CTcpServer();  // 析构函数自动关闭socket，释放资源。
};

_freecplus.cpp

CTcpServer::CTcpServer() {
    m_listenfd = -1;
    m_connfd = -1;
    m_socklen = 0;
    m_btimeout = false;
}

bool CTcpServer::InitServer(const unsigned int port) {
    if (m_listenfd > 0) {
        close(m_listenfd);
        m_listenfd = -1;
    }

    if ((m_listenfd = socket(AF_INET, SOCK_STREAM, 0)) <= 0) return false;

    // WINDOWS平台如下
    //char b_opt='1';
    //setsockopt(m_listenfd,SOL_SOCKET,SO_REUSEADDR,&b_opt,sizeof(b_opt));

    // Linux如下
    int opt = 1;
    unsigned int len = sizeof(opt);
    setsockopt(m_listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, len);

    memset(&m_servaddr, 0, sizeof(m_servaddr));
    m_servaddr.sin_family = AF_INET;
    m_servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    m_servaddr.sin_port = htons(port);
    if (bind(m_listenfd, (struct sockaddr *) &m_servaddr, sizeof(m_servaddr)) != 0) {
        CloseListen();
        return false;
    }

    if (listen(m_listenfd, 5) != 0) {
        CloseListen();
        return false;
    }

    m_socklen = sizeof(struct sockaddr_in);

    return true;
}

bool CTcpServer::Accept() {
    if (m_listenfd == -1) return false;

    if ((m_connfd = accept(m_listenfd, (struct sockaddr *) &m_clientaddr, (socklen_t * ) & m_socklen)) < 0)
        return false;

    return true;
}

char *CTcpServer::GetIP() {
    return (inet_ntoa(m_clientaddr.sin_addr));
}

bool CTcpServer::Read(char *buffer, const int itimeout) {
    if (m_connfd == -1) return false;

    if (itimeout > 0) {
        fd_set tmpfd;

        FD_ZERO(&tmpfd);
        FD_SET(m_connfd, &tmpfd);

        struct timeval timeout;
        timeout.tv_sec = itimeout;
        timeout.tv_usec = 0;

        m_btimeout = false;

        int i;
        if ((i = select(m_connfd + 1, &tmpfd, 0, 0, &timeout)) <= 0) {
            if (i == 0) m_btimeout = true;
            return false;
        }
    }

    m_buflen = 0;
    return (TcpRead(m_connfd, buffer, &m_buflen));
}

bool CTcpServer::Write(const char *buffer, const int ibuflen) {
    if (m_connfd == -1) return false;

    fd_set tmpfd;

    FD_ZERO(&tmpfd);
    FD_SET(m_connfd, &tmpfd);

    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;

    m_btimeout = false;

    int i;
    if ((i = select(m_connfd + 1, 0, &tmpfd, 0, &timeout)) <= 0) {
        if (i == 0) m_btimeout = true;
        return false;
    }

    int ilen = ibuflen;
    if (ilen == 0) ilen = strlen(buffer);

    return (TcpWrite(m_connfd, buffer, ilen));
}

void CTcpServer::CloseListen() {
    if (m_listenfd > 0) {
        close(m_listenfd);
        m_listenfd = -1;
    }
}

void CTcpServer::CloseClient() {
    if (m_connfd > 0) {
        close(m_connfd);
        m_connfd = -1;
    }
}

CTcpServer::~CTcpServer() {
    CloseListen();
    CloseClient();
}

客户端CTcpClient类

_freecplus.h

// socket通信的客户端类
class CTcpClient {
public:
    int m_sockfd;    // 客户端的socket.
    char m_ip[21];    // 服务端的ip地址。
    int m_port;      // 与服务端通信的端口。
    bool m_btimeout;  // 调用Read和Write方法时，失败的原因是否是超时：true-超时，false-未超时。
    int m_buflen;    // 调用Read方法后，接收到的报文的大小，单位：字节。

    CTcpClient();  // 构造函数。

    // 向服务端发起连接请求。
    // ip：服务端的ip地址。
    // port：服务端监听的端口。
    // 返回值：true-成功；false-失败。
    bool ConnectToServer(const char *ip, const int port);

    // 接收服务端发送过来的数据。
    // buffer：接收数据缓冲区的地址，数据的长度存放在m_buflen成员变量中。
    // itimeout：等待数据的超时时间，单位：秒，缺省值是0-无限等待。
    // 返回值：true-成功；false-失败，失败有两种情况：1）等待超时，成员变量m_btimeout的值被设置为true；2）socket连接已不可用。
    bool Read(char *buffer, const int itimeout = 0);

    // 向服务端发送数据。
    // buffer：待发送数据缓冲区的地址。
    // ibuflen：待发送数据的大小，单位：字节，缺省值为0，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
    // 返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
    bool Write(const char *buffer, const int ibuflen = 0);

    // 断开与服务端的连接
    void Close();

    ~CTcpClient();  // 析构函数自动关闭socket，释放资源。
};

_freecplus.cpp

CTcpClient::CTcpClient() {
    m_sockfd = -1;
    memset(m_ip, 0, sizeof(m_ip));
    m_port = 0;
    m_btimeout = false;
}

bool CTcpClient::ConnectToServer(const char *ip, const int port) {
    if (m_sockfd != -1) {
        close(m_sockfd);
        m_sockfd = -1;
    }

    strcpy(m_ip, ip);
    m_port = port;

    struct hostent *h;
    struct sockaddr_in servaddr;

    if ((m_sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) return false;

    if (!(h = gethostbyname(m_ip))) {
        close(m_sockfd);
        m_sockfd = -1;
        return false;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(m_port);  // 指定服务端的通讯端口
    memcpy(&servaddr.sin_addr, h->h_addr, h->h_length);

    if (connect(m_sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) != 0) {
        close(m_sockfd);
        m_sockfd = -1;
        return false;
    }

    return true;
}

bool CTcpClient::Read(char *buffer, const int itimeout) {
    if (m_sockfd == -1) return false;

    if (itimeout > 0) {
        fd_set tmpfd;

        FD_ZERO(&tmpfd);
        FD_SET(m_sockfd, &tmpfd);

        struct timeval timeout;
        timeout.tv_sec = itimeout;
        timeout.tv_usec = 0;

        m_btimeout = false;

        int i;
        if ((i = select(m_sockfd + 1, &tmpfd, 0, 0, &timeout)) <= 0) {
            if (i == 0) m_btimeout = true;
            return false;
        }
    }

    m_buflen = 0;
    return (TcpRead(m_sockfd, buffer, &m_buflen));
}

bool CTcpClient::Write(const char *buffer, const int ibuflen) {
    if (m_sockfd == -1) return false;

    fd_set tmpfd;

    FD_ZERO(&tmpfd);
    FD_SET(m_sockfd, &tmpfd);

    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;

    m_btimeout = false;

    int i;
    if ((i = select(m_sockfd + 1, 0, &tmpfd, 0, &timeout)) <= 0) {
        if (i == 0) m_btimeout = true;
        return false;
    }

    int ilen = ibuflen;

    if (ibuflen == 0) ilen = strlen(buffer);

    return (TcpWrite(m_sockfd, buffer, ilen));
}

void CTcpClient::Close() {
    if (m_sockfd > 0) close(m_sockfd);

    m_sockfd = -1;
    memset(m_ip, 0, sizeof(m_ip));
    m_port = 0;
    m_btimeout = false;
}

CTcpClient::~CTcpClient() {
    Close();
}

简单服务端和客户端示例

_server.cpp

#include "_freecplus.h"

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Using:./demo48 port\nExample:./demo48 5005\n\n");
        return -1;
    }

    CTcpServer TcpServer;   // 创建服务端对象。

    if (TcpServer.InitServer(atoi(argv[1])) == false) // 初始化TcpServer的通信端口。
    {
        printf("TcpServer.InitServer(%s) failed.\n", argv[1]);
        return -1;
    }

    if (TcpServer.Accept() == false)   // 等待客户端连接。
    {
        printf("TcpServer.Accept() failed.\n");
        return -1;
    }

    printf("客户端(%s)已连接。\n", TcpServer.GetIP());

    char strbuffer[1024];  // 存放数据的缓冲区。

    while (true) {
        memset(strbuffer, 0, sizeof(strbuffer));
        //if (TcpServer.Read(strbuffer,300)==false) break; // 接收客户端发过来的请求报文。
        if (TcpServer.Read(strbuffer, 10) == false) break; // 接收客户端发过来的请求报文。
        printf("接收：%s\n", strbuffer);

        strcat(strbuffer, "ok");      // 在客户端的报文后加上"ok"。
        printf("发送：%s\n", strbuffer);
        if (TcpServer.Write(strbuffer) == false) break;     // 向客户端回应报文。
    }

    printf("客户端已断开。\n");    // 程序直接退出，析构函数会释放资源。
}

_client.cpp

#include "_freecplus.h"

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Using:./demo47 ip port\nExample:./demo47 172.21.0.3 5005\n\n");
        return -1;
    }

    CTcpClient TcpClient;   // 创建客户端的对象。

    if (TcpClient.ConnectToServer(argv[1], atoi(argv[2])) == false) // 向服务端发起连接请求。
    {
        printf("TcpClient.ConnectToServer(\"%s\",%s) failed.\n", argv[1], argv[2]);
        return -1;
    }

    char strbuffer[1024];    // 存放数据的缓冲区。

    for (int ii = 0; ii < 30; ii++)   // 利用循环，与服务端进行5次交互。
    {
        memset(strbuffer, 0, sizeof(strbuffer));
        snprintf(strbuffer, 50, "%d:这是第%d个超级女生，编号%03d。", getpid(), ii + 1, ii + 1);
        printf("发送：%s\n", strbuffer);
        if (TcpClient.Write(strbuffer) == false) break;    // 向服务端发送请求报文。

        memset(strbuffer, 0, sizeof(strbuffer));
        if (TcpClient.Read(strbuffer, 20) == false) break;  // 接收服务端的回应报文。
        printf("接收：%s\n", strbuffer);

        sleep(1);
    }

    // 程序直接退出，析构函数会释放资源。
}

results matching ""

    No results matching ""