static void connectHandler(int fd, void *data, int flags)
{
  privateSocketStruct *pss= (privateSocketStruct *)data;
  FPRINTF((stderr, "connectHandler(%d, %p, %d)\n", fd, data, flags));
  if (flags & AIO_X) /* -- exception */
    {
      /* error during asynchronous connect() */
      aioDisable(fd);
      pss->sockError= socketError(fd);
      pss->sockState= Unconnected;
      perror("connectHandler");
    }
  else /* (flags & AIO_W) -- connect completed */
    {
      /* connect() has completed */
      int error= socketError(fd);
      if (error)
	{
	  FPRINTF((stderr, "connectHandler: error %d (%s)\n", error, strerror(error)));
	  pss->sockError= error;
	  pss->sockState= Unconnected;
	}
      else
	{
	  pss->sockState= Connected;
	  setLinger(pss->s, 1);
	}
    }
  notify(pss, CONN_NOTIFY);
}

bool UdpSocket::listen(uint16_t port)
{
    if (mPriv->listening)
        return false;

    sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = INADDR_ANY;
    local.sin_port = htons(port);
    mPriv->server = socket(AF_INET, SOCK_DGRAM, 0);
    if (mPriv->server == INVALID_SOCKET) {
        const int err = socketError();
        fprintf(stderr, "socket failed: %d %s\n", err, socketErrorMessage(err).c_str());
        return false;
    }
    if (bind(mPriv->server, reinterpret_cast<sockaddr*>(&local), sizeof(local))) {
        const int err = socketError();
        fprintf(stderr, "bind on port %d failed: %d %s\n", port, err, socketErrorMessage(err).c_str());
        close(mPriv->server);
        return false;
    }

    mPriv->start();
    mPriv->listening = true;

    return true;
}

/* wrapper for socket accpeting */
int socksswitch_accept(const int sock) {
    SOCKET_ADDR_LEN addrlen = sizeof(struct sockaddr_in);
    struct sockaddr_in addr;
    int rc;

    DEBUG_ENTER;

    rc = accept(sock, (struct sockaddr *) &addr, &addrlen);

    /* socket connected */
    if (rc > 0) {
	TRACE_INFO("connect from %s:%i (socket:%i)\n",
		   inet_ntoa(addr.sin_addr), ntohs(addr.sin_port), rc);
    }

    /* error */
    else {
	TRACE_WARNING("failure on connecting (socket:%i err:%i): %s\n",
		      sock, SOCKET_ERROR_CODE, socketError());
	socketError();
    }

    DEBUG_LEAVE;
    return rc;
}

int_t send(int_t s, const void *data, int_t length, int_t flags)
{
   error_t error;
   size_t written;
   Socket *socket;

   //Make sure the socket descriptor is valid
   if(s < 0 || s >= SOCKET_MAX_COUNT)
   {
      socketError(NULL, ERROR_INVALID_SOCKET);
      return SOCKET_ERROR;
   }

   //Point to the socket structure
   socket = &socketTable[s];

   //Send data
   error = socketSend(socket, data, length, &written, flags << 8);

   //Any error to report?
   if(error)
   {
      socketError(socket, error);
      return SOCKET_ERROR;
   }

   //Return the number of bytes sent
   return written;
}

SimondConnector::SimondConnector(QObject *parent) :
    QObject(parent), state(Unconnected),
    socket(new QSslSocket(this)),
    timeoutTimer(new QTimer(this)),
    response(new QDataStream(socket)),
    mic(new SoundInput(SOUND_CHANNELS, SOUND_SAMPLERATE, this)),
    passThroughSound(false)
{
    connect(this, SIGNAL(connectionState(ConnectionState)), this, SLOT(setCurrentState(ConnectionState)));
    connect(socket, SIGNAL(readyRead()), this, SLOT(messageReceived()));
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError()));
    connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(socketError()));
    connect(socket, SIGNAL(connected()), this, SLOT(connectionEstablished()));
    connect(socket, SIGNAL(encrypted()), this, SLOT(connectionEstablished()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(connectionLost()));

    connect(mic, SIGNAL(error(QString)), this, SIGNAL(error(QString)));
    connect(mic, SIGNAL(microphoneLevel(int,int,int)), this, SIGNAL(microphoneLevel(int,int,int)));
    connect(mic, SIGNAL(listening()), this, SLOT(startRecording()));
    connect(mic, SIGNAL(complete()), this, SLOT(commitRecording()));
    connect(mic, SIGNAL(readyRead()), this, SLOT(soundDataAvailable()));

    connect(timeoutTimer, SIGNAL(timeout()), this, SLOT(timeoutReached()));
    timeoutTimer->setSingleShot(true);
    timeoutTimer->setInterval(SOCKET_TIMEOUT);
}

int_t recv(int_t s, void *data, int_t size, int_t flags)
{
   error_t error;
   size_t received;
   Socket *socket;

   //Make sure the socket descriptor is valid
   if(s < 0 || s >= SOCKET_MAX_COUNT)
   {
      socketError(NULL, ERROR_INVALID_SOCKET);
      return SOCKET_ERROR;
   }

   //Point to the socket structure
   socket = &socketTable[s];

   //Receive data
   error = socketReceive(socket, data, size, &received, flags << 8);

   //Any error to report?
   if(error)
   {
      socketError(socket, error);
      return SOCKET_ERROR;
   }

   //Return the number of bytes received
   return received;
}

int_t shutdown(int_t s, int_t how)
{
   error_t error;
   Socket *socket;

   //Make sure the socket descriptor is valid
   if(s < 0 || s >= SOCKET_MAX_COUNT)
   {
      socketError(NULL, ERROR_INVALID_SOCKET);
      return SOCKET_ERROR;
   }

   //Point to the socket structure
   socket = &socketTable[s];

   //Shutdown socket
   error = socketShutdown(socket, how);

   //Any error to report?
   if(error)
   {
      socketError(socket, error);
      return SOCKET_ERROR;
   }

   //Successful processing
   return SOCKET_SUCCESS;
}

void ClientApplication::start() {
	if (!parseCommandLine()) {
		QMessageBox::critical(NULL, applicationName(), trUtf8("Error in the command line arguments. Arguments:\n--host <h>\tConnect to the server on host <h>.\n--local\tRun client locally.\n--port <p>\tUse port <p> to connect to the server."));
		quit();
		return;
	}
	if (mode == mUnspecified) {
		ConnectDialog connectDialog;
		int code = connectDialog.exec();
		if (code == QDialog::Rejected) {
			quit();
			return;
		}
		if (connectDialog.local()) {
			mode = mLocal;
		}
		else {
			mode = mRemote;
			host = connectDialog.host();
			port = connectDialog.port();
		}
	}
	if (mode == mLocal) {
		theTrainer.reset(new Trainer());
		showMainWindow();
	}
	else {
		ProxyTrainer *trainer = new ProxyTrainer();
		theTrainer.reset(trainer);
		connect(trainer, SIGNAL(socketConnected()), SLOT(showMainWindow()));
		connect(trainer, SIGNAL(socketDisconnected()), SLOT(socketDisconnected()));
		connect(trainer, SIGNAL(socketError(QString)), SLOT(socketError(QString)));
		trainer->socketConnectToHost(host, port);
	}
}

int_t listen(int_t s, int_t backlog)
{
   error_t error;
   Socket *socket;

   //Make sure the socket descriptor is valid
   if(s < 0 || s >= SOCKET_MAX_COUNT)
   {
      socketError(NULL, ERROR_INVALID_SOCKET);
      return SOCKET_ERROR;
   }

   //Point to the socket structure
   socket = &socketTable[s];

   //Place the socket in the listening state
   error = socketListen(socket);

   //Any error to report?
   if(error)
   {
      socketError(socket, error);
      return SOCKET_ERROR;
   }

   //Successful processing
   return SOCKET_SUCCESS;
}

/* create and bind master socket */
int masterSocket(const int port) {
    int rc;
    struct sockaddr_in addr;

    DEBUG_ENTER;

    /* create master socket */
    rc = socket(AF_INET, SOCK_STREAM, 0);
    if (rc == SOCKET_ERROR) {
	TRACE_ERROR("master socket create (err:%i): %s\n",
		    SOCKET_ERROR_CODE, socketError());
	DEBUG_LEAVE;
	return 0;
    }

    TRACE_VERBOSE("master socket created: %i\n", rc);

    DEBUG;

    /* set socket non blocking */
#ifdef WIN32
    unsigned long nValue = 1;
    ioctlsocket(rc, FIONBIO, &nValue);
#endif

    DEBUG;

    /* bind master socket */
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(port);
    if (bind
	(rc, (struct sockaddr *) &addr,
	 sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
	TRACE_ERROR("failure on binding socket (err:%i): %s\n",
		    SOCKET_ERROR_CODE, socketError());
	DEBUG_LEAVE;
	exit(1);
    }
    TRACE_VERBOSE("master socket bound: %i\n", rc);

    DEBUG;

    /* listen master socket */
    if (listen(rc, 128) == SOCKET_ERROR) {
	TRACE_ERROR("failure on listening (err:%i): %s\n",
		    SOCKET_ERROR_CODE, socketError());
	DEBUG_LEAVE;
	exit(1);
    }

    TRACE_INFO("listening on *:%d (socket:%i)\n", port, rc);
    DEBUG_LEAVE;
    return rc;
}

void UdpSocketPrivate::run()
{
    sockaddr_in from;
    socklen_t fromlen;
    int ret;
    timeval tv;
    fd_set fds;
    char buf[4096];

    for (;;) {
        tv.tv_sec = 5;
        tv.tv_usec = 0;

        FD_ZERO(&fds);
        FD_SET(server, &fds);

        ret = select(server + 1, &fds, 0, 0, &tv);
        if (ret == SOCKET_ERROR) {
            const int err = socketError();
            fprintf(stderr, "socket failed: %d %s\n", err, UdpSocket::socketErrorMessage(err).c_str());
            return;
        } else if (ret > 0) {
            assert(FD_ISSET(server, &fds));
            bool done;
            do {
                done = true;
                fromlen = sizeof(from);
                ret = recvfrom(server, buf, sizeof(buf), 0, reinterpret_cast<sockaddr*>(&from), &fromlen);
                if (ret == SOCKET_ERROR) {
                    const int err = socketError();
                    if (err == EINTR)
                        done = false;
                    else {
                        fprintf(stderr, "socket recvfrom failed: %d %s\n", err, UdpSocket::socketErrorMessage(err).c_str());
                        return;
                    }
                }
                //printf("got socket data %d\n", ret);
                if (callback && !callback(buf, ret, userData)) {
                    return;
                }
            } while (!done);
        }
        //printf("server wakeup\n");

        MutexLocker locker(&mutex);
        if (stopped)
            return;
    }
}

void MainWindow::startServer()
{
    if(!db || !db->isOpen()) {
        QMessageBox::information(this, tr("No database"),
                                 tr("you need to configure database for server at first..."));
        return;
    }
    if(server) {
        server->close();
        delete server;
    }

    server = new FSEServer(this);
    server->setDatabase(db);

    connect(server, SIGNAL(acceptError(QAbstractSocket::SocketError)),
            this, SLOT(socketError(QAbstractSocket::SocketError)));
    connect(server, SIGNAL(errorString(QString)),
            this, SLOT(logCollect(QString)));
    connect(server, SIGNAL(debugString(QString)),
            this, SLOT(logCollect(QString)));

    if(server->listen(QHostAddress(IPv4), serverPort)) {
        logCollect(tr("start to listen ") + IPv4 + ":" +QString::number(serverPort));
        stateChange(ServerWorking);
    }
    else {
        qDebug() << "start failed" << server->serverError();
        stopServer();
    }
}

/*!
    Constructs an assistant client with the given \a parent.
    The \a path specifies the path to the Qt Assistant executable.
    If \a path is an empty string the system path (\c{%PATH%} or \c $PATH)
    is used.
*/
QAssistantClient::QAssistantClient( const QString &path, QObject *parent )
    : QObject( parent ), host ( QLatin1String("localhost") )
{
    if ( path.isEmpty() )
        assistantCommand = QLatin1String("assistant");
    else {
        QFileInfo fi( path );
        if ( fi.isDir() )
            assistantCommand = path + QLatin1String("/assistant");
        else
            assistantCommand = path;
    }

#if defined(Q_OS_MAC)
    assistantCommand += QLatin1String(".app/Contents/MacOS/assistant");
#endif

    socket = new QTcpSocket( this );
    connect( socket, SIGNAL(connected()),
            SLOT(socketConnected()) );
    connect( socket, SIGNAL(disconnected()),
            SLOT(socketConnectionClosed()) );
    connect( socket, SIGNAL(error(QAbstractSocket::SocketError)),
             SLOT(socketError()) );
    opened = false;
    proc = new QProcess( this );
    port = 0;
    pageBuffer = QLatin1String("");
    connect( proc, SIGNAL(readyReadStandardError()),
             this, SLOT(readStdError()) );
    connect( proc, SIGNAL(error(QProcess::ProcessError)),
        this, SLOT(procError(QProcess::ProcessError)) );
}

IndiClient::IndiClient(const int &attempts) : mPort(indi::PORT), mAttempts(attempts), mAttempt(1)
{
    connect(&mQTcpSocket, SIGNAL(connected()), SLOT(socketConnected()));
    connect(&mQTcpSocket, SIGNAL(disconnected()), SLOT(socketDisconnected()));
    connect(&mQTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(socketError(QAbstractSocket::SocketError)));
    connect(&mQTcpSocket, SIGNAL(readyRead()), SLOT(socketReadyRead()));
}

//! [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();
}

FilezillaAdminConnection::FilezillaAdminConnection(QObject *parent) :
    QObject(parent)
{
    mSocket = new QTcpSocket();
    connect(mSocket, SIGNAL(readyRead()), this, SLOT(bytesToRead()));
    connect(mSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError)));
}

TSock::TSock(QTcpSocket *sock, QObject *parent) :
  QObject(parent),
  listenPort(0)
{

    if (sock == NULL)
        socket = new QTcpSocket;
    else
        socket = sock;

    connect(socket, SIGNAL(connected()),
            this, SLOT(socketConnected()));

    connect(socket, SIGNAL(disconnected()),
            this, SLOT(socketDisconnected()));

    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
            this, SLOT(socketError(QAbstractSocket::SocketError)));

    connect(socket, SIGNAL(readyRead()),
            this, SLOT(socketDataReady()));


    connect(&server, SIGNAL(newConnection()),
            this, SLOT(serverConnection()));
}

void MessageQueue::writeData() {
	if(_sendbuflen==0) {
		// If send buffer is empty, serialize the next message in the queue.
		// The snapshot upload queue has lower priority than the normal queue.
		if(!_sendqueue.isEmpty()) {
			// There are messages in the higher priority queue, send one
			_sendbuflen = _sendqueue.dequeue()->serialize(_sendbuffer);
		} else if(!_snapshot_send.isEmpty()) {
			// If there is nothing in the normal send queue, check if
			// there is something in the lower priority snapshot queue
			SnapshotMode mode(SnapshotMode::SNAPSHOT);
			_sendbuflen = mode.serialize(_sendbuffer);
			_sendbuflen += _snapshot_send.takeFirst()->serialize(_sendbuffer + _sendbuflen);
		}
	}

	if(_sentcount < _sendbuflen) {
		int sent = _socket->write(_sendbuffer+_sentcount, _sendbuflen-_sentcount);
		if(sent<0) {
			// Error
			emit socketError(_socket->errorString());
			return;
		}
		_sentcount += sent;
		if(_sentcount == _sendbuflen) {
			_sendbuflen=0;
			_sentcount=0;
			if(_closeWhenReady)
				close();
			else
				writeData();
		}
	}
}

SmtpClient::SmtpClient(const QString & host, int port, ConnectionType ct) :
    name("localhost"),
    authMethod(AuthPlain),
    connectionTimeout(5000),
    responseTimeout(5000)
{
    if (ct == TcpConnection)
        this->useSsl = false;
    else if (ct == SslConnection)
        this->useSsl = true;

    if (useSsl == false)
        socket = new QTcpSocket(this);
    else
        socket = new QSslSocket(this);

    this->host = host;
    this->port = port;

    connect(socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
            this, SLOT(socketStateChanged(QAbstractSocket::SocketState)));
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
            this, SLOT(socketError(QAbstractSocket::SocketError)));
    connect(socket, SIGNAL(readyRead()),
            this, SLOT(socketReadyRead()));
}

/* wrapper for socket closing */
int socksswitch_close(const int sock) {
    char addrstr[256];

    DEBUG_ENTER;

    if (sock <= 0) {
	DEBUG_LEAVE;
	return 0;
    }

    strcpy(addrstr, socksswitch_addr(sock));

    /* disconnect */
    if (shutdown(sock, SD_BOTH) == 0 && SOCKET_CLOSE(sock) == 0)
	TRACE_INFO("disconnected from %s (socket:%i)\n", addrstr, sock);

    /* error */
    else {
	TRACE_WARNING
	    ("failure on closing from %s (socket:%i err:%i): %s\n",
	     addrstr, sock, SOCKET_ERROR_CODE, socketError());
	DEBUG_LEAVE;
	return SOCKET_ERROR;
    }

    DEBUG_LEAVE;
    return 1;
}