350 lines
8.5 KiB
C++
350 lines
8.5 KiB
C++
/**
|
|
* @file llsdrpcserver.cpp
|
|
* @author Phoenix
|
|
* @date 2005-10-11
|
|
* @brief Implementation of the LLSDRPCServer and related classes.
|
|
*
|
|
* $LicenseInfo:firstyear=2005&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2005-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "linden_common.h"
|
|
#include "llsdrpcserver.h"
|
|
|
|
#include "llbuffer.h"
|
|
#include "llbufferstream.h"
|
|
#include "llmemtype.h"
|
|
#include "llpumpio.h"
|
|
#include "llsdserialize.h"
|
|
#include "llstl.h"
|
|
|
|
static const char FAULT_PART_1[] = "{'fault':{'code':i";
|
|
static const char FAULT_PART_2[] = ", 'description':'";
|
|
static const char FAULT_PART_3[] = "'}}";
|
|
|
|
static const char RESPONSE_PART_1[] = "{'response':";
|
|
static const char RESPONSE_PART_2[] = "}";
|
|
|
|
static const S32 FAULT_GENERIC = 1000;
|
|
static const S32 FAULT_METHOD_NOT_FOUND = 1001;
|
|
|
|
static const std::string LLSDRPC_METHOD_SD_NAME("method");
|
|
static const std::string LLSDRPC_PARAMETER_SD_NAME("parameter");
|
|
|
|
|
|
/**
|
|
* LLSDRPCServer
|
|
*/
|
|
LLSDRPCServer::LLSDRPCServer() :
|
|
mState(LLSDRPCServer::STATE_NONE),
|
|
mPump(NULL),
|
|
mLock(0)
|
|
{
|
|
LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER);
|
|
}
|
|
|
|
LLSDRPCServer::~LLSDRPCServer()
|
|
{
|
|
LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER);
|
|
std::for_each(
|
|
mMethods.begin(),
|
|
mMethods.end(),
|
|
llcompose1(
|
|
DeletePointerFunctor<LLSDRPCMethodCallBase>(),
|
|
llselect2nd<method_map_t::value_type>()));
|
|
std::for_each(
|
|
mCallbackMethods.begin(),
|
|
mCallbackMethods.end(),
|
|
llcompose1(
|
|
DeletePointerFunctor<LLSDRPCMethodCallBase>(),
|
|
llselect2nd<method_map_t::value_type>()));
|
|
}
|
|
|
|
|
|
// virtual
|
|
ESDRPCSStatus LLSDRPCServer::deferredResponse(
|
|
const LLChannelDescriptors& channels,
|
|
LLBufferArray* data) {
|
|
// subclass should provide a sane implementation
|
|
return ESDRPCS_DONE;
|
|
}
|
|
|
|
void LLSDRPCServer::clearLock()
|
|
{
|
|
if(mLock && mPump)
|
|
{
|
|
mPump->clearLock(mLock);
|
|
mPump = NULL;
|
|
mLock = 0;
|
|
}
|
|
}
|
|
|
|
// virtual
|
|
LLIOPipe::EStatus LLSDRPCServer::process_impl(
|
|
const LLChannelDescriptors& channels,
|
|
buffer_ptr_t& buffer,
|
|
bool& eos,
|
|
LLSD& context,
|
|
LLPumpIO* pump)
|
|
{
|
|
PUMP_DEBUG;
|
|
LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER);
|
|
// lldebugs << "LLSDRPCServer::process_impl" << llendl;
|
|
// Once we have all the data, We need to read the sd on
|
|
// the the in channel, and respond on the out channel
|
|
if(!eos) return STATUS_BREAK;
|
|
if(!pump || !buffer) return STATUS_PRECONDITION_NOT_MET;
|
|
|
|
std::string method_name;
|
|
LLIOPipe::EStatus status = STATUS_DONE;
|
|
|
|
switch(mState)
|
|
{
|
|
case STATE_DEFERRED:
|
|
PUMP_DEBUG;
|
|
if(ESDRPCS_DONE != deferredResponse(channels, buffer.get()))
|
|
{
|
|
buildFault(
|
|
channels,
|
|
buffer.get(),
|
|
FAULT_GENERIC,
|
|
"deferred response failed.");
|
|
}
|
|
mState = STATE_DONE;
|
|
return STATUS_DONE;
|
|
|
|
case STATE_DONE:
|
|
// lldebugs << "STATE_DONE" << llendl;
|
|
break;
|
|
case STATE_CALLBACK:
|
|
// lldebugs << "STATE_CALLBACK" << llendl;
|
|
PUMP_DEBUG;
|
|
method_name = mRequest[LLSDRPC_METHOD_SD_NAME].asString();
|
|
if(!method_name.empty() && mRequest.has(LLSDRPC_PARAMETER_SD_NAME))
|
|
{
|
|
if(ESDRPCS_DONE != callbackMethod(
|
|
method_name,
|
|
mRequest[LLSDRPC_PARAMETER_SD_NAME],
|
|
channels,
|
|
buffer.get()))
|
|
{
|
|
buildFault(
|
|
channels,
|
|
buffer.get(),
|
|
FAULT_GENERIC,
|
|
"Callback method call failed.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// this should never happen, since we should not be in
|
|
// this state unless we originally found a method and
|
|
// params during the first call to process.
|
|
buildFault(
|
|
channels,
|
|
buffer.get(),
|
|
FAULT_GENERIC,
|
|
"Invalid LLSDRPC sever state - callback without method.");
|
|
}
|
|
pump->clearLock(mLock);
|
|
mLock = 0;
|
|
mState = STATE_DONE;
|
|
break;
|
|
case STATE_NONE:
|
|
// lldebugs << "STATE_NONE" << llendl;
|
|
default:
|
|
{
|
|
// First time we got here - process the SD request, and call
|
|
// the method.
|
|
PUMP_DEBUG;
|
|
LLBufferStream istr(channels, buffer.get());
|
|
mRequest.clear();
|
|
LLSDSerialize::fromNotation(
|
|
mRequest,
|
|
istr,
|
|
buffer->count(channels.in()));
|
|
|
|
// { 'method':'...', 'parameter': ... }
|
|
method_name = mRequest[LLSDRPC_METHOD_SD_NAME].asString();
|
|
if(!method_name.empty() && mRequest.has(LLSDRPC_PARAMETER_SD_NAME))
|
|
{
|
|
ESDRPCSStatus rv = callMethod(
|
|
method_name,
|
|
mRequest[LLSDRPC_PARAMETER_SD_NAME],
|
|
channels,
|
|
buffer.get());
|
|
switch(rv)
|
|
{
|
|
case ESDRPCS_DEFERRED:
|
|
mPump = pump;
|
|
mLock = pump->setLock();
|
|
mState = STATE_DEFERRED;
|
|
status = STATUS_BREAK;
|
|
break;
|
|
|
|
case ESDRPCS_CALLBACK:
|
|
{
|
|
mState = STATE_CALLBACK;
|
|
LLPumpIO::LLLinkInfo link;
|
|
link.mPipe = LLIOPipe::ptr_t(this);
|
|
link.mChannels = channels;
|
|
LLPumpIO::links_t links;
|
|
links.push_back(link);
|
|
pump->respond(links, buffer, context);
|
|
mLock = pump->setLock();
|
|
status = STATUS_BREAK;
|
|
break;
|
|
}
|
|
case ESDRPCS_DONE:
|
|
mState = STATE_DONE;
|
|
break;
|
|
case ESDRPCS_ERROR:
|
|
default:
|
|
buildFault(
|
|
channels,
|
|
buffer.get(),
|
|
FAULT_GENERIC,
|
|
"Method call failed.");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// send a fault
|
|
buildFault(
|
|
channels,
|
|
buffer.get(),
|
|
FAULT_GENERIC,
|
|
"Unable to find method and parameter in request.");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
PUMP_DEBUG;
|
|
return status;
|
|
}
|
|
|
|
// virtual
|
|
ESDRPCSStatus LLSDRPCServer::callMethod(
|
|
const std::string& method,
|
|
const LLSD& params,
|
|
const LLChannelDescriptors& channels,
|
|
LLBufferArray* response)
|
|
{
|
|
LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER);
|
|
// Try to find the method in the method table.
|
|
ESDRPCSStatus rv = ESDRPCS_DONE;
|
|
method_map_t::iterator it = mMethods.find(method);
|
|
if(it != mMethods.end())
|
|
{
|
|
rv = (*it).second->call(params, channels, response);
|
|
}
|
|
else
|
|
{
|
|
it = mCallbackMethods.find(method);
|
|
if(it == mCallbackMethods.end())
|
|
{
|
|
// method not found.
|
|
std::ostringstream message;
|
|
message << "rpc server unable to find method: " << method;
|
|
buildFault(
|
|
channels,
|
|
response,
|
|
FAULT_METHOD_NOT_FOUND,
|
|
message.str());
|
|
}
|
|
else
|
|
{
|
|
// we found it in the callback methods - tell the process
|
|
// to coordinate calling on the pump callback.
|
|
return ESDRPCS_CALLBACK;
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
// virtual
|
|
ESDRPCSStatus LLSDRPCServer::callbackMethod(
|
|
const std::string& method,
|
|
const LLSD& params,
|
|
const LLChannelDescriptors& channels,
|
|
LLBufferArray* response)
|
|
{
|
|
LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER);
|
|
// Try to find the method in the callback method table.
|
|
ESDRPCSStatus rv = ESDRPCS_DONE;
|
|
method_map_t::iterator it = mCallbackMethods.find(method);
|
|
if(it != mCallbackMethods.end())
|
|
{
|
|
rv = (*it).second->call(params, channels, response);
|
|
}
|
|
else
|
|
{
|
|
std::ostringstream message;
|
|
message << "pcserver unable to find callback method: " << method;
|
|
buildFault(
|
|
channels,
|
|
response,
|
|
FAULT_METHOD_NOT_FOUND,
|
|
message.str());
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
void LLSDRPCServer::buildFault(
|
|
const LLChannelDescriptors& channels,
|
|
LLBufferArray* data,
|
|
S32 code,
|
|
const std::string& msg)
|
|
{
|
|
LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER);
|
|
LLBufferStream ostr(channels, data);
|
|
ostr << FAULT_PART_1 << code << FAULT_PART_2 << msg << FAULT_PART_3;
|
|
llinfos << "LLSDRPCServer::buildFault: " << code << ", " << msg << llendl;
|
|
}
|
|
|
|
// static
|
|
void LLSDRPCServer::buildResponse(
|
|
const LLChannelDescriptors& channels,
|
|
LLBufferArray* data,
|
|
const LLSD& response)
|
|
{
|
|
LLMemType m1(LLMemType::MTYPE_IO_SD_SERVER);
|
|
LLBufferStream ostr(channels, data);
|
|
ostr << RESPONSE_PART_1;
|
|
LLSDSerialize::toNotation(response, ostr);
|
|
ostr << RESPONSE_PART_2;
|
|
#if LL_DEBUG
|
|
std::ostringstream debug_ostr;
|
|
debug_ostr << "LLSDRPCServer::buildResponse: ";
|
|
LLSDSerialize::toNotation(response, debug_ostr);
|
|
llinfos << debug_ostr.str() << llendl;
|
|
#endif
|
|
}
|