QString SignalProxy::IODevicePeer::address() const { QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(_device); if(socket) return socket->peerAddress().toString(); else return QString(); }
QAbstractSocketEngine *QHttpSocketEngineHandler::createSocketEngine(const QHostAddress &address, QAbstractSocket::SocketType socketType, QObject *parent) { if (socketType != QAbstractSocket::TcpSocket) return 0; if (address == QHostAddress::LocalHost || address == QHostAddress::LocalHostIPv6) return 0; // find proxy info QAbstractSocket *abstractSocket = qobject_cast<QAbstractSocket *>(parent); if (!abstractSocket) return 0; QNetworkProxy proxy = abstractSocket->proxy(); if (proxy.type() == QNetworkProxy::DefaultProxy) proxy = QNetworkProxy::applicationProxy(); if (proxy.type() != QNetworkProxy::HttpProxy) return 0; QHttpSocketEngine *engine = new QHttpSocketEngine(parent); engine->setProxy(proxy); return engine; }
uint32_t TQIODeviceTransport::read(uint8_t* buf, uint32_t len) { uint32_t actualSize; qint64 readSize; if (!dev_->isOpen()) { throw TTransportException(TTransportException::NOT_OPEN, "read(): underlying QIODevice is not open"); } actualSize = (uint32_t)std::min((qint64)len, dev_->bytesAvailable()); readSize = dev_->read(reinterpret_cast<char *>(buf), actualSize); if (readSize < 0) { QAbstractSocket* socket; if ((socket = qobject_cast<QAbstractSocket* >(dev_.get()))) { throw TTransportException(TTransportException::UNKNOWN, "Failed to read() from QAbstractSocket", socket->error()); } throw TTransportException(TTransportException::UNKNOWN, "Failed to read from from QIODevice"); } return (uint32_t)readSize; }
void SharedDaemon::AddNewClient(const std::string &host, const stringVector &args, void *cbdata) { /// Send appropriate message for TCP or WebConnection void** data = (void**)cbdata; ConnectionType typeOfConnection = *((ConnectionType*)(data[0])); QAbstractSocket* socket = static_cast<QAbstractSocket*>(data[1]); ViewerState* viewerState = static_cast<ViewerState*>(data[2]); JSONNode node; QString hostname = typeOfConnection == TcpConnection ? socket->localAddress().toString(): dynamic_cast<QWsSocket*>(socket)->internalSocket()->localAddress().toString(); if(hostMap.contains(hostname)) hostname = hostMap[hostname]; node["host"] = hostname.toStdString(); //host node["port"] = args[7]; //port node["version"] = args[2]; //version node["securityKey"] = args[9]; //key node["numStates"] = viewerState->GetNumStateObjects(); //number of states JSONNode::JSONArray rpc_array = JSONNode::JSONArray(); for(size_t i = 0; i < ViewerRPC::MaxRPC; ++i) { rpc_array.push_back(ViewerRPC::ViewerRPCType_ToString((ViewerRPC::ViewerRPCType)i)); } node["rpc_array"] = rpc_array; if(typeOfConnection == TcpConnection) { QTcpSocket *tsocket = dynamic_cast<QTcpSocket*>(socket); std::string message = node.ToString(); tsocket->write(message.c_str(),message.length()); if(tsocket->state() != QAbstractSocket::UnconnectedState) tsocket->waitForBytesWritten(); tsocket->disconnectFromHost(); if(tsocket->state() != QAbstractSocket::UnconnectedState) tsocket->waitForDisconnected(); //HKTODO: Do not delete connection (test fix for ORNL machines) //tsocket->deleteLater(); } else { QWsSocket *wsocket = dynamic_cast<QWsSocket*>(socket); wsocket->write(QString(node.ToString().c_str())); wsocket->flush(); if(wsocket->internalSocket()->state() != QAbstractSocket::UnconnectedState) wsocket->internalSocket()->waitForBytesWritten(); wsocket->close(""); wsocket->internalSocket()->disconnectFromHost(); if(wsocket->internalSocket()->state() != QAbstractSocket::UnconnectedState) wsocket->internalSocket()->waitForDisconnected(); wsocket->deleteLater(); } }
bool HttpServerResponse::flush() { QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(&priv->device); if (!socket) return false; return socket->flush(); }
void SmppClient::onReadyRead() { QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(sender()); if (socket) { stopTimer(); m_buffer.append(socket->readAll()); handleIncomingData(); } }
void SslTlsSocket::handleSocketError(QAbstractSocket::SocketError err) { Q_UNUSED(err); QAbstractSocket *sock = qobject_cast<QAbstractSocket *>(d); Q_ASSERT(sock); delayedDisconnect->stop(); emit disconnected(tr("The underlying socket is having troubles when processing connection to %1:%2: %3").arg( host, QString::number(port), sock->errorString())); }
void SslTlsSocket::handleStateChanged() { /* Qt delivers the stateChanged() signal before the error() one. That's a problem because we really want to provide a nice error message to the user and QAbstractSocket::error() is not set yet by the time this function executes. That's why we have to delay the first disconnected() signal. */ QAbstractSocket *sock = qobject_cast<QAbstractSocket *>(d); Q_ASSERT(sock); QString proxyMsg; switch (sock->proxy().type()) { case QNetworkProxy::NoProxy: break; case QNetworkProxy::HttpCachingProxy: Q_ASSERT_X(false, "proxy detection", "Qt should have returned a proxy capable of tunneling, but we got back an HTTP proxy."); break; case QNetworkProxy::FtpCachingProxy: Q_ASSERT_X(false, "proxy detection", "Qt should have returned a proxy capable of tunneling, but we got back an FTP proxy."); break; case QNetworkProxy::DefaultProxy: proxyMsg = tr(" (via proxy %1)").arg(sock->proxy().hostName()); break; case QNetworkProxy::Socks5Proxy: proxyMsg = tr(" (via SOCKS5 proxy %1)").arg(sock->proxy().hostName()); break; case QNetworkProxy::HttpProxy: proxyMsg = tr(" (via HTTP proxy %1)").arg(sock->proxy().hostName()); break; } switch (sock->state()) { case QAbstractSocket::HostLookupState: emit stateChanged(Imap::CONN_STATE_HOST_LOOKUP, tr("Looking up %1%2...").arg(host, sock->proxy().capabilities().testFlag(QNetworkProxy::HostNameLookupCapability) ? proxyMsg : QString())); break; case QAbstractSocket::ConnectingState: emit stateChanged(Imap::CONN_STATE_CONNECTING, tr("Connecting to %1:%2%3%4...").arg( host, QString::number(port), startEncrypted ? tr(" (SSL)") : QString(), sock->proxy().capabilities().testFlag(QNetworkProxy::TunnelingCapability) ? proxyMsg : QString())); break; case QAbstractSocket::BoundState: case QAbstractSocket::ListeningState: break; case QAbstractSocket::ConnectedState: if (! startEncrypted) { emit stateChanged(Imap::CONN_STATE_CONNECTED_PRETLS_PRECAPS, tr("Connected")); } else { emit stateChanged(Imap::CONN_STATE_SSL_HANDSHAKE, tr("Negotiating encryption...")); } break; case QAbstractSocket::UnconnectedState: case QAbstractSocket::ClosingState: disconnectedMessage = tr("Socket is disconnected: %1").arg(sock->errorString()); delayedDisconnect->start(); break; } }
bool SignalProxy::IODevicePeer::isSecure() const { #ifdef HAVE_SSL QSslSocket *sslSocket = qobject_cast<QSslSocket *>(_device); if(sslSocket) return sslSocket->isEncrypted() || sslSocket->localAddress() == QHostAddress::LocalHost || sslSocket->localAddress() == QHostAddress::LocalHostIPv6; #endif QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(_device); if(socket) return socket->localAddress() == QHostAddress::LocalHost || socket->localAddress() == QHostAddress::LocalHostIPv6; return false; }
qint64 Worker::writeAndFlush(QIODevice* device, const char* buf, int size) { if (device) { qint64 res = device->write(buf, size); QAbstractSocket* sock = qobject_cast<QAbstractSocket*>(device); if (sock) { sock->flush(); } return res; } return -1; }
QIODevice* EmbraceChunker::newDevice() { QAbstractSocket* lsocket = new QAbstractSocket(QAbstractSocket::UnknownSocketType, 0); int sock = socket(PF_INET, SOCK_PACKET, htons(ETH_P_ALL)); if (sock < 0) { std::cerr << "socket : %s\n" << strerror(errno) << std::endl; } if (setsockopt(sock, SOL_SOCKET, SO_RCVBUFFORCE, (char *)&_socketBufferSize, sizeof(unsigned long long)) < 0) { std::cerr << "sock opt : %s\n" << strerror(errno) << std::endl; } lsocket->setSocketDescriptor(sock); return lsocket; }
void TQIODeviceTransport::flush() { if (!dev_->isOpen()) { throw TTransportException(TTransportException::NOT_OPEN, "flush(): underlying QIODevice is not open"); } QAbstractSocket* socket; if ((socket = qobject_cast<QAbstractSocket*>(dev_.get()))) { socket->flush(); } else { dev_->waitForBytesWritten(1); } }
/** * @see http://tools.ietf.org/html/rfc1929 * * Once the SOCKS V5 server has started, and the client has selected the * Username/Password Authentication protocol, the Username/Password * subnegotiation begins. This begins with the client producing a * Username/Password request: * * +----+------+----------+------+----------+ * |VER | ULEN | UNAME | PLEN | PASSWD | * +----+------+----------+------+----------+ * | 1 | 1 | 1 to 255 | 1 | 1 to 255 | * +----+------+----------+------+----------+ * * The VER field contains the current version of the subnegotiation, * which is X'01'. The ULEN field contains the length of the UNAME field * that follows. The UNAME field contains the username as known to the * source operating system. The PLEN field contains the length of the * PASSWD field that follows. The PASSWD field contains the password * association with the given UNAME. */ void Worker::authenticate(void) { int size = this->m_buf.size(); if (-1 == this->m_expected_length) { if (size > 1) { quint8 ver = static_cast<quint8>(this->m_buf.at(0)); int ulen = static_cast<quint8>(this->m_buf.at(1)); if (size > 2 + ulen) { int plen = static_cast<quint8>(this->m_buf.at(ulen + 2)); this->m_expected_length = ulen + plen + 3; } if (ver != 1) { this->m_state = Worker::FatalErrorState; Q_EMIT this->error(Worker::ProtocolVersionMismatch); return; } } } if (this->m_expected_length != -1 && size > this->m_expected_length) { this->m_state = Worker::FatalErrorState; Q_EMIT this->error(Worker::TooMuchData); return; } if (size == this->m_expected_length) { int ulen = static_cast<quint8>(this->m_buf.at(1)); int plen = static_cast<quint8>(this->m_buf.at(ulen + 2)); QByteArray username = ulen ? QByteArray(this->m_buf.constData() + 2, ulen) : QByteArray(); QByteArray password = plen ? QByteArray(this->m_buf.constData() + 2 + ulen + 1, plen) : QByteArray(); QByteArray hostname; this->m_expected_length = -1; this->m_buf.clear(); QAbstractSocket* sock = qobject_cast<QAbstractSocket*>(this->m_peer); if (sock) { hostname = sock->peerAddress().toString().toLocal8Bit(); } if (this->m_noauth_allowed && username.isEmpty() && password.isEmpty()) { this->acceptAuthentication(); } else { Q_EMIT this->authenticateRequest(username, password, hostname); } } }
QXmlStreamReader::TokenType Parser::Private::blockingReadNext() { QXmlStreamReader::TokenType token = QXmlStreamReader::Invalid; forever { token = reader.readNext(); if (reader.error() == QXmlStreamReader::PrematureEndOfDocumentError) { if (reader.device()->waitForReadyRead(1000)) { // let's try again continue; } else { // device error, e.g. remote host closed connection, or timeout // ### we have no way to know if waitForReadyRead() timed out or failed with a real // error, and sensible heuristics based on QIODevice fail. // - error strings are translated and in any case not guaranteed to stay the same, // so we can't use them. // - errorString().isEmpty() does not work because errorString() is // "network timeout error" if the waitFor... timed out. // - isSequential() [for socket] && isOpen() doesn't work because isOpen() // returns true if the remote host closed the connection. // ...so we fall back to knowing it might be a QAbstractSocket. QIODevice *dev = reader.device(); QAbstractSocket *sock = qobject_cast<QAbstractSocket *>(dev); if (!sock || sock->state() != QAbstractSocket::ConnectedState) { throw ParserException(dev->errorString()); } } } else if (reader.hasError()) { throw ParserException(reader.errorString()); //TODO add line, column? break; } else { // read a valid next token break; } } return token; }
void EmbraceChunker::next(QIODevice* device) { QAbstractSocket* socket = static_cast<QAbstractSocket*>(device); WritableData writableData = getDataStorage(_sizeOfFrame); int readTotal = 0; if (writableData.isValid() ) { do { int read = socket->read((char*)writableData.ptr() + readTotal*sizeof(char) , _sizeOfFrame); if( read == -1 ) { std::cerr << "read error"; // TODO - clean up and annul writableData } readTotal += read; } while ( readTotal < _sizeOfFrame ); } else { // TODO dump the data here std::cerr << "EmbraceChunker: " "WritableData is not valid!" << std::endl; } }
void XmlRpcServer::incomingConnection( int socketDescriptor ) { #ifdef DEBUG_XMLRPC qDebug() << this << "new incoming connection"; #endif QAbstractSocket * s = NULL; #ifndef QT_NO_OPENSSL if ( sslParams != NULL && !sslParams->certificate.isNull() ) { s = new QSslSocket( this ); s->setSocketDescriptor( socketDescriptor ); ((QSslSocket *)s)->setLocalCertificate( sslParams->certificate ); ((QSslSocket *)s)->setPrivateKey( sslParams->privateKey ); ((QSslSocket *)s)->setCaCertificates( sslParams->ca ); } else { s = new QTcpSocket( this ); s->setSocketDescriptor( socketDescriptor ); } #else s = new QTcpSocket( this ); s->setSocketDescriptor( socketDescriptor ); #endif Q_ASSERT( s->state() == QAbstractSocket::ConnectedState ); connect( s, SIGNAL(disconnected()), this, SLOT(slotSocketDisconnected()) ); HttpServer * p = new HttpServer( s ); connect( p, SIGNAL(protocolTimeout(Protocol*)), this, SLOT(slotProtocolTimeout(Protocol*)) ); connect( p, SIGNAL(parseError(HttpServer*)), this, SLOT(slotParseError(HttpServer*)) ); connect( p, SIGNAL(requestReceived(HttpServer*, const QHttpRequestHeader&, const QByteArray&)), this, SLOT(slotRequestReceived(HttpServer*, const QHttpRequestHeader&, const QByteArray&)) ); connect( p, SIGNAL(replySent(HttpServer*)), this, SLOT(slotReplySent(HttpServer*)) ); }
uint32_t TQIODeviceTransport::write_partial(const uint8_t* buf, uint32_t len) { qint64 written; if (!dev_->isOpen()) { throw TTransportException(TTransportException::NOT_OPEN, "write_partial(): underlying QIODevice is not open"); } written = dev_->write(reinterpret_cast<const char*>(buf), len); if (written < 0) { QAbstractSocket* socket; if ((socket = qobject_cast<QAbstractSocket*>(dev_.get()))) { throw TTransportException(TTransportException::UNKNOWN, "write_partial(): failed to write to QAbstractSocket", socket->error()); } throw TTransportException(TTransportException::UNKNOWN, "write_partial(): failed to write to underlying QIODevice"); } return (uint32_t)written; }
void Controler::newConection(){ QAbstractSocket * socket = tcpServer->nextPendingConnection(); qDebug()<<trUtf8("Получено соединение: %1:%2").arg(socket->peerAddress().toString()).arg(socket->peerPort()); }
void Graph::onSocketError(QAbstractSocket::SocketError) { QAbstractSocket *socket = (QAbstractSocket *)sender(); qDebug() << " socket error: " << socket->errorString(); socket->deleteLater(); }
bool SslTlsSocket::isDead() { QAbstractSocket *sock = qobject_cast<QAbstractSocket *>(d); Q_ASSERT(sock); return sock->state() != QAbstractSocket::ConnectedState; }