void Client::onDataReceived()
{
qDebug() << "onDataReceived():";
buf_+=socket_->readAll();
setSeen();
if (buf_.size()<3) return; // if we don't read header
if (getProtoId(buf_)!=CSPYP1_PROTOCOL_ID ||
getProtoVersion(buf_)!=CSPYP1_PROTOCOL_VERSION)
{
// wrong packet - disconnecting client
qDebug() << "PROTOCOL ERROR!";
disconnectFromHost();
return;
}
const Cspyp1Command command = getCommand(buf_);
for (quint32 i = 0; i < sizeof(CommandTable) / sizeof(*CommandTable); ++i)
{
if (CommandTable[i].command == command)
{
(this->*CommandTable[i].function)();
return;
}
}
qDebug() << "PROTOCOL ERROR!";
disconnectFromHost();
}
void QXmppIncomingClient::onDigestReply()
{
QXmppPasswordReply *reply = qobject_cast<QXmppPasswordReply *> (sender());
if (!reply)
return;
reply->deleteLater();
if (reply->error() == QXmppPasswordReply::TemporaryError)
{
warning (QString ("Temporary authentication failure for '%1' from %2").arg (d->saslServer->username(), d->origin()));
updateCounter ("incoming-client.auth.temporary-auth-failure");
sendPacket (QXmppSaslFailure ("temporary-auth-failure"));
disconnectFromHost();
return;
}
QByteArray challenge;
d->saslServer->setPasswordDigest (reply->digest());
QXmppSaslServer::Response result = d->saslServer->respond (reply->property ("__sasl_raw").toByteArray(), challenge);
if (result != QXmppSaslServer::Challenge)
{
warning (QString ("Authentication failed for '%1' from %2").arg (d->saslServer->username(), d->origin()));
updateCounter ("incoming-client.auth.not-authorized");
sendPacket (QXmppSaslFailure ("not-authorized"));
disconnectFromHost();
return;
}
// send new challenge
sendPacket (QXmppSaslChallenge (challenge));
}
void QXmppIncomingClient::onPasswordReply()
{
QXmppPasswordReply *reply = qobject_cast<QXmppPasswordReply*>(sender());
if (!reply)
return;
reply->deleteLater();
const QString username = reply->property("__sasl_username").toString();
switch (reply->error()) {
case QXmppPasswordReply::NoError:
d->username = username;
info(QString("Authentication succeeded for '%1'").arg(username));
sendData("<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl'/>");
break;
case QXmppPasswordReply::AuthorizationError:
warning(QString("Authentication failed for '%1'").arg(username));
sendData("<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><not-authorized/></failure>");
disconnectFromHost();
break;
case QXmppPasswordReply::TemporaryError:
warning(QString("Temporary authentication failure for '%1'").arg(username));
sendData("<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><temporary-auth-failure/></failure>");
disconnectFromHost();
break;
}
}
void QXmppIncomingServer::slotDialbackResponseReceived(const QXmppDialback &dialback)
{
QXmppOutgoingServer *stream = qobject_cast<QXmppOutgoingServer*>(sender());
if (!stream ||
dialback.command() != QXmppDialback::Verify ||
dialback.id() != d->localStreamId ||
dialback.from() != stream->remoteDomain())
return;
// relay verify response
QXmppDialback response;
response.setCommand(QXmppDialback::Result);
response.setTo(dialback.from());
response.setFrom(d->domain);
response.setType(dialback.type());
sendPacket(response);
// check for success
if (response.type() == QLatin1String("valid"))
{
info(QString("Verified incoming domain '%1' on %2").arg(dialback.from(), d->origin()));
const bool wasConnected = !d->authenticated.isEmpty();
d->authenticated.insert(dialback.from());
if (!wasConnected)
emit connected();
} else {
warning(QString("Failed to verify incoming domain '%1' on %2").arg(dialback.from(), d->origin()));
disconnectFromHost();
}
// disconnect dialback
stream->disconnectFromHost();
stream->deleteLater();
}
void
ScrobSocket::onReadyRead()
{
QByteArray bytes = readAll();
if (bytes != "OK\n") qWarning() << bytes.trimmed();
disconnectFromHost();
}
void QXmppOutgoingClient::handleStream(const QDomElement &streamElement)
{
if (d->state == QXmppOutgoingClientPrivate::Unset ||
d->state == QXmppOutgoingClientPrivate::TLSStarted ||
d->state == QXmppOutgoingClientPrivate::Authenticated) {
d->state = QXmppOutgoingClientPrivate::WaitingForStreamFeatures;
} else {
warning("handleStart in invalid state - disconnecting");
disconnectFromHost();
return;
}
if(d->streamId.isEmpty())
d->streamId = streamElement.attribute("id");
if (d->streamFrom.isEmpty())
d->streamFrom = streamElement.attribute("from");
if(d->streamVersion.isEmpty())
{
d->streamVersion = streamElement.attribute("version");
// no version specified, signals XMPP Version < 1.0.
// switch to old auth mechanism if enabled
if(d->streamVersion.isEmpty() && configuration().useNonSASLAuthentication()) {
sendNonSASLAuthQuery();
}
}
}
void BoxitSocket::timeOutDestroy() {
timeoutCount += 5;
// Disconnect after 3 minutes...
if (timeoutCount >= 180)
disconnectFromHost();
}
void QAsioTcpSocketParentPrivate::connectedHandler(const boost::system::error_code& error, boost::asio::ip::tcp::resolver::iterator iter)
{
if (!error) {
if (data_){
state_ = QAsioTcpSocketParent::ConnectedState;
erro_site = QAsioTcpSocketParent::NoError;
boost::asio::ip::tcp::endpoint peerPoint = socket_->remote_endpoint(erro_code);
peerIp = QString::fromStdString(peerPoint.address().to_string());
peerPort = peerPoint.port();
if (q) {
q->hostConnected();
socket_->async_read_some(boost::asio::buffer(data_,byteSize_),
stand_->wrap(boost::bind(&QAsioTcpSocketParentPrivate::readHandler,shared_from_this(),
boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred)));
setHeartTimeOut();
}
} else {
disconnectFromHost();
setError(error,QAsioTcpSocketParent::NoBufferSize);
}
} else {
boost::asio::ip::tcp::resolver::iterator end;
if(iter == end)
{
setError(error,QAsioTcpSocketParent::ConnectEorro);
}
}
}
void SmppClient::printErrorAndDisconnect(const Smpp::Error &e)
{
logMsg(QString("error: %e").arg(e.what()));
m_needInformAbountDisconnect = false;
emit disconnected(UnknownError);
disconnectFromHost();
}
void QXmppStream::_q_socketReadyRead()
{
d->dataBuffer.append(d->socket->readAll());
// handle whitespace pings
if (!d->dataBuffer.isEmpty() && d->dataBuffer.trimmed().isEmpty()) {
d->dataBuffer.clear();
handleStanza(QDomElement());
}
// FIXME : maybe these QRegExps could be static?
QRegExp startStreamRegex("^(<\\?xml.*\\?>)?\\s*<stream:stream.*>");
startStreamRegex.setMinimal(true);
QRegExp endStreamRegex("</stream:stream>$");
endStreamRegex.setMinimal(true);
// check whether we need to add stream start / end elements
//
// NOTE: as we may only have partial XML content, do not alter the stream's
// state until we have a valid XML document!
QByteArray completeXml = d->dataBuffer;
const QString strData = QString::fromUtf8(d->dataBuffer);
bool streamStart = false;
if (d->streamStart.isEmpty() && strData.contains(startStreamRegex))
streamStart = true;
else
completeXml.prepend(d->streamStart);
bool streamEnd = false;
if (strData.contains(endStreamRegex))
streamEnd = true;
else
completeXml.append(streamRootElementEnd);
// check whether we have a valid XML document
QDomDocument doc;
if (!doc.setContent(completeXml, true))
return;
// remove data from buffer
logReceived(strData);
d->dataBuffer.clear();
// process stream start
if (streamStart) {
d->streamStart = startStreamRegex.cap(0).toUtf8();
handleStream(doc.documentElement());
}
// process stanzas
QDomElement nodeRecv = doc.documentElement().firstChildElement();
while (!nodeRecv.isNull()) {
handleStanza(nodeRecv);
nodeRecv = nodeRecv.nextSiblingElement();
}
// process stream end
if (streamEnd)
disconnectFromHost();
}
void QXmppIncomingClient::onTimeout()
{
warning (QString ("Idle timeout for '%1' from %2").arg (d->jid, d->origin()));
disconnectFromHost();
// make sure disconnected() gets emitted no matter what
QTimer::singleShot (30, this, SIGNAL (disconnected()));
}
void QAsioTcpSocketParentPrivate::writeHandler(const boost::system::error_code& error, std::size_t bytes_transferred)
{
if (!error && q){
if (!q->writeDataed(bytes_transferred))
disconnectFromHost();
} else {
setError(error,QAsioTcpSocketParent::WriteEorro);
}
}
void Caster::onChannelClosed() {
Channel *c = static_cast<Channel*>(sender());
channels_.erase({c->destination_id_, c->source_id_});
if (c == platform_channel_) {
disconnectFromHost();
}
c->deleteLater();
}
void FrostbiteClient::onVersionCommand(const QString &type, int build)
{
Q_UNUSED(build);
if (GameType::fromString(type) != serverEntry->getGameType()) {
disconnectFromHost();
qDebug() << tr("Wrong server type, disconnecting...");
}
}
void SocketHandler::resetConnection(const QString &IP, int port)
{
_errorAppend = false;
_errorString = "";
if (_isConnected)
disconnectFromHost();
connectToHost(IP, port);
_isConnected = true;
}
void QXmppIncomingServer::handleStanza(const QDomElement &stanza)
{
const QString ns = stanza.namespaceURI();
if (ns == ns_tls && stanza.tagName() == QLatin1String("starttls"))
{
sendData("<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
socket()->flush();
socket()->startServerEncryption();
return;
}
else if (QXmppDialback::isDialback(stanza))
{
QXmppDialback request;
request.parse(stanza);
// check the request is valid
if (!request.type().isEmpty() ||
request.from().isEmpty() ||
request.to() != d->domain ||
request.key().isEmpty())
{
warning(QString("Invalid dialback received on %1").arg(d->origin()));
return;
}
const QString domain = request.from();
if (request.command() == QXmppDialback::Result)
{
debug(QString("Received a dialback result from '%1' on %2").arg(domain, d->origin()));
// establish dialback connection
QXmppOutgoingServer *stream = new QXmppOutgoingServer(d->domain, this);
bool check = connect(stream, SIGNAL(dialbackResponseReceived(QXmppDialback)),
this, SLOT(slotDialbackResponseReceived(QXmppDialback)));
Q_ASSERT(check);
Q_UNUSED(check);
stream->setVerify(d->localStreamId, request.key());
stream->connectToHost(domain);
}
else if (request.command() == QXmppDialback::Verify)
{
debug(QString("Received a dialback verify from '%1' on %2").arg(domain, d->origin()));
emit dialbackRequestReceived(request);
}
}
else if (d->authenticated.contains(QXmppUtils::jidToDomain(stanza.attribute("from"))))
{
// relay stanza if the remote party is authenticated
emit elementReceived(stanza);
} else {
warning(QString("Received an element from unverified domain '%1' on %2").arg(QXmppUtils::jidToDomain(stanza.attribute("from")), d->origin()));
disconnectFromHost();
}
}
void QAsioWebSocketParent::open(const QString & url)
{
if (_State == ConnectedState)
disconnectFromHost();
if (!Url::fromString(url,m_url)) {
emit error(tr("Invalid URL."));
return;
}
_State = ConnectingState;
}
void ChatServer::setIPAddressAndPort(QString ip, int port){
qDebug()<<"changing destination";
SocketState s = this->state();
this->_ipAddr = ip;
this->_port = port;
if(s == ConnectedState){
qDebug() << "Reconnecting";
emit disconnectFromHost();
emit reConnect();
}
}
void MainWindow::closeEvent(QCloseEvent*)
{
grabZoomKeys(false);
QSettings settings;
settings.setValue("show_toolbar", show_toolbar->isChecked());
settings.setValue("zoomlevel", zoom_slider->value());
settings.sync();
hide();
disconnectFromHost();
}
void QXmppIncomingClient::handleStream(const QDomElement &streamElement)
{
if (d->idleTimer->interval())
d->idleTimer->start();
d->saslStep = 0;
// start stream
const QByteArray sessionId = generateStanzaHash().toAscii();
QString response = QString("<?xml version='1.0'?><stream:stream"
" xmlns=\"%1\" xmlns:stream=\"%2\""
" id=\"%3\" from=\"%4\" version=\"1.0\" xml:lang=\"en\">").arg(
ns_client,
ns_stream,
sessionId,
d->domain.toAscii());
sendData(response.toUtf8());
// check requested domain
if (streamElement.attribute("to") != d->domain)
{
QString response = QString("<stream:error>"
"<host-unknown xmlns=\"urn:ietf:params:xml:ns:xmpp-streams\"/>"
"<text xmlns=\"urn:ietf:params:xml:ns:xmpp-streams\">"
"This server does not serve %1"
"</text>"
"</stream:error>").arg(streamElement.attribute("to"));
sendData(response.toUtf8());
disconnectFromHost();
return;
}
// send stream features
QXmppStreamFeatures features;
if (socket() && !socket()->isEncrypted() && !socket()->localCertificate().isNull() && !socket()->privateKey().isNull())
features.setTlsMode(QXmppStreamFeatures::Enabled);
if (!d->username.isEmpty())
{
features.setBindMode(QXmppStreamFeatures::Required);
features.setSessionMode(QXmppStreamFeatures::Enabled);
}
else if (d->passwordChecker)
{
QList<QXmppConfiguration::SASLAuthMechanism> mechanisms;
mechanisms << QXmppConfiguration::SASLPlain;
if (d->passwordChecker->hasGetPassword())
mechanisms << QXmppConfiguration::SASLDigestMD5;
features.setAuthMechanisms(mechanisms);
}
sendPacket(features);
}
void QXmppIncomingClient::onDigestReply()
{
QXmppPasswordReply *reply = qobject_cast<QXmppPasswordReply*>(sender());
if (!reply)
return;
reply->deleteLater();
const QMap<QByteArray, QByteArray> saslResponse = QXmppSaslDigestMd5::parseMessage(reply->property("__sasl_raw").toByteArray());
const QString username = QString::fromUtf8(saslResponse.value("username"));
if (reply->error() == QXmppPasswordReply::TemporaryError) {
warning(QString("Temporary authentication failure for '%1'").arg(username));
sendData("<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><temporary-auth-failure/></failure>");
disconnectFromHost();
return;
}
d->saslDigest.setSecret(reply->digest());
d->saslDigest.setDigestUri(saslResponse.value("digest-uri"));
d->saslDigest.setNc(saslResponse.value("nc"));
d->saslDigest.setCnonce(saslResponse.value("cnonce"));
if (saslResponse.value("response") != d->saslDigest.calculateDigest(
QByteArray("AUTHENTICATE:") + d->saslDigest.digestUri()))
{
sendData("<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><not-authorized/></failure>");
disconnectFromHost();
return;
}
// send new challenge
d->username = username;
d->saslStep = 2;
QMap<QByteArray, QByteArray> challenge;
challenge["rspauth"] = d->saslDigest.calculateDigest(
QByteArray(":") + d->saslDigest.digestUri());
const QByteArray data = QXmppSaslDigestMd5::serializeMessage(challenge).toBase64();
sendData("<challenge xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>" + data +"</challenge>");
}
void QXmppIncomingClient::onPasswordReply()
{
QXmppPasswordReply *reply = qobject_cast<QXmppPasswordReply *> (sender());
if (!reply)
return;
reply->deleteLater();
const QString jid = QString ("%1@%2").arg (d->saslServer->username(), d->domain);
switch (reply->error())
{
case QXmppPasswordReply::NoError:
d->jid = jid;
info (QString ("Authentication succeeded for '%1' from %2").arg (d->jid, d->origin()));
updateCounter ("incoming-client.auth.success");
sendPacket (QXmppSaslSuccess());
handleStart();
break;
case QXmppPasswordReply::AuthorizationError:
warning (QString ("Authentication failed for '%1' from %2").arg (jid, d->origin()));
updateCounter ("incoming-client.auth.not-authorized");
sendPacket (QXmppSaslFailure ("not-authorized"));
disconnectFromHost();
break;
case QXmppPasswordReply::TemporaryError:
warning (QString ("Temporary authentication failure for '%1' from %2").arg (jid, d->origin()));
updateCounter ("incoming-client.auth.temporary-auth-failure");
sendPacket (QXmppSaslFailure ("temporary-auth-failure"));
disconnectFromHost();
break;
}
}
void QFrankSSL::VerbindungTrennen()
{
#ifndef QT_NO_DEBUG
qDebug("%s VerbindungTrennen",this->metaObject()->className());
#endif
if(K_SSLStruktur==NULL)
return;
K_Verbindungsstatus=QFrankSSL::TRENNEN;
if(SSL_shutdown(K_SSLStruktur)==0)
SSL_shutdown(K_SSLStruktur);
if(K_MussWasGesendetWerden())
K_DatenSenden();
else
disconnectFromHost();
}
void TSocket::readClient()
{
qDebug() << "Client connected";
//read client query
QByteArray in1;
in1 = readAll();
qDebug() << in1;
QString data = QString::fromLocal8Bit( in1.data() );
QStringList list = data.simplified().split("\n");
data = list.at(0);
// send
execQuery( data );
QDataStream out( this );
out << qint64( 0xFFFF );
close();
disconnectFromHost();
waitForDisconnected();
/* QFile file("C:\\tt.txt");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QTextStream in(&file);
while( !in.atEnd() )
{
QString str = in.readLine();
sendString( str );
}
file.close();
QDataStream out( this );
out << qint64( 0xFFFF );
close();*/
//disconnectFromHost();
//waitForDisconnected();
}
void QFrankSSL::K_AllesZuruecksetzen()
{
#ifndef QT_NO_DEBUG
qDebug("%s K_AllesZuruecksetzen",this->metaObject()->className());
#endif
if(state()==QAbstractSocket::ConnectedState)
disconnectFromHost();
//SSL Struktur löschen
if(K_SSLStruktur!=NULL)
{
if(K_ListeDerSSLVerbindungen.contains(K_SSLStruktur))
K_ListeDerSSLVerbindungen.remove(K_SSLStruktur);
SSL_free(K_SSLStruktur);
}
K_SSLStruktur=NULL;
K_Verbindungsstatus=QFrankSSL::GETRENNT;
}
void Client::checkVersion(const QString &server_version){
QString client_version = Sanguosha->getVersion();
if(server_version == client_version)
return;
static QString link = "http://github.com/Moligaloo/QSanguosha/downloads";
QString text = tr("Server version is %1, client version is %2 <br/>").arg(server_version).arg(client_version);
if(server_version > client_version)
text.append(tr("Your client version is older than the server's, please update it <br/>"));
else
text.append(tr("The server version is older than your client version, please ask the server to update<br/>"));
text.append(tr("Download link : <a href='%1'>%1</a> <br/>").arg(link));
QMessageBox::warning(NULL, tr("Warning"), text);
disconnectFromHost();
}
void pServer::onConnection()
{
auto socket = _server.nextPendingConnection();
auto addr = socket->peerAddress();
auto it = _limits.find(addr);
if (it == _limits.end()) {
it = _limits.insert(addr, 0);
} else {
if (it.value() > pServer::LIMIT) {
socket->disconnectFromHost();
socket->deleteLater();
return;
}
}
// qDebug() << "Connected: " << socket->peerAddress().toString() << " with used limit " << it.value() << " bytes";
new pSocket(socket, pThreadPool::getNextThread(), it.value());
Logger::log(socket->peerAddress().toString() + socket->peerName(), it.value());
}
void QAsioTcpSocketParentPrivate::readHandler(const boost::system::error_code& error, std::size_t bytes_transferred)
{
if(!error){
if (bytes_transferred == 0){
disconnectFromHost();
return;
}
if (q) {
q->readDataed(data_,bytes_transferred);
socket_->async_read_some(boost::asio::buffer(data_,byteSize_),
stand_->wrap(boost::bind(&QAsioTcpSocketParentPrivate::readHandler,shared_from_this(),
boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred)));
if (timer && (timeOut_s > 0 )) {
timer->expires_from_now(boost::posix_time::seconds(timeOut_s));
}
}
} else {
setError(error,QAsioTcpSocketParent::ReadError);
}
}
void QAsioWebSocketParent::hostConnected()
{
if (!isServer) { //连接后，发送websocket协议的http请求
m_key = generateKey();
const QString handshake =
createHandShakeRequest(m_url.ResourceName(),
m_url.Host()
% QStringLiteral(":")
% QString::number(m_url.port(80)),
m_origin,
QString(),
QString(),
m_key);//新建key
if (handshake.isEmpty()) {
disconnectFromHost();
emit error(tr("链接发送数据错误"));
return;
}
write(handshake.toLatin1());//发送key
}
}
void EventClient::connectToHost(KodiHost *host)
{
if (m_socket >= 0) {
disconnectFromHost();
}
m_kodiHost = CAddress(host->address().toLatin1().data());
m_socket = socket(AF_INET, SOCK_DGRAM, 0);
if (m_socket < 0) {
qDebug() << "cannot create socket";
}
m_kodiHost.Bind(m_socket);
if (!m_thumbnail.isEmpty()) {
CPacketHELO HeloPackage("Kodimote", ICON_PNG, m_thumbnail.toLatin1().data());
HeloPackage.Send(m_socket, m_kodiHost);
} else {
CPacketHELO HeloPackage("Kodimote", ICON_NONE);
HeloPackage.Send(m_socket, m_kodiHost);
}
qDebug() << "connected to kodi" << m_socket;
}
