~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

QVERIFY(certificate.subjectInfo(QSslCertificate::CommonName).contains(QString(QtNetworkSettings::serverLocalName() + ".*." + QtNetworkSettings::serverDomainName())));

1357

QVERIFY(certificate.issuerInfo(QSslCertificate::CommonName).contains(QtNetworkSettings::serverName()));

1358

1359

socket->close();

1360

}

1361

1362

class SslServer2 : public QTcpServer

1363

{

1364

protected:

1365

void incomingConnection(qintptr socketDescriptor)

1366

{

1367

QSslSocket *socket = new QSslSocket(this);

1368

socket->ignoreSslErrors();

1369

1370

// Only set the certificate

1371

QList<QSslCertificate> localCert = QSslCertificate::fromPath(SRCDIR "certs/fluke.cert");

1372

QVERIFY(!localCert.isEmpty());

1373

QVERIFY(localCert.first().handle());

1374

socket->setLocalCertificate(localCert.first());

1375

1376

QVERIFY(socket->setSocketDescriptor(socketDescriptor, QAbstractSocket::ConnectedState));

1377

1378

socket->startServerEncryption();

1379

}

1380

};

1381

1382

void tst_QSslSocket::setEmptyKey()

1383

{

1384

if (!QSslSocket::supportsSsl())

1385

return;

1386

1387

QFETCH_GLOBAL(bool, setProxy);

1388

if (setProxy)

1389

return;

1390

1391

SslServer2 server;

1392

server.listen();

1393

1394

QSslSocket socket;

1395

socket.connectToHostEncrypted("127.0.0.1", server.serverPort());

1396

1397

QTestEventLoop::instance().enterLoop(2);

1398

1399

QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);

1400

QCOMPARE(socket.error(), QAbstractSocket::UnknownSocketError);

1401

}

1402

1403

void tst_QSslSocket::spontaneousWrite()

1404

{

1405

QFETCH_GLOBAL(bool, setProxy);

1406

if (setProxy)

1407

return;

1408

1409

SslServer server;

1410

QSslSocket *receiver = new QSslSocket(this);

1411

connect(receiver, SIGNAL(readyRead()), SLOT(exitLoop()));

1412

1413

// connect two sockets to each other:

1414

QVERIFY(server.listen(QHostAddress::LocalHost));

1415

receiver->connectToHost("127.0.0.1", server.serverPort());

1416

QVERIFY(receiver->waitForConnected(5000));

1417

QVERIFY(server.waitForNewConnection(0));

1418

1419

QSslSocket *sender = server.socket;

1420

QVERIFY(sender);

1421

QVERIFY(sender->state() == QAbstractSocket::ConnectedState);

1422

receiver->setObjectName("receiver");

1423

sender->setObjectName("sender");

1424

receiver->ignoreSslErrors();

1425

receiver->startClientEncryption();

1426

1427

// SSL handshake:

1428

connect(receiver, SIGNAL(encrypted()), SLOT(exitLoop()));

1429

enterLoop(1);

1430

QVERIFY(!timeout());

1431

QVERIFY(sender->isEncrypted());

1432

QVERIFY(receiver->isEncrypted());

1433

1434

// make sure there's nothing to be received on the sender:

1435

while (sender->waitForReadyRead(10) || receiver->waitForBytesWritten(10)) {}

1436

1437

// spontaneously write something:

1438

QByteArray data("Hello World");

1439

sender->write(data);

1440

1441

// check if the other side receives it:

1442

enterLoop(1);

1443

QVERIFY(!timeout());

1444

QCOMPARE(receiver->bytesAvailable(), qint64(data.size()));

1445

QCOMPARE(receiver->readAll(), data);

1446

}

1447

1448

void tst_QSslSocket::setReadBufferSize()

1449

{

1450

QFETCH_GLOBAL(bool, setProxy);

1451

if (setProxy)

1452

return;

1453

1454

SslServer server;

1455

QSslSocket *receiver = new QSslSocket(this);

1456

connect(receiver, SIGNAL(readyRead()), SLOT(exitLoop()));

1457

1458

// connect two sockets to each other:

1459

QVERIFY(server.listen(QHostAddress::LocalHost));

1460

receiver->connectToHost("127.0.0.1", server.serverPort());

1461

QVERIFY(receiver->waitForConnected(5000));

1462

QVERIFY(server.waitForNewConnection(0));

1463

1464

QSslSocket *sender = server.socket;

1465

QVERIFY(sender);

1466

QVERIFY(sender->state() == QAbstractSocket::ConnectedState);

1467

receiver->setObjectName("receiver");

1468

sender->setObjectName("sender");

1469

receiver->ignoreSslErrors();

1470

receiver->startClientEncryption();

1471

1472

// SSL handshake:

1473

connect(receiver, SIGNAL(encrypted()), SLOT(exitLoop()));

1474

enterLoop(1);

1475

QVERIFY(!timeout());

1476

QVERIFY(sender->isEncrypted());

1477

QVERIFY(receiver->isEncrypted());

1478

1479

QByteArray data(2048, 'b');

1480

receiver->setReadBufferSize(39 * 1024); // make it a non-multiple of the data.size()

1481

1482

// saturate the incoming buffer

1483

while (sender->state() == QAbstractSocket::ConnectedState &&

1484

receiver->state() == QAbstractSocket::ConnectedState &&

1485

receiver->bytesAvailable() < receiver->readBufferSize()) {

1486

sender->write(data);

1487

//qDebug() << receiver->bytesAvailable() << "<" << receiver->readBufferSize() << (receiver->bytesAvailable() < receiver->readBufferSize());

1488

1489

while (sender->bytesToWrite())

1490

QVERIFY(sender->waitForBytesWritten(10));

1491

1492

// drain it:

1493

while (receiver->bytesAvailable() < receiver->readBufferSize() &&

1494

receiver->waitForReadyRead(10)) {}

1495

}

1496

1497

//qDebug() << sender->bytesToWrite() << "bytes to write";

1498

//qDebug() << receiver->bytesAvailable() << "bytes available";

1499

1500

// send a bit more

1501

sender->write(data);

1502

sender->write(data);

1503

sender->write(data);

1504

sender->write(data);

1505

QVERIFY(sender->waitForBytesWritten(10));

1506

1507

qint64 oldBytesAvailable = receiver->bytesAvailable();

1508

1509

// now unset the read buffer limit and iterate

1510

receiver->setReadBufferSize(0);

1511

enterLoop(1);

1512

QVERIFY(!timeout());

1513

1514

QVERIFY(receiver->bytesAvailable() > oldBytesAvailable);

1515

}

1516

1517

class SetReadBufferSize_task_250027_handler : public QObject {

1518

Q_OBJECT

1519

public slots:

1520

void readyReadSlot() {

1521

QTestEventLoop::instance().exitLoop();

1522

}

1523

void waitSomeMore(QSslSocket *socket) {

1524

QTime t;

1525

t.start();

1526

while (!socket->encryptedBytesAvailable()) {

1527

QCoreApplication::processEvents(QEventLoop::AllEvents | QEventLoop::WaitForMoreEvents, 250);

1528

if (t.elapsed() > 1000 || socket->state() != QAbstractSocket::ConnectedState)

1529

return;

1530

}

1531

}

1532

};

1533

1534

void tst_QSslSocket::setReadBufferSize_task_250027()

1535

{

1536

// do not execute this when a proxy is set.

1537

QFETCH_GLOBAL(bool, setProxy);

1538

if (setProxy)

1539

return;

1540

1541

QSslSocketPtr socket = newSocket();

1542

socket->setReadBufferSize(1000); // limit to 1 kb/sec

1543

socket->ignoreSslErrors();

1544

socket->connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1545

socket->ignoreSslErrors();

1546

QVERIFY(socket->waitForConnected(10*1000));

1547

QVERIFY(socket->waitForEncrypted(10*1000));

1548

1549

// exit the event loop as soon as we receive a readyRead()

1550

SetReadBufferSize_task_250027_handler setReadBufferSize_task_250027_handler;

1551

connect(socket.data(), SIGNAL(readyRead()), &setReadBufferSize_task_250027_handler, SLOT(readyReadSlot()));

1552

1553

// provoke a response by sending a request

1554

socket->write("GET /qtest/fluke.gif HTTP/1.0\n"); // this file is 27 KB

1555

socket->write("Host: ");

1556

socket->write(QtNetworkSettings::serverName().toLocal8Bit().constData());

1557

socket->write("\n");

1558

socket->write("Connection: close\n");

1559

socket->write("\n");

1560

socket->flush();

1561

1562

QTestEventLoop::instance().enterLoop(10);

1563

setReadBufferSize_task_250027_handler.waitSomeMore(socket.data());

1564

QByteArray firstRead = socket->readAll();

1565

// First read should be some data, but not the whole file

1566

QVERIFY(firstRead.size() > 0 && firstRead.size() < 20*1024);

1567

1568

QTestEventLoop::instance().enterLoop(10);

1569

setReadBufferSize_task_250027_handler.waitSomeMore(socket.data());

1570

QByteArray secondRead = socket->readAll();

1571

// second read should be some more data

1572

QVERIFY(secondRead.size() > 0);

1573

1574

socket->close();

1575

}

1576

1577

class SslServer3 : public QTcpServer

1578

{

1579

Q_OBJECT

1580

public:

1581

SslServer3() : socket(0) { }

1582

QSslSocket *socket;

1583

1584

protected:

1585

void incomingConnection(qintptr socketDescriptor)

1586

{

1587

socket = new QSslSocket(this);

1588

connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));

1589

1590

QFile file(SRCDIR "certs/fluke.key");

1591

QVERIFY(file.open(QIODevice::ReadOnly));

1592

QSslKey key(file.readAll(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey);

1593

QVERIFY(!key.isNull());

1594

socket->setPrivateKey(key);

1595

1596

QList<QSslCertificate> localCert = QSslCertificate::fromPath(SRCDIR "certs/fluke.cert");

1597

QVERIFY(!localCert.isEmpty());

1598

QVERIFY(localCert.first().handle());

1599

socket->setLocalCertificate(localCert.first());

1600

1601

QVERIFY(socket->setSocketDescriptor(socketDescriptor, QAbstractSocket::ConnectedState));

1602

QVERIFY(!socket->peerAddress().isNull());

1603

QVERIFY(socket->peerPort() != 0);

1604

QVERIFY(!socket->localAddress().isNull());

1605

QVERIFY(socket->localPort() != 0);

1606

}

1607

1608

protected slots:

1609

void ignoreErrorSlot()

1610

{

1611

socket->ignoreSslErrors();

1612

}

1613

};

1614

1615

class ThreadedSslServer: public QThread

1616

{

1617

Q_OBJECT

1618

public:

1619

QSemaphore dataReadSemaphore;

1620

int serverPort;

1621

bool ok;

1622

1623

ThreadedSslServer() : serverPort(-1), ok(false)

1624

{ }

1625

1626

~ThreadedSslServer()

1627

{

1628

if (isRunning()) wait(2000);

1629

QVERIFY(ok);

1630

}

1631

1632

signals:

1633

void listening();

1634

1635

protected:

1636

void run()

1637

{

1638

// if all goes well (no timeouts), this thread will sleep for a total of 500 ms

1639

// (i.e., 5 times 100 ms, one sleep for each operation)

1640

1641

SslServer3 server;

1642

server.listen(QHostAddress::LocalHost);

1643

serverPort = server.serverPort();

1644

emit listening();

1645

1646

// delayed acceptance:

1647

QTest::qSleep(100);

1648

bool ret = server.waitForNewConnection(2000);

1649

Q_UNUSED(ret);

1650

1651

// delayed start of encryption

1652

QTest::qSleep(100);

1653

QSslSocket *socket = server.socket;

1654

if (!socket || !socket->isValid())

1655

return; // error

1656

socket->ignoreSslErrors();

1657

socket->startServerEncryption();

1658

if (!socket->waitForEncrypted(2000))

1659

return; // error

1660

1661

// delayed reading data

1662

QTest::qSleep(100);

1663

if (!socket->waitForReadyRead(2000))

1664

return; // error

1665

socket->readAll();

1666

dataReadSemaphore.release();

1667

1668

// delayed sending data

1669

QTest::qSleep(100);

1670

socket->write("Hello, World");

1671

while (socket->bytesToWrite())

1672

if (!socket->waitForBytesWritten(2000))

1673

return; // error

1674

1675

// delayed replying (reading then sending)

1676

QTest::qSleep(100);

1677

if (!socket->waitForReadyRead(2000))

1678

return; // error

1679

socket->write("Hello, World");

1680

while (socket->bytesToWrite())

1681

if (!socket->waitForBytesWritten(2000))

1682

return; // error

1683

1684

// delayed disconnection:

1685

QTest::qSleep(100);

1686

socket->disconnectFromHost();

1687

if (!socket->waitForDisconnected(2000))

1688

return; // error

1689

1690

delete socket;

1691

ok = true;

1692

}

1693

};

1694

1695

void tst_QSslSocket::waitForMinusOne()

1696

{

1697

#ifdef Q_OS_WIN

1698

QSKIP("QTBUG-24451 - indefinite wait may hang");

1699

#endif

1700

QFETCH_GLOBAL(bool, setProxy);

1701

if (setProxy)

1702

return;

1703

1704

ThreadedSslServer server;

1705

connect(&server, SIGNAL(listening()), SLOT(exitLoop()));

1706

1707

// start the thread and wait for it to be ready

1708

server.start();

1709

enterLoop(1);

1710

QVERIFY(!timeout());

1711

1712

// connect to the server

1713

QSslSocket socket;

1714

QTest::qSleep(100);

1715

socket.connectToHost("127.0.0.1", server.serverPort);

1716

QVERIFY(socket.waitForConnected(-1));

1717

socket.ignoreSslErrors();

1718

socket.startClientEncryption();

1719

1720

// first verification: this waiting should take 200 ms

1721

QVERIFY2(socket.waitForEncrypted(-1), qPrintable(socket.errorString()));

1722

QVERIFY(socket.isEncrypted());

1723

QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);

1724

QCOMPARE(socket.bytesAvailable(), Q_INT64_C(0));

1725

1726

// second verification: write and make sure the other side got it (100 ms)

1727

socket.write("How are you doing?");

1728

QVERIFY(socket.bytesToWrite() != 0);

1729

QVERIFY(socket.waitForBytesWritten(-1));

1730

QVERIFY(server.dataReadSemaphore.tryAcquire(1, 2000));

1731

1732

// third verification: it should wait for 100 ms:

1733

QVERIFY(socket.waitForReadyRead(-1));

1734

QVERIFY(socket.isEncrypted());

1735

QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);

1736

QVERIFY(socket.bytesAvailable() != 0);

1737

1738

// fourth verification: deadlock prevention:

1739

// we write and then wait for reading; the other side needs to receive before

1740

// replying (100 ms delay)

1741

socket.write("I'm doing just fine!");

1742

QVERIFY(socket.bytesToWrite() != 0);

1743

QVERIFY(socket.waitForReadyRead(-1));

1744

1745

// fifth verification: it should wait for 200 ms more

1746

QVERIFY(socket.waitForDisconnected(-1));

1747

}

1748

1749

class VerifyServer : public QTcpServer

1750

{

1751

Q_OBJECT

1752

public:

1753

VerifyServer() : socket(0) { }

1754

QSslSocket *socket;

1755

1756

protected:

1757

void incomingConnection(qintptr socketDescriptor)

1758

{

1759

socket = new QSslSocket(this);

1760

1761

socket->setPrivateKey(SRCDIR "certs/fluke.key");

1762

socket->setLocalCertificate(SRCDIR "certs/fluke.cert");

1763

socket->setSocketDescriptor(socketDescriptor);

1764

socket->startServerEncryption();

1765

}

1766

};

1767

1768

void tst_QSslSocket::verifyMode()

1769

{

1770

QFETCH_GLOBAL(bool, setProxy);

1771

if (setProxy)

1772

return;

1773

1774

QSslSocket socket;

1775

QCOMPARE(socket.peerVerifyMode(), QSslSocket::AutoVerifyPeer);

1776

socket.setPeerVerifyMode(QSslSocket::VerifyNone);

1777

QCOMPARE(socket.peerVerifyMode(), QSslSocket::VerifyNone);

1778

socket.setPeerVerifyMode(QSslSocket::VerifyNone);

1779

socket.setPeerVerifyMode(QSslSocket::VerifyPeer);

1780

QCOMPARE(socket.peerVerifyMode(), QSslSocket::VerifyPeer);

1781

1782

socket.connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1783

QVERIFY(!socket.waitForEncrypted());

1784

1785

QList<QSslError> expectedErrors = QList<QSslError>()

1786

<< QSslError(QSslError::SelfSignedCertificate, socket.peerCertificate());

1787

QCOMPARE(socket.sslErrors(), expectedErrors);

1788

socket.abort();

1789

1790

VerifyServer server;

1791

server.listen();

1792

1793

QSslSocket clientSocket;

1794

clientSocket.connectToHostEncrypted("127.0.0.1", server.serverPort());

1795

clientSocket.ignoreSslErrors();

1796

1797

QEventLoop loop;

1798

QTimer::singleShot(5000, &loop, SLOT(quit()));

1799

connect(&clientSocket, SIGNAL(encrypted()), &loop, SLOT(quit()));

1800

loop.exec();

1801

1802

QVERIFY(clientSocket.isEncrypted());

1803

#if (defined(UBUNTU_ONEIRIC) && defined(__x86_64__)) || defined(Q_OS_WIN) || defined(Q_OS_MAC)

1804

QEXPECT_FAIL("", "QTBUG-24234", Abort);

1805

#endif

1806

QVERIFY(server.socket->sslErrors().isEmpty());

1807

}

1808

1809

void tst_QSslSocket::verifyDepth()

1810

{

1811

QSslSocket socket;

1812

QCOMPARE(socket.peerVerifyDepth(), 0);

1813

socket.setPeerVerifyDepth(1);

1814

QCOMPARE(socket.peerVerifyDepth(), 1);

1815

QTest::ignoreMessage(QtWarningMsg, "QSslSocket::setPeerVerifyDepth: cannot set negative depth of -1");

1816

socket.setPeerVerifyDepth(-1);

1817

QCOMPARE(socket.peerVerifyDepth(), 1);

1818

}

1819

1820

void tst_QSslSocket::peerVerifyError()

1821

{

1822

QSslSocketPtr socket = newSocket();

1823

QSignalSpy sslErrorsSpy(socket.data(), SIGNAL(sslErrors(QList<QSslError>)));

1824

QSignalSpy peerVerifyErrorSpy(socket.data(), SIGNAL(peerVerifyError(QSslError)));

1825

1826

socket->connectToHostEncrypted(QHostInfo::fromName(QtNetworkSettings::serverName()).addresses().first().toString(), 443);

1827

QVERIFY(!socket->waitForEncrypted(10000));

1828

QVERIFY(!peerVerifyErrorSpy.isEmpty());

1829

QVERIFY(!sslErrorsSpy.isEmpty());

1830

QCOMPARE(qvariant_cast<QSslError>(peerVerifyErrorSpy.last().at(0)).error(), QSslError::HostNameMismatch);

1831

QCOMPARE(qvariant_cast<QList<QSslError> >(sslErrorsSpy.at(0).at(0)).size(), peerVerifyErrorSpy.size());

1832

}

1833

1834

void tst_QSslSocket::disconnectFromHostWhenConnecting()

1835

{

1836

QSslSocketPtr socket = newSocket();

1837

socket->connectToHostEncrypted(QtNetworkSettings::serverName(), 993);

1838

socket->ignoreSslErrors();

1839

socket->write("XXXX LOGOUT\r\n");

1840

QAbstractSocket::SocketState state = socket->state();

1841

// without proxy, the state will be HostLookupState;

1842

// with proxy, the state will be ConnectingState.

1843

QVERIFY(socket->state() == QAbstractSocket::HostLookupState ||

1844

socket->state() == QAbstractSocket::ConnectingState);

1845

socket->disconnectFromHost();

1846

// the state of the socket must be the same before and after calling

1847

// disconnectFromHost()

1848

QCOMPARE(state, socket->state());

1849

QVERIFY(socket->state() == QAbstractSocket::HostLookupState ||

1850

socket->state() == QAbstractSocket::ConnectingState);

1851

QVERIFY(socket->waitForDisconnected(10000));

1852

QCOMPARE(socket->state(), QAbstractSocket::UnconnectedState);

1853

// we did not call close, so the socket must be still open

1854

QVERIFY(socket->isOpen());

1855

QCOMPARE(socket->bytesToWrite(), qint64(0));

1856

1857

// don't forget to login

1858

QCOMPARE((int) socket->write("USER ftptest\r\n"), 14);

1859

1860

}

1861

1862

void tst_QSslSocket::disconnectFromHostWhenConnected()

1863

{

1864

QSslSocketPtr socket = newSocket();

1865

socket->connectToHostEncrypted(QtNetworkSettings::serverName(), 993);

1866

socket->ignoreSslErrors();

1867

QVERIFY(socket->waitForEncrypted(5000));

1868

socket->write("XXXX LOGOUT\r\n");

1869

QCOMPARE(socket->state(), QAbstractSocket::ConnectedState);

1870

socket->disconnectFromHost();

1871

QCOMPARE(socket->state(), QAbstractSocket::ClosingState);

1872

QVERIFY(socket->waitForDisconnected(5000));

1873

QCOMPARE(socket->bytesToWrite(), qint64(0));

1874

}

1875

1876

void tst_QSslSocket::resetProxy()

1877

{

1878

QFETCH_GLOBAL(bool, setProxy);

1879

if (setProxy)

1880

return;

1881

1882

// check fix for bug 199941

1883

1884

QNetworkProxy goodProxy(QNetworkProxy::NoProxy);

1885

QNetworkProxy badProxy(QNetworkProxy::HttpProxy, "thisCannotWorkAbsolutelyNotForSure", 333);

1886

1887

// make sure the connection works, and then set a nonsense proxy, and then

1888

// make sure it does not work anymore

1889

QSslSocket socket;

1890

socket.addCaCertificates(QLatin1String(SRCDIR "certs/qt-test-server-cacert.pem"));

1891

socket.setProxy(goodProxy);

1892

socket.connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1893

QVERIFY2(socket.waitForConnected(10000), qPrintable(socket.errorString()));

1894

socket.abort();

1895

socket.setProxy(badProxy);

1896

socket.connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1897

QVERIFY(! socket.waitForConnected(10000));

1898

1899

// don't forget to login

1900

QCOMPARE((int) socket.write("USER ftptest\r\n"), 14);

1901

QCOMPARE((int) socket.write("PASS password\r\n"), 15);

1902

1903

enterLoop(10);

1904

1905

// now the other way round:

1906

// set the nonsense proxy and make sure the connection does not work,

1907

// and then set the right proxy and make sure it works

1908

QSslSocket socket2;

1909

socket2.addCaCertificates(QLatin1String(SRCDIR "certs/qt-test-server-cacert.pem"));

1910

socket2.setProxy(badProxy);

1911

socket2.connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1912

QVERIFY(! socket2.waitForConnected(10000));

1913

socket2.abort();

1914

socket2.setProxy(goodProxy);

1915

socket2.connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1916

QVERIFY2(socket2.waitForConnected(10000), qPrintable(socket.errorString()));

1917

}

1918

1919

void tst_QSslSocket::ignoreSslErrorsList_data()

1920

{

1921

QTest::addColumn<QList<QSslError> >("expectedSslErrors");

1922

QTest::addColumn<int>("expectedSslErrorSignalCount");

1923

1924

// construct the list of errors that we will get with the SSL handshake and that we will ignore

1925

QList<QSslError> expectedSslErrors;

1926

// fromPath gives us a list of certs, but it actually only contains one

1927

QList<QSslCertificate> certs = QSslCertificate::fromPath(QLatin1String(SRCDIR "certs/qt-test-server-cacert.pem"));

1928

QSslError rightError(QSslError::SelfSignedCertificate, certs.at(0));

1929

QSslError wrongError(QSslError::SelfSignedCertificate);

1930

1931

1932

QTest::newRow("SSL-failure-empty-list") << expectedSslErrors << 1;

1933

expectedSslErrors.append(wrongError);

1934

QTest::newRow("SSL-failure-wrong-error") << expectedSslErrors << 1;

1935

expectedSslErrors.append(rightError);

1936

QTest::newRow("allErrorsInExpectedList1") << expectedSslErrors << 0;

1937

expectedSslErrors.removeAll(wrongError);

1938

QTest::newRow("allErrorsInExpectedList2") << expectedSslErrors << 0;

1939

expectedSslErrors.removeAll(rightError);

1940

QTest::newRow("SSL-failure-empty-list-again") << expectedSslErrors << 1;

1941

}

1942

1943

void tst_QSslSocket::ignoreSslErrorsList()

1944

{

1945

QSslSocket socket;

1946

connect(&socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

1947

this, SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));

1948

1949

// this->socket = &socket;

1950

QSslCertificate cert;

1951

1952

QFETCH(QList<QSslError>, expectedSslErrors);

1953

socket.ignoreSslErrors(expectedSslErrors);

1954

1955

QFETCH(int, expectedSslErrorSignalCount);

1956

QSignalSpy sslErrorsSpy(&socket, SIGNAL(error(QAbstractSocket::SocketError)));

1957

1958

socket.connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1959

1960

bool expectEncryptionSuccess = (expectedSslErrorSignalCount == 0);

1961

QCOMPARE(socket.waitForEncrypted(10000), expectEncryptionSuccess);

1962

QCOMPARE(sslErrorsSpy.count(), expectedSslErrorSignalCount);

1963

}

1964

1965

void tst_QSslSocket::ignoreSslErrorsListWithSlot_data()

1966

{

1967

ignoreSslErrorsList_data();

1968

}

1969

1970

// this is not a test, just a slot called in the test below

1971

void tst_QSslSocket::ignoreErrorListSlot(const QList<QSslError> &)

1972

{

1973

socket->ignoreSslErrors(storedExpectedSslErrors);

1974

}

1975

1976

void tst_QSslSocket::ignoreSslErrorsListWithSlot()

1977

{

1978

QSslSocket socket;

1979

this->socket = &socket;

1980

1981

QFETCH(QList<QSslError>, expectedSslErrors);

1982

// store the errors to ignore them later in the slot connected below

1983

storedExpectedSslErrors = expectedSslErrors;

1984

connect(&socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

1985

this, SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));

1986

connect(&socket, SIGNAL(sslErrors(QList<QSslError>)),

1987

this, SLOT(ignoreErrorListSlot(QList<QSslError>)));

1988

socket.connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

1989

1990

QFETCH(int, expectedSslErrorSignalCount);

1991

bool expectEncryptionSuccess = (expectedSslErrorSignalCount == 0);

1992

QCOMPARE(socket.waitForEncrypted(10000), expectEncryptionSuccess);

1993

}

1994

1995

// make sure a closed socket has no bytesAvailable()

1996

// related to https://bugs.webkit.org/show_bug.cgi?id=28016

1997

void tst_QSslSocket::readFromClosedSocket()

1998

{

1999

QSslSocketPtr socket = newSocket();

2000

socket->ignoreSslErrors();

2001

socket->connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

2002

socket->ignoreSslErrors();

2003

socket->waitForConnected();

2004

socket->waitForEncrypted();

2005

// provoke a response by sending a request

2006

socket->write("GET /qtest/fluke.gif HTTP/1.1\n");

2007

socket->write("Host: ");

2008

socket->write(QtNetworkSettings::serverName().toLocal8Bit().constData());

2009

socket->write("\n");

2010

socket->write("\n");

2011

socket->waitForBytesWritten();

2012

socket->waitForReadyRead();

2013

QVERIFY(socket->state() == QAbstractSocket::ConnectedState);

2014

QVERIFY(socket->bytesAvailable());

2015

socket->close();

2016

QVERIFY(!socket->bytesAvailable());

2017

QVERIFY(!socket->bytesToWrite());

2018

QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);

2019

}

2020

2021

void tst_QSslSocket::writeBigChunk()

2022

{

2023

if (!QSslSocket::supportsSsl())

2024

return;

2025

2026

QSslSocketPtr socket = newSocket();

2027

this->socket = socket.data();

2028

2029

connect(this->socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));

2030

socket->connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

2031

2032

QByteArray data;

2033

data.resize(1024*1024*10); // 10 MB

2034

// init with garbage. needed so ssl cannot compress it in an efficient way.

2035

for (size_t i = 0; i < data.size() / sizeof(int); i++) {

2036

int r = qrand();

2037

data.data()[i*sizeof(int)] = r;

2038

}

2039

2040

QVERIFY(socket->waitForEncrypted(10000));

2041

QString errorBefore = socket->errorString();

2042

2043

int ret = socket->write(data.constData(), data.size());

2044

QVERIFY(data.size() == ret);

2045

2046

// spin the event loop once so QSslSocket::transmit() gets called

2047

QCoreApplication::processEvents();

2048

QString errorAfter = socket->errorString();

2049

2050

// no better way to do this right now since the error is the same as the default error.

2051

if (socket->errorString().startsWith(QLatin1String("Unable to write data")))

2052

{

2053

qWarning() << socket->error() << socket->errorString();

2054

QFAIL("Error while writing! Check if the OpenSSL BIO size is limited?!");

2055

}

2056

// also check the error string. If another error (than UnknownError) occurred, it should be different than before

2057

QVERIFY(errorBefore == errorAfter);

2058

2059

// check that everything has been written to OpenSSL

2060

QVERIFY(socket->bytesToWrite() == 0);

2061

2062

socket->close();

2063

}

2064

2065

void tst_QSslSocket::blacklistedCertificates()

2066

{

2067

QFETCH_GLOBAL(bool, setProxy);

2068

if (setProxy)

2069

return;

2070

2071

SslServer server(SRCDIR "certs/fake-login.live.com.key", SRCDIR "certs/fake-login.live.com.pem");

2072

QSslSocket *receiver = new QSslSocket(this);

2073

connect(receiver, SIGNAL(readyRead()), SLOT(exitLoop()));

2074

2075

// connect two sockets to each other:

2076

QVERIFY(server.listen(QHostAddress::LocalHost));

2077

receiver->connectToHost("127.0.0.1", server.serverPort());

2078

QVERIFY(receiver->waitForConnected(5000));

2079

QVERIFY(server.waitForNewConnection(0));

2080

2081

QSslSocket *sender = server.socket;

2082

QVERIFY(sender);

2083

QVERIFY(sender->state() == QAbstractSocket::ConnectedState);

2084

receiver->setObjectName("receiver");

2085

sender->setObjectName("sender");

2086

receiver->startClientEncryption();

2087

2088

connect(receiver, SIGNAL(sslErrors(QList<QSslError>)), SLOT(exitLoop()));

2089

connect(receiver, SIGNAL(encrypted()), SLOT(exitLoop()));

2090

enterLoop(1);

2091

QList<QSslError> sslErrors = receiver->sslErrors();

2092

QVERIFY(sslErrors.count() > 0);

2093

// there are more errors (self signed cert and hostname mismatch), but we only care about the blacklist error

2094

QCOMPARE(sslErrors.at(0).error(), QSslError::CertificateBlacklisted);

2095

}

2096

2097

void tst_QSslSocket::versionAccessors()

2098

{

2099

if (!QSslSocket::supportsSsl())

2100

return;

2101

2102

qDebug() << QSslSocket::sslLibraryVersionString();

2103

qDebug() << QString::number(QSslSocket::sslLibraryVersionNumber(), 16);

2104

}

2105

2106

void tst_QSslSocket::sslOptions()

2107

{

2108

if (!QSslSocket::supportsSsl())

2109

return;

2110

2111

#ifdef SSL_OP_NO_COMPRESSION

2112

QCOMPARE(QSslSocketBackendPrivate::setupOpenSslOptions(QSsl::SecureProtocols,

2113

QSslConfigurationPrivate::defaultSslOptions),

2114

long(SSL_OP_ALL|SSL_OP_NO_SSLv2|SSL_OP_NO_COMPRESSION));

2115

#else

2116

QCOMPARE(QSslSocketBackendPrivate::setupOpenSslOptions(QSsl::SecureProtocols,

2117

QSslConfigurationPrivate::defaultSslOptions),

2118

long(SSL_OP_ALL|SSL_OP_NO_SSLv2));

2119

#endif

2120

2121

QCOMPARE(QSslSocketBackendPrivate::setupOpenSslOptions(QSsl::SecureProtocols,

2122

QSsl::SslOptionDisableEmptyFragments

2123

|QSsl::SslOptionDisableLegacyRenegotiation),

2124

long(SSL_OP_ALL|SSL_OP_NO_SSLv2));

2125

2126

#ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION

2127

QCOMPARE(QSslSocketBackendPrivate::setupOpenSslOptions(QSsl::SecureProtocols,

2128

QSsl::SslOptionDisableEmptyFragments),

2129

long((SSL_OP_ALL|SSL_OP_NO_SSLv2|SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)));

2130

#endif

2131

2132

#ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS

2133

QCOMPARE(QSslSocketBackendPrivate::setupOpenSslOptions(QSsl::SecureProtocols,

2134

QSsl::SslOptionDisableLegacyRenegotiation),

2135

long((SSL_OP_ALL|SSL_OP_NO_SSLv2) & ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS));

2136

#endif

2137

2138

#ifdef SSL_OP_NO_TICKET

2139

QCOMPARE(QSslSocketBackendPrivate::setupOpenSslOptions(QSsl::SecureProtocols,

2140

QSsl::SslOptionDisableEmptyFragments

2141

|QSsl::SslOptionDisableLegacyRenegotiation

2142

|QSsl::SslOptionDisableSessionTickets),

2143

long((SSL_OP_ALL|SSL_OP_NO_SSLv2|SSL_OP_NO_TICKET)));

2144

#endif

2145

2146

#ifdef SSL_OP_NO_TICKET

2147

#ifdef SSL_OP_NO_COMPRESSION

2148

QCOMPARE(QSslSocketBackendPrivate::setupOpenSslOptions(QSsl::SecureProtocols,

2149

QSsl::SslOptionDisableEmptyFragments

2150

|QSsl::SslOptionDisableLegacyRenegotiation

2151

|QSsl::SslOptionDisableSessionTickets

2152

|QSsl::SslOptionDisableCompression),

2153

long((SSL_OP_ALL|SSL_OP_NO_SSLv2|SSL_OP_NO_TICKET|SSL_OP_NO_COMPRESSION)));

2154

#endif

2155

#endif

2156

}

2157

2158

void tst_QSslSocket::encryptWithoutConnecting()

2159

{

2160

if (!QSslSocket::supportsSsl())

2161

return;

2162

2163

QTest::ignoreMessage(QtWarningMsg,

2164

"QSslSocket::startClientEncryption: cannot start handshake when not connected");

2165

2166

QSslSocket sock;

2167

sock.startClientEncryption();

2168

}

2169

2170

void tst_QSslSocket::resume_data()

2171

{

2172

QTest::addColumn<bool>("ignoreErrorsAfterPause");

2173

QTest::addColumn<QList<QSslError> >("errorsToIgnore");

2174

QTest::addColumn<bool>("expectSuccess");

2175

2176

QList<QSslError> errorsList;

2177

QTest::newRow("DoNotIgnoreErrors") << false << QList<QSslError>() << false;

2178

QTest::newRow("ignoreAllErrors") << true << QList<QSslError>() << true;

2179

2180

QList<QSslCertificate> certs = QSslCertificate::fromPath(QLatin1String(SRCDIR "certs/qt-test-server-cacert.pem"));

2181

QSslError rightError(QSslError::SelfSignedCertificate, certs.at(0));

2182

QSslError wrongError(QSslError::SelfSignedCertificate);

2183

errorsList.append(wrongError);

2184

QTest::newRow("ignoreSpecificErrors-Wrong") << true << errorsList << false;

2185

errorsList.clear();

2186

errorsList.append(rightError);

2187

QTest::newRow("ignoreSpecificErrors-Right") << true << errorsList << true;

2188

}

2189

2190

void tst_QSslSocket::resume()

2191

{

2192

// make sure the server certificate is not in the list of accepted certificates,

2193

// we want to trigger the sslErrors signal

2194

QSslSocket::setDefaultCaCertificates(QSslSocket::systemCaCertificates());

2195

2196

QFETCH(bool, ignoreErrorsAfterPause);

2197

QFETCH(QList<QSslError>, errorsToIgnore);

2198

QFETCH(bool, expectSuccess);

2199

2200

QSslSocket socket;

2201

socket.setPauseMode(QAbstractSocket::PauseOnSslErrors);

2202

2203

QSignalSpy sslErrorSpy(&socket, SIGNAL(sslErrors(QList<QSslError>)));

2204

QSignalSpy encryptedSpy(&socket, SIGNAL(encrypted()));

2205

QSignalSpy errorSpy(&socket, SIGNAL(error(QAbstractSocket::SocketError)));

2206

2207

connect(&socket, SIGNAL(sslErrors(QList<QSslError>)), &QTestEventLoop::instance(), SLOT(exitLoop()));

2208

connect(&socket, SIGNAL(encrypted()), &QTestEventLoop::instance(), SLOT(exitLoop()));

2209

connect(&socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

2210

this, SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));

2211

connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop()));

2212

2213

socket.connectToHostEncrypted(QtNetworkSettings::serverName(), 993);

2214

QTestEventLoop::instance().enterLoop(10);

2215

QVERIFY(!QTestEventLoop::instance().timeout());

2216

QCOMPARE(sslErrorSpy.count(), 1);

2217

QCOMPARE(errorSpy.count(), 0);

2218

QCOMPARE(encryptedSpy.count(), 0);

2219

QVERIFY(!socket.isEncrypted());

2220

if (ignoreErrorsAfterPause) {

2221

if (errorsToIgnore.empty())

2222

socket.ignoreSslErrors();

2223

else

2224

socket.ignoreSslErrors(errorsToIgnore);

2225

}

2226

socket.resume();

2227

QTestEventLoop::instance().enterLoop(10);

2228

QVERIFY(!QTestEventLoop::instance().timeout()); // quit by encrypted() or error() signal

2229

if (expectSuccess) {

2230

QCOMPARE(encryptedSpy.count(), 1);

2231

QVERIFY(socket.isEncrypted());

2232

QCOMPARE(errorSpy.count(), 0);

2233

socket.disconnectFromHost();

2234

QVERIFY(socket.waitForDisconnected(10000));

2235

} else {

2236

QCOMPARE(encryptedSpy.count(), 0);

2237

QVERIFY(!socket.isEncrypted());

2238

QCOMPARE(errorSpy.count(), 1);

2239

QCOMPARE(socket.error(), QAbstractSocket::SslHandshakeFailedError);

2240

}

2241

}

2242

2243

class WebSocket : public QSslSocket

2244

{

2245

Q_OBJECT

2246

public:

2247

explicit WebSocket(qintptr socketDescriptor,

2248

const QString &keyFile = SRCDIR "certs/fluke.key",

2249

const QString &certFile = SRCDIR "certs/fluke.cert");

2250

2251

protected slots:

2252

void onReadyReadFirstBytes(void);

2253

2254

private:

2255

void _startServerEncryption(void);

2256

2257

QString m_keyFile;

2258

QString m_certFile;

2259

2260

private:

2261

Q_DISABLE_COPY(WebSocket)

2262

};

2263

2264

WebSocket::WebSocket (qintptr socketDescriptor, const QString &keyFile, const QString &certFile)

2265

: m_keyFile(keyFile),

2266

m_certFile(certFile)

2267

{

2268

QVERIFY(setSocketDescriptor(socketDescriptor, QAbstractSocket::ConnectedState, QIODevice::ReadWrite | QIODevice::Unbuffered));

2269

connect (this, SIGNAL(readyRead()), this, SLOT(onReadyReadFirstBytes()));

2270

}

2271

2272

void WebSocket::_startServerEncryption (void)

2273

{

2274

QFile file(m_keyFile);

2275

QVERIFY(file.open(QIODevice::ReadOnly));

2276

QSslKey key(file.readAll(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey);

2277

QVERIFY(!key.isNull());

2278

setPrivateKey(key);

2279

2280

QList<QSslCertificate> localCert = QSslCertificate::fromPath(m_certFile);

2281

QVERIFY(!localCert.isEmpty());

2282

QVERIFY(localCert.first().handle());

2283

setLocalCertificate(localCert.first());

2284

2285

QVERIFY(!peerAddress().isNull());

2286

QVERIFY(peerPort() != 0);

2287

QVERIFY(!localAddress().isNull());

2288

QVERIFY(localPort() != 0);

2289

2290

setProtocol(QSsl::AnyProtocol);

2291

setPeerVerifyMode(QSslSocket::VerifyNone);

2292

ignoreSslErrors();

2293

startServerEncryption();

2294

}

2295

2296

void WebSocket::onReadyReadFirstBytes (void)

2297

{

2298

peek(1);

2299

disconnect(this,SIGNAL(readyRead()), this, SLOT(onReadyReadFirstBytes()));

2300

_startServerEncryption();

2301

}

2302

2303

class SslServer4 : public QTcpServer

2304

{

2305

Q_OBJECT

2306

public:

2307

SslServer4() : socket(0) {}

2308

WebSocket *socket;

2309

2310

protected:

2311

void incomingConnection(qintptr socketDescriptor)

2312

{

2313

socket = new WebSocket(socketDescriptor);

2314

}

2315

};

2316

2317

void tst_QSslSocket::qtbug18498_peek()

2318

{

2319

QFETCH_GLOBAL(bool, setProxy);

2320

if (setProxy)

2321

return;

2322

2323

SslServer4 server;

2324

QSslSocket *client = new QSslSocket(this);

2325

2326

QVERIFY(server.listen(QHostAddress::LocalHost));

2327

client->connectToHost("127.0.0.1", server.serverPort());

2328

QVERIFY(client->waitForConnected(5000));

2329

QVERIFY(server.waitForNewConnection(1000));

2330

client->setObjectName("client");

2331

client->ignoreSslErrors();

2332

2333

connect(client, SIGNAL(encrypted()), this, SLOT(exitLoop()));

2334

connect(client, SIGNAL(disconnected()), this, SLOT(exitLoop()));

2335

2336

client->startClientEncryption();

2337

WebSocket *serversocket = server.socket;

2338

QVERIFY(serversocket);

2339

serversocket->setObjectName("server");

2340

2341

enterLoop(1);

2342

QVERIFY(!timeout());

2343

QVERIFY(serversocket->isEncrypted());

2344

QVERIFY(client->isEncrypted());

2345

2346

QByteArray data("abc123");

2347

client->write(data.data());

2348

2349

connect(serversocket, SIGNAL(readyRead()), this, SLOT(exitLoop()));

2350

enterLoop(1);

2351

QVERIFY(!timeout());

2352

2353

QByteArray peek1_data;

2354

peek1_data.reserve(data.size());

2355

QByteArray peek2_data;

2356

QByteArray read_data;

2357

2358

int lngth = serversocket->peek(peek1_data.data(), 10);

2359

peek1_data.resize(lngth);

2360

2361

peek2_data = serversocket->peek(10);

2362

read_data = serversocket->readAll();

2363

2364

QCOMPARE(peek1_data, data);

2365

QCOMPARE(peek2_data, data);

2366

QCOMPARE(read_data, data);

2367

}

2368

2369

class SslServer5 : public QTcpServer

2370

{

2371

Q_OBJECT

2372

public:

2373

SslServer5() : socket(0) {}

2374

QSslSocket *socket;

2375

2376

protected:

2377

void incomingConnection(qintptr socketDescriptor)

2378

{

2379

socket = new QSslSocket;

2380

socket->setSocketDescriptor(socketDescriptor);

2381

}

2382

};

2383

2384

void tst_QSslSocket::qtbug18498_peek2()

2385

{

2386

QFETCH_GLOBAL(bool, setProxy);

2387

if (setProxy)

2388

return;

2389

2390

SslServer5 listener;

2391

QVERIFY(listener.listen(QHostAddress::Any));

2392

QScopedPointer<QSslSocket> client(new QSslSocket);

2393

client->connectToHost(QHostAddress::LocalHost, listener.serverPort());

2394

QVERIFY(client->waitForConnected(5000));

2395

QVERIFY(listener.waitForNewConnection(1000));

2396

2397

QScopedPointer<QSslSocket> server(listener.socket);

2398

2399

QVERIFY(server->write("HELLO\r\n", 7));

2400

QElapsedTimer stopwatch;

2401

stopwatch.start();

2402

while (client->bytesAvailable() < 7 && stopwatch.elapsed() < 5000)

2403

QTest::qWait(100);

2404

char c;

2405

QVERIFY(client->peek(&c,1) == 1);

2406

QCOMPARE(c, 'H');

2407

QVERIFY(client->read(&c,1) == 1);

2408

QCOMPARE(c, 'H');

2409

QByteArray b = client->peek(2);

2410

QCOMPARE(b, QByteArray("EL"));

2411

char a[3];

2412

QVERIFY(client->peek(a, 2) == 2);

2413

QCOMPARE(a[0], 'E');

2414

QCOMPARE(a[1], 'L');

2415

QCOMPARE(client->readAll(), QByteArray("ELLO\r\n"));

2416

2417

//check data split between QIODevice and plain socket buffers.

2418

QByteArray bigblock;

2419

bigblock.fill('#', QIODEVICE_BUFFERSIZE + 1024);

2420

QVERIFY(client->write(QByteArray("head")));

2421

QVERIFY(client->write(bigblock));

2422

while (server->bytesAvailable() < bigblock.length() + 4 && stopwatch.elapsed() < 5000)

2423

QTest::qWait(100);

2424

QCOMPARE(server->read(4), QByteArray("head"));

2425

QCOMPARE(server->peek(bigblock.length()), bigblock);

2426

b.reserve(bigblock.length());

2427

b.resize(server->peek(b.data(), bigblock.length()));

2428

QCOMPARE(b, bigblock);

2429

2430

//check oversized peek

2431

QCOMPARE(server->peek(bigblock.length() * 3), bigblock);

2432

b.reserve(bigblock.length() * 3);

2433

b.resize(server->peek(b.data(), bigblock.length() * 3));

2434

QCOMPARE(b, bigblock);

2435

2436

QCOMPARE(server->readAll(), bigblock);

2437

2438

QVERIFY(client->write("STARTTLS\r\n"));

2439

stopwatch.start();

2440

// ### Qt5 use QTRY_VERIFY

2441

while (server->bytesAvailable() < 10 && stopwatch.elapsed() < 5000)

2442

QTest::qWait(100);

2443

QVERIFY(server->peek(&c,1) == 1);

2444

QCOMPARE(c, 'S');

2445

b = server->peek(3);

2446

QCOMPARE(b, QByteArray("STA"));

2447

QCOMPARE(server->read(5), QByteArray("START"));

2448

QVERIFY(server->peek(a, 3) == 3);

2449

QCOMPARE(a[0], 'T');

2450

QCOMPARE(a[1], 'L');

2451

QCOMPARE(a[2], 'S');

2452

QCOMPARE(server->readAll(), QByteArray("TLS\r\n"));

2453

2454

QFile file(SRCDIR "certs/fluke.key");

2455

QVERIFY(file.open(QIODevice::ReadOnly));

2456

QSslKey key(file.readAll(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey);

2457

QVERIFY(!key.isNull());

2458

server->setPrivateKey(key);

2459

2460

QList<QSslCertificate> localCert = QSslCertificate::fromPath(SRCDIR "certs/fluke.cert");

2461

QVERIFY(!localCert.isEmpty());

2462

QVERIFY(localCert.first().handle());

2463

server->setLocalCertificate(localCert.first());

2464

2465

server->setProtocol(QSsl::AnyProtocol);

2466

server->setPeerVerifyMode(QSslSocket::VerifyNone);

2467

2468

server->ignoreSslErrors();

2469

client->ignoreSslErrors();

2470

2471

server->startServerEncryption();

2472

client->startClientEncryption();

2473

2474

QVERIFY(server->write("hello\r\n", 7));

2475

stopwatch.start();

2476

while (client->bytesAvailable() < 7 && stopwatch.elapsed() < 5000)

2477

QTest::qWait(100);

2478

QVERIFY(server->mode() == QSslSocket::SslServerMode && client->mode() == QSslSocket::SslClientMode);

2479

QVERIFY(client->peek(&c,1) == 1);

2480

QCOMPARE(c, 'h');

2481

QVERIFY(client->read(&c,1) == 1);

2482

QCOMPARE(c, 'h');

2483

b = client->peek(2);

2484

QCOMPARE(b, QByteArray("el"));

2485

QCOMPARE(client->readAll(), QByteArray("ello\r\n"));

2486

2487

QVERIFY(client->write("goodbye\r\n"));

2488

stopwatch.start();

2489

while (server->bytesAvailable() < 9 && stopwatch.elapsed() < 5000)

2490

QTest::qWait(100);

2491

QVERIFY(server->peek(&c,1) == 1);

2492

QCOMPARE(c, 'g');

2493

QCOMPARE(server->readAll(), QByteArray("goodbye\r\n"));

2494

client->disconnectFromHost();

2495

QVERIFY(client->waitForDisconnected(5000));

2496

}

2497

2498

void tst_QSslSocket::setEmptyDefaultConfiguration() // this test should be last, as it has some side effects

2499

{

2500

// used to produce a crash in QSslConfigurationPrivate::deepCopyDefaultConfiguration, QTBUG-13265

2501

2502

if (!QSslSocket::supportsSsl())

2503

return;

2504

2505

QSslConfiguration emptyConf;

2506

QSslConfiguration::setDefaultConfiguration(emptyConf);

2507

2508

QSslSocketPtr socket = newSocket();

2509

connect(socket.data(), SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));

2510

socket->connectToHostEncrypted(QtNetworkSettings::serverName(), 443);

2511

QVERIFY2(!socket->waitForEncrypted(4000), qPrintable(socket->errorString()));

2512

}

2513

2514

#endif // QT_NO_SSL

2515

2516

QTEST_MAIN(tst_QSslSocket)

2517

2518

#include "tst_qsslsocket.moc"

Older »