Network::Network(const QString &host, quint16 port) : commandStarted(false)
{
    if (port == 0) {
        //Default argument, not worth going further
    } else {
        connectToHost(host, port);
    }

    connect(this, SIGNAL(readyRead()), SLOT(onReceipt()));
}

void OftSocket::directConnect(const QHostAddress &addr, quint16 port)
{
	m_state = ReadHeader;
	connectToHost(addr, port);
	m_clientPort = port;
	m_timer.start();
	debug().nospace() << "Trying to establish a direct connection to "
			<< addr.toString().toLocal8Bit().constData()
			<< ":" << port;
}

void ZMClient::restartConnection()
{
    // Reset the flag
    m_zmclientReady = false;
    m_bConnected = false;
    m_server_unavailable = false;

    // Retry to connect. . .  Maybe the user restarted mythzmserver?
    connectToHost(m_hostname, m_port);
}

MainWindow::MainWindow(QWidget *parent) :
	QMainWindow(parent),
	ui(new Ui::MainWindow)
{
	ui->setupUi(this);
	ui->gameBox->setEnabled(FALSE);
	connect(ui->clientButton, SIGNAL(released()), this, SLOT(connectToHost()));
	connect(ui->serverButton, SIGNAL(released()), this, SLOT(runServer()));
	moves = 0;
}

void ApcUpsMon::requestEvents()
{
    if (socket.state() == QAbstractSocket::ConnectedState) {
        socket.putChar('\0');
        socket.putChar('\x06');
        socket.write("events");
    } else {
        // We're not connected, try and reconnect?
        connectToHost();
    }
}

void Connection::connectToServer() {
    Q_ASSERT(!m_host.isEmpty());
    Q_ASSERT(m_port);

    connect(this, SIGNAL(connected()), SLOT(onConnected()), Qt::UniqueConnection);
    connect(this, SIGNAL(disconnected()), SLOT(onDisconnected()), Qt::UniqueConnection);
    connect(this, SIGNAL(readyRead()), SLOT(onReadyRead()), Qt::UniqueConnection);
    connect(this, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(onError(QAbstractSocket::SocketError)), Qt::UniqueConnection);

    connectToHost(m_host, m_port);
}

void *connect(void *data){
    struct program_data *tData;
    tData = (struct program_data*) data;
    while ((*tData).hasQuit == 0){
        connectToHost((*tData).ipInput);
        sleep(10);//prevents spamming the network if server is down
    }
    
    return NULL;
    
}

Server::Server(QObject * parent) : QObject(parent)
{
	_server = new QTcpServer(this);
	connect(_server, SIGNAL(newConnection()), SLOT(connected()));
	if(connectToHost(QHostAddress::Any, 8081)) {
        // Pokud jsme tady, server jeste neni pripojen k Log!!!
        syslog(LOG_INFO, "Server is listening...");
    } else {
        syslog(LOG_ERR, "Could not listen on given port!");
	}
}

/*!
    If there's a connection activity on the socket, process it. Then
    notify our parent if there really was activity.
*/
void QNativeSocketEngine::connectionNotification()
{
    Q_D(QNativeSocketEngine);
    Q_ASSERT(state() == QAbstractSocket::ConnectingState);

    connectToHost(d->peerAddress, d->peerPort);
    if (state() != QAbstractSocket::ConnectingState) {
        // we changed states
        QAbstractSocketEngine::connectionNotification();
    }
}

MainWindow::MainWindow(Socket *connection, QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    connection(connection)
{
    ui->setupUi(this);

    /* Disable unavailable offline control
     */
    ui->configurationWidget->setDisabled(true);
    ui->controlWidget->setDisabled(true);
    ui->PiecesDock->setDisabled(true);
    ui->stopButton->setDisabled(true);
    ui->resumeButton->setDisabled(true);

    /* Connection/Disconnection notification
     */
    connect(connection, SIGNAL(connected()), this, SLOT(connectionNotify()));
    connect(connection, SIGNAL(disconnected()), this, SLOT(disconnectionNotify()));

    /* Received logLine
     */
    connect(connection, SIGNAL(gotLog(QString)), this, SLOT(appendLog(QString)));

    /* Received Boxed info
     */
    connect(connection, SIGNAL(gotAccepted(int)), this, SLOT(addAccepted(int)));
    connect(connection, SIGNAL(gotRejected(int)), this, SLOT(addRejected(int)));

    /* Received Error / Warning
     */
    connect(connection, SIGNAL(gotError(int)), this, SLOT(errorNotify(int)));
    //connect(connection, SIGNAL(gotWarning(int)), this, SLOT(warningNotify(int)));

    /* Connection button
     */
    connect(ui->ConnectionButton, SIGNAL(clicked()), this, SLOT(connectToHost()));

    /* Send configuration data button
     */
    connect(ui->sendConfigButton, SIGNAL(clicked()), this, SLOT(sendConfig()));

    /* Actions button : Lauch / Resume / Stop
     */
    connect(ui->launchButton, SIGNAL(clicked()), this, SLOT(launch()));
    connect(ui->resumeButton, SIGNAL(clicked()), this, SLOT(resume()));
    connect(ui->stopButton, SIGNAL(clicked()), this, SLOT(stop()));

    /* Refresh time display
     */
    connect(&timer, SIGNAL(timeout()), this, SLOT(displayTime()));

    timer.start(50);
}

// Have a socket error, set m_errorString and propagate
// signal
void ApcUpsMon::socketError(QAbstractSocket::SocketError)
{
    m_errorString = socket.errorString();
    if (socket.state() != QAbstractSocket::ConnectedState) {
        // Attempt to reconnect in two timer intervals or,
        // failing that, ten seconds
        QTimer::singleShot((timer.interval() ? timer.interval() : 10000),
                           this, SLOT(connectToHost()));
    }
    
    emit haveError(m_errorString);
}

/*!
    Waits for \a msecs milliseconds or until the socket is ready for
    writing. If \a timedOut is not 0 and \a msecs milliseconds have
    passed, the value of \a timedOut is set to true.

    Returns true if data is available for writing; otherwise returns
    false.

    This is a blocking function call; its use is disadvised in a
    single threaded application, as the whole thread will stop
    responding until the function returns. waitForWrite() is most
    useful when there is no event loop available. The general approach
    is to create a QSocketNotifier, passing the socket descriptor
    returned by socketDescriptor() to its constructor.
*/
bool QNativeSocketEngine::waitForWrite(int msecs, bool *timedOut)
{
    Q_D(QNativeSocketEngine);
    Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::waitForWrite(), false);
    Q_CHECK_NOT_STATE(QNativeSocketEngine::waitForWrite(),
                      QAbstractSocket::UnconnectedState, false);

    if (timedOut)
        *timedOut = false;

    int ret = d->nativeSelect(msecs, false);
    // On Windows, the socket is in connected state if a call to
    // select(writable) is successful. In this case we should not
    // issue a second call to WSAConnect()
#if defined (Q_WS_WIN)
    if (ret > 0) {
        setState(QAbstractSocket::ConnectedState);
        d_func()->fetchConnectionParameters();
        return true;
    } else {
        int value = 0;
        int valueSize = sizeof(value);
        if (::getsockopt(d->socketDescriptor, SOL_SOCKET, SO_ERROR, (char *) &value, &valueSize) == 0) {
            if (value == WSAECONNREFUSED) {
                d->setError(QAbstractSocket::ConnectionRefusedError, QNativeSocketEnginePrivate::ConnectionRefusedErrorString);
                d->socketState = QAbstractSocket::UnconnectedState;
                return false;
            } else if (value == WSAETIMEDOUT) {
                d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::ConnectionTimeOutErrorString);
                d->socketState = QAbstractSocket::UnconnectedState;
                return false;
            } else if (value == WSAEHOSTUNREACH) {
                d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::HostUnreachableErrorString);
                d->socketState = QAbstractSocket::UnconnectedState;
                return false;
            }
        }
    }
#endif

    if (ret == 0) {
        if (timedOut)
            *timedOut = true;
        d->setError(QAbstractSocket::SocketTimeoutError,
                    QNativeSocketEnginePrivate::TimeOutErrorString);
        d->hasSetSocketError = false; // A timeout error is temporary in waitFor functions
        return false;
    } else if (state() == QAbstractSocket::ConnectingState) {
        connectToHost(d->peerAddress, d->peerPort);
    }

    return ret > 0;
}

bool KMSmtpClient::login()
{
    //Check out state.
    if((!isConnected()) && (!connectToHost()))
    {
        //Means socket is still not connected to server or already login.
        return false;
    }
    //Check auth method.
    if(authMethod()==AuthPlain)
    {
        //Sending command: AUTH PLAIN base64('\0' + username + '\0' + password)
        sendMessage("AUTH PLAIN " + QByteArray().append((char)0x00)
                    .append(userName()).append((char)0x00)
                    .append(password()).toBase64());
        // The response code needs to be 235.
        if(!waitAndCheckResponse(235, ServerError))
        {
            //Failed to login.
            return false;
        }
        //Mission complete.
        return true;
    }
    //Then the method should be auth login.
    // Sending command: AUTH LOGIN
    sendMessage("AUTH LOGIN");
    //The response code needs to be 334.
    if(!waitAndCheckResponse(334, AuthenticationFailedError))
    {
        //Failed to login.
        return false;
    }
    // Send the username in base64
    sendMessage(QByteArray().append(userName()).toBase64());
    //The response code needs to be 334.
    if(!waitAndCheckResponse(334, AuthenticationFailedError))
    {
        //Failed to login.
        return false;
    }
    // Send the password in base64
    sendMessage(QByteArray().append(password()).toBase64());
    //If the response is not 235 then the authentication was faild
    if(!waitAndCheckResponse(235, AuthenticationFailedError))
    {
        //Failed to login.
        return false;
    }
    //Mission compelte.
    return true;
}

void enviarRespuesta(char* hostname,char* respuesta) {
	char request[1000];
        setupSocket(hostname);
        connectToHost(hostname);
        sprintf(request,"GET /index.php?r=juego/respuesta&tokenSolicitud=%s&solucion=%s HTTP/1.1\r\nHost: %s\r\n\r\n",tokenSolicitud,respuesta,hostname);
        //http://hornero.fi.uncoma.edu.ar/index.php?r=juego/respuesta&&tokenSolicitud=76d7cadd3df99e06ae8c4aa580ca6900&solucion=-5933
	printf("\nse envia request: %s\n", request);
	if (send(sock, request, sizeof(request), 0) != (int)sizeof(request)) {
		printf( "Error sending request." );
		exit(1);
	}
        getBuffer();
}

void TcpClient::tryConnectToHost(const QString &host, int port)
{
    setServerPort(port);
    if (host == zeroHost) {
        if (!findLocalIpv4InterfaceData()) {
            return;
        }
    } else {
        if (connectToHost(host, port)) {
            setServerIp(host);
        }
    }
}

void enviarSolicitud(char* hostname, char* token,char* problema) {
        char request[1000];
        setupSocket(hostname);
        connectToHost(hostname);
	sprintf(request,"GET /index.php?r=juego/solicitud&token=%s&problema=%s HTTP/1.1\r\nHost: %s\r\n\r\n",token,problema,hostname);
	//printf("se envia request: %s", request);
	if (send(sock, request, sizeof(request), 0) != (int)sizeof(request)) {
		printf( "Error sending request." );
		exit(1);
	}
        getBuffer();
        
}

bool ftpInterface::uploadFile(QString fileName,QString fixFilename,bool deleteSource)
{
		delSrc=deleteSource;
//    progress->show();
    aborting=FALSE;
    addToLog("FTP uploadFile",LOGFTP);
    if ( fileName.isNull() )  return FALSE;
    ftpDone=TRUE;
    if(isUnconnected())
      {
        ftpDone=FALSE;
        connectToHost();
      }

    while(!ftpDone)
     {
       if(aborting) return FALSE;
       qApp->processEvents();
     }

    sourceFn=new QFile(fileName);
    if ( !sourceFn->open( QIODevice::ReadOnly ) )
		 {
//		   QMessageBox::critical( 0, tr("Upload error"),
//                tr("Can't open file '%1' for reading.").arg(fileName) );
				delete sourceFn;
				sourceFn=NULL;
        return FALSE;
    }
    QFileInfo fi( fileName );
		QFileInfo fin(fixFilename);
    addToLog(QString("FTP bytes: %1").arg(sourceFn->size()),LOGFTP);

    ftpDone=FALSE;
    int id=ftp->put( sourceFn, fi.fileName(),QFtp::Binary);
    addToLog(QString("FTP put file id: %1").arg(id),LOGFTP);
    while(!ftpDone)
     {
       if(aborting) return FALSE;
       qApp->processEvents();
     }
		if(!fixFilename.isEmpty())
			{
			 ftp->rename(fi.fileName(),fin.fileName());
			}
     addToLog("FTP starting progress",LOGFTP);
    //progress->exec(); // ### takes a lot of time!!!
    return TRUE;
}

void Benchmark::connectToHost()
{

  if (m_count < m_usersCount) {
    BenchmarkClient *client;
    if (m_authIn.size() > m_count)
      client = new BenchmarkClient(m_authIn.at(m_count).toMap(), this);
    else
      client = new BenchmarkClient(m_nickPrefix + QString::number(m_count), this);

    connect(client->io(), SIGNAL(clientStateChanged(int,int)), SLOT(clientStateChanged(int,int)));
    client->open(m_serverAddr);

//    client->setNick(m_nickPrefix + QString::number(m_count));
//    client->setCookieAuth(false);
//    client->openUrl(m_serverAddr);

//    QSettings settings(m_chatConf, QSettings::IniFormat, this);
//    settings.setIniCodec("UTF-8");
//    settings.setValue("Profile/Nick", m_nickPrefix + QString::number(m_count));
//
//    QProcess *chat = new QProcess(this);
//    m_process.append(chat);
//
//    chat->start(m_chatFile);
//    chat->waitForStarted();
//    AbstractProfile *profile = new AbstractProfile();
//    profile->setNick(m_nickPrefix + QString::number(m_count));
//    connect(this, SIGNAL(finished()), profile, SLOT(deleteLater()));

//    ClientService *service = new ClientService(profile, m_network);
//    connect(this, SIGNAL(finished()), service, SLOT(deleteLater()));

    #if !defined(BENCHMARK_NO_UI)
//    connect(service, SIGNAL(accessGranted(QString,QString,quint16)), SLOT(accessGranted(QString,QString,quint16)));
//    connect(service, SIGNAL(accessDenied(quint16)), SLOT(accessDenied(quint16)));
//    connect(service, SIGNAL(syncUsersEnd()), SLOT(syncUsersEnd()));
//    connect(service, SIGNAL(unconnected(bool)), SLOT(unconnected()));
    emit started(++m_count);
    #else
    ++m_count;
    #endif

//    msleep(m_connectInterval);
//    connectToHost();

//    service->connectToHost();
    QTimer::singleShot(m_connectInterval, this, SLOT(connectToHost()));
  }

bool CTcpClient::Connect2Server( const QHostAddress &hostAddr, quint16 nPort )
{
    svrAddr = hostAddr;
    nSvrPort = nPort;

    try {
        connectToHost( svrAddr, nSvrPort );
    } catch ( ... ) {
        int n = 0;
        n++;
        return false;
    }

    return true;
}

Response Client::get(const string &path)
{
    connectToHost();
    std::ostringstream request_stream;
    request_stream << "GET " << path << " HTTP/1.1\r\n";
    request_stream << "Host: " << host_.hostName() << "\r\n";
    request_stream << "Accept: */* \r\n";
    if (x_api_key_ != "")
        request_stream << "X-Api-Key: " << x_api_key_ << "\r\n";
    if (access_token_ != "")
        request_stream << "Authorization: Bearer " << access_token_ << "\r\n";
    request_stream << "Connection: close \r\n\r\n";	// close socket connection after get all response

    return getResponse(request_stream.str());
}