source: trunk/src/network/socket/qhttpsocketengine.cpp@ 659

Last change on this file since 659 was 651, checked in by Dmitry A. Kuminov, 16 years ago

trunk: Merged in qt 4.6.2 sources.
File size: 25.1 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the QtNetwork module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "qhttpsocketengine_p.h"
43#include "qtcpsocket.h"
44#include "qhostaddress.h"
45#include "qdatetime.h"
46#include "qurl.h"
47#include "qhttp.h"
48
49#if !defined(QT_NO_NETWORKPROXY) && !defined(QT_NO_HTTP)
50#include <qdebug.h>
51
52QT_BEGIN_NAMESPACE
53
54#define DEBUG
55
56QHttpSocketEngine::QHttpSocketEngine(QObject *parent)
57 : QAbstractSocketEngine(*new QHttpSocketEnginePrivate, parent)
58{
59}
60
61QHttpSocketEngine::~QHttpSocketEngine()
62{
63}
64
65bool QHttpSocketEngine::initialize(QAbstractSocket::SocketType type, QAbstractSocket::NetworkLayerProtocol protocol)
66{
67 Q_D(QHttpSocketEngine);
68 if (type != QAbstractSocket::TcpSocket)
69 return false;
70
71 setProtocol(protocol);
72 setSocketType(type);
73 d->socket = new QTcpSocket(this);
74
75 // Explicitly disable proxying on the proxy socket itself to avoid
76 // unwanted recursion.
77 d->socket->setProxy(QNetworkProxy::NoProxy);
78
79 // Intercept all the signals.
80 connect(d->socket, SIGNAL(connected()),
81 this, SLOT(slotSocketConnected()),
82 Qt::DirectConnection);
83 connect(d->socket, SIGNAL(disconnected()),
84 this, SLOT(slotSocketDisconnected()),
85 Qt::DirectConnection);
86 connect(d->socket, SIGNAL(readyRead()),
87 this, SLOT(slotSocketReadNotification()),
88 Qt::DirectConnection);
89 connect(d->socket, SIGNAL(bytesWritten(qint64)),
90 this, SLOT(slotSocketBytesWritten()),
91 Qt::DirectConnection);
92 connect(d->socket, SIGNAL(error(QAbstractSocket::SocketError)),
93 this, SLOT(slotSocketError(QAbstractSocket::SocketError)),
94 Qt::DirectConnection);
95 connect(d->socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
96 this, SLOT(slotSocketStateChanged(QAbstractSocket::SocketState)),
97 Qt::DirectConnection);
98
99 return true;
100}
101
102bool QHttpSocketEngine::initialize(int, QAbstractSocket::SocketState)
103{
104 return false;
105}
106
107void QHttpSocketEngine::setProxy(const QNetworkProxy &proxy)
108{
109 Q_D(QHttpSocketEngine);
110 d->proxy = proxy;
111 QString user = proxy.user();
112 if (!user.isEmpty())
113 d->authenticator.setUser(user);
114 QString password = proxy.password();
115 if (!password.isEmpty())
116 d->authenticator.setPassword(password);
117}
118
119int QHttpSocketEngine::socketDescriptor() const
120{
121 Q_D(const QHttpSocketEngine);
122 return d->socket ? d->socket->socketDescriptor() : 0;
123}
124
125bool QHttpSocketEngine::isValid() const
126{
127 Q_D(const QHttpSocketEngine);
128 return d->socket;
129}
130
131bool QHttpSocketEngine::connectInternal()
132{
133 Q_D(QHttpSocketEngine);
134
135 // If the handshake is done, enter ConnectedState state and return true.
136 if (d->state == Connected) {
137 qWarning("QHttpSocketEngine::connectToHost: called when already connected");
138 setState(QAbstractSocket::ConnectedState);
139 return true;
140 }
141
142 if (d->state == ConnectSent && d->socketState != QAbstractSocket::ConnectedState)
143 setState(QAbstractSocket::UnconnectedState);
144
145 // Handshake isn't done. If unconnected, start connecting.
146 if (d->state == None && d->socket->state() == QAbstractSocket::UnconnectedState) {
147 setState(QAbstractSocket::ConnectingState);
148 d->socket->connectToHost(d->proxy.hostName(), d->proxy.port());
149 }
150
151 // If connected (might happen right away, at least for localhost services
152 // on some BSD systems), there might already be bytes available.
153 if (bytesAvailable())
154 slotSocketReadNotification();
155
156 return d->socketState == QAbstractSocket::ConnectedState;
157}
158
159bool QHttpSocketEngine::connectToHost(const QHostAddress &address, quint16 port)
160{
161 Q_D(QHttpSocketEngine);
162
163 setPeerAddress(address);
164 setPeerPort(port);
165 d->peerName.clear();
166
167 return connectInternal();
168}
169
170bool QHttpSocketEngine::connectToHostByName(const QString &hostname, quint16 port)
171{
172 Q_D(QHttpSocketEngine);
173
174 setPeerAddress(QHostAddress());
175 setPeerPort(port);
176 d->peerName = hostname;
177
178 return connectInternal();
179}
180
181bool QHttpSocketEngine::bind(const QHostAddress &, quint16)
182{
183 return false;
184}
185
186bool QHttpSocketEngine::listen()
187{
188 return false;
189}
190
191int QHttpSocketEngine::accept()
192{
193 return 0;
194}
195
196void QHttpSocketEngine::close()
197{
198 Q_D(QHttpSocketEngine);
199 if (d->socket) {
200 d->socket->close();
201 delete d->socket;
202 d->socket = 0;
203 }
204}
205
206qint64 QHttpSocketEngine::bytesAvailable() const
207{
208 Q_D(const QHttpSocketEngine);
209 return d->readBuffer.size() + (d->socket ? d->socket->bytesAvailable() : 0);
210}
211
212qint64 QHttpSocketEngine::read(char *data, qint64 maxlen)
213{
214 Q_D(QHttpSocketEngine);
215 qint64 bytesRead = d->socket->read(data, maxlen);
216
217 if (d->socket->state() == QAbstractSocket::UnconnectedState
218 && d->socket->bytesAvailable() == 0) {
219 emitReadNotification();
220 }
221
222 if (bytesRead == -1) {
223 // If nothing has been read so far, and the direct socket read
224 // failed, return the socket's error. Otherwise, fall through and
225 // return as much as we read so far.
226 close();
227 setError(QAbstractSocket::RemoteHostClosedError,
228 QLatin1String("Remote host closed"));
229 setState(QAbstractSocket::UnconnectedState);
230 return -1;
231 }
232 return bytesRead;
233}
234
235qint64 QHttpSocketEngine::write(const char *data, qint64 len)
236{
237 Q_D(QHttpSocketEngine);
238 return d->socket->write(data, len);
239}
240
241#ifndef QT_NO_UDPSOCKET
242qint64 QHttpSocketEngine::readDatagram(char *, qint64, QHostAddress *,
243 quint16 *)
244{
245 return 0;
246}
247
248qint64 QHttpSocketEngine::writeDatagram(const char *, qint64, const QHostAddress &,
249 quint16)
250{
251 return 0;
252}
253
254bool QHttpSocketEngine::hasPendingDatagrams() const
255{
256 return false;
257}
258
259qint64 QHttpSocketEngine::pendingDatagramSize() const
260{
261 return 0;
262}
263#endif // QT_NO_UDPSOCKET
264
265qint64 QHttpSocketEngine::bytesToWrite() const
266{
267 Q_D(const QHttpSocketEngine);
268 if (d->socket) {
269 return d->socket->bytesToWrite();
270 } else {
271 return 0;
272 }
273}
274
275int QHttpSocketEngine::option(SocketOption option) const
276{
277 Q_D(const QHttpSocketEngine);
278 if (d->socket) {
279 // convert the enum and call the real socket
280 if (option == QAbstractSocketEngine::LowDelayOption)
281 return d->socket->socketOption(QAbstractSocket::LowDelayOption).toInt();
282 if (option == QAbstractSocketEngine::KeepAliveOption)
283 return d->socket->socketOption(QAbstractSocket::KeepAliveOption).toInt();
284 }
285 return -1;
286}
287
288bool QHttpSocketEngine::setOption(SocketOption option, int value)
289{
290 Q_D(QHttpSocketEngine);
291 if (d->socket) {
292 // convert the enum and call the real socket
293 if (option == QAbstractSocketEngine::LowDelayOption)
294 d->socket->setSocketOption(QAbstractSocket::LowDelayOption, value);
295 if (option == QAbstractSocketEngine::KeepAliveOption)
296 d->socket->setSocketOption(QAbstractSocket::KeepAliveOption, value);
297 return true;
298 }
299 return false;
300}
301
302/*
303 Returns the difference between msecs and elapsed. If msecs is -1,
304 however, -1 is returned.
305*/
306static int qt_timeout_value(int msecs, int elapsed)
307{
308 if (msecs == -1)
309 return -1;
310
311 int timeout = msecs - elapsed;
312 return timeout < 0 ? 0 : timeout;
313}
314
315bool QHttpSocketEngine::waitForRead(int msecs, bool *timedOut)
316{
317 Q_D(const QHttpSocketEngine);
318
319 if (!d->socket || d->socket->state() == QAbstractSocket::UnconnectedState)
320 return false;
321
322 QTime stopWatch;
323 stopWatch.start();
324
325 // Wait for more data if nothing is available.
326 if (!d->socket->bytesAvailable()) {
327 if (!d->socket->waitForReadyRead(qt_timeout_value(msecs, stopWatch.elapsed()))) {
328 if (d->socket->state() == QAbstractSocket::UnconnectedState)
329 return true;
330 setError(d->socket->error(), d->socket->errorString());
331 if (timedOut && d->socket->error() == QAbstractSocket::SocketTimeoutError)
332 *timedOut = true;
333 return false;
334 }
335 }
336
337 // If we're not connected yet, wait until we are, or until an error
338 // occurs.
339 while (d->state != Connected && d->socket->waitForReadyRead(qt_timeout_value(msecs, stopWatch.elapsed()))) {
340 // Loop while the protocol handshake is taking place.
341 }
342
343 // Report any error that may occur.
344 if (d->state != Connected) {
345 setError(d->socket->error(), d->socket->errorString());
346 if (timedOut && d->socket->error() == QAbstractSocket::SocketTimeoutError)
347 *timedOut = true;
348 return false;
349 }
350 return true;
351}
352
353bool QHttpSocketEngine::waitForWrite(int msecs, bool *timedOut)
354{
355 Q_D(const QHttpSocketEngine);
356
357 // If we're connected, just forward the call.
358 if (d->state == Connected) {
359 if (d->socket->bytesToWrite()) {
360 if (!d->socket->waitForBytesWritten(msecs)) {
361 if (d->socket->error() == QAbstractSocket::SocketTimeoutError && timedOut)
362 *timedOut = true;
363 return false;
364 }
365 }
366 return true;
367 }
368
369 QTime stopWatch;
370 stopWatch.start();
371
372 // If we're not connected yet, wait until we are, and until bytes have
373 // been received (i.e., the socket has connected, we have sent the
374 // greeting, and then received the response).
375 while (d->state != Connected && d->socket->waitForReadyRead(qt_timeout_value(msecs, stopWatch.elapsed()))) {
376 // Loop while the protocol handshake is taking place.
377 }
378
379 // Report any error that may occur.
380 if (d->state != Connected) {
381// setError(d->socket->error(), d->socket->errorString());
382 if (timedOut && d->socket->error() == QAbstractSocket::SocketTimeoutError)
383 *timedOut = true;
384 }
385
386 return true;
387}
388
389bool QHttpSocketEngine::waitForReadOrWrite(bool *readyToRead, bool *readyToWrite,
390 bool checkRead, bool checkWrite,
391 int msecs, bool *timedOut)
392{
393 Q_UNUSED(checkRead);
394
395 if (!checkWrite) {
396 // Not interested in writing? Then we wait for read notifications.
397 bool canRead = waitForRead(msecs, timedOut);
398 if (readyToRead)
399 *readyToRead = canRead;
400 return canRead;
401 }
402
403 // Interested in writing? Then we wait for write notifications.
404 bool canWrite = waitForWrite(msecs, timedOut);
405 if (readyToWrite)
406 *readyToWrite = canWrite;
407 return canWrite;
408}
409
410bool QHttpSocketEngine::isReadNotificationEnabled() const
411{
412 Q_D(const QHttpSocketEngine);
413 return d->readNotificationEnabled;
414}
415
416void QHttpSocketEngine::setReadNotificationEnabled(bool enable)
417{
418 Q_D(QHttpSocketEngine);
419 if (d->readNotificationEnabled == enable)
420 return;
421
422 d->readNotificationEnabled = enable;
423 if (enable) {
424 // Enabling read notification can trigger a notification.
425 if (bytesAvailable())
426 slotSocketReadNotification();
427 }
428}
429
430bool QHttpSocketEngine::isWriteNotificationEnabled() const
431{
432 Q_D(const QHttpSocketEngine);
433 return d->writeNotificationEnabled;
434}
435
436void QHttpSocketEngine::setWriteNotificationEnabled(bool enable)
437{
438 Q_D(QHttpSocketEngine);
439 d->writeNotificationEnabled = enable;
440 if (enable && d->state == Connected && d->socket->state() == QAbstractSocket::ConnectedState)
441 QMetaObject::invokeMethod(this, "writeNotification", Qt::QueuedConnection);
442}
443
444bool QHttpSocketEngine::isExceptionNotificationEnabled() const
445{
446 Q_D(const QHttpSocketEngine);
447 return d->exceptNotificationEnabled;
448}
449
450void QHttpSocketEngine::setExceptionNotificationEnabled(bool enable)
451{
452 Q_D(QHttpSocketEngine);
453 d->exceptNotificationEnabled = enable;
454}
455
456void QHttpSocketEngine::slotSocketConnected()
457{
458 Q_D(QHttpSocketEngine);
459
460 // Send the greeting.
461 const char method[] = "CONNECT ";
462 QByteArray peerAddress = d->peerName.isEmpty() ?
463 d->peerAddress.toString().toLatin1() :
464 QUrl::toAce(d->peerName);
465 QByteArray path = peerAddress + ':' + QByteArray::number(d->peerPort);
466 QByteArray data = method;
467 data += path;
468 data += " HTTP/1.1\r\n";
469 data += "Proxy-Connection: keep-alive\r\n"
470 "User-Agent: Mozilla/5.0\r\n"
471 "Host: " + peerAddress + "\r\n";
472 QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
473 //qDebug() << "slotSocketConnected: priv=" << priv << (priv ? (int)priv->method : -1);
474 if (priv && priv->method != QAuthenticatorPrivate::None) {
475 data += "Proxy-Authorization: " + priv->calculateResponse(method, path);
476 data += "\r\n";
477 }
478 data += "\r\n";
479// qDebug() << ">>>>>>>> sending request" << this;
480// qDebug() << data;
481// qDebug() << ">>>>>>>";
482 d->socket->write(data);
483 d->state = ConnectSent;
484}
485
486void QHttpSocketEngine::slotSocketDisconnected()
487{
488}
489
490void QHttpSocketEngine::slotSocketReadNotification()
491{
492 Q_D(QHttpSocketEngine);
493 if (d->state != Connected && d->socket->bytesAvailable() == 0)
494 return;
495
496 if (d->state == Connected) {
497 // Forward as a read notification.
498 if (d->readNotificationEnabled)
499 emitReadNotification();
500 return;
501 }
502
503 readResponseContent:
504 if (d->state == ReadResponseContent) {
505 char dummybuffer[4096];
506 while (d->pendingResponseData) {
507 int read = d->socket->read(dummybuffer, qMin(sizeof(dummybuffer), (size_t)d->pendingResponseData));
508 if (read >= 0)
509 dummybuffer[read] = 0;
510
511 if (read == 0)
512 return;
513 if (read == -1) {
514 d->socket->disconnectFromHost();
515 emitWriteNotification();
516 return;
517 }
518 d->pendingResponseData -= read;
519 }
520 if (d->pendingResponseData > 0)
521 return;
522 d->state = SendAuthentication;
523 slotSocketConnected();
524 return;
525 }
526
527 // Still in handshake mode. Wait until we've got a full response.
528 bool done = false;
529 do {
530 d->readBuffer += d->socket->readLine();
531 } while (!(done = d->readBuffer.endsWith("\r\n\r\n")) && d->socket->canReadLine());
532
533 if (!done) {
534 // Wait for more.
535 return;
536 }
537
538 if (!d->readBuffer.startsWith("HTTP/1.")) {
539 // protocol error, this isn't HTTP
540 d->readBuffer.clear();
541 d->socket->close();
542 setState(QAbstractSocket::UnconnectedState);
543 setError(QAbstractSocket::ProxyProtocolError, tr("Did not receive HTTP response from proxy"));
544 emitConnectionNotification();
545 return;
546 }
547
548 QHttpResponseHeader responseHeader(QString::fromLatin1(d->readBuffer));
549 d->readBuffer.clear(); // we parsed the proxy protocol response. from now on direct socket reading will be done
550
551 int statusCode = responseHeader.statusCode();
552 if (statusCode == 200) {
553 d->state = Connected;
554 setLocalAddress(d->socket->localAddress());
555 setLocalPort(d->socket->localPort());
556 setState(QAbstractSocket::ConnectedState);
557 } else if (statusCode == 407) {
558 if (d->authenticator.isNull())
559 d->authenticator.detach();
560 QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
561
562 priv->parseHttpResponse(responseHeader, true);
563
564 if (priv->phase == QAuthenticatorPrivate::Invalid) {
565 // problem parsing the reply
566 d->socket->close();
567 setState(QAbstractSocket::UnconnectedState);
568 setError(QAbstractSocket::ProxyProtocolError, tr("Error parsing authentication request from proxy"));
569 emitConnectionNotification();
570 return;
571 }
572
573 bool willClose;
574 QString proxyConnectionHeader = responseHeader.value(QLatin1String("Proxy-Connection"));
575 proxyConnectionHeader = proxyConnectionHeader.toLower();
576 if (proxyConnectionHeader == QLatin1String("close")) {
577 willClose = true;
578 } else if (proxyConnectionHeader == QLatin1String("keep-alive")) {
579 willClose = false;
580 } else {
581 // no Proxy-Connection header, so use the default
582 // HTTP 1.1's default behaviour is to keep persistent connections
583 // HTTP 1.0 or earlier, so we expect the server to close
584 willClose = (responseHeader.majorVersion() * 0x100 + responseHeader.minorVersion()) <= 0x0100;
585 }
586
587 if (willClose) {
588 // the server will disconnect, so let's avoid receiving an error
589 // especially since the signal below may trigger a new event loop
590 d->socket->disconnectFromHost();
591 d->socket->readAll();
592 }
593
594 if (priv->phase == QAuthenticatorPrivate::Done)
595 emit proxyAuthenticationRequired(d->proxy, &d->authenticator);
596
597 // priv->phase will get reset to QAuthenticatorPrivate::Start if the authenticator got modified in the signal above.
598 if (priv->phase == QAuthenticatorPrivate::Done) {
599 setError(QAbstractSocket::ProxyAuthenticationRequiredError, tr("Authentication required"));
600 d->socket->disconnectFromHost();
601 } else {
602 // close the connection if it isn't already and reconnect using the chosen authentication method
603 d->state = SendAuthentication;
604 if (willClose) {
605 d->socket->connectToHost(d->proxy.hostName(), d->proxy.port());
606 } else {
607 bool ok;
608 int contentLength = responseHeader.value(QLatin1String("Content-Length")).toInt(&ok);
609 if (ok && contentLength > 0) {
610 d->state = ReadResponseContent;
611 d->pendingResponseData = contentLength;
612 goto readResponseContent;
613 } else {
614 d->state = SendAuthentication;
615 slotSocketConnected();
616 }
617 }
618 return;
619 }
620 } else {
621 d->socket->close();
622 setState(QAbstractSocket::UnconnectedState);
623 if (statusCode == 403 || statusCode == 405) {
624 // 403 Forbidden
625 // 405 Method Not Allowed
626 setError(QAbstractSocket::SocketAccessError, tr("Proxy denied connection"));
627 } else if (statusCode == 404) {
628 // 404 Not Found: host lookup error
629 setError(QAbstractSocket::HostNotFoundError, QAbstractSocket::tr("Host not found"));
630 } else if (statusCode == 503) {
631 // 503 Service Unavailable: Connection Refused
632 setError(QAbstractSocket::ConnectionRefusedError, QAbstractSocket::tr("Connection refused"));
633 } else {
634 // Some other reply
635 //qWarning("UNEXPECTED RESPONSE: [%s]", responseHeader.toString().toLatin1().data());
636 setError(QAbstractSocket::ProxyProtocolError, tr("Error communicating with HTTP proxy"));
637 }
638 }
639
640 // The handshake is done; notify that we're connected (or failed to connect)
641 emitConnectionNotification();
642}
643
644void QHttpSocketEngine::slotSocketBytesWritten()
645{
646 Q_D(QHttpSocketEngine);
647 if (d->state == Connected && d->writeNotificationEnabled)
648 emitWriteNotification();
649}
650
651void QHttpSocketEngine::slotSocketError(QAbstractSocket::SocketError error)
652{
653 Q_D(QHttpSocketEngine);
654 d->readBuffer.clear();
655
656 if (d->state != Connected) {
657 // we are in proxy handshaking stages
658 if (error == QAbstractSocket::HostNotFoundError)
659 setError(QAbstractSocket::ProxyNotFoundError, tr("Proxy server not found"));
660 else if (error == QAbstractSocket::ConnectionRefusedError)
661 setError(QAbstractSocket::ProxyConnectionRefusedError, tr("Proxy connection refused"));
662 else if (error == QAbstractSocket::SocketTimeoutError)
663 setError(QAbstractSocket::ProxyConnectionTimeoutError, tr("Proxy server connection timed out"));
664 else if (error == QAbstractSocket::RemoteHostClosedError)
665 setError(QAbstractSocket::ProxyConnectionClosedError, tr("Proxy connection closed prematurely"));
666 else
667 setError(error, d->socket->errorString());
668 emitConnectionNotification();
669 return;
670 }
671
672 // We're connected
673 if (error == QAbstractSocket::SocketTimeoutError)
674 return; // ignore this error
675
676 d->state = None;
677 setError(error, d->socket->errorString());
678 if (error == QAbstractSocket::RemoteHostClosedError) {
679 emitReadNotification();
680 } else {
681 qDebug() << "QHttpSocketEngine::slotSocketError: got weird error =" << error;
682 }
683}
684
685void QHttpSocketEngine::slotSocketStateChanged(QAbstractSocket::SocketState state)
686{
687 Q_UNUSED(state);
688}
689
690void QHttpSocketEngine::emitPendingReadNotification()
691{
692 Q_D(QHttpSocketEngine);
693 d->readNotificationPending = false;
694 if (d->readNotificationEnabled)
695 emit readNotification();
696}
697
698void QHttpSocketEngine::emitPendingWriteNotification()
699{
700 Q_D(QHttpSocketEngine);
701 d->writeNotificationPending = false;
702 if (d->writeNotificationEnabled)
703 emit writeNotification();
704}
705
706void QHttpSocketEngine::emitPendingConnectionNotification()
707{
708 Q_D(QHttpSocketEngine);
709 d->connectionNotificationPending = false;
710 emit connectionNotification();
711}
712
713void QHttpSocketEngine::emitReadNotification()
714{
715 Q_D(QHttpSocketEngine);
716 d->readNotificationActivated = true;
717 if (d->readNotificationEnabled && !d->readNotificationPending) {
718 d->readNotificationPending = true;
719 QMetaObject::invokeMethod(this, "emitPendingReadNotification", Qt::QueuedConnection);
720 }
721}
722
723void QHttpSocketEngine::emitWriteNotification()
724{
725 Q_D(QHttpSocketEngine);
726 d->writeNotificationActivated = true;
727 if (d->writeNotificationEnabled && !d->writeNotificationPending) {
728 d->writeNotificationPending = true;
729 QMetaObject::invokeMethod(this, "emitPendingWriteNotification", Qt::QueuedConnection);
730 }
731}
732
733void QHttpSocketEngine::emitConnectionNotification()
734{
735 Q_D(QHttpSocketEngine);
736 if (!d->connectionNotificationPending) {
737 d->connectionNotificationPending = true;
738 QMetaObject::invokeMethod(this, "emitPendingConnectionNotification", Qt::QueuedConnection);
739 }
740}
741
742QHttpSocketEnginePrivate::QHttpSocketEnginePrivate()
743 : readNotificationEnabled(false)
744 , writeNotificationEnabled(false)
745 , exceptNotificationEnabled(false)
746 , readNotificationActivated(false)
747 , writeNotificationActivated(false)
748 , readNotificationPending(false)
749 , writeNotificationPending(false)
750 , connectionNotificationPending(false)
751 , pendingResponseData(0)
752{
753 socket = 0;
754 state = QHttpSocketEngine::None;
755}
756
757QHttpSocketEnginePrivate::~QHttpSocketEnginePrivate()
758{
759}
760
761QAbstractSocketEngine *QHttpSocketEngineHandler::createSocketEngine(QAbstractSocket::SocketType socketType,
762 const QNetworkProxy &proxy,
763 QObject *parent)
764{
765 if (socketType != QAbstractSocket::TcpSocket)
766 return 0;
767
768 // proxy type must have been resolved by now
769 if (proxy.type() != QNetworkProxy::HttpProxy)
770 return 0;
771
772 // we only accept active sockets
773 if (!qobject_cast<QAbstractSocket *>(parent))
774 return 0;
775
776 QHttpSocketEngine *engine = new QHttpSocketEngine(parent);
777 engine->setProxy(proxy);
778 return engine;
779}
780
781QAbstractSocketEngine *QHttpSocketEngineHandler::createSocketEngine(int, QObject *)
782{
783 return 0;
784}
785
786QT_END_NAMESPACE
787
788#endif
Note: See TracBrowser for help on using the repository browser.