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

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

游戏引擎

开发平台：

C++ Builder

llares.cpp：源码内容
  1. /** 
  2.  * @file llares.cpp
  3.  * @author Bryan O'Sullivan
  4.  * @date 2007-08-15
  5.  * @brief Wrapper for asynchronous DNS lookups.
  6.  *
  7.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2007-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.  */
  35. #include "linden_common.h"
  36. #include "llares.h"
  38. #include <ares_dns.h>
  39. #include <ares_version.h>
  41. #include "apr_portable.h"
  42. #include "apr_network_io.h"
  43. #include "apr_poll.h"
  45. #include "llapr.h"
  46. #include "llareslistener.h"
  48. #if defined(LL_WINDOWS)
  49. #pragma warning (disable : 4355) // 'this' used in initializer list: yes, intentionally
  50. # define ns_c_in 1
  51. # define NS_HFIXEDSZ     12      /* #/bytes of fixed data in header */
  52. # define NS_QFIXEDSZ     4       /* #/bytes of fixed data in query */
  53. # define NS_RRFIXEDSZ    10      /* #/bytes of fixed data in r record */
  54. #else
  55. # include <arpa/nameser.h>
  56. #endif
  58. LLAres::HostResponder::~HostResponder()
  59. {
  60. }
  62. void LLAres::HostResponder::hostResult(const hostent *ent)
  63. {
  64. llinfos << "LLAres::HostResponder::hostResult not implemented" << llendl;
  65. }
  67. void LLAres::HostResponder::hostError(int code)
  68. {
  69. llinfos << "LLAres::HostResponder::hostError " << code << ": "
  70. << LLAres::strerror(code) << llendl;
  71. }
  73. LLAres::NameInfoResponder::~NameInfoResponder()
  74. {
  75. }
  77. void LLAres::NameInfoResponder::nameInfoResult(const char *node,
  78.    const char *service)
  79. {
  80. llinfos << "LLAres::NameInfoResponder::nameInfoResult not implemented"
  81. << llendl;
  82. }
  84. void LLAres::NameInfoResponder::nameInfoError(int code)
  85. {
  86. llinfos << "LLAres::NameInfoResponder::nameInfoError " << code << ": "
  87. << LLAres::strerror(code) << llendl;
  88. }
  90. LLAres::QueryResponder::~QueryResponder()
  91. {
  92. }
  94. void LLAres::QueryResponder::queryResult(const char *buf, size_t len)
  95. {
  96. llinfos << "LLAres::QueryResponder::queryResult not implemented"
  97. << llendl;
  98. }
  100. void LLAres::QueryResponder::queryError(int code)
  101. {
  102. llinfos << "LLAres::QueryResponder::queryError " << code << ": "
  103. << LLAres::strerror(code) << llendl;
  104. }
  106. LLAres::LLAres() :
  107.     chan_(NULL),
  108.     mInitSuccess(false),
  109.     mListener(new LLAresListener(this))
  110. {
  111. if (ares_init(&chan_) != ARES_SUCCESS)
  112. {
  113. llwarns << "Could not succesfully initialize ares!" << llendl;
  114. return;
  115. }
  117. mInitSuccess = true;
  118. }
  120. LLAres::~LLAres()
  121. {
  122. ares_destroy(chan_);
  123. }
  125. void LLAres::cancel()
  126. {
  127. ares_cancel(chan_);
  128. }
  130. static void host_callback_1_5(void *arg, int status, int timeouts,
  131.   struct hostent *ent)
  132. {
  133. LLPointer<LLAres::HostResponder> *resp =
  134. (LLPointer<LLAres::HostResponder> *) arg;
  136. if (status == ARES_SUCCESS)
  137. {
  138. (*resp)->hostResult(ent);
  139. } else {
  140. (*resp)->hostError(status);
  141. }
  143. delete resp;
  144. }
  146. #if ARES_VERSION_MAJOR == 1 && ARES_VERSION_MINOR == 4
  147. static void host_callback(void *arg, int status, struct hostent *ent)
  148. {
  149. host_callback_1_5(arg, status, 0, ent);
  150. }
  151. #else
  152. # define host_callback host_callback_1_5
  153. #endif
  155. void LLAres::getHostByName(const char *name, HostResponder *resp,
  156.    int family)
  157. {
  158. ares_gethostbyname(chan_, name, family, host_callback,
  159.    new LLPointer<LLAres::HostResponder>(resp));
  160. }
  162. void LLAres::getSrvRecords(const std::string &name, SrvResponder *resp)
  163. {
  164. search(name, RES_SRV, resp);
  165. }
  167. void LLAres::rewriteURI(const std::string &uri, UriRewriteResponder *resp)
  168. {
  169. llinfos << "Rewriting " << uri << llendl;
  171. resp->mUri = LLURI(uri);
  172. search("_" + resp->mUri.scheme() + "._tcp." + resp->mUri.hostName(),
  173.    RES_SRV, resp);
  174. }
  176. LLQueryResponder::LLQueryResponder()
  177. : LLAres::QueryResponder(),
  178.   mResult(ARES_ENODATA),
  179.   mType(RES_INVALID)
  180. {
  181. }
  183. int LLQueryResponder::parseRR(const char *buf, size_t len, const char *&pos,
  184.   LLPointer<LLDnsRecord> &r)
  185. {
  186. std::string rrname;
  187. size_t enclen;
  188. int ret;
  190. // RR name.
  192. ret = LLAres::expandName(pos, buf, len, rrname, enclen);
  193. if (ret != ARES_SUCCESS)
  194. {
  195. return ret;
  196. }
  198. pos += enclen;
  200. if (pos + NS_RRFIXEDSZ > buf + len)
  201. {
  202. return ARES_EBADRESP;
  203. }
  205. int rrtype = DNS_RR_TYPE(pos);
  206. int rrclass = DNS_RR_CLASS(pos);
  207. int rrttl = DNS_RR_TTL(pos);
  208. int rrlen = DNS_RR_LEN(pos);
  210. if (rrclass != ns_c_in)
  211. {
  212. return ARES_EBADRESP;
  213. }
  215. pos += NS_RRFIXEDSZ;
  217. if (pos + rrlen > buf + len)
  218. {
  219. return ARES_EBADRESP;
  220. }
  222. switch (rrtype)
  223. {
  224. case RES_A:
  225. r = new LLARecord(rrname, rrttl);
  226. break;
  227. case RES_NS:
  228. r = new LLNsRecord(rrname, rrttl);
  229. break;
  230. case RES_CNAME:
  231. r = new LLCnameRecord(rrname, rrttl);
  232. break;
  233. case RES_PTR:
  234. r = new LLPtrRecord(rrname, rrttl);
  235. break;
  236. case RES_AAAA:
  237. r = new LLAaaaRecord(rrname, rrttl);
  238. break;
  239. case RES_SRV:
  240. r = new LLSrvRecord(rrname, rrttl);
  241. break;
  242. default:
  243. llinfos << "LLQueryResponder::parseRR got unknown RR type " << rrtype
  244. << llendl;
  245. return ARES_EBADRESP;
  246. }
  248. ret = r->parse(buf, len, pos, rrlen);
  250. if (ret == ARES_SUCCESS)
  251. {
  252. pos += rrlen;
  253. } else {
  254. r = NULL;
  255. }
  257. return ret;
  258. }
  260. int LLQueryResponder::parseSection(const char *buf, size_t len,
  261.    size_t count, const char *&pos,
  262.    dns_rrs_t &rrs)
  263. {
  264. int ret = ARES_SUCCESS;
  266. for (size_t i = 0; i < count; i++)
  267. {
  268. LLPointer<LLDnsRecord> r;
  269. ret = parseRR(buf, len, pos, r);
  270. if (ret != ARES_SUCCESS)
  271. {
  272. break;
  273. }
  274. rrs.push_back(r);
  275. }
  277. return ret;
  278. }
  280. void LLQueryResponder::queryResult(const char *buf, size_t len)
  281. {
  282. const char *pos = buf;
  283. int qdcount = DNS_HEADER_QDCOUNT(pos);
  284. int ancount = DNS_HEADER_ANCOUNT(pos);
  285. int nscount = DNS_HEADER_NSCOUNT(pos);
  286. int arcount = DNS_HEADER_ARCOUNT(pos);
  287. int ret;
  289. if (qdcount == 0 || ancount + nscount + arcount == 0)
  290. {
  291. ret = ARES_ENODATA;
  292. goto bail;
  293. }
  295. pos += NS_HFIXEDSZ;
  297. for (int i = 0; i < qdcount; i++)
  298. {
  299. std::string ignore;
  300. size_t enclen;
  302. ret = LLAres::expandName(pos, buf, len, i == 0 ? mQuery : ignore,
  303.  enclen);
  304. if (ret != ARES_SUCCESS)
  305. {
  306. goto bail;
  307. }
  309. pos += enclen;
  311. if (i == 0)
  312. {
  313. int t = DNS_QUESTION_TYPE(pos);
  314. switch (t)
  315. {
  316. case RES_A:
  317. case RES_NS:
  318. case RES_CNAME:
  319. case RES_PTR:
  320. case RES_AAAA:
  321. case RES_SRV:
  322. mType = (LLResType) t;
  323. break;
  324. default:
  325. llinfos << "Cannot grok query type " << t << llendl;
  326. ret = ARES_EBADQUERY;
  327. goto bail;
  328. }
  329. }
  331. pos += NS_QFIXEDSZ;
  332. if (pos > buf + len)
  333. {
  334. ret = ARES_EBADRESP;
  335. goto bail;
  336. }
  337. }
  339. ret = parseSection(buf, len, ancount, pos, mAnswers);
  340. if (ret != ARES_SUCCESS)
  341. {
  342. goto bail;
  343. }
  345. ret = parseSection(buf, len, nscount, pos, mAuthorities);
  346. if (ret != ARES_SUCCESS)
  347. {
  348. goto bail;
  349. }
  351. ret = parseSection(buf, len, arcount, pos, mAdditional);
  353. bail:
  354. mResult = ret;
  355. if (mResult == ARES_SUCCESS)
  356. {
  357. querySuccess();
  358. } else {
  359. queryError(mResult);
  360. }
  361. }
  363. void LLQueryResponder::querySuccess()
  364. {
  365. llinfos << "LLQueryResponder::queryResult not implemented" << llendl;
  366. }
  368. void LLAres::SrvResponder::querySuccess()
  369. {
  370. if (mType == RES_SRV)
  371. {
  372. srvResult(mAnswers);
  373. } else {
  374. srvError(ARES_EBADRESP);
  375. }
  376. }
  378. void LLAres::SrvResponder::queryError(int code)
  379. {
  380. srvError(code);
  381. }
  383. void LLAres::SrvResponder::srvResult(const dns_rrs_t &ents)
  384. {
  385. llinfos << "LLAres::SrvResponder::srvResult not implemented" << llendl;
  387. for (size_t i = 0; i < ents.size(); i++)
  388. {
  389. const LLSrvRecord *s = (const LLSrvRecord *) ents[i].get();
  391. llinfos << "[" << i << "] " << s->host() << ":" << s->port()
  392. << " priority " << s->priority()
  393. << " weight " << s->weight()
  394. << llendl;
  395. }
  396. }
  398. void LLAres::SrvResponder::srvError(int code)
  399. {
  400. llinfos << "LLAres::SrvResponder::srvError " << code << ": "
  401. << LLAres::strerror(code) << llendl;
  402. }
  404. static void nameinfo_callback_1_5(void *arg, int status, int timeouts,
  405.   char *node, char *service)
  406. {
  407. LLPointer<LLAres::NameInfoResponder> *resp =
  408. (LLPointer<LLAres::NameInfoResponder> *) arg;
  410. if (status == ARES_SUCCESS)
  411. {
  412. (*resp)->nameInfoResult(node, service);
  413. } else {
  414. (*resp)->nameInfoError(status);
  415. }
  417. delete resp;
  418. }
  420. #if ARES_VERSION_MAJOR == 1 && ARES_VERSION_MINOR == 4
  421. static void nameinfo_callback(void *arg, int status, char *node, char *service)
  422. {
  423. nameinfo_callback_1_5(arg, status, 0, node, service);
  424. }
  425. #else
  426. # define nameinfo_callback nameinfo_callback_1_5
  427. #endif
  429. void LLAres::getNameInfo(const struct sockaddr &sa, socklen_t salen, int flags,
  430.  NameInfoResponder *resp)
  431. {
  432. ares_getnameinfo(chan_, &sa, salen, flags, nameinfo_callback,
  433.  new LLPointer<NameInfoResponder>(resp));
  434. }
  436. static void search_callback_1_5(void *arg, int status, int timeouts,
  437. unsigned char *abuf, int alen)
  438. {
  439. LLPointer<LLAres::QueryResponder> *resp =
  440. (LLPointer<LLAres::QueryResponder> *) arg;
  442. if (status == ARES_SUCCESS)
  443. {
  444. (*resp)->queryResult((const char *) abuf, alen);
  445. } else {
  446. (*resp)->queryError(status);
  447. }
  449. delete resp;
  450. }
  452. #if ARES_VERSION_MAJOR == 1 && ARES_VERSION_MINOR == 4
  453. static void search_callback(void *arg, int status, unsigned char *abuf,
  454. int alen)
  455. {
  456. search_callback_1_5(arg, status, 0, abuf, alen);
  457. }
  458. #else
  459. # define search_callback search_callback_1_5
  460. #endif
  462. void LLAres::search(const std::string &query, LLResType type,
  463. QueryResponder *resp)
  464. {
  465. ares_search(chan_, query.c_str(), ns_c_in, type, search_callback,
  466. new LLPointer<QueryResponder>(resp));
  467. }
  469. bool LLAres::process(U64 timeout)
  470. {
  471. if (!gAPRPoolp)
  472. {
  473. ll_init_apr();
  474. }
  476. int socks[ARES_GETSOCK_MAXNUM];
  477. apr_pollfd_t aprFds[ARES_GETSOCK_MAXNUM];
  478. apr_int32_t nsds = 0;
  479. int nactive = 0;
  480. int bitmask;
  482. bitmask = ares_getsock(chan_, socks, ARES_GETSOCK_MAXNUM);
  484. if (bitmask == 0)
  485. {
  486. return nsds > 0;
  487. }
  489. apr_status_t status;
  490. LLAPRPool pool;
  491. status = pool.getStatus() ;
  492. ll_apr_assert_status(status);
  494. for (int i = 0; i < ARES_GETSOCK_MAXNUM; i++)
  495. {
  496. if (ARES_GETSOCK_READABLE(bitmask, i))
  497. {
  498. aprFds[nactive].reqevents = APR_POLLIN | APR_POLLERR;
  499. }
  500. else if (ARES_GETSOCK_WRITABLE(bitmask, i))
  501. {
  502. aprFds[nactive].reqevents = APR_POLLOUT | APR_POLLERR;
  503. } else {
  504. continue;
  505. }
  507. apr_socket_t *aprSock = NULL;
  509. status = apr_os_sock_put(&aprSock, (apr_os_sock_t *) &socks[i], pool.getAPRPool());
  510. if (status != APR_SUCCESS)
  511. {
  512. ll_apr_warn_status(status);
  513. return nsds > 0;
  514. }
  516. aprFds[nactive].desc.s = aprSock;
  517. aprFds[nactive].desc_type = APR_POLL_SOCKET;
  518. aprFds[nactive].p = pool.getAPRPool();
  519. aprFds[nactive].rtnevents = 0;
  520. aprFds[nactive].client_data = &socks[i];
  522. nactive++;
  523. }
  525. if (nactive > 0)
  526. {
  527. status = apr_poll(aprFds, nactive, &nsds, timeout);
  529. if (status != APR_SUCCESS && status != APR_TIMEUP)
  530. {
  531. ll_apr_warn_status(status);
  532. }
  534. for (int i = 0; i < nactive; i++)
  535. {
  536. int evts = aprFds[i].rtnevents;
  537. int ifd = (evts & (APR_POLLIN | APR_POLLERR))
  538. ? *((int *) aprFds[i].client_data) : ARES_SOCKET_BAD;
  539. int ofd = (evts & (APR_POLLOUT | APR_POLLERR))
  540. ? *((int *) aprFds[i].client_data) : ARES_SOCKET_BAD;
  542. ares_process_fd(chan_, ifd, ofd);
  543. }
  544. }
  546. return nsds > 0;
  547. }
  549. bool LLAres::processAll()
  550. {
  551. bool anyProcessed = false, ret;
  553. do {
  554. timeval tv;
  556. ret = ares_timeout(chan_, NULL, &tv) != NULL;
  558. if (ret)
  559. {
  560. ret = process(tv.tv_sec * 1000000LL + tv.tv_usec);
  561. anyProcessed |= ret;
  562. }
  563. } while (ret);
  565. return anyProcessed;
  566. }
  568. int LLAres::expandName(const char *encoded, const char *abuf, size_t alen,
  569.    std::string &s, size_t &enclen)
  570. {
  571. char *t;
  572. int ret;
  573. long e;
  575. ret = ares_expand_name((const unsigned char *) encoded,
  576.    (const unsigned char *) abuf, alen, &t, &e);
  577. if (ret == ARES_SUCCESS)
  578. {
  579. s.assign(t);
  580. enclen = e;
  581. ares_free_string(t);
  582. }
  583. return ret;
  584. }
  586. const char *LLAres::strerror(int code)
  587. {
  588. return ares_strerror(code);
  589. }
  591. LLAres *gAres;
  593. LLAres *ll_init_ares()
  594. {
  595. if (gAres == NULL)
  596. {
  597. gAres = new LLAres();
  598. }
  599. return gAres;
  600. }
  602. LLDnsRecord::LLDnsRecord(LLResType type, const std::string &name,
  603.  unsigned ttl)
  604. : LLRefCount(),
  605.   mType(type),
  606.   mName(name),
  607.   mTTL(ttl)
  608. {
  609. }
  611. LLHostRecord::LLHostRecord(LLResType type, const std::string &name,
  612.    unsigned ttl)
  613. : LLDnsRecord(type, name, ttl)
  614. {
  615. }
  617. int LLHostRecord::parse(const char *buf, size_t len, const char *pos,
  618. size_t rrlen)
  619. {
  620. int ret;
  622. ret = LLAres::expandName(pos, buf, len, mHost);
  623. if (ret != ARES_SUCCESS)
  624. {
  625. goto bail;
  626. }
  628. ret = ARES_SUCCESS;
  630. bail:
  631. return ret;
  632. }
  634. LLCnameRecord::LLCnameRecord(const std::string &name, unsigned ttl)
  635. : LLHostRecord(RES_CNAME, name, ttl)
  636. {
  637. }
  639. LLPtrRecord::LLPtrRecord(const std::string &name, unsigned ttl)
  640. : LLHostRecord(RES_PTR, name, ttl)
  641. {
  642. }
  644. LLAddrRecord::LLAddrRecord(LLResType type, const std::string &name,
  645.    unsigned ttl)
  646. : LLDnsRecord(type, name, ttl),
  648.   mSize(0)
  649. {
  650. }
  652. LLARecord::LLARecord(const std::string &name, unsigned ttl)
  653. : LLAddrRecord(RES_A, name, ttl)
  654. {
  655. }
  657. int LLARecord::parse(const char *buf, size_t len, const char *pos,
  658.  size_t rrlen)
  659. {
  660. int ret;
  662. if (rrlen != sizeof(mSA.sin.sin_addr.s_addr))
  663. {
  664. ret = ARES_EBADRESP;
  665. goto bail;
  666. }
  668. memset(&mSA, 0, sizeof(mSA));
  669. memcpy(&mSA.sin.sin_addr.s_addr, pos, rrlen);
  670. mSA.sin.sin_family = AF_INET6;
  671. mSize = sizeof(mSA.sin);
  673. ret = ARES_SUCCESS;
  675. bail:
  676. return ret;
  677. }
  679. LLAaaaRecord::LLAaaaRecord(const std::string &name, unsigned ttl)
  680. : LLAddrRecord(RES_AAAA, name, ttl)
  681. {
  682. }
  684. int LLAaaaRecord::parse(const char *buf, size_t len, const char *pos,
  685. size_t rrlen)
  686. {
  687. int ret;
  689. if (rrlen != sizeof(mSA.sin6.sin6_addr))
  690. {
  691. ret = ARES_EBADRESP;
  692. goto bail;
  693. }
  695. memset(&mSA, 0, sizeof(mSA));
  696. memcpy(&mSA.sin6.sin6_addr.s6_addr, pos, rrlen);
  697. mSA.sin6.sin6_family = AF_INET6;
  698. mSize = sizeof(mSA.sin6);
  700. ret = ARES_SUCCESS;
  702. bail:
  703. return ret;
  704. }
  706. LLSrvRecord::LLSrvRecord(const std::string &name, unsigned ttl)
  707. : LLHostRecord(RES_SRV, name, ttl),
  709.   mPriority(0),
  710.   mWeight(0),
  711.   mPort(0)
  712. {
  713. }
  715. int LLSrvRecord::parse(const char *buf, size_t len, const char *pos,
  716.    size_t rrlen)
  717. {
  718. int ret;
  720. if (rrlen < 6)
  721. {
  722. ret = ARES_EBADRESP;
  723. goto bail;
  724. }
  726. memcpy(&mPriority, pos, 2);
  727. memcpy(&mWeight, pos + 2, 2);
  728. memcpy(&mPort, pos + 4, 2);
  730. mPriority = ntohs(mPriority);
  731. mWeight = ntohs(mWeight);
  732. mPort = ntohs(mPort);
  734. ret = LLHostRecord::parse(buf, len, pos + 6, rrlen - 6);
  736. bail:
  737. return ret;
  738. }
  740. LLNsRecord::LLNsRecord(const std::string &name, unsigned ttl)
  741. : LLHostRecord(RES_NS, name, ttl)
  742. {
  743. }
  745. void LLAres::UriRewriteResponder::queryError(int code)
  746. {
  747. std::vector<std::string> uris;
  748. uris.push_back(mUri.asString());
  749. rewriteResult(uris);
  750. }
  752. void LLAres::UriRewriteResponder::querySuccess()
  753. {
  754. std::vector<std::string> uris;
  756. if (mType != RES_SRV)
  757. {
  758. goto bail;
  759. }
  761. for (size_t i = 0; i < mAnswers.size(); i++)
  762. {
  763. const LLSrvRecord *r = (const LLSrvRecord *) mAnswers[i].get();
  765. if (r->type() == RES_SRV)
  766. {
  767. // Check the domain in the response to ensure that it's
  768. // the same as the domain in the request, so that bad guys
  769. // can't forge responses that point to their own login
  770. // servers with their own certificates.
  772. // Hard-coding the domain to check here is a bit of a
  773. // hack.  Hoist it to an outer caller if anyone ever needs
  774. // this functionality on other domains.
  776. static const std::string domain(".lindenlab.com");
  777. const std::string &host = r->host();
  779. std::string::size_type s = host.find(domain) + domain.length();
  781. if (s != host.length() && s != host.length() - 1)
  782. {
  783. continue;
  784. }
  786. LLURI uri(mUri.scheme(),
  787.   mUri.userName(),
  788.   mUri.password(),
  789.   r->host(),
  790.   mUri.defaultPort() ? r->port() : mUri.hostPort(),
  791.   mUri.escapedPath(),
  792.   mUri.escapedQuery());
  793. uris.push_back(uri.asString());
  794. }
  795. }
  797. if (!uris.empty())
  798. {
  799. goto done;
  800. }
  802. bail:
  803. uris.push_back(mUri.asString());
  805. done:
  806. rewriteResult(uris);
  807. }
  809. void LLAres::UriRewriteResponder::rewriteResult(
  810. const std::vector<std::string> &uris)
  811. {
  812. llinfos << "LLAres::UriRewriteResponder::rewriteResult not implemented"
  813. << llendl;
  815. for (size_t i = 0; i < uris.size(); i++)
  816. {
  817. llinfos << "[" << i << "] " << uris[i] << llendl;
  818. }
  819. }