开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llfiltersd2xmlrpc.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：19k
源码类别：

游戏引擎

开发平台：

C++ Builder

llfiltersd2xmlrpc.cpp：源码内容
  1. /** 
  2.  * @file llfiltersd2xmlrpc.cpp
  3.  * @author Phoenix
  4.  * @date 2005-04-26
  5.  *
  6.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2005-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. /** 
  35.  * xml rpc request: 
  36.  * <code>
  37.  * <?xml version="1.0"?>
  38.  * <methodCall><methodName>examples.getStateName</methodName>
  39.  * <params><param><value><i4>41</i4></value></param></params>
  40.  * </methodCall>
  41.  * </code>
  42.  *
  43.  * xml rpc response:
  44.  * <code>
  45.  * <?xml version="1.0"?>
  46.  * <methodResponse>
  47.  * <params><param><value><string>South Dakota</string></value></param></params>
  48.  * </methodResponse>
  49.  * </code>
  50.  *
  51.  * xml rpc fault:
  52.  * </code>
  53.  * <?xml version="1.0"?>
  54.  * <methodResponse>
  55.  * <fault><value><struct>
  56.  * <member><name>faultCode</name><value><int>4</int></value></member>
  57.  * <member><name>faultString</name><value><string>...</string></value></member>
  58.  * </struct></value></fault>
  59.  * </methodResponse>
  60.  * </code>
  61.  *
  62.  * llsd rpc request:
  63.  * <code>
  64.  * { 'method':'...', 'parameter':...]}
  65.  * </code>
  66.  * 
  67.  * llsd rpc response:
  68.  * <code>
  69.  * { 'response':... }
  70.  * </code>
  71.  * 
  72.  * llsd rpc fault: 
  73.  * <code>
  74.  * { 'fault': {'code':i..., 'description':'...'} }
  75.  * </code>
  76.  * 
  77.  */
  79. #include "linden_common.h"
  80. #include "llfiltersd2xmlrpc.h"
  82. #include <sstream>
  83. #include <iterator>
  84. #include <xmlrpc-epi/xmlrpc.h>
  85. #include "apr_base64.h"
  87. #include "llbuffer.h"
  88. #include "llbufferstream.h"
  89. #include "llmemorystream.h"
  90. #include "llsd.h"
  91. #include "llsdserialize.h"
  92. #include "lluuid.h"
  94. // spammy mode
  95. //#define LL_SPEW_STREAM_OUT_DEBUGGING 1
  97. /**
  98.  * String constants
  99.  */
  100. static const char XML_HEADER[] = "<?xml version="1.0" encoding="UTF-8"?>";
  101. static const char XMLRPC_REQUEST_HEADER_1[] = "<methodCall><methodName>";
  102. static const char XMLRPC_REQUEST_HEADER_2[] = "</methodName><params>";
  103. static const char XMLRPC_REQUEST_FOOTER[] = "</params></methodCall>";
  104. static const char XMLRPC_METHOD_RESPONSE_HEADER[] = "<methodResponse>";
  105. static const char XMLRPC_METHOD_RESPONSE_FOOTER[] = "</methodResponse>";
  106. static const char XMLRPC_RESPONSE_HEADER[] = "<params><param>";
  107. static const char XMLRPC_RESPONSE_FOOTER[] = "</param></params>";
  108. static const char XMLRPC_FAULT_1[] = "<fault><value><struct><member><name>faultCode</name><value><int>";
  109. static const char XMLRPC_FAULT_2[] = "</int></value></member><member><name>faultString</name><value><string>";
  110. static const char XMLRPC_FAULT_3[] = "</string></value></member></struct></value></fault>";
  111. static const char LLSDRPC_RESPONSE_HEADER[] = "{'response':";
  112. static const char LLSDRPC_RESPONSE_FOOTER[] = "}";
  113. const char LLSDRPC_REQUEST_HEADER_1[] = "{'method':'";
  114. const char LLSDRPC_REQUEST_HEADER_2[] = "', 'parameter': ";
  115. const char LLSDRPC_REQUEST_FOOTER[] = "}";
  116. static const char LLSDRPC_FAULT_HADER_1[] = "{ 'fault': {'code':i";
  117. static const char LLSDRPC_FAULT_HADER_2[] = ", 'description':";
  118. static const char LLSDRPC_FAULT_FOOTER[] = "} }";
  119. static const S32 DEFAULT_PRECISION = 20;
  121. /**
  122.  * LLFilterSD2XMLRPC
  123.  */
  124. LLFilterSD2XMLRPC::LLFilterSD2XMLRPC()
  125. {
  126. }
  128. LLFilterSD2XMLRPC::~LLFilterSD2XMLRPC()
  129. {
  130. }
  132. std::string xml_escape_string(const std::string& in)
  133. {
  134. std::ostringstream out;
  135. std::string::const_iterator it = in.begin();
  136. std::string::const_iterator end = in.end();
  137. for(; it != end; ++it)
  138. {
  139. switch((*it))
  140. {
  141. case '<':
  142. out << "&lt;";
  143. break;
  144. case '>':
  145. out << "&gt;";
  146. break;
  147. case '&':
  148. out << "&amp;";
  149. break;
  150. case ''':
  151. out << "&apos;";
  152. break;
  153. case '"':
  154. out << "&quot;";
  155. break;
  156. default:
  157. out << (*it);
  158. break;
  159. }
  160. }
  161. return out.str();
  162. }
  164. void LLFilterSD2XMLRPC::streamOut(std::ostream& ostr, const LLSD& sd)
  165. {
  166. ostr << "<value>";
  167. switch(sd.type())
  168. {
  169. case LLSD::TypeMap:
  170. {
  171. #if LL_SPEW_STREAM_OUT_DEBUGGING
  172. llinfos << "streamOut(map) BEGIN" << llendl;
  173. #endif
  174. ostr << "<struct>";
  175. if(ostr.fail())
  176. {
  177. llinfos << "STREAM FAILURE writing struct" << llendl;
  178. }
  179. LLSD::map_const_iterator it = sd.beginMap();
  180. LLSD::map_const_iterator end = sd.endMap();
  181. for(; it != end; ++it)
  182. {
  183. ostr << "<member><name>" << xml_escape_string((*it).first)
  184. << "</name>";
  185. streamOut(ostr, (*it).second);
  186. if(ostr.fail())
  187. {
  188. llinfos << "STREAM FAILURE writing '" << (*it).first
  189. << "' with sd type " << (*it).second.type() << llendl;
  190. }
  191. ostr << "</member>";
  192. }
  193. ostr << "</struct>";
  194. #if LL_SPEW_STREAM_OUT_DEBUGGING
  195. llinfos << "streamOut(map) END" << llendl;
  196. #endif
  197. break;
  198. }
  199. case LLSD::TypeArray:
  200. {
  201. #if LL_SPEW_STREAM_OUT_DEBUGGING
  202. llinfos << "streamOut(array) BEGIN" << llendl;
  203. #endif
  204. ostr << "<array><data>";
  205. LLSD::array_const_iterator it = sd.beginArray();
  206. LLSD::array_const_iterator end = sd.endArray();
  207. for(; it != end; ++it)
  208. {
  209. streamOut(ostr, *it);
  210. if(ostr.fail())
  211. {
  212. llinfos << "STREAM FAILURE writing array element sd type "
  213. << (*it).type() << llendl;
  214. }
  215. }
  216. #if LL_SPEW_STREAM_OUT_DEBUGGING
  217. llinfos << "streamOut(array) END" << llendl;
  218. #endif
  219. ostr << "</data></array>";
  220. break;
  221. }
  222. case LLSD::TypeUndefined:
  223. // treat undefined as a bool with a false value.
  224. case LLSD::TypeBoolean:
  225. #if LL_SPEW_STREAM_OUT_DEBUGGING
  226. llinfos << "streamOut(bool)" << llendl;
  227. #endif
  228. ostr << "<boolean>" << (sd.asBoolean() ? "1" : "0") << "</boolean>";
  229. break;
  230. case LLSD::TypeInteger:
  231. #if LL_SPEW_STREAM_OUT_DEBUGGING
  232. llinfos << "streamOut(int)" << llendl;
  233. #endif
  234. ostr << "<i4>" << sd.asInteger() << "</i4>";
  235. break;
  236. case LLSD::TypeReal:
  237. #if LL_SPEW_STREAM_OUT_DEBUGGING
  238. llinfos << "streamOut(real)" << llendl;
  239. #endif
  240. ostr << "<double>" << sd.asReal() << "</double>";
  241. break;
  242. case LLSD::TypeString:
  243. #if LL_SPEW_STREAM_OUT_DEBUGGING
  244. llinfos << "streamOut(string)" << llendl;
  245. #endif
  246. ostr << "<string>" << xml_escape_string(sd.asString()) << "</string>";
  247. break;
  248. case LLSD::TypeUUID:
  249. #if LL_SPEW_STREAM_OUT_DEBUGGING
  250. llinfos << "streamOut(uuid)" << llendl;
  251. #endif
  252. // serialize it as a string
  253. ostr << "<string>" << sd.asString() << "</string>";
  254. break;
  255. case LLSD::TypeURI:
  256. {
  257. #if LL_SPEW_STREAM_OUT_DEBUGGING
  258. llinfos << "streamOut(uri)" << llendl;
  259. #endif
  260. // serialize it as a string
  261. ostr << "<string>" << xml_escape_string(sd.asString()) << "</string>";
  262. break;
  263. }
  264. case LLSD::TypeBinary:
  265. {
  266. #if LL_SPEW_STREAM_OUT_DEBUGGING
  267. llinfos << "streamOut(binary)" << llendl;
  268. #endif
  269. // this is pretty inefficient, but we'll deal with that
  270. // problem when it becomes one.
  271. ostr << "<base64>";
  272. LLSD::Binary buffer = sd.asBinary();
  273. if(!buffer.empty())
  274. {
  275. // *TODO: convert to LLBase64
  276. int b64_buffer_length = apr_base64_encode_len(buffer.size());
  277. char* b64_buffer = new char[b64_buffer_length];
  278. b64_buffer_length = apr_base64_encode_binary(
  279. b64_buffer,
  280. &buffer[0],
  281. buffer.size());
  282. ostr.write(b64_buffer, b64_buffer_length - 1);
  283. delete[] b64_buffer;
  284. }
  285. ostr << "</base64>";
  286. break;
  287. }
  288. case LLSD::TypeDate:
  289. #if LL_SPEW_STREAM_OUT_DEBUGGING
  290. llinfos << "streamOut(date)" << llendl;
  291. #endif
  292. // no need to escape this since it will be alpha-numeric.
  293. ostr << "<dateTime.iso8601>" << sd.asString() << "</dateTime.iso8601>";
  294. break;
  295. default:
  296. // unhandled type
  297. llwarns << "Unhandled structured data type: " << sd.type()
  298. << llendl;
  299. break;
  300. }
  301. ostr << "</value>";
  302. }
  304. /**
  305.  * LLFilterSD2XMLRPCResponse
  306.  */
  308. LLFilterSD2XMLRPCResponse::LLFilterSD2XMLRPCResponse()
  309. {
  310. }
  312. LLFilterSD2XMLRPCResponse::~LLFilterSD2XMLRPCResponse()
  313. {
  314. }
  317. // virtual
  318. LLIOPipe::EStatus LLFilterSD2XMLRPCResponse::process_impl(
  319. const LLChannelDescriptors& channels,
  320. buffer_ptr_t& buffer,
  321. bool& eos,
  322. LLSD& context,
  323. LLPumpIO* pump)
  324. {
  325. PUMP_DEBUG;
  326. // This pipe does not work if it does not have everyting. This
  327. // could be addressed by making a stream parser for llsd which
  328. // handled partial information.
  329. if(!eos)
  330. {
  331. return STATUS_BREAK;
  332. }
  334. PUMP_DEBUG;
  335. // we have everyting in the buffer, so turn the structure data rpc
  336. // response into an xml rpc response.
  337. LLBufferStream stream(channels, buffer.get());
  338. stream << XML_HEADER << XMLRPC_METHOD_RESPONSE_HEADER;
  339. LLSD sd;
  340. LLSDSerialize::fromNotation(sd, stream, buffer->count(channels.in()));
  342. PUMP_DEBUG;
  343. LLIOPipe::EStatus rv = STATUS_ERROR;
  344. if(sd.has("response"))
  345. {
  346. PUMP_DEBUG;
  347. // it is a normal response. pack it up and ship it out.
  348. stream.precision(DEFAULT_PRECISION);
  349. stream << XMLRPC_RESPONSE_HEADER;
  350. streamOut(stream, sd["response"]);
  351. stream << XMLRPC_RESPONSE_FOOTER << XMLRPC_METHOD_RESPONSE_FOOTER;
  352. rv = STATUS_DONE;
  353. }
  354. else if(sd.has("fault"))
  355. {
  356. PUMP_DEBUG;
  357. // it is a fault.
  358. stream << XMLRPC_FAULT_1 << sd["fault"]["code"].asInteger()
  359. << XMLRPC_FAULT_2
  360. << xml_escape_string(sd["fault"]["description"].asString())
  361. << XMLRPC_FAULT_3 << XMLRPC_METHOD_RESPONSE_FOOTER;
  362. rv = STATUS_DONE;
  363. }
  364. else
  365. {
  366. llwarns << "Unable to determine the type of LLSD response." << llendl;
  367. }
  368. PUMP_DEBUG;
  369. return rv;
  370. }
  372. /**
  373.  * LLFilterSD2XMLRPCRequest
  374.  */
  375. LLFilterSD2XMLRPCRequest::LLFilterSD2XMLRPCRequest()
  376. {
  377. }
  379. LLFilterSD2XMLRPCRequest::LLFilterSD2XMLRPCRequest(const char* method)
  380. {
  381. if(method)
  382. {
  383. mMethod.assign(method);
  384. }
  385. }
  387. LLFilterSD2XMLRPCRequest::~LLFilterSD2XMLRPCRequest()
  388. {
  389. }
  391. // virtual
  392. LLIOPipe::EStatus LLFilterSD2XMLRPCRequest::process_impl(
  393. const LLChannelDescriptors& channels,
  394. buffer_ptr_t& buffer,
  395. bool& eos,
  396. LLSD& context,
  397. LLPumpIO* pump)
  398. {
  399. // This pipe does not work if it does not have everyting. This
  400. // could be addressed by making a stream parser for llsd which
  401. // handled partial information.
  402. PUMP_DEBUG;
  403. if(!eos)
  404. {
  405. llinfos << "!eos" << llendl;
  406. return STATUS_BREAK;
  407. }
  409. // See if we can parse it
  410. LLBufferStream stream(channels, buffer.get());
  411. LLSD sd;
  412. LLSDSerialize::fromNotation(sd, stream, buffer->count(channels.in()));
  413. if(stream.fail())
  414. {
  415. llinfos << "STREAM FAILURE reading structure data." << llendl;
  416. }
  418. PUMP_DEBUG;
  419. // We can get the method and parameters from either the member
  420. // function or passed in via the buffer. We prefer the buffer if
  421. // we found a parameter and a method, or fall back to using
  422. // mMethod and putting everyting in the buffer into the parameter.
  423. std::string method;
  424. LLSD param_sd;
  425. if(sd.has("method") && sd.has("parameter"))
  426. {
  427. method = sd["method"].asString();
  428. param_sd = sd["parameter"];
  429. }
  430. else
  431. {
  432. method = mMethod;
  433. param_sd = sd;
  434. }
  435. if(method.empty())
  436. {
  437. llwarns << "SD -> XML Request no method found." << llendl;
  438. return STATUS_ERROR;
  439. }
  441. PUMP_DEBUG;
  442. // We have a method, and some kind of parameter, so package it up
  443. // and send it out.
  444. LLBufferStream ostream(channels, buffer.get());
  445. ostream.precision(DEFAULT_PRECISION);
  446. if(ostream.fail())
  447. {
  448. llinfos << "STREAM FAILURE setting precision" << llendl;
  449. }
  450. ostream << XML_HEADER << XMLRPC_REQUEST_HEADER_1
  451. << xml_escape_string(method) << XMLRPC_REQUEST_HEADER_2;
  452. if(ostream.fail())
  453. {
  454. llinfos << "STREAM FAILURE writing method headers" << llendl;
  455. }
  456. switch(param_sd.type())
  457. {
  458. case LLSD::TypeMap:
  459. // If the params are a map, then we do not want to iterate
  460. // through them since the iterators returned will be map
  461. // ordered un-named values, which will lose the names, and
  462. // only stream the values, turning it into an array.
  463. ostream << "<param>";
  464. streamOut(ostream, param_sd);
  465. ostream << "</param>";
  466. break;
  467. case LLSD::TypeArray:
  468. {
  470. LLSD::array_iterator it = param_sd.beginArray();
  471. LLSD::array_iterator end = param_sd.endArray();
  472. for(; it != end; ++it)
  473. {
  474. ostream << "<param>";
  475. streamOut(ostream, *it);
  476. ostream << "</param>";
  477. }
  478. break;
  479. }
  480. default:
  481. ostream << "<param>";
  482. streamOut(ostream, param_sd);
  483. ostream << "</param>";
  484. break;
  485. }
  487. stream << XMLRPC_REQUEST_FOOTER;
  488. return STATUS_DONE;
  489. }
  491. /**
  492.  * LLFilterXMLRPCResponse2LLSD
  493.  */
  494. // this is a c function here since it's really an implementation
  495. // detail that requires a header file just get the definition of the
  496. // parameters.
  497. LLIOPipe::EStatus stream_out(std::ostream& ostr, XMLRPC_VALUE value)
  498. {
  499. XMLRPC_VALUE_TYPE_EASY type = XMLRPC_GetValueTypeEasy(value);
  500. LLIOPipe::EStatus status = LLIOPipe::STATUS_OK;
  501. switch(type)
  502. {
  503. case xmlrpc_type_base64:
  504. {
  505. S32 len = XMLRPC_GetValueStringLen(value);
  506. const char* buf = XMLRPC_GetValueBase64(value);
  507. ostr << " b(";
  508. if((len > 0) && buf)
  509. {
  510. ostr << len << ")"";
  511. ostr.write(buf, len);
  512. ostr << """;
  513. }
  514. else
  515. {
  516. ostr << "0)""";
  517. }
  518. break;
  519. }
  520. case xmlrpc_type_boolean:
  521. //lldebugs << "stream_out() bool" << llendl;
  522. ostr << " " << (XMLRPC_GetValueBoolean(value) ? "true" : "false");
  523. break;
  524. case xmlrpc_type_datetime:
  525. ostr << " d"" << XMLRPC_GetValueDateTime_ISO8601(value) << """;
  526. break;
  527. case xmlrpc_type_double:
  528. ostr << " r" << XMLRPC_GetValueDouble(value);
  529. //lldebugs << "stream_out() double" << XMLRPC_GetValueDouble(value)
  530. //  << llendl;
  531. break;
  532. case xmlrpc_type_int:
  533. ostr << " i" << XMLRPC_GetValueInt(value);
  534. //lldebugs << "stream_out() integer:" << XMLRPC_GetValueInt(value)
  535. //  << llendl;
  536. break;
  537. case xmlrpc_type_string:
  538. //lldebugs << "stream_out() string: " << str << llendl;
  539. ostr << " s(" << XMLRPC_GetValueStringLen(value) << ")'"
  540. << XMLRPC_GetValueString(value) << "'";
  541. break;
  542. case xmlrpc_type_array: // vector
  543. case xmlrpc_type_mixed: // vector
  544. {
  545. //lldebugs << "stream_out() array" << llendl;
  546. ostr << " [";
  547. U32 needs_comma = 0;
  548. XMLRPC_VALUE current = XMLRPC_VectorRewind(value);
  549. while(current && (LLIOPipe::STATUS_OK == status))
  550. {
  551. if(needs_comma++) ostr << ",";
  552. status = stream_out(ostr, current);
  553. current = XMLRPC_VectorNext(value);
  554. }
  555. ostr << "]";
  556. break;
  557. }
  558. case xmlrpc_type_struct: // still vector
  559. {
  560. //lldebugs << "stream_out() struct" << llendl;
  561. ostr << " {";
  562. std::string name;
  563. U32 needs_comma = 0;
  564. XMLRPC_VALUE current = XMLRPC_VectorRewind(value);
  565. while(current && (LLIOPipe::STATUS_OK == status))
  566. {
  567. if(needs_comma++) ostr << ",";
  568. name.assign(XMLRPC_GetValueID(current));
  569. ostr << "'" << LLSDNotationFormatter::escapeString(name) << "':";
  570. status = stream_out(ostr, current);
  571. current = XMLRPC_VectorNext(value);
  572. }
  573. ostr << "}";
  574. break;
  575. }
  576. case xmlrpc_type_empty:
  577. case xmlrpc_type_none:
  578. default:
  579. status = LLIOPipe::STATUS_ERROR;
  580. llwarns << "Found an empty xmlrpc type.." << llendl;
  581. // not much we can do here...
  582. break;
  583. };
  584. return status;
  585. }
  587. LLFilterXMLRPCResponse2LLSD::LLFilterXMLRPCResponse2LLSD()
  588. {
  589. }
  591. LLFilterXMLRPCResponse2LLSD::~LLFilterXMLRPCResponse2LLSD()
  592. {
  593. }
  595. LLIOPipe::EStatus LLFilterXMLRPCResponse2LLSD::process_impl(
  596. const LLChannelDescriptors& channels,
  597. buffer_ptr_t& buffer,
  598. bool& eos,
  599. LLSD& context,
  600. LLPumpIO* pump)
  601. {
  602. PUMP_DEBUG;
  603. if(!eos) return STATUS_BREAK;
  604. if(!buffer) return STATUS_ERROR;
  606. PUMP_DEBUG;
  607. // *FIX: This technique for reading data is far from optimal. We
  608. // need to have some kind of istream interface into the xml
  609. // parser...
  610. S32 bytes = buffer->countAfter(channels.in(), NULL);
  611. if(!bytes) return STATUS_ERROR;
  612. char* buf = new char[bytes + 1];
  613. buf[bytes] = '';
  614. buffer->readAfter(channels.in(), NULL, (U8*)buf, bytes);
  616. //lldebugs << "xmlrpc response: " << buf << llendl;
  618. PUMP_DEBUG;
  619. XMLRPC_REQUEST response = XMLRPC_REQUEST_FromXML(
  620. buf,
  621. bytes,
  622. NULL);
  623. if(!response)
  624. {
  625. llwarns << "XML -> SD Response unable to parse xml." << llendl;
  626. delete[] buf;
  627. return STATUS_ERROR;
  628. }
  630. PUMP_DEBUG;
  631. LLBufferStream stream(channels, buffer.get());
  632. stream.precision(DEFAULT_PRECISION);
  633. if(XMLRPC_ResponseIsFault(response))
  634. {
  635. PUMP_DEBUG;
  636. stream << LLSDRPC_FAULT_HADER_1
  637.    << XMLRPC_GetResponseFaultCode(response)
  638.    << LLSDRPC_FAULT_HADER_2;
  639. const char* fault_str = XMLRPC_GetResponseFaultString(response);
  640. std::string fault_string;
  641. if(fault_str)
  642. {
  643. fault_string.assign(fault_str);
  644. }
  645. stream << "'" << LLSDNotationFormatter::escapeString(fault_string)
  646.    << "'" <<LLSDRPC_FAULT_FOOTER;
  647. }
  648. else
  649. {
  650. PUMP_DEBUG;
  651. stream << LLSDRPC_RESPONSE_HEADER;
  652. XMLRPC_VALUE param = XMLRPC_RequestGetData(response);
  653. if(param)
  654. {
  655. stream_out(stream, param);
  656. }
  657. stream << LLSDRPC_RESPONSE_FOOTER;
  658. }
  659. PUMP_DEBUG;
  660. XMLRPC_RequestFree(response, 1);
  661. delete[] buf;
  662. PUMP_DEBUG;
  663. return STATUS_DONE;
  664. }
  666. /**
  667.  * LLFilterXMLRPCRequest2LLSD
  668.  */
  669. LLFilterXMLRPCRequest2LLSD::LLFilterXMLRPCRequest2LLSD()
  670. {
  671. }
  673. LLFilterXMLRPCRequest2LLSD::~LLFilterXMLRPCRequest2LLSD()
  674. {
  675. }
  677. LLIOPipe::EStatus LLFilterXMLRPCRequest2LLSD::process_impl(
  678. const LLChannelDescriptors& channels,
  679. buffer_ptr_t& buffer,
  680. bool& eos,
  681. LLSD& context,
  682. LLPumpIO* pump)
  683. {
  684. PUMP_DEBUG;
  685. if(!eos) return STATUS_BREAK;
  686. if(!buffer) return STATUS_ERROR;
  688. PUMP_DEBUG;
  689. // *FIX: This technique for reading data is far from optimal. We
  690. // need to have some kind of istream interface into the xml
  691. // parser...
  692. S32 bytes = buffer->countAfter(channels.in(), NULL);
  693. if(!bytes) return STATUS_ERROR;
  694. char* buf = new char[bytes + 1];
  695. buf[bytes] = '';
  696. buffer->readAfter(channels.in(), NULL, (U8*)buf, bytes);
  698. //lldebugs << "xmlrpc request: " << buf << llendl;
  700. // Check the value in the buffer. XMLRPC_REQUEST_FromXML will report a error code 4 if 
  701. // values that are less than 0x20 are passed to it, except
  702. // 0x09: Horizontal tab; 0x0a: New Line; 0x0d: Carriage
  703. U8* cur_pBuf = (U8*)buf;
  704.     U8 cur_char;
  705. for (S32 i=0; i<bytes; i++) 
  706. {
  707.         cur_char = *cur_pBuf;
  708. if (   cur_char < 0x20
  709.             && 0x09 != cur_char
  710.             && 0x0a != cur_char
  711.             && 0x0d != cur_char )
  712.         {
  713. *cur_pBuf = '?';
  714.         }
  715. ++cur_pBuf;
  716. }
  718. PUMP_DEBUG;
  719. XMLRPC_REQUEST request = XMLRPC_REQUEST_FromXML(
  720. buf,
  721. bytes,
  722. NULL);
  723. if(!request)
  724. {
  725. llwarns << "XML -> SD Request process parse error." << llendl;
  726. delete[] buf;
  727. return STATUS_ERROR;
  728. }
  730. PUMP_DEBUG;
  731. LLBufferStream stream(channels, buffer.get());
  732. stream.precision(DEFAULT_PRECISION);
  733. const char* name = XMLRPC_RequestGetMethodName(request);
  734. stream << LLSDRPC_REQUEST_HEADER_1 << (name ? name : "")
  735.    << LLSDRPC_REQUEST_HEADER_2;
  736. XMLRPC_VALUE param = XMLRPC_RequestGetData(request);
  737. if(param)
  738. {
  739. PUMP_DEBUG;
  740. S32 size = XMLRPC_VectorSize(param);
  741. if(size > 1)
  742. {
  743. // if there are multiple parameters, stuff the values into
  744. // an array so that the next step in the chain can read them.
  745. stream << "[";
  746. }
  747.   XMLRPC_VALUE current = XMLRPC_VectorRewind(param);
  748. bool needs_comma = false;
  749.   while(current)
  750.   {
  751. if(needs_comma)
  752. {
  753. stream << ",";
  754. }
  755. needs_comma = true;
  756.   stream_out(stream, current);
  757.   current = XMLRPC_VectorNext(param);
  758.   }
  759. if(size > 1)
  760. {
  761. // close the array
  762. stream << "]";
  763. }
  764. }
  765. stream << LLSDRPC_REQUEST_FOOTER;
  766. XMLRPC_RequestFree(request, 1);
  767. delete[] buf;
  768. PUMP_DEBUG;
  769. return STATUS_DONE;
  770. }