Qt_26 - 8BitsCoding/RobotMentor GitHub Wiki

#include "asioclient.h"
#include <qdebug.h>

AsioClient::AsioClient() :
    work(new boost::asio::io_service::work(ioservice)),
    resolver(ioservice),
    socket(ioservice)
{
    worker = std::thread([&](){
        ioservice.run();
    });

}

AsioClient::~AsioClient(){
    ioservice.stop();
    worker.join();
    work.reset();
}

void AsioClient::Get(const QString& url, const QString& p)
{
    // 1. url -> ep resolve
    server = url.toStdString();
    path = p.toStdString();

    boost::asio::ip::tcp::resolver::query query(server, "http");
    resolver.async_resolve(query, boost::bind(&AsioClient::handle_resolve,
                                              this,
                                              boost::asio::placeholders::error,
                                              boost::asio::placeholders::iterator));

    // 2. connect

    // 3. send

    // 4. recv
}


void AsioClient::handle_resolve(const boost::system::error_code& err, boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
{
    if(!err) {
        boost::asio::ip::tcp::endpoint ep = *endpoint_iterator;
        qDebug() << ep.address().to_string().c_str();

        socket.async_connect(*endpoint_iterator,
                             boost::bind(&AsioClient::handle_connect,
                                         this,
                                         boost::asio::placeholders::error,
                                         endpoint_iterator));
    }
}

void AsioClient::handle_connect(const boost::system::error_code& err,
                                boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
{
    if(!err) {
        // success
        // write
        std::ostream os(&requestbuf);

        os << "GET" << path << " HTTP/1.0\r\n";
        os << "Host: " << server << "\r\n";
        os << "Accept: */*\r\n";
        os << "Connection: close\r\n\r\n";

        boost::asio::async_write(socket, requestbuf,
                                 boost::bind(&AsioClient::handle_write,
                                             this,
                                             boost::asio::placeholders::error));
    } else {
        qDebug() << err.message().c_str() << endl;
    }
}

void AsioClient::handle_write(const boost::system::error_code& err)
{
    // recv
    if(!err) {
        boost::asio::async_read_until(socket, responsebuf, "\r\n",
                                      boost::bind(&AsioClient::handle_read_line,
                                                  this,
                                                  boost::asio::placeholders::error));
    } else {
        qDebug() << "handle_Write error : " << err.message().c_str() << endl;
    }
}
void AsioClient::handle_read_line(const boost::system::error_code& err)
{
    if(!err) {
        std::istream is(&responsebuf);
        std::string http_version;
        unsigned int status_code;
        std::string message;

        is >> http_version;
        is >> status_code;
        std::getline(is, message);

        // Error Check
        // 1. http_version HTTP/
        // 2. status_code != 200

        if(status_code != 200) {
            return ;
        }

        // 개행문자(\r\n\r\n) 두번 나오는 부분부터 메시지의 본문이다.
        // 그 이전 메시지는 모두 헤더이다.
        boost::asio::async_read_until(socket, responsebuf, "\r\n\r\n",
                                      boost::bind(&AsioClient::handle_read_header,
                                                  this,
                                                  boost::asio::placeholders::error));

    } else {

    }
}

void AsioClient::handle_read_header(const boost::system::error_code& err)
{
    std::istream istrm(&responsebuf);

    std::string header;
    while(std::getline(istrm, header) && header != "\r") {
        // header
        //oss << header << std::endl;
        // 본문 내용만 받는다.
    }

    boost::asio::streambuf::const_buffers_type bufs = responsebuf.data();
    std::string str(boost::asio::buffers_begin(bufs),
                    boost::asio::buffers_begin(bufs) + responsebuf.size());

    oss << str ;

    boost::asio::async_read(socket, responsebuf,
                            boost::asio::transfer_at_least(1),
                            boost::bind(&AsioClient::handle_read_content,
                                        this,
                                        boost::asio::placeholders::error));
}

void AsioClient::handle_read_content(const boost::system::error_code& err)
{
    if(!err) {
        oss << &responsebuf;

        boost::asio::async_read(socket, responsebuf,
                                boost::asio::transfer_at_least(1),
                                boost::bind(&AsioClient::handle_read_content,
                                            this,
                                            boost::asio::placeholders::error));

    } else if(err == boost::asio::error::eof) {
        // file end
        qDebug() << oss.str().c_str() << endl;

        emit read_finish(QString::fromStdString(oss.str()));
    } else {
        // error
        emit read_failed(QString::fromStdString(err.message()));
    }
}

#ifndef ASIOCLIENT_H
#define ASIOCLIENT_H

#include <boost\asio.hpp>
#include <boost/bind.hpp>

#include <QObject>
#include <QString>
#include <memory>
#include <thread>

class AsioClient : public QObject
{
    Q_OBJECT
public:
    AsioClient();
    virtual ~AsioClient();

    void Get(const QString& url, const QString& path);
    void handle_resolve(const boost::system::error_code& err,
                        boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
    void handle_connect(const boost::system::error_code& err,
                        boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
    void handle_write(const boost::system::error_code& err);
    void handle_read_line(const boost::system::error_code& err);
    void handle_read_header(const boost::system::error_code& err);
    void handle_read_content(const boost::system::error_code& err);

private:
    boost::asio::io_service ioservice;
    std::shared_ptr<boost::asio::io_service::work> work;
    std::thread worker;

    std::string server, path;
    boost::asio::ip::tcp::resolver resolver;

    boost::asio::ip::tcp::socket socket;

    boost::asio::streambuf requestbuf;
    boost::asio::streambuf responsebuf;

    std::ostringstream oss;

signals:
    void read_finish(const QString& msg);
    void read_failed(const QString& msg);
};

#endif // ASIOCLIENT_H

#include "widget.h"
#include "ui_widget.h"
#include "QString"
#include <QRegularExpression>

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
    , client(new AsioClient)
{
    ui->setupUi(this);

    ui->paramTable->setColumnCount(2);
    ui->paramTable->setHorizontalHeaderLabels(QString("key;value").split(";"));
    ui->paramTable->setSelectionBehavior(QAbstractItemView::SelectRows);

    ui->urlEdit->setText("http://127.0.0.1:5000/");

    connect(client, SIGNAL(read_finish(QString)), this, SLOT(on_success));
}

Widget::~Widget()
{
    delete ui;
    delete client;
}


void Widget::on_getBtn_clicked()
{
    QString url = ui->urlEdit->text();
//    client->Get("www.boost.org","/");

    // https://gist.github.com/voodooGQ/4057330
    // 위 사이트에서 아래의 정규표현식을 받아와 사용한다.
    // 참고로 정규표현식 확인사이트는 https://regex101.com
    QRegularExpression re("^(?:([A-Za-z]+):)?(\\/{0,3})([0-9.\\-A-Za-z]+)(?::(\\d+))?(?:\\/([^?#]*))?(?:\\?([^#]*))?(?:#(.*))?$");
    QRegularExpressionMatch match = re.match(url);
    if(match.hasMatch()) {
        auto hostName = match.captured(3);      // match 3이 hostName
        auto urlPath = "/" + match.captured(5);       // match 5가 url

        client->Get(hostName, urlPath);
    }
}

void Widget::on_success(const QString& msg)
{
    ui->responseEdit->setText(msg);
}