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