QTcpSocket有时会阻塞动态创建的java脚本

我正试图通过代理连接到一个网站。我实现了一个qtcserver和一个qtcsocket。 服务器将连接传递到套接字。 它工作得很好，但是对于某些站点，特别是那些动态创建javascript的站点，套接字在某个点上会阻塞，导航器中不会显示任何内容。 附上密码，希望清楚

            #include "webproxy.h"
            #include <QtNetwork>
            #include <QMessageBox>
            #include <QtGui>
            #include <QHash>


            WebProxy::WebProxy(QObject *parent,int port): QObject(parent)

                {
                    qDebug()<<" Listen...";
                    authMethod = "";
                    QTcpServer *proxyServer = new QTcpServer(this);
                    if (!proxyServer->listen(QHostAddress::Any, port)) {
                       emit error(1);

                        return;
                    }

                    connect(proxyServer, SIGNAL(newConnection()), this, SLOT(manageQuery()));
                    qDebug() << "Proxy server running at port" << proxyServer->serverPort();






            void WebProxy::manageQuery() {
                    QTcpServer *proxyServer = qobject_cast<QTcpServer*>(sender());
                    QTcpSocket *socket = proxyServer->nextPendingConnection();
                    connect(socket, SIGNAL(readyRead()), this, SLOT(processQuery()));
                    connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));

                    qDebug()<<"New connection started..."<<socket->peerAddress();
                }
            QUrl WebProxy::getUrl(QList<QByteArray > &entries)
               {

                   QByteArray method = entries.value(0);
                   QByteArray address = entries.value(1);
                   QByteArray version = entries.value(2);

                   qDebug()<<method;
                   qDebug()<<address;
                   qDebug()<<version;
                   QUrl url = QUrl::fromEncoded(address);
                   if (!url.isValid()) {

                       qWarning() << "Invalid URL:" << url;

                       return QString();
                   }


                   return url;
               }

              void WebProxy::processQuery() {

                    int wSize = 0;
                    QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender());
                    QByteArray requestData = socket->readAll();


             qDebug()<<"Request "<<requestData;

                    int pos = requestData.indexOf("\r\n");


                    QByteArray requestLine = requestData.left(pos);
                    requestData.remove(0, pos + 2);

                    QList<QByteArray> entries = requestLine.split(' ');
                    QByteArray method         = entries.value(0);
                    QByteArray address        = entries.value(1);
                    QByteArray version        = entries.value(2);

                    QByteArray auth;
                    QByteArray authMethod;

                    QUrl url = QUrl::fromEncoded(address);
                    if (!url.isValid()) {
                        qWarning() << "Invalid URL:" << url;
                        socket->disconnectFromHost();
                        return;
                    }

                    QString host              = url.host();


                    int port = (url.port() <= 0) ? 80 : url.port();
                    QByteArray req = url.encodedPath();
                    if (url.hasQuery())
                        req.append('?').append(url.encodedQuery());


                    requestLine = method + " " + req + " " + version + "\r\n";
                    if (!authMethod.isEmpty())
                    {
                         requestLine.append(requestLine);
                         requestLine.append(authMethod);
                         requestLine.append("\r\n");
                     }

                    QString key = host + ':' + QString::number(port);
                    QTcpSocket *proxySocket = socket->findChild<QTcpSocket*>(key);

                    if (proxySocket) {
                        proxySocket->setObjectName(key);
                        proxySocket->setProperty("url", url);
                        proxySocket->setProperty("requestData", requestData);
                        wSize = proxySocket->write(requestData);


                    } else {
                        proxySocket = new QTcpSocket(socket);
                        proxySocket->setObjectName(key);
                        proxySocket->setProperty("url", url);
                        proxySocket->setProperty("requestData", requestData);
                        connect(proxySocket, SIGNAL(connected()), this, SLOT(sendRequest()));
                        connect(proxySocket, SIGNAL(readyRead()), this, SLOT(transferData()));
                        connect(proxySocket, SIGNAL(disconnected()), this, SLOT(closeConnection()));
                        connect(proxySocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(closeConnection()));
                        proxySocket->connectToHost(host, port);
                    }
                }

            void WebProxy::sendRequest() {
                    QTcpSocket *proxySocket = qobject_cast<QTcpSocket*>(sender());
                    QByteArray requestData = proxySocket->property("requestData").toByteArray();
                    int wSize = 0;
                    wSize     = proxySocket->write(requestData);

                }

            void WebProxy::transferData() {


                    QTcpSocket *proxySocket = qobject_cast<QTcpSocket*>(sender());

                    QByteArray data = proxySocket->readAll();

            qDebug()<<"READ TRANSFER SIZE..."<<data.size();

                    QString host = proxySocket->peerAddress().toString();
                    QByteArray    filtered(data);

                    QTcpSocket *socket  = qobject_cast<QTcpSocket*>(proxySocket->parent());
                    int wSize           = 0;
                    if (!data.trimmed().isEmpty())
                    {
                        wSize = socket->write(filtered);
                        if (wSize==-1)
                             qDebug()<<"WP error";
                        else
                             qDebug()<<"TRANSFER WRITE SIZE = "<<wSize<<" READ SIZE"<<filtered.size();

                    }

                }

            void WebProxy::closeConnection() {

                    QTcpSocket *proxySocket = qobject_cast<QTcpSocket*>(sender());
                    if (proxySocket) {
                        QTcpSocket *socket = qobject_cast<QTcpSocket*>(proxySocket->parent());
                        if (socket)
                            socket->disconnectFromHost();
                        if (proxySocket->error() != QTcpSocket::RemoteHostClosedError)
                            qWarning() << "Error for:" << proxySocket->property("url").toUrl()
                                    << proxySocket->errorString();
                        proxySocket->deleteLater();;
                    }
                }

#包括“webproxy.h”
#包括
#包括
#包括
#包括
WebProxy:：WebProxy（QObject*父对象，int端口）：QObject（父对象）
{
qDebug（）您可能希望以多线程方式使用
qtcserver

子类
qtcserver
，重载
qtcserver:：incomingConnection（int）
，创建
QThread
派生处理程序（下面介绍），并使用
QThread:：start

子类
QThread
，使构造函数接受
int
（套接字描述符），重载
QThread:：run（）
。在run函数中，创建
qtcsocket
，调用
QAbstractSocket:：setSocketDescriptor
初始化套接字，连接套接字插槽并调用
QThread:：exec（）
启动线程事件循环

确保在
QThread
的
run
中创建套接字，而不是在构造函数中创建套接字，以便套接字与该线程相关联

有关更多详细信息，请查看您可能希望以多线程方式使用的
QTcpServer

子类
qtcserver
，重载
qtcserver:：incomingConnection（int）
，创建
QThread
派生处理程序（下面介绍），并使用
QThread:：start

子类
QThread
，使构造函数接受
int
（套接字描述符），重载
QThread:：run（）
。在run函数中，创建
qtcsocket
，调用
QAbstractSocket:：setSocketDescriptor
初始化套接字，连接套接字插槽并调用
QThread:：exec（）
启动线程事件循环

确保在
QThread
的
run
中创建套接字，而不是在构造函数中创建套接字，以便套接字与该线程相关联

有关更多详细信息，请参阅