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