Пример #1
0
void first4thread::run()
{
    tcpSocket = new QTcpSocket;
    if (!tcpSocket->setSocketDescriptor(socketDescriptor)) {
	emit error(tcpSocket->error());
	return;
    }
    qDebug() << "New connection from: " << tcpSocket->peerAddress().toString();

    QDomDocument doc("first4");
    QDomElement root = doc.createElement("first4server");
    doc.appendChild(root);
	QDomElement server = doc.createElement("Server");
	server.setAttribute("Version", f4srv_version);
	server.setAttribute("Host", QHostInfo::localHostName()+"."+QHostInfo::localDomainName());
	server.setAttribute("ClientRequired", f4srv_client_required);
	root.appendChild(server);

    tcpSocket->write(doc.toByteArray());
    connect(tcpSocket, SIGNAL(readyRead()), SLOT(incomingRequest()), Qt::AutoConnection);
    tcpSocket->flush();
    //tcpSocket->disconnectFromHost();
    tcpSocket->waitForDisconnected();
}
Пример #2
0
/**
 *  Parse incoming \a request, and emit incomingRequest() signal
 *  or return xmlrpc response back to \a socket */
void Server::processRequest( QByteArray request, QTcpSocket *socket )
{
    d->lastRequestId++;


    int requestId = d->lastRequestId;
    d->processingRequests[ requestId ] = socket;


    int dataPos = request.indexOf("\r\n\r\n")+4;

    if ( dataPos < 0 ) {
        qDebug() << "did not find data part";
        socket->disconnectFromHost();
        return;
    }

    QByteArray requestHeader = request.left( dataPos );
    QByteArray requestData = request.mid( dataPos );

    QHttpRequestHeader httpRequestHeader( QString::fromUtf8(requestHeader) );

    bool keepAlive = httpRequestHeader.value("Connection").toLower() == "keep-alive";
    if ( keepAlive ) {
        d->keepAliveRequests.insert( requestId );
    }

    /*
    qDebug() << "request:";
    if ( request.count() < 1024 )
        qDebug() << QString( request );
    else
        qDebug() << "too long";
    */
    
    Request parsedRequest;
    QString errorMessage;

    if ( !parsedRequest.setContent(requestData,&errorMessage) ) {
        sendFault( requestId, -32600, errorMessage );
        return;
    }

    QString methodName = parsedRequest.methodName();
    QList<Variant> parameters = parsedRequest.parameters();

    //qDebug() << methodName << parameters;

    if ( methodName.startsWith("system.") ) {
        //reserved server methods

        if ( methodName == "system.listMethods" ) {
            sendReturnValue(requestId, Variant( d->introspection.listMethods() ) );
            return;
        }

        if ( methodName == "system.methodSignature" && parameters.count() == 1 ) {
            QString methodName = parameters[0].toString();

            sendReturnValue(requestId, Variant( d->introspection.methodSignatures(methodName) ) );
            return;
        }

        if ( methodName == "system.methodHelp" && parameters.count() == 1 ) {
            QString methodName = parameters[0].toString();

            sendReturnValue(requestId, Variant( d->introspection.methodHelp(methodName) ) );
            return;
        }

        sendFault(requestId, -32601, "Method not found" );
        return;
    }

    if ( !d->introspection.isEmpty() ) {
        // check method name first:

        if ( !d->introspection.isMethodSupported(methodName) ) {
            sendFault(requestId, -32601, "Method not found" );
            return;
        }

        QVariant::Type returnType;

        

        if ( !d->introspection.checkMethodParameters( methodName,
                                                      parameters,
                                                      &returnType ) ) {
            sendFault(requestId, -32602, "Invalid method parameters" );
            return;
        }

        d->expectedReturnTypes[ requestId ] = returnType;
    }

    Q_EMIT incomingRequest( requestId, methodName, parameters );
}