void QSslServer::incomingConnection(qintptr socket) { QSslSocket *pSslSocket = new QSslSocket(); if (Q_LIKELY(pSslSocket)) { pSslSocket->setSslConfiguration(m_sslConfiguration); if (Q_LIKELY(pSslSocket->setSocketDescriptor(socket))) { typedef void (QSslSocket::* sslErrorsSignal)(const QList<QSslError> &); #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 2) connect(pSslSocket, &QSslSocket::peerVerifyError, this, &QSslServer::peerVerifyError); connect(pSslSocket, &QSslSocket::encrypted, this, &QSslServer::newEncryptedConnection); #else connect(pSslSocket,SIGNAL(peerVerifyError(QSslError)), this, SIGNAL(peerVerifyError(QSslError))); connect(pSslSocket, SIGNAL(sslErrors(QList<QSslError>)), this, SIGNAL(sslErrors(QList<QSslError>))); connect(pSslSocket, SIGNAL(encrypted()), this, SIGNAL(newEncryptedConnection())); #endif addPendingConnection(pSslSocket); pSslSocket->startServerEncryption(); } else { delete pSslSocket; } } }
void NetInterface::startArrangedConnection(NetConnection *conn) { conn->setConnectionState(NetConnection::SendingPunchPackets); addPendingConnection(conn); conn->mConnectSendCount = 0; conn->mConnectLastSendTime = getCurrentTime(); sendPunchPackets(conn); }
void CListenerSocket::incomingConnection(qintptr socketDescriptor) { CServerSocket * pSock = new CServerSocket(); pSock->setSocketDescriptor(socketDescriptor); connect(pSock,SIGNAL(MessageReady(QString)),this,SLOT(OnIncomingMessage(QString))); serverSockets.push_back(pSock); addPendingConnection(pSock); nextPendingConnection(); }
void SslServer::incomingConnection(qintptr handle) { QSslSocket *socket = new QSslSocket(this); socket->setSocketDescriptor(handle); socket->setLocalCertificate(_cert); socket->setPrivateKey(_key); addPendingConnection(socket); }
void QWsServer::incomingConnection( int socketDescriptor ) { QTcpSocket * tcpSocket = new QTcpSocket( tcpServer ); tcpSocket->setSocketDescriptor( socketDescriptor, QAbstractSocket::ConnectedState ); QWsSocket * wsSocket = new QWsSocket( this, tcpSocket ); addPendingConnection( wsSocket ); emit newConnection(); }
void NetInterface::startConnection(NetConnection *conn) { TNLAssert(conn->getConnectionState() == NetConnection::NotConnected, "Cannot start unless it is in the NotConnected state."); addPendingConnection(conn); conn->mConnectSendCount = 0; conn->setConnectionState(NetConnection::AwaitingChallengeResponse); sendConnectChallengeRequest(conn); }
//! [1] void SslServer::incomingConnection(qintptr socketDescriptor) { QSslSocket *serverSocket = new QSslSocket; if (serverSocket->setSocketDescriptor(socketDescriptor)) { addPendingConnection(serverSocket); connect(serverSocket, &QSslSocket::encrypted, this, &SslServer::ready); serverSocket->startServerEncryption(); } else { delete serverSocket; } }
// Intercept new socket connection and enable SSL void SslServer::incomingConnection(int socketDescriptor) { QSslSocket *serverSocket = new QSslSocket(); if (serverSocket->setSocketDescriptor(socketDescriptor)) { addPendingConnection (serverSocket); } else { delete serverSocket; } }
void NetInterface::startConnection(NetConnection *conn) { addPendingConnection(conn); conn->mConnectionSendCount = 0; conn->setConnectSequence(Platform::getVirtualMilliseconds()); conn->setConnectionState(NetConnection::AwaitingChallengeResponse); // This is a the client side of the connection, so set the connection to // server flag. We need to set this early so that if the connection times // out, its onRemove() will handle the cleanup properly. conn->setIsConnectionToServer(); // Everything set, so send off the request. sendConnectChallengeRequest(conn); }
void Server::incomingConnection(int socketDescriptor) { QTcpSocket *socket = new QTcpSocket(this); socket->setSocketDescriptor(socketDescriptor); addPendingConnection(socket); #ifdef DEBUG qDebug("\nServer::incomingConnection(%i): %s:%i", socketDescriptor, qPrintable(socket->peerAddress().toString()), socket->peerPort()); #endif connect(socket, SIGNAL(disconnected()), SLOT(client_disconnected())); connect(socket, SIGNAL(readyRead()), SLOT(client_readyRead())); m_clients.insert(socket, new Client); QccPacket(QccPacket::ConnectionAccepted).send(socket); // QccPacket::ConnectionRefused #ifdef DEBUG qDebug("ConnectionAccepted"); #endif }
/*! Called when a new connection is established. Converts \a socket to a QSslSocket. \internal */ void QSslServer::incomingConnection(qintptr socket) { QSslSocket *pSslSocket = new QSslSocket(); if (Q_LIKELY(pSslSocket)) { pSslSocket->setSslConfiguration(m_sslConfiguration); if (Q_LIKELY(pSslSocket->setSocketDescriptor(socket))) { connect(pSslSocket, &QSslSocket::peerVerifyError, this, &QSslServer::peerVerifyError); typedef void (QSslSocket::* sslErrorsSignal)(const QList<QSslError> &); connect(pSslSocket, static_cast<sslErrorsSignal>(&QSslSocket::sslErrors), this, &QSslServer::sslErrors); connect(pSslSocket, &QSslSocket::encrypted, this, &QSslServer::newEncryptedConnection); addPendingConnection(pSslSocket); pSslSocket->startServerEncryption(); } else { delete pSslSocket; } } }
/*! \internal */ void QWebSocketServerPrivate::handshakeReceived() { if (Q_UNLIKELY(!currentSender)) { return; } QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(currentSender->sender); if (Q_UNLIKELY(!pTcpSocket)) { return; } //When using Google Chrome the handshake in received in two parts. //Therefore, the readyRead signal is emitted twice. //This is a guard against the BEAST attack. //See: https://www.imperialviolet.org/2012/01/15/beastfollowup.html //For Safari, the handshake is delivered at once //FIXME: For FireFox, the readyRead signal is never emitted //This is a bug in FireFox (see https://bugzilla.mozilla.org/show_bug.cgi?id=594502) if (!pTcpSocket->canReadLine()) { return; } disconnect(pTcpSocket, &QTcpSocket::readyRead, this, &QWebSocketServerPrivate::handshakeReceived); Q_Q(QWebSocketServer); bool success = false; bool isSecure = false; if (m_pendingConnections.length() >= maxPendingConnections()) { pTcpSocket->close(); pTcpSocket->deleteLater(); setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection, QWebSocketServer::tr("Too many pending connections.")); return; } QWebSocketHandshakeRequest request(pTcpSocket->peerPort(), isSecure); QTextStream textStream(pTcpSocket); request.readHandshake(textStream, MAX_HEADERLINE_LENGTH, MAX_HEADERLINES); if (request.isValid()) { QWebSocketCorsAuthenticator corsAuthenticator(request.origin()); Q_EMIT q->originAuthenticationRequired(&corsAuthenticator); QWebSocketHandshakeResponse response(request, m_serverName, corsAuthenticator.allowed(), supportedVersions(), supportedProtocols(), supportedExtensions()); if (response.isValid()) { QTextStream httpStream(pTcpSocket); httpStream << response; httpStream.flush(); if (response.canUpgrade()) { QWebSocket *pWebSocket = QWebSocketPrivate::upgradeFrom(pTcpSocket, request, response); if (pWebSocket) { addPendingConnection(pWebSocket); Q_EMIT q->newConnection(); success = true; } else { setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection, QWebSocketServer::tr("Upgrade to WebSocket failed.")); } } else { setError(response.error(), response.errorString()); } } else { setError(QWebSocketProtocol::CloseCodeProtocolError, QWebSocketServer::tr("Invalid response received.")); } } if (!success) { pTcpSocket->close(); } }
void QWsServer::dataReceived() { QTcpSocket * tcpSocket = qobject_cast<QTcpSocket*>( sender() ); if (tcpSocket == 0) return; bool allHeadersFetched = false; const QLatin1String emptyLine("\r\n"); while ( tcpSocket->canReadLine() ) { QString line = tcpSocket->readLine(); if (line == emptyLine) { allHeadersFetched = true; break; } headerBuffer[ tcpSocket ].append(line); } if (!allHeadersFetched) return; QString request( headerBuffer[ tcpSocket ].join("") ); QRegExp regExp; regExp.setMinimal( true ); // Extract mandatory datas // Version regExp.setPattern( QWsServer::regExpVersionStr ); regExp.indexIn(request); QString versionStr = regExp.cap(1); EWebsocketVersion version; if ( ! versionStr.isEmpty() ) { version = (EWebsocketVersion)versionStr.toInt(); } else if ( tcpSocket->bytesAvailable() >= 8 ) { version = WS_V0; request.append( tcpSocket->read(8) ); } else { version = WS_VUnknow; } // Resource name regExp.setPattern( QWsServer::regExpResourceNameStr ); regExp.indexIn(request); QString resourceName = regExp.cap(1); // Host (address & port) regExp.setPattern( QWsServer::regExpHostStr ); regExp.indexIn(request); QString host = regExp.cap(1); QStringList hostTmp = host.split(':'); QString hostAddress = hostTmp[0]; QString hostPort; if ( hostTmp.size() > 1 ) hostPort = hostTmp.last(); // fix for IPv6 // Key QString key, key1, key2, key3; if ( version >= WS_V4 ) { regExp.setPattern( QWsServer::regExpKeyStr ); regExp.indexIn(request); key = regExp.cap(1); } else { regExp.setPattern( QWsServer::regExpKey1Str ); regExp.indexIn(request); key1 = regExp.cap(1); regExp.setPattern( QWsServer::regExpKey2Str ); regExp.indexIn(request); key2 = regExp.cap(1); regExp.setPattern( QWsServer::regExpKey3Str ); regExp.indexIn(request); key3 = regExp.cap(1); } //////////////////////////////////////////////////////////////////// // If the mandatory fields are not specified, we abord the connection to the Websocket server if ( version == WS_VUnknow || resourceName.isEmpty() || hostAddress.isEmpty() || ( key.isEmpty() && ( key1.isEmpty() || key2.isEmpty() || key3.isEmpty() ) ) ) { // Send bad request response QString response = QWsServer::composeBadRequestResponse( QList<EWebsocketVersion>() << WS_V6 << WS_V7 << WS_V8 << WS_V13 ); tcpSocket->write( response.toUtf8() ); tcpSocket->flush(); return; } //////////////////////////////////////////////////////////////////// // Extract optional datas // Origin regExp.setPattern( QWsServer::regExpOriginStr ); if ( regExp.indexIn(request) == -1 ) { regExp.setPattern( QWsServer::regExpOrigin2Str ); regExp.indexIn(request); } QString origin = regExp.cap(1); // Protocol regExp.setPattern( QWsServer::regExpProtocolStr ); regExp.indexIn(request); QString protocol = regExp.cap(1); // Extensions regExp.setPattern( QWsServer::regExpExtensionsStr ); regExp.indexIn(request); QString extensions = regExp.cap(1); //////////////////////////////////////////////////////////////////// // Compose opening handshake response QString response; if ( version >= WS_V6 ) { QString accept = computeAcceptV4( key ); response = QWsServer::composeOpeningHandshakeResponseV6( accept, protocol ); } else if ( version >= WS_V4 ) { QString accept = computeAcceptV4( key ); QString nonce = generateNonce(); response = QWsServer::composeOpeningHandshakeResponseV4( accept, nonce, protocol ); } else { QString accept = computeAcceptV0( key1, key2, key3 ); response = QWsServer::composeOpeningHandshakeResponseV0( accept, origin, hostAddress, hostPort, resourceName , protocol ); } // Handshake OK, disconnect readyRead disconnect( tcpSocket, SIGNAL(readyRead()), this, SLOT(dataReceived()) ); // Send opening handshake response if ( version == WS_V0 ) tcpSocket->write( response.toLatin1() ); else tcpSocket->write( response.toUtf8() ); tcpSocket->flush(); QWsSocket * wsSocket = new QWsSocket( this, tcpSocket, version ); wsSocket->setResourceName( resourceName ); wsSocket->setHost( host ); wsSocket->setHostAddress( hostAddress ); wsSocket->setHostPort( hostPort.toInt() ); wsSocket->setOrigin( origin ); wsSocket->setProtocol( protocol ); wsSocket->setExtensions( extensions ); wsSocket->serverSideSocket = true; // ORIGINAL CODE //int socketDescriptor = tcpSocket->socketDescriptor(); //incomingConnection( socketDescriptor ); // CHANGED CODE FOR LINUX COMPATIBILITY addPendingConnection( wsSocket ); emit newConnection(); }
void QWsServer::dataReceived() { QTcpSocket * clientSocket = qobject_cast<QTcpSocket*>(sender()); if (clientSocket == 0) return; QString request( clientSocket->readAll() ); QRegExp regExp; regExp.setMinimal( true ); // Extract mandatory datas // Version regExp.setPattern( QWsServer::regExpVersionStr ); regExp.indexIn(request); QString versionStr = regExp.cap(1); int version = 0; if ( ! versionStr.isEmpty() ) version = versionStr.toInt(); // Resource name regExp.setPattern( QWsServer::regExpResourceNameStr ); regExp.indexIn(request); QString resourceName = regExp.cap(1); // Host (address & port) regExp.setPattern( QWsServer::regExpHostStr ); regExp.indexIn(request); QStringList sl = regExp.cap(1).split(':'); QString hostAddress = sl[0]; QString hostPort; if ( sl.size() > 1 ) hostPort = sl[1]; // Key QString key, key1, key2, key3; if ( version >= 6 ) { regExp.setPattern( QWsServer::regExpKeyStr ); regExp.indexIn(request); key = regExp.cap(1); } else { regExp.setPattern( QWsServer::regExpKey1Str ); regExp.indexIn(request); key1 = regExp.cap(1); regExp.setPattern( QWsServer::regExpKey2Str ); regExp.indexIn(request); key2 = regExp.cap(1); regExp.setPattern( QWsServer::regExpKey3Str ); regExp.indexIn(request); key3 = regExp.cap(1); } // Extract optional datas // Origin QString origin; if ( version < 6 || version > 8 ) { regExp.setPattern( QWsServer::regExpOriginStr ); regExp.indexIn(request); origin = regExp.cap(1); } else { regExp.setPattern( QWsServer::regExpOriginV6Str ); regExp.indexIn(request); origin = regExp.cap(1); } // Protocol regExp.setPattern( QWsServer::regExpProtocolStr ); regExp.indexIn(request); QString protocol = regExp.cap(1); // Extensions regExp.setPattern( QWsServer::regExpExtensionsStr ); regExp.indexIn(request); QString extensions = regExp.cap(1); //////////////////////////////////////////////////////////////////// if ( version < 6 ) { qDebug() << "======== Handshake Received \n" << request << "======== \n"; } // If the mandatory params are not setted, we abord the connection to the Websocket server if ( hostAddress.isEmpty() || resourceName.isEmpty() || ( key.isEmpty() && ( key1.isEmpty() || key2.isEmpty() || key3.isEmpty() ) ) ) return; //////////////////////////////////////////////////////////////////// // Compose handshake answer QString answer; QString accept; if ( version >= 6 ) { accept = computeAcceptV2( key ); answer.append("HTTP/1.1 101 Switching Protocols\r\n"); answer.append("Upgrade: websocket\r\n"); answer.append("Connection: Upgrade\r\n"); answer.append("Sec-WebSocket-Accept: " + accept + "\r\n" + "\r\n"); } else if ( version < 6 ) { accept = computeAcceptV1( key1, key2, key3 ); answer.append("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"); answer.append("Upgrade: Websocket\r\n"); answer.append("Connection: Upgrade\r\n"); answer.append("Sec-WebSocket-Origin: " + origin + "\r\n"); answer.append("Sec-WebSocket-Location: ws://" + hostAddress + ( hostPort.isEmpty() ? "" : (":"+hostPort) ) + resourceName + "\r\n"); if ( !protocol.isEmpty() ) answer.append("Sec-WebSocket-Protocol: " + protocol + "\r\n"); answer.append( accept ); } if ( version < 6 ) { qDebug() << "======== Handshake sent \n" << answer << "======== \n"; } // Handshake OK, new connection disconnect(clientSocket, SIGNAL(readyRead()), this, SLOT(dataReceived())); // Send handshake answer clientSocket->write( answer.toUtf8() ); clientSocket->flush(); // TEMPORARY CODE FOR LINUX COMPATIBILITY QWsSocket * wsSocket = new QWsSocket( clientSocket, this ); addPendingConnection( wsSocket ); emit newConnection(); /* // ORIGINAL CODE int socketDescriptor = clientSocket->socketDescriptor(); incomingConnection( socketDescriptor ); */ }