qt 6.5.1 original

tests/manual/qnetworkaccessmanager/qget/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#####################################################################
+## qget Binary:
+#####################################################################
+
+qt_internal_add_manual_test(qget
+    SOURCES
+        downloadmanager.cpp
+        qget.cpp qget.h
+        transferitem.cpp
+    LIBRARIES
+        Qt::Network
+)

tests/manual/qnetworkaccessmanager/qget/downloadmanager.cpp

@@ -0,0 +1,125 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "qget.h"
+#include <QAuthenticator>
+#include <QCoreApplication>
+#include <QDebug>
+#include <QSslError>
+
+DownloadManager::DownloadManager()
+    : queueMode (Parallel)
+{
+    connect(&nam, SIGNAL(finished(QNetworkReply*)), this, SLOT(finished(QNetworkReply*)));
+    connect(&nam, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), this, SLOT(authenticationRequired(QNetworkReply*,QAuthenticator*)));
+    connect(&nam, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)), this, SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
+#ifndef QT_NO_SSL
+    connect(&nam, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)), this, SLOT(sslErrors(QNetworkReply*,QList<QSslError>)));
+#endif
+}
+
+DownloadManager::~DownloadManager()
+{
+
+}
+
+void DownloadManager::get(const QNetworkRequest &request, const QString &user, const QString &password)
+{
+    DownloadItem *dl = new DownloadItem(request, user, password, nam);
+    transfers.append(dl);
+    connect(dl, SIGNAL(downloadFinished(TransferItem*)), SLOT(downloadFinished(TransferItem*)));
+}
+
+void DownloadManager::upload(const QNetworkRequest &request, const QString &user, const QString &password, const QString &filename, TransferItem::Method method)
+{
+    QScopedPointer<QFile> file(new QFile(filename));
+    if (!file->open(QFile::ReadOnly)) {
+        qDebug() << "Can't open input file" << file->fileName() << file->errorString();
+        return;
+    }
+    UploadItem *ul = new UploadItem(request, user, password, nam, file.take(), method);
+    transfers.append(ul);
+    connect(ul, SIGNAL(downloadFinished(TransferItem*)), SLOT(downloadFinished(TransferItem*)));
+}
+
+void DownloadManager::finished(QNetworkReply *)
+{
+}
+
+void DownloadManager::downloadFinished(TransferItem *item)
+{
+    qDebug() << "finished " << item->reply->url() << " with http status: " << item->reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    if (item->reply->error() != QNetworkReply::NoError)
+        qDebug() << "and error: " << item->reply->error() << item->reply->errorString();
+    transfers.removeOne(item);
+    item->deleteLater();
+    checkForAllDone();
+}
+
+void DownloadManager::checkForAllDone()
+{
+    if (transfers.isEmpty()) {
+        qDebug() << "All Done.";
+        QCoreApplication::quit();
+    }
+
+    foreach (TransferItem *item, transfers) {
+        if (!item->reply) {
+            item->start();
+            //by default multiple downloads are processed in parallel.
+            //but in serial mode, only start one transfer at a time.
+            if (queueMode == Serial)
+                break;
+        }
+    }
+
+}
+
+void DownloadManager::authenticationRequired(QNetworkReply *reply, QAuthenticator *auth)
+{
+    qDebug() << "authenticationRequired" << reply;
+    TransferItem *transfer = findTransfer(reply);
+    //provide the credentials exactly once, so that it fails if credentials are incorrect.
+    if ((transfer && !transfer->user.isEmpty()) || !transfer->password.isEmpty()) {
+        auth->setUser(transfer->user);
+        auth->setPassword(transfer->password);
+        transfer->user.clear();
+        transfer->password.clear();
+    }
+}
+
+void DownloadManager::proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth)
+{
+    //provide the credentials exactly once, so that it fails if credentials are incorrect.
+    if (!proxyUser.isEmpty() || !proxyPassword.isEmpty()) {
+        auth->setUser(proxyUser);
+        auth->setPassword(proxyPassword);
+        proxyUser.clear();
+        proxyPassword.clear();
+    }
+}
+
+#ifndef QT_NO_SSL
+void DownloadManager::sslErrors(QNetworkReply *, const QList<QSslError> &errors)
+{
+    qDebug() << "sslErrors";
+    foreach (const QSslError &error, errors) {
+        qDebug() << error.errorString();
+        qDebug() << error.certificate().toPem();
+    }
+}
+#endif
+
+TransferItem *DownloadManager::findTransfer(QNetworkReply *reply)
+{
+    foreach (TransferItem *item, transfers) {
+        if (item->reply == reply)
+            return item;
+    }
+    return 0;
+}
+
+void DownloadManager::setQueueMode(QueueMode mode)
+{
+    queueMode = mode;
+}

tests/manual/qnetworkaccessmanager/qget/qget.cpp

@@ -0,0 +1,177 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "qget.h"
+
+#include <QNetworkProxy>
+#include <QDebug>
+#include <QCoreApplication>
+#include <QList>
+#include <QStringList>
+
+void printShortUsage()
+{
+    qDebug() << QCoreApplication::applicationName() << " [options] [list of urls]" << Qt::endl
+             << "Get one or more urls using QNetworkAccessManager" << Qt::endl
+             << "--help to display detailed usage" << Qt::endl;
+}
+
+void printUsage()
+{
+    qDebug() << QCoreApplication::applicationName() << " [options] [list of urls]" << Qt::endl
+             << "Get one or more urls using QNetworkAccessManager" << Qt::endl
+             << "Options:"
+             << "--help                             This message" << Qt::endl
+             << "--user=<username>                  Set username to use for authentication"
+             << Qt::endl
+             << "--password=<password>              Set password to use for authentication"
+             << Qt::endl
+             << "--proxy-user=<username>            Set username to use for proxy authentication"
+             << Qt::endl
+             << "--proxy-password=<password>        Set password to use for proxy authentication"
+             << Qt::endl
+             << "--proxy=on                         Use system proxy (default)" << Qt::endl
+             << "--proxy=off                        Don't use system proxy" << Qt::endl
+             << "--proxy=<host:port>[,type]         Use specified proxy" << Qt::endl
+             << "                   ,http           HTTP proxy (default)" << Qt::endl
+             << "                   ,socks          SOCKS5 proxy" << Qt::endl
+             << "                   ,ftp            FTP proxy" << Qt::endl
+             << "                   ,httpcaching    HTTP caching proxy (no CONNECT method)"
+             << Qt::endl
+             << "--headers=filename                 Set request headers from file contents"
+             << Qt::endl
+             << "--post=filename                    upload the file to the next url using HTTP POST"
+             << Qt::endl
+             << "--put=filename                     upload the file to the next url using HTTP PUT"
+             << Qt::endl
+             << "--content-type=<MIME>              set content-type header for upload" << Qt::endl
+             << "--serial                           don't run requests in parallel" << Qt::endl;
+}
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication app(argc, argv);
+    if (argc < 2) {
+        printShortUsage();
+        return EXIT_FAILURE;
+    }
+
+    //use system proxy (by default)
+    QNetworkProxyFactory::setUseSystemConfiguration(true);
+
+    DownloadManager dl;
+    QString uploadFileName;
+    QString contentType;
+    QString httpUser;
+    QString httpPassword;
+    QString headersFile;
+    TransferItem::Method method = TransferItem::Get;
+    //arguments match wget where possible
+    foreach (QString str, app.arguments().mid(1)) {
+        if (str == "--help")
+            printUsage();
+        else if (str.startsWith("--user="))
+            httpUser = str.mid(7);
+        else if (str.startsWith("--password="))
+            httpPassword = str.mid(11);
+        else if (str.startsWith("--proxy-user="))
+            dl.setProxyUser(str.mid(13));
+        else if (str.startsWith("--proxy-password="))
+            dl.setProxyPassword(str.mid(17));
+        else if (str == "--proxy=off")
+            QNetworkProxyFactory::setUseSystemConfiguration(false);
+        else if (str == "--proxy=on")
+            QNetworkProxyFactory::setUseSystemConfiguration(true);
+        else if (str.startsWith("--proxy=")) {
+            //parse "--proxy=host:port[,type]"
+            QNetworkProxy proxy;
+            str = str.mid(8);
+            int sep = str.indexOf(':');
+            proxy.setHostName(str.left(sep));
+            str = str.mid(sep + 1);
+            sep = str.indexOf(',');
+            QString port;
+            if (sep < 0) {
+                port = str;
+                proxy.setType(QNetworkProxy::HttpProxy);
+            } else {
+                port = str.left(sep);
+                str = str.mid(sep + 1);
+                if (str == "socks")
+                    proxy.setType(QNetworkProxy::Socks5Proxy);
+                else if (str == "ftp")
+                    proxy.setType(QNetworkProxy::FtpCachingProxy);
+                else if (str == "httpcaching")
+                    proxy.setType(QNetworkProxy::HttpCachingProxy);
+                else if (str == "http")
+                    proxy.setType(QNetworkProxy::HttpProxy);
+                else {
+                    qDebug() << "unknown proxy type";
+                    return EXIT_FAILURE;
+                }
+            }
+            bool ok;
+            quint16 p = port.toUShort(&ok);
+            if (!ok) {
+                qDebug() << "couldn't parse proxy";
+                return EXIT_FAILURE;
+            }
+            proxy.setPort(p);
+            qDebug() << "proxy:" << proxy.hostName() << proxy.port() << proxy.type();
+            dl.setProxy(proxy);
+        }
+        else if (str.startsWith("--put=")) {
+            method = TransferItem::Put;
+            uploadFileName = str.mid(6);
+        }
+        else if (str.startsWith("--post=")) {
+            method = TransferItem::Post;
+            uploadFileName = str.mid(7);
+        }
+        else if (str.startsWith("--content-type="))
+            contentType=str.mid(15);
+        else if (str.startsWith("--headers="))
+            headersFile=str.mid(10);
+        else if (str == "--serial")
+            dl.setQueueMode(DownloadManager::Serial);
+        else if (str.startsWith(QLatin1Char('-')))
+            qDebug() << "unsupported option" << str;
+        else {
+            QUrl url(QUrl::fromUserInput(str));
+            QNetworkRequest request(url);
+            //set headers
+            if (!headersFile.isEmpty()) {
+                QFile f(headersFile);
+                if (!f.open(QFile::ReadOnly | QFile::Text)) {
+                    qDebug() << "can't open headers file: " << headersFile;
+                } else {
+                    while (!f.atEnd()) {
+                        QByteArray line = f.readLine().trimmed();
+                        if (line.isEmpty()) break;
+                        int colon = line.indexOf(':');
+                        qDebug() << line;
+                        if (colon > 0 && colon < line.length() - 2) {
+                            request.setRawHeader(line.left(colon), line.mid(colon+2));
+                        }
+                    }
+                    f.close();
+                }
+            }
+            if (!contentType.isEmpty())
+                request.setHeader(QNetworkRequest::ContentTypeHeader, contentType);
+
+            switch (method) {
+            case TransferItem::Put:
+            case TransferItem::Post:
+                dl.upload(request, httpUser, httpPassword, uploadFileName, method);
+                break;
+            case TransferItem::Get:
+                dl.get(request, httpUser, httpPassword);
+                break;
+            }
+            method = TransferItem::Get; //default for urls without a request type before it
+        }
+    }
+    QMetaObject::invokeMethod(&dl, "checkForAllDone", Qt::QueuedConnection);
+    return app.exec();
+}

tests/manual/qnetworkaccessmanager/qget/qget.h

@@ -0,0 +1,92 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+#ifndef QGET_H
+#define QGET_H
+
+#include <QNetworkAccessManager>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QFile>
+
+class TransferItem : public QObject
+{
+    Q_OBJECT
+public:
+    enum Method {Get,Put,Post};
+    TransferItem(const QNetworkRequest &r, const QString &u, const QString &p, QNetworkAccessManager &n, Method m);
+    void start();
+signals:
+    void downloadFinished(TransferItem *self);
+public slots:
+    void progress(qint64,qint64);
+public:
+    Method method;
+    QNetworkRequest request;
+    QNetworkReply *reply;
+    QNetworkAccessManager &nam;
+    QFile *inputFile;
+    QFile *outputFile;
+    QList<QUrl> redirects;
+    QString user;
+    QString password;
+};
+
+class DownloadItem : public TransferItem
+{
+    Q_OBJECT
+public:
+    DownloadItem(const QNetworkRequest &r, const QString &user, const QString &password, QNetworkAccessManager &nam);
+    ~DownloadItem();
+
+private slots:
+    void readyRead();
+    void finished();
+private:
+};
+
+class UploadItem : public TransferItem
+{
+    Q_OBJECT
+public:
+    UploadItem(const QNetworkRequest &r, const QString &user, const QString &password, QNetworkAccessManager &nam, QFile *f, TransferItem::Method method);
+    ~UploadItem();
+private slots:
+    void finished();
+};
+
+class DownloadManager : public QObject
+{
+    Q_OBJECT
+public:
+    DownloadManager();
+    ~DownloadManager();
+    void get(const QNetworkRequest &request, const QString &user, const QString &password);
+    void upload(const QNetworkRequest &request, const QString &user, const QString &password, const QString &filename, TransferItem::Method method);
+    void setProxy(const QNetworkProxy &proxy) { nam.setProxy(proxy); }
+    void setProxyUser(const QString &user) { proxyUser = user; }
+    void setProxyPassword(const QString &password) { proxyPassword = password; }
+    enum QueueMode { Parallel, Serial };
+    void setQueueMode(QueueMode mode);
+
+public slots:
+    void checkForAllDone();
+
+private slots:
+    void finished(QNetworkReply *reply);
+    void authenticationRequired(QNetworkReply *reply, QAuthenticator *authenticator);
+    void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator);
+#ifndef QT_NO_SSL
+    void sslErrors(QNetworkReply *reply, const QList<QSslError> &errors);
+#endif
+    void downloadFinished(TransferItem *item);
+private:
+    TransferItem *findTransfer(QNetworkReply *reply);
+
+    QNetworkAccessManager nam;
+    QList<TransferItem*> transfers;
+    QString proxyUser;
+    QString proxyPassword;
+    QueueMode queueMode;
+};
+
+#endif // QGET_H

tests/manual/qnetworkaccessmanager/qget/qget.pro

@@ -0,0 +1,8 @@
+TEMPLATE = app
+QT = core network
+CONFIG += console
+
+SOURCES += qget.cpp
+SOURCES += transferitem.cpp
+SOURCES += downloadmanager.cpp
+HEADERS += qget.h

tests/manual/qnetworkaccessmanager/qget/transferitem.cpp

@@ -0,0 +1,124 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "qget.h"
+#include <QDebug>
+
+TransferItem::TransferItem(const QNetworkRequest &r, const QString &u, const QString &p, QNetworkAccessManager &n, Method m)
+    : method(m), request(r), reply(0), nam(n), inputFile(0), outputFile(0), user(u), password(p)
+{
+}
+
+void TransferItem::progress(qint64 sent, qint64 total)
+{
+    if (total > 0)
+        qDebug() << (sent*100/total) << '%';
+    else
+        qDebug() << sent << 'B';
+}
+
+void TransferItem::start()
+{
+    switch (method) {
+    case Get:
+        reply = nam.get(request);
+        connect(reply, SIGNAL(readyRead()), this, SLOT(readyRead()));
+        connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(progress(qint64,qint64)));
+        break;
+    case Put:
+        reply = nam.put(request, inputFile);
+        connect(reply, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(progress(qint64,qint64)));
+        break;
+    case Post:
+        reply = nam.post(request, inputFile);
+        connect(reply, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(progress(qint64,qint64)));
+        break;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(finished()));
+}
+
+DownloadItem::DownloadItem(const QNetworkRequest &r, const QString &user, const QString &password, QNetworkAccessManager &manager)
+    : TransferItem(r, user, password, manager, Get)
+{
+}
+
+DownloadItem::~DownloadItem()
+{
+}
+
+void DownloadItem::readyRead()
+{
+    if (!outputFile)
+        outputFile = new QFile(this);
+    if (!outputFile->isOpen()) {
+        qDebug() << reply->header(QNetworkRequest::ContentTypeHeader) << reply->header(QNetworkRequest::ContentLengthHeader);
+        QString path = reply->url().path();
+        path = path.mid(path.lastIndexOf('/') + 1);
+        if (path.isEmpty())
+            path = QLatin1String("index.html");
+        outputFile->setFileName(path);
+        for (int i=1;i<1000;i++) {
+            if (!outputFile->exists() && outputFile->open(QIODevice::WriteOnly | QIODevice::Truncate))
+                break;
+            outputFile->setFileName(QString(QLatin1String("%1.%2")).arg(path).arg(i));
+        }
+        if (!outputFile->isOpen()) {
+            qDebug() << "couldn't open output file";
+            reply->abort();
+            return;
+        }
+        qDebug() << reply->url() << " -> " << outputFile->fileName();
+    }
+    outputFile->write(reply->readAll());
+}
+
+void DownloadItem::finished()
+{
+    if (reply->attribute(QNetworkRequest::RedirectionTargetAttribute).isValid()) {
+        QUrl url = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
+        url = reply->url().resolved(url);
+        qDebug() << reply->url() << "redirected to " << url;
+        if (redirects.contains(url)) {
+            qDebug() << "redirect loop detected";
+        } else if (redirects.count() > 10) {
+            qDebug() << "too many redirects";
+        } else {
+            //follow redirect
+            if (outputFile && outputFile->isOpen()) {
+                if (!outputFile->seek(0) || !outputFile->resize(0)) {
+                    outputFile->close();
+                    outputFile->remove();
+                }
+            }
+            reply->deleteLater();
+            reply = nam.get(QNetworkRequest(url));
+            reply->setParent(this);
+            connect(reply, SIGNAL(readyRead()), this, SLOT(readyRead()));
+            connect(reply, SIGNAL(finished()), this, SLOT(finished()));
+            redirects.append(url);
+            return;
+        }
+    }
+    if (outputFile && outputFile->isOpen()) {
+        outputFile->write(reply->readAll());
+        outputFile->close();
+    }
+    emit downloadFinished(this);
+}
+
+UploadItem::UploadItem(const QNetworkRequest &r, const QString &user, const QString &password, QNetworkAccessManager &n, QFile *f, TransferItem::Method method)
+    : TransferItem(r,user, password, n,method)
+{
+    inputFile = f;
+    f->setParent(this);
+    qDebug() << f->fileName() << f->isOpen() << f->size();
+}
+
+UploadItem::~UploadItem()
+{
+}
+
+void UploadItem::finished()
+{
+    emit downloadFinished(this);
+}