void SshConnectionPrivate::connectToHost()
{
QSSH_ASSERT_AND_RETURN(m_state == SocketUnconnected);
m_incomingData.clear();
m_incomingPacket.reset();
m_sendFacility.reset();
m_error = SshNoError;
m_ignoreNextPacket = false;
m_errorString.clear();
m_serverId.clear();
m_serverHasSentDataBeforeId = false;
try {
if (m_connParams.authenticationType == SshConnectionParameters::AuthenticationTypePublicKey)
createPrivateKey();
} catch (const SshClientException &ex) {
m_error = ex.error;
m_errorString = ex.errorString;
emit error(m_error);
return;
}
connect(m_socket, SIGNAL(connected()), this, SLOT(handleSocketConnected()));
connect(m_socket, SIGNAL(readyRead()), this, SLOT(handleIncomingData()));
connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this,
SLOT(handleSocketError()));
connect(m_socket, SIGNAL(disconnected()), this,
SLOT(handleSocketDisconnected()));
connect(&m_timeoutTimer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
m_state = SocketConnecting;
m_keyExchangeState = NoKeyExchange;
m_timeoutTimer.start();
m_socket->connectToHost(m_connParams.host, m_connParams.port);
}
void SmppClient::onReadyRead()
{
QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(sender());
if (socket) {
stopTimer();
m_buffer.append(socket->readAll());
handleIncomingData();
}
}
void SmppClient::handleIncomingData()
{
if (m_buffer.length() < 16) {
startTimer();
return;
}
SmppHeader header;
header.decode((const Smpp::Uint8 *)m_buffer.data());
if ((int)header.command_length() < m_buffer.length()) {
startTimer();
return;
}
Smpp::Uint32 commandId = header.command_id();
QByteArray pdu = m_buffer.mid(0, header.command_length());
m_buffer.remove(0, header.command_length());
switch (commandId) {
case Smpp::CommandId::SubmitSmResp:
handleSubmitSmResp(pdu);
break;
case Smpp::CommandId::BindTransceiverResp:
handleBindTransiverResp(pdu);
break;
case Smpp::CommandId::DeliverSm:
handleDeliverSm(pdu);
break;
case Smpp::CommandId::EnquireLinkResp:
handleEnquireLinkResp(pdu);
break;
default:
logMsg(QString("unsupported commandId: 0x%0")
.arg(commandId, 0x08, 0x10, QChar('0')));
break;
}
if (m_buffer.length()) {
handleIncomingData();
}
}
void DccChatThread::run()
{
KviDccThreadIncomingData data;
data.iLen = 0;
data.buffer = nullptr;
for(;;)
{
// Dequeue events
while(KviThreadEvent * e = dequeueEvent())
{
if(e->id() == KVI_THREAD_EVENT_TERMINATE)
{
delete e;
goto out_of_the_loop;
}
else
{
// Other events are senseless to us
delete e;
}
}
bool bCanRead;
bool bCanWrite;
if(kvi_select(m_fd, &bCanRead, &bCanWrite))
{
if(bCanWrite)
{
if(!tryFlushOutBuffers())
goto out_of_the_loop;
}
if(bCanRead)
{
data.buffer = (char *)KviMemory::reallocate(data.buffer, (data.iLen + 512) * sizeof(char));
int readLen;
#ifdef COMPILE_SSL_SUPPORT
if(m_pSSL)
{
readLen = m_pSSL->read(data.buffer + data.iLen, 512);
}
else
{
#endif
readLen = kvi_socket_recv(m_fd, data.buffer + data.iLen, 512);
#ifdef COMPILE_SSL_SUPPORT
}
#endif
if(readLen > 0)
{
data.iLen += readLen;
data.buffer = (char *)KviMemory::reallocate(data.buffer, data.iLen * sizeof(char));
if(!handleIncomingData(&data, false))
break; // non critical...
}
else
{
#ifdef COMPILE_SSL_SUPPORT
if(m_pSSL)
{
// ssl error....?
switch(m_pSSL->getProtocolError(readLen))
{
case KviSSL::ZeroReturn:
readLen = 0;
break;
case KviSSL::WantRead:
case KviSSL::WantWrite:
// hmmm...
break;
case KviSSL::SyscallError:
{
int iE = m_pSSL->getLastError(true);
if(iE != 0)
{
raiseSSLError();
postErrorEvent(KviError::SSLError);
goto out_of_the_loop;
}
}
break;
case KviSSL::SSLError:
{
raiseSSLError();
postErrorEvent(KviError::SSLError);
goto out_of_the_loop;
}
break;
default:
// Raise unknown SSL ERROR
postErrorEvent(KviError::SSLError);
goto out_of_the_loop;
break;
}
}
#endif
if(data.iLen > 0)
{
data.buffer = (char *)KviMemory::reallocate(data.buffer, data.iLen * sizeof(char));
}
else
{
KviMemory::free(data.buffer);
data.buffer = nullptr;
}
if(!handleInvalidSocketRead(readLen))
{
if(data.iLen)
handleIncomingData(&data, true); // critical
KVI_ASSERT(!data.iLen);
break; // error
}
}
}
msleep(100);
}
}
out_of_the_loop:
if(data.iLen)
KviMemory::free(data.buffer);
#ifdef COMPILE_SSL_SUPPORT
if(m_pSSL)
{
KviSSLMaster::freeSSL(m_pSSL);
m_pSSL = nullptr;
}
#endif
if(m_fd != KVI_INVALID_SOCKET)
::kvi_socket_close(m_fd);
m_fd = KVI_INVALID_SOCKET;
}
