You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

790 lines
22 KiB

  1. // -*- mode: cpp; mode: fold -*-
  2. // Description /*{{{*/
  3. /* ######################################################################
  4. HTTP and HTTPS share a lot of common code and these classes are
  5. exactly the dumping ground for this common code
  6. ##################################################################### */
  7. /*}}}*/
  8. // Include Files /*{{{*/
  9. #include <config.h>
  10. #include <apt-pkg/acquire-method.h>
  11. #include <apt-pkg/configuration.h>
  12. #include <apt-pkg/error.h>
  13. #include <apt-pkg/fileutl.h>
  14. #include <apt-pkg/strutl.h>
  15. #include <ctype.h>
  16. #include <signal.h>
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <sys/stat.h>
  20. #include <sys/time.h>
  21. #include <time.h>
  22. #include <unistd.h>
  23. #include <iostream>
  24. #include <limits>
  25. #include <map>
  26. #include <string>
  27. #include <vector>
  28. #include "server.h"
  29. #include <apti18n.h>
  30. /*}}}*/
  31. using namespace std;
  32. string ServerMethod::FailFile;
  33. int ServerMethod::FailFd = -1;
  34. time_t ServerMethod::FailTime = 0;
  35. // ServerState::RunHeaders - Get the headers before the data /*{{{*/
  36. // ---------------------------------------------------------------------
  37. /* Returns 0 if things are OK, 1 if an IO error occurred and 2 if a header
  38. parse error occurred */
  39. ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File,
  40. const std::string &Uri)
  41. {
  42. State = Header;
  43. Owner->Status(_("Waiting for headers"));
  44. Major = 0;
  45. Minor = 0;
  46. Result = 0;
  47. TotalFileSize = 0;
  48. JunkSize = 0;
  49. StartPos = 0;
  50. Encoding = Closes;
  51. HaveContent = false;
  52. time(&Date);
  53. do
  54. {
  55. string Data;
  56. if (ReadHeaderLines(Data) == false)
  57. continue;
  58. if (Owner->Debug == true)
  59. clog << "Answer for: " << Uri << endl << Data;
  60. for (string::const_iterator I = Data.begin(); I < Data.end(); ++I)
  61. {
  62. string::const_iterator J = I;
  63. for (; J != Data.end() && *J != '\n' && *J != '\r'; ++J);
  64. if (HeaderLine(string(I,J)) == false)
  65. return RUN_HEADERS_PARSE_ERROR;
  66. I = J;
  67. }
  68. // 100 Continue is a Nop...
  69. if (Result == 100)
  70. continue;
  71. // Tidy up the connection persistence state.
  72. if (Encoding == Closes && HaveContent == true)
  73. Persistent = false;
  74. return RUN_HEADERS_OK;
  75. }
  76. while (LoadNextResponse(false, File) == true);
  77. return RUN_HEADERS_IO_ERROR;
  78. }
  79. /*}}}*/
  80. // ServerState::HeaderLine - Process a header line /*{{{*/
  81. // ---------------------------------------------------------------------
  82. /* */
  83. bool ServerState::HeaderLine(string Line)
  84. {
  85. if (Line.empty() == true)
  86. return true;
  87. string::size_type Pos = Line.find(' ');
  88. if (Pos == string::npos || Pos+1 > Line.length())
  89. {
  90. // Blah, some servers use "connection:closes", evil.
  91. Pos = Line.find(':');
  92. if (Pos == string::npos || Pos + 2 > Line.length())
  93. return _error->Error(_("Bad header line"));
  94. Pos++;
  95. }
  96. // Parse off any trailing spaces between the : and the next word.
  97. string::size_type Pos2 = Pos;
  98. while (Pos2 < Line.length() && isspace_ascii(Line[Pos2]) != 0)
  99. Pos2++;
  100. string Tag = string(Line,0,Pos);
  101. string Val = string(Line,Pos2);
  102. if (stringcasecmp(Tag.c_str(),Tag.c_str()+4,"HTTP") == 0)
  103. {
  104. // Evil servers return no version
  105. if (Line[4] == '/')
  106. {
  107. int const elements = sscanf(Line.c_str(),"HTTP/%3u.%3u %3u%359[^\n]",&Major,&Minor,&Result,Code);
  108. if (elements == 3)
  109. {
  110. Code[0] = '\0';
  111. if (Owner != NULL && Owner->Debug == true)
  112. clog << "HTTP server doesn't give Reason-Phrase for " << Result << std::endl;
  113. }
  114. else if (elements != 4)
  115. return _error->Error(_("The HTTP server sent an invalid reply header"));
  116. }
  117. else
  118. {
  119. Major = 0;
  120. Minor = 9;
  121. if (sscanf(Line.c_str(),"HTTP %3u%359[^\n]",&Result,Code) != 2)
  122. return _error->Error(_("The HTTP server sent an invalid reply header"));
  123. }
  124. /* Check the HTTP response header to get the default persistence
  125. state. */
  126. if (Major < 1)
  127. Persistent = false;
  128. else
  129. {
  130. if (Major == 1 && Minor == 0)
  131. {
  132. Persistent = false;
  133. }
  134. else
  135. {
  136. Persistent = true;
  137. if (PipelineAllowed)
  138. Pipeline = true;
  139. }
  140. }
  141. return true;
  142. }
  143. if (stringcasecmp(Tag,"Content-Length:") == 0)
  144. {
  145. if (Encoding == Closes)
  146. Encoding = Stream;
  147. HaveContent = true;
  148. unsigned long long * DownloadSizePtr = &DownloadSize;
  149. if (Result == 416)
  150. DownloadSizePtr = &JunkSize;
  151. *DownloadSizePtr = strtoull(Val.c_str(), NULL, 10);
  152. if (*DownloadSizePtr >= std::numeric_limits<unsigned long long>::max())
  153. return _error->Errno("HeaderLine", _("The HTTP server sent an invalid Content-Length header"));
  154. else if (*DownloadSizePtr == 0)
  155. HaveContent = false;
  156. // On partial content (206) the Content-Length less than the real
  157. // size, so do not set it here but leave that to the Content-Range
  158. // header instead
  159. if(Result != 206 && TotalFileSize == 0)
  160. TotalFileSize = DownloadSize;
  161. return true;
  162. }
  163. if (stringcasecmp(Tag,"Content-Type:") == 0)
  164. {
  165. HaveContent = true;
  166. return true;
  167. }
  168. if (stringcasecmp(Tag,"Content-Range:") == 0)
  169. {
  170. HaveContent = true;
  171. // §14.16 says 'byte-range-resp-spec' should be a '*' in case of 416
  172. if (Result == 416 && sscanf(Val.c_str(), "bytes */%llu",&TotalFileSize) == 1)
  173. ; // we got the expected filesize which is all we wanted
  174. else if (sscanf(Val.c_str(),"bytes %llu-%*u/%llu",&StartPos,&TotalFileSize) != 2)
  175. return _error->Error(_("The HTTP server sent an invalid Content-Range header"));
  176. if ((unsigned long long)StartPos > TotalFileSize)
  177. return _error->Error(_("This HTTP server has broken range support"));
  178. // figure out what we will download
  179. DownloadSize = TotalFileSize - StartPos;
  180. return true;
  181. }
  182. if (stringcasecmp(Tag,"Transfer-Encoding:") == 0)
  183. {
  184. HaveContent = true;
  185. if (stringcasecmp(Val,"chunked") == 0)
  186. Encoding = Chunked;
  187. return true;
  188. }
  189. if (stringcasecmp(Tag,"Connection:") == 0)
  190. {
  191. if (stringcasecmp(Val,"close") == 0)
  192. Persistent = false;
  193. if (stringcasecmp(Val,"keep-alive") == 0)
  194. Persistent = true;
  195. return true;
  196. }
  197. if (stringcasecmp(Tag,"Last-Modified:") == 0)
  198. {
  199. if (RFC1123StrToTime(Val.c_str(), Date) == false)
  200. return _error->Error(_("Unknown date format"));
  201. return true;
  202. }
  203. if (stringcasecmp(Tag,"Location:") == 0)
  204. {
  205. Location = Val;
  206. return true;
  207. }
  208. return true;
  209. }
  210. /*}}}*/
  211. // ServerState::ServerState - Constructor /*{{{*/
  212. ServerState::ServerState(URI Srv, ServerMethod *Owner) :
  213. DownloadSize(0), ServerName(Srv), TimeOut(120), Owner(Owner)
  214. {
  215. Reset();
  216. }
  217. /*}}}*/
  218. bool ServerState::AddPartialFileToHashes(FileFd &File) /*{{{*/
  219. {
  220. File.Truncate(StartPos);
  221. return GetHashes()->AddFD(File, StartPos);
  222. }
  223. /*}}}*/
  224. // ServerMethod::DealWithHeaders - Handle the retrieved header data /*{{{*/
  225. // ---------------------------------------------------------------------
  226. /* We look at the header data we got back from the server and decide what
  227. to do. Returns DealWithHeadersResult (see http.h for details).
  228. */
  229. ServerMethod::DealWithHeadersResult
  230. ServerMethod::DealWithHeaders(FetchResult &Res)
  231. {
  232. // Not Modified
  233. if (Server->Result == 304)
  234. {
  235. RemoveFile("server", Queue->DestFile);
  236. Res.IMSHit = true;
  237. Res.LastModified = Queue->LastModified;
  238. return IMS_HIT;
  239. }
  240. /* Redirect
  241. *
  242. * Note that it is only OK for us to treat all redirection the same
  243. * because we *always* use GET, not other HTTP methods. There are
  244. * three redirection codes for which it is not appropriate that we
  245. * redirect. Pass on those codes so the error handling kicks in.
  246. */
  247. if (AllowRedirect
  248. && (Server->Result > 300 && Server->Result < 400)
  249. && (Server->Result != 300 // Multiple Choices
  250. && Server->Result != 304 // Not Modified
  251. && Server->Result != 306)) // (Not part of HTTP/1.1, reserved)
  252. {
  253. if (Server->Location.empty() == true);
  254. else if (Server->Location[0] == '/' && Queue->Uri.empty() == false)
  255. {
  256. URI Uri = Queue->Uri;
  257. if (Uri.Host.empty() == false)
  258. NextURI = URI::SiteOnly(Uri);
  259. else
  260. NextURI.clear();
  261. NextURI.append(DeQuoteString(Server->Location));
  262. return TRY_AGAIN_OR_REDIRECT;
  263. }
  264. else
  265. {
  266. NextURI = DeQuoteString(Server->Location);
  267. URI tmpURI = NextURI;
  268. URI Uri = Queue->Uri;
  269. // same protocol redirects are okay
  270. if (tmpURI.Access == Uri.Access)
  271. return TRY_AGAIN_OR_REDIRECT;
  272. // as well as http to https
  273. else if (Uri.Access == "http" && tmpURI.Access == "https")
  274. return TRY_AGAIN_OR_REDIRECT;
  275. }
  276. /* else pass through for error message */
  277. }
  278. // retry after an invalid range response without partial data
  279. else if (Server->Result == 416)
  280. {
  281. struct stat SBuf;
  282. if (stat(Queue->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
  283. {
  284. bool partialHit = false;
  285. if (Queue->ExpectedHashes.usable() == true)
  286. {
  287. Hashes resultHashes(Queue->ExpectedHashes);
  288. FileFd file(Queue->DestFile, FileFd::ReadOnly);
  289. Server->TotalFileSize = file.FileSize();
  290. Server->Date = file.ModificationTime();
  291. resultHashes.AddFD(file);
  292. HashStringList const hashList = resultHashes.GetHashStringList();
  293. partialHit = (Queue->ExpectedHashes == hashList);
  294. }
  295. else if ((unsigned long long)SBuf.st_size == Server->TotalFileSize)
  296. partialHit = true;
  297. if (partialHit == true)
  298. {
  299. // the file is completely downloaded, but was not moved
  300. if (Server->HaveContent == true)
  301. {
  302. // Send to error page to dev/null
  303. FileFd DevNull("/dev/null",FileFd::WriteExists);
  304. Server->RunData(&DevNull);
  305. }
  306. Server->HaveContent = false;
  307. Server->StartPos = Server->TotalFileSize;
  308. Server->Result = 200;
  309. }
  310. else if (RemoveFile("server", Queue->DestFile))
  311. {
  312. NextURI = Queue->Uri;
  313. return TRY_AGAIN_OR_REDIRECT;
  314. }
  315. }
  316. }
  317. /* We have a reply we don't handle. This should indicate a perm server
  318. failure */
  319. if (Server->Result < 200 || Server->Result >= 300)
  320. {
  321. std::string err;
  322. strprintf(err, "HttpError%u", Server->Result);
  323. SetFailReason(err);
  324. _error->Error("%u %s", Server->Result, Server->Code);
  325. if (Server->HaveContent == true)
  326. return ERROR_WITH_CONTENT_PAGE;
  327. return ERROR_UNRECOVERABLE;
  328. }
  329. // This is some sort of 2xx 'data follows' reply
  330. Res.LastModified = Server->Date;
  331. Res.Size = Server->TotalFileSize;
  332. // Open the file
  333. delete File;
  334. File = new FileFd(Queue->DestFile,FileFd::WriteAny);
  335. if (_error->PendingError() == true)
  336. return ERROR_NOT_FROM_SERVER;
  337. FailFile = Queue->DestFile;
  338. FailFile.c_str(); // Make sure we don't do a malloc in the signal handler
  339. FailFd = File->Fd();
  340. FailTime = Server->Date;
  341. if (Server->InitHashes(Queue->ExpectedHashes) == false || Server->AddPartialFileToHashes(*File) == false)
  342. {
  343. _error->Errno("read",_("Problem hashing file"));
  344. return ERROR_NOT_FROM_SERVER;
  345. }
  346. if (Server->StartPos > 0)
  347. Res.ResumePoint = Server->StartPos;
  348. SetNonBlock(File->Fd(),true);
  349. return FILE_IS_OPEN;
  350. }
  351. /*}}}*/
  352. // ServerMethod::SigTerm - Handle a fatal signal /*{{{*/
  353. // ---------------------------------------------------------------------
  354. /* This closes and timestamps the open file. This is necessary to get
  355. resume behavoir on user abort */
  356. void ServerMethod::SigTerm(int)
  357. {
  358. if (FailFd == -1)
  359. _exit(100);
  360. struct timeval times[2];
  361. times[0].tv_sec = FailTime;
  362. times[1].tv_sec = FailTime;
  363. times[0].tv_usec = times[1].tv_usec = 0;
  364. utimes(FailFile.c_str(), times);
  365. close(FailFd);
  366. _exit(100);
  367. }
  368. /*}}}*/
  369. // ServerMethod::Fetch - Fetch an item /*{{{*/
  370. // ---------------------------------------------------------------------
  371. /* This adds an item to the pipeline. We keep the pipeline at a fixed
  372. depth. */
  373. bool ServerMethod::Fetch(FetchItem *)
  374. {
  375. if (Server == nullptr || QueueBack == nullptr)
  376. return true;
  377. // If pipelining is disabled, we only queue 1 request
  378. auto const AllowedDepth = Server->Pipeline ? PipelineDepth : 0;
  379. // how deep is our pipeline currently?
  380. decltype(PipelineDepth) CurrentDepth = 0;
  381. for (FetchItem const *I = Queue; I != QueueBack; I = I->Next)
  382. ++CurrentDepth;
  383. do {
  384. // Make sure we stick with the same server
  385. if (Server->Comp(QueueBack->Uri) == false)
  386. break;
  387. bool const UsableHashes = QueueBack->ExpectedHashes.usable();
  388. // if we have no hashes, do at most one such request
  389. // as we can't fixup pipeling misbehaviors otherwise
  390. if (CurrentDepth != 0 && UsableHashes == false)
  391. break;
  392. if (UsableHashes && FileExists(QueueBack->DestFile))
  393. {
  394. FileFd partial(QueueBack->DestFile, FileFd::ReadOnly);
  395. Hashes wehave(QueueBack->ExpectedHashes);
  396. if (QueueBack->ExpectedHashes.FileSize() == partial.FileSize())
  397. {
  398. if (wehave.AddFD(partial) &&
  399. wehave.GetHashStringList() == QueueBack->ExpectedHashes)
  400. {
  401. FetchResult Res;
  402. Res.Filename = QueueBack->DestFile;
  403. Res.ResumePoint = QueueBack->ExpectedHashes.FileSize();
  404. URIStart(Res);
  405. // move item to the start of the queue as URIDone will
  406. // always dequeued the first item in the queue
  407. if (Queue != QueueBack)
  408. {
  409. FetchItem *Prev = Queue;
  410. for (; Prev->Next != QueueBack; Prev = Prev->Next)
  411. /* look for the previous queue item */;
  412. Prev->Next = QueueBack->Next;
  413. QueueBack->Next = Queue;
  414. Queue = QueueBack;
  415. QueueBack = Prev->Next;
  416. }
  417. Res.TakeHashes(wehave);
  418. URIDone(Res);
  419. continue;
  420. }
  421. else
  422. RemoveFile("Fetch-Partial", QueueBack->DestFile);
  423. }
  424. }
  425. auto const Tmp = QueueBack;
  426. QueueBack = QueueBack->Next;
  427. SendReq(Tmp);
  428. ++CurrentDepth;
  429. } while (CurrentDepth <= AllowedDepth && QueueBack != nullptr);
  430. return true;
  431. }
  432. /*}}}*/
  433. // ServerMethod::Loop - Main loop /*{{{*/
  434. int ServerMethod::Loop()
  435. {
  436. typedef vector<string> StringVector;
  437. typedef vector<string>::iterator StringVectorIterator;
  438. map<string, StringVector> Redirected;
  439. signal(SIGTERM,SigTerm);
  440. signal(SIGINT,SigTerm);
  441. Server = 0;
  442. int FailCounter = 0;
  443. while (1)
  444. {
  445. // We have no commands, wait for some to arrive
  446. if (Queue == 0)
  447. {
  448. if (WaitFd(STDIN_FILENO) == false)
  449. return 0;
  450. }
  451. /* Run messages, we can accept 0 (no message) if we didn't
  452. do a WaitFd above.. Otherwise the FD is closed. */
  453. int Result = Run(true);
  454. if (Result != -1 && (Result != 0 || Queue == 0))
  455. {
  456. if(FailReason.empty() == false ||
  457. _config->FindB("Acquire::http::DependOnSTDIN", true) == true)
  458. return 100;
  459. else
  460. return 0;
  461. }
  462. if (Queue == 0)
  463. continue;
  464. // Connect to the server
  465. if (Server == 0 || Server->Comp(Queue->Uri) == false)
  466. Server = CreateServerState(Queue->Uri);
  467. /* If the server has explicitly said this is the last connection
  468. then we pre-emptively shut down the pipeline and tear down
  469. the connection. This will speed up HTTP/1.0 servers a tad
  470. since we don't have to wait for the close sequence to
  471. complete */
  472. if (Server->Persistent == false)
  473. Server->Close();
  474. // Reset the pipeline
  475. if (Server->IsOpen() == false)
  476. QueueBack = Queue;
  477. // Connnect to the host
  478. if (Server->Open() == false)
  479. {
  480. Fail(true);
  481. Server = nullptr;
  482. continue;
  483. }
  484. // Fill the pipeline.
  485. Fetch(0);
  486. // Fetch the next URL header data from the server.
  487. switch (Server->RunHeaders(File, Queue->Uri))
  488. {
  489. case ServerState::RUN_HEADERS_OK:
  490. break;
  491. // The header data is bad
  492. case ServerState::RUN_HEADERS_PARSE_ERROR:
  493. {
  494. _error->Error(_("Bad header data"));
  495. Fail(true);
  496. RotateDNS();
  497. continue;
  498. }
  499. // The server closed a connection during the header get..
  500. default:
  501. case ServerState::RUN_HEADERS_IO_ERROR:
  502. {
  503. FailCounter++;
  504. _error->Discard();
  505. Server->Close();
  506. Server->Pipeline = false;
  507. Server->PipelineAllowed = false;
  508. if (FailCounter >= 2)
  509. {
  510. Fail(_("Connection failed"),true);
  511. FailCounter = 0;
  512. }
  513. RotateDNS();
  514. continue;
  515. }
  516. };
  517. // Decide what to do.
  518. FetchResult Res;
  519. Res.Filename = Queue->DestFile;
  520. switch (DealWithHeaders(Res))
  521. {
  522. // Ok, the file is Open
  523. case FILE_IS_OPEN:
  524. {
  525. URIStart(Res);
  526. // Run the data
  527. bool Result = true;
  528. // ensure we don't fetch too much
  529. // we could do "Server->MaximumSize = Queue->MaximumSize" here
  530. // but that would break the clever pipeline messup detection
  531. // so instead we use the size of the biggest item in the queue
  532. Server->MaximumSize = FindMaximumObjectSizeInQueue();
  533. if (Server->HaveContent)
  534. Result = Server->RunData(File);
  535. /* If the server is sending back sizeless responses then fill in
  536. the size now */
  537. if (Res.Size == 0)
  538. Res.Size = File->Size();
  539. // Close the file, destroy the FD object and timestamp it
  540. FailFd = -1;
  541. delete File;
  542. File = 0;
  543. // Timestamp
  544. struct timeval times[2];
  545. times[0].tv_sec = times[1].tv_sec = Server->Date;
  546. times[0].tv_usec = times[1].tv_usec = 0;
  547. utimes(Queue->DestFile.c_str(), times);
  548. // Send status to APT
  549. if (Result == true)
  550. {
  551. Hashes * const resultHashes = Server->GetHashes();
  552. HashStringList const hashList = resultHashes->GetHashStringList();
  553. if (PipelineDepth != 0 && Queue->ExpectedHashes.usable() == true && Queue->ExpectedHashes != hashList)
  554. {
  555. // we did not get the expected hash… mhhh:
  556. // could it be that server/proxy messed up pipelining?
  557. FetchItem * BeforeI = Queue;
  558. for (FetchItem *I = Queue->Next; I != 0 && I != QueueBack; I = I->Next)
  559. {
  560. if (I->ExpectedHashes.usable() == true && I->ExpectedHashes == hashList)
  561. {
  562. // yes, he did! Disable pipelining and rewrite queue
  563. if (Server->Pipeline == true)
  564. {
  565. // FIXME: fake a warning message as we have no proper way of communicating here
  566. std::string out;
  567. strprintf(out, _("Automatically disabled %s due to incorrect response from server/proxy. (man 5 apt.conf)"), "Acquire::http::PipelineDepth");
  568. std::cerr << "W: " << out << std::endl;
  569. Server->Pipeline = false;
  570. Server->PipelineAllowed = false;
  571. // we keep the PipelineDepth value so that the rest of the queue can be fixed up as well
  572. }
  573. Rename(Res.Filename, I->DestFile);
  574. Res.Filename = I->DestFile;
  575. BeforeI->Next = I->Next;
  576. I->Next = Queue;
  577. Queue = I;
  578. break;
  579. }
  580. BeforeI = I;
  581. }
  582. }
  583. Res.TakeHashes(*resultHashes);
  584. URIDone(Res);
  585. }
  586. else
  587. {
  588. if (Server->IsOpen() == false)
  589. {
  590. FailCounter++;
  591. _error->Discard();
  592. Server->Close();
  593. if (FailCounter >= 2)
  594. {
  595. Fail(_("Connection failed"),true);
  596. FailCounter = 0;
  597. }
  598. QueueBack = Queue;
  599. }
  600. else
  601. {
  602. Server->Close();
  603. Fail(true);
  604. }
  605. }
  606. break;
  607. }
  608. // IMS hit
  609. case IMS_HIT:
  610. {
  611. URIDone(Res);
  612. break;
  613. }
  614. // Hard server error, not found or something
  615. case ERROR_UNRECOVERABLE:
  616. {
  617. Fail();
  618. break;
  619. }
  620. // Hard internal error, kill the connection and fail
  621. case ERROR_NOT_FROM_SERVER:
  622. {
  623. delete File;
  624. File = 0;
  625. Fail();
  626. RotateDNS();
  627. Server->Close();
  628. break;
  629. }
  630. // We need to flush the data, the header is like a 404 w/ error text
  631. case ERROR_WITH_CONTENT_PAGE:
  632. {
  633. Fail();
  634. // Send to content to dev/null
  635. File = new FileFd("/dev/null",FileFd::WriteExists);
  636. Server->RunData(File);
  637. delete File;
  638. File = 0;
  639. break;
  640. }
  641. // Try again with a new URL
  642. case TRY_AGAIN_OR_REDIRECT:
  643. {
  644. // Clear rest of response if there is content
  645. if (Server->HaveContent)
  646. {
  647. File = new FileFd("/dev/null",FileFd::WriteExists);
  648. Server->RunData(File);
  649. delete File;
  650. File = 0;
  651. }
  652. /* Detect redirect loops. No more redirects are allowed
  653. after the same URI is seen twice in a queue item. */
  654. StringVector &R = Redirected[Queue->DestFile];
  655. bool StopRedirects = false;
  656. if (R.empty() == true)
  657. R.push_back(Queue->Uri);
  658. else if (R[0] == "STOP" || R.size() > 10)
  659. StopRedirects = true;
  660. else
  661. {
  662. for (StringVectorIterator I = R.begin(); I != R.end(); ++I)
  663. if (Queue->Uri == *I)
  664. {
  665. R[0] = "STOP";
  666. break;
  667. }
  668. R.push_back(Queue->Uri);
  669. }
  670. if (StopRedirects == false)
  671. Redirect(NextURI);
  672. else
  673. Fail();
  674. break;
  675. }
  676. default:
  677. Fail(_("Internal error"));
  678. break;
  679. }
  680. FailCounter = 0;
  681. }
  682. return 0;
  683. }
  684. /*}}}*/
  685. unsigned long long ServerMethod::FindMaximumObjectSizeInQueue() const /*{{{*/
  686. {
  687. unsigned long long MaxSizeInQueue = 0;
  688. for (FetchItem *I = Queue; I != 0 && I != QueueBack; I = I->Next)
  689. MaxSizeInQueue = std::max(MaxSizeInQueue, I->MaximumSize);
  690. return MaxSizeInQueue;
  691. }
  692. /*}}}*/
  693. ServerMethod::ServerMethod(char const * const Binary, char const * const Ver,unsigned long const Flags) :/*{{{*/
  694. aptMethod(Binary, Ver, Flags), Server(nullptr), File(NULL), PipelineDepth(10),
  695. AllowRedirect(false), Debug(false)
  696. {
  697. }
  698. /*}}}*/