//! [clientConnected]
void TennisServer::clientConnected()
{
    qDebug() << Q_FUNC_INFO << "connect";

    QBluetoothSocket *socket = l2capServer->nextPendingConnection();
    if (!socket)
        return;

    if(clientSocket){
        qDebug() << Q_FUNC_INFO << "Closing socket!";
        delete socket;
        return;
    }

    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
    connect(socket, SIGNAL(error(QBluetoothSocket::SocketError)), this, SLOT(socketError(QBluetoothSocket::SocketError)));

    stream = new QDataStream(socket);

    clientSocket = socket;    

    qDebug() << Q_FUNC_INFO << "started";

    emit clientConnected(clientSocket->peerName());
    lagTimer.start();
}
void QServer::addToList(QLocalSocket* socket)
{
	//Store sockets & connect them for read & discard them on disconnect
	connection_list.push_back(socket);
	connect(socket, SIGNAL(readyRead()), this , SLOT(readSocket()));
	connect(socket, SIGNAL(disconnected()), this , SLOT(discardSocket()));
}
Beispiel #3
0
void HttpServer :: incomingConnection(qintptr socketDescriptor)
{
  auto socket = new QTcpSocket (this);
  connect (socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
  connect (socket, SIGNAL(disconnected()), this, SLOT(disconnectSocket()));
  socket->setSocketDescriptor(socketDescriptor);
}
Beispiel #4
0
void PingPong::clientConnected()
{
    //! [Initiating server socket]
    if (!m_serverInfo->hasPendingConnections()) {
        setMessage("FAIL: expected pending server connection");
        return;
    }
    socket = m_serverInfo->nextPendingConnection();
    if (!socket)
        return;
    socket->setParent(this);
    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
    connect(socket, SIGNAL(error(QBluetoothSocket::SocketError)),
            this, SLOT(socketError(QBluetoothSocket::SocketError)));
    //! [Initiating server socket]
    setMessage(QStringLiteral("Client connected."));

    QByteArray size;
    size.setNum(m_boardWidth);
    size.append(' ');
    QByteArray size1;
    size1.setNum(m_boardHeight);
    size.append(size1);
    size.append(" \n");
    socket->write(size.constData());

}
void SocketThread::run()
{
	{
	queryTime.restart();
	if(isLogEnabled)logThread->writeLog("SocketThread Started");
	sslSocket=new QSslSocket;
	connect(this,SIGNAL(sendToApiSignal(QByteArray, QByteArray)),this,SLOT(sendToApiSlot(QByteArray, QByteArray)));
	connect(this,SIGNAL(reconnectApiSignal()),this,SLOT(reconnectApiSlot()));
	connect(sslSocket,SIGNAL(readyRead()),SLOT(readSocket()));

	secondTimer=new QTimer;
	connect(secondTimer,SIGNAL(timeout()),this,SLOT(secondSlot()));

	if(useSSL)sslSocket->connectToHostEncrypted(hostName, 443);
		else  sslSocket->connectToHost(hostName, 80);
	sslSocket->waitForConnected();
	if(isLogEnabled)
	{
		logThread->writeLog("SSL Socket state:"+sslSocket->errorString().toAscii()+". Supported: "+QByteArray::number(sslSocket->supportsSsl()));
	}
	
	secondTimer->start(100);
	sendPendingData();
	}
	exec();
}
//! [startClient]
void RfCommClient::startClient(const QBluetoothServiceInfo &remoteService)
{
    qDebug() << __PRETTY_FUNCTION__ << ">>";
    serviceInfo = remoteService;

    // make sure preconditions are met
    if (!powerOn() || socket) {
        qDebug() << __PRETTY_FUNCTION__ << "<< power not on or socket already exists!";
        return;
    }

    // Connect to service
    if (state == listening)
        state = pendingConnections;
    socket = new QBluetoothSocket(QBluetoothSocket::RfcommSocket);
    qDebug() << "Create socket";
    socket->connectToService(remoteService);
    qDebug() << "ConnecttoService done";

    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(socket, SIGNAL(connected()), this, SLOT(connected()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
    connect(socket, SIGNAL(error(QBluetoothSocket::SocketError)), this, SLOT(error(QBluetoothSocket::SocketError)));

    qDebug() << __PRETTY_FUNCTION__ << "<<";
}
Beispiel #7
0
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), ui(new Ui::MainWindow),media(0)
{
    isConnected=false;
    controllerConnected=false;
    ui->setupUi(this);
    this->setWindowTitle("Au2");

    instance = new VlcInstance(VlcCommon::args(), this);
    player = new VlcMediaPlayer(instance);
    player->setVideoWidget(ui->video);

    readDataFromFile();

    data[1] = 0;//hastighed
    data[2] = 0;//afstand
    data[3] = 0;//acceleration
    data[4] = 1;//AKS = on

    ui->AKS->setText("AKS-On");

    updateData();

    connect(ui->OpretForbindelse, SIGNAL(clicked()), this, SLOT(Au2connect()));
    connect(ui->KonfigurerIP, SIGNAL(clicked()), this, SLOT(konfigurerIP()));
    connect(ui->AKS, SIGNAL(clicked()), this, SLOT(AKSstatus()));
    connect(ui->IndstilMaksHastighed, SIGNAL(clicked()), this, SLOT(maksHastighed()));
    connect(ui->KalibrerStyretoj, SIGNAL(clicked()), this, SLOT(kalibrerStyretoj()));
    connect(ui->LukNed, SIGNAL(clicked()), this, SLOT(shutDown()));
    connect(this, SIGNAL(sig_getData()), this, SLOT(readSocket()));
}
void LocalSocketConnection::start()
{
  if (m_socket) {
    m_holdRequests = false;
    while (m_socket->bytesAvailable() != 0)
      readSocket();
  }
}
Beispiel #9
0
Connection::Connection(QObject *parent) :
    QObject(parent)
{
    conection = new QLocalSocket(this);

    connect(conection,SIGNAL(readyRead()),this,SLOT(readSocket()));
    connect(conection,SIGNAL(disconnected()),this,SLOT(discardSocket()));
    conection->connectToServer(Packets::server_name_tag);
}
//! [clientConnected]
void ChatServer::clientConnected()
{
    QBluetoothSocket *socket = rfcommServer->nextPendingConnection();
    if (!socket)
        return;

    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
    clientSockets.append(socket);
    emit clientConnected(socket->peerName());
}
Beispiel #11
0
Boolean Groupsock::handleRead(unsigned char* buffer, unsigned bufferMaxSize,
			      unsigned& bytesRead,
			      struct sockaddr_in& fromAddress) {
  // Read data from the socket, and relay it across any attached tunnels
  //##### later make this code more general - independent of tunnels

  bytesRead = 0;

  int maxBytesToRead = bufferMaxSize - TunnelEncapsulationTrailerMaxSize;
  int numBytes = readSocket(env(), socketNum(),
			    buffer, maxBytesToRead, fromAddress);
  if (numBytes < 0) {
    if (DebugLevel >= 0) { // this is a fatal error
      env().setResultMsg("Groupsock read failed: ",
			 env().getResultMsg());
    }
    return False;
  }

  // If we're a SSM group, make sure the source address matches:
  if (isSSM()
      && fromAddress.sin_addr.s_addr != sourceFilterAddress().s_addr) {
    return True;
  }

  // We'll handle this data.
  // Also write it (with the encapsulation trailer) to each member,
  // unless the packet was originally sent by us to begin with.
  bytesRead = numBytes;

  int numMembers = 0;
  if (!wasLoopedBackFromUs(env(), fromAddress)) {
    statsIncoming.countPacket(numBytes);
    statsGroupIncoming.countPacket(numBytes);
    numMembers =
      outputToAllMembersExcept(NULL, ttl(),
			       buffer, bytesRead,
			       fromAddress.sin_addr.s_addr);
    if (numMembers > 0) {
      statsRelayedIncoming.countPacket(numBytes);
      statsGroupRelayedIncoming.countPacket(numBytes);
    }
  }
  if (DebugLevel >= 3) {
    env() << *this << ": read " << bytesRead << " bytes from ";
    env() << our_inet_ntoa(fromAddress.sin_addr);
    if (numMembers > 0) {
      env() << "; relayed to " << numMembers << " members";
    }
    env() << "\n";
  }

  return True;
}
Beispiel #12
0
void receiver(int socket, char *filename)
{
	fd_set read, write;
	char readed[520];
	int f;
	if(filename==NULL)
		f=STDOUT_FILENO;
	else
		f=open(filename,O_WRONLY|O_CREAT|O_TRUNC);
	while(1){
	FD_ZERO(&read);
	FD_ZERO(&write);
	FD_SET(socket,&write);
	FD_SET(socket,&read);
	FD_SET(f,&write);
	if(select(socket+1,&read,&write, NULL,NULL)==-1)
	{
		fprintf(stderr,"Error selectreceiver\n");
		return;
	}

	if(FD_ISSET(socket,&write) && FD_ISSET(socket,&read))
	{
		printf("receiver readwritesocket\n");
		int rd=readSocket(socket,readed,520);
		if(rd>=0)
		{
			pkt_t *pkt=pkt_new();
			pkt_status_code errdec=pkt_decode((const char *)readed,(size_t)rd,pkt);
printf("lu : %s\n",pkt_get_payload(pkt));
			if(errdec==PKT_OK)
			{
				if(pkt_get_type(pkt)==PTYPE_DATA)
				{
					printf("On doit créer ACK/NACK\n");
				}
			}
			else
			{
				fprintf(stderr,"Error receiver decode\n");
				return;
			}
			pkt_del(pkt);
	printf("after del\n");
		}	
	}
	else if(FD_ISSET(f,&write))
	{
		printf("Write file\n");
		break;
	}
	}
}
Beispiel #13
0
void PingPong::addService(const QBluetoothServiceInfo &service)
{
    setMessage("Service found. Setting parameters...");
    //! [Connecting the socket]
    socket = new QBluetoothSocket(QBluetoothServiceInfo::L2capProtocol);
    socket->connectToService(service);

    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(socket, SIGNAL(connected()), this, SLOT(serverConnected()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(serverDisconnected()));
    //! [Connecting the socket]
    m_serviceFound = true;
}
Beispiel #14
0
void LCDServer::newConnection(QTcpSocket *socket)
{
    connect(socket, SIGNAL(readyRead()),
            this,   SLOT(  readSocket()));
    connect(socket, SIGNAL(disconnected()),
            this,   SLOT(  endConnection()));

    if (debug_level > 0)
        LOG(VB_NETWORK, LOG_INFO, "LCDServer: new connection");

    if (m_lcd)
        m_lcd->switchToTime();
}
Beispiel #15
0
void iControlPadClient::connectToService(const QBluetoothServiceInfo &remoteService)
{
    if (m_socket)
        return;

    // Connect to service
    m_socket = new QBluetoothSocket(QBluetoothSocket::RfcommSocket);
    qDebug() << "Create socket";
    m_socket->connectToService(remoteService);
    qDebug() << "Connecte Service done";
    connect(m_socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(m_socket, SIGNAL(connected()), this, SLOT(connected()));
    connect(m_socket, SIGNAL(disconnected()), this, SLOT(disconnected()));
}
Beispiel #16
0
//! [startClient]
void ChatClient::startClient(const QBluetoothServiceInfo &remoteService)
{
    if (socket)
        return;

    // Connect to service
    socket = new QBluetoothSocket(QBluetoothSocket::RfcommSocket);
    qDebug() << "Create socket";
    socket->connectToService(remoteService);
    qDebug() << "ConnecttoService done";

    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(socket, SIGNAL(connected()), this, SLOT(connected()));
    connect(socket, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
}
Beispiel #17
0
RunnerView::RunnerView(QString appUid, QString server, QWidget* parent) :
    QQuickWidget(parent),
    m_appUid(appUid),
    m_socket(new QLocalSocket(this)),
    m_shared(new QSharedMemory(appUid, this))
{
    qDebug() << "RunnerView::RunnerView";
    connect(engine(), SIGNAL(quit()), this, SLOT(quitApplication()));
    connect(m_socket, SIGNAL(connected()), this, SLOT(socketConnected()));
    connect(m_socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
    connect(m_socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(socketError(QLocalSocket::LocalSocketError)));
    connect(m_socket, SIGNAL(bytesWritten(qint64)), this, SLOT(socketBytesWritten(qint64)));
    connect(m_socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    m_socket->connectToServer(server);
    qDebug() << "RunnerView::RunnerView - END";
}
Beispiel #18
0
void ServerThread::run()
{
    _tcpSocket = new QTcpSocket();

    //qDebug () << "Setting socket descriptor " << _socketDescriptor;

    if (!_tcpSocket->setSocketDescriptor(_socketDescriptor))
    {
        qDebug() << "Cant set socket descriptor " << _socketDescriptor <<  " " << _tcpSocket->errorString();
        return;
    }

    connect(_tcpSocket, SIGNAL(readyRead()), this, SLOT(readSocket()), Qt::DirectConnection);
    connect(_tcpSocket, SIGNAL(disconnected()), this, SLOT(handleSocketDisconnect()), Qt::DirectConnection);

    exec();
}
Beispiel #19
0
void RTSPServer::RTSPClientSession::incomingRequestHandler1() {
  noteLiveness();

  struct sockaddr_in dummy; // 'from' address, meaningless in this case
  Boolean endOfMsg = False;
  unsigned char* ptr = &fRequestBuffer[fRequestBytesAlreadySeen];
  
  int bytesRead = readSocket(envir(), fClientSocket,
			     ptr, fRequestBufferBytesLeft, dummy);
  if (bytesRead <= 0 || (unsigned)bytesRead >= fRequestBufferBytesLeft) {
    // Either the client socket has died, or the request was too big for us.
    // Terminate this connection:
#ifdef DEBUG
    fprintf(stderr, "RTSPClientSession[%p]::incomingRequestHandler1() read %d bytes (of %d); terminating connection!\n", this, bytesRead, fRequestBufferBytesLeft);
#endif
    delete this;
    return;
  }
#ifdef DEBUG
  ptr[bytesRead] = '\0';
  fprintf(stderr, "RTSPClientSession[%p]::incomingRequestHandler1() read %d bytes:%s\n", this, bytesRead, ptr);
#endif

  // Look for the end of the message: <CR><LF><CR><LF>
  unsigned char *tmpPtr = ptr;
  if (fRequestBytesAlreadySeen > 0) --tmpPtr;
      // in case the last read ended with a <CR>
  while (tmpPtr < &ptr[bytesRead-1]) {
    if (*tmpPtr == '\r' && *(tmpPtr+1) == '\n') {
      if (tmpPtr - fLastCRLF == 2) { // This is it:
	endOfMsg = 1;
	break;
      }
      fLastCRLF = tmpPtr;
    }
    ++tmpPtr;
  }
  
  fRequestBufferBytesLeft -= bytesRead;
  fRequestBytesAlreadySeen += bytesRead;

  if (!endOfMsg) return; // subsequent reads will be needed to complete the request

  fRequestBuffer[fRequestBytesAlreadySeen] = '\0';
  handleRequest();
}
Beispiel #20
0
void *testReaderUnix(void *)
{
	UDDSocket readSocket("testDestination");
	readSocket.nonblocking();
	int rc = 0;
	while (rc<gNumToSend) {
		char buf[MAX_UDP_LENGTH];
		int count = readSocket.read(buf);
		if (count>0) {
			COUT("read: " << buf);
			rc++;
		} else {
			sleep(2);
		}
	}
	return NULL;
}
Beispiel #21
0
void *testReaderIP(void *)
{
	UDPSocket readSocket(5934, "localhost", 5061);
	readSocket.nonblocking();
	int rc = 0;
	while (rc<gNumToSend) {
		char buf[MAX_UDP_LENGTH];
		int count = readSocket.read(buf);
		if (count>0) {
			COUT("read: " << buf);
			rc++;
		} else {
			sleep(2);
		}
	}
	return NULL;
}
Beispiel #22
0
int ServerSocket::listenOnSocket()
{
	int listenErr = listen(this->sockfd, BACKLOG);
	if (listenErr != 0) {
		printf("\nSocket Listen FAILED! %d\n", errno);
		return cleanup();
	}
	printf("\nListening on %d...", PORT);
	acceptConnection();
	printf("\nConnection Accepted!");
	char *buf = new char[128];
	char *start = buf;
	int len = readSocket(buf);
	printf("\nReceived %d bytes", len);
	printf("\nReceived %s", start);
	writeToSocket("RESPONSE");
	return 0;
}
void LocalSocketConnection::setSocket(QLocalSocket *socket)
{
  if (m_socket != NULL) {
    m_socket->abort();
    m_socket->disconnect(this);
    disconnect(m_socket);
    m_socket->deleteLater();
  }
  if (socket != NULL) {
    connect(socket, SIGNAL(readyRead()),
            this, SLOT(readSocket()));
    connect(socket, SIGNAL(disconnected()),
            this, SIGNAL(disconnected()));
    connect(socket, SIGNAL(destroyed()),
            this, SLOT(socketDestroyed()));
  }
  m_dataStream->setDevice(socket);
  m_dataStream->setVersion(QDataStream::Qt_4_8);
  m_socket = socket;
}
Beispiel #24
0
void QxThread::doProcess(QTcpSocket & socket)
{
    if (! socket.setSocketDescriptor(m_iSocketDescriptor))
    {
        Q_EMIT error("[QxOrm] invalid socket descriptor : cannot start transaction", QxTransaction_ptr());
        return;
    }

    qx_bool bReadOk = readSocket(socket);
    if (! bReadOk) {
        Q_EMIT error(QString("[QxOrm] unable to read request from socket : '") + bReadOk.getDesc() + QString("'"), QxTransaction_ptr());
        return;
    }
    if (! m_bIsRunning) {
        return;
    }

    Q_EMIT transactionStarted(m_pTransaction);
    try {
        m_pTransaction->executeServer();
    }
    catch (const qx::exception & x) {
        qx_bool xb = x.toQxBool();
        m_pTransaction->setMessageReturn(xb);
    }
    catch (const std::exception & e) {
        m_pTransaction->setMessageReturn(qx_bool(QX_ERROR_UNKNOWN, e.what()));
    }
    catch (...) {
        m_pTransaction->setMessageReturn(qx_bool(QX_ERROR_UNKNOWN, "unknown error"));
    }
    if (! m_bIsRunning) {
        return;
    }

    qx_bool bWriteOk = writeSocket(socket);
    if (! bWriteOk) {
        Q_EMIT error(QString("[QxOrm] unable to write reply to socket : '") + bWriteOk.getDesc() + QString("'"), m_pTransaction);
    }
    Q_EMIT transactionFinished(m_pTransaction);
}
int readSocketExact(UsageEnvironment& env,
			  int socket, unsigned char* buffer, unsigned bufferSize,
			  struct sockaddr_in& fromAddress,
			  struct timeval* timeout) {
	/* read EXACTLY bufferSize bytes from the socket into the buffer.
		 fromaddress is address of last read.
		 return the number of bytes actually read when an error occurs
	*/
  int bsize = bufferSize;
  int bytesRead = 0;
  int totBytesRead =0;
  do {
	  bytesRead = readSocket (env, socket, buffer + totBytesRead, bsize,
													  fromAddress, timeout);
	  if (bytesRead <= 0) break;
	  totBytesRead += bytesRead;
	  bsize -= bytesRead;
	} while (bsize != 0);

  return totBytesRead;
}
void LocalSocketConnection::readSocket()
{
  if(!m_socket->isValid())
    return;

  if (m_holdRequests)
    return;

  if (m_socket->bytesAvailable() == 0)
    return;

  PacketType packet;
  (*m_dataStream) >> packet;

  emit packetReceived(packet, EndpointIdType());

  // Check again in 50 ms if no more data is available, or immediately if there
  // is. This helps ensure that burst traffic is handled robustly.
  QTimer::singleShot(m_socket->bytesAvailable() > 0 ? 0 : 50,
                     this, SLOT(readSocket()));
}
Beispiel #27
0
//! [startClient]
void TennisClient::startClient(const QBluetoothServiceInfo &remoteService)
{
    if (socket)
        return;

    serviceInfo = remoteService;

    // Connect to service
    socket = new QBluetoothSocket(QBluetoothServiceInfo::L2capProtocol);
    qDebug() << "Create socket";
    socket->connectToService(remoteService);
    qDebug() << "ConnecttoService done";

    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
    connect(socket, SIGNAL(connected()), this, SLOT(connected()));
    connect(socket, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
    connect(socket, SIGNAL(error(QBluetoothSocket::SocketError)), this, SLOT(error(QBluetoothSocket::SocketError)));

    lagTimer.start();
}
Beispiel #28
0
bool
RTMP::readPacketPayload(RTMPPacket& packet)
{
    RTMPHeader& hr = packet.header;

    const size_t bytesRead = packet.bytesRead;

    const int nToRead = hr.dataSize - bytesRead;

    const int nChunk = std::min<int>(nToRead, _inChunkSize);
    assert(nChunk >= 0);

    // This is fine. We'll keep trying to read this payload until there
    // is enough data.
    if (readSocket(payloadData(packet) + bytesRead, nChunk) != nChunk) {
        return false;
    }

    packet.bytesRead += nChunk;
        
    return true;
}
Beispiel #29
0
bool Connection::recvPacket()
{
  while (true)
  {
    if (m_reader.havePacket())
    {
      break;
    }

    if (!readSocket())
    {
      return false;
    }

    if (m_reader.havePacket())
    {
      break;
    }
  }

  return true;
}
Beispiel #30
0
void QxTransaction::executeClient(IxService * pService, const QString & sMethod)
{
   if ((pService == NULL) || sMethod.isEmpty()) { qAssert(false); return; }
   if (pService->getServiceName().isEmpty()) { pService->setMessageReturn(qx_bool(QX_ERROR_SERVICE_NOT_SPECIFIED, "[QxOrm] empty service name")); return; }
   pService->registerClass();

   QTcpSocket socket;
   QString serverName = QxConnect::getSingleton()->getIp();
   long serverPort = QxConnect::getSingleton()->getPort();
   socket.connectToHost(serverName, serverPort);
   if (! socket.waitForConnected(QxConnect::getSingleton()->getMaxWait()))
   { pService->setMessageReturn(qx_bool(QX_ERROR_SERVER_NOT_FOUND, "[QxOrm] unable to connect to server")); return; }

   if (m_sTransactionId.isEmpty())
   { setTransactionId(QUuid::createUuid().toString()); }

   setIpSource(socket.localAddress().toString());
   setPortSource(socket.localPort());
   setIpTarget(serverName);
   setPortTarget(serverPort);
   setServiceName(pService->getServiceName());
   setServiceMethod(sMethod);
   setTransactionBegin(QDateTime::currentDateTime());
   setInputParameter(pService->getInputParameter_BaseClass());

   qx_bool bWriteOk = writeSocket(socket);
   if (! bWriteOk) { pService->setMessageReturn(qx_bool(QX_ERROR_SERVICE_WRITE_ERROR, QString("[QxOrm] unable to write request to socket : '") + bWriteOk.getDesc() + QString("'"))); return; }
   qx_bool bReadOk = readSocket(socket);
   if (! bReadOk) { pService->setMessageReturn(qx_bool(QX_ERROR_SERVICE_READ_ERROR, QString("[QxOrm] unable to read reply from socket : '") + bReadOk.getDesc() + QString("'"))); return; }

   pService->setOutputParameter(getOutputParameter());
   pService->setMessageReturn(getMessageReturn());
   setTransactionEnd(QDateTime::currentDateTime());
   socket.disconnectFromHost();
   if (socket.state() != QAbstractSocket::UnconnectedState)
   { socket.waitForDisconnected(QxConnect::getSingleton()->getMaxWait()); }
}