]> git.saurik.com Git - apt.git/blob - methods/server.cc
672a3d16dd72a55aa796a7b91c1f984380cef74e
[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 if (Queue->Uri == NextURI)
301 {
302 SetFailReason("RedirectionLoop");
303 _error->Error("Redirection loop encountered");
304 if (Server->HaveContent == true)
305 return ERROR_WITH_CONTENT_PAGE;
306 return ERROR_UNRECOVERABLE;
307 }
308 return TRY_AGAIN_OR_REDIRECT;
309 }
310 else
311 {
312 NextURI = DeQuoteString(Server->Location);
313 URI tmpURI = NextURI;
314 if (tmpURI.Access == "http" && Binary == "https+http")
315 {
316 tmpURI.Access = "https+http";
317 NextURI = tmpURI;
318 }
319 if (Queue->Uri == NextURI)
320 {
321 SetFailReason("RedirectionLoop");
322 _error->Error("Redirection loop encountered");
323 if (Server->HaveContent == true)
324 return ERROR_WITH_CONTENT_PAGE;
325 return ERROR_UNRECOVERABLE;
326 }
327 URI Uri = Queue->Uri;
328 // same protocol redirects are okay
329 if (tmpURI.Access == Uri.Access)
330 return TRY_AGAIN_OR_REDIRECT;
331 // as well as http to https
332 else if (Uri.Access == "http" && tmpURI.Access == "https")
333 return TRY_AGAIN_OR_REDIRECT;
334 }
335 /* else pass through for error message */
336 }
337 // retry after an invalid range response without partial data
338 else if (Server->Result == 416)
339 {
340 struct stat SBuf;
341 if (stat(Queue->DestFile.c_str(),&SBuf) >= 0 && SBuf.st_size > 0)
342 {
343 bool partialHit = false;
344 if (Queue->ExpectedHashes.usable() == true)
345 {
346 Hashes resultHashes(Queue->ExpectedHashes);
347 FileFd file(Queue->DestFile, FileFd::ReadOnly);
348 Server->TotalFileSize = file.FileSize();
349 Server->Date = file.ModificationTime();
350 resultHashes.AddFD(file);
351 HashStringList const hashList = resultHashes.GetHashStringList();
352 partialHit = (Queue->ExpectedHashes == hashList);
353 }
354 else if ((unsigned long long)SBuf.st_size == Server->TotalFileSize)
355 partialHit = true;
356 if (partialHit == true)
357 {
358 // the file is completely downloaded, but was not moved
359 if (Server->HaveContent == true)
360 {
361 // Send to error page to dev/null
362 FileFd DevNull("/dev/null",FileFd::WriteExists);
363 Server->RunData(&DevNull);
364 }
365 Server->HaveContent = false;
366 Server->StartPos = Server->TotalFileSize;
367 Server->Result = 200;
368 }
369 else if (RemoveFile("server", Queue->DestFile))
370 {
371 NextURI = Queue->Uri;
372 return TRY_AGAIN_OR_REDIRECT;
373 }
374 }
375 }
376
377 /* We have a reply we don't handle. This should indicate a perm server
378 failure */
379 if (Server->Result < 200 || Server->Result >= 300)
380 {
381 std::string err;
382 strprintf(err, "HttpError%u", Server->Result);
383 SetFailReason(err);
384 _error->Error("%u %s", Server->Result, Server->Code);
385 if (Server->HaveContent == true)
386 return ERROR_WITH_CONTENT_PAGE;
387 return ERROR_UNRECOVERABLE;
388 }
389
390 // This is some sort of 2xx 'data follows' reply
391 Res.LastModified = Server->Date;
392 Res.Size = Server->TotalFileSize;
393
394 // Open the file
395 delete File;
396 File = new FileFd(Queue->DestFile,FileFd::WriteAny);
397 if (_error->PendingError() == true)
398 return ERROR_NOT_FROM_SERVER;
399
400 FailFile = Queue->DestFile;
401 FailFile.c_str(); // Make sure we don't do a malloc in the signal handler
402 FailFd = File->Fd();
403 FailTime = Server->Date;
404
405 if (Server->InitHashes(Queue->ExpectedHashes) == false || Server->AddPartialFileToHashes(*File) == false)
406 {
407 _error->Errno("read",_("Problem hashing file"));
408 return ERROR_NOT_FROM_SERVER;
409 }
410 if (Server->StartPos > 0)
411 Res.ResumePoint = Server->StartPos;
412
413 SetNonBlock(File->Fd(),true);
414 return FILE_IS_OPEN;
415 }
416 /*}}}*/
417 // ServerMethod::SigTerm - Handle a fatal signal /*{{{*/
418 // ---------------------------------------------------------------------
419 /* This closes and timestamps the open file. This is necessary to get
420 resume behavoir on user abort */
421 void ServerMethod::SigTerm(int)
422 {
423 if (FailFd == -1)
424 _exit(100);
425
426 struct timeval times[2];
427 times[0].tv_sec = FailTime;
428 times[1].tv_sec = FailTime;
429 times[0].tv_usec = times[1].tv_usec = 0;
430 utimes(FailFile.c_str(), times);
431 close(FailFd);
432
433 _exit(100);
434 }
435 /*}}}*/
436 // ServerMethod::Fetch - Fetch an item /*{{{*/
437 // ---------------------------------------------------------------------
438 /* This adds an item to the pipeline. We keep the pipeline at a fixed
439 depth. */
440 bool ServerMethod::Fetch(FetchItem *)
441 {
442 if (Server == nullptr || QueueBack == nullptr)
443 return true;
444
445 // If pipelining is disabled, we only queue 1 request
446 auto const AllowedDepth = Server->Pipeline ? PipelineDepth : 0;
447 // how deep is our pipeline currently?
448 decltype(PipelineDepth) CurrentDepth = 0;
449 for (FetchItem const *I = Queue; I != QueueBack; I = I->Next)
450 ++CurrentDepth;
451 if (CurrentDepth > AllowedDepth)
452 return true;
453
454 do {
455 // Make sure we stick with the same server
456 if (Server->Comp(QueueBack->Uri) == false)
457 break;
458
459 bool const UsableHashes = QueueBack->ExpectedHashes.usable();
460 // if we have no hashes, do at most one such request
461 // as we can't fixup pipeling misbehaviors otherwise
462 if (CurrentDepth != 0 && UsableHashes == false)
463 break;
464
465 if (UsableHashes && FileExists(QueueBack->DestFile))
466 {
467 FileFd partial(QueueBack->DestFile, FileFd::ReadOnly);
468 Hashes wehave(QueueBack->ExpectedHashes);
469 if (QueueBack->ExpectedHashes.FileSize() == partial.FileSize())
470 {
471 if (wehave.AddFD(partial) &&
472 wehave.GetHashStringList() == QueueBack->ExpectedHashes)
473 {
474 FetchResult Res;
475 Res.Filename = QueueBack->DestFile;
476 Res.ResumePoint = QueueBack->ExpectedHashes.FileSize();
477 URIStart(Res);
478 // move item to the start of the queue as URIDone will
479 // always dequeued the first item in the queue
480 if (Queue != QueueBack)
481 {
482 FetchItem *Prev = Queue;
483 for (; Prev->Next != QueueBack; Prev = Prev->Next)
484 /* look for the previous queue item */;
485 Prev->Next = QueueBack->Next;
486 QueueBack->Next = Queue;
487 Queue = QueueBack;
488 QueueBack = Prev->Next;
489 }
490 Res.TakeHashes(wehave);
491 URIDone(Res);
492 continue;
493 }
494 else
495 RemoveFile("Fetch-Partial", QueueBack->DestFile);
496 }
497 }
498 auto const Tmp = QueueBack;
499 QueueBack = QueueBack->Next;
500 SendReq(Tmp);
501 ++CurrentDepth;
502 } while (CurrentDepth <= AllowedDepth && QueueBack != nullptr);
503
504 return true;
505 }
506 /*}}}*/
507 // ServerMethod::Loop - Main loop /*{{{*/
508 int ServerMethod::Loop()
509 {
510 signal(SIGTERM,SigTerm);
511 signal(SIGINT,SigTerm);
512
513 Server = 0;
514
515 int FailCounter = 0;
516 while (1)
517 {
518 // We have no commands, wait for some to arrive
519 if (Queue == 0)
520 {
521 if (WaitFd(STDIN_FILENO) == false)
522 return 0;
523 }
524
525 /* Run messages, we can accept 0 (no message) if we didn't
526 do a WaitFd above.. Otherwise the FD is closed. */
527 int Result = Run(true);
528 if (Result != -1 && (Result != 0 || Queue == 0))
529 {
530 if(FailReason.empty() == false ||
531 _config->FindB("Acquire::http::DependOnSTDIN", true) == true)
532 return 100;
533 else
534 return 0;
535 }
536
537 if (Queue == 0)
538 continue;
539
540 // Connect to the server
541 if (Server == 0 || Server->Comp(Queue->Uri) == false)
542 Server = CreateServerState(Queue->Uri);
543
544 /* If the server has explicitly said this is the last connection
545 then we pre-emptively shut down the pipeline and tear down
546 the connection. This will speed up HTTP/1.0 servers a tad
547 since we don't have to wait for the close sequence to
548 complete */
549 if (Server->Persistent == false)
550 Server->Close();
551
552 // Reset the pipeline
553 if (Server->IsOpen() == false)
554 QueueBack = Queue;
555
556 // Connnect to the host
557 if (Server->Open() == false)
558 {
559 Fail(true);
560 Server = nullptr;
561 continue;
562 }
563
564 // Fill the pipeline.
565 Fetch(0);
566
567 // Fetch the next URL header data from the server.
568 switch (Server->RunHeaders(File, Queue->Uri))
569 {
570 case ServerState::RUN_HEADERS_OK:
571 break;
572
573 // The header data is bad
574 case ServerState::RUN_HEADERS_PARSE_ERROR:
575 {
576 _error->Error(_("Bad header data"));
577 Fail(true);
578 Server->Close();
579 RotateDNS();
580 continue;
581 }
582
583 // The server closed a connection during the header get..
584 default:
585 case ServerState::RUN_HEADERS_IO_ERROR:
586 {
587 FailCounter++;
588 _error->Discard();
589 Server->Close();
590 Server->Pipeline = false;
591 Server->PipelineAllowed = false;
592
593 if (FailCounter >= 2)
594 {
595 Fail(_("Connection failed"),true);
596 FailCounter = 0;
597 }
598
599 RotateDNS();
600 continue;
601 }
602 };
603
604 // Decide what to do.
605 FetchResult Res;
606 Res.Filename = Queue->DestFile;
607 switch (DealWithHeaders(Res))
608 {
609 // Ok, the file is Open
610 case FILE_IS_OPEN:
611 {
612 URIStart(Res);
613
614 // Run the data
615 bool Result = true;
616
617 // ensure we don't fetch too much
618 // we could do "Server->MaximumSize = Queue->MaximumSize" here
619 // but that would break the clever pipeline messup detection
620 // so instead we use the size of the biggest item in the queue
621 Server->MaximumSize = FindMaximumObjectSizeInQueue();
622
623 if (Server->HaveContent)
624 Result = Server->RunData(File);
625
626 /* If the server is sending back sizeless responses then fill in
627 the size now */
628 if (Res.Size == 0)
629 Res.Size = File->Size();
630
631 // Close the file, destroy the FD object and timestamp it
632 FailFd = -1;
633 delete File;
634 File = 0;
635
636 // Timestamp
637 struct timeval times[2];
638 times[0].tv_sec = times[1].tv_sec = Server->Date;
639 times[0].tv_usec = times[1].tv_usec = 0;
640 utimes(Queue->DestFile.c_str(), times);
641
642 // Send status to APT
643 if (Result == true)
644 {
645 Hashes * const resultHashes = Server->GetHashes();
646 HashStringList const hashList = resultHashes->GetHashStringList();
647 if (PipelineDepth != 0 && Queue->ExpectedHashes.usable() == true && Queue->ExpectedHashes != hashList)
648 {
649 // we did not get the expected hash… mhhh:
650 // could it be that server/proxy messed up pipelining?
651 FetchItem * BeforeI = Queue;
652 for (FetchItem *I = Queue->Next; I != 0 && I != QueueBack; I = I->Next)
653 {
654 if (I->ExpectedHashes.usable() == true && I->ExpectedHashes == hashList)
655 {
656 // yes, he did! Disable pipelining and rewrite queue
657 if (Server->Pipeline == true)
658 {
659 Warning(_("Automatically disabled %s due to incorrect response from server/proxy. (man 5 apt.conf)"), "Acquire::http::Pipeline-Depth");
660 Server->Pipeline = false;
661 Server->PipelineAllowed = false;
662 // we keep the PipelineDepth value so that the rest of the queue can be fixed up as well
663 }
664 Rename(Res.Filename, I->DestFile);
665 Res.Filename = I->DestFile;
666 BeforeI->Next = I->Next;
667 I->Next = Queue;
668 Queue = I;
669 break;
670 }
671 BeforeI = I;
672 }
673 }
674 Res.TakeHashes(*resultHashes);
675 URIDone(Res);
676 }
677 else
678 {
679 if (Server->IsOpen() == false)
680 {
681 FailCounter++;
682 _error->Discard();
683 Server->Close();
684
685 if (FailCounter >= 2)
686 {
687 Fail(_("Connection failed"),true);
688 FailCounter = 0;
689 }
690
691 QueueBack = Queue;
692 }
693 else
694 {
695 Server->Close();
696 Fail(true);
697 }
698 }
699 break;
700 }
701
702 // IMS hit
703 case IMS_HIT:
704 {
705 URIDone(Res);
706 break;
707 }
708
709 // Hard server error, not found or something
710 case ERROR_UNRECOVERABLE:
711 {
712 Fail();
713 break;
714 }
715
716 // Hard internal error, kill the connection and fail
717 case ERROR_NOT_FROM_SERVER:
718 {
719 delete File;
720 File = 0;
721
722 Fail();
723 RotateDNS();
724 Server->Close();
725 break;
726 }
727
728 // We need to flush the data, the header is like a 404 w/ error text
729 case ERROR_WITH_CONTENT_PAGE:
730 {
731 Fail();
732
733 // Send to content to dev/null
734 File = new FileFd("/dev/null",FileFd::WriteExists);
735 Server->RunData(File);
736 delete File;
737 File = 0;
738 break;
739 }
740
741 // Try again with a new URL
742 case TRY_AGAIN_OR_REDIRECT:
743 {
744 // Clear rest of response if there is content
745 if (Server->HaveContent)
746 Server->RunDataToDevNull();
747 Redirect(NextURI);
748 break;
749 }
750
751 default:
752 Fail(_("Internal error"));
753 break;
754 }
755
756 FailCounter = 0;
757 }
758
759 return 0;
760 }
761 /*}}}*/
762 unsigned long long ServerMethod::FindMaximumObjectSizeInQueue() const /*{{{*/
763 {
764 unsigned long long MaxSizeInQueue = 0;
765 for (FetchItem *I = Queue; I != 0 && I != QueueBack; I = I->Next)
766 MaxSizeInQueue = std::max(MaxSizeInQueue, I->MaximumSize);
767 return MaxSizeInQueue;
768 }
769 /*}}}*/
770 ServerMethod::ServerMethod(char const * const Binary, char const * const Ver,unsigned long const Flags) :/*{{{*/
771 aptMethod(Binary, Ver, Flags), Server(nullptr), File(NULL), PipelineDepth(10),
772 AllowRedirect(false), Debug(false)
773 {
774 }
775 /*}}}*/