bool N810GpsPlugin::sendToGpsDriverCtrl(QString cmd)
{
QLocalSocket *gpsCtrlSocket;
gpsCtrlSocket = new QLocalSocket(this);
QByteArray socketPath = ( "/var/lib/gps/gps_driver_ctrl");
gpsCtrlSocket->connectToServer(socketPath.data());
if(gpsCtrlSocket->waitForConnected()) {
qLog(Hardware)<< __PRETTY_FUNCTION__ << "connected" << cmd;
QByteArray data;
data.append(cmd);
data.append("\n");
gpsCtrlSocket->write(data);
gpsCtrlSocket->flush();
gpsCtrlSocket->disconnectFromServer();
return true;
} else {
qLog(Hardware) << __PRETTY_FUNCTION__ << "Could not connect to socket" << gpsCtrlSocket;
}
return false;
}
int QmKeysPrivate::getKeyValue(const struct input_event &query) {
// Try to connect to qmkeyd.
QLocalSocket socket;
socket.connectToServer(SERVER_NAME);
if (!socket.waitForConnected(1000)) {
return -1;
}
// Query for the given key
if (socket.write((char*)&query, sizeof(query)) != sizeof(query)) {
return -1;
}
if (!socket.waitForReadyRead(1000)) {
return -1;
}
struct input_event response;
int ret = 0;
// A loop because we might receive other events as well.
do {
ret = socket.read((char*)&response, sizeof(response));
if (ret == sizeof(response)) {
if (response.type == query.type && response.code == query.code) {
break;
}
}
} while (ret == sizeof(response));
socket.disconnect();
return response.value;
}
bool SingleInstance::hasPrevious(const QString &name, const QStringList &args)
{
qDebug() << "Checking for previous instance...";
QLocalSocket socket;
socket.connectToServer(name, QLocalSocket::ReadWrite);
if (socket.waitForConnected())
{
qDebug() << "Connection found!";
qDebug() << "Forwarding argument to existing instance...";
QByteArray buffer;
for (auto item : args)
{
buffer.append(item+"\n");
}
qDebug() << "Forwading buffer=" << buffer;
socket.write(buffer);
return true;
}
qDebug() << socket.errorString();
qDebug() << "No connection found";
return false;
}
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;
}
int main(void)
{
QLocalSocket socket;
socket.connectToServer(SOCK_PATH);
socket.open(QIODevice::ReadWrite);
printf("Connected.\n");
char str[100];
while(printf("> "), fgets(str, 100, stdin), !feof(stdin)) {
if (socket.write(str, strlen(str)) == -1) {
perror("send");
return EXIT_FAILURE;
}
int t;
if ((t = socket.read(str, 100)) > 0) {
str[t] = '\0';
printf("echo> %s", str);
} else {
if (t < 0)
perror("recv");
else
printf("Server closed connection.\n");
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
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;
}
void sendData(QLocalSocket& sock, int num) {
qDebug("send %d", num);
QByteArray block;
QDataStream ds(&block, QIODevice::WriteOnly);
ds << num;
sock.write(block);
}
// 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 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)
}
//
// 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 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
}
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);
}
}
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)
}
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;
}
static bool sendData(const QByteArray &out, QByteArray *in)
{
#if USE_LOCAL_SOCKETS
QLocalSocket socket;
socket.connectToServer("gdrdeamon");
#else
QTcpSocket socket;
socket.connectToHost("127.0.0.1", 15001);
#endif
if (!socket.waitForConnected(1000))
return false;
qint32 size = out.size();
socket.write((char*)&size, sizeof(qint32));
socket.write(out);
while (socket.bytesToWrite() && socket.waitForBytesWritten())
;
while (socket.waitForReadyRead())
in->append(socket.readAll());
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;
}
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();
}
}
void YACReaderLocalServer::sendResponse()
{
/*QLocalSocket *clientConnection = localServer->nextPendingConnection();
connect(clientConnection, SIGNAL(disconnected()),
clientConnection, SLOT(deleteLater()));
QDataStream in(clientConnection);
in.setVersion(QDataStream::Qt_4_0);
if (clientConnection->bytesAvailable() == 0)
return;
if (in.atEnd())
return;
QString message;
in >> message;
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_0);
out << QString("OK");
clientConnection->write(block);
clientConnection->flush();
clientConnection->disconnectFromServer();*/
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_0);
out << (quint16)0;
out << QString("ok");
out.device()->seek(0);
out << (quint16)(block.size() - sizeof(quint16));
QLocalSocket *clientConnection = localServer->nextPendingConnection();
connect(clientConnection, SIGNAL(disconnected()),
clientConnection, SLOT(deleteLater()));
clientConnection->write(block);
clientConnection->flush();
clientConnection->disconnectFromServer();
}
void Server::sendFortune()
{
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_0);
out << (quint16)0;
out << fortunes.at(qrand() % fortunes.size());
out.device()->seek(0);
out << (quint16)(block.size() - sizeof(quint16));
QLocalSocket *clientConnection = server->nextPendingConnection();
connect(clientConnection, SIGNAL(disconnected()),
clientConnection, SLOT(deleteLater()));
clientConnection->write(block);
clientConnection->flush();
clientConnection->disconnectFromServer();
}
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();
}
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;
}
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();
}
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();
}
size_t callback_read_file(void *ptr, size_t size, size_t nmemb, void *userp)
{
// qDebug()<<__FILE__<<__LINE__<<__FUNCTION__<<size<<nmemb<<userp;
size_t tlen = size * nmemb, rlen = 0;
QBuffer strbuf;
QByteArray line;
int n = 0, wlen = 0;
CurlFtp *ftp = static_cast<CurlFtp*>(userp);
QLocalSocket *router = ftp->getDataSock2();
strbuf.setData((const char*)ptr, tlen);
strbuf.open(QBuffer::ReadOnly);
// Q_ASSERT(strbuf.canReadLine()); // ???
rlen = 0;
while (!strbuf.atEnd()) {
if (strbuf.canReadLine()) {
line = strbuf.readLine();
} else {
line = strbuf.readAll();
}
rlen += line.length();
wlen = router->write(line);
// qDebug()<<"Line: "<<n++<<line.length()<<wlen;
// fprintf(stdout, "%s", ".");
// fflush(stdout);
Q_ASSERT(line.length() == wlen);
// break;
}
strbuf.close();
router->flush();
// qDebug()<<"can rw:"<<router->isReadable()<<router->isWritable()<<router->isOpen();
// fprintf(stdout, "route read file:. %p %d %s", router, router->bytesAvailable(), "\n");
fflush(stdout);
return rlen;
return 0;
}
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;
}
bool QtLocalPeer::clientSendMessage(const QString &message, int timeout)
{
QLocalSocket *socket = new QLocalSocket();
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) {
delete socket;
return false;
}
int client_id = this->client_seq ++;
this->clients.insert(socket, client_id);
QObject::connect(socket, SIGNAL(readyRead()), this, SLOT(receiveMessage()));
// QByteArray uMsg(message.toUtf8());
// QDataStream ds(socket);
// ds.writeBytes(uMsg.constData(), uMsg.size());
socket->write(message.toAscii());
bool res = socket->waitForBytesWritten(timeout);
// res &= socket.waitForReadyRead(timeout); // wait for ack
// res &= (socket.read(qstrlen(ack)) == ack);
// qDebug()<<"client send msg:"<<message<<res;
return res;
return true;
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
int client_id = this->client_seq ++;
this->clients.insert(socket, client_id);
QObject::connect(socket, SIGNAL(readyRead()), this, SLOT(receiveMessage()));
QObject::connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
return;
// multi client long connection support
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));
socket->write(ack, qstrlen(ack));
socket->waitForBytesWritten(1000);
// delete socket;
emit messageReceived(message); //### (might take a long time to return)
}
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)
}
bool Application::IsAlreadyRunning () const
{
QLocalSocket socket;
socket.connectToServer (GetSocketName ());
if (socket.waitForConnected () ||
socket.state () == QLocalSocket::ConnectedState)
{
QByteArray toSend;
{
QDataStream out (&toSend, QIODevice::WriteOnly);
out << Arguments_;
}
socket.write (toSend);
socket.disconnectFromServer ();
socket.waitForDisconnected ();
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;
}
int main(int argc, const char* argv[]) {
disableQtBearerPoll(); // Fixes wifi ping spikes
QString applicationName = "High Fidelity Interface - " + qgetenv("USERNAME");
bool instanceMightBeRunning = true;
#ifdef Q_OS_WIN
// Try to create a shared memory block - if it can't be created, there is an instance of
// interface already running. We only do this on Windows for now because of the potential
// for crashed instances to leave behind shared memory instances on unix.
QSharedMemory sharedMemory { applicationName };
instanceMightBeRunning = !sharedMemory.create(1, QSharedMemory::ReadOnly);
#endif
if (instanceMightBeRunning) {
// Try to connect and send message to existing interface instance
QLocalSocket socket;
socket.connectToServer(applicationName);
static const int LOCAL_SERVER_TIMEOUT_MS = 500;
// Try to connect - if we can't connect, interface has probably just gone down
if (socket.waitForConnected(LOCAL_SERVER_TIMEOUT_MS)) {
QStringList arguments;
for (int i = 0; i < argc; ++i) {
arguments << argv[i];
}
QCommandLineParser parser;
QCommandLineOption urlOption("url", "", "value");
parser.addOption(urlOption);
parser.process(arguments);
if (parser.isSet(urlOption)) {
QUrl url = QUrl(parser.value(urlOption));
if (url.isValid() && url.scheme() == HIFI_URL_SCHEME) {
qDebug() << "Writing URL to local socket";
socket.write(url.toString().toUtf8());
if (!socket.waitForBytesWritten(5000)) {
qDebug() << "Error writing URL to local socket";
}
}
}
socket.close();
qDebug() << "Interface instance appears to be running, exiting";
return EXIT_SUCCESS;
}
#ifdef Q_OS_WIN
return EXIT_SUCCESS;
#endif
}
// Check OpenGL version.
// This is done separately from the main Application so that start-up and shut-down logic within the main Application is
// not made more complicated than it already is.
{
OpenGLVersionChecker openGLVersionChecker(argc, const_cast<char**>(argv));
if (!openGLVersionChecker.isValidVersion()) {
qCDebug(interfaceapp, "Early exit due to OpenGL version.");
return 0;
}
}
QElapsedTimer startupTime;
startupTime.start();
// Debug option to demonstrate that the client's local time does not
// need to be in sync with any other network node. This forces clock
// skew for the individual client
const char* CLOCK_SKEW = "--clockSkew";
const char* clockSkewOption = getCmdOption(argc, argv, CLOCK_SKEW);
if (clockSkewOption) {
int clockSkew = atoi(clockSkewOption);
usecTimestampNowForceClockSkew(clockSkew);
qCDebug(interfaceapp, "clockSkewOption=%s clockSkew=%d", clockSkewOption, clockSkew);
}
// Oculus initialization MUST PRECEDE OpenGL context creation.
// The nature of the Application constructor means this has to be either here,
// or in the main window ctor, before GL startup.
Application::initPlugins();
int exitCode;
{
QSettings::setDefaultFormat(QSettings::IniFormat);
Application app(argc, const_cast<char**>(argv), startupTime);
// Setup local server
QLocalServer server { &app };
// We failed to connect to a local server, so we remove any existing servers.
server.removeServer(applicationName);
server.listen(applicationName);
QObject::connect(&server, &QLocalServer::newConnection, &app, &Application::handleLocalServerConnection);
QTranslator translator;
translator.load("i18n/interface_en");
app.installTranslator(&translator);
qCDebug(interfaceapp, "Created QT Application.");
exitCode = app.exec();
server.close();
}
Application::shutdownPlugins();
qCDebug(interfaceapp, "Normal exit.");
return exitCode;
}
