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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llxmlrpctransaction.cpp
  3.  * @brief LLXMLRPCTransaction and related class implementations 
  4.  *
  5.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2006-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #include "llviewerprecompiledheaders.h"
  33. #include "llxmlrpctransaction.h"
  34. #include "llxmlrpclistener.h"
  35. #include "llcurl.h"
  36. #include "llviewercontrol.h"
  37. // Have to include these last to avoid queue redefinition!
  38. #include <xmlrpc-epi/xmlrpc.h>
  39. #include "llappviewer.h"
  40. // Static instance of LLXMLRPCListener declared here so that every time we
  41. // bring in this code, we instantiate a listener. If we put the static
  42. // instance of LLXMLRPCListener into llxmlrpclistener.cpp, the linker would
  43. // simply omit llxmlrpclistener.o, and shouting on the LLEventPump would do
  44. // nothing.
  45. static LLXMLRPCListener listener("LLXMLRPCTransaction");
  46. LLXMLRPCValue LLXMLRPCValue::operator[](const char* id) const
  47. {
  48. return LLXMLRPCValue(XMLRPC_VectorGetValueWithID(mV, id));
  49. }
  50. std::string LLXMLRPCValue::asString() const
  51. {
  52. const char* s = XMLRPC_GetValueString(mV);
  53. return s ? s : "";
  54. }
  55. int LLXMLRPCValue::asInt() const { return XMLRPC_GetValueInt(mV); }
  56. bool LLXMLRPCValue::asBool() const { return XMLRPC_GetValueBoolean(mV) != 0; }
  57. double LLXMLRPCValue::asDouble() const { return XMLRPC_GetValueDouble(mV); }
  58. LLXMLRPCValue LLXMLRPCValue::rewind()
  59. {
  60. return LLXMLRPCValue(XMLRPC_VectorRewind(mV));
  61. }
  62. LLXMLRPCValue LLXMLRPCValue::next()
  63. {
  64. return LLXMLRPCValue(XMLRPC_VectorNext(mV));
  65. }
  66. bool LLXMLRPCValue::isValid() const
  67. {
  68. return mV != NULL;
  69. }
  70. LLXMLRPCValue LLXMLRPCValue::createArray()
  71. {
  72. return LLXMLRPCValue(XMLRPC_CreateVector(NULL, xmlrpc_vector_array));
  73. }
  74. LLXMLRPCValue LLXMLRPCValue::createStruct()
  75. {
  76. return LLXMLRPCValue(XMLRPC_CreateVector(NULL, xmlrpc_vector_struct));
  77. }
  78. void LLXMLRPCValue::append(LLXMLRPCValue& v)
  79. {
  80. XMLRPC_AddValueToVector(mV, v.mV);
  81. }
  82. void LLXMLRPCValue::appendString(const std::string& v)
  83. {
  84. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueString(NULL, v.c_str(), 0));
  85. }
  86. void LLXMLRPCValue::appendInt(int v)
  87. {
  88. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueInt(NULL, v));
  89. }
  90. void LLXMLRPCValue::appendBool(bool v)
  91. {
  92. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueBoolean(NULL, v));
  93. }
  94. void LLXMLRPCValue::appendDouble(double v)
  95. {
  96. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueDouble(NULL, v));
  97. }
  98. void LLXMLRPCValue::append(const char* id, LLXMLRPCValue& v)
  99. {
  100. XMLRPC_SetValueID(v.mV, id, 0);
  101. XMLRPC_AddValueToVector(mV, v.mV);
  102. }
  103. void LLXMLRPCValue::appendString(const char* id, const std::string& v)
  104. {
  105. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueString(id, v.c_str(), 0));
  106. }
  107. void LLXMLRPCValue::appendInt(const char* id, int v)
  108. {
  109. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueInt(id, v));
  110. }
  111. void LLXMLRPCValue::appendBool(const char* id, bool v)
  112. {
  113. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueBoolean(id, v));
  114. }
  115. void LLXMLRPCValue::appendDouble(const char* id, double v)
  116. {
  117. XMLRPC_AddValueToVector(mV, XMLRPC_CreateValueDouble(id, v));
  118. }
  119. void LLXMLRPCValue::cleanup()
  120. {
  121. XMLRPC_CleanupValue(mV);
  122. mV = NULL;
  123. }
  124. XMLRPC_VALUE LLXMLRPCValue::getValue() const
  125. {
  126. return mV;
  127. }
  128. class LLXMLRPCTransaction::Impl
  129. {
  130. public:
  131. typedef LLXMLRPCTransaction::EStatus EStatus;
  132. LLCurlEasyRequest* mCurlRequest;
  133. EStatus mStatus;
  134. CURLcode mCurlCode;
  135. std::string mStatusMessage;
  136. std::string mStatusURI;
  137. LLCurl::TransferInfo mTransferInfo;
  138. std::string mURI;
  139. char* mRequestText;
  140. int mRequestTextSize;
  141. std::string mProxyAddress;
  142. std::string mResponseText;
  143. XMLRPC_REQUEST mResponse;
  144. Impl(const std::string& uri, XMLRPC_REQUEST request, bool useGzip);
  145. Impl(const std::string& uri,
  146.  const std::string& method, LLXMLRPCValue params, bool useGzip);
  147. ~Impl();
  148. bool process();
  149. void setStatus(EStatus code,
  150.    const std::string& message = "", const std::string& uri = "");
  151. void setCurlStatus(CURLcode);
  152. private:
  153. void init(XMLRPC_REQUEST request, bool useGzip);
  154. static size_t curlDownloadCallback(
  155. char* data, size_t size, size_t nmemb, void* user_data);
  156. };
  157. LLXMLRPCTransaction::Impl::Impl(const std::string& uri,
  158. XMLRPC_REQUEST request, bool useGzip)
  159. : mCurlRequest(0),
  160.   mStatus(LLXMLRPCTransaction::StatusNotStarted),
  161.   mURI(uri),
  162.   mRequestText(0), 
  163.   mResponse(0)
  164. {
  165. init(request, useGzip);
  166. }
  167. LLXMLRPCTransaction::Impl::Impl(const std::string& uri,
  168. const std::string& method, LLXMLRPCValue params, bool useGzip)
  169. : mCurlRequest(0),
  170.   mStatus(LLXMLRPCTransaction::StatusNotStarted),
  171.   mURI(uri),
  172.   mRequestText(0), 
  173.   mResponse(0)
  174. {
  175. XMLRPC_REQUEST request = XMLRPC_RequestNew();
  176. XMLRPC_RequestSetMethodName(request, method.c_str());
  177. XMLRPC_RequestSetRequestType(request, xmlrpc_request_call);
  178. XMLRPC_RequestSetData(request, params.getValue());
  179. init(request, useGzip);
  180.     // DEV-28398: without this XMLRPC_RequestFree() call, it looks as though
  181.     // the 'request' object is simply leaked. It's less clear to me whether we
  182.     // should also ask to free request value data (second param 1), since the
  183.     // data come from 'params'.
  184.     XMLRPC_RequestFree(request, 1);
  185. }
  186. void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip)
  187. {
  188. if (!mCurlRequest)
  189. {
  190. mCurlRequest = new LLCurlEasyRequest();
  191. }
  192. if (gSavedSettings.getBOOL("BrowserProxyEnabled"))
  193. {
  194. mProxyAddress = gSavedSettings.getString("BrowserProxyAddress");
  195. S32 port = gSavedSettings.getS32 ( "BrowserProxyPort" );
  196. // tell curl about the settings
  197. mCurlRequest->setoptString(CURLOPT_PROXY, mProxyAddress);
  198. mCurlRequest->setopt(CURLOPT_PROXYPORT, port);
  199. mCurlRequest->setopt(CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
  200. }
  201. // mCurlRequest->setopt(CURLOPT_VERBOSE, 1); // usefull for debugging
  202. mCurlRequest->setopt(CURLOPT_NOSIGNAL, 1);
  203. mCurlRequest->setWriteCallback(&curlDownloadCallback, (void*)this);
  204. mCurlRequest->setopt(CURLOPT_SSL_VERIFYPEER, LLCurl::getSSLVerify());
  205. mCurlRequest->setopt(CURLOPT_SSL_VERIFYHOST, LLCurl::getSSLVerify() ? 2 : 0);
  206. // Be a little impatient about establishing connections.
  207. mCurlRequest->setopt(CURLOPT_CONNECTTIMEOUT, 40L);
  208. /* Setting the DNS cache timeout to -1 disables it completely.
  209.    This might help with bug #503 */
  210. mCurlRequest->setopt(CURLOPT_DNS_CACHE_TIMEOUT, -1);
  211.     mCurlRequest->slist_append("Content-Type: text/xml");
  212. if (useGzip)
  213. {
  214. mCurlRequest->setoptString(CURLOPT_ENCODING, "");
  215. }
  216. mRequestText = XMLRPC_REQUEST_ToXML(request, &mRequestTextSize);
  217. if (mRequestText)
  218. {
  219. mCurlRequest->setoptString(CURLOPT_POSTFIELDS, mRequestText);
  220. mCurlRequest->setopt(CURLOPT_POSTFIELDSIZE, mRequestTextSize);
  221. }
  222. else
  223. {
  224. setStatus(StatusOtherError);
  225. }
  226. mCurlRequest->sendRequest(mURI);
  227. }
  228. LLXMLRPCTransaction::Impl::~Impl()
  229. {
  230. if (mResponse)
  231. {
  232. XMLRPC_RequestFree(mResponse, 1);
  233. }
  234. if (mRequestText)
  235. {
  236. XMLRPC_Free(mRequestText);
  237. }
  238. delete mCurlRequest;
  239. }
  240. bool LLXMLRPCTransaction::Impl::process()
  241. {
  242. switch(mStatus)
  243. {
  244. case LLXMLRPCTransaction::StatusComplete:
  245. case LLXMLRPCTransaction::StatusCURLError:
  246. case LLXMLRPCTransaction::StatusXMLRPCError:
  247. case LLXMLRPCTransaction::StatusOtherError:
  248. {
  249. return true;
  250. }
  251. case LLXMLRPCTransaction::StatusNotStarted:
  252. {
  253. setStatus(LLXMLRPCTransaction::StatusStarted);
  254. break;
  255. }
  256. default:
  257. {
  258. // continue onward
  259. }
  260. }
  261. const F32 MAX_PROCESSING_TIME = 0.05f;
  262. LLTimer timer;
  263. while (mCurlRequest->perform() > 0)
  264. {
  265. if (timer.getElapsedTimeF32() >= MAX_PROCESSING_TIME)
  266. {
  267. return false;
  268. }
  269. }
  270. while(1)
  271. {
  272. CURLcode result;
  273. bool newmsg = mCurlRequest->getResult(&result, &mTransferInfo);
  274. if (newmsg)
  275. {
  276. if (result != CURLE_OK)
  277. {
  278. setCurlStatus(result);
  279. llwarns << "LLXMLRPCTransaction CURL error "
  280. << mCurlCode << ": " << mCurlRequest->getErrorString() << llendl;
  281. llwarns << "LLXMLRPCTransaction request URI: "
  282. << mURI << llendl;
  283. return true;
  284. }
  285. setStatus(LLXMLRPCTransaction::StatusComplete);
  286. mResponse = XMLRPC_REQUEST_FromXML(
  287. mResponseText.data(), mResponseText.size(), NULL);
  288. bool hasError = false;
  289. bool hasFault = false;
  290. int faultCode = 0;
  291. std::string faultString;
  292. LLXMLRPCValue error(XMLRPC_RequestGetError(mResponse));
  293. if (error.isValid())
  294. {
  295. hasError = true;
  296. faultCode = error["faultCode"].asInt();
  297. faultString = error["faultString"].asString();
  298. }
  299. else if (XMLRPC_ResponseIsFault(mResponse))
  300. {
  301. hasFault = true;
  302. faultCode = XMLRPC_GetResponseFaultCode(mResponse);
  303. faultString = XMLRPC_GetResponseFaultString(mResponse);
  304. }
  305. if (hasError || hasFault)
  306. {
  307. setStatus(LLXMLRPCTransaction::StatusXMLRPCError);
  308. llwarns << "LLXMLRPCTransaction XMLRPC "
  309. << (hasError ? "error " : "fault ")
  310. << faultCode << ": "
  311. << faultString << llendl;
  312. llwarns << "LLXMLRPCTransaction request URI: "
  313. << mURI << llendl;
  314. }
  315. return true;
  316. }
  317. else
  318. {
  319. break; // done
  320. }
  321. }
  322. return false;
  323. }
  324. void LLXMLRPCTransaction::Impl::setStatus(EStatus status,
  325. const std::string& message, const std::string& uri)
  326. {
  327. mStatus = status;
  328. mStatusMessage = message;
  329. mStatusURI = uri;
  330. if (mStatusMessage.empty())
  331. {
  332. switch (mStatus)
  333. {
  334. case StatusNotStarted:
  335. mStatusMessage = "(not started)";
  336. break;
  337. case StatusStarted:
  338. mStatusMessage = "(waiting for server response)";
  339. break;
  340. case StatusDownloading:
  341. mStatusMessage = "(reading server response)";
  342. break;
  343. case StatusComplete:
  344. mStatusMessage = "(done)";
  345. break;
  346. default:
  347. // Usually this means that there's a problem with the login server,
  348. // not with the client.  Direct user to status page.
  349. mStatusMessage =
  350. "Despite our best efforts, something unexpected has gone wrong. n"
  351. " n"
  352. "Please check secondlife.com/status n"
  353. "to see if there is a known problem with the service.";
  354. mStatusURI = "http://secondlife.com/status/";
  355. }
  356. }
  357. }
  358. void LLXMLRPCTransaction::Impl::setCurlStatus(CURLcode code)
  359. {
  360. std::string message;
  361. std::string uri = "http://secondlife.com/community/support.php";
  362. switch (code)
  363. {
  364. case CURLE_COULDNT_RESOLVE_HOST:
  365. message =
  366. "DNS could not resolve the host name.n"
  367. "Please verify that you can connect to the www.secondlife.comn"
  368. "web site.  If you can, but continue to receive this error,n"
  369. "please go to the support section and report this problem.";
  370. break;
  371. case CURLE_SSL_PEER_CERTIFICATE:
  372. message =
  373. "The login server couldn't verify itself via SSL.n"
  374. "If you continue to receive this error, please gon"
  375. "to the Support section of the SecondLife.com web siten"
  376. "and report the problem.";
  377. break;
  378. case CURLE_SSL_CACERT:
  379. case CURLE_SSL_CONNECT_ERROR:
  380. message =
  381. "Often this means that your computer's clock is set incorrectly.n"
  382. "Please go to Control Panels and make sure the time and daten"
  383. "are set correctly.n"
  384. "n"
  385. "If you continue to receive this error, please gon"
  386. "to the Support section of the SecondLife.com web siten"
  387. "and report the problem.";
  388. break;
  389. default:
  390. break;
  391. }
  392. mCurlCode = code;
  393. setStatus(StatusCURLError, message, uri);
  394. }
  395. size_t LLXMLRPCTransaction::Impl::curlDownloadCallback(
  396. char* data, size_t size, size_t nmemb, void* user_data)
  397. {
  398. Impl& impl(*(Impl*)user_data);
  399. size_t n = size * nmemb;
  400. impl.mResponseText.append(data, n);
  401. if (impl.mStatus == LLXMLRPCTransaction::StatusStarted)
  402. {
  403. impl.setStatus(LLXMLRPCTransaction::StatusDownloading);
  404. }
  405. return n;
  406. }
  407. LLXMLRPCTransaction::LLXMLRPCTransaction(
  408. const std::string& uri, XMLRPC_REQUEST request, bool useGzip)
  409. : impl(* new Impl(uri, request, useGzip))
  410. { }
  411. LLXMLRPCTransaction::LLXMLRPCTransaction(
  412. const std::string& uri,
  413. const std::string& method, LLXMLRPCValue params, bool useGzip)
  414. : impl(* new Impl(uri, method, params, useGzip))
  415. { }
  416. LLXMLRPCTransaction::~LLXMLRPCTransaction()
  417. {
  418. delete &impl;
  419. }
  420. bool LLXMLRPCTransaction::process()
  421. {
  422. return impl.process();
  423. }
  424. LLXMLRPCTransaction::EStatus LLXMLRPCTransaction::status(int* curlCode)
  425. {
  426. if (curlCode)
  427. {
  428. *curlCode = 
  429. (impl.mStatus == StatusCURLError)
  430. ? impl.mCurlCode
  431. : CURLE_OK;
  432. }
  433. return impl.mStatus;
  434. }
  435. std::string LLXMLRPCTransaction::statusMessage()
  436. {
  437. return impl.mStatusMessage;
  438. }
  439. std::string LLXMLRPCTransaction::statusURI()
  440. {
  441. return impl.mStatusURI;
  442. }
  443. XMLRPC_REQUEST LLXMLRPCTransaction::response()
  444. {
  445. return impl.mResponse;
  446. }
  447. LLXMLRPCValue LLXMLRPCTransaction::responseValue()
  448. {
  449. return LLXMLRPCValue(XMLRPC_RequestGetData(impl.mResponse));
  450. }
  451. F64 LLXMLRPCTransaction::transferRate()
  452. {
  453. if (impl.mStatus != StatusComplete)
  454. {
  455. return 0.0L;
  456. }
  457. double rate_bits_per_sec = impl.mTransferInfo.mSpeedDownload * 8.0;
  458. LL_INFOS("AppInit") << "Buffer size:   " << impl.mResponseText.size() << " B" << LL_ENDL;
  459. LL_DEBUGS("AppInit") << "Transfer size: " << impl.mTransferInfo.mSizeDownload << " B" << LL_ENDL;
  460. LL_DEBUGS("AppInit") << "Transfer time: " << impl.mTransferInfo.mTotalTime << " s" << LL_ENDL;
  461. LL_INFOS("AppInit") << "Transfer rate: " << rate_bits_per_sec / 1000.0 << " Kb/s" << LL_ENDL;
  462. return rate_bits_per_sec;
  463. }