int main(int argc, char *argv[])
{
QApplication a(argc, argv);
//a.removeLibraryPath(a.libraryPaths().first());
qRegisterMetaType<Song>("Song");
qRegisterMetaTypeStreamOperators<Song>("Song");
MainWindow w;
QStringList args = a.arguments();
QLocalSocket socket;
socket.connectToServer("iniTunes");
QTextStream stream(&socket);
if(socket.waitForConnected(3000))
{
stream <<QString::number(PLAY)<<endl;
stream << args.at(1) <<endl;
socket.waitForBytesWritten();
exit(0);
}
else
{
qDebug()<<"Launch";
w.show();
w.createRemote();
if(args.count()==2)
{
qDebug()<<"Open";
w.open(args.at(1));
}
}
return a.exec();
}
//
// Sending to the server is done synchronously, at startup.
// If the server isn't already running, startup continues,
// and the items in savedPaymentRequest will be handled
// when uiReady() is called.
//
bool PaymentServer::ipcSendCommandLine()
{
bool fResult = false;
for (const QString& r : savedPaymentRequests)
{
QLocalSocket* socket = new QLocalSocket();
socket->connectToServer(ipcServerName(), QIODevice::WriteOnly);
if (!socket->waitForConnected(BITCOIN_IPC_CONNECT_TIMEOUT))
{
delete socket;
socket = nullptr;
return false;
}
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_0);
out << r;
out.device()->seek(0);
socket->write(block);
socket->flush();
socket->waitForBytesWritten(BITCOIN_IPC_CONNECT_TIMEOUT);
socket->disconnectFromServer();
delete socket;
socket = nullptr;
fResult = true;
}
return fResult;
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
while (socket->bytesAvailable() < (int)sizeof(quint32))
socket->waitForReadyRead();
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0) {
qWarning("QtLocalPeer: Message reception failed %s", socket->errorString().toLatin1().constData());
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
socket->write(ack, qstrlen(ack));
socket->waitForBytesWritten(1000);
delete socket;
emit messageReceived(message); //### (might take a long time to return)
}
bool QtLocalPeer::sendMessage(const QString &message, int timeout)
{
if (!isClient())
return false;
QLocalSocket socket;
bool connOk = false;
for(int i = 0; i < 2; i++) {
// Try twice, in case the other instance is just starting up
socket.connectToServer(socketName);
connOk = socket.waitForConnected(timeout/2);
if (connOk || i)
break;
int ms = 250;
#if defined(Q_OS_WIN)
Sleep(DWORD(ms));
#else
struct timespec ts = { ms / 1000, (ms % 1000) * 1000 * 1000 };
nanosleep(&ts, NULL);
#endif
}
if (!connOk)
return false;
QByteArray uMsg(message.toUtf8());
QDataStream ds(&socket);
ds.writeBytes(uMsg.constData(), uMsg.size());
bool res = socket.waitForBytesWritten(timeout);
res &= socket.waitForReadyRead(timeout); // wait for ack
res &= (socket.read(qstrlen(ack)) == ack);
return res;
}
bool KNSingletonApplication::sendMessages(const QString &uniqueKey,
const QStringList &messages)
{
//Create sender client.
QLocalSocket client;
//Link to the server which is listening to the unique key.
client.connectToServer(uniqueKey, QIODevice::WriteOnly);
//If connecting failed, return false.
if(!client.waitForConnected(TimeoutLimit))
{
qDebug("Cannot connect to the local server.");
//Disconnect from the server.
client.disconnectFromServer();
return false;
}
//Generate the message data.
QByteArray messageData;
QDataStream dataWriter(&messageData, QIODevice::WriteOnly);
dataWriter << messages;
//Send the data to local server.
client.write(messageData);
//Check sending status.
if(!client.waitForBytesWritten(TimeoutLimit))
{
qDebug("Send arguments failed.");
client.disconnectFromServer();
return false;
}
//Send the arguments success.
client.disconnectFromServer();
return true;
}
bool Application::IsAlreadyRunning () const
{
QLocalSocket socket;
socket.connectToServer (GetSocketName ());
if (socket.waitForConnected () ||
socket.state () == QLocalSocket::ConnectedState)
{
QDataStream out (&socket);
out << Arguments_;
if (socket.waitForBytesWritten ())
return true;
if (socket.error() == QLocalSocket::UnknownSocketError)
return true;
}
else
{
switch (socket.error ())
{
case QLocalSocket::ServerNotFoundError:
case QLocalSocket::ConnectionRefusedError:
break;
default:
qWarning () << Q_FUNC_INFO
<< "socket error"
<< socket.error ();
return true;
}
}
// Clear any halted servers and their messages
QLocalServer::removeServer (GetSocketName ());
return false;
}
// Process incoming IPC command. First check if monero-wallet-gui is
// already running. If it is, send it to that instance instead, if not,
// queue the command for later use inside our QML engine. Returns true
// when queued, false if sent to another instance, at which point we can
// kill the current process.
bool IPC::saveCommand(QString cmdString){
qDebug() << QString("saveCommand called: %1").arg(cmdString);
QLocalSocket ls;
QByteArray buffer;
buffer = buffer.append(cmdString);
QString socketFilePath = this->socketFile().filePath();
ls.connectToServer(socketFilePath, QIODevice::WriteOnly);
if(ls.waitForConnected(1000)){
ls.write(buffer);
if (!ls.waitForBytesWritten(1000)){
qDebug() << QString("Could not send command \"%1\" over IPC %2: \"%3\"").arg(cmdString, socketFilePath, ls.errorString());
return false;
}
qDebug() << QString("Sent command \"%1\" over IPC \"%2\"").arg(cmdString, socketFilePath);
return false;
}
if(ls.isOpen())
ls.disconnectFromServer();
// Queue for later
this->SetQueuedCmd(cmdString);
return true;
}
void pqdbg_send_message(int lvl, const QString &msg, const QString &title)
{
#ifdef PQDEBUG
static QMutex mutex;
mutex.lock();
QLocalSocket *debugSocket = PHPQt5::debugSocket();
if(debugSocket->isOpen()) {
/*
QByteArray data;
QDataStream out(&data, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_0);
out << reinterpret_cast<quint64>(PQEngine::pqeEngine);
out << PQEngine::pqeCoreName;
out << lvl;
out << title;
out << msg;
out.device()->reset();
// = QString("%1:::%2:::%3:::%4:::%5:::%")
// .arg(reinterpret_cast<quint64>(PQEngine::pqeEngine))
// .arg(PQEngine::pqeCoreName)
// .arg(lvl)
// .arg(title)
// .arg(msg).toUtf8();
debugSocket->write(data);
debugSocket->waitForBytesWritten();
*/
QString str = QString("%1:::%2:::%3:::%4:::%5:::%6:::%")
.arg(reinterpret_cast<quint64>(PQEngine::pqeEngine))
.arg(PQEngine::pqeCoreName)
.arg(reinterpret_cast<quint64>(QThread::currentThread()))
.arg(lvl)
.arg(title)
.arg(msg).toUtf8();
/*
QByteArray block;
QDataStream sendStream(&block, QIODevice::ReadWrite);
sendStream << quint16(0) << str;
sendStream.device()->seek(0);
sendStream << (quint16)(block.size() - sizeof(quint16));
*/
debugSocket->write(str.toUtf8());
debugSocket->waitForBytesWritten();
}
mutex.unlock();
#else
Q_UNUSED(lvl);
Q_UNUSED(msg);
Q_UNUSED(title);
#endif
}
BrowserApplication::BrowserApplication(int &argc, char **argv, char *styleSheet,QSharedDataPointer<ProcessOptions> processOptions)
: QApplication(argc, argv)
, m_localServer(0)
, m_privateProfile(0)
, sawStyleSheetCommandLineOption(false)
, nextSessionNameIndex(1)
{
nameTemplate = QLatin1String("domterm-%1");
QCoreApplication::setOrganizationName(QLatin1String("DomTerm"));
QCoreApplication::setApplicationName(QLatin1String("QtDomTerm"));
QCoreApplication::setApplicationVersion(QLatin1String(QTDOMTERM_VERSION));
QString serverName = QCoreApplication::applicationName()
+ QString::fromLatin1(QT_VERSION_STR).remove('.') + QLatin1String("webengine");
if (styleSheet != NULL) {
m_stylesheetFilename = QString(styleSheet);
sawStyleSheetCommandLineOption = true;
}
m_fileSystemWatcher = new QFileSystemWatcher(this);
QLocalSocket socket;
socket.connectToServer(serverName);
if (socket.waitForConnected(500)) {
QDataStream stream(&socket);
stream << *processOptions;
socket.waitForBytesWritten();
return;
}
#if defined(Q_OS_OSX)
QApplication::setQuitOnLastWindowClosed(false);
#else
QApplication::setQuitOnLastWindowClosed(true);
#endif
m_localServer = new QLocalServer(this);
connect(m_localServer, SIGNAL(newConnection()),
this, SLOT(newLocalSocketConnection()));
if (!m_localServer->listen(serverName)
&& m_localServer->serverError() == QAbstractSocket::AddressInUseError) {
QLocalServer::removeServer(serverName);
if (!m_localServer->listen(serverName))
qWarning("Could not create local socket %s.", qPrintable(serverName));
}
#ifndef QT_NO_OPENSSL
if (!QSslSocket::supportsSsl()) {
QMessageBox::information(0, "Demo Browser",
"This system does not support OpenSSL. SSL websites will not be available.");
}
#endif
QString localSysName = QLocale::system().name();
installTranslator(QLatin1String("qt_") + localSysName);
QTimer::singleShot(0, this, SLOT(postLaunch()));
}
void ControlPeer::receiveConnection()
{
QLocalSocket* socket = p->server->nextPendingConnection();
if (!socket) {
return;
}
while (socket->bytesAvailable() < (int)sizeof(quint32)) {
socket->waitForReadyRead();
}
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0) {
qWarning("Guzum.ControlPeer: Message reception failed %s", socket->errorString().toLatin1().constData());
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
socket->write(ACK, qstrlen(ACK));
socket->waitForBytesWritten(1000);
delete socket;
// split message into the tokens, the format is the following:
// <method_name>\n<arg0>\n<arg1> etc
QStringList tokens = message.split("\n");
QString methodName = tokens[0];
if (methodName == SHOW_DIALOG_METHOD) {
showFileSelectorDialog();
} else if (methodName == OPEN_FILE_METHOD) {
if (tokens.size() == 2) {
// just open file using default gnupg home
QString filename = tokens[1];
editFile(filename);
} else if (tokens.size() == 3) {
// use file and custom gnupg home
QString filename = tokens[1];
QString gnupgHome = tokens[2];
editFile(filename, gnupgHome);
}
QString filename = message.mid(qstrlen(OPEN_FILE_METHOD)+1);
}
}
bool LH_QtPlugin_WebKit::sendQuit()
{
QLocalSocket sock;
sock.connectToServer("LCDHost_WebKitServer");
if( !sock.waitForConnected(100) ) return false;
WebKitCommand('Q').write(&sock);
sock.waitForBytesWritten(100);
sock.disconnectFromServer();
return true;
}
QSingleApplication::QSingleApplication(int argc, char **argv):QApplication(argc,argv)
{
_isRunning=false;
QCoreApplication::setApplicationName("localserver");
QString serverName=QCoreApplication::applicationName();
QLocalSocket socket;
socket.connectToServer(serverName);
if(socket.waitForConnected(500))
{
QTextStream stream(&socket);
QStringList args=QCoreApplication::arguments();
if(args.count()>1)
{
stream<<args.last();
}else
{
stream<<QString();
}
stream.flush();
qDebug()<<"Connected server,program will quit";
socket.waitForBytesWritten();
/**
*qApp->quit(); 此代码是用来退出事件循环的;在构造函数中,事件循环
*尚未启动,因此就无法退出. 最好就是设置标志判断在外部判断
*/
_isRunning=true;
return;
}
qDebug()<<"Can't connect to server,build a server";
server=new QLocalServer(this);
connect(server,SIGNAL(newConnection()),this,SLOT(newLocalConnection()));
if(server->listen(serverName))
{
//防止程序崩溃时,残留进程服务,移除之
if(server->serverError()==QAbstractSocket::AddressInUseError&&QFile::exists(server->serverName()))
{
QFile::remove(server->serverName());
server->listen(serverName);
}
}
}
int main(int argc, char *argv[])
{
//_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF );
//oldHandler = qInstallMsgHandler(msgHandler);
QApplication a(argc, argv);
QTranslator qtTranslator;
qtTranslator.load(":/lang/qt_" + QLocale::system().name(),
QLibraryInfo::location(QLibraryInfo::TranslationsPath));
a.installTranslator(&qtTranslator);
QTranslator myappTranslator;
myappTranslator.load(":/lang/xdcc_" + QLocale::system().name());
a.installTranslator(&myappTranslator);
_singular = new QSharedMemory("DCClient");
if(_singular->attach(QSharedMemory::ReadWrite))
{
_singular->detach();
if(argc >= 2)
{
QLocalSocket socket;
socket.connectToServer("DCClientIPC");
if(socket.waitForConnected())
{
QDataStream out(&socket);
out << QString(argv[1]);
socket.waitForBytesWritten();
}
}
return 0;
}
_singular->create(1);
QApplication::setQuitOnLastWindowClosed(false);
XDCC xdcc;
int ret = a.exec();
delete _singular;
return ret;
}
bool SingleApplication::sendMessage(const QString &message)
{
QLocalSocket socket;
socket.connectToServer(serverName());
if (socket.waitForConnected(500)) {
QTextStream stream(&socket);
stream << message;
stream.flush();
if (socket.waitForBytesWritten())
return true;
}
return false;
}
bool QtLocalPeer::serverSendMessage(const QString &message, int client_id, int timeout)
{
qDebug()<<__FILE__<<__LINE__<<__FUNCTION__<<client_id;
QLocalSocket *socket = NULL;
QHash<QLocalSocket*, int>::iterator it;
if (client_id == -1) {
// broadcast
for (it = this->clients.begin(); it != this->clients.end(); it++) {
socket = it.key();
// QByteArray uMsg(message.toUtf8());
// QDataStream ds(socket);
// ds.writeBytes(uMsg.constData(), uMsg.size());
socket->write(message.toAscii());
bool res = socket->waitForBytesWritten(timeout);
}
} else {
for (it = this->clients.begin(); it != this->clients.end(); it++) {
if (it.value() == client_id) {
socket = it.key();
}
}
if (socket) {
// qDebug()<<__FILE__<<__LINE__<<__FUNCTION__<<client_id;
// QByteArray uMsg(message.toUtf8());
// QDataStream ds(socket);
// ds.writeBytes(uMsg.constData(), uMsg.size());
socket->write(message.toAscii());
bool res = socket->waitForBytesWritten(timeout);
} else {
qDebug()<<"can not find socket for client:"<<client_id;
}
}
return true;
}
HOOK_EVAL_API void hook_eval(char* str,unsigned long length)
{
QByteArray string(str,length);
QLocalSocket socket;
socket.connectToServer("phpdecoder");
if ( socket.waitForConnected(1000) ) {
qDebug()<<"connected!";
qDebug()<<socket.write(string);
qDebug()<<socket.waitForBytesWritten(1000);
socket.close();
} else {
qDebug()<<socket.error()<<socket.errorString();
}
qDebug()<<string;
}
RKGraphicsDeviceBackendTransmitter* RKGraphicsDeviceBackendTransmitter::instance () {
if (_instance) return _instance;
RK_TRACE (GRAPHICS_DEVICE);
QLocalSocket *con = new QLocalSocket ();
con->connectToServer (RKRBackendProtocolBackend::rkdServerName ());
con->waitForConnected (2000);
if (con->state () == QLocalSocket::ConnectedState) {
con->write (RKRBackendTransmitter::instance ()->connectionToken ().toLocal8Bit ().data ());
con->write ("\n");
con->waitForBytesWritten (1000);
_instance = new RKGraphicsDeviceBackendTransmitter (con, true);
return _instance;
}
return 0;
}
void SocketHandler::newConnection()
{
sensordLogT() << "[SocketHandler]: New connection received.";
while (m_server->hasPendingConnections()) {
QLocalSocket* socket = m_server->nextPendingConnection();
connect(socket, SIGNAL(readyRead()), this, SLOT(socketReadable()));
connect(socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
connect(socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(socketError(QLocalSocket::LocalSocketError)));
// Initialize socket
socket->write("\n", 1);
socket->waitForBytesWritten();
}
}
bool SingleApplication::sendMessage(const QString &message)
{
QLocalSocket socket;
socket.connectToServer(serverName());
if (socket.waitForConnected(500)) {
QTextStream stream(&socket);
stream << message;
stream.flush();
if (socket.waitForBytesWritten())
return true;
// if the message was sent before waitForBytesWritten was called
// it will return false
if (socket.error() == QLocalSocket::UnknownSocketError)
return true;
}
return false;
}
int main(int argc,char *argv[])
{
QDir::setCurrent(QFileInfo(QString::fromLocal8Bit(argv[0])).absolutePath());
Local::addLibraryPath("./plugins");
Local::setStyle("Fusion");
Local a(argc,argv);
Config::load();
int single;
if((single=Config::getValue("/Interface/Single",1))){
QLocalSocket socket;
socket.connectToServer("BiliLocalInstance");
if(socket.waitForConnected()){
QDataStream s(&socket);
s<<a.arguments().mid(1);
socket.waitForBytesWritten();
return 0;
}
}
Shield::load();
loadTranslator();
setDefaultFont();
setToolTipBase();
a.connect(&a,&Local::aboutToQuit,[](){
Shield::save();
Config::save();
});
qsrand(QTime::currentTime().msec());
Interface w;
Plugin::loadPlugins();
w.show();
w.tryLocal(a.arguments().mid(1));
QLocalServer *server=NULL;
if(single){
server=new QLocalServer(qApp);
server->listen("BiliLocalInstance");
QObject::connect(server,&QLocalServer::newConnection,[&](){
QLocalSocket *r=server->nextPendingConnection();
r->waitForReadyRead();
QDataStream s(r);
QStringList args;
s>>args;
r->deleteLater();
w.tryLocal(args);
});
}
int main(int argc, char *argv[])
{
#if QT_NO_DEBUG
QLocalSocket socket;
socket.connectToServer(SERVER);
if(socket.waitForConnected(1000))
{
if (argc == 2)
{
socket.write(argv[1]);
socket.flush();
socket.waitForBytesWritten();
}
socket.disconnectFromServer();
exit(0);
}
else
{
if (argc != 1)
exit(0);
}
#endif
QApplication a(argc, argv);
MainWindow w;
QTranslator translator ;
translator.load("/usr/share/qt/translations/qt_cs");
a.installTranslator(&translator);
//w.show();
return a.exec();
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
while (socket->bytesAvailable() < (int)sizeof(quint32))
socket->waitForReadyRead();
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0) {
qWarning() << "QtLocalPeer: Message reception failed" << socket->errorString();
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
#ifdef Q_OS_WIN
if (message == "qbt://pid") {
qint64 pid = GetCurrentProcessId();
socket->write((const char *)&pid, sizeof pid);
} else {
socket->write(ack, qstrlen(ack));
}
#else
socket->write(ack, qstrlen(ack));
#endif
socket->waitForBytesWritten(1000);
delete socket;
#ifdef Q_OS_WIN
if (message == "qbt://pid")
return;
#endif
emit messageReceived(message); //### (might take a long time to return)
}
void SocketExternalInstance::loadFile(const QString &file_name) const
{
#ifdef _WIN32
::AllowSetForegroundWindow(-1);
#endif
QLocalSocket socket;
socket.connectToServer(GLOG_SERVICE_NAME);
if (!socket.waitForConnected(1000)) {
LOG( logERROR ) << "Failed to connect to socket";
return;
}
socket.write(file_name.toUtf8());
if (!socket.waitForBytesWritten(1000)) {
LOG( logERROR ) << "Failed to send filename";
}
socket.close();
}
bool Application::sendRaiseRequest()
{
if (!d_ptr->isRunning)
return false;
QLocalSocket localSocket;
localSocket.connectToServer(GUI_APPLICATION_SHARED_MEMORY_KEY, QIODevice::WriteOnly);
if (!localSocket.waitForConnected(GUI_APPLICATION_LOCAL_SOCKET_TIMEOUT))
return false;
localSocket.write(QString("raise").toUtf8());
if (!localSocket.waitForBytesWritten(GUI_APPLICATION_LOCAL_SOCKET_TIMEOUT))
return false;
localSocket.disconnectFromServer();
return true;
}
unsigned int LocalPeer::get_hwnd_and_activate()
{
unsigned int hwnd = 0;
#ifdef _WIN32
QLocalSocket socket;
bool connOk = false;
int timeout = 5000;
for(int i = 0; i < 2; i++)
{
socket.connectToServer(socket_name_);
connOk = socket.waitForConnected(timeout/2);
if (connOk || i)
break;
int ms = 250;
Sleep(DWORD(ms));
}
if (!connOk)
return false;
QByteArray uMsg((QString(crossprocess_message_get_hwnd_activate)).toUtf8());
QDataStream ds(&socket);
ds.writeBytes(uMsg.constData(), uMsg.size());
if (socket.waitForBytesWritten(timeout))
{
if (socket.waitForReadyRead(timeout))
{
QByteArray data_read = socket.readAll();
if (data_read.size() == sizeof(hwnd))
{
hwnd = *(unsigned int*) data_read.data();
}
}
}
#endif _WIN32
return hwnd;
}
void GPUSiftClient::operator ()(const cv::Mat1b &img,
const cv::Mat &mask,
std::vector<cv::KeyPoint> &keypoints,
std::vector<float> &descriptors) const
{
QLocalSocket socket;
socket.connectToServer("nestk_sift_gpu");
if (!socket.waitForConnected(1000))
{
ntk_dbg(0) << "Could not connect to GPU SIFT server!";
keypoints.clear();
descriptors.clear();
return;
}
// Send image
QDataStream stream(&socket);
ntk_dbg(2) << "Sending " << img.rows << " " << img.cols;
stream << (qint32)img.rows << (qint32)img.cols;
int num_bytes = stream.writeRawData((const char*)img.data, img.rows*img.cols);
ntk_assert(num_bytes == img.rows*img.cols, "Could not send all data");
// Read keypoints
socket.waitForReadyRead();
qint32 num_features = -1;
stream >> num_features;
ntk_dbg_print(num_features, 2);
keypoints.resize(num_features);
readFullRawData(socket, stream, (char*)&keypoints[0], num_features*sizeof(KeyPoint));
ntk_assert(stream.status() == QDataStream::Ok, "Bad transmission.");
descriptors.resize(num_features*descriptorSize());
readFullRawData(socket, stream, (char*)&descriptors[0],
num_features*descriptorSize()*sizeof(float));
ntk_assert(stream.status() == QDataStream::Ok, "Bad transmission.");
stream << (qint32) 42;
socket.waitForBytesWritten();
socket.disconnectFromServer();
}
void qt_flushOutBuffer()
{
if (!qt_initialized)
return;
// Write the block size at the beginning of the bock
QDataStream sizeStream(&qt_socket);
sizeStream << (quint32)(qt_outBuffer.size());
// Write the block to the QLocalSocket
qt_socket.write(qt_outBuffer);
// waitForBytesWritten(-1) is supposed implement this loop, but it does not seem to work !
// update: seems to work with Qt 4.5
while (qt_socket.bytesToWrite() > 0)
{
qt_socket.flush();
qt_socket.waitForBytesWritten(-1);
}
// Reset the buffer
qt_out.device()->seek(0);
qt_outBuffer.clear();
}
bool mASocketManager::openFileOnRemote(const QString &_path)
{
bool r = false;
QString path = QFileInfo(_path).canonicalFilePath();
path.append('\n');
QLocalSocket socket;
socket.connectToServer(MA_LOCAL_SERVER_NAME);
if(socket.waitForConnected(MAX_TIMEOUT_CLIENT))
{
socket.write(path.toUtf8());
socket.flush();
socket.waitForBytesWritten(MAX_TIMEOUT_CLIENT);
r = true;
}
socket.close();
return r;
}
QString ControlPeer::sendRawMessage(const QString & msg, int timeout)
{
if (mode() != ModeClient) {
p->error = NotInClientModeError;
return QString();
}
QString controlSocketPath = Guzum::Config::controlSocketPath();
QLocalSocket socket;
bool res = false;
socket.connectToServer(controlSocketPath);
res = socket.waitForConnected(timeout);
if (!res) {
p->error = ReadFailedError;
return QString();
}
QByteArray bytes(msg.toUtf8());
QByteArray responseBytes;
QDataStream ds(&socket);
ds.writeBytes(bytes.constData(), bytes.size());
res = socket.waitForBytesWritten(timeout);
if (res) {
res &= socket.waitForReadyRead(timeout); // wait for ack
if (res) {
responseBytes = socket.read(qstrlen(ACK));
res &= (responseBytes == ACK);
}
}
if (!res) {
p->error = ReadFailedError;
return QString();
}
p->error = NoError;
return QString::fromUtf8(responseBytes.constData());
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
// Why doesn't Qt have a blocking stream that takes care of this shait???
while (socket->bytesAvailable() < static_cast<int>(sizeof(quint32))) {
if (!socket->isValid()) // stale request
return;
socket->waitForReadyRead(1000);
}
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
//qDebug() << "RCV: remaining" << remaining;
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
//qDebug() << "RCV: got" << got << "remaining" << remaining;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
//### error check: got<0
if (got < 0) {
qWarning() << "QtLocalPeer: Message reception failed" << socket->errorString();
delete socket;
return;
}
// ### async this
QString message = QString::fromUtf8(uMsg.constData(), uMsg.size());
socket->write(ack, qstrlen(ack));
socket->waitForBytesWritten(1000);
emit messageReceived(message, socket); // ##(might take a long time to return)
}
