]>
git.saurik.com Git - apt.git/blob - methods/server.cc
672a3d16dd72a55aa796a7b91c1f984380cef74e
1 // -*- mode: cpp; mode: fold -*-
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 ##################################################################### */
10 // Include Files /*{{{*/
13 #include <apt-pkg/configuration.h>
14 #include <apt-pkg/error.h>
15 #include <apt-pkg/fileutl.h>
16 #include <apt-pkg/strutl.h>
38 string
ServerMethod::FailFile
;
39 int ServerMethod::FailFd
= -1;
40 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 */
46 ServerState::RunHeadersResult
ServerState::RunHeaders(FileFd
* const File
,
47 const std::string
&Uri
)
51 Owner
->Status(_("Waiting for headers"));
66 if (ReadHeaderLines(Data
) == false)
69 if (Owner
->Debug
== true)
70 clog
<< "Answer for: " << Uri
<< endl
<< Data
;
72 for (string::const_iterator I
= Data
.begin(); I
< Data
.end(); ++I
)
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
;
81 // 100 Continue is a Nop...
85 // Tidy up the connection persistence state.
86 if (Encoding
== Closes
&& HaveContent
== true)
89 return RUN_HEADERS_OK
;
91 while (LoadNextResponse(false, File
) == true);
93 return RUN_HEADERS_IO_ERROR
;
96 // ServerState::HeaderLine - Process a header line /*{{{*/
97 // ---------------------------------------------------------------------
99 bool ServerState::HeaderLine(string Line
)
101 if (Line
.empty() == true)
104 string::size_type Pos
= Line
.find(' ');
105 if (Pos
== string::npos
|| Pos
+1 > Line
.length())
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"));
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)
119 string Tag
= string(Line
,0,Pos
);
120 string Val
= string(Line
,Pos2
);
122 if (stringcasecmp(Tag
.c_str(),Tag
.c_str()+4,"HTTP") == 0)
124 // Evil servers return no version
127 int const elements
= sscanf(Line
.c_str(),"HTTP/%3u.%3u %3u%359[^\n]",&Major
,&Minor
,&Result
,Code
);
131 if (Owner
!= NULL
&& Owner
->Debug
== true)
132 clog
<< "HTTP server doesn't give Reason-Phrase for " << std::to_string(Result
) << std::endl
;
134 else if (elements
!= 4)
135 return _error
->Error(_("The HTTP server sent an invalid reply header"));
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"));
145 /* Check the HTTP response header to get the default persistence
151 if (Major
== 1 && Minor
== 0)
166 if (stringcasecmp(Tag
,"Content-Length:") == 0)
168 if (Encoding
== Closes
)
172 unsigned long long * DownloadSizePtr
= &DownloadSize
;
174 DownloadSizePtr
= &JunkSize
;
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)
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
185 if(Result
!= 206 && TotalFileSize
== 0)
186 TotalFileSize
= DownloadSize
;
191 if (stringcasecmp(Tag
,"Content-Type:") == 0)
197 if (stringcasecmp(Tag
,"Content-Range:") == 0)
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"));
209 // figure out what we will download
210 DownloadSize
= TotalFileSize
- StartPos
;
214 if (stringcasecmp(Tag
,"Transfer-Encoding:") == 0)
217 if (stringcasecmp(Val
,"chunked") == 0)
222 if (stringcasecmp(Tag
,"Connection:") == 0)
224 if (stringcasecmp(Val
,"close") == 0)
226 if (stringcasecmp(Val
,"keep-alive") == 0)
231 if (stringcasecmp(Tag
,"Last-Modified:") == 0)
233 if (RFC1123StrToTime(Val
.c_str(), Date
) == false)
234 return _error
->Error(_("Unknown date format"));
238 if (stringcasecmp(Tag
,"Location:") == 0)
247 // ServerState::ServerState - Constructor /*{{{*/
248 ServerState::ServerState(URI Srv
, ServerMethod
*Owner
) :
249 DownloadSize(0), ServerName(Srv
), TimeOut(120), Owner(Owner
)
254 bool ServerState::AddPartialFileToHashes(FileFd
&File
) /*{{{*/
256 File
.Truncate(StartPos
);
257 return GetHashes()->AddFD(File
, StartPos
);
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).
266 ServerMethod::DealWithHeadersResult
267 ServerMethod::DealWithHeaders(FetchResult
&Res
)
270 if (Server
->Result
== 304)
272 RemoveFile("server", Queue
->DestFile
);
274 Res
.LastModified
= Queue
->LastModified
;
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.
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)
291 if (Server
->Location
.empty() == true);
292 else if (Server
->Location
[0] == '/' && Queue
->Uri
.empty() == false)
294 URI Uri
= Queue
->Uri
;
295 if (Uri
.Host
.empty() == false)
296 NextURI
= URI::SiteOnly(Uri
);
299 NextURI
.append(DeQuoteString(Server
->Location
));
300 if (Queue
->Uri
== NextURI
)
302 SetFailReason("RedirectionLoop");
303 _error
->Error("Redirection loop encountered");
304 if (Server
->HaveContent
== true)
305 return ERROR_WITH_CONTENT_PAGE
;
306 return ERROR_UNRECOVERABLE
;
308 return TRY_AGAIN_OR_REDIRECT
;
312 NextURI
= DeQuoteString(Server
->Location
);
313 URI tmpURI
= NextURI
;
314 if (tmpURI
.Access
== "http" && Binary
== "https+http")
316 tmpURI
.Access
= "https+http";
319 if (Queue
->Uri
== NextURI
)
321 SetFailReason("RedirectionLoop");
322 _error
->Error("Redirection loop encountered");
323 if (Server
->HaveContent
== true)
324 return ERROR_WITH_CONTENT_PAGE
;
325 return ERROR_UNRECOVERABLE
;
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
;
335 /* else pass through for error message */
337 // retry after an invalid range response without partial data
338 else if (Server
->Result
== 416)
341 if (stat(Queue
->DestFile
.c_str(),&SBuf
) >= 0 && SBuf
.st_size
> 0)
343 bool partialHit
= false;
344 if (Queue
->ExpectedHashes
.usable() == true)
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
);
354 else if ((unsigned long long)SBuf
.st_size
== Server
->TotalFileSize
)
356 if (partialHit
== true)
358 // the file is completely downloaded, but was not moved
359 if (Server
->HaveContent
== true)
361 // Send to error page to dev/null
362 FileFd
DevNull("/dev/null",FileFd::WriteExists
);
363 Server
->RunData(&DevNull
);
365 Server
->HaveContent
= false;
366 Server
->StartPos
= Server
->TotalFileSize
;
367 Server
->Result
= 200;
369 else if (RemoveFile("server", Queue
->DestFile
))
371 NextURI
= Queue
->Uri
;
372 return TRY_AGAIN_OR_REDIRECT
;
377 /* We have a reply we don't handle. This should indicate a perm server
379 if (Server
->Result
< 200 || Server
->Result
>= 300)
382 strprintf(err
, "HttpError%u", Server
->Result
);
384 _error
->Error("%u %s", Server
->Result
, Server
->Code
);
385 if (Server
->HaveContent
== true)
386 return ERROR_WITH_CONTENT_PAGE
;
387 return ERROR_UNRECOVERABLE
;
390 // This is some sort of 2xx 'data follows' reply
391 Res
.LastModified
= Server
->Date
;
392 Res
.Size
= Server
->TotalFileSize
;
396 File
= new FileFd(Queue
->DestFile
,FileFd::WriteAny
);
397 if (_error
->PendingError() == true)
398 return ERROR_NOT_FROM_SERVER
;
400 FailFile
= Queue
->DestFile
;
401 FailFile
.c_str(); // Make sure we don't do a malloc in the signal handler
403 FailTime
= Server
->Date
;
405 if (Server
->InitHashes(Queue
->ExpectedHashes
) == false || Server
->AddPartialFileToHashes(*File
) == false)
407 _error
->Errno("read",_("Problem hashing file"));
408 return ERROR_NOT_FROM_SERVER
;
410 if (Server
->StartPos
> 0)
411 Res
.ResumePoint
= Server
->StartPos
;
413 SetNonBlock(File
->Fd(),true);
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)
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
);
436 // ServerMethod::Fetch - Fetch an item /*{{{*/
437 // ---------------------------------------------------------------------
438 /* This adds an item to the pipeline. We keep the pipeline at a fixed
440 bool ServerMethod::Fetch(FetchItem
*)
442 if (Server
== nullptr || QueueBack
== nullptr)
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
)
451 if (CurrentDepth
> AllowedDepth
)
455 // Make sure we stick with the same server
456 if (Server
->Comp(QueueBack
->Uri
) == false)
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)
465 if (UsableHashes
&& FileExists(QueueBack
->DestFile
))
467 FileFd
partial(QueueBack
->DestFile
, FileFd::ReadOnly
);
468 Hashes
wehave(QueueBack
->ExpectedHashes
);
469 if (QueueBack
->ExpectedHashes
.FileSize() == partial
.FileSize())
471 if (wehave
.AddFD(partial
) &&
472 wehave
.GetHashStringList() == QueueBack
->ExpectedHashes
)
475 Res
.Filename
= QueueBack
->DestFile
;
476 Res
.ResumePoint
= QueueBack
->ExpectedHashes
.FileSize();
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
)
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
;
488 QueueBack
= Prev
->Next
;
490 Res
.TakeHashes(wehave
);
495 RemoveFile("Fetch-Partial", QueueBack
->DestFile
);
498 auto const Tmp
= QueueBack
;
499 QueueBack
= QueueBack
->Next
;
502 } while (CurrentDepth
<= AllowedDepth
&& QueueBack
!= nullptr);
507 // ServerMethod::Loop - Main loop /*{{{*/
508 int ServerMethod::Loop()
510 signal(SIGTERM
,SigTerm
);
511 signal(SIGINT
,SigTerm
);
518 // We have no commands, wait for some to arrive
521 if (WaitFd(STDIN_FILENO
) == false)
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))
530 if(FailReason
.empty() == false ||
531 _config
->FindB("Acquire::http::DependOnSTDIN", true) == true)
540 // Connect to the server
541 if (Server
== 0 || Server
->Comp(Queue
->Uri
) == false)
542 Server
= CreateServerState(Queue
->Uri
);
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
549 if (Server
->Persistent
== false)
552 // Reset the pipeline
553 if (Server
->IsOpen() == false)
556 // Connnect to the host
557 if (Server
->Open() == false)
564 // Fill the pipeline.
567 // Fetch the next URL header data from the server.
568 switch (Server
->RunHeaders(File
, Queue
->Uri
))
570 case ServerState::RUN_HEADERS_OK
:
573 // The header data is bad
574 case ServerState::RUN_HEADERS_PARSE_ERROR
:
576 _error
->Error(_("Bad header data"));
583 // The server closed a connection during the header get..
585 case ServerState::RUN_HEADERS_IO_ERROR
:
590 Server
->Pipeline
= false;
591 Server
->PipelineAllowed
= false;
593 if (FailCounter
>= 2)
595 Fail(_("Connection failed"),true);
604 // Decide what to do.
606 Res
.Filename
= Queue
->DestFile
;
607 switch (DealWithHeaders(Res
))
609 // Ok, the file is Open
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();
623 if (Server
->HaveContent
)
624 Result
= Server
->RunData(File
);
626 /* If the server is sending back sizeless responses then fill in
629 Res
.Size
= File
->Size();
631 // Close the file, destroy the FD object and timestamp it
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
);
642 // Send status to APT
645 Hashes
* const resultHashes
= Server
->GetHashes();
646 HashStringList
const hashList
= resultHashes
->GetHashStringList();
647 if (PipelineDepth
!= 0 && Queue
->ExpectedHashes
.usable() == true && Queue
->ExpectedHashes
!= hashList
)
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
)
654 if (I
->ExpectedHashes
.usable() == true && I
->ExpectedHashes
== hashList
)
656 // yes, he did! Disable pipelining and rewrite queue
657 if (Server
->Pipeline
== true)
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
664 Rename(Res
.Filename
, I
->DestFile
);
665 Res
.Filename
= I
->DestFile
;
666 BeforeI
->Next
= I
->Next
;
674 Res
.TakeHashes(*resultHashes
);
679 if (Server
->IsOpen() == false)
685 if (FailCounter
>= 2)
687 Fail(_("Connection failed"),true);
709 // Hard server error, not found or something
710 case ERROR_UNRECOVERABLE
:
716 // Hard internal error, kill the connection and fail
717 case ERROR_NOT_FROM_SERVER
:
728 // We need to flush the data, the header is like a 404 w/ error text
729 case ERROR_WITH_CONTENT_PAGE
:
733 // Send to content to dev/null
734 File
= new FileFd("/dev/null",FileFd::WriteExists
);
735 Server
->RunData(File
);
741 // Try again with a new URL
742 case TRY_AGAIN_OR_REDIRECT
:
744 // Clear rest of response if there is content
745 if (Server
->HaveContent
)
746 Server
->RunDataToDevNull();
752 Fail(_("Internal error"));
762 unsigned long long ServerMethod::FindMaximumObjectSizeInQueue() const /*{{{*/
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
;
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)