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