1 // -*- mode: cpp; mode: fold -*-
3 // $Id: cachedb.cc,v 1.7 2004/05/08 19:41:01 mdz Exp $
4 /* ######################################################################
8 Simple uniform interface to a cache database.
10 ##################################################################### */
12 // Include Files /*{{{*/
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 #include <apt-pkg/debfile.h>
23 #include <apt-pkg/gpgv.h>
25 #include <netinet/in.h> // htonl, etc
35 // CacheDB::ReadyDB - Ready the DB2 /*{{{*/
36 // ---------------------------------------------------------------------
37 /* This opens the DB2 file for caching package information */
38 bool CacheDB::ReadyDB(std::string
const &DB
)
42 ReadOnly
= _config
->FindB("APT::FTPArchive::ReadOnlyDB",false);
48 /* Check if the DB was disabled while running and deal with a
50 if (DBFailed() == true)
52 _error
->Warning(_("DB was corrupted, file renamed to %s.old"),DBFile
.c_str());
53 rename(DBFile
.c_str(),(DBFile
+".old").c_str());
58 DBFile
= std::string();
63 db_create(&Dbp
, NULL
, 0);
64 if ((err
= Dbp
->open(Dbp
, NULL
, DB
.c_str(), NULL
, DB_BTREE
,
65 (ReadOnly
?DB_RDONLY
:DB_CREATE
),
68 if (err
== DB_OLD_VERSION
)
70 _error
->Warning(_("DB is old, attempting to upgrade %s"),DBFile
.c_str());
71 err
= Dbp
->upgrade(Dbp
, DB
.c_str(), 0);
73 err
= Dbp
->open(Dbp
, NULL
, DB
.c_str(), NULL
, DB_HASH
,
74 (ReadOnly
?DB_RDONLY
:DB_CREATE
), 0644);
77 // the database format has changed from DB_HASH to DB_BTREE in
81 _error
->Error(_("DB format is invalid. If you upgraded from an older version of apt, please remove and re-create the database."));
86 return _error
->Error(_("Unable to open DB file %s: %s"),DB
.c_str(), db_strerror(err
));
95 // CacheDB::OpenFile - Open the file /*{{{*/
96 // ---------------------------------------------------------------------
98 bool CacheDB::OpenFile()
101 if(Fd
&& Fd
->Name() == this->FileName
)
104 // a different file is open, close it first
105 if(Fd
&& Fd
->Name() != this->FileName
)
109 Fd
= new FileFd(FileName
,FileFd::ReadOnly
);
110 if (_error
->PendingError() == true)
118 // CacheDB::CloseFile - Close the file /*{{{*/
119 void CacheDB::CloseFile()
128 // CacheDB::OpenDebFile - Open a debfile /*{{{*/
129 bool CacheDB::OpenDebFile()
131 // debfile is already open
132 if(DebFile
&& &DebFile
->GetFile() == Fd
)
135 // a different debfile is open, close it first
136 if(DebFile
&& &DebFile
->GetFile() != Fd
)
139 // first open the fd, then pass it to the debDebFile
140 if(OpenFile() == false)
142 DebFile
= new debDebFile(*Fd
);
143 if (_error
->PendingError() == true)
148 // CacheDB::CloseDebFile - Close a debfile again /*{{{*/
149 void CacheDB::CloseDebFile()
160 // CacheDB::GetFileStat - Get stats from the file /*{{{*/
161 // ---------------------------------------------------------------------
162 /* This gets the size from the database if it's there. If we need
163 * to look at the file, also get the mtime from the file. */
164 bool CacheDB::GetFileStat(bool const &doStat
)
166 if ((CurStat
.Flags
& FlSize
) == FlSize
&& doStat
== false)
169 /* Get it from the file. */
170 if (OpenFile() == false)
175 if (fstat(Fd
->Fd(),&St
) != 0)
178 return _error
->Errno("fstat",
179 _("Failed to stat %s"),FileName
.c_str());
181 CurStat
.FileSize
= St
.st_size
;
182 CurStat
.mtime
= htonl(St
.st_mtime
);
183 CurStat
.Flags
|= FlSize
;
188 // CacheDB::GetCurStat - Set the CurStat variable. /*{{{*/
189 // ---------------------------------------------------------------------
190 /* Sets the CurStat variable. Either to 0 if no database is used
191 * or to the value in the database if one is used */
192 bool CacheDB::GetCurStat()
194 memset(&CurStat
,0,sizeof(CurStat
));
198 /* First see if there is anything about it
201 /* Get the flags (and mtime) */
203 // Ensure alignment of the returned structure
204 Data
.data
= &CurStat
;
205 Data
.ulen
= sizeof(CurStat
);
206 Data
.flags
= DB_DBT_USERMEM
;
211 CurStat
.Flags
= ntohl(CurStat
.Flags
);
212 CurStat
.FileSize
= ntohl(CurStat
.FileSize
);
217 // CacheDB::GetFileInfo - Get all the info about the file /*{{{*/
218 // ---------------------------------------------------------------------
219 bool CacheDB::GetFileInfo(std::string
const &FileName
, bool const &DoControl
,
220 bool const &DoContents
,
221 bool const &GenContentsOnly
,
222 bool const &DoSource
,
223 bool const &DoMD5
, bool const &DoSHA1
,
224 bool const &DoSHA256
, bool const &DoSHA512
,
225 bool const &checkMtime
)
228 this->FileName
= FileName
;
230 if (GetCurStat() == false)
234 if (GetFileStat(checkMtime
) == false)
237 /* if mtime changed, update CurStat from disk */
238 if (checkMtime
== true && OldStat
.mtime
!= CurStat
.mtime
)
239 CurStat
.Flags
= FlSize
;
241 Stats
.Bytes
+= CurStat
.FileSize
;
244 if ((DoControl
&& LoadControl() == false)
245 || (DoContents
&& LoadContents(GenContentsOnly
) == false)
246 || (DoSource
&& LoadSource() == false)
247 || (DoMD5
&& GetMD5(false) == false)
248 || (DoSHA1
&& GetSHA1(false) == false)
249 || (DoSHA256
&& GetSHA256(false) == false)
250 || (DoSHA512
&& GetSHA512(false) == false) )
259 bool CacheDB::LoadSource()
261 // Try to read the control information out of the DB.
262 if ((CurStat
.Flags
& FlSource
) == FlSource
)
264 // Lookup the control information
266 if (Get() == true && Dsc
.TakeDsc(Data
.data
, Data
.size
) == true)
270 CurStat
.Flags
&= ~FlSource
;
272 if (OpenFile() == false)
276 if (Dsc
.Read(FileName
) == false)
280 return _error
->Error(_("Failed to read .dsc"));
282 // Write back the control information
284 if (Put(Dsc
.Data
, Dsc
.Length
) == true)
285 CurStat
.Flags
|= FlSource
;
290 // CacheDB::LoadControl - Load Control information /*{{{*/
291 // ---------------------------------------------------------------------
293 bool CacheDB::LoadControl()
295 // Try to read the control information out of the DB.
296 if ((CurStat
.Flags
& FlControl
) == FlControl
)
298 // Lookup the control information
300 if (Get() == true && Control
.TakeControl(Data
.data
,Data
.size
) == true)
302 CurStat
.Flags
&= ~FlControl
;
305 if(OpenDebFile() == false)
309 if (Control
.Read(*DebFile
) == false)
312 if (Control
.Control
== 0)
313 return _error
->Error(_("Archive has no control record"));
315 // Write back the control information
317 if (Put(Control
.Control
,Control
.Length
) == true)
318 CurStat
.Flags
|= FlControl
;
322 // CacheDB::LoadContents - Load the File Listing /*{{{*/
323 // ---------------------------------------------------------------------
325 bool CacheDB::LoadContents(bool const &GenOnly
)
327 // Try to read the control information out of the DB.
328 if ((CurStat
.Flags
& FlContents
) == FlContents
)
333 // Lookup the contents information
337 if (Contents
.TakeContents(Data
.data
,Data
.size
) == true)
341 CurStat
.Flags
&= ~FlContents
;
344 if(OpenDebFile() == false)
348 if (Contents
.Read(*DebFile
) == false)
351 // Write back the control information
353 if (Put(Contents
.Data
,Contents
.CurSize
) == true)
354 CurStat
.Flags
|= FlContents
;
359 static std::string
bytes2hex(uint8_t *bytes
, size_t length
) {
363 space
.reserve(length
*2 + 1);
364 for (size_t i
= 0; i
< length
; i
++) {
365 snprintf(buf
, sizeof(buf
), "%02x", bytes
[i
]);
371 static inline unsigned char xdig2num(char const &dig
) {
372 if (isdigit(dig
)) return dig
- '0';
373 if ('a' <= dig
&& dig
<= 'f') return dig
- 'a' + 10;
374 if ('A' <= dig
&& dig
<= 'F') return dig
- 'A' + 10;
378 static void hex2bytes(uint8_t *bytes
, const char *hex
, int length
) {
379 while (length
-- > 0) {
381 if (isxdigit(hex
[0]) && isxdigit(hex
[1])) {
382 *bytes
= xdig2num(hex
[0]) * 16 + xdig2num(hex
[1]);
389 // CacheDB::GetMD5 - Get the MD5 hash /*{{{*/
390 // ---------------------------------------------------------------------
392 bool CacheDB::GetMD5(bool const &GenOnly
)
394 // Try to read the control information out of the DB.
395 if ((CurStat
.Flags
& FlMD5
) == FlMD5
)
400 MD5Res
= bytes2hex(CurStat
.MD5
, sizeof(CurStat
.MD5
));
404 Stats
.MD5Bytes
+= CurStat
.FileSize
;
406 if (OpenFile() == false)
410 if (Fd
->Seek(0) == false || MD5
.AddFD(*Fd
, CurStat
.FileSize
) == false)
413 MD5Res
= MD5
.Result();
414 hex2bytes(CurStat
.MD5
, MD5Res
.data(), sizeof(CurStat
.MD5
));
415 CurStat
.Flags
|= FlMD5
;
419 // CacheDB::GetSHA1 - Get the SHA1 hash /*{{{*/
420 // ---------------------------------------------------------------------
422 bool CacheDB::GetSHA1(bool const &GenOnly
)
424 // Try to read the control information out of the DB.
425 if ((CurStat
.Flags
& FlSHA1
) == FlSHA1
)
430 SHA1Res
= bytes2hex(CurStat
.SHA1
, sizeof(CurStat
.SHA1
));
434 Stats
.SHA1Bytes
+= CurStat
.FileSize
;
436 if (OpenFile() == false)
440 if (Fd
->Seek(0) == false || SHA1
.AddFD(*Fd
, CurStat
.FileSize
) == false)
443 SHA1Res
= SHA1
.Result();
444 hex2bytes(CurStat
.SHA1
, SHA1Res
.data(), sizeof(CurStat
.SHA1
));
445 CurStat
.Flags
|= FlSHA1
;
449 // CacheDB::GetSHA256 - Get the SHA256 hash /*{{{*/
450 // ---------------------------------------------------------------------
452 bool CacheDB::GetSHA256(bool const &GenOnly
)
454 // Try to read the control information out of the DB.
455 if ((CurStat
.Flags
& FlSHA256
) == FlSHA256
)
460 SHA256Res
= bytes2hex(CurStat
.SHA256
, sizeof(CurStat
.SHA256
));
464 Stats
.SHA256Bytes
+= CurStat
.FileSize
;
466 if (OpenFile() == false)
469 SHA256Summation SHA256
;
470 if (Fd
->Seek(0) == false || SHA256
.AddFD(*Fd
, CurStat
.FileSize
) == false)
473 SHA256Res
= SHA256
.Result();
474 hex2bytes(CurStat
.SHA256
, SHA256Res
.data(), sizeof(CurStat
.SHA256
));
475 CurStat
.Flags
|= FlSHA256
;
479 // CacheDB::GetSHA256 - Get the SHA256 hash /*{{{*/
480 // ---------------------------------------------------------------------
482 bool CacheDB::GetSHA512(bool const &GenOnly
)
484 // Try to read the control information out of the DB.
485 if ((CurStat
.Flags
& FlSHA512
) == FlSHA512
)
490 SHA512Res
= bytes2hex(CurStat
.SHA512
, sizeof(CurStat
.SHA512
));
494 Stats
.SHA512Bytes
+= CurStat
.FileSize
;
496 if (OpenFile() == false)
499 SHA512Summation SHA512
;
500 if (Fd
->Seek(0) == false || SHA512
.AddFD(*Fd
, CurStat
.FileSize
) == false)
503 SHA512Res
= SHA512
.Result();
504 hex2bytes(CurStat
.SHA512
, SHA512Res
.data(), sizeof(CurStat
.SHA512
));
505 CurStat
.Flags
|= FlSHA512
;
509 // CacheDB::Finish - Write back the cache structure /*{{{*/
510 // ---------------------------------------------------------------------
512 bool CacheDB::Finish()
514 // Optimize away some writes.
515 if (CurStat
.Flags
== OldStat
.Flags
&&
516 CurStat
.mtime
== OldStat
.mtime
)
519 // Write the stat information
520 CurStat
.Flags
= htonl(CurStat
.Flags
);
521 CurStat
.FileSize
= htonl(CurStat
.FileSize
);
523 Put(&CurStat
,sizeof(CurStat
));
524 CurStat
.Flags
= ntohl(CurStat
.Flags
);
525 CurStat
.FileSize
= ntohl(CurStat
.FileSize
);
530 // CacheDB::Clean - Clean the Database /*{{{*/
531 // ---------------------------------------------------------------------
532 /* Tidy the database by removing files that no longer exist at all. */
533 bool CacheDB::Clean()
535 if (DBLoaded
== false)
538 /* I'm not sure what VERSION_MINOR should be here.. 2.4.14 certainly
539 needs the lower one and 2.7.7 needs the upper.. */
541 if ((errno
= Dbp
->cursor(Dbp
, NULL
, &Cursor
, 0)) != 0)
542 return _error
->Error(_("Unable to get a cursor"));
546 memset(&Key
,0,sizeof(Key
));
547 memset(&Data
,0,sizeof(Data
));
548 while ((errno
= Cursor
->c_get(Cursor
,&Key
,&Data
,DB_NEXT
)) == 0)
550 const char *Colon
= (char*)memrchr(Key
.data
, ':', Key
.size
);
553 if (stringcmp(Colon
+ 1, (char *)Key
.data
+Key
.size
,"st") == 0 ||
554 stringcmp(Colon
+ 1, (char *)Key
.data
+Key
.size
,"cl") == 0 ||
555 stringcmp(Colon
+ 1, (char *)Key
.data
+Key
.size
,"cs") == 0 ||
556 stringcmp(Colon
+ 1, (char *)Key
.data
+Key
.size
,"cn") == 0)
558 std::string FileName
= std::string((const char *)Key
.data
,Colon
);
559 if (FileExists(FileName
) == true) {
564 Cursor
->c_del(Cursor
,0);
566 int res
= Dbp
->compact(Dbp
, NULL
, NULL
, NULL
, NULL
, DB_FREE_SPACE
, NULL
);
568 _error
->Warning("compact failed with result %i", res
);
570 if(_config
->FindB("Debug::APT::FTPArchive::Clean", false) == true)
571 Dbp
->stat_print(Dbp
, 0);