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