llsdrpcclient.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:6k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llsdrpcclient.cpp
  3.  * @author Phoenix
  4.  * @date 2005-11-05
  5.  * @brief Implementation of the llsd client classes.
  6.  *
  7.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2005-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  34. #include "linden_common.h"
  35. #include "llsdrpcclient.h"
  36. #include "llbufferstream.h"
  37. #include "llfiltersd2xmlrpc.h"
  38. #include "llmemtype.h"
  39. #include "llpumpio.h"
  40. #include "llsd.h"
  41. #include "llsdserialize.h"
  42. #include "llurlrequest.h"
  43. /**
  44.  * String constants
  45.  */
  46. static std::string LLSDRPC_RESPONSE_NAME("response");
  47. static std::string LLSDRPC_FAULT_NAME("fault");
  48. /** 
  49.  * LLSDRPCResponse
  50.  */
  51. LLSDRPCResponse::LLSDRPCResponse() :
  52. mIsError(false),
  53. mIsFault(false)
  54. {
  55. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  56. }
  57. // virtual
  58. LLSDRPCResponse::~LLSDRPCResponse()
  59. {
  60. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  61. }
  62. bool LLSDRPCResponse::extractResponse(const LLSD& sd)
  63. {
  64. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  65. bool rv = true;
  66. if(sd.has(LLSDRPC_RESPONSE_NAME))
  67. {
  68. mReturnValue = sd[LLSDRPC_RESPONSE_NAME];
  69. mIsFault = false;
  70. }
  71. else if(sd.has(LLSDRPC_FAULT_NAME))
  72. {
  73. mReturnValue = sd[LLSDRPC_FAULT_NAME];
  74. mIsFault = true;
  75. }
  76. else
  77. {
  78. mReturnValue.clear();
  79. mIsError = true;
  80. rv = false;
  81. }
  82. return rv;
  83. }
  84. // virtual
  85. LLIOPipe::EStatus LLSDRPCResponse::process_impl(
  86. const LLChannelDescriptors& channels,
  87. buffer_ptr_t& buffer,
  88. bool& eos,
  89. LLSD& context,
  90. LLPumpIO* pump)
  91. {
  92. PUMP_DEBUG;
  93. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  94. if(mIsError)
  95. {
  96. error(pump);
  97. }
  98. else if(mIsFault)
  99. {
  100. fault(pump);
  101. }
  102. else
  103. {
  104. response(pump);
  105. }
  106. PUMP_DEBUG;
  107. return STATUS_DONE;
  108. }
  109. /** 
  110.  * LLSDRPCClient
  111.  */
  112. LLSDRPCClient::LLSDRPCClient() :
  113. mState(STATE_NONE),
  114. mQueue(EPBQ_PROCESS)
  115. {
  116. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  117. }
  118. // virtual
  119. LLSDRPCClient::~LLSDRPCClient()
  120. {
  121. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  122. }
  123. bool LLSDRPCClient::call(
  124. const std::string& uri,
  125. const std::string& method,
  126. const LLSD& parameter,
  127. LLSDRPCResponse* response,
  128. EPassBackQueue queue)
  129. {
  130. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  131. //llinfos << "RPC: " << uri << "." << method << "(" << *parameter << ")"
  132. // << llendl;
  133. if(method.empty() || !response)
  134. {
  135. return false;
  136. }
  137. mState = STATE_READY;
  138. mURI.assign(uri);
  139. std::stringstream req;
  140. req << LLSDRPC_REQUEST_HEADER_1 << method
  141. << LLSDRPC_REQUEST_HEADER_2;
  142. LLSDSerialize::toNotation(parameter, req);
  143. req << LLSDRPC_REQUEST_FOOTER;
  144. mRequest = req.str();
  145. mQueue = queue;
  146. mResponse = response;
  147. return true;
  148. }
  149. bool LLSDRPCClient::call(
  150. const std::string& uri,
  151. const std::string& method,
  152. const std::string& parameter,
  153. LLSDRPCResponse* response,
  154. EPassBackQueue queue)
  155. {
  156. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  157. //llinfos << "RPC: " << uri << "." << method << "(" << parameter << ")"
  158. // << llendl;
  159. if(method.empty() || parameter.empty() || !response)
  160. {
  161. return false;
  162. }
  163. mState = STATE_READY;
  164. mURI.assign(uri);
  165. std::stringstream req;
  166. req << LLSDRPC_REQUEST_HEADER_1 << method
  167. << LLSDRPC_REQUEST_HEADER_2 << parameter
  168. << LLSDRPC_REQUEST_FOOTER;
  169. mRequest = req.str();
  170. mQueue = queue;
  171. mResponse = response;
  172. return true;
  173. }
  174. // virtual
  175. LLIOPipe::EStatus LLSDRPCClient::process_impl(
  176. const LLChannelDescriptors& channels,
  177. buffer_ptr_t& buffer,
  178. bool& eos,
  179. LLSD& context,
  180. LLPumpIO* pump)
  181. {
  182. PUMP_DEBUG;
  183. LLMemType m1(LLMemType::MTYPE_IO_SD_CLIENT);
  184. if((STATE_NONE == mState) || (!pump))
  185. {
  186. // You should have called the call() method already.
  187. return STATUS_PRECONDITION_NOT_MET;
  188. }
  189. EStatus rv = STATUS_DONE;
  190. switch(mState)
  191. {
  192. case STATE_READY:
  193. {
  194. PUMP_DEBUG;
  195. // lldebugs << "LLSDRPCClient::process_impl STATE_READY" << llendl;
  196. buffer->append(
  197. channels.out(),
  198. (U8*)mRequest.c_str(),
  199. mRequest.length());
  200. context[CONTEXT_DEST_URI_SD_LABEL] = mURI;
  201. mState = STATE_WAITING_FOR_RESPONSE;
  202. break;
  203. }
  204. case STATE_WAITING_FOR_RESPONSE:
  205. {
  206. PUMP_DEBUG;
  207. // The input channel has the sd response in it.
  208. //lldebugs << "LLSDRPCClient::process_impl STATE_WAITING_FOR_RESPONSE"
  209. //  << llendl;
  210. LLBufferStream resp(channels, buffer.get());
  211. LLSD sd;
  212. LLSDSerialize::fromNotation(sd, resp, buffer->count(channels.in()));
  213. LLSDRPCResponse* response = (LLSDRPCResponse*)mResponse.get();
  214. if (!response)
  215. {
  216. mState = STATE_DONE;
  217. break;
  218. }
  219. response->extractResponse(sd);
  220. if(EPBQ_PROCESS == mQueue)
  221. {
  222. LLPumpIO::chain_t chain;
  223. chain.push_back(mResponse);
  224. pump->addChain(chain, DEFAULT_CHAIN_EXPIRY_SECS);
  225. }
  226. else
  227. {
  228. pump->respond(mResponse.get());
  229. }
  230. mState = STATE_DONE;
  231. break;
  232. }
  233. case STATE_DONE:
  234. default:
  235. PUMP_DEBUG;
  236. llinfos << "invalid state to process" << llendl;
  237. rv = STATUS_ERROR;
  238. break;
  239. }
  240. return rv;
  241. }