Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

4 files changed, 574 insertions, 0 deletions

diff --git a/tests/manual/network_remote_stresstest/network_remote_stresstest.pro b/tests/manual/network_remote_stresstest/network_remote_stresstest.pro
new file mode 100644
index 0000000000..9ed1090533
--- /dev/null
+++ b/tests/manual/network_remote_stresstest/network_remote_stresstest.pro
@@ -0,0 +1,8 @@
+load(qttest_p4)
+
+QT = core network
+
+SOURCES  += tst_network_remote_stresstest.cpp
+
+RESOURCES += url-list.qrc
+
diff --git a/tests/manual/network_remote_stresstest/tst_network_remote_stresstest.cpp b/tests/manual/network_remote_stresstest/tst_network_remote_stresstest.cpp
new file mode 100644
index 0000000000..06ebf444f7
--- /dev/null
+++ b/tests/manual/network_remote_stresstest/tst_network_remote_stresstest.cpp
@@ -0,0 +1,499 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QtCore/QThread>
+#include <QtCore/QSemaphore>
+#include <QtCore/QElapsedTimer>
+#include <QtCore/QSharedPointer>
+#include <QtCore/QVector>
+#include <QtNetwork/QTcpSocket>
+#include <QtNetwork/QSslSocket>
+#include <QtNetwork/QNetworkReply>
+#include <QtNetwork/QNetworkAccessManager>
+
+#ifdef QT_BUILD_INTERNAL
+# include <private/qnetworkaccessmanager_p.h>
+#endif
+
+#include <qplatformdefs.h>
+#ifdef Q_OS_UNIX
+# include <sys/types.h>
+# include <sys/socket.h>
+# include <sys/select.h>
+# include <netinet/in.h>
+# include <errno.h>
+# include <netdb.h>
+# include <signal.h>
+# include <unistd.h>
+# include <fcntl.h>
+
+typedef int SOCKET;
+# define INVALID_SOCKET -1
+# define SOCKET_ERROR -1
+
+#elif defined(Q_OS_WIN)
+# include <winsock2.h>
+#endif
+
+Q_DECLARE_METATYPE(QVector<QUrl>)
+
+class tst_NetworkRemoteStressTest : public QObject
+{
+    Q_OBJECT
+public:
+    enum { AttemptCount = 100 };
+    tst_NetworkRemoteStressTest();
+
+    qint64 byteCounter;
+    QNetworkAccessManager manager;
+    QVector<QUrl> httpUrls, httpsUrls, mixedUrls;
+    bool intermediateDebug;
+
+private:
+    void clearManager();
+
+public slots:
+    void initTestCase_data();
+    void init();
+
+    void slotReadAll() { byteCounter += static_cast<QIODevice *>(sender())->readAll().size(); }
+
+private Q_SLOTS:
+    void blockingSequentialRemoteHosts();
+    void sequentialRemoteHosts();
+    void parallelRemoteHosts_data();
+    void parallelRemoteHosts();
+    void namRemoteGet_data();
+    void namRemoteGet();
+};
+
+tst_NetworkRemoteStressTest::tst_NetworkRemoteStressTest()
+    : intermediateDebug(qgetenv("STRESSDEBUG").toInt() > 0)
+{
+#ifdef Q_OS_WIN
+    WSAData wsadata;
+
+    // IPv6 requires Winsock v2.0 or better.
+    WSAStartup(MAKEWORD(2,0), &wsadata);
+#elif defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
+    ::signal(SIGALRM, SIG_IGN);
+#endif
+
+    QFile urlList(":/url-list.txt");
+    if (urlList.open(QIODevice::ReadOnly)) {
+        while (!urlList.atEnd()) {
+            QByteArray line = urlList.readLine().trimmed();
+            QUrl url = QUrl::fromEncoded(line);
+            if (url.scheme() == "http") {
+                httpUrls << url;
+                mixedUrls << url;
+            } else if (url.scheme() == "https") {
+                httpsUrls << url;
+                mixedUrls << url;
+            }
+        }
+    }
+
+    httpUrls << httpUrls;
+    httpsUrls << httpsUrls;
+}
+
+void tst_NetworkRemoteStressTest::initTestCase_data()
+{
+    QTest::addColumn<QVector<QUrl> >("urlList");
+    QTest::addColumn<bool>("useSslSocket");
+
+    QTest::newRow("no-ssl") << httpUrls << false;
+//    QTest::newRow("no-ssl-in-sslsocket") << httpUrls << true;
+    QTest::newRow("ssl") << httpsUrls << true;
+    QTest::newRow("mixed") << mixedUrls << false;
+//    QTest::newRow("mixed-in-sslsocket") << mixedUrls << true;
+}
+
+void tst_NetworkRemoteStressTest::init()
+{
+    // clear the internal cache
+#ifndef QT_BUILD_INTERNAL
+    if (strncmp(QTest::currentTestFunction(), "nam") == 0)
+        QSKIP("QNetworkAccessManager tests disabled", SkipAll);
+#endif
+}
+
+void tst_NetworkRemoteStressTest::clearManager()
+{
+#ifdef QT_BUILD_INTERNAL
+    QNetworkAccessManagerPrivate::clearCache(&manager);
+    manager.setProxy(QNetworkProxy());
+    manager.setCache(0);
+#endif
+}
+
+bool nativeLookup(const char *hostname, int port, QByteArray &buf)
+{
+#if !defined(QT_NO_GETADDRINFO) && 0
+    addrinfo *res = 0;
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = PF_UNSPEC;
+
+    int result = getaddrinfo(QUrl::toAce(hostname).constData(), QByteArray::number(port).constData(), &hints, &res);
+    if (!result)
+        return false;
+    for (addrinfo *node = res; node; node = node->ai_next) {
+        if (node->ai_family == AF_INET) {
+            buf = QByteArray((char *)node->ai_addr, node->ai_addrlen);
+            break;
+        }
+    }
+    freeaddrinfo(res);
+#else
+    hostent *result = gethostbyname(hostname);
+    if (!result || result->h_addrtype != AF_INET)
+        return false;
+
+    struct sockaddr_in s;
+    s.sin_family = AF_INET;
+    s.sin_port = htons(port);
+    s.sin_addr =  *(struct in_addr *) result->h_addr_list[0];
+
+    buf = QByteArray((char *)&s, sizeof s);
+#endif
+
+    return !buf.isEmpty();
+}
+
+bool nativeSelect(int fd, int timeout, bool selectForWrite)
+{
+    if (timeout < 0)
+        return false;
+
+    // wait for connected
+    fd_set fds, fde;
+    FD_ZERO(&fds);
+    FD_ZERO(&fde);
+    FD_SET(fd, &fds);
+    FD_SET(fd, &fde);
+
+    int ret;
+    do {
+        struct timeval tv;
+        tv.tv_sec = timeout / 1000;
+        tv.tv_usec = timeout % 1000;
+        if (selectForWrite)
+            ret = ::select(fd + 1, 0, &fds, &fde, &tv);
+        else
+            ret = ::select(fd + 1, &fds, 0, &fde, &tv);
+    } while (ret == -1 && errno == EINTR);
+    return ret != 0;
+}
+
+void tst_NetworkRemoteStressTest::blockingSequentialRemoteHosts()
+{
+    QFETCH_GLOBAL(QVector<QUrl>, urlList);
+    QFETCH_GLOBAL(bool, useSslSocket);
+
+    qint64 totalBytes = 0;
+    QElapsedTimer outerTimer;
+    outerTimer.start();
+
+    for (int i = 0; i < urlList.size(); ++i) {
+        const QUrl &url = urlList.at(i);
+        bool isHttps = url.scheme() == "https";
+        QElapsedTimer timeout;
+        byteCounter = 0;
+        timeout.start();
+
+        QSharedPointer<QTcpSocket> socket;
+        if (useSslSocket || isHttps) {
+            socket = QSharedPointer<QTcpSocket>(new QSslSocket);
+        } else {
+            socket = QSharedPointer<QTcpSocket>(new QTcpSocket);
+        }
+
+        socket->connectToHost(url.host(), url.port(isHttps ? 443 : 80));
+        QVERIFY2(socket->waitForConnected(10000), "Timeout connecting to " + url.encodedHost());
+
+        if (isHttps) {
+            static_cast<QSslSocket *>(socket.data())->setProtocol(QSsl::TlsV1);
+            static_cast<QSslSocket *>(socket.data())->startClientEncryption();
+            static_cast<QSslSocket *>(socket.data())->ignoreSslErrors();
+            QVERIFY2(static_cast<QSslSocket *>(socket.data())->waitForEncrypted(10000), "Timeout starting TLS with " + url.encodedHost());
+        }
+
+        socket->write("GET " + url.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemoveFragment) + " HTTP/1.0\r\n"
+                      "Connection: close\r\n"
+                      "User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
+                      "Host: " + url.encodedHost() + "\r\n"
+                      "\r\n");
+        while (socket->bytesToWrite())
+            QVERIFY2(socket->waitForBytesWritten(10000), "Timeout writing to " + url.encodedHost());
+
+        while (socket->state() == QAbstractSocket::ConnectedState && !timeout.hasExpired(10000)) {
+            socket->waitForReadyRead(10000);
+            byteCounter += socket->readAll().size(); // discard
+        }
+        QVERIFY2(!timeout.hasExpired(10000), "Timeout reading from " + url.encodedHost());
+
+        totalBytes += byteCounter;
+        if (intermediateDebug) {
+            double rate = (byteCounter * 1.0 / timeout.elapsed());
+            qDebug() << i << url << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
+                    << (rate / 1024.0 * 1000) << "kB/s";
+        }
+    }
+    qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 * 1000 / outerTimer.elapsed()) << "kB/s";
+}
+
+void tst_NetworkRemoteStressTest::sequentialRemoteHosts()
+{
+    QFETCH_GLOBAL(QVector<QUrl>, urlList);
+    QFETCH_GLOBAL(bool, useSslSocket);
+
+    qint64 totalBytes = 0;
+    QElapsedTimer outerTimer;
+    outerTimer.start();
+
+    for (int i = 0; i < urlList.size(); ++i) {
+        const QUrl &url = urlList.at(i);
+        bool isHttps = url.scheme() == "https";
+        QElapsedTimer timeout;
+        byteCounter = 0;
+        timeout.start();
+
+        QSharedPointer<QTcpSocket> socket;
+        if (useSslSocket || isHttps) {
+            socket = QSharedPointer<QTcpSocket>(new QSslSocket);
+        } else {
+            socket = QSharedPointer<QTcpSocket>(new QTcpSocket);
+        }
+        if (isHttps) {
+            static_cast<QSslSocket *>(socket.data())->setProtocol(QSsl::TlsV1);
+            static_cast<QSslSocket *>(socket.data())->connectToHostEncrypted(url.host(), url.port(443));
+            static_cast<QSslSocket *>(socket.data())->ignoreSslErrors();
+        } else {
+            socket->connectToHost(url.host(), url.port(80));
+        }
+
+        socket->write("GET " + url.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemoveFragment) + " HTTP/1.0\r\n"
+                      "Connection: close\r\n"
+                      "User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
+                      "Host: " + url.encodedHost() + "\r\n"
+                      "\r\n");
+        connect(socket.data(), SIGNAL(readyRead()), SLOT(slotReadAll()));
+
+        QTestEventLoop::instance().connect(socket.data(), SIGNAL(disconnected()), SLOT(exitLoop()));
+        QTestEventLoop::instance().enterLoop(30);
+        QVERIFY2(!QTestEventLoop::instance().timeout(), "Timeout with " + url.encodedHost() + "; "
+                 + QByteArray::number(socket->bytesToWrite()) + " bytes to write");
+
+        totalBytes += byteCounter;
+        if (intermediateDebug) {
+            double rate = (byteCounter * 1.0 / timeout.elapsed());
+            qDebug() << i << url << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
+                    << (rate / 1024.0 * 1000) << "kB/s";
+        }
+    }
+    qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 * 1000 / outerTimer.elapsed()) << "kB/s";
+}
+
+void tst_NetworkRemoteStressTest::parallelRemoteHosts_data()
+{
+    QTest::addColumn<int>("parallelAttempts");
+    QTest::newRow("1") << 1;
+    QTest::newRow("2") << 2;
+    QTest::newRow("4") << 4;
+    QTest::newRow("5") << 5;
+    QTest::newRow("6") << 6;
+    QTest::newRow("8") << 8;
+    QTest::newRow("10") << 10;
+    QTest::newRow("25") << 25;
+    QTest::newRow("500") << 500;
+}
+
+void tst_NetworkRemoteStressTest::parallelRemoteHosts()
+{
+    QFETCH_GLOBAL(QVector<QUrl>, urlList);
+    QFETCH_GLOBAL(bool, useSslSocket);
+
+    QFETCH(int, parallelAttempts);
+
+    qint64 totalBytes = 0;
+    QElapsedTimer outerTimer;
+    outerTimer.start();
+
+    QVector<QUrl>::ConstIterator it = urlList.constBegin();
+    while (it != urlList.constEnd()) {
+        QElapsedTimer timeout;
+        byteCounter = 0;
+        timeout.start();
+
+        QVector<QSharedPointer<QTcpSocket> > sockets;
+        sockets.reserve(parallelAttempts);
+        for (int j = 0; j < parallelAttempts && it != urlList.constEnd(); ++j, ++it) {
+            const QUrl &url = *it;
+            bool isHttps = url.scheme() == "https";
+            QTcpSocket *socket;
+            if (useSslSocket || isHttps)
+                socket = new QSslSocket;
+            else
+                socket = new QTcpSocket;
+            if (isHttps) {
+                static_cast<QSslSocket *>(socket)->setProtocol(QSsl::TlsV1);
+                static_cast<QSslSocket *>(socket)->connectToHostEncrypted(url.host(), url.port(443));
+                static_cast<QSslSocket *>(socket)->ignoreSslErrors();
+            } else {
+                socket->connectToHost(url.host(), url.port(isHttps ? 443 : 80));
+            }
+
+            socket->write("GET " + url.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemoveFragment) + " HTTP/1.0\r\n"
+                          "Connection: close\r\n"
+                          "User-Agent: tst_QTcpSocket_stresstest/1.0\r\n"
+                          "Host: " + url.encodedHost() + "\r\n"
+                          "\r\n");
+            connect(socket, SIGNAL(readyRead()), SLOT(slotReadAll()));
+            QTestEventLoop::instance().connect(socket, SIGNAL(disconnected()), SLOT(exitLoop()));
+            socket->setProperty("remoteUrl", url);
+
+            sockets.append(QSharedPointer<QTcpSocket>(socket));
+        }
+
+        while (!timeout.hasExpired(10000)) {
+            QTestEventLoop::instance().enterLoop(10);
+            int done = 0;
+            for (int j = 0; j < sockets.size(); ++j)
+                done += sockets[j]->state() == QAbstractSocket::UnconnectedState ? 1 : 0;
+            if (done == sockets.size())
+                break;
+        }
+        for (int j = 0; j < sockets.size(); ++j)
+            if (sockets[j]->state() != QAbstractSocket::UnconnectedState) {
+                qDebug() << "Socket to" << sockets[j]->property("remoteUrl").toUrl() << "still open with"
+                        << sockets[j]->bytesToWrite() << "bytes to write";
+                QFAIL("Timed out");
+            }
+
+        totalBytes += byteCounter;
+        if (intermediateDebug) {
+            double rate = (byteCounter * 1.0 / timeout.elapsed());
+            qDebug() << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
+                    << (rate / 1024.0 * 1000) << "kB/s";
+        }
+    }
+    qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 * 1000 / outerTimer.elapsed()) << "kB/s";
+}
+
+void tst_NetworkRemoteStressTest::namRemoteGet_data()
+{
+    QTest::addColumn<int>("parallelAttempts");
+    QTest::newRow("1") << 1;
+    QTest::newRow("2") << 2;
+    QTest::newRow("4") << 4;
+    QTest::newRow("5") << 5;
+    QTest::newRow("6") << 6;
+    QTest::newRow("8") << 8;
+    QTest::newRow("10") << 10;
+    QTest::newRow("25") << 25;
+    QTest::newRow("500") << 500;
+}
+
+void tst_NetworkRemoteStressTest::namRemoteGet()
+{
+    QFETCH_GLOBAL(QVector<QUrl>, urlList);
+
+    QFETCH(int, parallelAttempts);
+    bool pipelineAllowed = false;// QFETCH(bool, pipelineAllowed);
+
+    qint64 totalBytes = 0;
+    QElapsedTimer outerTimer;
+    outerTimer.start();
+
+    QVector<QUrl>::ConstIterator it = urlList.constBegin();
+    while (it != urlList.constEnd()) {
+        QElapsedTimer timeout;
+        byteCounter = 0;
+        timeout.start();
+
+        QNetworkRequest req;
+        req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, pipelineAllowed);
+
+        QVector<QSharedPointer<QNetworkReply> > replies;
+        replies.reserve(parallelAttempts);
+        for (int j = 0; j < parallelAttempts && it != urlList.constEnd(); ++j) {
+            req.setUrl(*it++);
+            QNetworkReply *r = manager.get(req);
+            r->ignoreSslErrors();
+
+            connect(r, SIGNAL(readyRead()), SLOT(slotReadAll()));
+            QTestEventLoop::instance().connect(r, SIGNAL(finished()), SLOT(exitLoop()));
+
+            replies.append(QSharedPointer<QNetworkReply>(r));
+        }
+
+        while (!timeout.hasExpired(30000)) {
+            QTestEventLoop::instance().enterLoop(30 - timeout.elapsed() / 1000);
+            int done = 0;
+            for (int j = 0; j < replies.size(); ++j)
+                done += replies[j]->isFinished() ? 1 : 0;
+            if (done == replies.size())
+                break;
+        }
+        if (timeout.hasExpired(30000)) {
+            for (int j = 0; j < replies.size(); ++j)
+                if (!replies[j]->isFinished())
+                    qDebug() << "Request" << replies[j]->url() << "not finished";
+            QFAIL("Timed out");
+        }
+        replies.clear();
+
+        totalBytes += byteCounter;
+        if (intermediateDebug) {
+            double rate = (byteCounter * 1.0 / timeout.elapsed());
+            qDebug() << byteCounter << "bytes in" << timeout.elapsed() << "ms:"
+                    << (rate / 1024.0 * 1000) << "kB/s";
+        }
+    }
+    qDebug() << "Average transfer rate was" << (totalBytes / 1024.0 * 1000 / outerTimer.elapsed()) << "kB/s";
+}
+
+QTEST_MAIN(tst_NetworkRemoteStressTest);
+
+#include "tst_network_remote_stresstest.moc"
diff --git a/tests/manual/network_remote_stresstest/url-list.qrc b/tests/manual/network_remote_stresstest/url-list.qrc
new file mode 100644
index 0000000000..ec529e5970
--- /dev/null
+++ b/tests/manual/network_remote_stresstest/url-list.qrc
@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>url-list.txt</file>
+    </qresource>
+</RCC>
diff --git a/tests/manual/network_remote_stresstest/url-list.txt b/tests/manual/network_remote_stresstest/url-list.txt
new file mode 100644
index 0000000000..edbf7e1165
--- /dev/null
+++ b/tests/manual/network_remote_stresstest/url-list.txt
@@ -0,0 +1,62 @@
+http://www.digicert.com/CACerts/DigiCertAssuredIDRootCA.crt
+http://www.digicert.com/CACerts/DigiCertGlobalRootCA.crt
+http://www.digicert.com/CACerts/DigiCertHighAssuranceEVRootCA.crt
+http://www.quovadis.bm/public/qvrca2.crt
+http://www.quovadis.bm/public/qvrca3.crt
+https://secure.globalsign.net/cacert/root-r2.crt
+http://secure.globalsign.net/cacert/Root-R1.crt
+http://www.certplus.com/PC/certplus_class2.pem
+https://www.startssl.com/certs/ca.crt
+http://www.turktrust.com.tr/sertifikalar/TURKTRUST_Elektronik_Sertifika_Hizmet_Saglayicisi.crt
+http://www.turktrust.com.tr/sertifikalar/kok_s2.crt
+http://crt.comodoca.com/COMODOCertificationAuthority.crt
+http://crt.comodoca.com/COMODOECCCertificationAuthority.crt
+https://bugzilla.mozilla.org/attachment.cgi?id=368998
+https://bugzilla.mozilla.org/attachment.cgi?id=335538
+https://bugzilla.mozilla.org/attachment.cgi?id=304810
+https://www.securetrust.com/legal/STCA.txt
+https://www.securetrust.com/legal/SGCA.txt
+http://www.securetrust.com/legal/XGCA.txt
+http://www.diginotar.nl/files/Rootcertificaten/DigiNotar%20root%20CA2007.crt
+https://bugzilla.mozilla.org/attachment.cgi?id=294057
+https://bugzilla.mozilla.org/attachment.cgi?id=368997
+https://bugzilla.mozilla.org/attachment.cgi?id=306731
+https://certs.starfieldtech.com/repository/valicert_class2_root.crt
+https://certs.godaddy.com/repository/gd-class2-root.crt
+https://certs.starfieldtech.com/repository/sf-class2-root.crt
+ftp://ftp.networksolutions.com/certs/netsolevroot.crt
+https://bugzilla.mozilla.org/attachment.cgi?id=335551
+https://bugzilla.mozilla.org/attachment.cgi?id=369000
+https://bugzilla.mozilla.org/attachment.cgi?id=306736
+https://bugzilla.mozilla.org/attachment.cgi?id=267983
+https://swisssign.net/cgi-bin/authority/download?ca=50AFCC078715476F38C5B465D1DE95AAE9DF9CCC&into=browser
+https://swisssign.net/cgi-bin/authority/download?ca=5B257B96A465517EB839F3C078665EE83AE7F0EE&into=browser
+https://swisssign.net/cgi-bin/authority/download?ca=17A0CDC1E441B63A5B3BCB459DBD1CC298FA8658&into=browser
+http://apps.identrust.com/roots/DSTROOTCAX3.cer
+https://bugzilla.mozilla.org/attachment.cgi?id=277051
+http://www.ssi.gouv.fr/IMG/crt/igca-rsa.crt
+http://www.e-szigno.hu/RootCA.crt
+http://www.s-trust.de/service_support/zertifikatsmanagement/verzeichnisdienste/download_wurzelzertifikate/ordner_crt_dateien/authentication.crt
+http://www.trustcenter.de/media/class_2_ii.der
+http://www.trustcenter.de/media/class_3_ii.der
+http://www.trustcenter.de/media/Universal_CA-I.der
+http://www.certigna.fr/ca/ACcertigna.crt
+https://repository.secomtrust.net/EV-Root1/EVRoot1ca.cer
+http://fedir.comsign.co.il/cacert/ComsignCA.crt
+http://fedir.comsign.co.il/cacert/ComsignSecuredCA.crt
+http://crl.pki.wellsfargo.com/wsprca.crt
+http://cacert.omniroot.com/ct_root_ss.crt
+http://www.kamusm.gov.tr/BilgiDeposu/KOKSHS.v3.crt
+https://bugzilla.mozilla.org/attachment.cgi?id=380381
+http://210.71.154.6/download/ROOTeCA.cer
+https://bugzilla.mozilla.org/attachment.cgi?id=359654
+http://www.gpki.go.jp/apcaself/APCAroot.der
+https://bugzilla.mozilla.org/attachment.cgi?id=405525
+https://bugzilla.mozilla.org/attachment.cgi?id=361508
+https://bugzilla.mozilla.org/attachment.cgi?id=361508
+http://www.hongkongpost.gov.hk/product/download/root/img/smartid_rt.cacert
+http://www.sk.ee/files/JUUR-SK.der
+https://bugzilla.mozilla.org/attachment.cgi?id=408102
+http://www.disig.eu/ca/cert/ca_disig.der
+https://bugzilla.mozilla.org/attachment.cgi?id=365241
+https://www2.jcsinc.co.jp/repository/certs/SSAD-rca.der