Commit | Line | Data |
---|---|---|
b2e465d6 AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
c9569a1e | 3 | // $Id: cachedb.cc,v 1.7 2004/05/08 19:41:01 mdz Exp $ |
b2e465d6 AL |
4 | /* ###################################################################### |
5 | ||
6 | CacheDB | |
7 | ||
8 | Simple uniform interface to a cache database. | |
9 | ||
10 | ##################################################################### */ | |
11 | /*}}}*/ | |
12 | // Include Files /*{{{*/ | |
b2e465d6 AL |
13 | #include "cachedb.h" |
14 | ||
dc738e7a | 15 | #include <apti18n.h> |
b2e465d6 AL |
16 | #include <apt-pkg/error.h> |
17 | #include <apt-pkg/md5.h> | |
cde41ae8 | 18 | #include <apt-pkg/sha1.h> |
84a0890e | 19 | #include <apt-pkg/sha2.h> |
b2e465d6 AL |
20 | #include <apt-pkg/strutl.h> |
21 | #include <apt-pkg/configuration.h> | |
22 | ||
23 | #include <netinet/in.h> // htonl, etc | |
24 | /*}}}*/ | |
25 | ||
26 | // CacheDB::ReadyDB - Ready the DB2 /*{{{*/ | |
27 | // --------------------------------------------------------------------- | |
28 | /* This opens the DB2 file for caching package information */ | |
9209ec47 | 29 | bool CacheDB::ReadyDB(string const &DB) |
b2e465d6 | 30 | { |
c9569a1e AL |
31 | int err; |
32 | ||
b2e465d6 AL |
33 | ReadOnly = _config->FindB("APT::FTPArchive::ReadOnlyDB",false); |
34 | ||
35 | // Close the old DB | |
36 | if (Dbp != 0) | |
37 | Dbp->close(Dbp,0); | |
38 | ||
39 | /* Check if the DB was disabled while running and deal with a | |
40 | corrupted DB */ | |
41 | if (DBFailed() == true) | |
42 | { | |
dc738e7a | 43 | _error->Warning(_("DB was corrupted, file renamed to %s.old"),DBFile.c_str()); |
b2e465d6 AL |
44 | rename(DBFile.c_str(),(DBFile+".old").c_str()); |
45 | } | |
46 | ||
47 | DBLoaded = false; | |
48 | Dbp = 0; | |
49 | DBFile = string(); | |
50 | ||
51 | if (DB.empty()) | |
52 | return true; | |
c9569a1e AL |
53 | |
54 | db_create(&Dbp, NULL, 0); | |
cde41ae8 | 55 | if ((err = Dbp->open(Dbp, NULL, DB.c_str(), NULL, DB_BTREE, |
b2e465d6 | 56 | (ReadOnly?DB_RDONLY:DB_CREATE), |
c9569a1e | 57 | 0644)) != 0) |
b2e465d6 | 58 | { |
c9569a1e AL |
59 | if (err == DB_OLD_VERSION) |
60 | { | |
61 | _error->Warning(_("DB is old, attempting to upgrade %s"),DBFile.c_str()); | |
62 | err = Dbp->upgrade(Dbp, DB.c_str(), 0); | |
63 | if (!err) | |
64 | err = Dbp->open(Dbp, NULL, DB.c_str(), NULL, DB_HASH, | |
65 | (ReadOnly?DB_RDONLY:DB_CREATE), 0644); | |
66 | ||
67 | } | |
eb2bc4f2 MV |
68 | // the database format has changed from DB_HASH to DB_BTREE in |
69 | // apt 0.6.44 | |
70 | if (err == EINVAL) | |
71 | { | |
c6474fb6 | 72 | _error->Error(_("DB format is invalid. If you upgraded from an older version of apt, please remove and re-create the database.")); |
eb2bc4f2 | 73 | } |
c9569a1e AL |
74 | if (err) |
75 | { | |
76 | Dbp = 0; | |
77 | return _error->Error(_("Unable to open DB file %s: %s"),DB.c_str(), db_strerror(err)); | |
78 | } | |
b2e465d6 AL |
79 | } |
80 | ||
81 | DBFile = DB; | |
82 | DBLoaded = true; | |
83 | return true; | |
84 | } | |
85 | /*}}}*/ | |
c6474fb6 | 86 | // CacheDB::OpenFile - Open the file /*{{{*/ |
b2e465d6 | 87 | // --------------------------------------------------------------------- |
cde41ae8 MV |
88 | /* */ |
89 | bool CacheDB::OpenFile() | |
90 | { | |
91 | Fd = new FileFd(FileName,FileFd::ReadOnly); | |
92 | if (_error->PendingError() == true) | |
93 | { | |
94 | delete Fd; | |
95 | Fd = NULL; | |
96 | return false; | |
97 | } | |
98 | return true; | |
99 | } | |
100 | /*}}}*/ | |
101 | // CacheDB::GetFileStat - Get stats from the file /*{{{*/ | |
102 | // --------------------------------------------------------------------- | |
103 | /* This gets the size from the database if it's there. If we need | |
104 | * to look at the file, also get the mtime from the file. */ | |
ff574e76 | 105 | bool CacheDB::GetFileStat(bool const &doStat) |
cde41ae8 | 106 | { |
ff574e76 | 107 | if ((CurStat.Flags & FlSize) == FlSize && doStat == false) |
cde41ae8 MV |
108 | { |
109 | /* Already worked out the file size */ | |
110 | } | |
111 | else | |
112 | { | |
113 | /* Get it from the file. */ | |
114 | if (Fd == NULL && OpenFile() == false) | |
115 | { | |
116 | return false; | |
117 | } | |
118 | // Stat the file | |
119 | struct stat St; | |
120 | if (fstat(Fd->Fd(),&St) != 0) | |
121 | { | |
122 | return _error->Errno("fstat", | |
123 | _("Failed to stat %s"),FileName.c_str()); | |
124 | } | |
125 | CurStat.FileSize = St.st_size; | |
126 | CurStat.mtime = htonl(St.st_mtime); | |
127 | CurStat.Flags |= FlSize; | |
128 | } | |
129 | return true; | |
130 | } | |
131 | /*}}}*/ | |
132 | // CacheDB::GetCurStat - Set the CurStat variable. /*{{{*/ | |
133 | // --------------------------------------------------------------------- | |
134 | /* Sets the CurStat variable. Either to 0 if no database is used | |
135 | * or to the value in the database if one is used */ | |
136 | bool CacheDB::GetCurStat() | |
b2e465d6 | 137 | { |
b2e465d6 AL |
138 | memset(&CurStat,0,sizeof(CurStat)); |
139 | ||
cde41ae8 MV |
140 | if (DBLoaded) |
141 | { | |
c6474fb6 | 142 | /* First see if there is anything about it |
cde41ae8 | 143 | in the database */ |
b2e465d6 | 144 | |
cde41ae8 | 145 | /* Get the flags (and mtime) */ |
b2e465d6 | 146 | InitQuery("st"); |
b2e465d6 AL |
147 | // Ensure alignment of the returned structure |
148 | Data.data = &CurStat; | |
149 | Data.ulen = sizeof(CurStat); | |
150 | Data.flags = DB_DBT_USERMEM; | |
cde41ae8 | 151 | if (Get() == false) |
b2e465d6 | 152 | { |
b2e465d6 | 153 | CurStat.Flags = 0; |
b2e465d6 | 154 | } |
cde41ae8 MV |
155 | CurStat.Flags = ntohl(CurStat.Flags); |
156 | CurStat.FileSize = ntohl(CurStat.FileSize); | |
b2e465d6 | 157 | } |
cde41ae8 MV |
158 | return true; |
159 | } | |
160 | /*}}}*/ | |
161 | // CacheDB::GetFileInfo - Get all the info about the file /*{{{*/ | |
162 | // --------------------------------------------------------------------- | |
9209ec47 DK |
163 | bool CacheDB::GetFileInfo(string const &FileName, bool const &DoControl, bool const &DoContents, |
164 | bool const &GenContentsOnly, bool const &DoMD5, bool const &DoSHA1, | |
9a961efc MV |
165 | bool const &DoSHA256, bool const &DoSHA512, |
166 | bool const &checkMtime) | |
cde41ae8 MV |
167 | { |
168 | this->FileName = FileName; | |
169 | ||
170 | if (GetCurStat() == false) | |
b2e465d6 | 171 | { |
cde41ae8 | 172 | return false; |
b2e465d6 | 173 | } |
b2e465d6 | 174 | OldStat = CurStat; |
ff574e76 DK |
175 | |
176 | if (GetFileStat(checkMtime) == false) | |
cde41ae8 MV |
177 | { |
178 | delete Fd; | |
179 | Fd = NULL; | |
180 | return false; | |
181 | } | |
182 | ||
ff574e76 DK |
183 | /* if mtime changed, update CurStat from disk */ |
184 | if (checkMtime == true && OldStat.mtime != CurStat.mtime) | |
185 | CurStat.Flags = FlSize; | |
186 | ||
cde41ae8 MV |
187 | Stats.Bytes += CurStat.FileSize; |
188 | Stats.Packages++; | |
189 | ||
2a5f8389 DK |
190 | if ((DoControl && LoadControl() == false) |
191 | || (DoContents && LoadContents(GenContentsOnly) == false) | |
192 | || (DoMD5 && GetMD5(false) == false) | |
193 | || (DoSHA1 && GetSHA1(false) == false) | |
9a961efc MV |
194 | || (DoSHA256 && GetSHA256(false) == false) |
195 | || (DoSHA512 && GetSHA512(false) == false) | |
196 | ) | |
cde41ae8 MV |
197 | { |
198 | delete Fd; | |
199 | Fd = NULL; | |
200 | delete DebFile; | |
201 | DebFile = NULL; | |
202 | return false; | |
203 | } | |
204 | ||
205 | delete Fd; | |
206 | Fd = NULL; | |
207 | delete DebFile; | |
208 | DebFile = NULL; | |
209 | ||
b2e465d6 AL |
210 | return true; |
211 | } | |
212 | /*}}}*/ | |
213 | // CacheDB::LoadControl - Load Control information /*{{{*/ | |
214 | // --------------------------------------------------------------------- | |
215 | /* */ | |
216 | bool CacheDB::LoadControl() | |
217 | { | |
218 | // Try to read the control information out of the DB. | |
219 | if ((CurStat.Flags & FlControl) == FlControl) | |
220 | { | |
221 | // Lookup the control information | |
222 | InitQuery("cl"); | |
223 | if (Get() == true && Control.TakeControl(Data.data,Data.size) == true) | |
224 | return true; | |
225 | CurStat.Flags &= ~FlControl; | |
226 | } | |
227 | ||
cde41ae8 MV |
228 | if (Fd == NULL && OpenFile() == false) |
229 | { | |
230 | return false; | |
231 | } | |
b2e465d6 AL |
232 | // Create a deb instance to read the archive |
233 | if (DebFile == 0) | |
234 | { | |
235 | DebFile = new debDebFile(*Fd); | |
236 | if (_error->PendingError() == true) | |
237 | return false; | |
238 | } | |
239 | ||
240 | Stats.Misses++; | |
241 | if (Control.Read(*DebFile) == false) | |
242 | return false; | |
243 | ||
244 | if (Control.Control == 0) | |
dc738e7a | 245 | return _error->Error(_("Archive has no control record")); |
b2e465d6 AL |
246 | |
247 | // Write back the control information | |
248 | InitQuery("cl"); | |
249 | if (Put(Control.Control,Control.Length) == true) | |
250 | CurStat.Flags |= FlControl; | |
251 | return true; | |
252 | } | |
253 | /*}}}*/ | |
254 | // CacheDB::LoadContents - Load the File Listing /*{{{*/ | |
255 | // --------------------------------------------------------------------- | |
256 | /* */ | |
9209ec47 | 257 | bool CacheDB::LoadContents(bool const &GenOnly) |
b2e465d6 AL |
258 | { |
259 | // Try to read the control information out of the DB. | |
260 | if ((CurStat.Flags & FlContents) == FlContents) | |
261 | { | |
262 | if (GenOnly == true) | |
263 | return true; | |
264 | ||
265 | // Lookup the contents information | |
266 | InitQuery("cn"); | |
267 | if (Get() == true) | |
268 | { | |
269 | if (Contents.TakeContents(Data.data,Data.size) == true) | |
270 | return true; | |
271 | } | |
272 | ||
273 | CurStat.Flags &= ~FlContents; | |
274 | } | |
275 | ||
cde41ae8 MV |
276 | if (Fd == NULL && OpenFile() == false) |
277 | { | |
278 | return false; | |
279 | } | |
b2e465d6 AL |
280 | // Create a deb instance to read the archive |
281 | if (DebFile == 0) | |
282 | { | |
283 | DebFile = new debDebFile(*Fd); | |
284 | if (_error->PendingError() == true) | |
285 | return false; | |
286 | } | |
287 | ||
288 | if (Contents.Read(*DebFile) == false) | |
289 | return false; | |
290 | ||
291 | // Write back the control information | |
292 | InitQuery("cn"); | |
293 | if (Put(Contents.Data,Contents.CurSize) == true) | |
294 | CurStat.Flags |= FlContents; | |
295 | return true; | |
296 | } | |
297 | /*}}}*/ | |
cde41ae8 MV |
298 | |
299 | static string bytes2hex(uint8_t *bytes, size_t length) { | |
76ef756a MV |
300 | char buf[3]; |
301 | string space; | |
302 | ||
303 | space.reserve(length*2 + 1); | |
304 | for (size_t i = 0; i < length; i++) { | |
305 | snprintf(buf, sizeof(buf), "%02x", bytes[i]); | |
306 | space.append(buf); | |
307 | } | |
308 | return space; | |
cde41ae8 MV |
309 | } |
310 | ||
9209ec47 | 311 | static inline unsigned char xdig2num(char const &dig) { |
cde41ae8 MV |
312 | if (isdigit(dig)) return dig - '0'; |
313 | if ('a' <= dig && dig <= 'f') return dig - 'a' + 10; | |
314 | if ('A' <= dig && dig <= 'F') return dig - 'A' + 10; | |
315 | return 0; | |
316 | } | |
317 | ||
318 | static void hex2bytes(uint8_t *bytes, const char *hex, int length) { | |
319 | while (length-- > 0) { | |
320 | *bytes = 0; | |
321 | if (isxdigit(hex[0]) && isxdigit(hex[1])) { | |
322 | *bytes = xdig2num(hex[0]) * 16 + xdig2num(hex[1]); | |
323 | hex += 2; | |
324 | } | |
325 | bytes++; | |
326 | } | |
327 | } | |
328 | ||
b2e465d6 AL |
329 | // CacheDB::GetMD5 - Get the MD5 hash /*{{{*/ |
330 | // --------------------------------------------------------------------- | |
331 | /* */ | |
9209ec47 | 332 | bool CacheDB::GetMD5(bool const &GenOnly) |
b2e465d6 AL |
333 | { |
334 | // Try to read the control information out of the DB. | |
335 | if ((CurStat.Flags & FlMD5) == FlMD5) | |
336 | { | |
337 | if (GenOnly == true) | |
338 | return true; | |
339 | ||
cde41ae8 | 340 | MD5Res = bytes2hex(CurStat.MD5, sizeof(CurStat.MD5)); |
b2e465d6 AL |
341 | return true; |
342 | } | |
b2e465d6 | 343 | |
cde41ae8 | 344 | Stats.MD5Bytes += CurStat.FileSize; |
b2e465d6 | 345 | |
cde41ae8 MV |
346 | if (Fd == NULL && OpenFile() == false) |
347 | { | |
348 | return false; | |
349 | } | |
b2e465d6 | 350 | MD5Summation MD5; |
cde41ae8 | 351 | if (Fd->Seek(0) == false || MD5.AddFD(Fd->Fd(),CurStat.FileSize) == false) |
b2e465d6 AL |
352 | return false; |
353 | ||
354 | MD5Res = MD5.Result(); | |
cde41ae8 | 355 | hex2bytes(CurStat.MD5, MD5Res.data(), sizeof(CurStat.MD5)); |
b2e465d6 AL |
356 | CurStat.Flags |= FlMD5; |
357 | return true; | |
358 | } | |
359 | /*}}}*/ | |
cde41ae8 MV |
360 | // CacheDB::GetSHA1 - Get the SHA1 hash /*{{{*/ |
361 | // --------------------------------------------------------------------- | |
362 | /* */ | |
9209ec47 | 363 | bool CacheDB::GetSHA1(bool const &GenOnly) |
cde41ae8 MV |
364 | { |
365 | // Try to read the control information out of the DB. | |
366 | if ((CurStat.Flags & FlSHA1) == FlSHA1) | |
367 | { | |
368 | if (GenOnly == true) | |
369 | return true; | |
370 | ||
371 | SHA1Res = bytes2hex(CurStat.SHA1, sizeof(CurStat.SHA1)); | |
372 | return true; | |
373 | } | |
374 | ||
375 | Stats.SHA1Bytes += CurStat.FileSize; | |
376 | ||
377 | if (Fd == NULL && OpenFile() == false) | |
378 | { | |
379 | return false; | |
380 | } | |
381 | SHA1Summation SHA1; | |
382 | if (Fd->Seek(0) == false || SHA1.AddFD(Fd->Fd(),CurStat.FileSize) == false) | |
383 | return false; | |
384 | ||
385 | SHA1Res = SHA1.Result(); | |
386 | hex2bytes(CurStat.SHA1, SHA1Res.data(), sizeof(CurStat.SHA1)); | |
387 | CurStat.Flags |= FlSHA1; | |
388 | return true; | |
389 | } | |
390 | /*}}}*/ | |
391 | // CacheDB::GetSHA256 - Get the SHA256 hash /*{{{*/ | |
392 | // --------------------------------------------------------------------- | |
393 | /* */ | |
9209ec47 | 394 | bool CacheDB::GetSHA256(bool const &GenOnly) |
cde41ae8 MV |
395 | { |
396 | // Try to read the control information out of the DB. | |
397 | if ((CurStat.Flags & FlSHA256) == FlSHA256) | |
398 | { | |
399 | if (GenOnly == true) | |
400 | return true; | |
401 | ||
402 | SHA256Res = bytes2hex(CurStat.SHA256, sizeof(CurStat.SHA256)); | |
403 | return true; | |
404 | } | |
405 | ||
406 | Stats.SHA256Bytes += CurStat.FileSize; | |
407 | ||
408 | if (Fd == NULL && OpenFile() == false) | |
409 | { | |
410 | return false; | |
411 | } | |
412 | SHA256Summation SHA256; | |
413 | if (Fd->Seek(0) == false || SHA256.AddFD(Fd->Fd(),CurStat.FileSize) == false) | |
414 | return false; | |
415 | ||
416 | SHA256Res = SHA256.Result(); | |
417 | hex2bytes(CurStat.SHA256, SHA256Res.data(), sizeof(CurStat.SHA256)); | |
418 | CurStat.Flags |= FlSHA256; | |
419 | return true; | |
420 | } | |
421 | /*}}}*/ | |
9a961efc MV |
422 | // CacheDB::GetSHA256 - Get the SHA256 hash /*{{{*/ |
423 | // --------------------------------------------------------------------- | |
424 | /* */ | |
425 | bool CacheDB::GetSHA512(bool const &GenOnly) | |
426 | { | |
427 | // Try to read the control information out of the DB. | |
428 | if ((CurStat.Flags & FlSHA512) == FlSHA512) | |
429 | { | |
430 | if (GenOnly == true) | |
431 | return true; | |
432 | ||
433 | SHA512Res = bytes2hex(CurStat.SHA512, sizeof(CurStat.SHA512)); | |
434 | return true; | |
435 | } | |
436 | ||
437 | Stats.SHA512Bytes += CurStat.FileSize; | |
438 | ||
439 | if (Fd == NULL && OpenFile() == false) | |
440 | { | |
441 | return false; | |
442 | } | |
443 | SHA512Summation SHA512; | |
444 | if (Fd->Seek(0) == false || SHA512.AddFD(Fd->Fd(),CurStat.FileSize) == false) | |
445 | return false; | |
446 | ||
447 | SHA512Res = SHA512.Result(); | |
448 | hex2bytes(CurStat.SHA512, SHA512Res.data(), sizeof(CurStat.SHA512)); | |
449 | CurStat.Flags |= FlSHA512; | |
450 | return true; | |
451 | } | |
452 | /*}}}*/ | |
b2e465d6 AL |
453 | // CacheDB::Finish - Write back the cache structure /*{{{*/ |
454 | // --------------------------------------------------------------------- | |
455 | /* */ | |
456 | bool CacheDB::Finish() | |
457 | { | |
458 | // Optimize away some writes. | |
459 | if (CurStat.Flags == OldStat.Flags && | |
9bfe66dc | 460 | CurStat.mtime == OldStat.mtime) |
b2e465d6 AL |
461 | return true; |
462 | ||
463 | // Write the stat information | |
464 | CurStat.Flags = htonl(CurStat.Flags); | |
cde41ae8 | 465 | CurStat.FileSize = htonl(CurStat.FileSize); |
b2e465d6 AL |
466 | InitQuery("st"); |
467 | Put(&CurStat,sizeof(CurStat)); | |
468 | CurStat.Flags = ntohl(CurStat.Flags); | |
cde41ae8 MV |
469 | CurStat.FileSize = ntohl(CurStat.FileSize); |
470 | ||
b2e465d6 AL |
471 | return true; |
472 | } | |
473 | /*}}}*/ | |
474 | // CacheDB::Clean - Clean the Database /*{{{*/ | |
475 | // --------------------------------------------------------------------- | |
476 | /* Tidy the database by removing files that no longer exist at all. */ | |
477 | bool CacheDB::Clean() | |
478 | { | |
479 | if (DBLoaded == false) | |
480 | return true; | |
481 | ||
482 | /* I'm not sure what VERSION_MINOR should be here.. 2.4.14 certainly | |
483 | needs the lower one and 2.7.7 needs the upper.. */ | |
b2e465d6 | 484 | DBC *Cursor; |
c9569a1e | 485 | if ((errno = Dbp->cursor(Dbp, NULL, &Cursor, 0)) != 0) |
dc738e7a | 486 | return _error->Error(_("Unable to get a cursor")); |
b2e465d6 AL |
487 | |
488 | DBT Key; | |
489 | DBT Data; | |
490 | memset(&Key,0,sizeof(Key)); | |
491 | memset(&Data,0,sizeof(Data)); | |
492 | while ((errno = Cursor->c_get(Cursor,&Key,&Data,DB_NEXT)) == 0) | |
493 | { | |
592b401a MV |
494 | const char *Colon = (char*)memrchr(Key.data, ':', Key.size); |
495 | if (Colon) | |
b2e465d6 | 496 | { |
592b401a MV |
497 | if (stringcmp(Colon + 1, (char *)Key.data+Key.size,"st") == 0 || |
498 | stringcmp(Colon + 1, (char *)Key.data+Key.size,"cl") == 0 || | |
499 | stringcmp(Colon + 1, (char *)Key.data+Key.size,"cn") == 0) | |
b2e465d6 | 500 | { |
592b401a | 501 | if (FileExists(string((const char *)Key.data,Colon)) == true) |
b2e465d6 AL |
502 | continue; |
503 | } | |
504 | } | |
505 | ||
506 | Cursor->c_del(Cursor,0); | |
507 | } | |
09fab244 | 508 | Dbp->compact(Dbp, NULL, NULL, NULL, NULL, DB_FREE_SPACE, NULL); |
b2e465d6 AL |
509 | |
510 | return true; | |
511 | } | |
512 | /*}}}*/ |