You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
465 lines
14 KiB
465 lines
14 KiB
/**************************************************************************
|
|
* Copyright (C) 2003 - 2004 by Frerich Raabe <raabe@kde.org> *
|
|
* Tobias Koenig <tokoe@kde.org> *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
***************************************************************************/
|
|
|
|
#include <tqfile.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <kio/job.h>
|
|
#include <klocale.h>
|
|
#include <kmdcodec.h>
|
|
|
|
#include "debugdialog.h"
|
|
#include "xmlrpciface.h"
|
|
|
|
using namespace KXMLRPC;
|
|
|
|
namespace KXMLRPC
|
|
{
|
|
class Result
|
|
{
|
|
friend class Query;
|
|
public:
|
|
Result()
|
|
{ }
|
|
|
|
bool success() const
|
|
{
|
|
return m_success;
|
|
}
|
|
int errorCode() const
|
|
{
|
|
return m_errorCode;
|
|
}
|
|
TQString errorString() const
|
|
{
|
|
return m_errorString;
|
|
}
|
|
TQValueList<TQVariant> data() const
|
|
{
|
|
return m_data;
|
|
}
|
|
|
|
private:
|
|
bool m_success;
|
|
int m_errorCode;
|
|
TQString m_errorString;
|
|
TQValueList<TQVariant> m_data;
|
|
};
|
|
}
|
|
|
|
Query *Query::create( const TQVariant &id, TQObject *parent, const char *name )
|
|
{
|
|
return new Query( id, parent, name );
|
|
}
|
|
|
|
void Query::call( const TQString &server, const TQString &method,
|
|
const TQValueList<TQVariant> &args, const TQString &userAgent )
|
|
{
|
|
const TQString xmlMarkup = markupCall( method, args );
|
|
DebugDialog::addMessage( xmlMarkup, DebugDialog::Output );
|
|
|
|
TQByteArray postData;
|
|
TQDataStream stream( postData, IO_WriteOnly );
|
|
stream.writeRawBytes( xmlMarkup.utf8(), xmlMarkup.utf8().length() );
|
|
|
|
KIO::TransferJob *job = KIO::http_post( KURL( server ), postData, false );
|
|
if ( !job ) {
|
|
kdWarning() << "Unable to create KIO job for " << server << endl;
|
|
return;
|
|
}
|
|
job->addMetaData( "UserAgent", userAgent );
|
|
job->addMetaData( "content-type", "Content-Type: text/xml; charset=utf-8" );
|
|
job->addMetaData( "ConnectTimeout", "50" );
|
|
|
|
connect( job, TQT_SIGNAL( data( KIO::Job *, const TQByteArray & ) ),
|
|
this, TQT_SLOT( slotData( KIO::Job *, const TQByteArray & ) ) );
|
|
connect( job, TQT_SIGNAL( result( KIO::Job * ) ),
|
|
this, TQT_SLOT( slotResult( KIO::Job * ) ) );
|
|
|
|
m_pendingJobs.append( job );
|
|
}
|
|
|
|
void Query::slotData( KIO::Job *, const TQByteArray &data )
|
|
{
|
|
unsigned int oldSize = m_buffer.size();
|
|
m_buffer.resize( oldSize + data.size() );
|
|
memcpy( m_buffer.data() + oldSize, data.data(), data.size() );
|
|
}
|
|
|
|
void Query::slotResult( KIO::Job *job )
|
|
{
|
|
m_pendingJobs.remove( job );
|
|
|
|
if ( job->error() != 0 )
|
|
{
|
|
emit fault( job->error(), job->errorString(), m_id );
|
|
emit finished( this );
|
|
return ;
|
|
}
|
|
|
|
TQString data = TQString::fromUtf8( m_buffer.data(), m_buffer.size() );
|
|
DebugDialog::addMessage( data, DebugDialog::Input );
|
|
|
|
TQDomDocument doc;
|
|
TQString errMsg;
|
|
int errLine, errCol;
|
|
if ( !doc.setContent( data, false, &errMsg, &errLine, &errCol ) )
|
|
{
|
|
emit fault( -1, i18n( "Received invalid XML markup: %1 at %2:%3" )
|
|
.arg( errMsg ).arg( errLine ).arg( errCol ), m_id );
|
|
emit finished( this );
|
|
return ;
|
|
}
|
|
|
|
m_buffer.truncate( 0 );
|
|
|
|
if ( isMessageResponse( doc ) )
|
|
emit message( parseMessageResponse( doc ).data(), m_id );
|
|
else if ( isFaultResponse( doc ) )
|
|
{
|
|
emit fault( parseFaultResponse( doc ).errorCode(), parseFaultResponse( doc ).errorString(), m_id );
|
|
}
|
|
else
|
|
{
|
|
emit fault( 1, i18n( "Unknown type of XML markup received" ), m_id );
|
|
}
|
|
|
|
emit finished( this );
|
|
}
|
|
|
|
bool Query::isMessageResponse( const TQDomDocument &doc ) const
|
|
{
|
|
return doc.documentElement().firstChild().toElement().tagName().lower() == "params";
|
|
}
|
|
|
|
Result Query::parseMessageResponse( const TQDomDocument &doc ) const
|
|
{
|
|
Result response;
|
|
response.m_success = true;
|
|
|
|
TQDomNode paramNode = doc.documentElement().firstChild().firstChild();
|
|
while ( !paramNode.isNull() )
|
|
{
|
|
response.m_data << demarshal( paramNode.firstChild().toElement() );
|
|
paramNode = paramNode.nextSibling();
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
bool Query::isFaultResponse( const TQDomDocument &doc ) const
|
|
{
|
|
return doc.documentElement().firstChild().toElement().tagName().lower() == "fault";
|
|
}
|
|
|
|
Result Query::parseFaultResponse( const TQDomDocument &doc ) const
|
|
{
|
|
Result response;
|
|
response.m_success = false;
|
|
|
|
TQDomNode errorNode = doc.documentElement().firstChild().firstChild();
|
|
const TQVariant errorVariant = demarshal( errorNode.toElement() );
|
|
response.m_errorCode = errorVariant.toMap() [ "faultCode" ].toInt();
|
|
response.m_errorString = errorVariant.toMap() [ "faultString" ].toString();
|
|
|
|
return response;
|
|
}
|
|
|
|
TQString Query::markupCall( const TQString &cmd,
|
|
const TQValueList<TQVariant> &args ) const
|
|
{
|
|
TQString markup = "<?xml version=\"1.0\" ?>\r\n<methodCall>\r\n";
|
|
|
|
markup += "<methodName>" + cmd + "</methodName>\r\n";
|
|
|
|
if ( !args.isEmpty() )
|
|
{
|
|
markup += "<params>\r\n";
|
|
TQValueList<TQVariant>::ConstIterator it = args.begin();
|
|
TQValueList<TQVariant>::ConstIterator end = args.end();
|
|
for ( ; it != end; ++it )
|
|
markup += "<param>\r\n" + marshal( *it ) + "</param>\r\n";
|
|
markup += "</params>\r\n";
|
|
}
|
|
|
|
markup += "</methodCall>\r\n";
|
|
|
|
return markup;
|
|
}
|
|
|
|
TQString Query::marshal( const TQVariant &arg ) const
|
|
{
|
|
switch ( arg.type() )
|
|
{
|
|
case TQVariant::String:
|
|
case TQVariant::CString:
|
|
{
|
|
TQString result = arg.toString();
|
|
result = result.replace( "&", "&" );
|
|
result = result.replace( "\"", """ );
|
|
result = result.replace( "<", "<" );
|
|
result = result.replace( ">", ">" );
|
|
return "<value><string>" + result + "</string></value>\r\n";
|
|
}
|
|
case TQVariant::Int:
|
|
return "<value><int>" + TQString::number( arg.toInt() ) + "</int></value>\r\n";
|
|
case TQVariant::Double:
|
|
return "<value><double>" + TQString::number( arg.toDouble() ) + "</double></value>\r\n";
|
|
case TQVariant::Bool:
|
|
{
|
|
TQString markup = "<value><boolean>";
|
|
markup += arg.toBool() ? "1" : "0";
|
|
markup += "</boolean></value>\r\n";
|
|
return markup;
|
|
}
|
|
case TQVariant::ByteArray:
|
|
return "<value><base64>" + KCodecs::base64Encode( arg.toByteArray() ) + "</base64></value>\r\n";
|
|
case TQVariant::DateTime:
|
|
return "<value><datetime.iso8601>" + arg.toDateTime().toString( Qt::ISODate ) + "</datetime.iso8601></value>\r\n";
|
|
case TQVariant::List:
|
|
{
|
|
TQString markup = "<value><array><data>\r\n";
|
|
const TQValueList<TQVariant> args = arg.toList();
|
|
TQValueList<TQVariant>::ConstIterator it = args.begin();
|
|
TQValueList<TQVariant>::ConstIterator end = args.end();
|
|
for ( ; it != end; ++it )
|
|
markup += marshal( *it );
|
|
markup += "</data></array></value>\r\n";
|
|
return markup;
|
|
}
|
|
case TQVariant::Map:
|
|
{
|
|
TQString markup = "<value><struct>\r\n";
|
|
TQMap<TQString, TQVariant> map = arg.toMap();
|
|
TQMap<TQString, TQVariant>::ConstIterator it = map.begin();
|
|
TQMap<TQString, TQVariant>::ConstIterator end = map.end();
|
|
for ( ; it != end; ++it )
|
|
{
|
|
markup += "<member>\r\n";
|
|
markup += "<name>" + it.key() + "</name>\r\n";
|
|
markup += marshal( it.data() );
|
|
markup += "</member>\r\n";
|
|
}
|
|
markup += "</struct></value>\r\n";
|
|
return markup;
|
|
}
|
|
default:
|
|
kdWarning() << "Failed to marshal unknown variant type: " << arg.type() << endl;
|
|
};
|
|
return TQString();
|
|
}
|
|
|
|
TQVariant Query::demarshal( const TQDomElement &elem ) const
|
|
{
|
|
Q_ASSERT( elem.tagName().lower() == "value" );
|
|
|
|
const TQDomElement typeElement = elem.firstChild().toElement();
|
|
const TQString typeName = typeElement.tagName().lower();
|
|
|
|
if ( typeName == "string" )
|
|
return TQVariant( typeElement.text() );
|
|
else if ( typeName == "i4" || typeName == "int" )
|
|
return TQVariant( typeElement.text().toInt() );
|
|
else if ( typeName == "double" )
|
|
return TQVariant( typeElement.text().toDouble() );
|
|
else if ( typeName == "boolean" )
|
|
{
|
|
if ( typeElement.text().lower() == "true" || typeElement.text() == "1" )
|
|
return TQVariant( true );
|
|
else
|
|
return TQVariant( false );
|
|
}
|
|
else if ( typeName == "base64" )
|
|
return TQVariant( KCodecs::base64Decode( TQCString(typeElement.text().latin1()) ) );
|
|
else if ( typeName == "datetime" || typeName == "datetime.iso8601" )
|
|
return TQVariant( TQDateTime::fromString( typeElement.text(), Qt::ISODate ) );
|
|
else if ( typeName == "array" )
|
|
{
|
|
TQValueList<TQVariant> values;
|
|
TQDomNode valueNode = typeElement.firstChild().firstChild();
|
|
while ( !valueNode.isNull() )
|
|
{
|
|
values << demarshal( valueNode.toElement() );
|
|
valueNode = valueNode.nextSibling();
|
|
}
|
|
return TQVariant( values );
|
|
}
|
|
else if ( typeName == "struct" )
|
|
{
|
|
TQMap<TQString, TQVariant> map;
|
|
TQDomNode memberNode = typeElement.firstChild();
|
|
while ( !memberNode.isNull() )
|
|
{
|
|
const TQString key = memberNode.toElement().elementsByTagName( "name" ).item( 0 ).toElement().text();
|
|
const TQVariant data = demarshal( memberNode.toElement().elementsByTagName( "value" ).item( 0 ).toElement() );
|
|
map[ key ] = data;
|
|
memberNode = memberNode.nextSibling();
|
|
}
|
|
return TQVariant( map );
|
|
}
|
|
else
|
|
kdWarning() << "Cannot demarshal unknown type " << typeName << endl;
|
|
|
|
return TQVariant();
|
|
}
|
|
|
|
Query::Query( const TQVariant &id, TQObject *parent, const char *name )
|
|
: TQObject( parent, name ), m_id( id )
|
|
{}
|
|
|
|
Query::~Query()
|
|
{
|
|
TQValueList<KIO::Job*>::Iterator it;
|
|
for ( it = m_pendingJobs.begin(); it != m_pendingJobs.end(); ++it )
|
|
(*it)->kill();
|
|
}
|
|
|
|
Server::Server( const KURL &url, TQObject *parent, const char *name )
|
|
: TQObject( parent, name )
|
|
{
|
|
if ( url.isValid() )
|
|
m_url = url;
|
|
|
|
m_userAgent = "KDE XMLRPC resources";
|
|
|
|
DebugDialog::init();
|
|
}
|
|
|
|
Server::~Server()
|
|
{
|
|
TQValueList<Query*>::Iterator it;
|
|
for ( it = mPendingQueries.begin(); it !=mPendingQueries.end(); ++it )
|
|
(*it)->deleteLater();
|
|
|
|
mPendingQueries.clear();
|
|
}
|
|
|
|
void Server::queryFinished( Query *query )
|
|
{
|
|
mPendingQueries.remove( query );
|
|
query->deleteLater();
|
|
}
|
|
|
|
void Server::setUrl( const KURL &url )
|
|
{
|
|
m_url = url.isValid() ? url : KURL();
|
|
}
|
|
|
|
void Server::call( const TQString &method, const TQValueList<TQVariant> &args,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot, const TQVariant &id )
|
|
{
|
|
if ( m_url.isEmpty() )
|
|
kdWarning() << "Cannot execute call to " << method << ": empty server URL" << endl;
|
|
|
|
Query *query = Query::create( id, this );
|
|
connect( query, TQT_SIGNAL( message( const TQValueList<TQVariant> &, const TQVariant& ) ), msgObj, messageSlot );
|
|
connect( query, TQT_SIGNAL( fault( int, const TQString&, const TQVariant& ) ), faultObj, faultSlot );
|
|
connect( query, TQT_SIGNAL( finished( Query* ) ), this, TQT_SLOT( queryFinished( Query* ) ) );
|
|
mPendingQueries.append( query );
|
|
|
|
query->call( m_url.url(), method, args, m_userAgent );
|
|
}
|
|
|
|
void Server::call( const TQString &method, const TQVariant &arg,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << arg ;
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, int arg,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << TQVariant( arg );
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, bool arg,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << TQVariant( arg );
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, double arg ,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << TQVariant( arg );
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, const TQString &arg ,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << TQVariant( arg );
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, const TQCString &arg,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << TQVariant( arg );
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, const TQByteArray &arg ,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << TQVariant( arg );
|
|
call( method, args, faultObj, faultSlot, msgObj, messageSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, const TQDateTime &arg,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
args << TQVariant( arg );
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
void Server::call( const TQString &method, const TQStringList &arg,
|
|
TQObject* msgObj, const char* messageSlot,
|
|
TQObject* faultObj, const char* faultSlot,
|
|
const TQVariant &id )
|
|
{
|
|
TQValueList<TQVariant> args;
|
|
TQStringList::ConstIterator it = arg.begin();
|
|
TQStringList::ConstIterator end = arg.end();
|
|
for ( ; it != end; ++it )
|
|
args << TQVariant( *it );
|
|
call( method, args, msgObj, messageSlot, faultObj, faultSlot, id );
|
|
}
|
|
|
|
#include "xmlrpciface.moc"
|