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

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

游戏引擎

开发平台：

C++ Builder

llxfermanager.cpp：源码内容
  1. /** 
  2.  * @file llxfermanager.cpp
  3.  * @brief implementation of LLXferManager class for a collection of xfers
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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.  */
  33. #include "linden_common.h"
  35. #include "llxfermanager.h"
  37. #include "llxfer.h"
  38. #include "llxfer_file.h"
  39. #include "llxfer_mem.h"
  40. #include "llxfer_vfile.h"
  42. #include "llerror.h"
  43. #include "lluuid.h"
  44. #include "u64.h"
  46. const F32 LL_XFER_REGISTRATION_TIMEOUT = 60.0f;  // timeout if a registered transfer hasn't been requested in 60 seconds
  47. const F32 LL_PACKET_TIMEOUT = 3.0f;             // packet timeout at 3 s
  48. const S32 LL_PACKET_RETRY_LIMIT = 10;            // packet retransmission limit
  50. const S32 LL_DEFAULT_MAX_SIMULTANEOUS_XFERS = 10;
  51. const S32 LL_DEFAULT_MAX_REQUEST_FIFO_XFERS = 1000;
  53. #define LL_XFER_PROGRESS_MESSAGES 0
  54. #define LL_XFER_TEST_REXMIT       0
  57. ///////////////////////////////////////////////////////////
  59. LLXferManager::LLXferManager (LLVFS *vfs)
  60. {
  61. init(vfs);
  62. }
  64. ///////////////////////////////////////////////////////////
  66. LLXferManager::~LLXferManager ()
  67. {
  68. cleanup();
  69. }
  71. ///////////////////////////////////////////////////////////
  73. void LLXferManager::init (LLVFS *vfs)
  74. {
  75. mSendList = NULL;
  76. mReceiveList = NULL;
  78. setMaxOutgoingXfersPerCircuit(LL_DEFAULT_MAX_SIMULTANEOUS_XFERS);
  79. setMaxIncomingXfers(LL_DEFAULT_MAX_REQUEST_FIFO_XFERS);
  81. mVFS = vfs;
  83. // Turn on or off ack throttling
  84. mUseAckThrottling = FALSE;
  85. setAckThrottleBPS(100000);
  86. }
  88. ///////////////////////////////////////////////////////////
  90. void LLXferManager::cleanup ()
  91. {
  92. LLXfer *xferp;
  93. LLXfer *delp;
  95. for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer());
  96. mOutgoingHosts.clear();
  98. delp = mSendList;
  99. while (delp)
  100. {
  101. xferp = delp->mNext;
  102. delete delp;
  103. delp = xferp;
  104. }
  105. mSendList = NULL;
  107. delp = mReceiveList;
  108. while (delp)
  109. {
  110. xferp = delp->mNext;
  111. delete delp;
  112. delp = xferp;
  113. }
  114. mReceiveList = NULL;
  115. }
  117. ///////////////////////////////////////////////////////////
  119. void LLXferManager::setMaxIncomingXfers(S32 max_num)
  120. {
  121. mMaxIncomingXfers = max_num;
  122. }
  124. ///////////////////////////////////////////////////////////
  126. void LLXferManager::setMaxOutgoingXfersPerCircuit(S32 max_num)
  127. {
  128. mMaxOutgoingXfersPerCircuit = max_num;
  129. }
  131. void LLXferManager::setUseAckThrottling(const BOOL use)
  132. {
  133. mUseAckThrottling = use;
  134. }
  136. void LLXferManager::setAckThrottleBPS(const F32 bps)
  137. {
  138. // Let's figure out the min we can set based on the ack retry rate
  139. // and number of simultaneous.
  141. // Assuming we're running as slow as possible, this is the lowest ack
  142. // rate we can use.
  143. F32 min_bps = (1000.f * 8.f* mMaxIncomingXfers) / LL_PACKET_TIMEOUT;
  145. // Set
  146. F32 actual_rate = llmax(min_bps*1.1f, bps);
  147. LL_DEBUGS("AppInit") << "LLXferManager ack throttle min rate: " << min_bps << LL_ENDL;
  148. LL_DEBUGS("AppInit") << "LLXferManager ack throttle actual rate: " << actual_rate << LL_ENDL;
  149. mAckThrottle.setRate(actual_rate);
  150. }
  153. ///////////////////////////////////////////////////////////
  155. void LLXferManager::updateHostStatus()
  156. {
  157.     LLXfer *xferp;
  158. LLHostStatus *host_statusp = NULL;
  160. for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer());
  161. mOutgoingHosts.clear();
  163. for (xferp = mSendList; xferp; xferp = xferp->mNext)
  164. {
  165. for (status_list_t::iterator iter = mOutgoingHosts.begin();
  166.  iter != mOutgoingHosts.end(); ++iter)
  167. {
  168. host_statusp = *iter;
  169. if (host_statusp->mHost == xferp->mRemoteHost)
  170. {
  171. break;
  172. }
  173. }
  174. if (!host_statusp)
  175. {
  176. host_statusp = new LLHostStatus();
  177. if (host_statusp)
  178. {
  179. host_statusp->mHost = xferp->mRemoteHost;
  180. mOutgoingHosts.push_front(host_statusp);
  181. }
  182. }
  183. if (host_statusp)
  184. {
  185. if (xferp->mStatus == e_LL_XFER_PENDING)
  186. {
  187. host_statusp->mNumPending++;
  188. }
  189. else if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
  190. {
  191. host_statusp->mNumActive++;
  192. }
  193. }
  195. }
  196. }
  198. ///////////////////////////////////////////////////////////
  200. void LLXferManager::printHostStatus()
  201. {
  202. LLHostStatus *host_statusp = NULL;
  203. if (!mOutgoingHosts.empty())
  204. {
  205. llinfos << "Outgoing Xfers:" << llendl;
  207. for (status_list_t::iterator iter = mOutgoingHosts.begin();
  208.  iter != mOutgoingHosts.end(); ++iter)
  209. {
  210. host_statusp = *iter;
  211. llinfos << "    " << host_statusp->mHost << "  active: " << host_statusp->mNumActive << "  pending: " << host_statusp->mNumPending << llendl;
  212. }
  213. }
  214. }
  216. ///////////////////////////////////////////////////////////
  218. LLXfer *LLXferManager::findXfer (U64 id, LLXfer *list_head)
  219. {
  220.     LLXfer *xferp;
  221. for (xferp = list_head; xferp; xferp = xferp->mNext)
  222. {
  223. if (xferp->mID == id)
  224. {
  225. return(xferp);
  226. }
  227. }
  228. return(NULL);
  229. }
  232. ///////////////////////////////////////////////////////////
  234. void LLXferManager::removeXfer (LLXfer *delp, LLXfer **list_head)
  235. {
  236. // This function assumes that delp will only occur in the list
  237. // zero or one times.
  238. if (delp)
  239. {
  240. if (*list_head == delp)
  241. {
  242. *list_head = delp->mNext;
  243. delete (delp);
  244. }
  245. else
  246. {
  247. LLXfer *xferp = *list_head;
  248. while (xferp->mNext)
  249. {
  250. if (xferp->mNext == delp)
  251. {
  252. xferp->mNext = delp->mNext;
  253. delete (delp);
  254. break;
  255. }
  256. xferp = xferp->mNext;
  257. }
  258. }
  259. }
  260. }
  262. ///////////////////////////////////////////////////////////
  264. U32 LLXferManager::numActiveListEntries(LLXfer *list_head)
  265. {
  266. U32 num_entries = 0;
  268. while (list_head)
  269. {
  270. if ((list_head->mStatus == e_LL_XFER_IN_PROGRESS)) 
  271. {
  272. num_entries++;
  273. }
  274. list_head = list_head->mNext;
  275. }
  276. return(num_entries);
  277. }
  279. ///////////////////////////////////////////////////////////
  281. S32 LLXferManager::numPendingXfers(const LLHost &host)
  282. {
  283. LLHostStatus *host_statusp = NULL;
  285. for (status_list_t::iterator iter = mOutgoingHosts.begin();
  286.  iter != mOutgoingHosts.end(); ++iter)
  287. {
  288. host_statusp = *iter;
  289. if (host_statusp->mHost == host)
  290. {
  291. return (host_statusp->mNumPending);
  292. }
  293. }
  294. return 0;
  295. }
  297. ///////////////////////////////////////////////////////////
  299. S32 LLXferManager::numActiveXfers(const LLHost &host)
  300. {
  301. LLHostStatus *host_statusp = NULL;
  303. for (status_list_t::iterator iter = mOutgoingHosts.begin();
  304.  iter != mOutgoingHosts.end(); ++iter)
  305. {
  306. host_statusp = *iter;
  307. if (host_statusp->mHost == host)
  308. {
  309. return (host_statusp->mNumActive);
  310. }
  311. }
  312. return 0;
  313. }
  315. ///////////////////////////////////////////////////////////
  317. void LLXferManager::changeNumActiveXfers(const LLHost &host, S32 delta)
  318. {
  319. LLHostStatus *host_statusp = NULL;
  321. for (status_list_t::iterator iter = mOutgoingHosts.begin();
  322.  iter != mOutgoingHosts.end(); ++iter)
  323. {
  324. host_statusp = *iter;
  325. if (host_statusp->mHost == host)
  326. {
  327. host_statusp->mNumActive += delta;
  328. }
  329. }
  330. }
  332. ///////////////////////////////////////////////////////////
  334. void LLXferManager::registerCallbacks(LLMessageSystem *msgsystem)
  335. {
  336. msgsystem->setHandlerFuncFast(_PREHASH_ConfirmXferPacket,  process_confirm_packet, NULL);
  337. msgsystem->setHandlerFuncFast(_PREHASH_RequestXfer,        process_request_xfer,        NULL);
  338. msgsystem->setHandlerFuncFast(_PREHASH_SendXferPacket,     continue_file_receive,  NULL);
  339. msgsystem->setHandlerFuncFast(_PREHASH_AbortXfer,      process_abort_xfer,      NULL);
  340. }
  342. ///////////////////////////////////////////////////////////
  344. U64 LLXferManager::getNextID ()
  345. {
  346. LLUUID a_guid;
  348. a_guid.generate();
  351. return(*((U64*)(a_guid.mData)));
  352. }
  354. ///////////////////////////////////////////////////////////
  356. S32 LLXferManager::encodePacketNum(S32 packet_num, BOOL is_EOF)
  357. {
  358. if (is_EOF)
  359. {
  360. packet_num |= 0x80000000;
  361. }
  362. return packet_num;
  363. }
  365. ///////////////////////////////////////////////////////////
  367. S32 LLXferManager::decodePacketNum(S32 packet_num)
  368. {
  369. return(packet_num & 0x0FFFFFFF);
  370. }
  372. ///////////////////////////////////////////////////////////
  374. BOOL LLXferManager::isLastPacket(S32 packet_num)
  375. {
  376. return(packet_num & 0x80000000);
  377. }
  379. ///////////////////////////////////////////////////////////
  381. U64 LLXferManager::registerXfer(const void *datap, const S32 length)
  382. {
  383. LLXfer *xferp;
  384. U64 xfer_id = getNextID();
  386. xferp = (LLXfer *) new LLXfer_Mem();
  387. if (xferp)
  388. {
  389. xferp->mNext = mSendList;
  390. mSendList = xferp;
  392. xfer_id = ((LLXfer_Mem *)xferp)->registerXfer(xfer_id, datap,length);
  394. if (!xfer_id)
  395. {
  396. removeXfer(xferp,&mSendList);
  397. }
  398. }
  399. else
  400. {
  401. llerrs << "Xfer allocation error" << llendl;
  402. xfer_id = 0;
  403. }
  405.     return(xfer_id);
  406. }
  408. ///////////////////////////////////////////////////////////
  410. void LLXferManager::requestFile(const std::string& local_filename,
  411. const std::string& remote_filename,
  412. ELLPath remote_path,
  413. const LLHost& remote_host,
  414. BOOL delete_remote_on_completion,
  415. void (*callback)(void**,S32,LLExtStat),
  416. void** user_data,
  417. BOOL is_priority,
  418. BOOL use_big_packets)
  419. {
  420. LLXfer *xferp;
  422. for (xferp = mReceiveList; xferp ; xferp = xferp->mNext)
  423. {
  424. if (xferp->getXferTypeTag() == LLXfer::XFER_FILE
  425. && (((LLXfer_File*)xferp)->matchesLocalFilename(local_filename))
  426. && (((LLXfer_File*)xferp)->matchesRemoteFilename(remote_filename, remote_path))
  427. && (remote_host == xferp->mRemoteHost)
  428. && (callback == xferp->mCallback)
  429. && (user_data == xferp->mCallbackDataHandle))
  431. {
  432. // cout << "requested a xfer already in progress" << endl;
  433. return;
  434. }
  435. }
  437. S32 chunk_size = use_big_packets ? LL_XFER_LARGE_PAYLOAD : -1;
  438. xferp = (LLXfer *) new LLXfer_File(chunk_size);
  439. if (xferp)
  440. {
  441. addToList(xferp, mReceiveList, is_priority);
  443. // Remove any file by the same name that happens to be lying
  444. // around.
  445. // Note: according to AaronB, this is here to deal with locks on files that were
  446. // in transit during a crash,
  447. if(delete_remote_on_completion &&
  448.    (remote_filename.substr(remote_filename.length()-4) == ".tmp"))
  449. {
  450. LLFile::remove(local_filename);
  451. }
  452. ((LLXfer_File *)xferp)->initializeRequest(
  453. getNextID(),
  454. local_filename,
  455. remote_filename,
  456. remote_path,
  457. remote_host,
  458. delete_remote_on_completion,
  459. callback,user_data);
  460. startPendingDownloads();
  461. }
  462. else
  463. {
  464. llerrs << "Xfer allocation error" << llendl;
  465. }
  466. }
  468. void LLXferManager::requestFile(const std::string& remote_filename,
  469. ELLPath remote_path,
  470. const LLHost& remote_host,
  471. BOOL delete_remote_on_completion,
  472. void (*callback)(void*,S32,void**,S32,LLExtStat),
  473. void** user_data,
  474. BOOL is_priority)
  475. {
  476. LLXfer *xferp;
  478. xferp = (LLXfer *) new LLXfer_Mem();
  479. if (xferp)
  480. {
  481. addToList(xferp, mReceiveList, is_priority);
  482. ((LLXfer_Mem *)xferp)->initializeRequest(getNextID(),
  483.  remote_filename, 
  484.  remote_path,
  485.  remote_host,
  486.  delete_remote_on_completion,
  487.  callback, user_data);
  488. startPendingDownloads();
  489. }
  490. else
  491. {
  492. llerrs << "Xfer allocation error" << llendl;
  493. }
  494. }
  496. void LLXferManager::requestVFile(const LLUUID& local_id,
  497.  const LLUUID& remote_id,
  498.  LLAssetType::EType type, LLVFS* vfs,
  499.  const LLHost& remote_host,
  500.  void (*callback)(void**,S32,LLExtStat),
  501.  void** user_data,
  502.  BOOL is_priority)
  503. {
  504. LLXfer *xferp;
  506. for (xferp = mReceiveList; xferp ; xferp = xferp->mNext)
  507. {
  508. if (xferp->getXferTypeTag() == LLXfer::XFER_VFILE
  509. && (((LLXfer_VFile*)xferp)->matchesLocalFile(local_id, type))
  510. && (((LLXfer_VFile*)xferp)->matchesRemoteFile(remote_id, type))
  511. && (remote_host == xferp->mRemoteHost)
  512. && (callback == xferp->mCallback)
  513. && (user_data == xferp->mCallbackDataHandle))
  515. {
  516. // cout << "requested a xfer already in progress" << endl;
  517. return;
  518. }
  519. }
  521. xferp = (LLXfer *) new LLXfer_VFile();
  522. if (xferp)
  523. {
  524. addToList(xferp, mReceiveList, is_priority);
  525. ((LLXfer_VFile *)xferp)->initializeRequest(getNextID(),
  526. vfs,
  527. local_id,
  528. remote_id,
  529. type,
  530. remote_host,
  531. callback,
  532. user_data);
  533. startPendingDownloads();
  534. }
  535. else
  536. {
  537. llerrs << "Xfer allocation error" << llendl;
  538. }
  540. }
  542. /*
  543. void LLXferManager::requestXfer(
  544. const std::string& local_filename, 
  545. BOOL delete_remote_on_completion,
  546. U64 xfer_id, 
  547. const LLHost &remote_host, 
  548. void (*callback)(void **,S32),
  549. void **user_data)
  550. {
  551. LLXfer *xferp;
  553. for (xferp = mReceiveList; xferp ; xferp = xferp->mNext)
  554. {
  555. if (xferp->getXferTypeTag() == LLXfer::XFER_FILE
  556. && (((LLXfer_File*)xferp)->matchesLocalFilename(local_filename))
  557. && (xfer_id == xferp->mID)
  558. && (remote_host == xferp->mRemoteHost)
  559. && (callback == xferp->mCallback)
  560. && (user_data == xferp->mCallbackDataHandle))
  562. {
  563. // cout << "requested a xfer already in progress" << endl;
  564. return;
  565. }
  566. }
  568. xferp = (LLXfer *) new LLXfer_File();
  569. if (xferp)
  570. {
  571. xferp->mNext = mReceiveList;
  572. mReceiveList = xferp;
  574. ((LLXfer_File *)xferp)->initializeRequest(xfer_id,local_filename,"",LL_PATH_NONE,remote_host,delete_remote_on_completion,callback,user_data);
  575. startPendingDownloads();
  576. }
  577. else
  578. {
  579. llerrs << "Xfer allcoation error" << llendl;
  580. }
  581. }
  583. void LLXferManager::requestXfer(U64 xfer_id, const LLHost &remote_host, BOOL delete_remote_on_completion, void (*callback)(void *,S32,void **,S32),void **user_data)
  584. {
  585. LLXfer *xferp;
  587. xferp = (LLXfer *) new LLXfer_Mem();
  588. if (xferp)
  589. {
  590. xferp->mNext = mReceiveList;
  591. mReceiveList = xferp;
  593. ((LLXfer_Mem *)xferp)->initializeRequest(xfer_id,"",LL_PATH_NONE,remote_host,delete_remote_on_completion,callback,user_data);
  594. startPendingDownloads();
  595. }
  596. else
  597. {
  598. llerrs << "Xfer allcoation error" << llendl;
  599. }
  600. }
  601. */
  602. ///////////////////////////////////////////////////////////
  604. void LLXferManager::processReceiveData (LLMessageSystem *mesgsys, void ** /*user_data*/)
  605. {
  606. // there's sometimes an extra 4 bytes added to an xfer payload
  607. const S32 BUF_SIZE = LL_XFER_LARGE_PAYLOAD + 4;
  608. char fdata_buf[LL_XFER_LARGE_PAYLOAD + 4]; /* Flawfinder : ignore */
  609. S32 fdata_size;
  610. U64 id;
  611. S32 packetnum;
  612. LLXfer * xferp;
  614. mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
  615. mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Packet, packetnum);
  617. fdata_size = mesgsys->getSizeFast(_PREHASH_DataPacket,_PREHASH_Data);
  618. mesgsys->getBinaryDataFast(_PREHASH_DataPacket, _PREHASH_Data, fdata_buf, 0, 0, BUF_SIZE);
  620. xferp = findXfer(id, mReceiveList);
  622. if (!xferp) 
  623. {
  624. char U64_BUF[MAX_STRING]; /* Flawfinder : ignore */
  625. llwarns << "received xfer data from " << mesgsys->getSender()
  626. << " for non-existent xfer id: "
  627. << U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << llendl;
  628. return;
  629. }
  631. S32 xfer_size;
  633. if (decodePacketNum(packetnum) != xferp->mPacketNum) // is the packet different from what we were expecting?
  634. {
  635. // confirm it if it was a resend of the last one, since the confirmation might have gotten dropped
  636. if (decodePacketNum(packetnum) == (xferp->mPacketNum - 1))
  637. {
  638. llinfos << "Reconfirming xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet " << packetnum << llendl;  sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
  639. }
  640. else
  641. {
  642. llinfos << "Ignoring xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " recv'd packet " << packetnum << "; expecting " << xferp->mPacketNum << llendl;
  643. }
  644. return;
  645. }
  647. S32 result = 0;
  649. if (xferp->mPacketNum == 0) // first packet has size encoded as additional S32 at beginning of data
  650. {
  651. ntohmemcpy(&xfer_size,fdata_buf,MVT_S32,sizeof(S32));
  653. // do any necessary things on first packet ie. allocate memory
  654. xferp->setXferSize(xfer_size);
  656. // adjust buffer start and size
  657. result = xferp->receiveData(&(fdata_buf[sizeof(S32)]),fdata_size-(sizeof(S32)));
  658. }
  659. else
  660. {
  661. result = xferp->receiveData(fdata_buf,fdata_size);
  662. }
  664. if (result == LL_ERR_CANNOT_OPEN_FILE)
  665. {
  666. xferp->abort(LL_ERR_CANNOT_OPEN_FILE);
  667. removeXfer(xferp,&mReceiveList);
  668. startPendingDownloads();
  669. return;
  670. }
  672. xferp->mPacketNum++;  // expect next packet
  674. if (!mUseAckThrottling)
  675. {
  676. // No throttling, confirm right away
  677. sendConfirmPacket(mesgsys, id, decodePacketNum(packetnum), mesgsys->getSender());
  678. }
  679. else
  680. {
  681. // Throttling, put on queue to be confirmed later.
  682. LLXferAckInfo ack_info;
  683. ack_info.mID = id;
  684. ack_info.mPacketNum = decodePacketNum(packetnum);
  685. ack_info.mRemoteHost = mesgsys->getSender();
  686. mXferAckQueue.push(ack_info);
  687. }
  689. if (isLastPacket(packetnum))
  690. {
  691. xferp->processEOF();
  692. removeXfer(xferp,&mReceiveList);
  693. startPendingDownloads();
  694. }
  695. }
  697. ///////////////////////////////////////////////////////////
  699. void LLXferManager::sendConfirmPacket (LLMessageSystem *mesgsys, U64 id, S32 packetnum, const LLHost &remote_host)
  700. {
  701. #if LL_XFER_PROGRESS_MESSAGES
  702. if (!(packetnum % 50))
  703. {
  704. cout << "confirming xfer packet #" << packetnum << endl;
  705. }
  706. #endif
  707. mesgsys->newMessageFast(_PREHASH_ConfirmXferPacket);
  708. mesgsys->nextBlockFast(_PREHASH_XferID);
  709. mesgsys->addU64Fast(_PREHASH_ID, id);
  710. mesgsys->addU32Fast(_PREHASH_Packet, packetnum);
  712. mesgsys->sendMessage(remote_host);
  713. }
  715. ///////////////////////////////////////////////////////////
  717. static bool find_and_remove(std::multiset<std::string>& files,
  718. const std::string& filename)
  719. {
  720. std::multiset<std::string>::iterator ptr;
  721. if ( (ptr = files.find(filename)) != files.end())
  722. {
  723. //erase(filename) erases *all* entries with that key
  724. files.erase(ptr);
  725. return true;
  726. }
  727. return false;
  728. }
  730. void LLXferManager::expectFileForRequest(const std::string& filename)
  731. {
  732. mExpectedRequests.insert(filename);
  733. }
  735. bool LLXferManager::validateFileForRequest(const std::string& filename)
  736. {
  737. return find_and_remove(mExpectedRequests, filename);
  738. }
  740. void LLXferManager::expectFileForTransfer(const std::string& filename)
  741. {
  742. mExpectedTransfers.insert(filename);
  743. }
  745. bool LLXferManager::validateFileForTransfer(const std::string& filename)
  746. {
  747. return find_and_remove(mExpectedTransfers, filename);
  748. }
  750. static bool remove_prefix(std::string& filename, const std::string& prefix)
  751. {
  752. if (std::equal(prefix.begin(), prefix.end(), filename.begin()))
  753. {
  754. filename = filename.substr(prefix.length());
  755. return true;
  756. }
  757. return false;
  758. }
  760. static bool verify_cache_filename(const std::string& filename)
  761. {
  762. //NOTE: This routine is only used to check file names that our own
  763. // code places in the cache directory. As such, it can be limited
  764. // to this very restrictive file name pattern. It does not need to
  765. // handle other characters. The only known uses of this are (with examples):
  766. // sim to sim object pass: fc0b72d8-9456-63d9-a802-a557ef847313.tmp
  767. // sim to viewer mute list: mute_b78eacd0-1244-448e-93ca-28ede242f647.tmp
  768. // sim to viewer task inventory: inventory_d8ab59d2-baf0-0e79-c4c2-a3f99b9fcf45.tmp
  770. //IMPORTANT: Do not broaden the filenames accepted by this routine
  771. // without careful analysis. Anything allowed by this function can
  772. // be downloaded by the viewer.
  774. size_t len = filename.size();
  775. //const boost::regex expr("[0-9a-zA-Z_-]<1,46>.tmp");
  776. if (len < 5 || len > 50)
  777. {
  778. return false;
  779. }
  780. for(size_t i=0; i<(len-4); ++i)
  781. {
  782. char c = filename[i];
  783. bool ok = isalnum(c) || '_'==c || '-'==c;
  784. if (!ok)
  785. {
  786. return false;
  787. }
  788. }
  789. return filename[len-4] == '.'
  790. && filename[len-3] == 't'
  791. && filename[len-2] == 'm'
  792. && filename[len-1] == 'p';
  793. }
  795. void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user_data*/)
  796. {
  798. U64 id;
  799. std::string local_filename;
  800. ELLPath local_path = LL_PATH_NONE;
  801. S32 result = LL_ERR_NOERR;
  802. LLUUID uuid;
  803. LLAssetType::EType type;
  804. S16 type_s16;
  805. BOOL b_use_big_packets;
  807. mesgsys->getBOOL("XferID", "UseBigPackets", b_use_big_packets);
  809. mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
  810. char U64_BUF[MAX_STRING]; /* Flawfinder : ignore */
  811. llinfos << "xfer request id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF))
  812.    << " to " << mesgsys->getSender() << llendl;
  814. mesgsys->getStringFast(_PREHASH_XferID, _PREHASH_Filename, local_filename);
  816. {
  817. U8 local_path_u8;
  818. mesgsys->getU8("XferID", "FilePath", local_path_u8);
  819. local_path = (ELLPath)local_path_u8;
  820. }
  822. mesgsys->getUUIDFast(_PREHASH_XferID, _PREHASH_VFileID, uuid);
  823. mesgsys->getS16Fast(_PREHASH_XferID, _PREHASH_VFileType, type_s16);
  824. type = (LLAssetType::EType)type_s16;
  826. LLXfer *xferp;
  828. if (uuid != LLUUID::null)
  829. {
  830. if(NULL == LLAssetType::lookup(type))
  831. {
  832. llwarns << "Invalid type for xfer request: " << uuid << ":"
  833. << type_s16 << " to " << mesgsys->getSender() << llendl;
  834. return;
  835. }
  837. llinfos << "starting vfile transfer: " << uuid << "," << LLAssetType::lookup(type) << " to " << mesgsys->getSender() << llendl;
  839. if (! mVFS)
  840. {
  841. llwarns << "Attempt to send VFile w/o available VFS" << llendl;
  842. return;
  843. }
  845. xferp = (LLXfer *)new LLXfer_VFile(mVFS, uuid, type);
  846. if (xferp)
  847. {
  848. xferp->mNext = mSendList;
  849. mSendList = xferp;
  850. result = xferp->startSend(id,mesgsys->getSender());
  851. }
  852. else
  853. {
  854. llerrs << "Xfer allcoation error" << llendl;
  855. }
  856. }
  857. else if (!local_filename.empty())
  858. {
  859. // See DEV-21775 for detailed security issues
  861. if (local_path == LL_PATH_NONE)
  862. {
  863. // this handles legacy simulators that are passing objects
  864. // by giving a filename that explicitly names the cache directory
  865. static const std::string legacy_cache_prefix = "data/";
  866. if (remove_prefix(local_filename, legacy_cache_prefix))
  867. {
  868. local_path = LL_PATH_CACHE;
  869. }
  870. }
  872. switch (local_path)
  873. {
  874. case LL_PATH_NONE:
  875. if(!validateFileForTransfer(local_filename))
  876. {
  877. llwarns << "SECURITY: Unapproved filename '" << local_filename << llendl;
  878. return;
  879. }
  880. break;
  882. case LL_PATH_CACHE:
  883. if(!verify_cache_filename(local_filename))
  884. {
  885. llwarns << "SECURITY: Illegal cache filename '" << local_filename << llendl;
  886. return;
  887. }
  888. break;
  890. default:
  891. llwarns << "SECURITY: Restricted file dir enum: " << (U32)local_path << llendl;
  892. return;
  893. }
  896. std::string expanded_filename = gDirUtilp->getExpandedFilename( local_path, local_filename );
  897. llinfos << "starting file transfer: " <<  expanded_filename << " to " << mesgsys->getSender() << llendl;
  899. BOOL delete_local_on_completion = FALSE;
  900. mesgsys->getBOOL("XferID", "DeleteOnCompletion", delete_local_on_completion);
  902. // -1 chunk_size causes it to use the default
  903. xferp = (LLXfer *)new LLXfer_File(expanded_filename, delete_local_on_completion, b_use_big_packets ? LL_XFER_LARGE_PAYLOAD : -1);
  905. if (xferp)
  906. {
  907. xferp->mNext = mSendList;
  908. mSendList = xferp;
  909. result = xferp->startSend(id,mesgsys->getSender());
  910. }
  911. else
  912. {
  913. llerrs << "Xfer allcoation error" << llendl;
  914. }
  915. }
  916. else
  917. {
  918. char U64_BUF[MAX_STRING]; /* Flawfinder : ignore */
  919. llinfos << "starting memory transfer: "
  920. << U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << " to "
  921. << mesgsys->getSender() << llendl;
  923. xferp = findXfer(id, mSendList);
  925. if (xferp)
  926. {
  927. result = xferp->startSend(id,mesgsys->getSender());
  928. }
  929. else
  930. {
  931. llinfos << "Warning: " << U64_BUF << " not found." << llendl;
  932. result = LL_ERR_FILE_NOT_FOUND;
  933. }
  934. }
  936. if (result)
  937. {
  938. if (xferp)
  939. {
  940. xferp->abort(result);
  941. removeXfer(xferp,&mSendList);
  942. }
  943. else // can happen with a memory transfer not found
  944. {
  945. llinfos << "Aborting xfer to " << mesgsys->getSender() << " with error: " << result << llendl;
  947. mesgsys->newMessageFast(_PREHASH_AbortXfer);
  948. mesgsys->nextBlockFast(_PREHASH_XferID);
  949. mesgsys->addU64Fast(_PREHASH_ID, id);
  950. mesgsys->addS32Fast(_PREHASH_Result, result);
  952. mesgsys->sendMessage(mesgsys->getSender());
  953. }
  954. }
  955. else if(xferp && (numActiveXfers(xferp->mRemoteHost) < mMaxOutgoingXfersPerCircuit))
  956. {
  957. xferp->sendNextPacket();
  958. changeNumActiveXfers(xferp->mRemoteHost,1);
  959. // llinfos << "***STARTING XFER IMMEDIATELY***" << llendl;
  960. }
  961. else
  962. {
  963. if(xferp)
  964. {
  965. llinfos << "  queueing xfer request, " << numPendingXfers(xferp->mRemoteHost) << " ahead of this one" << llendl;
  966. }
  967. else
  968. {
  969. llwarns << "LLXferManager::processFileRequest() - no xfer found!"
  970. << llendl;
  971. }
  972. }
  973. }
  976. ///////////////////////////////////////////////////////////
  978. void LLXferManager::processConfirmation (LLMessageSystem *mesgsys, void ** /*user_data*/)
  979. {
  980. U64 id = 0;
  981. S32 packetNum = 0;
  983. mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
  984. mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Packet, packetNum);
  986. LLXfer* xferp = findXfer(id, mSendList);
  987. if (xferp)
  988. {
  989. // cout << "confirmed packet #" << packetNum << " ping: "<< xferp->ACKTimer.getElapsedTimeF32() <<  endl;
  990. xferp->mWaitingForACK = FALSE;
  991. if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
  992. {
  993. xferp->sendNextPacket();
  994. }
  995. else
  996. {
  997. removeXfer(xferp, &mSendList);
  998. }
  999. }
  1000. }
  1002. ///////////////////////////////////////////////////////////
  1004. void LLXferManager::retransmitUnackedPackets ()
  1005. {
  1006. LLXfer *xferp;
  1007. LLXfer *delp;
  1008. xferp = mReceiveList;
  1009. while(xferp)
  1010. {
  1011. if (xferp->mStatus == e_LL_XFER_IN_PROGRESS)
  1012. {
  1013. // if the circuit dies, abort
  1014. if (! gMessageSystem->mCircuitInfo.isCircuitAlive( xferp->mRemoteHost ))
  1015. {
  1016. llinfos << "Xfer found in progress on dead circuit, aborting" << llendl;
  1017. xferp->mCallbackResult = LL_ERR_CIRCUIT_GONE;
  1018. xferp->processEOF();
  1019. delp = xferp;
  1020. xferp = xferp->mNext;
  1021. removeXfer(delp,&mReceiveList);
  1022. continue;
  1023.   }
  1025. }
  1026. xferp = xferp->mNext;
  1027. }
  1029. xferp = mSendList; 
  1030. updateHostStatus();
  1031. F32 et;
  1032. while (xferp)
  1033. {
  1034. if (xferp->mWaitingForACK && ( (et = xferp->ACKTimer.getElapsedTimeF32()) > LL_PACKET_TIMEOUT))
  1035. {
  1036. if (xferp->mRetries > LL_PACKET_RETRY_LIMIT)
  1037. {
  1038. llinfos << "dropping xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet retransmit limit exceeded, xfer dropped" << llendl;
  1039. xferp->abort(LL_ERR_TCP_TIMEOUT);
  1040. delp = xferp;
  1041. xferp = xferp->mNext;
  1042. removeXfer(delp,&mSendList);
  1043. }
  1044. else
  1045. {
  1046. llinfos << "resending xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << " packet unconfirmed after: "<< et << " sec, packet " << xferp->mPacketNum << llendl;
  1047. xferp->resendLastPacket();
  1048. xferp = xferp->mNext;
  1049. }
  1050. }
  1051. else if ((xferp->mStatus == e_LL_XFER_REGISTERED) && ( (et = xferp->ACKTimer.getElapsedTimeF32()) > LL_XFER_REGISTRATION_TIMEOUT))
  1052. {
  1053. llinfos << "registered xfer never requested, xfer dropped" << llendl;
  1054. xferp->abort(LL_ERR_TCP_TIMEOUT);
  1055. delp = xferp;
  1056. xferp = xferp->mNext;
  1057. removeXfer(delp,&mSendList);
  1058. }
  1059. else if (xferp->mStatus == e_LL_XFER_ABORTED)
  1060. {
  1061. llwarns << "Removing aborted xfer " << xferp->mRemoteHost << ":" << xferp->getFileName() << llendl;
  1062. delp = xferp;
  1063. xferp = xferp->mNext;
  1064. removeXfer(delp,&mSendList);
  1065. }
  1066. else if (xferp->mStatus == e_LL_XFER_PENDING)
  1067. {
  1068. // llinfos << "*** numActiveXfers = " << numActiveXfers(xferp->mRemoteHost) << "        mMaxOutgoingXfersPerCircuit = " << mMaxOutgoingXfersPerCircuit << llendl;   
  1069. if (numActiveXfers(xferp->mRemoteHost) < mMaxOutgoingXfersPerCircuit)
  1070. {
  1071. //     llinfos << "bumping pending xfer to active" << llendl;
  1072. xferp->sendNextPacket();
  1073. changeNumActiveXfers(xferp->mRemoteHost,1);
  1074. }
  1075. xferp = xferp->mNext;
  1076. }
  1077. else
  1078. {
  1079. xferp = xferp->mNext;
  1080. }
  1081. }
  1083. //
  1084. // HACK - if we're using xfer confirm throttling, throttle our xfer confirms here
  1085. // so we don't blow through bandwidth.
  1086. //
  1088. while (mXferAckQueue.getLength())
  1089. {
  1090. if (mAckThrottle.checkOverflow(1000.0f*8.0f))
  1091. {
  1092. break;
  1093. }
  1094. //llinfos << "Confirm packet queue length:" << mXferAckQueue.getLength() << llendl;
  1095. LLXferAckInfo ack_info;
  1096. mXferAckQueue.pop(ack_info);
  1097. //llinfos << "Sending confirm packet" << llendl;
  1098. sendConfirmPacket(gMessageSystem, ack_info.mID, ack_info.mPacketNum, ack_info.mRemoteHost);
  1099. mAckThrottle.throttleOverflow(1000.f*8.f); // Assume 1000 bytes/packet
  1100. }
  1101. }
  1104. ///////////////////////////////////////////////////////////
  1106. void LLXferManager::processAbort (LLMessageSystem *mesgsys, void ** /*user_data*/)
  1107. {
  1108. U64 id = 0;
  1109. S32 result_code = 0;
  1110. LLXfer * xferp;
  1112. mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
  1113. mesgsys->getS32Fast(_PREHASH_XferID, _PREHASH_Result, result_code);
  1115. xferp = findXfer(id, mReceiveList);
  1116. if (xferp)
  1117. {
  1118. xferp->mCallbackResult = result_code;
  1119. xferp->processEOF();
  1120. removeXfer(xferp, &mReceiveList);
  1121. startPendingDownloads();
  1122. }
  1123. }
  1125. ///////////////////////////////////////////////////////////
  1127. void LLXferManager::startPendingDownloads()
  1128. {
  1129. // This method goes through the list, and starts pending
  1130. // operations until active downloads == mMaxIncomingXfers. I copy
  1131. // the pending xfers into a temporary data structure because the
  1132. // xfers are stored as an intrusive linked list where older
  1133. // requests get pushed toward the back. Thus, if we didn't do a
  1134. // stateful iteration, it would be possible for old requests to
  1135. // never start.
  1136. LLXfer* xferp = mReceiveList;
  1137. std::list<LLXfer*> pending_downloads;
  1138. S32 download_count = 0;
  1139. S32 pending_count = 0;
  1140. while(xferp)
  1141. {
  1142. if(xferp->mStatus == e_LL_XFER_PENDING)
  1143. {
  1144. ++pending_count;
  1145. pending_downloads.push_front(xferp);
  1146. }
  1147. else if(xferp->mStatus == e_LL_XFER_IN_PROGRESS)
  1148. {
  1149. ++download_count;
  1150. }
  1151. xferp = xferp->mNext;
  1152. }
  1154. S32 start_count = mMaxIncomingXfers - download_count;
  1156. lldebugs << "LLXferManager::startPendingDownloads() - XFER_IN_PROGRESS: "
  1157.  << download_count << " XFER_PENDING: " << pending_count
  1158.  << " startring " << llmin(start_count, pending_count) << llendl;
  1160. if((start_count > 0) && (pending_count > 0))
  1161. {
  1162. S32 result;
  1163. for (std::list<LLXfer*>::iterator iter = pending_downloads.begin();
  1164.  iter != pending_downloads.end(); ++iter)
  1165. {
  1166. xferp = *iter;
  1167. if (start_count-- <= 0)
  1168. break;
  1169. result = xferp->startDownload();
  1170. if(result)
  1171. {
  1172. xferp->abort(result);
  1173. ++start_count;
  1174. }
  1175. }
  1176. }
  1177. }
  1179. ///////////////////////////////////////////////////////////
  1181. void LLXferManager::addToList(LLXfer* xferp, LLXfer*& head, BOOL is_priority)
  1182. {
  1183. if(is_priority)
  1184. {
  1185. xferp->mNext = NULL;
  1186. LLXfer* next = head;
  1187. if(next)
  1188. {
  1189. while(next->mNext)
  1190. {
  1191. next = next->mNext;
  1192. }
  1193. next->mNext = xferp;
  1194. }
  1195. else
  1196. {
  1197. head = xferp;
  1198. }
  1199. }
  1200. else
  1201. {
  1202. xferp->mNext = head;
  1203. head = xferp;
  1204. }
  1205. }
  1207. ///////////////////////////////////////////////////////////
  1208. //  Globals and C routines
  1209. ///////////////////////////////////////////////////////////
  1211. LLXferManager *gXferManager = NULL;
  1214. void start_xfer_manager(LLVFS *vfs)
  1215. {
  1216. gXferManager = new LLXferManager(vfs);
  1217. }
  1219. void cleanup_xfer_manager()
  1220. {
  1221. if (gXferManager)
  1222. {
  1223. delete(gXferManager);
  1224. gXferManager = NULL;
  1225. }
  1226. }
  1228. void process_confirm_packet (LLMessageSystem *mesgsys, void **user_data)
  1229. {
  1230. gXferManager->processConfirmation(mesgsys,user_data);
  1231. }
  1233. void process_request_xfer(LLMessageSystem *mesgsys, void **user_data)
  1234. {
  1235. gXferManager->processFileRequest(mesgsys,user_data);
  1236. }
  1238. void continue_file_receive(LLMessageSystem *mesgsys, void **user_data)
  1239. {
  1240. #if LL_TEST_XFER_REXMIT
  1241. if (ll_frand() > 0.05f)
  1242. {
  1243. #endif
  1244. gXferManager->processReceiveData(mesgsys,user_data);
  1245. #if LL_TEST_XFER_REXMIT
  1246. }
  1247. else
  1248. {
  1249. cout << "oops! dropped a xfer packet" << endl;
  1250. }
  1251. #endif
  1252. }
  1254. void process_abort_xfer(LLMessageSystem *mesgsys, void **user_data)
  1255. {
  1256. gXferManager->processAbort(mesgsys,user_data);
  1257. }