一个基本的http客户端-CSDN博客

本文链接：https://blog.csdn.net/hfwyydy/article/details/134520052

高可用客户端

1. httpClient.h

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

class HttpClient
{
public:
    HttpClient(std::string url) : url_(url), port_(0) {}
    int write_http(const std::string &method, const std::string &msg);

private:
    int get_socket();

    int set_sock_timeout(int sockfd, int sec, int ms);

    int set_buf_size(int sockfd, int sendsize, int recvsize);

    int domain_judge(const char *buf);

    int split_url(std::string &url, std::string &host, unsigned short &port);

    int host_get_by_name(const char *name);

    void print_netstat(int err);

    int noblock_connect(int sockfd, struct sockaddr *addrs, int addrlen);

    int make_http_head(const char *method, std::string &httpmsg, const std::string &purl);

    int make_http_msg(const std::string &method, std::string &msg);

    int writen(int connfd, const char *vptr, size_t n);

    int recvn_timeout(int connfd, char *vptr, int n, int timeout);

    std::string readn(int sockfd, size_t n);

    int parse_recvmsg(std::string &recvmsg);

    int parse_test(std::string &msg);

private:
    std::function<int(std::string &)> parseFunc_;
    std::string url_;
    std::string host_;
    unsigned short port_;
};

2.httpClient.cpp

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <string>
#include <vector>
#include <memory>

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

#include <jsoncpp/json/json.h>

#include "httpClient.h"

int HttpClient::make_http_head(const char *method, std::string &httpmsg, const std::string &purl)
{
    char headbuf[1024] = {0};
    int len = snprintf(headbuf, sizeof(headbuf), "%s %s HTTP/1.1\r\n"
                                                 "Content-Type: application/json\r\n"
                                                 "Accept: application/json\r\n"
                                                 "Host: %s:%d\r\n"
                                                 "Connection: Keep-Alive\r\n"
                                                 "Content-Length: %d\r\n\r\n",
                       method,
                       purl.c_str(),
                       host_.c_str(),
                       port_,
                       static_cast<int>(httpmsg.size()));
    httpmsg = headbuf + httpmsg;
    return 0;
}

int HttpClient::make_http_msg(const std::string &method, std::string &msg)
{
    return make_http_head(method.c_str(), msg, "");
}

int HttpClient::writen(int connfd, const char *vptr, size_t n)
{
    int nleft = n, nwrite = 0, retryCont = 0;
    char *ptr = const_cast<char *>(vptr);

    while (nleft > 0)
    {
        if ((nwrite = send(connfd, ptr, nleft, MSG_NOSIGNAL)) <= 0)
        {
            if (retryCont < 100 && (nwrite == 0 || errno == EINTR))
            {
                nwrite = 0;
                ++retryCont;
                usleep(10000);
            }
            else
            {
                return -1;
            }
        }
        nleft -= nwrite;
        ptr += nwrite;
    }

    return n;
}

int HttpClient::recvn_timeout(int connfd, char *vptr, int n, int sec)
{
    int nleft = n;
    int nread = 0, retryCnt = 0;
    char *ptr = vptr;
    fd_set fdset;
    struct timeval timeout;

    while (nleft > 0)
    {
        timeout.tv_sec = sec;
        timeout.tv_usec = 0;
        FD_ZERO(&fdset);
        FD_SET(connfd, &fdset);
        if (select(connfd + 1, &fdset, nullptr, nullptr, &timeout) <= 0)
        {
            printf("select fail errno = %d\n", errno);
            break;
        }
        if ((nread = recv(connfd, ptr, nleft, 0)) < 0)
        {
            if (retryCnt < 50 && (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR))
            {
                nread = 0;
                ++retryCnt;
                usleep(10000);
            }
            else
            {
                break;
            }
        }
        else if (nread == 0)
        {
            break;
        }
        nleft -= nread;
        ptr += nread;
    }
    return (n - nleft);
}

std::string HttpClient::readn(int sockfd, size_t n)
{
    char buf[2048] = {0};
    std::string result;
    int total = 0;
    int byterecv;

    do
    {
        byterecv = recvn_timeout(sockfd, buf, 2048, 5);
        if (byterecv <= 0)
        {
            break;
        }
        total += byterecv;
        result.append(buf, byterecv);
    } while (total < n && byterecv == sizeof(buf));

    return result;
}

int HttpClient::parse_recvmsg(std::string &recvmsg)
{
    std::string ::size_type headend = recvmsg.find("\r\n\r\n");
    if (headend == std::string::npos)
    {
        std::cout << "not found header" << std::endl;
        return false;
    }
    std::string body = recvmsg.substr(headend + 4);
    return parseFunc_(body);
}

int HttpClient::split_url(std::string &url, std::string &host, unsigned short &port)
{
    if (!url.compare(0, 7, "http://"))
    {
        url = url.substr(7);
    }

    if (!url.compare(0, 8, "https://"))
    {
        url = url.substr(8);
    }

    size_t slashPos = url.find("/");
    if (slashPos != std::string::npos)
    {
        url = url.substr(0, slashPos);
    }

    size_t colonPos = url.find(":");
    if (colonPos == std::string::npos)
    {
        host = url;
        port = 80;
    }
    else
    {
        host = url.substr(0, colonPos);
        port = atoi(url.substr(colonPos + 1).c_str());
    }
}

int HttpClient::domain_judge(const char *buf)
{
    if (nullptr == buf)
    {
        return false;
    }

    bool hasChar = false, hasDot = false;
    for (size_t i = 0; i < strlen(buf); ++i)
    {
        if (isalpha(buf[i]))
        {
            hasChar = true;
            continue;
        }
        if ('.' == buf[i])
        {
            hasDot = true;
            continue;
        }
        if (hasChar && hasDot)
        {
            return true;
        }
    }
    return false;
}

int HttpClient::host_get_by_name(const char *name)
{
    //    char ipaadress[64] = {0};
    struct addrinfo hints, *reslut = nullptr, *address = nullptr;
    memset(&hints, 0, sizeof(addrinfo));

    hints.ai_family = AF_UNSPEC; // ipv4 ipv6
    hints.ai_flags = AI_PASSIVE;
    hints.ai_socktype = SOCK_STREAM;

    int ret = getaddrinfo(name, nullptr, &hints, &reslut);
    if (ret != 0)
    {
        std::cerr << "getaddrinfo err " << gai_strerror(ret) << std::endl;
        return ret;
    }

    for (address = reslut; address != nullptr; address = address->ai_next)
    {
        if (address->ai_family == AF_INET)
        {
            struct sockaddr_in *addr = reinterpret_cast<struct sockaddr_in *>(address->ai_addr);
            freeaddrinfo(reslut);
            return static_cast<int>(addr->sin_addr.s_addr);
        }
        else if (address->ai_family == AF_INET6)
        {
            struct sockaddr_in6 *addr = reinterpret_cast<struct sockaddr_in6 *>(address->ai_addr);
            continue; // 暂不使用ipv6
        }
    }
    freeaddrinfo(reslut);
    return false;
}

int HttpClient::set_buf_size(int sockfd, int sendsize, int recvsize)
{
    int ret1 = ::setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<char *>(&sendsize), sizeof(sendsize));
    int ret2 = ::setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<char *>(&recvsize), sizeof(recvsize));

    return (ret1 == 0 && ret2 == 0) ? 0 : -1;
}

int HttpClient::set_sock_timeout(int sockfd, int sec, int ms)
{
    timeval timeout = {sec, ms * 1000};
    int ret1 = ::setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<char *>(&timeout), sizeof(timeout));
    int ret2 = ::setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<char *>(&timeout), sizeof(timeout));

    return (ret1 == 0 && ret2 == 0) ? 0 : -1;
}

int HttpClient::noblock_connect(int sockfd, struct sockaddr *addrs, int addrlen)
{
    struct timeval timeout = {5, 0};
    int err = -1;
    fd_set fdset;

    int flag = 1;
    if (ioctl(sockfd, FIONBIO, &flag) != 0)
    {
        printf("ioctl error\n");
    }

    int ret = connect(sockfd, addrs, addrlen);
    if (-1 == ret)
    {
        if (EINPROGRESS == errno)
        {
            FD_ZERO(&fdset);
            FD_SET(sockfd, &fdset);
            if (select(sockfd + 1, nullptr, &fdset, nullptr, &timeout) > 0)
            {
                getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &err, (socklen_t *)&addrlen);
                if (0 == err)
                {
                    ret = 0;
                }
                else
                {
                    ret = -1;
                }
            }
            else
            {
                ret = -1;
            }
        }
    }
    flag = 0;
    if (ioctl(sockfd, FIONBIO, &flag) != 0)
    {
        printf("ioctl error\n");
    }
    if (ret < 0)
    {
        print_netstat(err);
    }
    return ret;
}

void HttpClient::print_netstat(int err)
{
    switch (err)
    {
    case ENETUNREACH: // 网不通
    case EHOSTUNREACH:
        printf("network is unreachable err[%d]\n", err);
        break;
    case ECONNREFUSED: // 连接端口被拒绝
        printf("no-one listening on the remote address\n");
        break;
    case ETIMEDOUT: // 网络连接失败,服务器未响应
        printf("timeout while attempting connection the server may be to busy\n");
        break;
    default:
        printf("other errno %d\n", err);
        break;
    }
}

int HttpClient::get_socket()
{
    int bufsize = 0x20000; // 128k
    int errnoret = -1;
    struct sockaddr_in serveraddr;
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        return -1;
    }
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    split_url(url_, host_, port_);

    if (domain_judge(host_.c_str()))
    {
        serveraddr.sin_addr.s_addr = host_get_by_name(host_.c_str());
    }
    else
    {
        serveraddr.sin_addr.s_addr = inet_addr(host_.c_str());
    }

    serveraddr.sin_port = htons(port_);

    if (set_buf_size(sockfd, bufsize, bufsize) < 0)
    {
        close(sockfd);
        return -1;
    }

    if (set_sock_timeout(sockfd, 5, 0) < 0)
    {
        close(sockfd);
        return -1;
    }

    int ret = noblock_connect(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    if (-1 == ret)
    {
        close(sockfd);
        return -1;
    }

    return sockfd;
}

int HttpClient::parse_test(std::string &msg)
{
    std::cout << msg << std::endl;
    return 0;
}

int HttpClient::write_http(const std::string &method, const std::string &msg)
{
    std::string httpmsg = msg;

    int fd = get_socket();
    if (fd < 0)
    {
        printf("fd is error\n");
        return -1;
    }
    make_http_msg(method, httpmsg);
    writen(fd, httpmsg.c_str(), httpmsg.size());
    std::string recvmsg = readn(fd, 2048);
    std::cout << recvmsg << std::endl;
    if (recvmsg.size())
    {
        parseFunc_ = std::bind(&HttpClient::parse_test, this, std::placeholders::_1);
        parse_recvmsg(recvmsg);
    }

    return 0;
}

void test()
{
    HttpClient client("192.168.95.1:8080");
    client.write_http("post", "hello\n");
}

int main()
{
    test();
    return 0;
}