git.saurik.com Git - apt.git/blob

1 // -*- mode: cpp; mode: fold -*-

2 // Description /*{{{*/

3 /* ######################################################################

5 HTTP and HTTPS share a lot of common code and these classes are

6 exactly the dumping ground for this common code

8 ##################################################################### */

9 /*}}}*/

10 // Include Files /*{{{*/

11 #include <config.h>

13 #include <apt-pkg/configuration.h>

14 #include <apt-pkg/error.h>

15 #include <apt-pkg/fileutl.h>

16 #include <apt-pkg/strutl.h>

18 #include <ctype.h>

19 #include <signal.h>

20 #include <stdio.h>

21 #include <stdlib.h>

22 #include <sys/stat.h>

23 #include <sys/time.h>

24 #include <time.h>

25 #include <unistd.h>

26 #include <iostream>

27 #include <limits>

28 #include <map>

29 #include <string>

30 #include <vector>

32 #include "server.h"

34 #include <apti18n.h>

35 /*}}}*/

36 using namespace std;

38 string ServerMethod::FailFile;

 int ServerMethod::FailFd = -1;

 time_t ServerMethod::FailTime = 0;

42 // ServerState::RunHeaders - Get the headers before the data /*{{{*/

43 // ---------------------------------------------------------------------

44 /* Returns 0 if things are OK, 1 if an IO error occurred and 2 if a header

45 parse error occurred */

 ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File,

                                                       const std::string &Uri)

48 {

49 Reset(false);

    Owner->Status(_("Waiting for headers"));

52 do

53 {

54 string Data;

       if (ReadHeaderLines(Data) == false)

56 continue;

       if (Owner->Debug == true)

          clog << "Answer for: " << Uri << endl << Data;

       for (string::const_iterator I = Data.begin(); I < Data.end(); ++I)

62 {

63 string::const_iterator J = I;

          for (; J != Data.end() && *J != '\n' && *J != '\r'; ++J);

          if (HeaderLine(string(I,J)) == false)

66 return RUN_HEADERS_PARSE_ERROR;

67 I = J;

68 }

70 // 100 Continue is a Nop...

       if (Result == 100)

72 continue;

74 // Tidy up the connection persistence state.

       if (Encoding == Closes && HaveContent == true)

76 Persistent = false;

78 return RUN_HEADERS_OK;

79 }

    while (LoadNextResponse(false, File) == true);

82 return RUN_HEADERS_IO_ERROR;

83 }

84 /*}}}*/

85 // ServerState::HeaderLine - Process a header line /*{{{*/

86 // ---------------------------------------------------------------------

87 /* */

 bool ServerState::HeaderLine(string Line)

89 {

    if (Line.empty() == true)

91 return true;

    if (Line.size() > 4 && stringcasecmp(Line.data(), Line.data()+4, "HTTP") == 0)

94 {

95 // Evil servers return no version

       if (Line[4] == '/')

97 {

          int const elements = sscanf(Line.c_str(),"HTTP/%3u.%3u %3u%359[^\n]",&Major,&Minor,&Result,Code);

          if (elements == 3)

100 {

             Code[0] = '\0';

             if (Owner != NULL && Owner->Debug == true)

                clog << "HTTP server doesn't give Reason-Phrase for " << std::to_string(Result) << std::endl;

104 }

          else if (elements != 4)

             return _error->Error(_("The HTTP server sent an invalid reply header"));

107 }

108 else

109 {

110 Major = 0;

111 Minor = 9;

          if (sscanf(Line.c_str(),"HTTP %3u%359[^\n]",&Result,Code) != 2)

             return _error->Error(_("The HTTP server sent an invalid reply header"));

114 }

115

116 /* Check the HTTP response header to get the default persistence

117 state. */

       if (Major < 1)

119 Persistent = false;

120 else

121 {

          if (Major == 1 && Minor == 0)

123 {

124 Persistent = false;

125 }

126 else

127 {

128 Persistent = true;

129 if (PipelineAllowed)

130 Pipeline = true;

131 }

132 }

133

134 return true;

135 }

136

137 // Blah, some servers use "connection:closes", evil.

138 // and some even send empty header fields…

    string::size_type Pos = Line.find(':');

    if (Pos == string::npos)

       return _error->Error(_("Bad header line"));

142 ++Pos;

143

144 // Parse off any trailing spaces between the : and the next word.

145 string::size_type Pos2 = Pos;

    while (Pos2 < Line.length() && isspace_ascii(Line[Pos2]) != 0)

147 Pos2++;

148

    string const Tag(Line,0,Pos);

    string const Val(Line,Pos2);

151

    if (stringcasecmp(Tag,"Content-Length:") == 0)

153 {

154 if (Encoding == Closes)

155 Encoding = Stream;

156 HaveContent = true;

157

158 unsigned long long * DownloadSizePtr = &DownloadSize;

       if (Result == 416 || (Result >= 300 && Result < 400))

160 DownloadSizePtr = &JunkSize;

161

       *DownloadSizePtr = strtoull(Val.c_str(), NULL, 10);

       if (*DownloadSizePtr >= std::numeric_limits<unsigned long long>::max())

          return _error->Errno("HeaderLine", _("The HTTP server sent an invalid Content-Length header"));

       else if (*DownloadSizePtr == 0)

166 HaveContent = false;

167

168 // On partial content (206) the Content-Length less than the real

169 // size, so do not set it here but leave that to the Content-Range

170 // header instead

       if(Result != 206 && TotalFileSize == 0)

172 TotalFileSize = DownloadSize;

173

174 return true;

175 }

176

    if (stringcasecmp(Tag,"Content-Type:") == 0)

178 {

179 HaveContent = true;

180 return true;

181 }

182

    if (stringcasecmp(Tag,"Content-Range:") == 0)

184 {

185 HaveContent = true;

186

187 // §14.16 says 'byte-range-resp-spec' should be a '*' in case of 416

       if (Result == 416 && sscanf(Val.c_str(), "bytes */%llu",&TotalFileSize) == 1)

189 ; // we got the expected filesize which is all we wanted

       else if (sscanf(Val.c_str(),"bytes %llu-%*u/%llu",&StartPos,&TotalFileSize) != 2)

          return _error->Error(_("The HTTP server sent an invalid Content-Range header"));

       if ((unsigned long long)StartPos > TotalFileSize)

          return _error->Error(_("This HTTP server has broken range support"));

194

195 // figure out what we will download

196 DownloadSize = TotalFileSize - StartPos;

197 return true;

198 }

199

    if (stringcasecmp(Tag,"Transfer-Encoding:") == 0)

201 {

202 HaveContent = true;

       if (stringcasecmp(Val,"chunked") == 0)

204 Encoding = Chunked;

205 return true;

206 }

207

    if (stringcasecmp(Tag,"Connection:") == 0)

209 {

       if (stringcasecmp(Val,"close") == 0)

211 {

212 Persistent = false;

213 Pipeline = false;

214 /* Some servers send error pages (as they are dynamically generated)

215 for simplicity via a connection close instead of e.g. chunked,

216 so assuming an always closing server only if we get a file + close */

          if (Result >= 200 && Result < 300)

218 PipelineAllowed = false;

219 }

       else if (stringcasecmp(Val,"keep-alive") == 0)

221 Persistent = true;

222 return true;

223 }

224

    if (stringcasecmp(Tag,"Last-Modified:") == 0)

226 {

       if (RFC1123StrToTime(Val.c_str(), Date) == false)

          return _error->Error(_("Unknown date format"));

229 return true;

230 }

231

    if (stringcasecmp(Tag,"Location:") == 0)

233 {

234 Location = Val;

235 return true;

236 }

237

    if (stringcasecmp(Tag, "Accept-Ranges:") == 0)

239 {

       std::string ranges = ',' + Val + ',';

       ranges.erase(std::remove(ranges.begin(), ranges.end(), ' '), ranges.end());

       if (ranges.find(",bytes,") == std::string::npos)

243 RangesAllowed = false;

244 return true;

245 }

246

247 return true;

248 }

249 /*}}}*/

250 // ServerState::ServerState - Constructor /*{{{*/

 ServerState::ServerState(URI Srv, ServerMethod *Owner) :

    DownloadSize(0), ServerName(Srv), TimeOut(120), Owner(Owner)

253 {

254 Reset();

255 }

256 /*}}}*/

 bool ServerState::AddPartialFileToHashes(FileFd &File)                  /*{{{*/

258 {

259 File.Truncate(StartPos);

    return GetHashes()->AddFD(File, StartPos);

261 }

262 /*}}}*/

 void ServerState::Reset(bool const Everything)                          /*{{{*/

264 {

    Major = 0; Minor = 0; Result = 0; Code[0] = '\0';

    TotalFileSize = 0; JunkSize = 0; StartPos = 0;

    Encoding = Closes; time(&Date); HaveContent = false;

    State = Header; MaximumSize = 0;

269 if (Everything)

270 {

       Persistent = false; Pipeline = false; PipelineAllowed = true;

272 RangesAllowed = true;

273 }

274 }

275 /*}}}*/

276

277 // ServerMethod::DealWithHeaders - Handle the retrieved header data /*{{{*/

278 // ---------------------------------------------------------------------

279 /* We look at the header data we got back from the server and decide what

280 to do. Returns DealWithHeadersResult (see http.h for details).

281 */

282 ServerMethod::DealWithHeadersResult

 ServerMethod::DealWithHeaders(FetchResult &Res)

284 {

285 // Not Modified

    if (Server->Result == 304)

287 {

       RemoveFile("server", Queue->DestFile);

289 Res.IMSHit = true;

290 Res.LastModified = Queue->LastModified;

291 Res.Size = 0;

292 return IMS_HIT;

293 }

294

295 /* Redirect

296 *

297 * Note that it is only OK for us to treat all redirection the same

298 * because we *always* use GET, not other HTTP methods. There are

299 * three redirection codes for which it is not appropriate that we

300 * redirect. Pass on those codes so the error handling kicks in.

301 */

302 if (AllowRedirect

        && (Server->Result > 300 && Server->Result < 400)

        && (Server->Result != 300       // Multiple Choices

            && Server->Result != 304    // Not Modified

            && Server->Result != 306))  // (Not part of HTTP/1.1, reserved)

307 {

       if (Server->Location.empty() == true)

309 ;

       else if (Server->Location[0] == '/' && Queue->Uri.empty() == false)

311 {

312 URI Uri = Queue->Uri;

          if (Uri.Host.empty() == false)

             NextURI = URI::SiteOnly(Uri);

315 else

316 NextURI.clear();

          NextURI.append(DeQuoteString(Server->Location));

          if (Queue->Uri == NextURI)

319 {

320 SetFailReason("RedirectionLoop");

             _error->Error("Redirection loop encountered");

             if (Server->HaveContent == true)

323 return ERROR_WITH_CONTENT_PAGE;

324 return ERROR_UNRECOVERABLE;

325 }

326 return TRY_AGAIN_OR_REDIRECT;

327 }

328 else

329 {

          NextURI = DeQuoteString(Server->Location);

331 URI tmpURI = NextURI;

          if (tmpURI.Access.find('+') != std::string::npos)

333 {

             _error->Error("Server tried to trick us into using a specific implementation: %s", tmpURI.Access.c_str());

             if (Server->HaveContent == true)

336 return ERROR_WITH_CONTENT_PAGE;

337 return ERROR_UNRECOVERABLE;

338 }

339 URI Uri = Queue->Uri;

          if (Binary.find('+') != std::string::npos)

341 {

             auto base = Binary.substr(0, Binary.find('+'));

             if (base != tmpURI.Access)

344 {

                tmpURI.Access = base + '+' + tmpURI.Access;

                if (tmpURI.Access == Binary)

347 {

                   std::string tmpAccess = Uri.Access;

                   std::swap(tmpURI.Access, Uri.Access);

350 NextURI = tmpURI;

                   std::swap(tmpURI.Access, Uri.Access);

352 }

353 else

354 NextURI = tmpURI;

355 }

356 }

          if (Queue->Uri == NextURI)

358 {

359 SetFailReason("RedirectionLoop");

             _error->Error("Redirection loop encountered");

             if (Server->HaveContent == true)

362 return ERROR_WITH_CONTENT_PAGE;

363 return ERROR_UNRECOVERABLE;

364 }

365 Uri.Access = Binary;

366 // same protocol redirects are okay

          if (tmpURI.Access == Uri.Access)

368 return TRY_AGAIN_OR_REDIRECT;

369 // as well as http to https

          else if ((Uri.Access == "http" || Uri.Access == "https+http") && tmpURI.Access == "https")

371 return TRY_AGAIN_OR_REDIRECT;

372 else

373 {

             auto const tmpplus = tmpURI.Access.find('+');

             if (tmpplus != std::string::npos && tmpURI.Access.substr(tmpplus + 1) == "https")

376 {

                auto const uriplus = Uri.Access.find('+');

                if (uriplus == std::string::npos)

379 {

                   if (Uri.Access == tmpURI.Access.substr(0, tmpplus)) // foo -> foo+https

381 return TRY_AGAIN_OR_REDIRECT;

382 }

                else if (Uri.Access.substr(uriplus + 1) == "http" &&

                      Uri.Access.substr(0, uriplus) == tmpURI.Access.substr(0, tmpplus)) // foo+http -> foo+https

385 return TRY_AGAIN_OR_REDIRECT;

386 }

387 }

          _error->Error("Redirection from %s to '%s' is forbidden", Uri.Access.c_str(), NextURI.c_str());

389 }

390 /* else pass through for error message */

391 }

392 // retry after an invalid range response without partial data

    else if (Server->Result == 416)

394 {

395 struct stat SBuf;

       if (stat(Queue->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)

397 {

398 bool partialHit = false;

          if (Queue->ExpectedHashes.usable() == true)

400 {

401 Hashes resultHashes(Queue->ExpectedHashes);

             FileFd file(Queue->DestFile, FileFd::ReadOnly);

             Server->TotalFileSize = file.FileSize();

             Server->Date = file.ModificationTime();

405 resultHashes.AddFD(file);

             HashStringList const hashList = resultHashes.GetHashStringList();

407 partialHit = (Queue->ExpectedHashes == hashList);

408 }

          else if ((unsigned long long)SBuf.st_size == Server->TotalFileSize)

410 partialHit = true;

          if (partialHit == true)

412 {

413 // the file is completely downloaded, but was not moved

             if (Server->HaveContent == true)

415 {

416 // nuke the sent error page

417 Server->RunDataToDevNull();

418 Server->HaveContent = false;

419 }

420 Server->StartPos = Server->TotalFileSize;

421 Server->Result = 200;

422 }

          else if (RemoveFile("server", Queue->DestFile))

424 {

425 NextURI = Queue->Uri;

426 return TRY_AGAIN_OR_REDIRECT;

427 }

428 }

429 }

430

431 /* We have a reply we don't handle. This should indicate a perm server

432 failure */

    if (Server->Result < 200 || Server->Result >= 300)

434 {

       if (_error->PendingError() == false)

436 {

437 std::string err;

          strprintf(err, "HttpError%u", Server->Result);

439 SetFailReason(err);

          _error->Error("%u %s", Server->Result, Server->Code);

441 }

       if (Server->HaveContent == true)

443 return ERROR_WITH_CONTENT_PAGE;

444 return ERROR_UNRECOVERABLE;

445 }

446

447 // This is some sort of 2xx 'data follows' reply

448 Res.LastModified = Server->Date;

449 Res.Size = Server->TotalFileSize;

450 return FILE_IS_OPEN;

451 }

452 /*}}}*/

453 // ServerMethod::SigTerm - Handle a fatal signal /*{{{*/

454 // ---------------------------------------------------------------------

455 /* This closes and timestamps the open file. This is necessary to get

456 resume behavoir on user abort */

 void ServerMethod::SigTerm(int)

458 {

    if (FailFd == -1)

460 _exit(100);

461

462 struct timeval times[2];

    times[0].tv_sec = FailTime;

    times[1].tv_sec = FailTime;

    times[0].tv_usec = times[1].tv_usec = 0;

    utimes(FailFile.c_str(), times);

467 close(FailFd);

468

469 _exit(100);

470 }

471 /*}}}*/

472 // ServerMethod::Fetch - Fetch an item /*{{{*/

473 // ---------------------------------------------------------------------

474 /* This adds an item to the pipeline. We keep the pipeline at a fixed

475 depth. */

 bool ServerMethod::Fetch(FetchItem *)

477 {

    if (Server == nullptr || QueueBack == nullptr)

479 return true;

480

481 // If pipelining is disabled, we only queue 1 request

    auto const AllowedDepth = Server->Pipeline ? PipelineDepth : 0;

483 // how deep is our pipeline currently?

    decltype(PipelineDepth) CurrentDepth = 0;

    for (FetchItem const *I = Queue; I != QueueBack; I = I->Next)

486 ++CurrentDepth;

487 if (CurrentDepth > AllowedDepth)

488 return true;

489

490 do {

491 // Make sure we stick with the same server

       if (Server->Comp(QueueBack->Uri) == false)

493 break;

494

       bool const UsableHashes = QueueBack->ExpectedHashes.usable();

496 // if we have no hashes, do at most one such request

497 // as we can't fixup pipeling misbehaviors otherwise

       if (CurrentDepth != 0 && UsableHashes == false)

499 break;

500

       if (UsableHashes && FileExists(QueueBack->DestFile))

502 {

          FileFd partial(QueueBack->DestFile, FileFd::ReadOnly);

504 Hashes wehave(QueueBack->ExpectedHashes);

          if (QueueBack->ExpectedHashes.FileSize() == partial.FileSize())

506 {

             if (wehave.AddFD(partial) &&

                   wehave.GetHashStringList() == QueueBack->ExpectedHashes)

509 {

510 FetchResult Res;

511 Res.Filename = QueueBack->DestFile;

                Res.ResumePoint = QueueBack->ExpectedHashes.FileSize();

513 URIStart(Res);

514 // move item to the start of the queue as URIDone will

515 // always dequeued the first item in the queue

516 if (Queue != QueueBack)

517 {

518 FetchItem *Prev = Queue;

                   for (; Prev->Next != QueueBack; Prev = Prev->Next)

520 /* look for the previous queue item */;

521 Prev->Next = QueueBack->Next;

522 QueueBack->Next = Queue;

523 Queue = QueueBack;

524 QueueBack = Prev->Next;

525 }

526 Res.TakeHashes(wehave);

527 URIDone(Res);

528 continue;

529 }

530 else

                RemoveFile("Fetch-Partial", QueueBack->DestFile);

532 }

533 }

534 auto const Tmp = QueueBack;

535 QueueBack = QueueBack->Next;

536 SendReq(Tmp);

537 ++CurrentDepth;

    } while (CurrentDepth <= AllowedDepth && QueueBack != nullptr);

539

540 return true;

541 }

542 /*}}}*/

543 // ServerMethod::Loop - Main loop /*{{{*/

 int ServerMethod::Loop()

545 {

546 signal(SIGTERM,SigTerm);

547 signal(SIGINT,SigTerm);

548

549 Server = 0;

550

551 int FailCounter = 0;

552 while (1)

553 {

554 // We have no commands, wait for some to arrive

       if (Queue == 0)

556 {

          if (WaitFd(STDIN_FILENO) == false)

558 return 0;

559 }

560

561 /* Run messages, we can accept 0 (no message) if we didn't

562 do a WaitFd above.. Otherwise the FD is closed. */

       int Result = Run(true);

       if (Result != -1 && (Result != 0 || Queue == 0))

565 {

          if(FailReason.empty() == false ||

             ConfigFindB("DependOnSTDIN", true) == true)

568 return 100;

569 else

570 return 0;

571 }

572

       if (Queue == 0)

574 continue;

575

576 // Connect to the server

       if (Server == 0 || Server->Comp(Queue->Uri) == false)

578 {

          Server = CreateServerState(Queue->Uri);

          setPostfixForMethodNames(::URI(Queue->Uri).Host.c_str());

          AllowRedirect = ConfigFindB("AllowRedirect", true);

          PipelineDepth = ConfigFindI("Pipeline-Depth", 10);

583 Debug = DebugEnabled();

584 }

585

586 /* If the server has explicitly said this is the last connection

587 then we pre-emptively shut down the pipeline and tear down

588 the connection. This will speed up HTTP/1.0 servers a tad

589 since we don't have to wait for the close sequence to

590 complete */

       if (Server->Persistent == false)

592 Server->Close();

593

594 // Reset the pipeline

       if (Server->IsOpen() == false)

596 QueueBack = Queue;

597

598 // Connnect to the host

       if (Server->Open() == false)

600 {

601 Fail(true);

602 Server = nullptr;

603 continue;

604 }

605

606 // Fill the pipeline.

607 Fetch(0);

608

609 // Fetch the next URL header data from the server.

       switch (Server->RunHeaders(File, Queue->Uri))

611 {

612 case ServerState::RUN_HEADERS_OK:

613 break;

614

615 // The header data is bad

616 case ServerState::RUN_HEADERS_PARSE_ERROR:

617 {

             _error->Error(_("Bad header data"));

619 Fail(true);

620 Server->Close();

621 RotateDNS();

622 continue;

623 }

624

625 // The server closed a connection during the header get..

626 default:

627 case ServerState::RUN_HEADERS_IO_ERROR:

628 {

629 FailCounter++;

630 _error->Discard();

631 Server->Close();

632 Server->Pipeline = false;

633 Server->PipelineAllowed = false;

634

             if (FailCounter >= 2)

636 {

                Fail(_("Connection failed"),true);

638 FailCounter = 0;

639 }

640

641 RotateDNS();

642 continue;

643 }

644 };

645

646 // Decide what to do.

647 FetchResult Res;

648 Res.Filename = Queue->DestFile;

       switch (DealWithHeaders(Res))

650 {

651 // Ok, the file is Open

652 case FILE_IS_OPEN:

653 {

654 URIStart(Res);

655

656 // Run the data

657 bool Result = true;

658

659 // ensure we don't fetch too much

660 // we could do "Server->MaximumSize = Queue->MaximumSize" here

661 // but that would break the clever pipeline messup detection

662 // so instead we use the size of the biggest item in the queue

663 Server->MaximumSize = FindMaximumObjectSizeInQueue();

664

665 if (Server->HaveContent)

                Result = Server->RunData(File);

667

668 /* If the server is sending back sizeless responses then fill in

669 the size now */

             if (Res.Size == 0)

                Res.Size = File->Size();

672

673 // Close the file, destroy the FD object and timestamp it

674 FailFd = -1;

675 delete File;

676 File = 0;

677

678 // Timestamp

679 struct timeval times[2];

             times[0].tv_sec = times[1].tv_sec = Server->Date;

             times[0].tv_usec = times[1].tv_usec = 0;

             utimes(Queue->DestFile.c_str(), times);

683

684 // Send status to APT

             if (Result == true)

686 {

                Hashes * const resultHashes = Server->GetHashes();

                HashStringList const hashList = resultHashes->GetHashStringList();

                if (PipelineDepth != 0 && Queue->ExpectedHashes.usable() == true && Queue->ExpectedHashes != hashList)

690 {

691 // we did not get the expected hash… mhhh:

692 // could it be that server/proxy messed up pipelining?

693 FetchItem * BeforeI = Queue;

                   for (FetchItem *I = Queue->Next; I != 0 && I != QueueBack; I = I->Next)

695 {

                      if (I->ExpectedHashes.usable() == true && I->ExpectedHashes == hashList)

697 {

698 // yes, he did! Disable pipelining and rewrite queue

                         if (Server->Pipeline == true)

700 {

                            Warning(_("Automatically disabled %s due to incorrect response from server/proxy. (man 5 apt.conf)"), "Acquire::http::Pipeline-Depth");

702 Server->Pipeline = false;

703 Server->PipelineAllowed = false;

704 // we keep the PipelineDepth value so that the rest of the queue can be fixed up as well

705 }

                         Rename(Res.Filename, I->DestFile);

707 Res.Filename = I->DestFile;

708 BeforeI->Next = I->Next;

709 I->Next = Queue;

710 Queue = I;

711 break;

712 }

713 BeforeI = I;

714 }

715 }

716 Res.TakeHashes(*resultHashes);

717 URIDone(Res);

718 }

719 else

720 {

                if (Server->IsOpen() == false)

722 {

723 FailCounter++;

724 _error->Discard();

725 Server->Close();

726

                   if (FailCounter >= 2)

728 {

                      Fail(_("Connection failed"),true);

730 FailCounter = 0;

731 }

732

733 QueueBack = Queue;

734 }

735 else

736 {

737 Server->Close();

738 Fail(true);

739 }

740 }

741 break;

742 }

743

744 // IMS hit

745 case IMS_HIT:

746 {

747 URIDone(Res);

748 break;

749 }

750

751 // Hard server error, not found or something

752 case ERROR_UNRECOVERABLE:

753 {

754 Fail();

755 break;

756 }

757

758 // Hard internal error, kill the connection and fail

759 case ERROR_NOT_FROM_SERVER:

760 {

761 delete File;

762 File = 0;

763

764 Fail();

765 RotateDNS();

766 Server->Close();

767 break;

768 }

769

770 // We need to flush the data, the header is like a 404 w/ error text

771 case ERROR_WITH_CONTENT_PAGE:

772 {

773 Server->RunDataToDevNull();

774 Fail();

775 break;

776 }

777

778 // Try again with a new URL

779 case TRY_AGAIN_OR_REDIRECT:

780 {

781 // Clear rest of response if there is content

782 if (Server->HaveContent)

783 Server->RunDataToDevNull();

784 Redirect(NextURI);

785 break;

786 }

787

788 default:

          Fail(_("Internal error"));

790 break;

791 }

792

793 FailCounter = 0;

794 }

795

796 return 0;

797 }

798 /*}}}*/

 unsigned long long ServerMethod::FindMaximumObjectSizeInQueue() const   /*{{{*/

800 {

801 unsigned long long MaxSizeInQueue = 0;

    for (FetchItem *I = Queue; I != 0 && I != QueueBack; I = I->Next)

       MaxSizeInQueue = std::max(MaxSizeInQueue, I->MaximumSize);

804 return MaxSizeInQueue;

805 }

806 /*}}}*/

 ServerMethod::ServerMethod(std::string &&Binary, char const * const Ver,unsigned long const Flags) :/*{{{*/

    aptMethod(std::move(Binary), Ver, Flags), Server(nullptr), File(NULL), PipelineDepth(10),

    AllowRedirect(false), Debug(false)

810 {

811 }

812 /*}}}*/

 bool ServerMethod::Configuration(std::string Message)                   /*{{{*/

814 {

    if (aptMethod::Configuration(Message) == false)

816 return false;

817

    _config->CndSet("Acquire::tor::Proxy",

819 "socks5h://apt-transport-tor@localhost:9050");

820 return true;

821 }

822 /*}}}*/

 bool ServerMethod::AddProxyAuth(URI &Proxy, URI const &Server) const    /*{{{*/

824 {

    if (std::find(methodNames.begin(), methodNames.end(), "tor") != methodNames.end() &&

          Proxy.User == "apt-transport-tor" && Proxy.Password.empty())

827 {

       std::string pass = Server.Host;

       pass.erase(std::remove_if(pass.begin(), pass.end(), [](char const c) { return std::isalnum(c) == 0; }), pass.end());

       if (pass.length() > 255)

          Proxy.Password = pass.substr(0, 255);

832 else

          Proxy.Password = std::move(pass);

834 }

835 // FIXME: should we support auth.conf for proxies?

836 return true;

837 }

838 /*}}}*/