]> git.saurik.com Git - apt.git/blob - apt-pkg/acquire-item.h
merged from debian-sid
[apt.git] / apt-pkg / acquire-item.h
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: acquire-item.h,v 1.26.2.3 2004/01/02 18:51:00 mdz Exp $
4 /* ######################################################################
5
6 Acquire Item - Item to acquire
7
8 When an item is instantiated it will add it self to the local list in
9 the Owner Acquire class. Derived classes will then call QueueURI to
10 register all the URI's they wish to fetch at the initial moment.
11
12 Three item classes are provided to provide functionality for
13 downloading of Index, Translation and Packages files.
14
15 A Archive class is provided for downloading .deb files. It does Hash
16 checking and source location as well as a retry algorithm.
17
18 ##################################################################### */
19 /*}}}*/
20 #ifndef PKGLIB_ACQUIRE_ITEM_H
21 #define PKGLIB_ACQUIRE_ITEM_H
22
23 #include <apt-pkg/acquire.h>
24 #include <apt-pkg/hashes.h>
25 #include <apt-pkg/weakptr.h>
26 #include <apt-pkg/pkgcache.h>
27
28 #ifndef APT_8_CLEANER_HEADERS
29 #include <apt-pkg/indexfile.h>
30 #include <apt-pkg/vendor.h>
31 #include <apt-pkg/sourcelist.h>
32 #include <apt-pkg/pkgrecords.h>
33 #include <apt-pkg/indexrecords.h>
34 #endif
35
36 /** \addtogroup acquire
37 * @{
38 *
39 * \file acquire-item.h
40 */
41
42 class indexRecords;
43 class pkgRecords;
44 class pkgSourceList;
45
46 /** \brief Represents the process by which a pkgAcquire object should {{{
47 * retrieve a file or a collection of files.
48 *
49 * By convention, Item subclasses should insert themselves into the
50 * acquire queue when they are created by calling QueueURI(), and
51 * remove themselves by calling Dequeue() when either Done() or
52 * Failed() is invoked. Item objects are also responsible for
53 * notifying the download progress indicator (accessible via
54 * #Owner->Log) of their status.
55 *
56 * \see pkgAcquire
57 */
58 class pkgAcquire::Item : public WeakPointable
59 {
60 protected:
61
62 /** \brief The acquire object with which this item is associated. */
63 pkgAcquire *Owner;
64
65 /** \brief Insert this item into its owner's queue.
66 *
67 * \param ItemDesc Metadata about this item (its URI and
68 * description).
69 */
70 inline void QueueURI(ItemDesc &Item)
71 {Owner->Enqueue(Item);};
72
73 /** \brief Remove this item from its owner's queue. */
74 inline void Dequeue() {Owner->Dequeue(this);};
75
76 /** \brief Rename a file without modifying its timestamp.
77 *
78 * Many item methods call this as their final action.
79 *
80 * \param From The file to be renamed.
81 *
82 * \param To The new name of #From. If #To exists it will be
83 * overwritten.
84 */
85 void Rename(std::string From,std::string To);
86
87 public:
88
89 /** \brief The current status of this item. */
90 enum ItemState
91 {
92 /** \brief The item is waiting to be downloaded. */
93 StatIdle,
94
95 /** \brief The item is currently being downloaded. */
96 StatFetching,
97
98 /** \brief The item has been successfully downloaded. */
99 StatDone,
100
101 /** \brief An error was encountered while downloading this
102 * item.
103 */
104 StatError,
105
106 /** \brief The item was downloaded but its authenticity could
107 * not be verified.
108 */
109 StatAuthError,
110
111 /** \brief The item was could not be downloaded because of
112 * a transient network error (e.g. network down)
113 */
114 StatTransientNetworkError
115 } Status;
116
117 /** \brief Contains a textual description of the error encountered
118 * if #Status is #StatError or #StatAuthError.
119 */
120 std::string ErrorText;
121
122 /** \brief The size of the object to fetch. */
123 unsigned long long FileSize;
124
125 /** \brief How much of the object was already fetched. */
126 unsigned long long PartialSize;
127
128 /** \brief If not \b NULL, contains the name of a subprocess that
129 * is operating on this object (for instance, "gzip" or "gpgv").
130 */
131 const char *Mode;
132
133 /** \brief A client-supplied unique identifier.
134 *
135 * This field is initalized to 0; it is meant to be filled in by
136 * clients that wish to use it to uniquely identify items.
137 *
138 * \todo it's unused in apt itself
139 */
140 unsigned long ID;
141
142 /** \brief If \b true, the entire object has been successfully fetched.
143 *
144 * Subclasses should set this to \b true when appropriate.
145 */
146 bool Complete;
147
148 /** \brief If \b true, the URI of this object is "local".
149 *
150 * The only effect of this field is to exclude the object from the
151 * download progress indicator's overall statistics.
152 */
153 bool Local;
154 std::string UsedMirror;
155
156 /** \brief The number of fetch queues into which this item has been
157 * inserted.
158 *
159 * There is one queue for each source from which an item could be
160 * downloaded.
161 *
162 * \sa pkgAcquire
163 */
164 unsigned int QueueCounter;
165
166 /** \brief The name of the file into which the retrieved object
167 * will be written.
168 */
169 std::string DestFile;
170
171 /** \brief Invoked by the acquire worker when the object couldn't
172 * be fetched.
173 *
174 * This is a branch of the continuation of the fetch process.
175 *
176 * \param Message An RFC822-formatted message from the acquire
177 * method describing what went wrong. Use LookupTag() to parse
178 * it.
179 *
180 * \param Cnf The method via which the worker tried to fetch this object.
181 *
182 * \sa pkgAcqMethod
183 */
184 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
185
186 /** \brief Invoked by the acquire worker when the object was
187 * fetched successfully.
188 *
189 * Note that the object might \e not have been written to
190 * DestFile; check for the presence of an Alt-Filename entry in
191 * Message to find the file to which it was really written.
192 *
193 * Done is often used to switch from one stage of the processing
194 * to the next (e.g. fetching, unpacking, copying). It is one
195 * branch of the continuation of the fetch process.
196 *
197 * \param Message Data from the acquire method. Use LookupTag()
198 * to parse it.
199 * \param Size The size of the object that was fetched.
200 * \param Hash The HashSum of the object that was fetched.
201 * \param Cnf The method via which the object was fetched.
202 *
203 * \sa pkgAcqMethod
204 */
205 virtual void Done(std::string Message,unsigned long long Size,std::string Hash,
206 pkgAcquire::MethodConfig *Cnf);
207
208 /** \brief Invoked when the worker starts to fetch this object.
209 *
210 * \param Message RFC822-formatted data from the worker process.
211 * Use LookupTag() to parse it.
212 *
213 * \param Size The size of the object being fetched.
214 *
215 * \sa pkgAcqMethod
216 */
217 virtual void Start(std::string Message,unsigned long long Size);
218
219 /** \brief Custom headers to be sent to the fetch process.
220 *
221 * \return a string containing RFC822-style headers that are to be
222 * inserted into the 600 URI Acquire message sent to the fetch
223 * subprocess. The headers are inserted after a newline-less
224 * line, so they should (if nonempty) have a leading newline and
225 * no trailing newline.
226 */
227 virtual std::string Custom600Headers() {return std::string();};
228
229 /** \brief A "descriptive" URI-like string.
230 *
231 * \return a URI that should be used to describe what is being fetched.
232 */
233 virtual std::string DescURI() = 0;
234 /** \brief Short item description.
235 *
236 * \return a brief description of the object being fetched.
237 */
238 virtual std::string ShortDesc() {return DescURI();}
239
240 /** \brief Invoked by the worker when the download is completely done. */
241 virtual void Finished() {};
242
243 /** \brief HashSum
244 *
245 * \return the HashSum of this object, if applicable; otherwise, an
246 * empty string.
247 */
248 virtual std::string HashSum() {return std::string();};
249
250 /** \return the acquire process with which this item is associated. */
251 pkgAcquire *GetOwner() {return Owner;};
252
253 /** \return \b true if this object is being fetched from a trusted source. */
254 virtual bool IsTrusted() {return false;};
255
256 // report mirror problems
257 /** \brief Report mirror problem
258 *
259 * This allows reporting mirror failures back to a centralized
260 * server. The apt-report-mirror-failure script is called for this
261 *
262 * \param FailCode A short failure string that is send
263 */
264 void ReportMirrorFailure(std::string FailCode);
265
266
267 /** \brief Initialize an item.
268 *
269 * Adds the item to the list of items known to the acquire
270 * process, but does not place it into any fetch queues (you must
271 * manually invoke QueueURI() to do so).
272 *
273 * Initializes all fields of the item other than Owner to 0,
274 * false, or the empty string.
275 *
276 * \param Owner The new owner of this item.
277 */
278 Item(pkgAcquire *Owner);
279
280 /** \brief Remove this item from its owner's queue by invoking
281 * pkgAcquire::Remove.
282 */
283 virtual ~Item();
284 };
285 /*}}}*/
286 /** \brief Information about an index patch (aka diff). */ /*{{{*/
287 struct DiffInfo {
288 /** The filename of the diff. */
289 std::string file;
290
291 /** The sha1 hash of the diff. */
292 std::string sha1;
293
294 /** The size of the diff. */
295 unsigned long size;
296 };
297 /*}}}*/
298 /** \brief An item that is responsible for fetching a SubIndex {{{
299 *
300 * The MetaIndex file includes only records for important indexes
301 * and records for these SubIndex files so these can carry records
302 * for addition files like PDiffs and Translations
303 */
304 class pkgAcqSubIndex : public pkgAcquire::Item
305 {
306 protected:
307 /** \brief If \b true, debugging information will be written to std::clog. */
308 bool Debug;
309
310 /** \brief The item that is currently being downloaded. */
311 pkgAcquire::ItemDesc Desc;
312
313 /** \brief The Hash that this file should have after download
314 */
315 HashString ExpectedHash;
316
317 public:
318 // Specialized action members
319 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
320 virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
321 pkgAcquire::MethodConfig *Cnf);
322 virtual std::string DescURI() {return Desc.URI;};
323 virtual std::string Custom600Headers();
324 virtual bool ParseIndex(std::string const &IndexFile);
325
326 /** \brief Create a new pkgAcqSubIndex.
327 *
328 * \param Owner The Acquire object that owns this item.
329 *
330 * \param URI The URI of the list file to download.
331 *
332 * \param URIDesc A long description of the list file to download.
333 *
334 * \param ShortDesc A short description of the list file to download.
335 *
336 * \param ExpectedHash The list file's MD5 signature.
337 */
338 pkgAcqSubIndex(pkgAcquire *Owner, std::string const &URI,std::string const &URIDesc,
339 std::string const &ShortDesc, HashString const &ExpectedHash);
340 };
341 /*}}}*/
342 /** \brief An item that is responsible for fetching an index file of {{{
343 * package list diffs and starting the package list's download.
344 *
345 * This item downloads the Index file and parses it, then enqueues
346 * additional downloads of either the individual patches (using
347 * pkgAcqIndexDiffs) or the entire Packages file (using pkgAcqIndex).
348 *
349 * \sa pkgAcqIndexDiffs, pkgAcqIndex
350 */
351 class pkgAcqDiffIndex : public pkgAcquire::Item
352 {
353 protected:
354 /** \brief If \b true, debugging information will be written to std::clog. */
355 bool Debug;
356
357 /** \brief The item that is currently being downloaded. */
358 pkgAcquire::ItemDesc Desc;
359
360 /** \brief The URI of the index file to recreate at our end (either
361 * by downloading it or by applying partial patches).
362 */
363 std::string RealURI;
364
365 /** \brief The Hash that the real index file should have after
366 * all patches have been applied.
367 */
368 HashString ExpectedHash;
369
370 /** \brief The index file which will be patched to generate the new
371 * file.
372 */
373 std::string CurrentPackagesFile;
374
375 /** \brief A description of the Packages file (stored in
376 * pkgAcquire::ItemDesc::Description).
377 */
378 std::string Description;
379
380 public:
381 // Specialized action members
382 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
383 virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
384 pkgAcquire::MethodConfig *Cnf);
385 virtual std::string DescURI() {return RealURI + "Index";};
386 virtual std::string Custom600Headers();
387
388 /** \brief Parse the Index file for a set of Packages diffs.
389 *
390 * Parses the Index file and creates additional download items as
391 * necessary.
392 *
393 * \param IndexDiffFile The name of the Index file.
394 *
395 * \return \b true if the Index file was successfully parsed, \b
396 * false otherwise.
397 */
398 bool ParseDiffIndex(std::string IndexDiffFile);
399
400
401 /** \brief Create a new pkgAcqDiffIndex.
402 *
403 * \param Owner The Acquire object that owns this item.
404 *
405 * \param URI The URI of the list file to download.
406 *
407 * \param URIDesc A long description of the list file to download.
408 *
409 * \param ShortDesc A short description of the list file to download.
410 *
411 * \param ExpectedHash The list file's MD5 signature.
412 */
413 pkgAcqDiffIndex(pkgAcquire *Owner,std::string URI,std::string URIDesc,
414 std::string ShortDesc, HashString ExpectedHash);
415 };
416 /*}}}*/
417 /** \brief An item that is responsible for fetching all the patches {{{
418 * that need to be applied to a given package index file.
419 *
420 * After downloading and applying a single patch, this item will
421 * enqueue a new pkgAcqIndexDiffs to download and apply the remaining
422 * patches. If no patch can be found that applies to an intermediate
423 * file or if one of the patches cannot be downloaded, falls back to
424 * downloading the entire package index file using pkgAcqIndex.
425 *
426 * \sa pkgAcqDiffIndex, pkgAcqIndex
427 */
428 class pkgAcqIndexDiffs : public pkgAcquire::Item
429 {
430 private:
431
432 /** \brief Queue up the next diff download.
433 *
434 * Search for the next available diff that applies to the file
435 * that currently exists on disk, and enqueue it by calling
436 * QueueURI().
437 *
438 * \return \b true if an applicable diff was found, \b false
439 * otherwise.
440 */
441 bool QueueNextDiff();
442
443 /** \brief Handle tasks that must be performed after the item
444 * finishes downloading.
445 *
446 * Dequeues the item and checks the resulting file's md5sum
447 * against ExpectedHash after the last patch was applied.
448 * There is no need to check the md5/sha1 after a "normal"
449 * patch because QueueNextDiff() will check the sha1 later.
450 *
451 * \param allDone If \b true, the file was entirely reconstructed,
452 * and its md5sum is verified.
453 */
454 void Finish(bool allDone=false);
455
456 protected:
457
458 /** \brief If \b true, debugging output will be written to
459 * std::clog.
460 */
461 bool Debug;
462
463 /** \brief A description of the item that is currently being
464 * downloaded.
465 */
466 pkgAcquire::ItemDesc Desc;
467
468 /** \brief The URI of the package index file that is being
469 * reconstructed.
470 */
471 std::string RealURI;
472
473 /** \brief The HashSum of the package index file that is being
474 * reconstructed.
475 */
476 HashString ExpectedHash;
477
478 /** A description of the file being downloaded. */
479 std::string Description;
480
481 /** The patches that remain to be downloaded, including the patch
482 * being downloaded right now. This list should be ordered so
483 * that each diff appears before any diff that depends on it.
484 *
485 * \todo These are indexed by sha1sum; why not use some sort of
486 * dictionary instead of relying on ordering and stripping them
487 * off the front?
488 */
489 std::vector<DiffInfo> available_patches;
490
491 /** Stop applying patches when reaching that sha1 */
492 std::string ServerSha1;
493
494 /** The current status of this patch. */
495 enum DiffState
496 {
497 /** \brief The diff is in an unknown state. */
498 StateFetchUnkown,
499
500 /** \brief The diff is currently being fetched. */
501 StateFetchDiff,
502
503 /** \brief The diff is currently being uncompressed. */
504 StateUnzipDiff, // FIXME: No longer used
505
506 /** \brief The diff is currently being applied. */
507 StateApplyDiff
508 } State;
509
510 public:
511
512 /** \brief Called when the patch file failed to be downloaded.
513 *
514 * This method will fall back to downloading the whole index file
515 * outright; its arguments are ignored.
516 */
517 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
518
519 virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
520 pkgAcquire::MethodConfig *Cnf);
521 virtual std::string DescURI() {return RealURI + "Index";};
522
523 /** \brief Create an index diff item.
524 *
525 * After filling in its basic fields, this invokes Finish(true) if
526 * #diffs is empty, or QueueNextDiff() otherwise.
527 *
528 * \param Owner The pkgAcquire object that owns this item.
529 *
530 * \param URI The URI of the package index file being
531 * reconstructed.
532 *
533 * \param URIDesc A long description of this item.
534 *
535 * \param ShortDesc A brief description of this item.
536 *
537 * \param ExpectedHash The expected md5sum of the completely
538 * reconstructed package index file; the index file will be tested
539 * against this value when it is entirely reconstructed.
540 *
541 * \param diffs The remaining diffs from the index of diffs. They
542 * should be ordered so that each diff appears before any diff
543 * that depends on it.
544 */
545 pkgAcqIndexDiffs(pkgAcquire *Owner,std::string URI,std::string URIDesc,
546 std::string ShortDesc, HashString ExpectedHash,
547 std::string ServerSha1,
548 std::vector<DiffInfo> diffs=std::vector<DiffInfo>());
549 };
550 /*}}}*/
551 /** \brief An acquire item that is responsible for fetching an index {{{
552 * file (e.g., Packages or Sources).
553 *
554 * \sa pkgAcqDiffIndex, pkgAcqIndexDiffs, pkgAcqIndexTrans
555 *
556 * \todo Why does pkgAcqIndex have protected members?
557 */
558 class pkgAcqIndex : public pkgAcquire::Item
559 {
560 protected:
561
562 /** \brief If \b true, the index file has been decompressed. */
563 bool Decompression;
564
565 /** \brief If \b true, the partially downloaded file will be
566 * removed when the download completes.
567 */
568 bool Erase;
569
570 /** \brief Verify for correctness by checking if a "Package"
571 * tag is found in the index. This can be set to
572 * false for optional index targets
573 *
574 */
575 // FIXME: instead of a bool it should use a verify string that will
576 // then be used in the pkgAcqIndex::Done method to ensure that
577 // the downloaded file contains the expected tag
578 bool Verify;
579
580 /** \brief The download request that is currently being
581 * processed.
582 */
583 pkgAcquire::ItemDesc Desc;
584
585 /** \brief The object that is actually being fetched (minus any
586 * compression-related extensions).
587 */
588 std::string RealURI;
589
590 /** \brief The expected hashsum of the decompressed index file. */
591 HashString ExpectedHash;
592
593 /** \brief The compression-related file extensions that are being
594 * added to the downloaded file one by one if first fails (e.g., "gz bz2").
595 */
596 std::string CompressionExtension;
597
598 public:
599
600 // Specialized action members
601 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
602 virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
603 pkgAcquire::MethodConfig *Cnf);
604 virtual std::string Custom600Headers();
605 virtual std::string DescURI() {return Desc.URI;};
606 virtual std::string HashSum() {return ExpectedHash.toStr(); };
607
608 /** \brief Create a pkgAcqIndex.
609 *
610 * \param Owner The pkgAcquire object with which this item is
611 * associated.
612 *
613 * \param URI The URI of the index file that is to be downloaded.
614 *
615 * \param URIDesc A "URI-style" description of this index file.
616 *
617 * \param ShortDesc A brief description of this index file.
618 *
619 * \param ExpectedHash The expected hashsum of this index file.
620 *
621 * \param compressExt The compression-related extension with which
622 * this index file should be downloaded, or "" to autodetect
623 * Compression types can be set with config Acquire::CompressionTypes,
624 * default is ".lzma" or ".bz2" (if the needed binaries are present)
625 * fallback is ".gz" or none.
626 */
627 pkgAcqIndex(pkgAcquire *Owner,std::string URI,std::string URIDesc,
628 std::string ShortDesc, HashString ExpectedHash,
629 std::string compressExt="");
630 pkgAcqIndex(pkgAcquire *Owner, struct IndexTarget const * const Target,
631 HashString const &ExpectedHash, indexRecords const *MetaIndexParser);
632 void Init(std::string const &URI, std::string const &URIDesc, std::string const &ShortDesc);
633 };
634 /*}}}*/
635 /** \brief An acquire item that is responsible for fetching a {{{
636 * translated index file.
637 *
638 * The only difference from pkgAcqIndex is that transient failures
639 * are suppressed: no error occurs if the translated index file is
640 * missing.
641 */
642 class pkgAcqIndexTrans : public pkgAcqIndex
643 {
644 public:
645
646 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
647 virtual std::string Custom600Headers();
648
649 /** \brief Create a pkgAcqIndexTrans.
650 *
651 * \param Owner The pkgAcquire object with which this item is
652 * associated.
653 *
654 * \param URI The URI of the index file that is to be downloaded.
655 *
656 * \param URIDesc A "URI-style" description of this index file.
657 *
658 * \param ShortDesc A brief description of this index file.
659 */
660 pkgAcqIndexTrans(pkgAcquire *Owner,std::string URI,std::string URIDesc,
661 std::string ShortDesc);
662 pkgAcqIndexTrans(pkgAcquire *Owner, struct IndexTarget const * const Target,
663 HashString const &ExpectedHash, indexRecords const *MetaIndexParser);
664 };
665 /*}}}*/
666 /** \brief Information about an index file. */ /*{{{*/
667 class IndexTarget
668 {
669 public:
670 /** \brief A URI from which the index file can be downloaded. */
671 std::string URI;
672
673 /** \brief A description of the index file. */
674 std::string Description;
675
676 /** \brief A shorter description of the index file. */
677 std::string ShortDesc;
678
679 /** \brief The key by which this index file should be
680 * looked up within the meta signature file.
681 */
682 std::string MetaKey;
683
684 virtual bool IsOptional() const {
685 return false;
686 }
687 virtual bool IsSubIndex() const {
688 return false;
689 }
690 };
691 /*}}}*/
692 /** \brief Information about an optional index file. */ /*{{{*/
693 class OptionalIndexTarget : public IndexTarget
694 {
695 virtual bool IsOptional() const {
696 return true;
697 }
698 };
699 /*}}}*/
700 /** \brief Information about an subindex index file. */ /*{{{*/
701 class SubIndexTarget : public IndexTarget
702 {
703 virtual bool IsSubIndex() const {
704 return true;
705 }
706 };
707 /*}}}*/
708 /** \brief Information about an subindex index file. */ /*{{{*/
709 class OptionalSubIndexTarget : public OptionalIndexTarget
710 {
711 virtual bool IsSubIndex() const {
712 return true;
713 }
714 };
715 /*}}}*/
716
717 /** \brief An acquire item that downloads the detached signature {{{
718 * of a meta-index (Release) file, then queues up the release
719 * file itself.
720 *
721 * \todo Why protected members?
722 *
723 * \sa pkgAcqMetaIndex
724 */
725 class pkgAcqMetaSig : public pkgAcquire::Item
726 {
727 protected:
728 /** \brief The last good signature file */
729 std::string LastGoodSig;
730
731 /** \brief The fetch request that is currently being processed. */
732 pkgAcquire::ItemDesc Desc;
733
734 /** \brief The URI of the signature file. Unlike Desc.URI, this is
735 * never modified; it is used to determine the file that is being
736 * downloaded.
737 */
738 std::string RealURI;
739
740 /** \brief The URI of the meta-index file to be fetched after the signature. */
741 std::string MetaIndexURI;
742
743 /** \brief A "URI-style" description of the meta-index file to be
744 * fetched after the signature.
745 */
746 std::string MetaIndexURIDesc;
747
748 /** \brief A brief description of the meta-index file to be fetched
749 * after the signature.
750 */
751 std::string MetaIndexShortDesc;
752
753 /** \brief A package-system-specific parser for the meta-index file. */
754 indexRecords* MetaIndexParser;
755
756 /** \brief The index files which should be looked up in the meta-index
757 * and then downloaded.
758 *
759 * \todo Why a list of pointers instead of a list of structs?
760 */
761 const std::vector<struct IndexTarget*>* IndexTargets;
762
763 public:
764
765 // Specialized action members
766 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
767 virtual void Done(std::string Message,unsigned long long Size,std::string Md5Hash,
768 pkgAcquire::MethodConfig *Cnf);
769 virtual std::string Custom600Headers();
770 virtual std::string DescURI() {return RealURI; };
771
772 /** \brief Create a new pkgAcqMetaSig. */
773 pkgAcqMetaSig(pkgAcquire *Owner,std::string URI,std::string URIDesc, std::string ShortDesc,
774 std::string MetaIndexURI, std::string MetaIndexURIDesc, std::string MetaIndexShortDesc,
775 const std::vector<struct IndexTarget*>* IndexTargets,
776 indexRecords* MetaIndexParser);
777 };
778 /*}}}*/
779 /** \brief An item that is responsible for downloading the meta-index {{{
780 * file (i.e., Release) itself and verifying its signature.
781 *
782 * Once the download and verification are complete, the downloads of
783 * the individual index files are queued up using pkgAcqDiffIndex.
784 * If the meta-index file had a valid signature, the expected hashsums
785 * of the index files will be the md5sums listed in the meta-index;
786 * otherwise, the expected hashsums will be "" (causing the
787 * authentication of the index files to be bypassed).
788 */
789 class pkgAcqMetaIndex : public pkgAcquire::Item
790 {
791 protected:
792 /** \brief The fetch command that is currently being processed. */
793 pkgAcquire::ItemDesc Desc;
794
795 /** \brief The URI that is actually being downloaded; never
796 * modified by pkgAcqMetaIndex.
797 */
798 std::string RealURI;
799
800 /** \brief The file in which the signature for this index was stored.
801 *
802 * If empty, the signature and the md5sums of the individual
803 * indices will not be checked.
804 */
805 std::string SigFile;
806
807 /** \brief The index files to download. */
808 const std::vector<struct IndexTarget*>* IndexTargets;
809
810 /** \brief The parser for the meta-index file. */
811 indexRecords* MetaIndexParser;
812
813 /** \brief If \b true, the index's signature is currently being verified.
814 */
815 bool AuthPass;
816 // required to deal gracefully with problems caused by incorrect ims hits
817 bool IMSHit;
818
819 /** \brief Check that the release file is a release file for the
820 * correct distribution.
821 *
822 * \return \b true if no fatal errors were encountered.
823 */
824 bool VerifyVendor(std::string Message);
825
826 /** \brief Called when a file is finished being retrieved.
827 *
828 * If the file was not downloaded to DestFile, a copy process is
829 * set up to copy it to DestFile; otherwise, Complete is set to \b
830 * true and the file is moved to its final location.
831 *
832 * \param Message The message block received from the fetch
833 * subprocess.
834 */
835 void RetrievalDone(std::string Message);
836
837 /** \brief Called when authentication succeeded.
838 *
839 * Sanity-checks the authenticated file, queues up the individual
840 * index files for download, and saves the signature in the lists
841 * directory next to the authenticated list file.
842 *
843 * \param Message The message block received from the fetch
844 * subprocess.
845 */
846 void AuthDone(std::string Message);
847
848 /** \brief Starts downloading the individual index files.
849 *
850 * \param verify If \b true, only indices whose expected hashsum
851 * can be determined from the meta-index will be downloaded, and
852 * the hashsums of indices will be checked (reporting
853 * #StatAuthError if there is a mismatch). If verify is \b false,
854 * no hashsum checking will be performed.
855 */
856 void QueueIndexes(bool verify);
857
858 public:
859
860 // Specialized action members
861 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
862 virtual void Done(std::string Message,unsigned long long Size, std::string Hash,
863 pkgAcquire::MethodConfig *Cnf);
864 virtual std::string Custom600Headers();
865 virtual std::string DescURI() {return RealURI; };
866
867 /** \brief Create a new pkgAcqMetaIndex. */
868 pkgAcqMetaIndex(pkgAcquire *Owner,
869 std::string URI,std::string URIDesc, std::string ShortDesc,
870 std::string SigFile,
871 const std::vector<struct IndexTarget*>* IndexTargets,
872 indexRecords* MetaIndexParser);
873 };
874 /*}}}*/
875 /** \brief An item repsonsible for downloading clearsigned metaindexes {{{*/
876 class pkgAcqMetaClearSig : public pkgAcqMetaIndex
877 {
878 /** \brief The URI of the meta-index file for the detached signature */
879 std::string MetaIndexURI;
880
881 /** \brief A "URI-style" description of the meta-index file */
882 std::string MetaIndexURIDesc;
883
884 /** \brief A brief description of the meta-index file */
885 std::string MetaIndexShortDesc;
886
887 /** \brief The URI of the detached meta-signature file if the clearsigned one failed. */
888 std::string MetaSigURI;
889
890 /** \brief A "URI-style" description of the meta-signature file */
891 std::string MetaSigURIDesc;
892
893 /** \brief A brief description of the meta-signature file */
894 std::string MetaSigShortDesc;
895
896 public:
897 void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
898 virtual std::string Custom600Headers();
899
900 /** \brief Create a new pkgAcqMetaClearSig. */
901 pkgAcqMetaClearSig(pkgAcquire *Owner,
902 std::string const &URI, std::string const &URIDesc, std::string const &ShortDesc,
903 std::string const &MetaIndexURI, std::string const &MetaIndexURIDesc, std::string const &MetaIndexShortDesc,
904 std::string const &MetaSigURI, std::string const &MetaSigURIDesc, std::string const &MetaSigShortDesc,
905 const std::vector<struct IndexTarget*>* IndexTargets,
906 indexRecords* MetaIndexParser);
907 };
908 /*}}}*/
909 /** \brief An item that is responsible for fetching a package file. {{{
910 *
911 * If the package file already exists in the cache, nothing will be
912 * done.
913 */
914 class pkgAcqArchive : public pkgAcquire::Item
915 {
916 protected:
917 /** \brief The package version being fetched. */
918 pkgCache::VerIterator Version;
919
920 /** \brief The fetch command that is currently being processed. */
921 pkgAcquire::ItemDesc Desc;
922
923 /** \brief The list of sources from which to pick archives to
924 * download this package from.
925 */
926 pkgSourceList *Sources;
927
928 /** \brief A package records object, used to look up the file
929 * corresponding to each version of the package.
930 */
931 pkgRecords *Recs;
932
933 /** \brief The hashsum of this package. */
934 HashString ExpectedHash;
935
936 /** \brief A location in which the actual filename of the package
937 * should be stored.
938 */
939 std::string &StoreFilename;
940
941 /** \brief The next file for this version to try to download. */
942 pkgCache::VerFileIterator Vf;
943
944 /** \brief How many (more) times to try to find a new source from
945 * which to download this package version if it fails.
946 *
947 * Set from Acquire::Retries.
948 */
949 unsigned int Retries;
950
951 /** \brief \b true if this version file is being downloaded from a
952 * trusted source.
953 */
954 bool Trusted;
955
956 /** \brief Queue up the next available file for this version. */
957 bool QueueNext();
958
959 public:
960
961 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
962 virtual void Done(std::string Message,unsigned long long Size,std::string Hash,
963 pkgAcquire::MethodConfig *Cnf);
964 virtual std::string DescURI() {return Desc.URI;};
965 virtual std::string ShortDesc() {return Desc.ShortDesc;};
966 virtual void Finished();
967 virtual std::string HashSum() {return ExpectedHash.toStr(); };
968 virtual bool IsTrusted();
969
970 /** \brief Create a new pkgAcqArchive.
971 *
972 * \param Owner The pkgAcquire object with which this item is
973 * associated.
974 *
975 * \param Sources The sources from which to download version
976 * files.
977 *
978 * \param Recs A package records object, used to look up the file
979 * corresponding to each version of the package.
980 *
981 * \param Version The package version to download.
982 *
983 * \param StoreFilename A location in which the actual filename of
984 * the package should be stored. It will be set to a guessed
985 * basename in the constructor, and filled in with a fully
986 * qualified filename once the download finishes.
987 */
988 pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
989 pkgRecords *Recs,pkgCache::VerIterator const &Version,
990 std::string &StoreFilename);
991 };
992 /*}}}*/
993 /** \brief Retrieve an arbitrary file to the current directory. {{{
994 *
995 * The file is retrieved even if it is accessed via a URL type that
996 * normally is a NOP, such as "file". If the download fails, the
997 * partial file is renamed to get a ".FAILED" extension.
998 */
999 class pkgAcqFile : public pkgAcquire::Item
1000 {
1001 /** \brief The currently active download process. */
1002 pkgAcquire::ItemDesc Desc;
1003
1004 /** \brief The hashsum of the file to download, if it is known. */
1005 HashString ExpectedHash;
1006
1007 /** \brief How many times to retry the download, set from
1008 * Acquire::Retries.
1009 */
1010 unsigned int Retries;
1011
1012 /** \brief Should this file be considered a index file */
1013 bool IsIndexFile;
1014
1015 public:
1016
1017 // Specialized action members
1018 virtual void Failed(std::string Message,pkgAcquire::MethodConfig *Cnf);
1019 virtual void Done(std::string Message,unsigned long long Size,std::string CalcHash,
1020 pkgAcquire::MethodConfig *Cnf);
1021 virtual std::string DescURI() {return Desc.URI;};
1022 virtual std::string HashSum() {return ExpectedHash.toStr(); };
1023 virtual std::string Custom600Headers();
1024
1025 /** \brief Create a new pkgAcqFile object.
1026 *
1027 * \param Owner The pkgAcquire object with which this object is
1028 * associated.
1029 *
1030 * \param URI The URI to download.
1031 *
1032 * \param Hash The hashsum of the file to download, if it is known;
1033 * otherwise "".
1034 *
1035 * \param Size The size of the file to download, if it is known;
1036 * otherwise 0.
1037 *
1038 * \param Desc A description of the file being downloaded.
1039 *
1040 * \param ShortDesc A brief description of the file being
1041 * downloaded.
1042 *
1043 * \param DestDir The directory the file should be downloaded into.
1044 *
1045 * \param DestFilename The filename+path the file is downloaded to.
1046 *
1047 * \param IsIndexFile The file is considered a IndexFile and cache-control
1048 * headers like "cache-control: max-age=0" are send
1049 *
1050 * If DestFilename is empty, download to DestDir/<basename> if
1051 * DestDir is non-empty, $CWD/<basename> otherwise. If
1052 * DestFilename is NOT empty, DestDir is ignored and DestFilename
1053 * is the absolute name to which the file should be downloaded.
1054 */
1055
1056 pkgAcqFile(pkgAcquire *Owner, std::string URI, std::string Hash, unsigned long long Size,
1057 std::string Desc, std::string ShortDesc,
1058 const std::string &DestDir="", const std::string &DestFilename="",
1059 bool IsIndexFile=false);
1060 };
1061 /*}}}*/
1062 /** @} */
1063
1064 #endif