Exemple #1
0
void ClientCore::login(QString ipAddr, QString login, QString password)
{
    if(connectToServer(ipAddr, SERVER_PORT)){
        QString blockPrep;
        blockPrep.append(login);
        blockPrep.append(" ");
        blockPrep.append(hashPW(password));

        QByteArray datablock;
        QDataStream in(&datablock, QIODevice::WriteOnly);

        in << blockPrep;

        this->sendBlock(ServerClient::loginComm,&datablock);
    } else {
        qDebug() << "cant connect";
    }
}
Exemple #2
0
void loop()
{
  if (client.connected()) {
    if (client.available()) {
      // read incoming bytes:
      char inChar = client.read();

      // add incoming byte to end of line:
      currentLine += inChar; 

      // if you get a newline, clear the line:
      if (inChar == '\n') {
        currentLine = "";
      } 
      // if the current line ends with <text>, it will
      // be followed by the tweet:
      if ( currentLine.endsWith("<text>")) {
        // tweet is beginning. Clear the tweet string:
        readingTweet = true; 
        tweet = "";
      }
      // if you're currently reading the bytes of a tweet,
      // add them to the tweet String:
      if (readingTweet) {
        if (inChar != '<') {
          tweet += inChar;
        } 
        else {
          // if you got a "<" character,
          // you've reached the end of the tweet:
          readingTweet = false;
          Serial.println(tweet);   
          // close the connection to the server:
          client.stop(); 
        }
      }
    }   
  }
  else if (millis() - lastAttemptTime > requestInterval) {
    // if you're not connected, and two minutes have passed since
    // your last connection, then attempt to connect again:
    connectToServer();
  }
}
Exemple #3
0
void QXmppClient::connectToServer(const QString& host,
                                  const QString& bareJid,
                                  const QString& passwd,
                                  int port,
                                  const QXmppPresence& initialPresence)
{
    QString user, domain;
    QStringList list = bareJid.split("@");
    if(list.size() == 2)
    {
        user = list.at(0);
        domain = list.at(1);
        connectToServer(host, user, passwd, domain, port, initialPresence);
    }
    else
    {
        emit logMessage(QXmppLogger::WarningMessage, "Invalid bareJid");
    }
}
Exemple #4
0
void QxmppPeer::connectHost( const std::string & jid, const std::string & password, 
                             const std::string & host, int port, bool tls )
{
    QXmppConfiguration conf;
    conf.setJid( jid.c_str() );
    conf.setPassword( password.c_str() );
    if ( host.size() > 0 )
        conf.setHost( host.c_str() );
    if ( port > 0 )
        conf.setPort( port );
    conf.setAutoReconnectionEnabled( true );
    //conf.setUseNonSASLAuthentication( true );
    if ( tls )
    	conf.setStreamSecurityMode( QXmppConfiguration::TLSEnabled );
    else
        conf.setStreamSecurityMode( QXmppConfiguration::TLSDisabled );

    connectToServer( conf );
}
Exemple #5
0
void LTWindow::error(QNetworkReply::NetworkError er)
{
    if (!playing)
    {
        ui->actionRecord->setEnabled(false);
        if (QMessageBox::critical(this, tr("Connection error!"), tr("There was an error with connection to LT server\n Error code: ") + QString("%1").arg(er), QMessageBox::Retry, QMessageBox::Close)
                == QMessageBox::Retry)
        {
            //try to connect again
            streamReader->disconnectFromLTServer();
            connectToServer();
        }
//        else
//		{
//			ui->messageBoardWidget->showStartupBoard();
//			showSessionBoard(true);
//		}
    }
}
Exemple #6
0
/// public slots
   void CServerManager::TakeServerConnect(const Message::CMessageConnectToServerPtr pMessage)
   {
      if(!m_connectToServer)
      {
         connectToServer(pMessage->m_serverIP, pMessage->m_serverPort);
         sendToServer(pMessage);

         qDebug("Network - start wait confirm timer");

         m_timerConfirm.start();
      }
      else
      {
         Message::CMessageInformationPtr ptr(new Message::CMessageInformation);
         ptr->m_typeInformation = Message::CMessageInformation::eConnectionToServer;
         ptr->m_strInformation = "Error, You again trying connect to server";
         emit SendInInformation(ptr);
      }
   }
Exemple #7
0
int openConnection() {
    int s = connectToServer(localPort, remoteName, remotePort);
    int x = 1;
    if (setsockopt(s, SOL_TCP, TCP_NODELAY, &x, sizeof(int)) < 0) {
        perror("setsockopt(TCP_NODELAY)");
        exit(1);
    }
    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(int)) < 0) {
        perror("setsockopt(SO_REUSEADDR)");
        exit(1);
    }
    x = sizeof(GoBackNMessageStruct);
    if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &x, sizeof(int)) < 0) {
        perror("setsockopt(SO_SNDBUF)");
        exit(1);
    }

    return s;
}
Exemple #8
0
    void EtherIPC::waitConnect() {
        if ( fStarting == 1 ) {
            return init();
        }

        if ( fStarting != 1 && fStarting != 2 ) {
            return connectionTimeout();
        }

        if ( ++fConnectAttempts < 10 ) {
            if ( fSocket.state() == QLocalSocket::ConnectingState ) {
                fSocket.abort();
            }

            connectToServer();
        } else {
            connectionTimeout();
        }
    }
void MainWindow::on_actionConnect_triggered()
{
    ConnectDialog dialog(this);
    QByteArray temp;

    if(dialog.exec()){
        temp = dialog.ui->lineEdit->text().toAscii();
        strcpy(info->hostname, temp.data());
        mySocket->port = dialog.ui->lineEdit_2->text().toInt();
        if((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
            printf("error creating socket");
        } else {
            mySocket->socket = sd;
        }
        if(connectToServer(mySocket, info)){
            connected = true;
        }
    }
}
Exemple #10
0
/*
 * get_db_infos()
 *
 * Scans pg_database system catalog and populates all user
 * databases.
 */
static void
get_db_infos(ClusterInfo *cluster)
{
	PGconn	   *conn = connectToServer(cluster, "template1");
	PGresult   *res;
	int			ntups;
	int			tupnum;
	DbInfo	   *dbinfos;
	int			i_datname,
				i_oid,
				i_spclocation;

	res = executeQueryOrDie(conn,
							"SELECT d.oid, d.datname, t.spclocation "
							"FROM pg_catalog.pg_database d "
							" LEFT OUTER JOIN pg_catalog.pg_tablespace t "
							" ON d.dattablespace = t.oid "
							"WHERE d.datallowconn = true "
	/* we don't preserve pg_database.oid so we sort by name */
							"ORDER BY 2");

	i_oid = PQfnumber(res, "oid");
	i_datname = PQfnumber(res, "datname");
	i_spclocation = PQfnumber(res, "spclocation");

	ntups = PQntuples(res);
	dbinfos = (DbInfo *) pg_malloc(sizeof(DbInfo) * ntups);

	for (tupnum = 0; tupnum < ntups; tupnum++)
	{
		dbinfos[tupnum].db_oid = atooid(PQgetvalue(res, tupnum, i_oid));
		snprintf(dbinfos[tupnum].db_name, sizeof(dbinfos[tupnum].db_name), "%s",
				 PQgetvalue(res, tupnum, i_datname));
		snprintf(dbinfos[tupnum].db_tblspace, sizeof(dbinfos[tupnum].db_tblspace), "%s",
				 PQgetvalue(res, tupnum, i_spclocation));
	}
	PQclear(res);

	PQfinish(conn);

	cluster->dbarr.dbs = dbinfos;
	cluster->dbarr.ndbs = ntups;
}
Exemple #11
0
/*
-- FUNCTION: processConnection
--
-- DATE: September 25, 2011
--
-- REVISIONS: (Date and Description)
--
-- DESIGNER: Luke Queenan
--
-- PROGRAMMER: Luke Queenan
--
-- INTERFACE: void processConnection(int socket, char *ip, int port);
--
-- RETURNS: void
--
-- NOTES:
-- This function is called after a client has connected to the server. The
-- function will determine the type of connection (getting a file or retrieving
-- a file) and call the appropriate function.
*/
void processConnection(int socket, char *ip, int port)
{
    int transferSocket = 0;
    char *buffer = (char*)malloc(sizeof(char) * BUFFER_LENGTH);

    // Read data from the client
    readData(&socket, buffer, BUFFER_LENGTH);
    printf("Filename is %s and the command is %d\n", buffer + 1, buffer[0]);
    // Close the command socket
    close(socket);
    
    // Connect to the client
    createTransferSocket(&transferSocket);
    if (connectToServer(&port, &transferSocket, ip) == -1)
    {
        systemFatal("Unable To Connect To Client");
    }
    
    printf("Connected to Client: %s\n", ip);
    
    switch ((int)buffer[0])
    {
    case GET_FILE:
        // Add 1 to buffer to move past the control byte
        printf("Sending %s to client now...\n", buffer + 1);
        sendFile(transferSocket, buffer + 1);
        break;
    case SEND_FILE:
        // Add 1 to buffer to move past the control byte
        printf("Getting %s from client now...\n", buffer + 1);
        getFile(transferSocket, buffer + 1);
        printf("Getting %s successful.\n", buffer + 1);
        break;
    case REQUEST_LIST:
        break;
    }
    
    // Free local variables and sockets
    printf("Closing client connection\n");
    free(buffer);
    close(transferSocket);
}
Exemple #12
0
void * startReconnectThread(void *url) {
	
	reconnectLoop = 1;
	reconnectThreadRunning = 1;
	
	while (reconnectLoop) {
		time_t  currentTime;

		currentTime = time(&currentTime);
		for(int i = 0; i < gMain.gNumEncoders; i++) {
			if(g[i]->forcedDisconnect) {
				LogMessage(g[i], LOG_DEBUG, "Reconnecting disconnected encoder.");

				int timeout = getReconnectSecs(g[i]);
				int timediff = currentTime - g[i]->forcedDisconnectSecs;
				if(timediff > timeout) {
					g[i]->forcedDisconnect = false;
					if(!g[i]->weareconnected) {
						setForceStop(g[i], 0);
						if(!connectToServer(g[i])) {
							g[i]->forcedDisconnect = true;
							g[i]->forcedDisconnectSecs = time(&(g[i]->forcedDisconnectSecs));
						}
						LogMessage(g[i], LOG_DEBUG, "Done Reconnecting disconnected encoder.");
					}
				}
				else {
					char    buf[255] = "";
					sprintf(buf, "Connecting in %d seconds", timeout - timediff);
					outputStatusCallback(g[i], buf);
				}
			}
		}
#ifdef WIN32
		Sleep(1000);
#else
		sleep(1);
#endif
	}
	reconnectThreadRunning = 0;
	return(NULL);
}
Exemple #13
0
// Performs a connect retry (or hardware reset) if not connected
bool ESP8266wifi::watchdog() {
    if (serverRetries >= SERVER_CONNECT_RETRIES_BEFORE_HW_RESET) {
        // give up, do a hardware reset
        return restart();
    }
    if (flags.serverConfigured && !flags.connectedToServer) {
        serverRetries++;
        if (flags.apConfigured && !isConnectedToAP()) {
            if (!connectToAP()) {
                // wait a bit longer, then check again
                delay(2000);
                if (!isConnectedToAP()) {
                    return restart();
                }
            }
        }
        return connectToServer();
    }
    return true;
}
MainController::MainController(ProjectorWindow &target) :
		ProjectorController(target), m_net(new ProjectorNet(this)), m_stageDataCounter(0),
		m_connected(false), m_view(TemplateManager::INDEX),
		m_activeQuestionIndex(0), m_activeRound (0) {
	connect(m_net, SIGNAL(onConnect()), this, SLOT(onConnect()));
	connect(m_net, SIGNAL(onContestState(ushort,CONTEST_STATUS)), this, SLOT(onContestState(ushort,CONTEST_STATUS)));
	connect(m_net, SIGNAL(onContestTime(ushort)), this, SLOT(onContestTime(ushort)));
	connect(m_net, SIGNAL(onDisconnect()), this, SLOT(onDisconnect()));
	connect(m_net, SIGNAL(onError(QString)), this, SLOT(onError(QString)));
	connect(m_net, SIGNAL(onQuestionState(ushort,ushort,QUESTION_STATUS)), this, SLOT(onQuestionState(ushort,ushort,QUESTION_STATUS)));
	connect(m_net, SIGNAL(onShowAnswer()), this, SLOT(onShowAnswer()));
	connect(m_net, SIGNAL(onHideAnswer()), this, SLOT(onHideAnswer()));
	connect(m_net, SIGNAL(onShowContestRanks(vector<RankData>)), this, SLOT(onShowContestRanks(vector<RankData>)));
	connect(m_net, SIGNAL(onShowContestTime()), this, SLOT(onShowContestTime()));
	connect(m_net, SIGNAL(onShowMainScreen()), this, SLOT(onShowMainScreen()));
	connect(m_net, SIGNAL(onStageData(ushort, QString)), this, SLOT(onStageData(ushort, QString)));
	connect(m_net, SIGNAL(onNumRounds(ushort)), this, SLOT(onRoundsReceived(ushort)));

	QTimer::singleShot(CONNECT_DELAY, this, SLOT(connectToServer()));
}
void main()
{
    networkSetup();
    if (create_connect())exit(0);
    sleep(1);
    create_full();
    connectToServer();

    //control() in new thread
    int unused = 0;
    pthread_t controlThread;
    int threadError = pthread_create (&controlThread,NULL,control, &unused);
    if(threadError)
    {
        printf("thread could not be started! \nerror: %d \nexiting program!\n",threadError);
        exit(0);
    }

    serverCommunication();
}
// --- Do network communications ---
void NetworkClient::communicate(float frameTime)
{	
	AnnDebug() << "Com";
	if(clientConnected)
		getInfoFromServer(); // Get game state from server
	// Calculate elapsed time for network communications
	/*netTime += frameTime;
	if(netTime < netNS::NET_TIMER) // if not time to communicate*/
		//return;
	if(tryToConnect)
		connectToServer(); // Attempt to connect to game server
	else if(clientConnected)
	{
		AnnDebug() << "Should transmit data here";
		checkNetworkTimeout(); // check for disconnect from server
		sendInfoToServer(); //
	}
	netTime -= netNS::NET_TIMER;

}
Exemple #17
0
int main(int argc, char **argv) {

  char buffer[MAXLINE];
  
  //
  // Check for host name and port number.
  //
  if (argc != 3) {
    fprintf(stderr,"usage: %s <host> <port>\n", argv[0]);
    exit(0);
  }

  //
  // Connect to the server.
  //
  int server = connectToServer(argv[1],atoi(argv[2]));

  printf("Welcome to the remote SOLITAIRE game for MATH 442.\n\n");
  printf("Here is a key of possible card plays you can make:\n");
  printf("\tplay <face><suit> - throw a card onto an arena pile in the center.\n");
  printf("\tmove k<suit> - move a king onto an empty pile.\n");
  printf("\tmove <face><suit> <face><suit>- move a card, putting it on top of another card.\n");
  printf("\tdraw - draw and overturn the next card, placing it on the discard pile.\n");
  printf("where <face> is one of a,2,3,...,9,t,j,q,k and <suit> is one of d,c,s,h.\n");

  //
  // Send a series of solitaire play commands.
  //
  while (1) {
    printf("\nEnter a card play: ");
    
    fgets(buffer,MAXLINE,stdin);
    write(server,buffer,strlen(buffer)+1);
    if (receiveAck(server)) {
      printf("Done!\n");
    } else {
      printf("That play wasn't made.\n");
    } 
  }

}
Exemple #18
0
    void EtherIPC::init() {        
        fConnectAttempts = 0;
        if ( fStarting <= 0 ) { // try to connect without starting geth
            EtherLog::logMsg("Etherwall starting", LS_Info);
            fStarting = 1;
            emit startingChanged(fStarting);
            return connectToServer();
        }

        const QSettings settings;

        const QString progStr = settings.value("geth/path", DefaultGethPath()).toString();
        const QString argStr = settings.value("geth/args", DefaultGethArgs).toString();
        const QString ddStr = settings.value("geth/datadir", DefaultDataDir).toString();
        QStringList args = (argStr + " --datadir " + ddStr).split(' ', QString::SkipEmptyParts);
        bool testnet = settings.value("geth/testnet", false).toBool();
        if ( testnet ) {
            args.append("--testnet");
        }
        bool hardfork = settings.value("geth/hardfork", true).toBool();
        if ( hardfork ) {
            args.append("--support-dao-fork");
        } else {
            args.append("--oppose-dao-fork");
        }

        QFileInfo info(progStr);
        if ( !info.exists() || !info.isExecutable() ) {
            fStarting = -1;
            emit startingChanged(-1);
            setError("Could not find Geth. Please check Geth path and try again.");
            return bail();
        }

        EtherLog::logMsg("Geth starting " + progStr + " " + args.join(" "), LS_Info);
        fStarting = 2;

        fGethLog.attach(&fGeth);
        fGeth.start(progStr, args);
        emit startingChanged(0);
    }
Exemple #19
0
/*
-- FUNCTION: initConnection
--
-- DATE: September 23, 2011
--
-- REVISIONS:
--
-- DESIGNER: Karl Castillo
--
-- PROGRAMMER: Karl Castillo
--
-- INTERFACE: int initConnection(int port, const char* ip) 
--				port - the port the client will connect to to the server
--				ip - ip address of the server
--
-- RETURNS: int - the new socket created
--
-- NOTES:
-- This function will create the socket, set reuse and connect to the server.
*/
int initConnection(int port, const char* ip) 
{
	int socket;

	// Creating Socket
	if((socket = tcpSocket()) == -1) {
		systemFatal("Error Creating Socket");
	}

	// Setting Socket to Reuse
	if(setReuse(&socket) == -1) {
		systemFatal("Error Set Socket Reuse");
	}
	
	// Connect to transfer server
	if(connectToServer(&port, &socket, ip) == -1) {
		systemFatal("Cannot Connect to server");
	}
	
	return socket;
}
void SQLToolWidget::handleDatabaseDropped(const QString &dbname)
{
		try
		{
			//Closing tabs related to the database to be dropped
			for(int i=0; i < databases_tbw->count(); i++)
			{
				if(databases_tbw->tabText(i).remove('&') == dbname)
				{
					closeDatabaseExplorer(i);
					i=-1;
				}
			}

			connectToServer();
		}
		catch(Exception &e)
		{
			throw Exception(e.getErrorMessage(), e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
		}
}
Exemple #21
0
bool IRC::receiveMessage(uint8_t MSG_ID, uint8_t callingThreadID, void* cdata) {

	bool lRetval = false;
	//std::cerr << "IRCthread msg received." << std::endl;
	if(MSG_THREAD_START_WORK == MSG_ID) {

		std::cerr << "Begin connect to server." << std::endl;
		lRetval = connectToServer();
		std::cerr << "Connected to server as \"" << mMyNick << "\"" << std::endl;
		if(cdata) delete(static_cast<ClientQueryData*>(cdata));

	} else if(MSG_QUERY_REPLY == MSG_ID) {

		//handleReply(static_cast<ClientQueryData*>(cdata));
		doCallback(cdata);
		//delete(cdata);

	}
	return(lRetval);

}
Exemple #22
0
void Client::btnConnectOnClick() {
	if (connectionState == ConnectionState::STATE_DISCONNECTED) {
		if ((serverConfiguration == nullptr) || (clientConfiguration == nullptr)) {
			QMessageBox::warning(this, "Can not connect", "Please choose a valid client configuration file first.");
			return;
		}

		setupProtocolClient();

		ui.btnConnect->setEnabled(false);
		ui.btnConnect->setText("Connecting...");
		QTimer::singleShot(0, protocolClient, SLOT(connectToServer()));
	} else if (connectionState == ConnectionState::STATE_CONNECTING) {
		// No click should be possible in this state
		ui.btnConnect->setEnabled(false);
	} else if (connectionState == ConnectionState::STATE_CONNECTED) {
		ui.btnConnect->setEnabled(false);
		ui.btnConnect->setText("Disconnecting...");
		QTimer::singleShot(0, protocolClient, SLOT(disconnectFromServer()));
	}
}
Exemple #23
0
int Client::rpcCall(const std::string& fun, int* argTypes, void** args) const {
  FunctionSignature signature(fun, argTypes);
  int serverSocket = connectToServer(signature);
  if (serverSocket < 0) {
    return serverSocket;
  }

  Connection conn(serverSocket);

  FunctionCall functionCall(std::move(signature), args);
  if (conn.send(Message::Type::CALL, functionCall.serialize()) < 0) {
    conn.close();
    return -1;
  }

  Message message;
  while (true) {
    int r = conn.read(&message);
    if (r < 0) {
      conn.close();
      return -1;
    }
    else if (r > 0) {
      // Done
      conn.close();
      break;
    }
  }

  if (message.type != Message::Type::CALL) {
    // Error
    return -1;
  }

  // Now we must deserialize the message
  auto callReturn = FunctionCall::deserialize(message);
  // Got the response back
  callReturn.writeDataTo(args);
  return 0;
}
Exemple #24
0
int main(int argc, const char * argv[])
{
    char commandBuffer[512];
    ssize_t commandLength;
    int socketHandle = -1;
    int countDown = MAX_ATTEMPTS_WITHOUT_STATUS;
    
    while (true)
    {
        if (socketHandle < 0) {
            socketHandle = connectToServer(SERVER_ADDRESS, SERVER_PORT);
        }
        
        if (socketConnected(socketHandle)) {
            int available = dataAvailable(socketHandle, 30);
            if (available > 0) {
                commandLength = receiveData(socketHandle, commandBuffer, sizeof(commandBuffer));
                if (commandLength > 0) {
                    countDown = MAX_ATTEMPTS_WITHOUT_STATUS;
                    std::cout << "Received: " <<  commandBuffer << std::endl;
                    handleCommand(socketHandle, commandBuffer, commandLength);
                }
            }
            else if ((countDown <= 0) || (available < 0)) {
                // socket must have broke, let's close and re-attempt
                close(socketHandle);
                socketHandle = -1;
                countDown = MAX_ATTEMPTS_WITHOUT_STATUS;
            }
            else {
                countDown -= 1;
            }
        }
        else {
            sleep(20);
        }
    }
    
    return 0;
}
int main( int argc, const char* argv[] )
{
    header(3, 1, false);
    //============================
    // SSL init 
	SSL_library_init(); 
	SSL_load_error_strings();
	ERR_load_BIO_strings();
	OpenSSL_add_all_algorithms(); 
	// ============== SSL init //
	
	// Verify args
	if (argc !=5)
	{
		printf("Usage:\n");
		printf("\t ./client --serverAddress=127.0.0.1 --port=1234 --send ./filename\n");
		printf("\t ./client --serverAddress=127.0.0.1 --port=1234 --recieve ./filename\n");
		exit(54);
	}

	char* serverhost = (char*) argv[1];
	char* port = (char*) argv[2];
	char* transType = (char*) argv[3];
	char* file = (char*) argv[4];
	serverhost = strrchr(serverhost, '=') + sizeof(char);
	port = strrchr(port, '=') + sizeof(char);
	transType = strrchr(transType, '-') + sizeof(char);
	printf("server: %s\n", serverhost);
	printf("port: %s\n", port);
	printf("transType: %s\n", transType);
	printf("file: %s\n", file);
	// seed for random numbers
 	srand(time(0));
 	
 	// connect to server
	connectToServer(serverhost,port,transType, file); 
	
	printf("Client application is exiting.\nGood Bye!\n");
	return 0;
}
int main(int argc, char** argv){
	if (argc != 2){
		printf("Pemakaian: ./client <server ip>\n");
	}
	else{
		connectToServer(argv[1]); // membuka koneksi ke server, jika gagal keluar dengan kode 1

		active = true;

		header();
		
		thread menu(start);

		thread msgrec(recieveMessage);

		menu.join();

		msgrec.join();

	}
	return 0;
}
Exemple #27
0
/*
 *	check_for_prepared_transactions()
 *
 *	Make sure there are no prepared transactions because the storage format
 *	might have changed.
 */
static void
check_for_prepared_transactions(ClusterInfo *cluster)
{
	PGresult   *res;
	PGconn	   *conn = connectToServer(cluster, "template1");

	prep_status("Checking for prepared transactions");

	res = executeQueryOrDie(conn,
							"SELECT * "
							"FROM pg_catalog.pg_prepared_xacts");

	if (PQntuples(res) != 0)
		pg_fatal("The %s cluster contains prepared transactions\n",
				 CLUSTER_NAME(cluster));

	PQclear(res);

	PQfinish(conn);

	check_ok();
}
Exemple #28
0
/*
 * get_pg_database_relfilenode()
 *
 *	Retrieves the relfilenode for a few system-catalog tables.	We need these
 *	relfilenodes later in the upgrade process.
 */
void
get_pg_database_relfilenode(ClusterInfo *cluster)
{
	PGconn	   *conn = connectToServer(cluster, "template1");
	PGresult   *res;
	int			i_relfile;

	res = executeQueryOrDie(conn,
							"SELECT c.relname, c.relfilenode "
							"FROM 	pg_catalog.pg_class c, "
							"		pg_catalog.pg_namespace n "
							"WHERE 	c.relnamespace = n.oid AND "
							"		n.nspname = 'pg_catalog' AND "
							"		c.relname = 'pg_database' "
							"ORDER BY c.relname");

	i_relfile = PQfnumber(res, "relfilenode");
	cluster->pg_database_oid = atooid(PQgetvalue(res, 0, i_relfile));

	PQclear(res);
	PQfinish(conn);
}
Exemple #29
0
void QXmppClient::setClientPresence(const QXmppPresence& presence)
{
    d->clientPresence = presence;
    d->addProperCapability(d->clientPresence);

    if (presence.type() == QXmppPresence::Unavailable)
    {
        // cancel reconnection
        d->reconnectionTimer->stop();

        // NOTE: we can't call disconnect() because it alters
        // the client presence
        if (d->stream->isConnected())
            sendPacket(d->clientPresence);

        d->stream->disconnectFromHost();
    }
    else if (d->stream->isConnected())
        sendPacket(d->clientPresence);
    else
        connectToServer(d->stream->configuration(), presence);
}
Exemple #30
0
MyIRC::MyIRC(QWidget *mainWindow)
{
    this->mainWindow = static_cast<test*>(mainWindow); //widget community.
    this->session = new MySession(this);
    this->controller = new WindowController(this);


    QPushButton *actConnect = new QPushButton("connect", mainWindow);
    connect(actConnect, SIGNAL(clicked()), this, SLOT(connectToServer()));
    actConnect->move(760, 0);
    //this->mainWindow->getUi()->mainToolBar->addAction(actConnect);

    QPushButton *actDisConnect = new QPushButton("Disconnect", mainWindow);
    connect(actDisConnect, SIGNAL(clicked()), this, SLOT(disconnectFromServer()));
    //this->mainWindow->getUi()->mainToolBar->addAction(actDisConnect);
    actDisConnect->move(834, 0);

    QPushButton *actSetNickname = new QPushButton("Set Nickname", mainWindow);
    connect(actSetNickname, SIGNAL(clicked()), this, SLOT(setNickname()));
    actSetNickname->move(930, 0);
    //this->mainWindow->getUi()->mainToolBar->addAction(actSetNickname);
}