bool MjpegClient::connectTo(const QString& host, int port, QString url, const QString& user, const QString& pass)
{
if(url.isEmpty())
url = "/";
m_host = host;
m_port = port > 0 ? port : 80;
m_url = url;
m_user = user;
m_pass = pass;
if(m_socket)
{
m_socket->abort();
delete m_socket;
m_socket = 0;
}
m_socket = new QTcpSocket(this);
connect(m_socket, SIGNAL(readyRead()), this, SLOT(dataReady()));
connect(m_socket, SIGNAL(disconnected()), this, SLOT(lostConnection()));
connect(m_socket, SIGNAL(disconnected()), this, SIGNAL(socketDisconnected()));
connect(m_socket, SIGNAL(connected()), this, SIGNAL(socketConnected()));
connect(m_socket, SIGNAL(connected()), this, SLOT(connectionReady()));
connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SIGNAL(socketError(QAbstractSocket::SocketError)));
connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(lostConnection(QAbstractSocket::SocketError)));
m_socket->connectToHost(host,port);
m_socket->setReadBufferSize(1024 * 1024);
return true;
}
void
Acceptor::processEstablishedConnection(
int fd,
const SocketAddress& clientAddr,
std::chrono::steady_clock::time_point acceptTime,
TransportInfo& tinfo) noexcept {
if (accConfig_.isSSL()) {
CHECK(sslCtxManager_);
AsyncSSLSocket::UniquePtr sslSock(
makeNewAsyncSSLSocket(
sslCtxManager_->getDefaultSSLCtx(), base_, fd));
++numPendingSSLConns_;
++totalNumPendingSSLConns_;
if (totalNumPendingSSLConns_ > accConfig_.maxConcurrentSSLHandshakes) {
VLOG(2) << "dropped SSL handshake on " << accConfig_.name <<
" too many handshakes in progress";
updateSSLStats(sslSock.get(), std::chrono::milliseconds(0),
SSLErrorEnum::DROPPED);
sslConnectionError();
return;
}
new AcceptorHandshakeHelper(
std::move(sslSock),
this,
clientAddr,
acceptTime,
tinfo
);
} else {
tinfo.ssl = false;
tinfo.acceptTime = acceptTime;
AsyncSocket::UniquePtr sock(makeNewAsyncSocket(base_, fd));
connectionReady(std::move(sock), clientAddr, empty_string, tinfo);
}
}
/**
* Set up the client tcp socket for an incoming connection
*/
void TCPServer::newConnection()
{
client = server.nextPendingConnection();
connect(client, SIGNAL(disconnected()), this, SLOT(endConnection()), Qt::QueuedConnection);
connect(client, SIGNAL(readyRead()), this, SLOT(clientReadString()), Qt::QueuedConnection);
emit connectionReady();
}
void CoreConnection::connectToCurrentAccount()
{
if (_authHandler) {
qWarning() << Q_FUNC_INFO << "Already connected!";
return;
}
resetConnection(false);
if (currentAccount().isInternal()) {
if (Quassel::runMode() != Quassel::Monolithic) {
qWarning() << "Cannot connect to internal core in client-only mode!";
return;
}
emit startInternalCore();
InternalPeer *peer = new InternalPeer();
_peer = peer;
Client::instance()->signalProxy()->addPeer(peer); // sigproxy will take ownership
emit connectToInternalCore(peer);
setState(Connected);
return;
}
_authHandler = new ClientAuthHandler(currentAccount(), this);
connect(_authHandler, SIGNAL(disconnected()), SLOT(coreSocketDisconnected()));
connect(_authHandler, SIGNAL(connectionReady()), SLOT(onConnectionReady()));
connect(_authHandler, SIGNAL(socketError(QAbstractSocket::SocketError,QString)), SLOT(coreSocketError(QAbstractSocket::SocketError,QString)));
connect(_authHandler, SIGNAL(transferProgress(int,int)), SLOT(updateProgress(int,int)));
connect(_authHandler, SIGNAL(requestDisconnect(QString,bool)), SLOT(disconnectFromCore(QString,bool)));
connect(_authHandler, SIGNAL(errorMessage(QString)), SIGNAL(connectionError(QString)));
connect(_authHandler, SIGNAL(errorPopup(QString)), SIGNAL(connectionErrorPopup(QString)), Qt::QueuedConnection);
connect(_authHandler, SIGNAL(statusMessage(QString)), SIGNAL(connectionMsg(QString)));
connect(_authHandler, SIGNAL(encrypted(bool)), SIGNAL(encrypted(bool)));
connect(_authHandler, SIGNAL(startCoreSetup(QVariantList)), SIGNAL(startCoreSetup(QVariantList)));
connect(_authHandler, SIGNAL(coreSetupFailed(QString)), SIGNAL(coreSetupFailed(QString)));
connect(_authHandler, SIGNAL(coreSetupSuccessful()), SIGNAL(coreSetupSuccess()));
connect(_authHandler, SIGNAL(userAuthenticationRequired(CoreAccount*,bool*,QString)), SIGNAL(userAuthenticationRequired(CoreAccount*,bool*,QString)));
connect(_authHandler, SIGNAL(handleNoSslInClient(bool*)), SIGNAL(handleNoSslInClient(bool*)));
connect(_authHandler, SIGNAL(handleNoSslInCore(bool*)), SIGNAL(handleNoSslInCore(bool*)));
#ifdef HAVE_SSL
connect(_authHandler, SIGNAL(handleSslErrors(const QSslSocket*,bool*,bool*)), SIGNAL(handleSslErrors(const QSslSocket*,bool*,bool*)));
#endif
connect(_authHandler, SIGNAL(loginSuccessful(CoreAccount)), SLOT(onLoginSuccessful(CoreAccount)));
connect(_authHandler, SIGNAL(handshakeComplete(RemotePeer*,Protocol::SessionState)), SLOT(onHandshakeComplete(RemotePeer*,Protocol::SessionState)));
setState(Connecting);
_authHandler->connectToCore();
}
void
Acceptor::sslConnectionReady(AsyncSocket::UniquePtr sock,
const SocketAddress& clientAddr,
const string& nextProtocol,
TransportInfo& tinfo) {
CHECK(numPendingSSLConns_ > 0);
connectionReady(std::move(sock), clientAddr, nextProtocol, tinfo);
--numPendingSSLConns_;
--totalNumPendingSSLConns_;
if (state_ == State::kDraining) {
checkDrained();
}
}
void Acceptor::plaintextConnectionReady(
AsyncTransportWrapper::UniquePtr sock,
const SocketAddress& clientAddr,
const string& nextProtocolName,
SecureTransportType secureTransportType,
TransportInfo& tinfo) {
connectionReady(
std::move(sock),
clientAddr,
nextProtocolName,
secureTransportType,
tinfo);
}
void
Acceptor::connectionAccepted(
int fd, const TSocketAddress& clientAddr) noexcept {
if (!canAccept(clientAddr)) {
close(fd);
return;
}
auto acceptTime = getCurrentTime();
TransportInfo tinfo;
tinfo.acceptTime = acceptTime;
TAsyncSocket::UniquePtr sock(new TAsyncSocket(base_, fd));
connectionReady(std::move(sock), clientAddr, empty_string, tinfo);
}
void
Acceptor::processEstablishedConnection(
int fd,
const SocketAddress& clientAddr,
std::chrono::steady_clock::time_point acceptTime,
TransportInfo& tinfo) noexcept {
if (accConfig_.isSSL()) {
CHECK(sslCtxManager_);
AsyncSSLSocket::UniquePtr sslSock(
makeNewAsyncSSLSocket(
sslCtxManager_->getDefaultSSLCtx(), base_, fd));
++numPendingSSLConns_;
++totalNumPendingSSLConns_;
if (totalNumPendingSSLConns_ > accConfig_.maxConcurrentSSLHandshakes) {
VLOG(2) << "dropped SSL handshake on " << accConfig_.name <<
" too many handshakes in progress";
auto error = SSLErrorEnum::DROPPED;
auto latency = std::chrono::milliseconds(0);
updateSSLStats(sslSock.get(), latency, error);
auto ex = folly::make_exception_wrapper<SSLException>(
error, latency, sslSock->getRawBytesReceived());
sslConnectionError(ex);
return;
}
startHandshakeManager(
std::move(sslSock),
this,
clientAddr,
acceptTime,
tinfo);
} else {
tinfo.ssl = false;
tinfo.acceptTime = acceptTime;
AsyncSocket::UniquePtr sock(makeNewAsyncSocket(base_, fd));
connectionReady(
std::move(sock),
clientAddr,
empty_string,
SecureTransportType::NONE,
tinfo);
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
settings = new QSettings("Maiznet", "TSProxy");
socket = new QTcpSocket(this);
connect(socket, SIGNAL(readyRead()), this, SLOT(dataReady()));
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(displayError(QAbstractSocket::SocketError)));
connect(socket, SIGNAL(connected()), this, SLOT(connectionReady()));
connect(this, SIGNAL(newConnectionStatus(bool)), this, SLOT(connectionStatusChanged(bool)));
ui->ts_proxy_host->setText(getFavoriteProxyHost());
ui->ts_proxy_port->setValue(getFavoriteProxyPort());
ui->ts_server_host->setText(getFavoriteTSHost());
ui->ts_server_port->setValue(getFavoriteTSPort());
}
int TCPReceiver::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: stringRead((*reinterpret_cast< QByteArray(*)>(_a[1]))); break;
case 1: connectionError((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 2: connectionReady(); break;
case 3: connectionNotReady(); break;
case 4: newConnection(); break;
case 5: endConnection(); break;
case 6: clientWriteString((*reinterpret_cast< QByteArray(*)>(_a[1]))); break;
case 7: { QByteArray _r = clientReadString();
if (_a[0]) *reinterpret_cast< QByteArray*>(_a[0]) = _r; } break;
case 8: stop(); break;
default: ;
}
_id -= 9;
}
return _id;
}
void ServSock::sss_connectionReady(int s)
{
connectionReady(s);
}
void ServSockSignal::newConnection(int x)
{
connectionReady(x);
}
