~ubuntu-branches/ubuntu/precise/rpm/precise-proposed

"Packages:Name:Basenames:Group:Requirename:Providename:Conflictname:ObsoleteName:Triggername:Dirnames:Requireversion:Provideversion:Installtid:Sigmd5:Sha1header:Filedigests:Depends:Pubkeys";

114

char * dbiTagStr = NULL;

115

char * o, * oe;

116

rpmTag rpmtag;

117

118

dbiTags.nlink++;

119

if (dbiTags.tags != NULL && dbiTags.max > 0) {

120

return;

121

}

122

123

dbiTagStr = rpmExpand("%{?_dbi_tags}", NULL);

124

if (!(dbiTagStr && *dbiTagStr)) {

125

dbiTagStr = _free(dbiTagStr);

126

dbiTagStr = xstrdup(_dbiTagStr_default);

127

}

128

129

/* Discard previous values. */

130

dbiTags.tags = _free(dbiTags.tags);

131

dbiTags.max = 0;

132

133

/* Always allocate package index */

134

dbiTags.tags = xcalloc(1, sizeof(*dbiTags.tags));

135

dbiTags.tags[dbiTags.max++] = RPMDBI_PACKAGES;

136

137

for (o = dbiTagStr; o && *o; o = oe) {

138

while (*o && risspace(*o))

139

o++;

140

if (*o == '\0')

141

break;

142

for (oe = o; oe && *oe; oe++) {

143

if (risspace(*oe))

144

break;

145

if (oe[0] == ':' && !(oe[1] == '/' && oe[2] == '/'))

146

break;

147

}

148

if (oe && *oe)

149

*oe++ = '\0';

150

rpmtag = rpmTagGetValue(o);

151

if (rpmtag == RPMTAG_NOT_FOUND) {

152

rpmlog(RPMLOG_WARNING,

153

_("dbiTagsInit: unrecognized tag name: \"%s\" ignored\n"), o);

154

continue;

155

}

156

if (dbiTagToDbix(rpmtag) >= 0)

157

continue;

158

159

dbiTags.tags = xrealloc(dbiTags.tags, (dbiTags.max + 1) * sizeof(*dbiTags.tags)); /* XXX memory leak */

160

dbiTags.tags[dbiTags.max++] = rpmtag;

161

}

162

163

dbiTagStr = _free(dbiTagStr);

164

}

165

166

static void dbiTagsFree(void)

167

{

168

if (--dbiTags.nlink > 0) {

169

return;

170

}

171

dbiTags.tags = _free(dbiTags.tags);

172

dbiTags.max = 0;

173

}

174

175

#define DB1vec NULL

176

#define DB2vec NULL

177

178

#ifdef HAVE_DB_H

179

extern struct _dbiVec db3vec;

180

#define DB3vec &db3vec

181

#else

182

#define DB3vec NULL

183

#endif

184

185

#ifdef HAVE_SQLITE3_H

186

extern struct _dbiVec sqlitevec;

187

#define SQLITEvec &sqlitevec

188

#else

189

#define SQLITEvec NULL

190

#endif

191

192

static struct _dbiVec * const mydbvecs[] = {

193

DB1vec, DB1vec, DB2vec, DB3vec, SQLITEvec, NULL

194

};

195

196

dbiIndex dbiOpen(rpmdb db, rpmTag rpmtag, unsigned int flags)

static rpmDbiTag const dbiTags[] = {

RPMDBI_PACKAGES,

RPMDBI_NAME,

RPMDBI_BASENAMES,

RPMDBI_GROUP,

RPMDBI_REQUIRENAME,

RPMDBI_PROVIDENAME,

RPMDBI_CONFLICTNAME,

RPMDBI_OBSOLETENAME,

RPMDBI_TRIGGERNAME,

RPMDBI_DIRNAMES,

RPMDBI_INSTALLTID,

RPMDBI_SIGMD5,

RPMDBI_SHA1HEADER,

};

#define dbiTagsMax (sizeof(dbiTags) / sizeof(rpmDbiTag))

/* A single item from an index database (i.e. the "data returned"). */

struct dbiIndexItem {

unsigned int hdrNum; /*!< header instance in db */

unsigned int tagNum; /*!< tag index in header */

};

/* Items retrieved from the index database.*/

typedef struct _dbiIndexSet {

struct dbiIndexItem * recs; /*!< array of records */

unsigned int count; /*!< number of records */

size_t alloced; /*!< alloced size */

} * dbiIndexSet;

static int addToIndex(dbiIndex dbi, rpmTagVal rpmtag, unsigned int hdrNum, Header h);

static unsigned int pkgInstance(dbiIndex dbi, int alloc);

static rpmdb rpmdbUnlink(rpmdb db);

static int buildIndexes(rpmdb db)

{

int rc = 0;

Header h;

rpmdbMatchIterator mi;

rc += rpmdbOpenAll(db);

/* If the main db was just created, this is expected - dont whine */

if (!(dbiFlags(db->_dbi[0]) & DBI_CREATED)) {

rpmlog(RPMLOG_WARNING,

_("Generating %d missing index(es), please wait...\n"),

db->db_buildindex);

}

/* Don't call us again */

db->db_buildindex = 0;

dbSetFSync(db->db_dbenv, 0);

mi = rpmdbInitIterator(db, RPMDBI_PACKAGES, NULL, 0);

while ((h = rpmdbNextIterator(mi))) {

unsigned int hdrNum = headerGetInstance(h);

/* Build all secondary indexes which were created on open */

for (int dbix = 1; dbix < dbiTagsMax; dbix++) {

dbiIndex dbi = db->_dbi[dbix];

100

if (dbi && (dbiFlags(dbi) & DBI_CREATED)) {

101

rc += addToIndex(dbi, dbiTags[dbix], hdrNum, h);

102

}

103

}

104

}

105

rpmdbFreeIterator(mi);

106

dbSetFSync(db->db_dbenv, !db->cfg.db_no_fsync);

107

return rc;

108

}

109

110

static int uintCmp(unsigned int a, unsigned int b)

111

{

112

return (a != b);

113

}

114

115

static unsigned int uintId(unsigned int a)

116

{

117

return a;

118

}

119

120

/** \ingroup dbi

121

* Return handle for an index database.

122

* @param db rpm database

123

* @param rpmtag rpm tag

124

* @param flags

125

* @return index database handle

126

127

static dbiIndex rpmdbOpenIndex(rpmdb db, rpmDbiTagVal rpmtag, int flags)

197

128

{

198

129

int dbix;

199

130

dbiIndex dbi = NULL;

200

int _dbapi, _dbapi_rebuild, _dbapi_wanted;

201

131

int rc = 0;

202

132

203

133

if (db == NULL)

204

134

return NULL;

205

135

206

dbix = dbiTagToDbix(rpmtag);

207

if (dbix < 0 || dbix >= dbiTags.max)

136

for (dbix = 0; dbix < dbiTagsMax; dbix++) {

137

if (rpmtag == dbiTags[dbix])

138

break;

139

}

140

if (dbix >= dbiTagsMax)

208

141

return NULL;

209

142

210

143

/* Is this index already open ? */

211

/* FIX: db->_dbi may be NULL */

212

144

if ((dbi = db->_dbi[dbix]) != NULL)

213

145

return dbi;

214

146

215

/* Try to ensure db home exists, error out if we cant even create */

216

if (!db->db_mkdirDone) {

217

const char *dbhome = rpmdbHome(db);

218

db->db_mkdirDone = (rpmioMkpath(dbhome, 0755, getuid(), getgid()) == 0);

219

if (!db->db_mkdirDone) return NULL;

220

}

221

222

_dbapi_rebuild = rpmExpandNumeric("%{_dbapi_rebuild}");

223

if (_dbapi_rebuild < 1 || _dbapi_rebuild > 4)

224

_dbapi_rebuild = 4;

225

/* _dbapi_wanted = (_rebuildinprogress ? -1 : db->db_api); */

226

_dbapi_wanted = (_rebuildinprogress ? _dbapi_rebuild : db->db_api);

227

228

switch (_dbapi_wanted) {

229

default:

230

_dbapi = _dbapi_wanted;

231

if (_dbapi < 0 || _dbapi >= 5 || mydbvecs[_dbapi] == NULL) {

232

rpmlog(RPMLOG_ERR, _("dbiOpen: dbapi %d not available\n"), _dbapi);

233

return NULL;

234

}

235

errno = 0;

236

dbi = NULL;

237

rc = (*mydbvecs[_dbapi]->open) (db, rpmtag, &dbi);

238

if (rc) {

239

static int _printed[32];

240

if (!_printed[dbix & 0x1f]++)

241

rpmlog(RPMLOG_ERR,

242

_("cannot open %s index using db%d - %s (%d)\n"),

243

rpmTagGetName(rpmtag), _dbapi,

244

(rc > 0 ? strerror(rc) : ""), rc);

245

_dbapi = -1;

246

}

247

break;

248

case -1:

249

_dbapi = 5;

250

while (_dbapi-- > 1) {

251

if (mydbvecs[_dbapi] == NULL)

252

continue;

253

errno = 0;

254

dbi = NULL;

255

rc = (*mydbvecs[_dbapi]->open) (db, rpmtag, &dbi);

256

if (rc == 0 && dbi)

257

break;

258

}

259

if (_dbapi <= 0) {

260

static int _printed[32];

261

if (!_printed[dbix & 0x1f]++)

262

rpmlog(RPMLOG_ERR, _("cannot open %s index\n"),

263

rpmTagGetName(rpmtag));

264

rc = 1;

265

goto exit;

266

}

267

if (db->db_api == -1 && _dbapi > 0)

268

db->db_api = _dbapi;

269

break;

270

}

271

272

/* We don't ever _REQUIRE_ conversion... */

273

#define SQLITE_HACK

274

#ifdef SQLITE_HACK_XXX

275

/* Require conversion. */

276

if (rc && _dbapi_wanted >= 0 && _dbapi != _dbapi_wanted && _dbapi_wanted == _dbapi_rebuild) {

277

rc = (_rebuildinprogress ? 0 : 1);

278

goto exit;

279

}

280

281

/* Suggest possible configuration */

282

if (_dbapi_wanted >= 0 && _dbapi != _dbapi_wanted) {

283

rc = 1;

284

goto exit;

285

}

286

287

/* Suggest possible configuration */

288

if (_dbapi_wanted < 0 && _dbapi != _dbapi_rebuild) {

289

rc = (_rebuildinprogress ? 0 : 1);

290

goto exit;

291

}

292

#endif

293

294

exit:

295

if (dbi != NULL && rc == 0) {

147

errno = 0;

148

dbi = NULL;

149

rc = dbiOpen(db, rpmtag, &dbi, flags);

150

151

if (rc) {

152

static int _printed[32];

153

if (!_printed[dbix & 0x1f]++)

154

rpmlog(RPMLOG_ERR, _("cannot open %s index using db%d - %s (%d)\n"),

155

rpmTagGetName(rpmtag), db->db_ver,

156

(rc > 0 ? strerror(rc) : ""), rc);

157

} else {

296

158

db->_dbi[dbix] = dbi;

297

if (rpmtag == RPMDBI_PACKAGES && db->db_bits == NULL) {

298

db->db_nbits = 1024;

299

if (!dbiStat(dbi, DB_FAST_STAT)) {

300

DB_HASH_STAT * hash = (DB_HASH_STAT *)dbi->dbi_stats;

301

if (hash)

302

db->db_nbits += hash->hash_nkeys;

303

}

304

db->db_bits = PBM_ALLOC(db->db_nbits);

159

int verifyonly = (flags & RPMDB_FLAG_VERIFYONLY);

160

int rebuild = (db->db_flags & RPMDB_FLAG_REBUILD);

161

if (dbiType(dbi) == DBI_PRIMARY) {

162

/* Allocate based on max header instance number + some reserve */

163

if (!verifyonly && (db->db_checked == NULL)) {

164

db->db_checked = intHashCreate(1024 + pkgInstance(dbi, 0) / 4,

165

uintId, uintCmp, NULL);

166

}

167

/* If primary got created, we can safely run without fsync */

168

if ((dbiFlags(dbi) & DBI_CREATED) || db->cfg.db_no_fsync) {

169

rpmlog(RPMLOG_DEBUG, "disabling fsync on database\n");

170

db->cfg.db_no_fsync = 1;

171

dbSetFSync(db->db_dbenv, 0);

172

}

173

} else { /* secondary index */

174

if (!rebuild && !verifyonly && (dbiFlags(dbi) & DBI_CREATED)) {

175

rpmlog(RPMLOG_DEBUG, "index %s needs creating\n", dbiName(dbi));

176

db->db_buildindex++;

177

if (db->db_buildindex == 1) {

178

buildIndexes(db);

179

}

180

}

305

181

}

306

182

}

307

#ifdef HAVE_DB_H

308

else

309

dbi = db3Free(dbi);

310

#endif

311

183

312

/* FIX: db->_dbi may be NULL */

313

184

return dbi;

314

185

}

315

186

316

/* Retrieve (key,data) pair from index database. */

317

int dbiGet(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,

318

unsigned int flags)

319

{

320

int rc;

321

assert((flags == DB_NEXT) || (key->data != NULL && key->size > 0));

322

(void) rpmswEnter(&dbi->dbi_rpmdb->db_getops, 0);

323

rc = (dbi->dbi_vec->cget) (dbi, dbcursor, key, data, flags);

324

(void) rpmswExit(&dbi->dbi_rpmdb->db_getops, data->size);

325

return rc;

326

}

327

328

/* Store (key,data) pair in index database. */

329

int dbiPut(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,

330

unsigned int flags)

331

{

332

int rc;

333

assert(key->data != NULL && key->size > 0 && data->data != NULL && data->size > 0);

334

(void) rpmswEnter(&dbi->dbi_rpmdb->db_putops, (ssize_t) 0);

335

rc = (dbi->dbi_vec->cput) (dbi, dbcursor, key, data, flags);

336

(void) rpmswExit(&dbi->dbi_rpmdb->db_putops, (ssize_t) data->size);

337

return rc;

338

}

339

340

/**

341

* Create and initialize item for index database set.

342

* @param hdrNum header instance in db

343

* @param tagNum tag index in header

344

* @return new item

345

346

static dbiIndexItem dbiIndexNewItem(unsigned int hdrNum, unsigned int tagNum)

347

{

348

dbiIndexItem rec = xcalloc(1, sizeof(*rec));

349

rec->hdrNum = hdrNum;

350

rec->tagNum = tagNum;

351

return rec;

352

}

353

354

187

union _dbswap {

355

188

unsigned int ui;

356

189

unsigned char uc[4];

396

229

const char * sdbir;

397

230

dbiIndexSet set;

398

231

unsigned int i;

232

dbiIndexType itype = dbiType(dbi);

399

233

400

234

if (dbi == NULL || data == NULL || setp == NULL)

401

235

return -1;

406

240

}

407

241

408

242

set = xcalloc(1, sizeof(*set));

409

dbiGrowSet(set, data->size / dbi->dbi_jlen);

410

set->count = data->size / dbi->dbi_jlen;

243

dbiGrowSet(set, data->size / itype);

244

set->count = data->size / itype;

411

245

412

switch (dbi->dbi_jlen) {

246

switch (itype) {

413

247

default:

414

case 2*sizeof(int32_t):

248

case DBI_SECONDARY:

415

249

for (i = 0; i < set->count; i++) {

416

250

union _dbswap hdrNum, tagNum;

417

251

427

261

set->recs[i].tagNum = tagNum.ui;

428

262

}

429

263

break;

430

case 1*sizeof(int32_t):

264

case DBI_PRIMARY:

431

265

for (i = 0; i < set->count; i++) {

432

266

union _dbswap hdrNum;

433

267

457

291

int _dbbyteswapped = dbiByteSwapped(dbi);

458

292

char * tdbir;

459

293

unsigned int i;

294

dbiIndexType itype = dbiType(dbi);

460

295

461

296

if (dbi == NULL || data == NULL || set == NULL)

462

297

return -1;

463

298

464

data->size = set->count * (dbi->dbi_jlen);

299

data->size = set->count * itype;

465

300

if (data->size == 0) {

466

301

data->data = NULL;

467

302

return 0;

468

303

}

469

304

tdbir = data->data = xmalloc(data->size);

470

305

471

switch (dbi->dbi_jlen) {

306

switch (itype) {

472

307

default:

473

case 2*sizeof(int32_t):

308

case DBI_SECONDARY:

474

309

for (i = 0; i < set->count; i++) {

475

310

union _dbswap hdrNum, tagNum;

476

311

488

323

tdbir += sizeof(tagNum.ui);

489

324

}

490

325

break;

491

case 1*sizeof(int32_t):

326

case DBI_PRIMARY:

492

327

for (i = 0; i < set->count; i++) {

493

328

union _dbswap hdrNum;

494

329

581

416

return (numCopied == num);

582

417

}

583

418

584

/* XXX transaction.c */

585

unsigned int dbiIndexSetCount(dbiIndexSet set) {

419

/* Count items in index database set. */

420

static unsigned int dbiIndexSetCount(dbiIndexSet set) {

586

421

return set->count;

587

422

}

588

423

589

/* XXX transaction.c */

590

unsigned int dbiIndexRecordOffset(dbiIndexSet set, int recno) {

424

/* Return record offset of header from element in index database set. */

425

static unsigned int dbiIndexRecordOffset(dbiIndexSet set, int recno) {

591

426

return set->recs[recno].hdrNum;

592

427

}

593

428

594

/* XXX transaction.c */

595

unsigned int dbiIndexRecordFileNumber(dbiIndexSet set, int recno) {

429

/* Return file index from element in index database set. */

430

static unsigned int dbiIndexRecordFileNumber(dbiIndexSet set, int recno) {

596

431

return set->recs[recno].tagNum;

597

432

}

598

433

599

/* XXX transaction.c */

600

dbiIndexSet dbiFreeIndexSet(dbiIndexSet set) {

434

/* Destroy set of index database items */

435

static dbiIndexSet dbiFreeIndexSet(dbiIndexSet set) {

601

436

if (set) {

602

437

set->recs = _free(set->recs);

603

438

set = _free(set);

606

441

}

607

442

608

443

typedef struct miRE_s {

609

rpmTag tag; /*!< header tag */

444

rpmTagVal tag; /*!< header tag */

610

445

rpmMireMode mode; /*!< pattern match mode */

611

446

char * pattern; /*!< pattern string */

612

447

int notmatch; /*!< like "grep -v" */

621

456

void * mi_keyp;

622

457

size_t mi_keylen;

623

458

rpmdb mi_db;

624

rpmTag mi_rpmtag;

459

rpmDbiTagVal mi_rpmtag;

625

460

dbiIndexSet mi_set;

626

461

DBC * mi_dbc;

627

DBT mi_key;

628

DBT mi_data;

629

462

int mi_setx;

630

463

Header mi_h;

631

464

int mi_sorted;

641

474

642

475

};

643

476

477

struct rpmdbIndexIterator_s {

478

rpmdbIndexIterator ii_next;

479

rpmdb ii_db;

480

dbiIndex ii_dbi;

481

rpmDbiTag ii_rpmtag;

482

DBC * ii_dbc;

483

DBT ii_key;

484

dbiIndexSet ii_set;

485

};

486

644

487

static rpmdb rpmdbRock;

645

646

488

static rpmdbMatchIterator rpmmiRock;

489

static rpmdbIndexIterator rpmiiRock;

647

490

648

491

int rpmdbCheckTerminate(int terminate)

649

492

{

718

561

return sigprocmask(SIG_SETMASK, oldMask, NULL);

719

562

}

720

563

721

#define _DB_ROOT "/"

722

#define _DB_HOME "%{_dbpath}"

723

#define _DB_FULLPATH NULL

724

#define _DB_FLAGS 0

725

#define _DB_MODE 0

726

#define _DB_PERMS 0644

727

728

#define _DB_MAJOR -1

729

#define _DB_ERRPFX "rpmdb"

730

731

static struct rpmdb_s const dbTemplate = {

732

_DB_ROOT, _DB_HOME, _DB_FULLPATH, _DB_FLAGS, _DB_MODE, _DB_PERMS,

733

_DB_MAJOR, _DB_ERRPFX

734

};

735

736

static int isTemporaryDB(rpmTag rpmtag)

737

{

738

int rc = 0;

739

switch (rpmtag) {

740

case RPMDBI_AVAILABLE:

741

case RPMDBI_ADDED:

742

case RPMDBI_REMOVED:

743

case RPMDBI_DEPENDS:

744

rc = 1;

745

break;

746

default:

747

break;

748

}

749

return rc;

750

}

751

752

564

rpmop rpmdbOp(rpmdb rpmdb, rpmdbOpX opx)

753

565

{

754

566

rpmop op = NULL;

772

584

{

773

585

const char *dbdir = NULL;

774

586

if (db) {

775

dbdir = db->db_chrootDone ? db->db_home : db->db_fullpath;

587

dbdir = rpmChrootDone() ? db->db_home : db->db_fullpath;

776

588

}

777

589

return dbdir;

778

590

}

779

591

780

int rpmdbSetChrootDone(rpmdb db, int chrootDone)

781

{

782

int ochrootDone = 0;

783

if (db != NULL) {

784

ochrootDone = db->db_chrootDone;

785

db->db_chrootDone = chrootDone;

786

}

787

return ochrootDone;

788

}

789

790

592

int rpmdbOpenAll(rpmdb db)

791

593

{

792

int dbix;

793

594

int rc = 0;

794

595

795

596

if (db == NULL) return -2;

796

597

797

if (dbiTags.tags != NULL)

798

for (dbix = 0; dbix < dbiTags.max; dbix++) {

799

if (db->_dbi[dbix] != NULL)

800

continue;

801

/* Filter out temporary databases */

802

if (isTemporaryDB(dbiTags.tags[dbix]))

803

continue;

804

(void) dbiOpen(db, dbiTags.tags[dbix], db->db_flags);

598

for (int dbix = 0; dbix < dbiTagsMax; dbix++) {

599

dbiIndex dbi = db->_dbi[dbix];

600

if (dbi == NULL) {

601

rc += (rpmdbOpenIndex(db, dbiTags[dbix], db->db_flags) == NULL);

602

}

805

603

}

806

604

return rc;

807

605

}

808

606

809

int rpmdbCloseDBI(rpmdb db, rpmTag rpmtag)

607

static int dbiForeach(dbiIndex *dbis,

608

int (*func) (dbiIndex, unsigned int), int del)

810

609

{

811

int dbix;

812

int rc = 0;

813

814

if (db == NULL || db->_dbi == NULL || dbiTags.tags == NULL)

815

return 0;

816

817

for (dbix = 0; dbix < dbiTags.max; dbix++) {

818

if (dbiTags.tags[dbix] != rpmtag)

610

int xx, rc = 0;

611

for (int dbix = dbiTagsMax; --dbix >= 0; ) {

612

if (dbis[dbix] == NULL)

819

613

continue;

820

if (db->_dbi[dbix] != NULL) {

821

int xx;

822

/* FIX: double indirection. */

823

xx = dbiClose(db->_dbi[dbix], 0);

824

if (xx && rc == 0) rc = xx;

825

db->_dbi[dbix] = NULL;

826

}

827

break;

614

xx = func(dbis[dbix], 0);

615

if (xx && rc == 0) rc = xx;

616

if (del)

617

dbis[dbix] = NULL;

828

618

}

829

619

return rc;

830

620

}

831

621

832

/* XXX query.c, rpminstall.c, verify.c */

833

622

int rpmdbClose(rpmdb db)

834

623

{

835

624

rpmdb * prev, next;

836

int dbix;

837

625

int rc = 0;

838

626

839

627

if (db == NULL)

840

628

goto exit;

841

629

842

(void) rpmdbUnlink(db, RPMDBG_M("rpmdbClose"));

630

(void) rpmdbUnlink(db);

843

631

844

632

if (db->nrefs > 0)

845

633

goto exit;

846

634

847

if (db->_dbi)

848

for (dbix = db->db_ndbi; --dbix >= 0; ) {

849

int xx;

850

if (db->_dbi[dbix] == NULL)

851

continue;

852

xx = dbiClose(db->_dbi[dbix], 0);

853

if (xx && rc == 0) rc = xx;

854

db->_dbi[dbix] = NULL;

855

}

856

db->db_errpfx = _free(db->db_errpfx);

635

/* Always re-enable fsync on close of rw-database */

636

if ((db->db_mode & O_ACCMODE) != O_RDONLY)

637

dbSetFSync(db->db_dbenv, 1);

638

639

rc = dbiForeach(db->_dbi, dbiClose, 1);

640

857

641

db->db_root = _free(db->db_root);

858

642

db->db_home = _free(db->db_home);

859

643

db->db_fullpath = _free(db->db_fullpath);

860

db->db_bits = PBM_FREE(db->db_bits);

644

db->db_checked = intHashFree(db->db_checked);

861

645

db->_dbi = _free(db->_dbi);

862

646

863

647

prev = &rpmdbRock;

870

654

871

655

db = _free(db);

872

656

873

dbiTagsFree();

874

875

657

exit:

876

658

(void) rpmsqEnable(-SIGHUP, NULL);

877

659

(void) rpmsqEnable(-SIGINT, NULL);

883

665

884

666

int rpmdbSync(rpmdb db)

885

667

{

886

int dbix;

887

int rc = 0;

888

889

668

if (db == NULL) return 0;

890

for (dbix = 0; dbix < db->db_ndbi; dbix++) {

891

int xx;

892

if (db->_dbi[dbix] == NULL)

893

continue;

894

if (db->_dbi[dbix]->dbi_no_dbsync)

895

continue;

896

xx = dbiSync(db->_dbi[dbix], 0);

897

if (xx && rc == 0) rc = xx;

898

}

899

return rc;

669

670

return dbiForeach(db->_dbi, dbiSync, 0);

900

671

}

901

672

902

/* FIX: dbTemplate structure assignment */

903

static

904

rpmdb newRpmdb(const char * root,

905

const char * home,

906

int mode, int perms, int flags)

673

static rpmdb newRpmdb(const char * root, const char * home,

674

int mode, int perms, int flags)

907

675

{

908

rpmdb db = xcalloc(sizeof(*db), 1);

909

const char * epfx = _DB_ERRPFX;

910

static int _initialized = 0;

676

rpmdb db = NULL;

677

char * db_home = rpmGetPath((home && *home) ? home : "%{_dbpath}", NULL);

911

678

912

if (!_initialized) {

913

_initialized = 1;

679

if (!(db_home && db_home[0] != '%')) {

680

rpmlog(RPMLOG_ERR, _("no dbpath has been set\n"));

681

free(db_home);

682

return NULL;

914

683

}

915

684

916

*db = dbTemplate; /* structure assignment */

917

918

db->_dbi = NULL;

685

db = xcalloc(sizeof(*db), 1);

919

686

920

687

if (!(perms & 0600)) perms = 0644; /* XXX sanity */

921

688

922

if (mode >= 0) db->db_mode = mode;

923

if (perms >= 0) db->db_perms = perms;

924

if (flags >= 0) db->db_flags = flags;

689

db->db_mode = (mode >= 0) ? mode : 0;

690

db->db_perms = (perms >= 0) ? perms : 0644;

691

db->db_flags = (flags >= 0) ? flags : 0;

925

692

926

db->db_home = rpmGetPath( (home && *home ? home : _DB_HOME), NULL);

927

if (!(db->db_home && db->db_home[0] != '%')) {

928

rpmlog(RPMLOG_ERR, _("no dbpath has been set\n"));

929

db->db_home = _free(db->db_home);

930

db = _free(db);

931

return NULL;

932

}

933

db->db_root = rpmGetPath((root && *root) ? root : _DB_ROOT, NULL);

693

db->db_home = db_home;

694

db->db_root = rpmGetPath((root && *root) ? root : "/", NULL);

934

695

db->db_fullpath = rpmGenPath(db->db_root, db->db_home, NULL);

935

db->db_errpfx = rpmExpand( (epfx && *epfx ? epfx : _DB_ERRPFX), NULL);

936

696

/* XXX remove environment after chrooted operations, for now... */

937

697

db->db_remove_env = (!rstreq(db->db_root, "/") ? 1 : 0);

938

db->db_ndbi = dbiTags.max;

939

db->db_malloc = rmalloc;

940

db->db_realloc = rrealloc;

941

db->db_free = NULL; /* XXX rfree() prototype differs from free() */

942

db->_dbi = xcalloc(db->db_ndbi, sizeof(*db->_dbi));

698

db->_dbi = xcalloc(dbiTagsMax, sizeof(*db->_dbi));

699

db->db_ver = DB_VERSION_MAJOR; /* XXX just to put something in messages */

943

700

db->nrefs = 0;

944

return rpmdbLink(db, RPMDBG_M("rpmdbCreate"));

701

return rpmdbLink(db);

945

702

}

946

703

947

704

static int openDatabase(const char * prefix,

948

const char * dbpath,

949

int _dbapi, rpmdb *dbp,

705

const char * dbpath, rpmdb *dbp,

950

706

int mode, int perms, int flags)

951

707

{

952

708

rpmdb db;

953

709

int rc, xx;

954

710

int justCheck = flags & RPMDB_FLAG_JUSTCHECK;

955

int minimal = flags & RPMDB_FLAG_MINIMAL;

956

957

dbiTagsInit();

958

959

/* Insure that _dbapi has one of -1, 1, 2, or 3 */

960

if (_dbapi < -1 || _dbapi > 4)

961

_dbapi = -1;

962

if (_dbapi == 0)

963

_dbapi = 1;

964

711

965

712

if (dbp)

966

713

*dbp = NULL;

971

718

if (db == NULL)

972

719

return 1;

973

720

974

(void) rpmsqEnable(SIGHUP, NULL);

975

(void) rpmsqEnable(SIGINT, NULL);

976

(void) rpmsqEnable(SIGTERM,NULL);

977

(void) rpmsqEnable(SIGQUIT,NULL);

978

(void) rpmsqEnable(SIGPIPE,NULL);

979

980

db->db_api = _dbapi;

981

982

{ int dbix;

983

984

rc = 0;

985

if (dbiTags.tags != NULL)

986

for (dbix = 0; rc == 0 && dbix < dbiTags.max; dbix++) {

987

dbiIndex dbi;

988

rpmTag rpmtag;

989

990

/* Filter out temporary databases */

991

if (isTemporaryDB((rpmtag = dbiTags.tags[dbix])))

992

continue;

993

994

dbi = dbiOpen(db, rpmtag, 0);

995

if (dbi == NULL) {

996

rc = -2;

997

break;

998

}

999

1000

switch (rpmtag) {

1001

case RPMDBI_PACKAGES:

1002

if (dbi == NULL) rc |= 1;

1003

#if 0

1004

/* XXX open only Packages, indices created on the fly. */

1005

if (db->db_api == 3)

1006

#endif

1007

goto exit;

1008

break;

1009

case RPMTAG_NAME:

1010

if (dbi == NULL) rc |= 1;

1011

if (minimal)

1012

goto exit;

1013

break;

1014

default:

1015

break;

1016

}

1017

}

721

/* Try to ensure db home exists, error out if we cant even create */

722

rc = rpmioMkpath(rpmdbHome(db), 0755, getuid(), getgid());

723

if (rc == 0) {

724

(void) rpmsqEnable(SIGHUP, NULL);

725

(void) rpmsqEnable(SIGINT, NULL);

726

(void) rpmsqEnable(SIGTERM,NULL);

727

(void) rpmsqEnable(SIGQUIT,NULL);

728

(void) rpmsqEnable(SIGPIPE,NULL);

729

730

/* Just the primary Packages database opened here */

731

rc = (rpmdbOpenIndex(db, RPMDBI_PACKAGES, db->db_flags) != NULL) ? 0 : -2;

1018

732

}

1019

733

1020

exit:

1021

734

if (rc || justCheck || dbp == NULL)

1022

735

xx = rpmdbClose(db);

1023

736

else {

1029

742

return rc;

1030

743

}

1031

744

1032

rpmdb rpmdbUnlink(rpmdb db, const char * msg)

745

static rpmdb rpmdbUnlink(rpmdb db)

1033

746

{

1034

if (_rpmdb_debug)

1035

fprintf(stderr, "--> db %p -- %d %s\n", db, db->nrefs, msg);

1036

db->nrefs--;

747

if (db)

748

db->nrefs--;

1037

749

return NULL;

1038

750

}

1039

751

1040

rpmdb rpmdbLink(rpmdb db, const char * msg)

752

rpmdb rpmdbLink(rpmdb db)

1041

753

{

1042

db->nrefs++;

1043

if (_rpmdb_debug)

1044

fprintf(stderr, "--> db %p ++ %d %s\n", db, db->nrefs, msg);

754

if (db)

755

db->nrefs++;

1045

756

return db;

1046

757

}

1047

758

1048

/* XXX python/rpmmodule.c */

1049

759

int rpmdbOpen (const char * prefix, rpmdb *dbp, int mode, int perms)

1050

760

{

1051

int _dbapi = rpmExpandNumeric("%{_dbapi}");

1052

return openDatabase(prefix, NULL, _dbapi, dbp, mode, perms, 0);

761

return openDatabase(prefix, NULL, dbp, mode, perms, 0);

1053

762

}

1054

763

1055

764

int rpmdbInit (const char * prefix, int perms)

1056

765

{

1057

766

rpmdb db = NULL;

1058

int _dbapi = rpmExpandNumeric("%{_dbapi}");

1059

767

int rc;

1060

768

1061

rc = openDatabase(prefix, NULL, _dbapi, &db, (O_CREAT | O_RDWR),

1062

perms, RPMDB_FLAG_JUSTCHECK);

769

rc = openDatabase(prefix, NULL, &db, (O_CREAT | O_RDWR), perms, 0);

1063

770

if (db != NULL) {

1064

771

int xx;

1065

772

xx = rpmdbOpenAll(db);

1074

781

int rpmdbVerify(const char * prefix)

1075

782

{

1076

783

rpmdb db = NULL;

1077

int _dbapi = rpmExpandNumeric("%{_dbapi}");

1078

784

int rc = 0;

1079

785

1080

rc = openDatabase(prefix, NULL, _dbapi, &db, O_RDONLY, 0644, 0);

786

rc = openDatabase(prefix, NULL, &db, O_RDONLY, 0644, RPMDB_FLAG_VERIFYONLY);

1081

787

1082

788

if (db != NULL) {

1083

int dbix;

1084

789

int xx;

1085

790

rc = rpmdbOpenAll(db);

1086

791

1087

for (dbix = db->db_ndbi; --dbix >= 0; ) {

1088

if (db->_dbi[dbix] == NULL)

1089

continue;

1090

/* FIX: double indirection. */

1091

xx = dbiVerify(db->_dbi[dbix], 0);

1092

if (xx && rc == 0) rc = xx;

1093

db->_dbi[dbix] = NULL;

1094

}

792

rc = dbiForeach(db->_dbi, dbiVerify, 0);

1095

793

1096

/* FIX: db->_dbi[] may be NULL. */

1097

794

xx = rpmdbClose(db);

1098

795

if (xx && rc == 0) rc = xx;

1099

796

db = NULL;

1101

798

return rc;

1102

799

}

1103

800

801

static Header rpmdbGetHeaderAt(rpmdb db, unsigned int offset)

802

{

803

rpmdbMatchIterator mi = rpmdbInitIterator(db, RPMDBI_PACKAGES,

804

&offset, sizeof(offset));

805

Header h = headerLink(rpmdbNextIterator(mi));

806

rpmdbFreeIterator(mi);

807

return h;

808

}

809

1104

810

/**

1105

811

* Find file matches in database.

1106

812

* @param db rpm database

1120

826

dbiIndex dbi = NULL;

1121

827

DBC * dbcursor;

1122

828

dbiIndexSet allMatches = NULL;

1123

dbiIndexItem rec = NULL;

829

rpmDbiTag dbtag = RPMDBI_BASENAMES;

1124

830

unsigned int i;

1125

831

int rc = -2; /* assume error */

1126

832

int xx;

1140

846

if (baseName == NULL)

1141

847

goto exit;

1142

848

1143

dbi = dbiOpen(db, RPMTAG_BASENAMES, 0);

849

dbi = rpmdbOpenIndex(db, dbtag, 0);

1144

850

if (dbi != NULL) {

1145

851

dbcursor = NULL;

1146

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, 0);

852

xx = dbiCopen(dbi, &dbcursor, 0);

1147

853

1148

854

key->data = (void *) baseName;

1149

855

key->size = strlen(baseName);

1154

860

if (rc > 0) {

1155

861

rpmlog(RPMLOG_ERR,

1156

862

_("error(%d) getting \"%s\" records from %s index\n"),

1157

rc, (char*)key->data, rpmTagGetName(dbi->dbi_rpmtag));

863

rc, (char*)key->data, dbiName(dbi));

1158

864

}

1159

865

1160

866

if (rc == 0)

1168

874

if (rc || allMatches == NULL) goto exit;

1169

875

1170

876

*matches = xcalloc(1, sizeof(**matches));

1171

rec = dbiIndexNewItem(0, 0);

1172

877

fpc = fpCacheCreate(allMatches->count);

1173

878

fp1 = fpLookup(fpc, dirName, baseName, 1);

1174

879

1179

884

uint32_t * dirIndexes;

1180

885

unsigned int offset = dbiIndexRecordOffset(allMatches, i);

1181

886

unsigned int prevoff;

1182

Header h;

1183

1184

{ rpmdbMatchIterator mi;

1185

mi = rpmdbInitIterator(db, RPMDBI_PACKAGES, &offset, sizeof(offset));

1186

h = rpmdbNextIterator(mi);

1187

if (h)

1188

h = headerLink(h);

1189

mi = rpmdbFreeIterator(mi);

1190

}

887

Header h = rpmdbGetHeaderAt(db, offset);

1191

888

1192

889

if (h == NULL) {

1193

890

i++;

1207

904

1208

905

fp2 = fpLookup(fpc, dirNames[dirIndexes[num]], baseNames[num], 1);

1209

906

if (FP_EQUAL(fp1, fp2)) {

1210

rec->hdrNum = dbiIndexRecordOffset(allMatches, i);

1211

rec->tagNum = dbiIndexRecordFileNumber(allMatches, i);

1212

xx = dbiAppendSet(*matches, rec, 1, sizeof(*rec), 0);

907

struct dbiIndexItem rec = {

908

.hdrNum = dbiIndexRecordOffset(allMatches, i),

909

.tagNum = dbiIndexRecordFileNumber(allMatches, i),

910

};

911

xx = dbiAppendSet(*matches, &rec, 1, sizeof(rec), 0);

1213

912

}

1214

913

1215

914

prevoff = offset;

1224

923

h = headerFree(h);

1225

924

}

1226

925

1227

rec = _free(rec);

1228

926

fpCacheFree(fpc);

1229

927

1230

928

if ((*matches)->count == 0) {

1240

938

return rc;

1241

939

}

1242

940

1243

/* XXX python/upgrade.c, install.c, uninstall.c */

1244

941

int rpmdbCountPackages(rpmdb db, const char * name)

1245

942

{

1246

943

DBC * dbcursor = NULL;

1247

DBT key;

1248

DBT data;

944

DBT key, data;

1249

945

dbiIndex dbi;

946

rpmDbiTag dbtag = RPMDBI_NAME;

1250

947

int rc;

1251

948

int xx;

1252

949

1253

950

if (db == NULL)

1254

951

return 0;

1255

952

953

dbi = rpmdbOpenIndex(db, dbtag, 0);

954

if (dbi == NULL)

955

return 0;

956

1256

957

memset(&key, 0, sizeof(key));

1257

958

memset(&data, 0, sizeof(data));

1258

959

1259

dbi = dbiOpen(db, RPMTAG_NAME, 0);

1260

if (dbi == NULL)

1261

return 0;

1262

1263

960

key.data = (void *) name;

1264

961

key.size = strlen(name);

1265

962

1266

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, 0);

963

xx = dbiCopen(dbi, &dbcursor, 0);

1267

964

rc = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

1268

#ifndef SQLITE_HACK

1269

965

xx = dbiCclose(dbi, dbcursor, 0);

1270

966

dbcursor = NULL;

1271

#endif

1272

967

1273

968

if (rc == 0) { /* success */

1274

dbiIndexSet matches;

1275

/* FIX: matches might be NULL */

1276

matches = NULL;

969

dbiIndexSet matches = NULL;

1277

970

(void) dbt2set(dbi, &data, &matches);

1278

971

if (matches) {

1279

972

rc = dbiIndexSetCount(matches);

1280

973

matches = dbiFreeIndexSet(matches);

1281

974

}

1282

} else

1283

if (rc == DB_NOTFOUND) { /* not found */

975

} else if (rc == DB_NOTFOUND) { /* not found */

1284

976

rc = 0;

1285

977

} else { /* error */

1286

978

rpmlog(RPMLOG_ERR,

1287

979

_("error(%d) getting \"%s\" records from %s index\n"),

1288

rc, (char*)key.data, rpmTagGetName(dbi->dbi_rpmtag));

980

rc, (char*)key.data, dbiName(dbi));

1289

981

rc = -1;

1290

982

}

1291

983

1292

#ifdef SQLITE_HACK

1293

xx = dbiCclose(dbi, dbcursor, 0);

1294

dbcursor = NULL;

1295

#endif

1296

1297

984

return rc;

1298

985

}

1299

986

1300

987

/**

1301

988

* Attempt partial matches on name[-version[-release]] strings.

1302

* @param dbi index database handle (always RPMTAG_NAME)

989

* @param db rpmdb handle

990

* @param dbi index database handle (always RPMDBI_NAME)

1303

991

* @param dbcursor index database cursor

1304

992

* @param key search key/length/flags

1305

993

* @param data search data/length/flags

1309

997

* @retval matches set of header instances that match

1310

998

* @return RPMRC_OK on match, RPMRC_NOMATCH or RPMRC_FAIL

1311

999

1312

static rpmRC dbiFindMatches(dbiIndex dbi, DBC * dbcursor,

1000

static rpmRC dbiFindMatches(rpmdb db, dbiIndex dbi, DBC * dbcursor,

1313

1001

DBT * key, DBT * data,

1314

1002

const char * name,

1315

1003

const char * version,

1329

1017

(void) dbt2set(dbi, data, matches);

1330

1018

if (version == NULL && release == NULL)

1331

1019

return RPMRC_OK;

1332

} else

1333

if (rc == DB_NOTFOUND) { /* not found */

1020

} else if (rc == DB_NOTFOUND) { /* not found */

1334

1021

return RPMRC_NOTFOUND;

1335

1022

} else { /* error */

1336

1023

rpmlog(RPMLOG_ERR,

1337

1024

_("error(%d) getting \"%s\" records from %s index\n"),

1338

rc, (char*)key->data, rpmTagGetName(dbi->dbi_rpmtag));

1025

rc, (char*)key->data, dbiName(dbi));

1339

1026

return RPMRC_FAIL;

1340

1027

}

1341

1028

1348

1035

if (recoff == 0)

1349

1036

continue;

1350

1037

1351

mi = rpmdbInitIterator(dbi->dbi_rpmdb,

1352

RPMDBI_PACKAGES, &recoff, sizeof(recoff));

1038

mi = rpmdbInitIterator(db, RPMDBI_PACKAGES, &recoff, sizeof(recoff));

1353

1039

1354

1040

/* Set iterator selectors for version/release if available. */

1355

1041

if (version &&

1390

1076

* Lookup by name, name-version, and finally by name-version-release.

1391

1077

* Both version and release can be patterns.

1392

1078

* @todo Name must be an exact match, as name is a db key.

1393

* @param dbi index database handle (always RPMTAG_NAME)

1079

* @param db rpmdb handle

1080

* @param dbi index database handle (always RPMDBI_NAME)

1394

1081

* @param dbcursor index database cursor

1395

1082

* @param key search key/length/flags

1396

1083

* @param data search data/length/flags

1398

1085

* @retval matches set of header instances that match

1399

1086

* @return RPMRC_OK on match, RPMRC_NOMATCH or RPMRC_FAIL

1400

1087

1401

static rpmRC dbiFindByLabel(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,

1402

const char * arg, dbiIndexSet * matches)

1088

static rpmRC dbiFindByLabel(rpmdb db, dbiIndex dbi, DBC * dbcursor,

1089

DBT * key, DBT * data, const char * arg, dbiIndexSet * matches)

1403

1090

{

1404

1091

const char * release;

1405

1092

char * localarg;

1411

1098

if (arg == NULL || strlen(arg) == 0) return RPMRC_NOTFOUND;

1412

1099

1413

1100

/* did they give us just a name? */

1414

rc = dbiFindMatches(dbi, dbcursor, key, data, arg, NULL, NULL, matches);

1101

rc = dbiFindMatches(db, dbi, dbcursor, key, data, arg, NULL, NULL, matches);

1415

1102

if (rc != RPMRC_NOTFOUND) return rc;

1416

1103

1417

1104

/* FIX: double indirection */

1444

1131

}

1445

1132

1446

1133

*s = '\0';

1447

rc = dbiFindMatches(dbi, dbcursor, key, data, localarg, s + 1, NULL, matches);

1134

rc = dbiFindMatches(db, dbi, dbcursor, key, data,

1135

localarg, s + 1, NULL, matches);

1448

1136

if (rc != RPMRC_NOTFOUND) goto exit;

1449

1137

1450

1138

/* FIX: double indirection */

1477

1165

1478

1166

*s = '\0';

1479

1167

/* FIX: *matches may be NULL. */

1480

rc = dbiFindMatches(dbi, dbcursor, key, data, localarg, s + 1, release, matches);

1168

rc = dbiFindMatches(db, dbi, dbcursor, key, data,

1169

localarg, s + 1, release, matches);

1481

1170

exit:

1482

1171

free(localarg);

1483

1172

return rc;

1499

1188

return 0;

1500

1189

1501

1190

if (dbi && mi->mi_dbc && mi->mi_modified && mi->mi_prevoffset) {

1502

DBT * key = &mi->mi_key;

1503

DBT * data = &mi->mi_data;

1191

DBT key, data;

1504

1192

sigset_t signalMask;

1505

1193

rpmRC rpmrc = RPMRC_NOTFOUND;

1506

1194

int xx;

1507

1195

1508

key->data = (void *) &mi->mi_prevoffset;

1509

key->size = sizeof(mi->mi_prevoffset);

1510

data->data = headerUnload(mi->mi_h);

1511

data->size = headerSizeof(mi->mi_h, HEADER_MAGIC_NO);

1196

memset(&key, 0, sizeof(key));

1197

memset(&data, 0, sizeof(data));

1198

key.data = (void *) &mi->mi_prevoffset;

1199

key.size = sizeof(mi->mi_prevoffset);

1200

data.data = headerUnload(mi->mi_h);

1201

data.size = headerSizeof(mi->mi_h, HEADER_MAGIC_NO);

1512

1202

1513

1203

/* Check header digest/signature on blob export (if requested). */

1514

1204

if (mi->mi_hdrchk && mi->mi_ts) {

1515

1205

char * msg = NULL;

1516

1206

int lvl;

1517

1207

1518

rpmrc = (*mi->mi_hdrchk) (mi->mi_ts, data->data, data->size, &msg);

1208

rpmrc = (*mi->mi_hdrchk) (mi->mi_ts, data.data, data.size, &msg);

1519

1209

lvl = (rpmrc == RPMRC_FAIL ? RPMLOG_ERR : RPMLOG_DEBUG);

1520

1210

rpmlog(lvl, "%s h#%8u %s",

1521

1211

(rpmrc == RPMRC_FAIL ? _("miFreeHeader: skipping") : "write"),

1523

1213

msg = _free(msg);

1524

1214

}

1525

1215

1526

if (data->data != NULL && rpmrc != RPMRC_FAIL) {

1216

if (data.data != NULL && rpmrc != RPMRC_FAIL) {

1527

1217

(void) blockSignals(&signalMask);

1528

rc = dbiPut(dbi, mi->mi_dbc, key, data, DB_KEYLAST);

1218

rc = dbiPut(dbi, mi->mi_dbc, &key, &data, DB_KEYLAST);

1529

1219

if (rc) {

1530

1220

rpmlog(RPMLOG_ERR,

1531

1221

_("error(%d) storing record #%d into %s\n"),

1532

rc, mi->mi_prevoffset, rpmTagGetName(dbi->dbi_rpmtag));

1222

rc, mi->mi_prevoffset, dbiName(dbi));

1533

1223

}

1534

1224

xx = dbiSync(dbi, 0);

1535

1225

(void) unblockSignals(&signalMask);

1536

1226

}

1537

data->data = _free(data->data);

1538

data->size = 0;

1227

data.data = _free(data.data);

1228

data.size = 0;

1539

1229

}

1540

1230

1541

1231

mi->mi_h = headerFree(mi->mi_h);

1561

1251

next->mi_next = NULL;

1562

1252

}

1563

1253

1564

dbi = dbiOpen(mi->mi_db, RPMDBI_PACKAGES, 0);

1565

if (dbi == NULL) /* XXX can't happen */

1566

return NULL;

1254

dbi = rpmdbOpenIndex(mi->mi_db, RPMDBI_PACKAGES, 0);

1567

1255

1568

1256

xx = miFreeHeader(mi, dbi);

1569

1257

1584

1272

1585

1273

mi->mi_set = dbiFreeIndexSet(mi->mi_set);

1586

1274

mi->mi_keyp = _free(mi->mi_keyp);

1587

mi->mi_db = rpmdbUnlink(mi->mi_db, RPMDBG_M("matchIterator"));

1275

/* XXX rpmdbUnlink() should be rpmdbFree() but no such call exists... */

1276

mi->mi_db = rpmdbUnlink(mi->mi_db);

1277

mi->mi_ts = rpmtsFree(mi->mi_ts);

1588

1278

1589

1279

mi = _free(mi);

1590

1280

1664

1354

* @param pattern pattern to duplicate

1665

1355

* @return duplicated pattern

1666

1356

1667

static char * mireDup(rpmTag tag, rpmMireMode *modep,

1357

static char * mireDup(rpmTagVal tag, rpmMireMode *modep,

1668

1358

const char * pattern)

1669

1359

{

1670

1360

const char * s;

1752

1442

return pat;

1753

1443

}

1754

1444

1755

int rpmdbSetIteratorRE(rpmdbMatchIterator mi, rpmTag tag,

1445

int rpmdbSetIteratorRE(rpmdbMatchIterator mi, rpmTagVal tag,

1756

1446

rpmMireMode mode, const char * pattern)

1757

1447

{

1758

1448

static rpmMireMode defmode = (rpmMireMode)-1;

1941

1631

int rc = 0;

1942

1632

if (mi == NULL)

1943

1633

return 0;

1944

/* XXX forward linkage prevents rpmtsLink */

1945

mi->mi_ts = ts;

1634

mi->mi_ts = rpmtsLink(ts);

1946

1635

mi->mi_hdrchk = hdrchk;

1947

1636

return rc;

1948

1637

}

1949

1638

1639

static rpmRC miVerifyHeader(rpmdbMatchIterator mi, const void *uh, size_t uhlen)

1640

{

1641

rpmRC rpmrc = RPMRC_NOTFOUND;

1642

1643

if (!(mi->mi_hdrchk && mi->mi_ts))

1644

return rpmrc;

1645

1646

/* Don't bother re-checking a previously read header. */

1647

if (mi->mi_db->db_checked) {

1648

if (intHashHasEntry(mi->mi_db->db_checked, mi->mi_offset))

1649

rpmrc = RPMRC_OK;

1650

}

1651

1652

/* If blob is unchecked, check blob import consistency now. */

1653

if (rpmrc != RPMRC_OK) {

1654

char * msg = NULL;

1655

int lvl;

1656

1657

rpmrc = (*mi->mi_hdrchk) (mi->mi_ts, uh, uhlen, &msg);

1658

lvl = (rpmrc == RPMRC_FAIL ? RPMLOG_ERR : RPMLOG_DEBUG);

1659

rpmlog(lvl, "%s h#%8u %s",

1660

(rpmrc == RPMRC_FAIL ? _("rpmdbNextIterator: skipping") : " read"),

1661

mi->mi_offset, (msg ? msg : "\n"));

1662

msg = _free(msg);

1663

1664

/* Mark header checked. */

1665

if (mi->mi_db && mi->mi_db->db_checked && rpmrc == RPMRC_OK) {

1666

intHashAddEntry(mi->mi_db->db_checked, mi->mi_offset);

1667

}

1668

}

1669

return rpmrc;

1670

}

1950

1671

1951

1672

/* FIX: mi->mi_key.data may be NULL */

1952

1673

Header rpmdbNextIterator(rpmdbMatchIterator mi)

1954

1675

dbiIndex dbi;

1955

1676

void * uh;

1956

1677

size_t uhlen;

1957

DBT * key;

1958

DBT * data;

1678

DBT key, data;

1959

1679

void * keyp;

1960

1680

size_t keylen;

1961

1681

int rc;

1964

1684

if (mi == NULL)

1965

1685

return NULL;

1966

1686

1967

dbi = dbiOpen(mi->mi_db, RPMDBI_PACKAGES, 0);

1687

dbi = rpmdbOpenIndex(mi->mi_db, RPMDBI_PACKAGES, 0);

1968

1688

if (dbi == NULL)

1969

1689

return NULL;

1970

1690

1975

1695

* marked with DB_WRITECURSOR as well.

1976

1696

1977

1697

if (mi->mi_dbc == NULL)

1978

xx = dbiCopen(dbi, dbi->dbi_txnid, &mi->mi_dbc, mi->mi_cflags);

1698

xx = dbiCopen(dbi, &mi->mi_dbc, mi->mi_cflags);

1979

1699

1980

key = &mi->mi_key;

1981

memset(key, 0, sizeof(*key));

1982

data = &mi->mi_data;

1983

memset(data, 0, sizeof(*data));

1700

memset(&key, 0, sizeof(key));

1701

memset(&data, 0, sizeof(data));

1984

1702

1985

1703

top:

1986

1704

uh = NULL;

2001

1719

keylen = sizeof(mi_offset.ui);

2002

1720

} else {

2003

1721

2004

key->data = keyp = (void *)mi->mi_keyp;

2005

key->size = keylen = mi->mi_keylen;

2006

data->data = uh;

2007

data->size = uhlen;

1722

key.data = keyp = (void *)mi->mi_keyp;

1723

key.size = keylen = mi->mi_keylen;

1724

data.data = uh;

1725

data.size = uhlen;

2008

1726

#if !defined(_USE_COPY_LOAD)

2009

data->flags |= DB_DBT_MALLOC;

1727

data.flags |= DB_DBT_MALLOC;

2010

1728

#endif

2011

rc = dbiGet(dbi, mi->mi_dbc, key, data,

2012

(key->data == NULL ? DB_NEXT : DB_SET));

2013

data->flags = 0;

2014

keyp = key->data;

2015

keylen = key->size;

2016

uh = data->data;

2017

uhlen = data->size;

1729

rc = dbiGet(dbi, mi->mi_dbc, &key, &data,

1730

(key.data == NULL ? DB_NEXT : DB_SET));

1731

data.flags = 0;

1732

keyp = key.data;

1733

keylen = key.size;

1734

uh = data.data;

1735

uhlen = data.size;

2018

1736

2019

1737

2020

1738

* If we got the next key, save the header instance number.

2021

1739

2022

* For db3 Packages, instance 0 (i.e. mi->mi_setx == 0) is the

1740

* Instance 0 (i.e. mi->mi_setx == 0) is the

2023

1741

* largest header instance in the database, and should be

2024

1742

* skipped.

2025

1743

2045

1763

2046

1764

/* Retrieve next header blob for index iterator. */

2047

1765

if (uh == NULL) {

2048

key->data = keyp;

2049

key->size = keylen;

1766

key.data = keyp;

1767

key.size = keylen;

2050

1768

#if !defined(_USE_COPY_LOAD)

2051

data->flags |= DB_DBT_MALLOC;

1769

data.flags |= DB_DBT_MALLOC;

2052

1770

#endif

2053

rc = dbiGet(dbi, mi->mi_dbc, key, data, DB_SET);

2054

data->flags = 0;

2055

keyp = key->data;

2056

keylen = key->size;

2057

uh = data->data;

2058

uhlen = data->size;

1771

rc = dbiGet(dbi, mi->mi_dbc, &key, &data, DB_SET);

1772

data.flags = 0;

1773

keyp = key.data;

1774

keylen = key.size;

1775

uh = data.data;

1776

uhlen = data.size;

2059

1777

if (rc)

2060

1778

return NULL;

2061

1779

}

2067

1785

if (uh == NULL)

2068

1786

return NULL;

2069

1787

2070

/* Check header digest/signature once (if requested). */

2071

if (mi->mi_hdrchk && mi->mi_ts) {

2072

rpmRC rpmrc = RPMRC_NOTFOUND;

2073

2074

/* Don't bother re-checking a previously read header. */

2075

if (mi->mi_db->db_bits) {

2076

pbm_set * set;

2077

2078

set = PBM_REALLOC((pbm_set **)&mi->mi_db->db_bits,

2079

&mi->mi_db->db_nbits, mi->mi_offset);

2080

if (PBM_ISSET(mi->mi_offset, set))

2081

rpmrc = RPMRC_OK;

2082

}

2083

2084

/* If blob is unchecked, check blob import consistency now. */

2085

if (rpmrc != RPMRC_OK) {

2086

char * msg = NULL;

2087

int lvl;

2088

2089

rpmrc = (*mi->mi_hdrchk) (mi->mi_ts, uh, uhlen, &msg);

2090

lvl = (rpmrc == RPMRC_FAIL ? RPMLOG_ERR : RPMLOG_DEBUG);

2091

rpmlog(lvl, "%s h#%8u %s",

2092

(rpmrc == RPMRC_FAIL ? _("rpmdbNextIterator: skipping") : " read"),

2093

mi->mi_offset, (msg ? msg : "\n"));

2094

msg = _free(msg);

2095

2096

/* Mark header checked. */

2097

if (mi->mi_db && mi->mi_db->db_bits && rpmrc == RPMRC_OK) {

2098

pbm_set * set;

2099

2100

set = PBM_REALLOC((pbm_set **)&mi->mi_db->db_bits,

2101

&mi->mi_db->db_nbits, mi->mi_offset);

2102

PBM_SET(mi->mi_offset, set);

2103

}

2104

2105

/* Skip damaged and inconsistent headers. */

2106

if (rpmrc == RPMRC_FAIL)

2107

goto top;

2108

}

1788

/* Verify header if enabled, skip damaged and inconsistent headers */

1789

if (miVerifyHeader(mi, uh, uhlen) == RPMRC_FAIL) {

1790

goto top;

2109

1791

}

2110

1792

2111

1793

/* Did the header blob load correctly? */

2161

1843

}

2162

1844

}

2163

1845

2164

static int rpmdbGrowIterator(rpmdbMatchIterator mi)

1846

int rpmdbExtendIterator(rpmdbMatchIterator mi,

1847

const void * keyp, size_t keylen)

2165

1848

{

2166

1849

DBC * dbcursor;

2167

DBT * key;

2168

DBT * data;

1850

DBT data, key;

2169

1851

dbiIndex dbi = NULL;

2170

1852

dbiIndexSet set;

2171

1853

int rc;

2172

1854

int xx;

2173

1855

2174

if (mi == NULL)

1856

if (mi == NULL || keyp == NULL)

2175

1857

return 1;

2176

1858

1859

memset(&key, 0, sizeof(key));

1860

memset(&data, 0, sizeof(data));

1861

key.data = (void *) keyp;

1862

key.size = keylen ? keylen : strlen(keyp);

1863

2177

1864

dbcursor = mi->mi_dbc;

2178

key = &mi->mi_key;

2179

data = &mi->mi_data;

2180

if (key->data == NULL)

2181

return 1;

2182

1865

2183

dbi = dbiOpen(mi->mi_db, mi->mi_rpmtag, 0);

1866

dbi = rpmdbOpenIndex(mi->mi_db, mi->mi_rpmtag, 0);

2184

1867

if (dbi == NULL)

2185

1868

return 1;

2186

1869

2187

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, 0);

2188

rc = dbiGet(dbi, dbcursor, key, data, DB_SET);

2189

#ifndef SQLITE_HACK

1870

xx = dbiCopen(dbi, &dbcursor, 0);

1871

rc = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

2190

1872

xx = dbiCclose(dbi, dbcursor, 0);

2191

1873

dbcursor = NULL;

2192

#endif

2193

1874

2194

1875

if (rc) { /* error/not found */

2195

1876

if (rc != DB_NOTFOUND)

2196

1877

rpmlog(RPMLOG_ERR,

2197

1878

_("error(%d) getting \"%s\" records from %s index\n"),

2198

rc, (char*)key->data, rpmTagGetName(dbi->dbi_rpmtag));

2199

#ifdef SQLITE_HACK

2200

xx = dbiCclose(dbi, dbcursor, 0);

2201

dbcursor = NULL;

2202

#endif

1879

rc, (char*)key.data, dbiName(dbi));

2203

1880

return rc;

2204

1881

}

2205

1882

2206

1883

set = NULL;

2207

(void) dbt2set(dbi, data, &set);

2208

2209

#ifdef SQLITE_HACK

2210

xx = dbiCclose(dbi, dbcursor, 0);

2211

dbcursor = NULL;

2212

#endif

1884

(void) dbt2set(dbi, &data, &set);

2213

1885

2214

1886

if (mi->mi_set == NULL) {

2215

1887

mi->mi_set = set;

2224

1896

return rc;

2225

1897

}

2226

1898

2227

int rpmdbPruneIterator(rpmdbMatchIterator mi, int * hdrNums,

2228

int nHdrNums, int sorted)

1899

int rpmdbPruneIterator(rpmdbMatchIterator mi, intHash hdrNums)

2229

1900

{

2230

if (mi == NULL || hdrNums == NULL || nHdrNums <= 0)

1901

if (mi == NULL || hdrNums == NULL || intHashNumKeys(hdrNums) <= 0)

2231

1902

return 1;

2232

1903

2233

if (mi->mi_set)

2234

(void) dbiPruneSet(mi->mi_set, hdrNums, nHdrNums, sizeof(*hdrNums), sorted);

1904

if (!mi->mi_set)

1905

return 0;

1906

1907

unsigned int from;

1908

unsigned int to = 0;

1909

unsigned int num = mi->mi_set->count;

1910

1911

assert(mi->mi_set->count > 0);

1912

1913

for (from = 0; from < num; from++) {

1914

if (intHashHasEntry(hdrNums, mi->mi_set->recs[from].hdrNum)) {

1915

mi->mi_set->count--;

1916

continue;

1917

}

1918

if (from != to)

1919

mi->mi_set->recs[to] = mi->mi_set->recs[from]; /* structure assignment */

1920

to++;

1921

}

2235

1922

return 0;

2236

1923

}

2237

1924

2246

1933

return 0;

2247

1934

}

2248

1935

2249

rpmdbMatchIterator rpmdbInitIterator(rpmdb db, rpmTag rpmtag,

1936

rpmdbMatchIterator rpmdbNewIterator(rpmdb db, rpmDbiTagVal dbitag)

1937

{

1938

rpmdbMatchIterator mi = NULL;

1939

1940

if (rpmdbOpenIndex(db, dbitag, 0) == NULL)

1941

return NULL;

1942

1943

mi = xcalloc(1, sizeof(*mi));

1944

mi->mi_keyp = NULL;

1945

mi->mi_keylen = 0;

1946

mi->mi_set = NULL;

1947

mi->mi_db = rpmdbLink(db);

1948

mi->mi_rpmtag = dbitag;

1949

1950

mi->mi_dbc = NULL;

1951

mi->mi_setx = 0;

1952

mi->mi_h = NULL;

1953

mi->mi_sorted = 0;

1954

mi->mi_cflags = 0;

1955

mi->mi_modified = 0;

1956

mi->mi_prevoffset = 0;

1957

mi->mi_offset = 0;

1958

mi->mi_filenum = 0;

1959

mi->mi_nre = 0;

1960

mi->mi_re = NULL;

1961

1962

mi->mi_ts = NULL;

1963

mi->mi_hdrchk = NULL;

1964

1965

/* Chain cursors for teardown on abnormal exit. */

1966

mi->mi_next = rpmmiRock;

1967

rpmmiRock = mi;

1968

1969

return mi;

1970

};

1971

1972

rpmdbMatchIterator rpmdbInitIterator(rpmdb db, rpmDbiTagVal rpmtag,

2250

1973

const void * keyp, size_t keylen)

2251

1974

{

2252

rpmdbMatchIterator mi;

2253

DBT * key;

2254

DBT * data;

1975

rpmdbMatchIterator mi = NULL;

2255

1976

dbiIndexSet set = NULL;

2256

1977

dbiIndex dbi;

2257

1978

void * mi_keyp = NULL;

2264

1985

2265

1986

/* XXX HACK to remove rpmdbFindByLabel/findMatches from the API */

2266

1987

if (rpmtag == RPMDBI_LABEL) {

2267

rpmtag = RPMTAG_NAME;

1988

rpmtag = RPMDBI_NAME;

2268

1989

isLabel = 1;

2269

1990

}

2270

1991

2271

dbi = dbiOpen(db, rpmtag, 0);

1992

dbi = rpmdbOpenIndex(db, rpmtag, 0);

2272

1993

if (dbi == NULL)

2273

1994

return NULL;

2274

1995

2275

/* Chain cursors for teardown on abnormal exit. */

2276

mi = xcalloc(1, sizeof(*mi));

2277

mi->mi_next = rpmmiRock;

2278

rpmmiRock = mi;

2279

2280

key = &mi->mi_key;

2281

data = &mi->mi_data;

2282

2283

1996

2284

1997

* Handle label and file name special cases.

2285

1998

* Otherwise, retrieve join keys for secondary lookup.

2286

1999

2287

if (rpmtag != RPMDBI_PACKAGES && keyp) {

2000

if (rpmtag != RPMDBI_PACKAGES) {

2001

DBT key, data;

2288

2002

DBC * dbcursor = NULL;

2289

int rc;

2003

int rc = 0;

2290

2004

int xx;

2291

2005

2292

if (isLabel) {

2293

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, 0);

2294

rc = dbiFindByLabel(dbi, dbcursor, key, data, keyp, &set);

2295

xx = dbiCclose(dbi, dbcursor, 0);

2296

dbcursor = NULL;

2297

} else if (rpmtag == RPMTAG_BASENAMES) {

2298

rc = rpmdbFindByFile(db, keyp, key, data, &set);

2006

memset(&key, 0, sizeof(key));

2007

memset(&data, 0, sizeof(data));

2008

2009

if (keyp) {

2010

2011

if (isLabel) {

2012

xx = dbiCopen(dbi, &dbcursor, 0);

2013

rc = dbiFindByLabel(db, dbi, dbcursor, &key, &data, keyp, &set);

2014

xx = dbiCclose(dbi, dbcursor, 0);

2015

dbcursor = NULL;

2016

} else if (rpmtag == RPMDBI_BASENAMES) {

2017

rc = rpmdbFindByFile(db, keyp, &key, &data, &set);

2018

} else {

2019

xx = dbiCopen(dbi, &dbcursor, 0);

2020

2021

key.data = (void *) keyp;

2022

key.size = keylen;

2023

if (key.data && key.size == 0)

2024

key.size = strlen((char *)key.data);

2025

if (key.data && key.size == 0)

2026

key.size++; /* XXX "/" fixup. */

2027

2028

rc = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

2029

if (rc > 0) {

2030

rpmlog(RPMLOG_ERR,

2031

_("error(%d) getting \"%s\" records from %s index\n"),

2032

rc, (key.data ? (char *)key.data : "???"),

2033

dbiName(dbi));

2034

}

2035

2036

/* Join keys need to be native endian internally. */

2037

if (rc == 0)

2038

(void) dbt2set(dbi, &data, &set);

2039

2040

xx = dbiCclose(dbi, dbcursor, 0);

2041

dbcursor = NULL;

2042

}

2043

if (rc) { /* error/not found */

2044

set = dbiFreeIndexSet(set);

2045

goto exit;

2046

}

2299

2047

} else {

2300

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, 0);

2301

2302

key->data = (void *) keyp;

2303

key->size = keylen;

2304

if (key->data && key->size == 0)

2305

key->size = strlen((char *)key->data);

2306

if (key->data && key->size == 0)

2307

key->size++; /* XXX "/" fixup. */

2308

2309

rc = dbiGet(dbi, dbcursor, key, data, DB_SET);

2310

if (rc > 0) {

2311

rpmlog(RPMLOG_ERR,

2312

_("error(%d) getting \"%s\" records from %s index\n"),

2313

rc, (key->data ? (char *)key->data : "???"),

2314

rpmTagGetName(dbi->dbi_rpmtag));

2315

}

2316

2317

/* Join keys need to be native endian internally. */

2318

if (rc == 0)

2319

(void) dbt2set(dbi, data, &set);

2320

2321

xx = dbiCclose(dbi, dbcursor, 0);

2322

dbcursor = NULL;

2323

}

2324

if (rc) { /* error/not found */

2325

set = dbiFreeIndexSet(set);

2326

rpmmiRock = mi->mi_next;

2327

mi->mi_next = NULL;

2328

mi = _free(mi);

2329

return NULL;

2330

}

2048

/* get all entries from index */

2049

xx = dbiCopen(dbi, &dbcursor, 0);

2050

2051

while ((rc = dbiGet(dbi, dbcursor, &key, &data, DB_NEXT)) == 0) {

2052

dbiIndexSet newset = NULL;

2053

2054

(void) dbt2set(dbi, &data, &newset);

2055

if (set == NULL) {

2056

set = newset;

2057

} else {

2058

dbiAppendSet(set, newset->recs, newset->count, sizeof(*(set->recs)), 0);

2059

dbiFreeIndexSet(newset);

2060

}

2061

}

2062

2063

if (rc != DB_NOTFOUND) {

2064

rpmlog(RPMLOG_ERR,

2065

_("error(%d) getting \"%s\" records from %s index\n"),

2066

rc, (key.data ? (char *)key.data : "???"), dbiName(dbi));

2067

}

2068

2069

xx = dbiCclose(dbi, dbcursor, 0);

2070

dbcursor = NULL;

2071

2072

if (rc != DB_NOTFOUND) { /* error */

2073

set = dbiFreeIndexSet(set);

2074

goto exit;

2075

}

2076

}

2331

2077

}

2332

2078

2333

2079

/* Copy the retrieval key, byte swapping header instance if necessary. */

2355

2101

}

2356

2102

}

2357

2103

2104

mi = rpmdbNewIterator(db, rpmtag);

2358

2105

mi->mi_keyp = mi_keyp;

2359

2106

mi->mi_keylen = keylen;

2360

2361

mi->mi_db = rpmdbLink(db, RPMDBG_M("matchIterator"));

2362

mi->mi_rpmtag = rpmtag;

2363

2364

mi->mi_dbc = NULL;

2365

2107

mi->mi_set = set;

2366

mi->mi_setx = 0;

2367

mi->mi_h = NULL;

2368

mi->mi_sorted = 0;

2369

mi->mi_cflags = 0;

2370

mi->mi_modified = 0;

2371

mi->mi_prevoffset = 0;

2372

mi->mi_offset = 0;

2373

mi->mi_filenum = 0;

2374

mi->mi_nre = 0;

2375

mi->mi_re = NULL;

2376

2377

mi->mi_ts = NULL;

2378

mi->mi_hdrchk = NULL;

2379

2108

2109

if (rpmtag != RPMDBI_PACKAGES && keyp == NULL) {

2110

rpmdbSortIterator(mi);

2111

}

2112

2113

exit:

2380

2114

return mi;

2381

2115

}

2382

2116

2383

/** \ingroup rpmdb

2384

* Return database iterator.

2385

* @param mi rpm database iterator

2386

* @param keyp key data (NULL for sequential access)

2387

* @param keylen key data length (0 will use strlen(keyp))

2388

* @return 0 on success

2389

2390

int rpmdbExtendIterator(rpmdbMatchIterator mi,

2391

const void * keyp, size_t keylen)

2392

{

2393

mi->mi_key.data = (void *) keyp;

2394

mi->mi_key.size = keylen ? keylen : strlen(keyp);

2395

return rpmdbGrowIterator(mi);

2396

}

2397

2398

2117

2399

2118

* Convert current tag data to db key

2400

2119

* @param tagdata Tag data container

2405

2124

static int td2key(rpmtd tagdata, DBT *key, int *freedata)

2406

2125

{

2407

2126

const char *str = NULL;

2408

uint8_t *bin = NULL;

2409

2127

2410

2128

*freedata = 0;

2411

2129

switch (rpmtdType(tagdata)) {

2433

2151

case RPM_STRING_TYPE:

2434

2152

case RPM_I18NSTRING_TYPE:

2435

2153

case RPM_STRING_ARRAY_TYPE:

2436

str = rpmtdGetString(tagdata);

2437

if (rpmtdTag(tagdata) == RPMTAG_FILEDIGESTS) {

2438

size_t binlen;

2439

uint8_t *t;

2440

2441

/* Filter out empty MD5 strings. */

2442

if (!(str && *str != '\0'))

2443

return 0;

2444

2445

binlen = strlen(str) / 2;

2446

bin = xmalloc(binlen);

2447

/* Convert from hex to binary. */

2448

t = bin;

2449

for (int j = 0; j < binlen; j++, t++, str += 2)

2450

*t = (rnibble(str[0]) << 4) | rnibble(str[1]);

2451

key->data = bin;

2452

key->size = binlen;

2453

*freedata = 1;

2454

break;

2455

} else if (rpmtdTag(tagdata) == RPMTAG_PUBKEYS) {

2456

/* Extract the pubkey id from the base64 blob. */

2457

bin = xmalloc(sizeof(pgpKeyID_t));

2458

int nbin = pgpExtractPubkeyFingerprint(str, bin);

2459

if (nbin <= 0) {

2460

free(bin);

2461

return 0;

2462

}

2463

key->data = bin;

2464

key->size = nbin;

2465

*freedata = 1;

2466

break;

2467

} else {

2468

/* fallthrough */;

2469

}

2470

2154

default:

2471

2155

str = rpmtdGetString(tagdata);

2472

2156

key->data = (char *) str; /* XXX discards const */

2481

2165

2482

2166

return 1;

2483

2167

}

2484

2485

static void logAddRemove(int removing, rpmtd tagdata)

2168

2169

* rpmdbIndexIterator

2170

2171

2172

rpmdbIndexIterator rpmdbIndexIteratorInit(rpmdb db, rpmDbiTag rpmtag)

2173

{

2174

rpmdbIndexIterator ii;

2175

dbiIndex dbi = NULL;

2176

2177

if (db == NULL)

2178

return NULL;

2179

2180

(void) rpmdbCheckSignals();

2181

2182

dbi = rpmdbOpenIndex(db, rpmtag, 0);

2183

if (dbi == NULL)

2184

return NULL;

2185

2186

/* Chain cursors for teardown on abnormal exit. */

2187

ii = xcalloc(1, sizeof(*ii));

2188

ii->ii_next = rpmiiRock;

2189

rpmiiRock = ii;

2190

2191

ii->ii_db = rpmdbLink(db);

2192

ii->ii_rpmtag = rpmtag;

2193

ii->ii_dbi = dbi;

2194

ii->ii_set = NULL;

2195

2196

return ii;

2197

}

2198

2199

int rpmdbIndexIteratorNext(rpmdbIndexIterator ii, const void ** key, size_t * keylen)

2200

{

2201

int rc, xx;

2202

DBT data;

2203

2204

if (ii == NULL)

2205

return -1;

2206

2207

if (ii->ii_dbc == NULL)

2208

xx = dbiCopen(ii->ii_dbi, &ii->ii_dbc, 0);

2209

2210

/* free old data */

2211

ii->ii_set = dbiFreeIndexSet(ii->ii_set);

2212

2213

memset(&data, 0, sizeof(data));

2214

rc = dbiGet(ii->ii_dbi, ii->ii_dbc, &ii->ii_key, &data, DB_NEXT);

2215

2216

if (rc != 0) {

2217

*key = NULL;

2218

*keylen = 0;

2219

2220

if (rc != DB_NOTFOUND) {

2221

rpmlog(RPMLOG_ERR,

2222

_("error(%d:%s) getting next key from %s index\n"),

2223

rc, db_strerror(rc), rpmTagGetName(ii->ii_rpmtag));

2224

}

2225

return -1;

2226

}

2227

2228

(void) dbt2set(ii->ii_dbi, &data, &ii->ii_set);

2229

*key = ii->ii_key.data;

2230

*keylen = ii->ii_key.size;

2231

2232

return 0;

2233

}

2234

2235

unsigned int rpmdbIndexIteratorNumPkgs(rpmdbIndexIterator ii)

2236

{

2237

return (ii && ii->ii_set) ? dbiIndexSetCount(ii->ii_set) : 0;

2238

}

2239

2240

unsigned int rpmdbIndexIteratorPkgOffset(rpmdbIndexIterator ii, unsigned int nr)

2241

{

2242

if (!ii || !ii->ii_set)

2243

return 0;

2244

if (dbiIndexSetCount(ii->ii_set) <= nr)

2245

return 0;

2246

return dbiIndexRecordOffset(ii->ii_set, nr);

2247

}

2248

2249

unsigned int rpmdbIndexIteratorTagNum(rpmdbIndexIterator ii, unsigned int nr)

2250

{

2251

if (!ii || !ii->ii_set)

2252

return 0;

2253

if (dbiIndexSetCount(ii->ii_set) <= nr)

2254

return 0;

2255

return dbiIndexRecordFileNumber(ii->ii_set, nr);

2256

}

2257

2258

rpmdbIndexIterator rpmdbIndexIteratorFree(rpmdbIndexIterator ii)

2259

{

2260

rpmdbIndexIterator * prev, next;

2261

int xx;

2262

2263

if (ii == NULL)

2264

return ii;

2265

2266

prev = &rpmiiRock;

2267

while ((next = *prev) != NULL && next != ii)

2268

prev = &next->ii_next;

2269

if (next) {

2270

*prev = next->ii_next;

2271

next->ii_next = NULL;

2272

}

2273

2274

if (ii->ii_dbc)

2275

xx = dbiCclose(ii->ii_dbi, ii->ii_dbc, 0);

2276

ii->ii_dbc = NULL;

2277

ii->ii_dbi = NULL;

2278

ii->ii_db = rpmdbUnlink(ii->ii_db);

2279

ii->ii_set = dbiFreeIndexSet(ii->ii_set);

2280

2281

ii = _free(ii);

2282

return ii;

2283

}

2284

2285

2286

2287

2288

static void logAddRemove(const char *dbiname, int removing, rpmtd tagdata)

2486

2289

{

2487

2290

rpm_count_t c = rpmtdCount(tagdata);

2488

2291

if (c == 1 && rpmtdType(tagdata) == RPM_STRING_TYPE) {

2489

2292

rpmlog(RPMLOG_DEBUG, "%s \"%s\" %s %s index.\n",

2490

2293

removing ? "removing" : "adding", rpmtdGetString(tagdata),

2491

removing ? "from" : "to",

2492

rpmTagGetName(rpmtdTag(tagdata)));

2294

removing ? "from" : "to", dbiname);

2493

2295

} else if (c > 0) {

2494

2296

rpmlog(RPMLOG_DEBUG, "%s %d entries %s %s index.\n",

2495

2297

removing ? "removing" : "adding", c,

2496

removing ? "from" : "to",

2497

rpmTagGetName(rpmtdTag(tagdata)));

2298

removing ? "from" : "to", dbiname);

2498

2299

}

2499

2300

}

2500

2301

2501

/* XXX psm.c */

2502

int rpmdbRemove(rpmdb db, int rid, unsigned int hdrNum,

2503

rpmts ts,

2504

rpmRC (*hdrchk) (rpmts ts, const void *uh, size_t uc, char ** msg))

2302

/* Update primary Packages index. NULL hdr means remove */

2303

static int updatePackages(dbiIndex dbi, unsigned int hdrNum, DBT *hdr)

2505

2304

{

2305

union _dbswap mi_offset;

2306

int rc = 0;

2307

int xx;

2506

2308

DBC * dbcursor = NULL;

2507

2309

DBT key;

2508

DBT data;

2509

union _dbswap mi_offset;

2310

2311

if (dbi == NULL || hdrNum == 0)

2312

return 1;

2313

2314

memset(&key, 0, sizeof(key));

2315

2316

xx = dbiCopen(dbi, &dbcursor, DB_WRITECURSOR);

2317

2318

mi_offset.ui = hdrNum;

2319

if (dbiByteSwapped(dbi) == 1)

2320

_DBSWAP(mi_offset);

2321

key.data = (void *) &mi_offset;

2322

key.size = sizeof(mi_offset.ui);

2323

2324

if (hdr) {

2325

rc = dbiPut(dbi, dbcursor, &key, hdr, DB_KEYLAST);

2326

if (rc) {

2327

rpmlog(RPMLOG_ERR,

2328

_("error(%d) adding header #%d record\n"), rc, hdrNum);

2329

}

2330

} else {

2331

DBT data;

2332

2333

memset(&data, 0, sizeof(data));

2334

rc = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

2335

if (rc) {

2336

rpmlog(RPMLOG_ERR,

2337

_("error(%d) removing header #%d record\n"), rc, hdrNum);

2338

} else

2339

rc = dbiDel(dbi, dbcursor, &key, &data, 0);

2340

}

2341

2342

xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);

2343

xx = dbiSync(dbi, 0);

2344

2345

return rc;

2346

}

2347

2348

int rpmdbRemove(rpmdb db, unsigned int hdrNum)

2349

{

2350

dbiIndex dbi;

2510

2351

Header h;

2511

2352

sigset_t signalMask;

2512

2353

int ret = 0;

2513

int rc = 0;

2514

2354

2515

2355

if (db == NULL)

2516

2356

return 0;

2517

2357

2518

memset(&key, 0, sizeof(key));

2519

memset(&data, 0, sizeof(data));

2520

2521

{ rpmdbMatchIterator mi;

2522

mi = rpmdbInitIterator(db, RPMDBI_PACKAGES, &hdrNum, sizeof(hdrNum));

2523

h = rpmdbNextIterator(mi);

2524

if (h)

2525

h = headerLink(h);

2526

mi = rpmdbFreeIterator(mi);

2527

}

2358

h = rpmdbGetHeaderAt(db, hdrNum);

2528

2359

2529

2360

if (h == NULL) {

2530

2361

rpmlog(RPMLOG_ERR, _("%s: cannot read header at 0x%x\n"),

2531

2362

"rpmdbRemove", hdrNum);

2532

2363

return 1;

2533

}

2534

2535

{

2364

} else {

2536

2365

char *nevra = headerGetAsString(h, RPMTAG_NEVRA);

2537

2366

rpmlog(RPMLOG_DEBUG, " --- h#%8u %s\n", hdrNum, nevra);

2538

2367

free(nevra);

2540

2369

2541

2370

(void) blockSignals(&signalMask);

2542

2371

2543

/* FIX: rpmvals heartburn */

2544

{ int dbix;

2545

dbiIndexItem rec = dbiIndexNewItem(hdrNum, 0);

2546

2547

if (dbiTags.tags != NULL)

2548

for (dbix = 0; dbix < dbiTags.max; dbix++) {

2549

dbiIndex dbi;

2550

rpmTag rpmtag;

2372

dbi = rpmdbOpenIndex(db, RPMDBI_PACKAGES, 0);

2373

/* Remove header from primary index */

2374

ret = updatePackages(dbi, hdrNum, NULL);

2375

2376

/* Remove associated data from secondary indexes */

2377

if (ret == 0) {

2378

struct dbiIndexItem rec = { .hdrNum = hdrNum, .tagNum = 0 };

2379

int rc = 0;

2380

DBC * dbcursor = NULL;

2381

DBT key, data;

2382

2383

memset(&key, 0, sizeof(key));

2384

memset(&data, 0, sizeof(data));

2385

2386

for (int dbix = 1; dbix < dbiTagsMax; dbix++) {

2387

rpmDbiTag rpmtag = dbiTags[dbix];

2551

2388

int xx = 0;

2552

2389

struct rpmtd_s tagdata;

2553

2390

2554

dbi = NULL;

2555

rpmtag = dbiTags.tags[dbix];

2556

2557

/* Filter out temporary databases */

2558

if (isTemporaryDB(rpmtag))

2559

continue;

2560

2561

if (rpmtag == RPMDBI_PACKAGES) {

2562

dbi = dbiOpen(db, rpmtag, 0);

2563

if (dbi == NULL) /* XXX shouldn't happen */

2564

continue;

2565

2566

mi_offset.ui = hdrNum;

2567

if (dbiByteSwapped(dbi) == 1)

2568

_DBSWAP(mi_offset);

2569

key.data = &mi_offset;

2570

key.size = sizeof(mi_offset.ui);

2571

2572

rc = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);

2573

rc = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

2574

if (rc) {

2575

rpmlog(RPMLOG_ERR,

2576

_("error(%d) setting header #%d record for %s removal\n"),

2577

rc, hdrNum, rpmTagGetName(dbi->dbi_rpmtag));

2578

} else

2579

rc = dbiDel(dbi, dbcursor, &key, &data, 0);

2580

xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);

2581

dbcursor = NULL;

2582

if (!dbi->dbi_no_dbsync)

2583

xx = dbiSync(dbi, 0);

2584

continue;

2585

}

2586

2391

if (!(dbi = rpmdbOpenIndex(db, rpmtag, 0)))

2392

continue;

2393

2587

2394

if (!headerGet(h, rpmtag, &tagdata, HEADERGET_MINMEM))

2588

2395

continue;

2589

2396

2590

if (!(dbi = dbiOpen(db, rpmtag, 0))) {

2591

rpmtdFreeData(&tagdata);

2592

continue;

2593

}

2594

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);

2397

xx = dbiCopen(dbi, &dbcursor, DB_WRITECURSOR);

2595

2398

2596

logAddRemove(1, &tagdata);

2399

logAddRemove(dbiName(dbi), 1, &tagdata);

2597

2400

while (rpmtdNext(&tagdata) >= 0) {

2598

2401

dbiIndexSet set;

2599

2402

int freedata = 0;

2623

2426

} else { /* error */

2624

2427

rpmlog(RPMLOG_ERR,

2625

2428

_("error(%d) setting \"%s\" records from %s index\n"),

2626

rc, (char*)key.data, rpmTagGetName(dbi->dbi_rpmtag));

2429

rc, (char*)key.data, dbiName(dbi));

2627

2430

ret += 1;

2628

2431

goto cont;

2629

2432

}

2630

2433

2631

rc = dbiPruneSet(set, rec, 1, sizeof(*rec), 1);

2434

rc = dbiPruneSet(set, &rec, 1, sizeof(rec), 1);

2632

2435

2633

2436

/* If nothing was pruned, then don't bother updating. */

2634

2437

if (rc) {

2642

2445

if (rc) {

2643

2446

rpmlog(RPMLOG_ERR,

2644

2447

_("error(%d) storing record \"%s\" into %s\n"),

2645

rc, (char*)key.data, rpmTagGetName(dbi->dbi_rpmtag));

2448

rc, (char*)key.data, dbiName(dbi));

2646

2449

ret += 1;

2647

2450

}

2648

2451

data.data = _free(data.data);

2652

2455

if (rc) {

2653

2456

rpmlog(RPMLOG_ERR,

2654

2457

_("error(%d) removing record \"%s\" from %s\n"),

2655

rc, (char*)key.data, rpmTagGetName(dbi->dbi_rpmtag));

2458

rc, (char*)key.data, dbiName(dbi));

2656

2459

ret += 1;

2657

2460

}

2658

2461

}

2666

2469

xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);

2667

2470

dbcursor = NULL;

2668

2471

2669

if (!dbi->dbi_no_dbsync)

2670

xx = dbiSync(dbi, 0);

2472

xx = dbiSync(dbi, 0);

2671

2473

2672

2474

rpmtdFreeData(&tagdata);

2673

2475

}

2674

2675

rec = _free(rec);

2676

2476

}

2677

2477

2678

2478

(void) unblockSignals(&signalMask);

2683

2483

return 0;

2684

2484

}

2685

2485

2686

/* XXX install.c */

2687

int rpmdbAdd(rpmdb db, int iid, Header h,

2688

rpmts ts,

2689

rpmRC (*hdrchk) (rpmts ts, const void *uh, size_t uc, char ** msg))

2486

/* Get current header instance number or try to allocate a new one */

2487

static unsigned int pkgInstance(dbiIndex dbi, int alloc)

2690

2488

{

2691

DBC * dbcursor = NULL;

2692

DBT key;

2693

DBT data;

2694

sigset_t signalMask;

2695

dbiIndex dbi;

2696

int dbix;

2697

union _dbswap mi_offset;

2698

2489

unsigned int hdrNum = 0;

2699

int ret = 0;

2700

int rc;

2701

int xx;

2702

2703

if (db == NULL)

2704

return 0;

2705

2706

memset(&key, 0, sizeof(key));

2707

memset(&data, 0, sizeof(data));

2708

2709

#ifdef NOTYET /* XXX headerDel() broken on dribbles. */

2710

xx = headerDel(h, RPMTAG_REMOVETID);

2711

#endif

2712

if (iid != 0 && iid != -1) {

2713

rpm_tid_t tid = iid;

2714

if (!headerIsEntry(h, RPMTAG_INSTALLTID))

2715

headerPutUint32(h, RPMTAG_INSTALLTID, &tid, 1);

2716

}

2717

2718

(void) blockSignals(&signalMask);

2719

2720

{

2490

2491

if (dbi != NULL && dbiType(dbi) == DBI_PRIMARY) {

2492

DBC * dbcursor = NULL;

2493

DBT key, data;

2721

2494

unsigned int firstkey = 0;

2722

void * keyp = &firstkey;

2723

size_t keylen = sizeof(firstkey);

2724

void * datap = NULL;

2725

size_t datalen = 0;

2726

2727

dbi = dbiOpen(db, RPMDBI_PACKAGES, 0);

2728

if (dbi != NULL) {

2729

2730

/* XXX db0: hack to pass sizeof header to fadAlloc */

2731

datap = h;

2732

datalen = headerSizeof(h, HEADER_MAGIC_NO);

2733

2734

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);

2735

2736

/* Retrieve join key for next header instance. */

2737

2738

key.data = keyp;

2739

key.size = keylen;

2740

data.data = datap;

2741

data.size = datalen;

2495

union _dbswap mi_offset;

2496

int ret;

2497

2498

memset(&key, 0, sizeof(key));

2499

memset(&data, 0, sizeof(data));

2500

2501

ret = dbiCopen(dbi, &dbcursor, alloc ? DB_WRITECURSOR : 0);

2502

2503

/* Key 0 holds the current largest instance, fetch it */

2504

key.data = &firstkey;

2505

key.size = sizeof(firstkey);

2742

2506

ret = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

2743

keyp = key.data;

2744

keylen = key.size;

2745

datap = data.data;

2746

datalen = data.size;

2747

2507

2748

hdrNum = 0;

2749

if (ret == 0 && datap) {

2750

memcpy(&mi_offset, datap, sizeof(mi_offset.ui));

2508

if (ret == 0 && data.data) {

2509

memcpy(&mi_offset, data.data, sizeof(mi_offset.ui));

2751

2510

if (dbiByteSwapped(dbi) == 1)

2752

2511

_DBSWAP(mi_offset);

2753

2512

hdrNum = mi_offset.ui;

2754

2513

}

2755

++hdrNum;

2756

mi_offset.ui = hdrNum;

2757

if (dbiByteSwapped(dbi) == 1)

2758

_DBSWAP(mi_offset);

2759

if (ret == 0 && datap) {

2760

memcpy(datap, &mi_offset, sizeof(mi_offset.ui));

2761

} else {

2762

datap = &mi_offset;

2763

datalen = sizeof(mi_offset.ui);

2764

}

2765

2766

key.data = keyp;

2767

key.size = keylen;

2768

data.data = datap;

2769

data.size = datalen;

2770

2771

ret = dbiPut(dbi, dbcursor, &key, &data, DB_KEYLAST);

2772

xx = dbiSync(dbi, 0);

2773

2774

xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);

2775

dbcursor = NULL;

2776

}

2777

2778

}

2779

2780

if (ret) {

2781

rpmlog(RPMLOG_ERR,

2782

_("error(%d) allocating new package instance\n"), ret);

2514

2515

if (alloc) {

2516

/* Rather complicated "increment by one", bswapping as needed */

2517

++hdrNum;

2518

mi_offset.ui = hdrNum;

2519

if (dbiByteSwapped(dbi) == 1)

2520

_DBSWAP(mi_offset);

2521

if (ret == 0 && data.data) {

2522

memcpy(data.data, &mi_offset, sizeof(mi_offset.ui));

2523

} else {

2524

data.data = &mi_offset;

2525

data.size = sizeof(mi_offset.ui);

2526

}

2527

2528

/* Unless we manage to insert the new instance number, we failed */

2529

ret = dbiPut(dbi, dbcursor, &key, &data, DB_KEYLAST);

2530

if (ret) {

2531

hdrNum = 0;

2532

rpmlog(RPMLOG_ERR,

2533

_("error(%d) allocating new package instance\n"), ret);

2534

}

2535

2536

ret = dbiSync(dbi, 0);

2537

}

2538

ret = dbiCclose(dbi, dbcursor, 0);

2539

}

2540

2541

return hdrNum;

2542

}

2543

2544

/* Add data to secondary index */

2545

static int addToIndex(dbiIndex dbi, rpmTagVal rpmtag, unsigned int hdrNum, Header h)

2546

{

2547

int xx, i, rc = 0;

2548

struct rpmtd_s tagdata, reqflags;

2549

DBC * dbcursor = NULL;

2550

2551

switch (rpmtag) {

2552

case RPMTAG_REQUIRENAME:

2553

headerGet(h, RPMTAG_REQUIREFLAGS, &reqflags, HEADERGET_MINMEM);

2554

/* fallthrough */

2555

default:

2556

headerGet(h, rpmtag, &tagdata, HEADERGET_MINMEM);

2557

break;

2558

}

2559

2560

if (rpmtdCount(&tagdata) == 0) {

2561

if (rpmtag != RPMTAG_GROUP)

2562

goto exit;

2563

2564

/* XXX preserve legacy behavior */

2565

tagdata.type = RPM_STRING_TYPE;

2566

tagdata.data = (const char **) "Unknown";

2567

tagdata.count = 1;

2568

}

2569

2570

xx = dbiCopen(dbi, &dbcursor, DB_WRITECURSOR);

2571

2572

logAddRemove(dbiName(dbi), 0, &tagdata);

2573

while ((i = rpmtdNext(&tagdata)) >= 0) {

2574

dbiIndexSet set;

2575

int freedata = 0, j;

2576

DBT key, data;

2577

/* Include the tagNum in all indices (only files use though) */

2578

struct dbiIndexItem rec = { .hdrNum = hdrNum, .tagNum = i };

2579

2580

switch (rpmtag) {

2581

case RPMTAG_REQUIRENAME: {

2582

/* Filter out install prerequisites. */

2583

rpm_flag_t *rflag = rpmtdNextUint32(&reqflags);

2584

if (rflag && isInstallPreReq(*rflag) &&

2585

!isErasePreReq(*rflag))

2586

continue;

2587

break;

2588

}

2589

case RPMTAG_TRIGGERNAME:

2590

if (i > 0) { /* don't add duplicates */

2591

const char **tnames = tagdata.data;

2592

const char *str = rpmtdGetString(&tagdata);

2593

for (j = 0; j < i; j++) {

2594

if (rstreq(str, tnames[j]))

2595

break;

2596

}

2597

if (j < i)

2598

continue;

2599

}

2600

break;

2601

default:

2602

break;

2603

}

2604

2605

memset(&key, 0, sizeof(key));

2606

memset(&data, 0, sizeof(data));

2607

2608

if (!td2key(&tagdata, &key, &freedata)) {

2609

continue;

2610

}

2611

2612

2613

* XXX with duplicates, an accurate data value and

2614

* DB_GET_BOTH is needed.

2615

2616

2617

set = NULL;

2618

2619

rc = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

2620

if (rc == 0) { /* success */

2621

/* With duplicates, cursor is positioned, discard the record. */

2622

if (!dbi->dbi_permit_dups)

2623

(void) dbt2set(dbi, &data, &set);

2624

} else if (rc != DB_NOTFOUND) { /* error */

2625

rpmlog(RPMLOG_ERR,

2626

_("error(%d) getting \"%s\" records from %s index\n"),

2627

rc, (char*)key.data, dbiName(dbi));

2628

rc += 1;

2629

goto cont;

2630

}

2631

2632

if (set == NULL) /* not found or duplicate */

2633

set = xcalloc(1, sizeof(*set));

2634

2635

(void) dbiAppendSet(set, &rec, 1, sizeof(rec), 0);

2636

2637

(void) set2dbt(dbi, &data, set);

2638

rc = dbiPut(dbi, dbcursor, &key, &data, DB_KEYLAST);

2639

2640

if (rc) {

2641

rpmlog(RPMLOG_ERR,

2642

_("error(%d) storing record %s into %s\n"),

2643

rc, (char*)key.data, dbiName(dbi));

2644

rc += 1;

2645

}

2646

data.data = _free(data.data);

2647

data.size = 0;

2648

set = dbiFreeIndexSet(set);

2649

cont:

2650

if (freedata) {

2651

free(key.data);

2652

}

2653

}

2654

2655

xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);

2656

dbcursor = NULL;

2657

2658

xx = dbiSync(dbi, 0);

2659

2660

exit:

2661

rpmtdFreeData(&tagdata);

2662

return rc;

2663

}

2664

2665

int rpmdbAdd(rpmdb db, Header h)

2666

{

2667

DBT hdr;

2668

sigset_t signalMask;

2669

dbiIndex dbi;

2670

unsigned int hdrNum = 0;

2671

int ret = 0;

2672

int hdrOk;

2673

2674

if (db == NULL)

2675

return 0;

2676

2677

memset(&hdr, 0, sizeof(hdr));

2678

2679

hdr.size = headerSizeof(h, HEADER_MAGIC_NO);

2680

hdr.data = headerUnload(h);

2681

hdrOk = (hdr.data != NULL && hdr.size > 0);

2682

2683

if (!hdrOk) {

2684

ret = -1;

2783

2685

goto exit;

2784

2686

}

2785

2687

2786

/* Now update the indexes */

2787

2788

if (hdrNum)

2789

{

2790

dbiIndexItem rec = dbiIndexNewItem(hdrNum, 0);

2791

2792

if (dbiTags.tags != NULL)

2793

for (dbix = 0; dbix < dbiTags.max; dbix++) {

2794

rpmTag rpmtag;

2795

rpmRC rpmrc;

2796

int j;

2797

struct rpmtd_s tagdata, reqflags;

2798

2799

rpmrc = RPMRC_NOTFOUND;

2800

dbi = NULL;

2801

rpmtag = dbiTags.tags[dbix];

2802

2803

/* Filter out temporary databases */

2804

if (isTemporaryDB(rpmtag))

2805

continue;

2806

2807

switch (rpmtag) {

2808

case RPMDBI_PACKAGES:

2809

dbi = dbiOpen(db, rpmtag, 0);

2810

if (dbi == NULL) /* XXX shouldn't happen */

2811

continue;

2812

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);

2813

2814

mi_offset.ui = hdrNum;

2815

if (dbiByteSwapped(dbi) == 1)

2816

_DBSWAP(mi_offset);

2817

key.data = (void *) &mi_offset;

2818

key.size = sizeof(mi_offset.ui);

2819

data.data = headerUnload(h);

2820

data.size = headerSizeof(h, HEADER_MAGIC_NO);

2821

2822

/* Check header digest/signature on blob export. */

2823

if (hdrchk && ts) {

2824

char * msg = NULL;

2825

int lvl;

2826

2827

rpmrc = (*hdrchk) (ts, data.data, data.size, &msg);

2828

lvl = (rpmrc == RPMRC_FAIL ? RPMLOG_ERR : RPMLOG_DEBUG);

2829

rpmlog(lvl, "%s h#%8u %s",

2830

(rpmrc == RPMRC_FAIL ? _("rpmdbAdd: skipping") : " +++"),

2831

hdrNum, (msg ? msg : "\n"));

2832

msg = _free(msg);

2833

}

2834

2835

if (data.data != NULL && rpmrc != RPMRC_FAIL) {

2836

xx = dbiPut(dbi, dbcursor, &key, &data, DB_KEYLAST);

2837

xx = dbiSync(dbi, 0);

2838

}

2839

data.data = _free(data.data);

2840

data.size = 0;

2841

xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);

2842

dbcursor = NULL;

2843

if (!dbi->dbi_no_dbsync)

2844

xx = dbiSync(dbi, 0);

2845

continue;

2846

break;

2847

case RPMTAG_REQUIRENAME:

2848

headerGet(h, rpmtag, &tagdata, HEADERGET_MINMEM);

2849

headerGet(h, RPMTAG_REQUIREFLAGS, &reqflags, HEADERGET_MINMEM);

2850

break;

2851

default:

2852

headerGet(h, rpmtag, &tagdata, HEADERGET_MINMEM);

2853

break;

2854

}

2855

2856

if (rpmtdCount(&tagdata) == 0) {

2857

if (rpmtag != RPMTAG_GROUP)

2858

continue;

2859

2860

/* XXX preserve legacy behavior */

2861

tagdata.type = RPM_STRING_TYPE;

2862

tagdata.data = (const char **) "Unknown";

2863

tagdata.count = 1;

2864

}

2865

2866

if (!(dbi = dbiOpen(db, rpmtag, 0))) {

2867

rpmtdFreeData(&tagdata);

2868

continue;

2869

}

2870

xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);

2871

2872

logAddRemove(0, &tagdata);

2873

while (rpmtdNext(&tagdata) >= 0) {

2874

dbiIndexSet set;

2875

int i, freedata = 0;

2876

2877

2878

* Include the tagNum in all indices. rpm-3.0.4 and earlier

2879

* included the tagNum only for files.

2880

2881

i = rec->tagNum = rpmtdGetIndex(&tagdata);

2882

switch (rpmtag) {

2883

case RPMTAG_REQUIRENAME: {

2884

/* Filter out install prerequisites. */

2885

rpm_flag_t *rflag = rpmtdNextUint32(&reqflags);

2886

if (rflag && isInstallPreReq(*rflag) &&

2887

!isErasePreReq(*rflag))

2888

continue;

2889

break;

2890

}

2891

case RPMTAG_TRIGGERNAME:

2892

if (i > 0) { /* don't add duplicates */

2893

const char **tnames = tagdata.data;

2894

const char *str = rpmtdGetString(&tagdata);

2895

for (j = 0; j < i; j++) {

2896

if (rstreq(str, tnames[j]))

2897

break;

2898

}

2899

if (j < i)

2900

continue;

2901

}

2902

break;

2903

default:

2904

break;

2905

}

2906

2907

if (!td2key(&tagdata, &key, &freedata)) {

2908

continue;

2909

}

2910

2911

2912

* XXX with duplicates, an accurate data value and

2913

* DB_GET_BOTH is needed.

2914

2915

2916

set = NULL;

2917

2918

rc = dbiGet(dbi, dbcursor, &key, &data, DB_SET);

2919

if (rc == 0) { /* success */

2920

/* With duplicates, cursor is positioned, discard the record. */

2921

if (!dbi->dbi_permit_dups)

2922

(void) dbt2set(dbi, &data, &set);

2923

} else if (rc != DB_NOTFOUND) { /* error */

2924

rpmlog(RPMLOG_ERR,

2925

_("error(%d) getting \"%s\" records from %s index\n"),

2926

rc, (char*)key.data, rpmTagGetName(dbi->dbi_rpmtag));

2927

ret += 1;

2928

goto cont;

2929

}

2930

2931

if (set == NULL) /* not found or duplicate */

2932

set = xcalloc(1, sizeof(*set));

2933

2934

(void) dbiAppendSet(set, rec, 1, sizeof(*rec), 0);

2935

2936

(void) set2dbt(dbi, &data, set);

2937

rc = dbiPut(dbi, dbcursor, &key, &data, DB_KEYLAST);

2938

2939

if (rc) {

2940

rpmlog(RPMLOG_ERR,

2941

_("error(%d) storing record %s into %s\n"),

2942

rc, (char*)key.data, rpmTagGetName(dbi->dbi_rpmtag));

2943

ret += 1;

2944

}

2945

data.data = _free(data.data);

2946

data.size = 0;

2947

set = dbiFreeIndexSet(set);

2948

cont:

2949

if (freedata) {

2950

free(key.data);

2951

}

2952

}

2953

2954

xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);

2955

dbcursor = NULL;

2956

2957

if (!dbi->dbi_no_dbsync)

2958

xx = dbiSync(dbi, 0);

2959

2960

rpmtdFreeData(&tagdata);

2961

}

2962

2963

rec = _free(rec);

2964

/* If everthing ok, mark header as installed now */

2965

if (ret == 0) {

2966

headerSetInstance(h, hdrNum);

2967

}

2688

(void) blockSignals(&signalMask);

2689

2690

dbi = rpmdbOpenIndex(db, RPMDBI_PACKAGES, 0);

2691

hdrNum = pkgInstance(dbi, 1);

2692

2693

/* Add header to primary index */

2694

ret = updatePackages(dbi, hdrNum, &hdr);

2695

2696

/* Add associated data to secondary indexes */

2697

if (ret == 0) {

2698

for (int dbix = 1; dbix < dbiTagsMax; dbix++) {

2699

rpmDbiTag rpmtag = dbiTags[dbix];

2700

2701

if (!(dbi = rpmdbOpenIndex(db, rpmtag, 0)))

2702

continue;

2703

2704

ret += addToIndex(dbi, rpmtag, hdrNum, h);

2705

}

2706

}

2707

2708

/* If everthing ok, mark header as installed now */

2709

if (ret == 0) {

2710

headerSetInstance(h, hdrNum);

2968

2711

}

2969

2712

2970

2713

exit:

2714

free(hdr.data);

2971

2715

(void) unblockSignals(&signalMask);

2972

2716

2973

2717

return ret;

2978

2722

* rm -f <prefix>/<dbpath>/__db.???

2979

2723

* Environment files not existing is not an error, failure to unlink is,

2980

2724

* return zero on success.

2981

* Only useful for BDB, dbapi 3 and 4.

2982

2725

* TODO/FIX: push this down to db3.c where it belongs

2983

2726

2984

2727

static int cleanDbenv(const char *prefix, const char *dbpath)

2997

2740

return rc;

2998

2741

}

2999

2742

3000

static int rpmdbRemoveDatabase(const char * prefix,

3001

const char * dbpath, int _dbapi)

2743

static int rpmdbRemoveDatabase(const char * prefix, const char * dbpath)

3002

2744

{

3003

2745

int i;

3004

2746

char *path;

3005

2747

int xx;

3006

2748

3007

dbiTagsInit();

3008

switch (_dbapi) {

3009

case 4:

3010

case 3:

3011

if (dbiTags.tags != NULL)

3012

for (i = 0; i < dbiTags.max; i++) {

3013

const char * base = rpmTagGetName(dbiTags.tags[i]);

3014

path = rpmGetPath(prefix, "/", dbpath, "/", base, NULL);

3015

if (access(path, F_OK) == 0)

3016

xx = unlink(path);

3017

free(path);

3018

}

3019

cleanDbenv(prefix, dbpath);

3020

break;

3021

case 2:

3022

case 1:

3023

case 0:

3024

break;

2749

for (i = 0; i < dbiTagsMax; i++) {

2750

const char * base = rpmTagGetName(dbiTags[i]);

2751

path = rpmGetPath(prefix, "/", dbpath, "/", base, NULL);

2752

if (access(path, F_OK) == 0)

2753

xx = unlink(path);

2754

free(path);

3025

2755

}

3026

dbiTagsFree();

2756

cleanDbenv(prefix, dbpath);

3027

2757

3028

2758

path = rpmGetPath(prefix, "/", dbpath, NULL);

3029

2759

xx = rmdir(path);

3033

2763

}

3034

2764

3035

2765

static int rpmdbMoveDatabase(const char * prefix,

3036

const char * olddbpath, int _olddbapi,

3037

const char * newdbpath, int _newdbapi)

2766

const char * olddbpath, const char * newdbpath)

3038

2767

{

3039

2768

int i;

3040

2769

struct stat st;

3043

2772

int selinux = is_selinux_enabled() && (matchpathcon_init(NULL) != -1);

3044

2773

sigset_t sigMask;

3045

2774

3046

dbiTagsInit();

3047

2775

blockSignals(&sigMask);

3048

switch (_olddbapi) {

3049

case 4:

3050

/* Fall through */

3051

case 3:

3052

if (dbiTags.tags != NULL)

3053

for (i = 0; i < dbiTags.max; i++) {

3054

const char * base;

3055

char *src, *dest;

3056

rpmTag rpmtag;

3057

3058

/* Filter out temporary databases */

3059

if (isTemporaryDB((rpmtag = dbiTags.tags[i])))

3060

continue;

3061

3062

base = rpmTagGetName(rpmtag);

3063

src = rpmGetPath(prefix, "/", olddbpath, "/", base, NULL);

3064

dest = rpmGetPath(prefix, "/", newdbpath, "/", base, NULL);

3065

3066

if (access(src, F_OK) != 0)

3067

goto cont;

3068

3069

3070

* Restore uid/gid/mode/mtime/security context if possible.

3071

3072

if (stat(dest, &st) < 0)

3073

if (stat(src, &st) < 0)

3074

goto cont;

3075

3076

if ((xx = rename(src, dest)) != 0) {

3077

rc = 1;

3078

goto cont;

3079

}

3080

xx = chown(dest, st.st_uid, st.st_gid);

3081

xx = chmod(dest, (st.st_mode & 07777));

3082

{ struct utimbuf stamp;

3083

stamp.actime = st.st_atime;

3084

stamp.modtime = st.st_mtime;

3085

xx = utime(dest, &stamp);

3086

}

3087

3088

if (selinux) {

3089

security_context_t scon = NULL;

3090

if (matchpathcon(dest, st.st_mode, &scon) != -1) {

3091

(void) setfilecon(dest, scon);

3092

freecon(scon);

3093

}

3094

}

3095

2776

for (i = 0; i < dbiTagsMax; i++) {

2777

rpmDbiTag rpmtag = dbiTags[i];

2778

const char *base = rpmTagGetName(rpmtag);

2779

char *src = rpmGetPath(prefix, "/", olddbpath, "/", base, NULL);

2780

char *dest = rpmGetPath(prefix, "/", newdbpath, "/", base, NULL);

2781

2782

if (access(src, F_OK) != 0)

2783

goto cont;

2784

2785

2786

* Restore uid/gid/mode/security context if possible.

2787

2788

if (stat(dest, &st) < 0)

2789

if (stat(src, &st) < 0)

2790

goto cont;

2791

2792

if ((xx = rename(src, dest)) != 0) {

2793

rc = 1;

2794

goto cont;

2795

}

2796

xx = chown(dest, st.st_uid, st.st_gid);

2797

xx = chmod(dest, (st.st_mode & 07777));

2798

2799

if (selinux) {

2800

security_context_t scon = NULL;

2801

if (matchpathcon(dest, st.st_mode, &scon) != -1) {

2802

(void) setfilecon(dest, scon);

2803

freecon(scon);

2804

}

2805

}

2806

3096

2807

cont:

3097

free(src);

3098

free(dest);

3099

}

3100

3101

cleanDbenv(prefix, olddbpath);

3102

cleanDbenv(prefix, newdbpath);

3103

break;

3104

case 2:

3105

case 1:

3106

case 0:

3107

break;

2808

free(src);

2809

free(dest);

3108

2810

}

2811

2812

cleanDbenv(prefix, olddbpath);

2813

cleanDbenv(prefix, newdbpath);

2814

3109

2815

unblockSignals(&sigMask);

3110

2816

3111

#ifdef SQLITE_HACK_XXX

3112

if (rc || _olddbapi == _newdbapi)

3113

return rc;

3114

3115

rc = rpmdbRemoveDatabase(prefix, newdbpath, _newdbapi);

3116

3117

#endif

3118

2817

if (selinux) {

3119

2818

(void) matchpathcon_fini();

3120

2819

}

3121

dbiTagsFree();

3122

2820

return rc;

3123

2821

}

3124

2822

3131

2829

rpmdb newdb;

3132

2830

char * newdbpath = NULL;

3133

2831

char * newrootdbpath = NULL;

3134

char * tfn;

3135

2832

int nocleanup = 1;

3136

2833

int failed = 0;

3137

2834

int removedir = 0;

3138

2835

int rc = 0, xx;

3139

int _dbapi;

3140

int _dbapi_rebuild;

3141

3142

if (prefix == NULL) prefix = "/";

3143

3144

_dbapi = rpmExpandNumeric("%{_dbapi}");

3145

_dbapi_rebuild = rpmExpandNumeric("%{_dbapi_rebuild}");

3146

3147

tfn = rpmGetPath("%{?_dbpath}", NULL);

3148

if (!(tfn && tfn[0] != '\0'))

3149

{

2836

2837

dbpath = rpmGetPath("%{?_dbpath}", NULL);

2838

if (rstreq(dbpath, "")) {

3150

2839

rpmlog(RPMLOG_ERR, _("no dbpath has been set"));

3151

2840

rc = 1;

3152

2841

goto exit;

3153

2842

}

3154

dbpath = rootdbpath = rpmGetPath(prefix, tfn, NULL);

3155

if (!(prefix[0] == '/' && prefix[1] == '\0'))

3156

dbpath += strlen(prefix) - 1;

3157

tfn = _free(tfn);

2843

rootdbpath = rpmGetPath(prefix, dbpath, NULL);

3158

2844

3159

tfn = rpmGetPath("%{?_dbpath_rebuild}", NULL);

3160

if (!(tfn && tfn[0] != '\0' && !rstreq(tfn, dbpath)))

3161

{

3162

tfn = _free(tfn);

3163

rasprintf(&tfn, "%srebuilddb.%d", dbpath, (int) getpid());

2845

newdbpath = rpmGetPath("%{?_dbpath_rebuild}", NULL);

2846

if (rstreq(newdbpath, "") || rstreq(newdbpath, dbpath)) {

2847

newdbpath = _free(newdbpath);

2848

rasprintf(&newdbpath, "%srebuilddb.%d", dbpath, (int) getpid());

3164

2849

nocleanup = 0;

3165

2850

}

3166

newdbpath = newrootdbpath = rpmGetPath(prefix, tfn, NULL);

3167

if (!(prefix[0] == '/' && prefix[1] == '\0'))

3168

newdbpath += strlen(prefix) - 1;

3169

tfn = _free(tfn);

2851

newrootdbpath = rpmGetPath(prefix, newdbpath, NULL);

3170

2852

3171

2853

rpmlog(RPMLOG_DEBUG, "rebuilding database %s into %s\n",

3172

2854

rootdbpath, newrootdbpath);

3173

2855

3174

if (!access(newrootdbpath, F_OK)) {

3175

rpmlog(RPMLOG_ERR, _("temporary database %s already exists\n"),

3176

newrootdbpath);

3177

rc = 1;

3178

goto exit;

3179

}

3180

3181

rpmlog(RPMLOG_DEBUG, "creating directory %s\n", newrootdbpath);

3182

2856

if (mkdir(newrootdbpath, 0755)) {

3183

2857

rpmlog(RPMLOG_ERR, _("failed to create directory %s: %s\n"),

3184

2858

newrootdbpath, strerror(errno));

3187

2861

}

3188

2862

removedir = 1;

3189

2863

3190

_rebuildinprogress = 0;

3191

3192

rpmlog(RPMLOG_DEBUG, "opening old database with dbapi %d\n",

3193

_dbapi);

3194

if (openDatabase(prefix, dbpath, _dbapi, &olddb, O_RDONLY, 0644,

3195

RPMDB_FLAG_MINIMAL)) {

3196

rc = 1;

3197

goto exit;

3198

}

3199

_dbapi = olddb->db_api;

3200

_rebuildinprogress = 1;

3201

rpmlog(RPMLOG_DEBUG, "opening new database with dbapi %d\n",

3202

_dbapi_rebuild);

3203

(void) rpmDefineMacro(NULL, "_rpmdb_rebuild %{nil}", -1);

3204

if (openDatabase(prefix, newdbpath, _dbapi_rebuild, &newdb, O_RDWR | O_CREAT, 0644, 0)) {

3205

rc = 1;

3206

goto exit;

3207

}

3208

3209

_rebuildinprogress = 0;

3210

3211

_dbapi_rebuild = newdb->db_api;

3212

2864

if (openDatabase(prefix, dbpath, &olddb, O_RDONLY, 0644, 0)) {

2865

rc = 1;

2866

goto exit;

2867

}

2868

if (openDatabase(prefix, newdbpath, &newdb,

2869

(O_RDWR | O_CREAT), 0644, RPMDB_FLAG_REBUILD)) {

2870

rc = 1;

2871

goto exit;

2872

}

2873

3213

2874

{ Header h = NULL;

3214

2875

rpmdbMatchIterator mi;

3215

2876

#define _RECNUM rpmdbGetIteratorOffset(mi)

3235

2896

/* Deleted entries are eliminated in legacy headers by copy. */

3236

2897

{ Header nh = (headerIsEntry(h, RPMTAG_HEADERIMAGE)

3237

2898

? headerCopy(h) : NULL);

3238

rc = rpmdbAdd(newdb, -1, (nh ? nh : h), ts, hdrchk);

2899

rc = rpmdbAdd(newdb, (nh ? nh : h));

3239

2900

nh = headerFree(nh);

3240

2901

}

3241

2902

3259

2920

_("failed to rebuild database: original database "

3260

2921

"remains in place\n"));

3261

2922

3262

xx = rpmdbRemoveDatabase(prefix, newdbpath, _dbapi_rebuild);

2923

xx = rpmdbRemoveDatabase(prefix, newdbpath);

3263

2924

rc = 1;

3264

2925

goto exit;

3265

2926

} else if (!nocleanup) {

3266

if (rpmdbMoveDatabase(prefix, newdbpath, _dbapi_rebuild, dbpath, _dbapi)) {

2927

if (rpmdbMoveDatabase(prefix, newdbpath, dbpath)) {

3267

2928

rpmlog(RPMLOG_ERR, _("failed to replace old database with new "

3268

2929

"database!\n"));

3269

2930

rpmlog(RPMLOG_ERR, _("replace files in %s with files from %s "

3276

2937

3277

2938

exit:

3278

2939

if (removedir && !(rc == 0 && nocleanup)) {

3279

rpmlog(RPMLOG_DEBUG, "removing directory %s\n", newrootdbpath);

3280

2940

if (rmdir(newrootdbpath))

3281

2941

rpmlog(RPMLOG_ERR, _("failed to remove directory %s: %s\n"),

3282

2942

newrootdbpath, strerror(errno));

3283

2943

}

3284

newrootdbpath = _free(newrootdbpath);

3285

rootdbpath = _free(rootdbpath);

2944

free(newdbpath);

2945

free(dbpath);

2946

free(newrootdbpath);

2947

free(rootdbpath);

3286

2948

3287

2949

return rc;

3288

2950

}

Older »