14 #define _MIRE_INTERNAL
20 #define _RPMBF_INTERNAL
24 #define _RPMTAG_INTERNAL
27 #define _RPMDB_INTERNAL
36 #if defined(__LCLINT__)
37 #define UINT32_T u_int32_t
39 #define UINT32_T rpmuint32_t
43 #if defined(__QNXNTO__)
67 #define _DBI_PERMS 0644
81 if (db->db_tags != NULL)
82 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
83 if (tag != db->db_tags[dbix].tag)
100 static const char *
const _dbiTagStr_default =
101 "Packages:Name:Basenames:Group:Requirename:Providename:Conflictname:Triggername:Dirnames:Requireversion:Provideversion:Installtid:Sigmd5:Sha1header:Filedigests:Depends:Pubkeys";
104 char * dbiTagStr = NULL;
110 dbiTagStr =
rpmExpand(
"%{?_dbi_tags}", NULL);
111 if (!(dbiTagStr && *dbiTagStr)) {
112 dbiTagStr =
_free(dbiTagStr);
113 dbiTagStr =
xstrdup(_dbiTagStr_default);
118 fprintf(stderr,
"--> %s(%p, %p) dbiTagStr %s\n", __FUNCTION__, dbiTagsP, dbiNTagsP, dbiTagStr);
122 dbiTags[dbiNTags].str =
xstrdup(
"Packages");
124 dbiTags[dbiNTags].iob = NULL;
127 for (o = dbiTagStr; o && *o; o = oe) {
132 for (oe = o; oe && *oe; oe++) {
135 if (oe[0] ==
':' && !(oe[1] ==
'/' && oe[2] ==
'/'))
144 for (dbix = 0; dbix < dbiNTags; dbix++) {
145 if (tag == dbiTags[dbix].tag) {
154 dbiTags[dbiNTags].str =
xstrdup(o);
155 dbiTags[dbiNTags].tag = tag;
156 dbiTags[dbiNTags].iob = NULL;
159 fprintf(stderr,
"\t%u %s(", (
unsigned)dbiNTags, o);
160 if (tag & 0x40000000)
161 fprintf(stderr,
"0x%x)\n", tag);
163 fprintf(stderr,
"%d)\n", tag);
169 if (dbiNTagsP != NULL)
170 *dbiNTagsP = dbiNTags;
171 if (dbiTagsP != NULL)
175 dbiTagStr =
_free(dbiTagStr);
186 extern struct _dbiVec
db3vec;
188 #define DB3vec &db3vec
194 #if defined(HAVE_SQLITE3_H)
199 #define SQLITEvec &sqlitevec
202 #define SQLITEvec NULL
218 if (fstat(fdno, &sb) == -1 &&
errno == EBADF)
219 ret = (open(devnull, flags) == fdno) ? 1 : 2;
225 static int _oneshot = 0;
233 static const char _devnull[] =
"/dev/null";
235 #if defined(STDIN_FILENO)
236 (void)
checkfd(_devnull, STDIN_FILENO, O_RDONLY);
238 #if defined(STDOUT_FILENO)
239 (void)
checkfd(_devnull, STDOUT_FILENO, O_WRONLY);
241 #if defined(STDERR_FILENO)
242 (void)
checkfd(_devnull, STDERR_FILENO, O_WRONLY);
249 assert(db->_dbi != NULL);
253 if (dbix >= db->db_ndbi)
257 if ((dbi = db->_dbi[dbix]) != NULL)
261 assert(_dbapi == 3 || _dbapi == 4);
262 assert(mydbvecs[_dbapi] != NULL);
264 rc = (*mydbvecs[_dbapi]->open) (db, tag, &dbi);
266 static uint8_t _printed[128];
267 if (!_printed[dbix & 0x1f]++)
269 _(
"cannot open %s(%u) index: %s(%d)\n\tDB: %s\n"),
271 (rc > 0 ? strerror(rc) :
""), rc,
272 ((mydbvecs[_dbapi]->dbv_version != NULL)
273 ? mydbvecs[_dbapi]->dbv_version :
"unknown"));
277 db->_dbi[dbix] = dbi;
283 fprintf(stderr,
"<== dbiOpen(%p, %s(%u), 0x%x) dbi %p = %p[%u:%u]\n", db,
tagName(tag), tag, flags, dbi, db->_dbi, (
unsigned)dbix, (
unsigned)db->db_ndbi);
308 if (_endian.
uc[0] == 0x44) {
309 uint8_t _b, *_c = _a.
uc; \
310 _b = _c[7]; _c[7] = _c[0]; _c[0] = _b; \
311 _b = _c[6]; _c[6] = _c[1]; _c[1] = _b; \
312 _b = _c[5]; _c[5] = _c[2]; _c[2] = _b; \
313 _b = _c[4]; _c[4] = _c[3]; _c[3] = _b; \
328 if (_endian.
uc[0] == 0x44) {
329 uint8_t _b, *_c = _a.
uc; \
330 _b = _c[3]; _c[3] = _c[0]; _c[0] = _b; \
331 _b = _c[2]; _c[2] = _c[1]; _c[1] = _b; \
346 if (_endian.
uc[0] == 0x44) {
347 uint8_t _b, *_c = _a.
uc; \
348 _b = _c[1]; _c[1] = _c[0]; _c[0] = _b; \
368 const int * a = (
const int *) one;
369 const int *
b = (
const int *) two;
383 int nrecs,
size_t recsize,
int sortset)
386 const char * rptr = (
const char *) recs;
387 size_t rlen = (recsize <
sizeof(*(set->recs)))
388 ? recsize :
sizeof(*(set->recs));
390 if (set == NULL || recs == NULL || nrecs <= 0 || recsize == 0)
394 (set->count + nrecs) *
sizeof(*(set->recs)));
396 memset(set->recs + set->count, 0, nrecs *
sizeof(*(set->recs)));
398 while (nrecs-- > 0) {
400 memcpy(set->recs + set->count, rptr, rlen);
406 if (sortset && set->count > 1)
407 qsort(set->recs, set->count,
sizeof(*(set->recs)),
hdrNumCmp);
419 return set->recs[recno].hdrNum;
424 return set->recs[recno].tagNum;
430 set->recs =
_free(set->recs);
464 #if defined(__LCLINT__)
480 sigset_t newMask, oldMask;
481 static int terminating = 0;
483 if (terminating)
return 1;
485 (void) sigfillset(&newMask);
486 (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
504 while ((mi = rpmmiRock) != NULL) {
511 while ((db = rpmdbRock) != NULL) {
512 rpmdbRock = db->db_next;
519 (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
547 (void) sigfillset(&newMask);
548 (void) sigprocmask(SIG_BLOCK, &newMask, oldMask);
549 (void) sigdelset(&newMask, SIGINT);
550 (void) sigdelset(&newMask, SIGQUIT);
551 (void) sigdelset(&newMask, SIGHUP);
552 (void) sigdelset(&newMask, SIGTERM);
553 (void) sigdelset(&newMask, SIGPIPE);
554 return sigprocmask(SIG_BLOCK, &newMask, NULL);
569 return sigprocmask(SIG_SETMASK, oldMask, NULL);
583 const char *
errstr =
"(unkown error)";
609 const char * fn = NULL;
613 {
const char * fnfmt =
rpmGetPath(
"%{?_hrmib_path}", NULL);
616 fnfmt =
_free(fnfmt);
625 char * dn = dirname(_fn);
631 oneshot = (
rpmioMkpath(dn, _mode, _uid, _gid) ? -1 : 1);
646 struct utimbuf stamp;
647 stamp.actime = he->
p.
ui32p[0];
648 stamp.modtime = he->
p.
ui32p[0];
649 if (!
Utime(fn, &stamp))
666 static const char l10n_sql_init[] =
"\
667 CREATE TABLE IF NOT EXISTS l10n (\n\
668 k TEXT UNIQUE PRIMARY KEY NOT NULL,\n\
672 static const char l10n_sql_qfmt[] =
673 #include "wdj_l10n_sqlite"
683 static int rpmdbExportL10N_SQL(
rpmdb db,
Header h,
int adding)
695 fn =
rpmGetPath(
"%{?__l10ndir:%{__l10ndir}/sqldb}", NULL);
704 char * dn = dirname(_fn);
705 static mode_t _mode = 0755;
706 static uid_t _uid = 0;
707 static gid_t _gid = 0;
710 oneshot = (
rpmioMkpath(dn, _mode, _uid, _gid) ? -1 : 1);
713 t =
rpmExpand(
"%{sql -echo ", fn,
":\n", l10n_sql_init,
"}", NULL);
725 const char * SQL =
queryHeader(h, (
char *)l10n_sql_qfmt);
727 "BEGIN TRANSACTION;\n",
729 "COMMIT TRANSACTION;\n",
765 xx = rpmdbExportL10N_SQL(db, h, adding);
781 if (_rpmdbPool == NULL) {
782 _rpmdbPool =
rpmioNewPool(
"db",
sizeof(*db), -1, _rpmdb_debug,
787 memset(((
char *)db)+
sizeof(db->_item), 0,
sizeof(*db)-
sizeof(db->_item));
795 if (db == NULL)
return -2;
797 if (db->db_tags != NULL && db->_dbi != NULL) {
799 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
800 if ((
int)db->db_tags[dbix].tag < 0)
802 if (db->_dbi[dbix] != NULL)
804 switch (db->db_tags[dbix].tag) {
819 (void)
dbiOpen(db, db->db_tags[dbix].tag, db->db_flags);
830 if (db == NULL || db->_dbi == NULL)
833 if (db->db_tags != NULL)
834 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
835 if (db->db_tags[dbix].tag != tagn)
837 db->db_tags[dbix].tag = (
rpmTag) tag;
848 if (db == NULL || db->_dbi == NULL)
851 if (db->db_tags != NULL)
852 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
853 if (db->db_tags[dbix].tag != (
rpmTag)tag)
855 if (db->_dbi[dbix] != NULL) {
858 xx = dbiClose(db->_dbi[dbix], 0);
859 if (xx && rc == 0) rc = xx;
860 db->_dbi[dbix] = NULL;
874 static const char msg[] =
"rpmdbClose";
885 fprintf(stderr,
"--> db %p -- %ld %s at %s:%u\n", db,
yarnPeekLock(db->_item.use), msg, __FILE__, __LINE__);
891 for (dbix = db->db_ndbi; dbix;) {
894 if (db->_dbi[dbix] == NULL)
897 xx = dbiClose(db->_dbi[dbix], 0);
898 if (xx && rc == 0) rc = xx;
899 db->_dbi[dbix] = NULL;
902 db->db_errpfx =
_free(db->db_errpfx);
903 db->db_root =
_free(db->db_root);
904 db->db_home =
_free(db->db_home);
906 db->_dbi =
_free(db->_dbi);
911 while ((next = *prev) != NULL && next != db)
912 prev = &next->db_next;
914 *prev = next->db_next;
915 next->db_next = NULL;
919 if (rpmdbRock == NULL && rpmmiRock == NULL) {
951 const char * fn = NULL;
976 if (fn && *fn && *fn !=
'/') {
980 if ((t =
Realpath(
".", dn)) != NULL) {
982 if (t > dn && t[-1] !=
'/')
984 t =
stpncpy(t, fn, (
sizeof(dn) - (t - dn)));
998 #define _DB_HOME "%{?_dbpath}"
1001 #define _DB_PERMS 0644
1004 #define _DB_ERRPFX "rpmdb"
1018 fprintf(stderr,
"==> rpmdbNew(%s, %s, 0x%x, 0%o, 0x%x) db %p\n", root, home, mode, perms, flags, db);
1021 if (!(perms & 0600)) perms = 0644;
1026 if (!(db->db_home && db->db_home[0] && db->db_home[0] !=
'%')) {
1028 db->db_root =
_free(db->db_root);
1029 db->db_home =
_free(db->db_home);
1034 db->db_flags = (flags >= 0) ? flags :
_DB_FLAGS;
1035 db->db_mode = (mode >= 0) ? mode :
_DB_MODE;
1036 db->db_perms = (perms > 0) ? perms :
_DB_PERMS;
1037 #if defined(WITH_DB)
1045 db->db_remove_env = 0;
1046 db->db_chrootDone = 0;
1048 db->db_errcall = NULL;
1049 db->db_errfile = NULL;
1050 db->db_malloc = NULL;
1051 db->db_realloc = NULL;
1059 db->db_dbenv = NULL;
1067 memset(&db->db_getops, 0,
sizeof(db->db_getops));
1068 memset(&db->db_putops, 0,
sizeof(db->db_putops));
1069 memset(&db->db_delops, 0,
sizeof(db->db_delops));
1078 const char * dbpath,
1079 int _dbapi,
rpmdb *dbp,
1091 if (_dbapi < -1 || _dbapi > 4)
1098 if (mode & O_WRONLY)
1101 db =
rpmdbNew(prefix, dbpath, mode, perms, flags);
1105 if (rpmdbRock == NULL && rpmmiRock == NULL) {
1119 db->db_api = _dbapi;
1124 if (db->db_tags != NULL)
1125 for (dbix = 0; rc == 0 && dbix < db->db_ndbi; dbix++) {
1127 rpmTag tag = dbiTag->tag;
1150 if (dbi == NULL) rc |= 1;
1153 if (db->db_api == 3)
1158 if (dbi == NULL) rc |= 1;
1167 if (rc || dbp == NULL)
1182 #if defined(WITH_DB)
1184 #elif defined(WITH_SQLITE)
1194 unsigned int count = 0;
1195 DBC * dbcursor = NULL;
1202 if (db == NULL || keyp == NULL)
1210 keylen = strlen((
char *)keyp);
1213 k.
data = (
void *) keyp;
1217 xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, 0);
1218 rc = dbiGet(dbi, dbcursor, &k, &v,
DB_SET);
1221 rc = dbiCount(dbi, dbcursor, &count, 0);
1232 rc,
tagName(dbi->dbi_rpmtag));
1236 xx = dbiCclose(dbi, dbcursor, 0);
1253 while ((c = (
int)*s)) {
1270 if (*s ==
'\0')
goto exit;
1286 static const char _REchars[] =
"^.*(|)[]+?{}$";
1293 for (se = s; *se !=
'\0'; se++, nt++)
1294 if (strchr(_REchars, *se)) nt++;
1295 nt += strlen(_pre) + strlen(_post);
1298 te = t = (
char *)
xmalloc(nt + 1);
1300 for (se = s; *se !=
'\0'; *te++ = *se++)
1301 if (strchr(_REchars, *se)) *te++ =
'\\';
1323 const char *** argvp)
1327 DBC * dbcursor = NULL;
1336 const char *
b = NULL;
1346 if (_rpmmi_debug || dbi->dbi_debug)
1347 fprintf(stderr,
"--> %s(%p, %s(%u), %d, \"%s\", %p, %p)\n", __FUNCTION__, db,
tagName(tag), (
unsigned)tag, mode, pat, matches, argvp);
1363 if (*pat ==
'^') pat++;
1374 b = be = (
char *)
xmalloc(nb + 1);
1376 if ((*be = *pat++) !=
'\\')
1387 k.
data = (
void *) b;
1392 k.
data = (
void *) pat;
1401 xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, 0);
1404 while ((rc = dbiPget(dbi, dbcursor, &k, &p, &v, _flags)) == 0) {
1410 if (b != NULL && nb > 0) {
1413 if (k.
size < nb || memcmp(b, k.
data, nb))
1418 memset (&k, 0,
sizeof(k));
1419 xx = dbiPget(dbi, dbcursor, &k, &p, &v,
DB_CURRENT);
1425 s = (
const char * ) k.
data;
1433 memcpy(&hdrNum, p.
data,
sizeof(hdrNum));
1441 (void)
dbiAppendSet(set, &hdrNum, 1,
sizeof(hdrNum), 0);
1446 char * a = (
char *) memcpy(
xmalloc(ns+1), s,
ns);
1453 xx = dbiCclose(dbi, dbcursor, 0);
1463 rc,
tagName(dbi->dbi_rpmtag));
1481 if (_rpmmi_debug || (dbi && dbi->dbi_debug))
1482 fprintf(stderr,
"<-- %s(%p, %s(%u), %d, %p, %p, %p) rc %d %p[%u]\n", __FUNCTION__, db,
tagName(tag), (
unsigned)tag, mode, pat, matches, argvp, ret, (matches && *matches ? (*matches)->recs : NULL), (matches && *matches ? (*matches)->count : 0));
1487 const char *** argvp)
1489 int rc =
dbiMireKeys(db, tag, mode, pat, NULL, argvp);
1491 fprintf(stderr,
"<-- %s(%p, %s(%u), %d, \"%s\", %p) rc %d\n", __FUNCTION__, db,
tagName(tag), (
unsigned)tag, mode, pat, argvp, rc);
1503 if (mi == NULL || mi->
mi_db == NULL || bn == NULL || *bn ==
'\0')
1511 if (rc == 0 && set != NULL) {
1514 for (i = 0; i < set->count; i++)
1515 set->recs[i].tagNum = tagNum;
1524 fprintf(stderr,
"<-- %s(%p, \"%s\")\trc %d set %p %p[%u]\n", __FUNCTION__, mi, bn, rc, set, (set ? set->recs : NULL), (
unsigned)(set ? set->count : 0));
1540 const char * s = pat;
1541 size_t ns = (s ? strlen(s) : 0);
1542 DBC * dbcursor = NULL;
1547 if (ns == 0)
goto exit;
1549 xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, 0);
1552 {
rpmTag tag = dbi->dbi_rpmtag;
1554 static const char _post_NVRA[] =
"(-[^-]+-[^-]+\\.[^.]+|-[^-]+\\.[^.]+|\\.[^.]+|)$";
1564 _pat = (s[0] ==
'^' || s[ns-1] ==
'$')
1569 if (s[0] ==
'^' || s[ns-1] ==
'$')
1582 ret =
dbiMireKeys(dbi->dbi_rpmdb, tag, mode, _pat, matches, NULL);
1592 ret,
tagName(dbi->dbi_rpmtag));
1596 xx = dbiCclose(dbi, dbcursor, 0);
1601 if (rc !=
RPMRC_OK && matches && *matches)
1612 sw = &dbi->dbi_rpmdb->db_getops;
1615 sw = &dbi->dbi_rpmdb->db_putops;
1619 sw = &dbi->dbi_rpmdb->db_delops;
1639 if (mi == NULL || mi->
mi_h == NULL)
1654 if (v.
data != NULL) {
1655 sigset_t signalMask;
1660 _(
"error(%d) storing record h#%u into %s\n"),
1664 xx = dbiSync(dbi, 0);
1689 while ((next = *prev) != NULL && next != mi)
1699 assert(dbi != NULL);
1704 xx = dbiCclose(dbi, mi->
mi_dbc, 0);
1737 if (_rpmmiPool == NULL) {
1738 _rpmmiPool =
rpmioNewPool(
"mi",
sizeof(*mi), -1, _rpmmi_debug,
1743 memset(((
char *)mi)+
sizeof(mi->
_item), 0,
sizeof(*mi)-
sizeof(mi->
_item));
1752 fprintf(stderr,
"<-- %s(%p) rc %u\n", __FUNCTION__, mi, (
unsigned)rc);
1757 uint32_t rc = (mi ? mi->
mi_bntag : 0);
1759 fprintf(stderr,
"<-- %s(%p) rc %u\n", __FUNCTION__, mi, (
unsigned)rc);
1775 assert(dbi != NULL);
1791 fprintf(stderr,
"<-- %s(%p) rc %u\n", __FUNCTION__, mi, (
unsigned)rc);
1807 return (mireA->tag - mireB->tag);
1840 nb = strlen(pattern) +
sizeof(
"^$");
1846 for (s = pattern; *s !=
'\0'; s++) {
1851 if (!brackets) nb++;
1860 if (c != (
int)
'[') brackets = 0;
1866 pat = t = (
char *)
xmalloc(nb);
1868 if (pattern[0] !=
'^') *t++ =
'^';
1873 for (s = pattern; *s !=
'\0'; s++, t++) {
1877 if (!brackets) *t++ =
'\\';
1880 if (!brackets) *t++ =
'.';
1889 if (c != (
int)
'[') brackets = 0;
1896 if (s > pattern && s[-1] !=
'$') *t++ =
'$';
1916 const char * allpat = NULL;
1921 const char *t =
rpmExpand(
"%{?_query_selector_match}", NULL);
1923 if (*t ==
'\0' || !strcmp(t,
"default"))
1925 else if (!strcmp(t,
"strcmp"))
1927 else if (!strcmp(t,
"regex"))
1929 else if (!strcmp(t,
"glob"))
1936 if (mi == NULL || pattern == NULL)
1940 if (*pattern ==
'!') {
1946 assert(nmire != NULL);
1947 allpat =
mireDup((
rpmTag)nmire->tag, &nmire->mode, pattern);
1950 nmire->mode = defmode;
1956 if (mi->
mi_re == NULL) {
1964 fprintf(stderr,
" mire %p[%u] realloc\n", mi->
mi_re, mi->
mi_nre+1);
1966 memset(mire, 0,
sizeof(*mire));
1969 mire->_item.use = use;
1970 mire->_item.pool = pool;
1975 mire->mode = nmire->mode;
1976 mire->pattern = nmire->pattern; nmire->pattern = NULL;
1977 mire->preg = nmire->preg; nmire->preg = NULL;
1978 mire->cflags = nmire->cflags;
1979 mire->eflags = nmire->eflags;
1980 mire->fnflags = nmire->fnflags;
1981 mire->tag = nmire->tag;
1982 mire->notmatch = notmatch;
1984 mire->offsets = NULL;
1992 fprintf(stderr,
"<-- %s(%p, %u(%s), %u, \"%s\") rc %d mi_re %p[%u]\n", __FUNCTION__, mi, (
unsigned)tag,
tagName(tag), (
unsigned)mode, pattern, rc, (mi ? mi->
mi_re: NULL), (
unsigned)(mi ? mi->
mi_nre : 0));
1993 allpat =
_free(allpat);
2006 if (c >=
'0' && c <=
'9')
2007 return (
unsigned char)(c -
'0');
2008 if (c >=
'A' && c <=
'F')
2009 return (
unsigned char)((int)(c -
'A') + 10);
2010 if (c >=
'a' && c <=
'f')
2011 return (
unsigned char)((int)(c -
'a') + 10);
2025 static char hex[] =
"0123456789abcdef";
2026 const char * s = (
const char *) data;
2028 val = t = (
char *)
xmalloc(size * 2 + 1);
2029 while (size-- > 0) {
2031 i = (unsigned) *s++;
2032 *t++ = hex[ (i >> 4) & 0xf ];
2033 *t++ = hex[ (
i ) & 0xf ];
2058 if (mi->
mi_h == NULL)
2065 if ((mire = mi->
mi_re) == NULL)
2068 for (i = 0; i < mi->
mi_nre; i++, mire++) {
2088 for (j = 0; j < (unsigned) he->
c; j++) {
2089 sprintf(numbuf,
"%u", (
unsigned) he->
p.
ui8p[j]);
2091 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2096 for (j = 0; j < (unsigned) he->
c; j++) {
2097 sprintf(numbuf,
"%u", (
unsigned) he->
p.
ui16p[j]);
2099 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2104 for (j = 0; j < (unsigned) he->
c; j++) {
2105 sprintf(numbuf,
"%u", (
unsigned) he->
p.
ui32p[j]);
2107 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2113 for (j = 0; j < (unsigned) he->
c; j++) {
2114 sprintf(numbuf,
"%llu", (
unsigned long long)he->
p.
ui64p[j]);
2116 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2123 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2127 for (j = 0; j < (unsigned) he->
c; j++) {
2129 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch)) {
2137 assert(he->
p.
ptr != NULL);
2140 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2145 #if !defined(SUPPORT_I18NSTRING_TYPE)
2151 if ((i+1) < mi->
mi_nre && mire[0].tag == mire[1].tag) {
2166 return (ntags > 0 && ntags == nmatches ? 0 : 1);
2204 switch (dbi->dbi_rpmdb->db_api) {
2205 default: map = 0;
break;
2210 static const int _prot = PROT_READ | PROT_WRITE;
2211 static const int _flags = MAP_PRIVATE| MAP_ANONYMOUS;
2212 static const int _fdno = -1;
2213 static const off_t _off = 0;
2215 memset(vp, 0,
sizeof(*vp));
2217 rc = dbiGet(dbi, dbcursor, kp, vp, flags);
2219 size_t uhlen = vp->
size;
2220 void * uh = mmap(NULL, uhlen, _prot, _flags, _fdno, _off);
2221 if (uh == NULL || uh == (
void *)-1)
2223 "==> mmap(%p[%u], 0x%x, 0x%x, %d, 0x%x) error(%d): %s\n",
2224 NULL, (
unsigned)uhlen, _prot, _flags, _fdno, (
unsigned)_off,
2227 vp->
ulen = (u_int32_t)uhlen;
2229 if (dbi->dbi_primary && pk)
2230 rc = dbiPget(dbi, dbcursor, kp, pk, vp, flags);
2232 rc = dbiGet(dbi, dbcursor, kp, vp, flags);
2234 if (mprotect(uh, uhlen, PROT_READ) != 0)
2235 fprintf(stderr,
"==> mprotect(%p[%u],0x%x) error(%d): %s\n",
2236 uh, (
unsigned)uhlen, PROT_READ,
2239 if (munmap(uh, uhlen) != 0)
2240 fprintf(stderr,
"==> munmap(%p[%u]) error(%d): %s\n",
2241 uh, (
unsigned)uhlen,
errno, strerror(
errno));
2245 rc = dbiGet(dbi, dbcursor, kp, vp, flags);
2246 if (_rpmmi_debug || dbi->dbi_debug)
2247 fprintf(stderr,
"<-- %s(%p(%s),%p,%p,%p,0x%x) rc %d\n", __FUNCTION__, dbi,
tagName(dbi->dbi_rpmtag), dbcursor, kp, vp, flags, rc);
2261 unsigned int _flags;
2276 switch (dbi->dbi_rpmdb->db_api) {
2277 default: map = 0;
break;
2281 if (_rpmmi_debug || dbi->dbi_debug)
2282 fprintf(stderr,
"--> %s(%p) dbi %p(%s)\n", __FUNCTION__, mi, dbi,
tagName(tag));
2290 if (mi->
mi_dbc == NULL) {
2314 if (mi->
mi_bf != NULL
2323 else if (dbi->dbi_primary) {
2356 }
while (rc == 0 && mi->
mi_offset == 0);
2387 if (mi->
mi_h == NULL) {
2389 _(
"rpmdb: header #%u cannot be loaded -- skipping.\n"),
2407 sprintf(origin,
"rpmdb (h#%u)", (
unsigned)hdrNum);
2429 if (mi->
mi_set->count > 1) {
2430 #if defined(__GLIBC__)
2440 {
struct _dbiIndexItem * rec;
2442 for (i = 0, rec = mi->
mi_set->recs; i < mi->mi_set->count; i++, rec++) {
2443 fprintf(stderr,
"\t%p[%u] = %p: %u %u %u\n", mi->
mi_set->recs,
2444 i, rec, rec->hdrNum, rec->tagNum, rec->fpNum);
2455 int rc = (mi == NULL || hdrNums == NULL || nHdrNums <= 0);
2459 if (mi->
mi_bf == NULL) {
2460 static size_t nRemoves = 2 * 8192;
2461 static double e = 1.0e-4;
2467 for (i = 0; i < nHdrNums; i++) {
2468 uint32_t mi_offset =
_hton_ui(hdrNums[i]);
2469 int xx =
rpmbfAdd(mi->
mi_bf, &mi_offset,
sizeof(mi_offset));
2475 fprintf(stderr,
"<-- %s(%p, %p[%u], %d) rc %d h# %u\n", __FUNCTION__, mi, hdrNums, (
unsigned)nHdrNums, sorted, rc, (
unsigned) (hdrNums ? hdrNums[0] : 0));
2481 int rc = (mi == NULL || hdrNums == NULL || nHdrNums <= 0);
2490 fprintf(stderr,
"<-- %s(%p, %p[%u]) rc %d h# %u\n", __FUNCTION__, mi, hdrNums, (
unsigned)nHdrNums, rc, (
unsigned) (hdrNums ? hdrNums[0] : 0));
2501 int usePatterns = 0;
2519 #ifdef RPM_VENDOR_MANDRIVA_XXX
2545 assert(dbi != NULL);
2555 if (_rpmmi_debug || (dbi && dbi->dbi_debug))
2556 fprintf(stderr,
"--> %s(%p, %s, %p[%u]=\"%s\") dbi %p mi %p\n", __FUNCTION__, db,
tagName(tag), keyp, (unsigned)keylen, (keyp != NULL && (keylen == 0 || ((
const char *)keyp)[keylen] ==
'\0') ? (
const char *)keyp :
"???"), dbi, mi);
2564 assert(keylen == 0);
2570 assert(keylen ==
sizeof(hdrNum));
2571 memcpy(&hdrNum, keyp,
sizeof(hdrNum));
2576 set->recs[0].hdrNum = hdrNum;
2578 else if (keyp == NULL) {
2580 assert(keylen == 0);
2582 else if (usePatterns) {
2587 #if defined(RPM_VENDOR_MANDRIVA)
2598 if(!rc && ((
const char*)keyp)[0] !=
'^' && tag ==
RPMTAG_NVRA &&
2599 (set == NULL || set->count < 1)) {
2601 char *tmp = (
char*)keyp;
2605 for (i = 0; (tmp = strchr(tmp,
'-')); i++)
2611 const char *origkeyp = keyp;
2612 size_t klen = strlen(keyp)+1;
2617 stpcpy((
char*)keyp, origkeyp);
2618 tmp = strrchr(keyp,
'-');
2623 xx = dbiCopen(pdbi, dbiTxnid(pdbi), &pdbc, 0);
2625 for(i = 0; set && i < set->count; i++) {
2629 uint32_t offset =
_hton_ui(set->recs[i].hdrNum);
2634 memset(&k, 0,
sizeof(k));
2635 memset(&v, 0,
sizeof(v));
2637 k.
size =
sizeof(offset);
2639 xx = dbiGet(dbi, pdbc, &k, &v,
DB_SET);
2641 tmp = (
char*)((
size_t)keyp + strlen(keyp) + 1);
2643 for (j = 0; j < (int)(
sizeof(checkTags)/
sizeof(checkTags[0])) &&
2644 *tmp !=
'\0'; j++) {
2645 he->
tag = checkTags[
j];
2647 size_t len = strlen(he->
p.
str);
2652 if(!strncmp(he->
p.
str, tmp, len))
2657 if(j && *tmp ==
'\0') {
2658 set->recs[
size].hdrNum = set->recs[
i].hdrNum;
2659 set->recs[
size].tagNum = set->recs[
i].tagNum;
2665 if(set && set->count != size) {
2667 set->recs =
xrealloc(set->recs, size *
sizeof(*set->recs));
2670 xx = dbiCclose(pdbi, pdbc, 0);
2675 if ((rc && rc !=
RPMRC_NOTFOUND) || set == NULL || set->count < 1) {
2683 else if (dbi && dbi->dbi_primary != NULL) {
2699 mi->
mi_count = (set ? set->count : 0);
2702 ?
xstrdup(dbi->dbi_primary) : NULL);
2705 switch (
tagType(tag) & 0xffff) {
2707 assert(keylen ==
sizeof(he->
p.
ui8p[0]));
2711 memcpy(&he->
p.
ui8p[3], keyp, keylen);
2714 assert(keylen ==
sizeof(he->
p.
ui16p[0]));
2718 memcpy(&he->
p.
ui16p[1], keyp, keylen);
2721 #if !defined(__LCLINT__)
2723 assert(keylen ==
sizeof(he->
p.
ui32p[0]));
2731 assert(keylen ==
sizeof(he->
p.
ui64p[0]));
2736 { uint32_t _tmp = he->
p.
ui32p[0];
2743 #if !defined(SUPPORT_I18NSTRING_TYPE)
2753 ? memcpy(
xmalloc(keylen), (
char *)keyp, keylen)
2781 sigset_t signalMask;
2801 "rpmdbRemove", (
unsigned)hdrNum);
2812 dbix = db->db_ndbi - 1;
2813 if (db->db_tags != NULL)
2823 (void) memset(&k, 0,
sizeof(k));
2824 (void) memset(&v, 0,
sizeof(v));
2825 (void) memset(he, 0,
sizeof(*he));
2826 he->
tag = dbiTag->tag;
2835 if (dbi == NULL)
goto exit;
2846 if (db->db_export != NULL)
2847 xx = db->db_export(db, h, 0);
2857 if (dbi == NULL)
goto exit;
2860 rc = dbiGet(dbi, dbcursor, &k, &v,
DB_SET);
2862 rc = dbiDel(dbi, dbcursor, &k, &v, 0);
2869 if (!dbi->dbi_no_dbsync)
2870 xx = dbiSync(dbi, 0);
2874 }
while (dbix-- > 0);
2890 sigset_t signalMask;
2901 fprintf(stderr,
"--> %s(%p, %u, %p, %p) h# %u\n", __FUNCTION__, db, (
unsigned)iid, h, ts, (
unsigned)hdrNum);
2906 if (iid != 0 && iid != -1) {
2930 if (dbi == NULL)
goto exit;
2932 if ((xx = dbiSeqno(dbi, &seqno, 0)) == 0) {
2946 if (dbi == NULL)
goto exit;
2948 dbix = db->db_ndbi - 1;
2949 if (db->db_tags != NULL)
2959 (void) memset(&k, 0,
sizeof(k));
2960 (void) memset(&v, 0,
sizeof(v));
2961 (void) memset(he, 0,
sizeof(*he));
2962 he->
tag = dbiTag->tag;
2971 if (dbi == NULL)
goto exit;
2982 if (db->db_export != NULL)
2983 xx = db->db_export(db, h, 1);
2986 k.
data = (
void *) &ui;
2991 assert(v.
data != NULL);
2999 if (dbi == NULL)
goto exit;
3002 xx = dbiPut(dbi, dbcursor, &k, &v,
DB_KEYLAST);
3009 if (!dbi->dbi_no_dbsync)
3010 xx = dbiSync(dbi, 0);
3017 }
while (dbix-- > 0);
static union _dbswap _endian
int rpmmiPrune(rpmmi mi, uint32_t *hdrNums, int nHdrNums, int sorted)
Remove items from set of package instances to iterate.
int rpmdbOpenAll(rpmdb db)
Open all database indices.
void yarnTwist(yarnLock bolt, yarnTwistOP op, long val)
int rpmmiGrowBasename(rpmmi mi, const char *bn)
Append packages containing common basename to iterator.
miRE mireNew(rpmMireMode mode, int tag)
Create pattern container.
mongo_error_t const char * errstr
struct _setSwap_s * setSwap
static uint16_t _hton_us(uint16_t us)
static const char * queryHeader(Header h, const char *qfmt)
Return header query string.
const char const char size_t len
const char bson_timestamp_t * ts
static rpmRC dbiFindMatches(dbiIndex dbi, const char *pat, dbiIndexSet *matches)
Attempt partial matches on name[-version[-release]] strings.
void * mireFreeAll(miRE mire, int nmire)
Destroy compiled patterns.
enum urltype_e urltype
Supported URL types.
OpenPGP constants and structures from RFC-2440.
void yarnPossess(yarnLock bolt)
static struct _dbiVec * mydbvecs[]
rpmbf rpmbfNew(size_t m, size_t k, unsigned flags)
Create a Bloom filter.
long yarnPeekLock(yarnLock bolt)
uint32_t rpmmiInstance(rpmmi mi)
Return header instance for current position of rpmdb iterator.
char * xstrdup(const char *str)
static rpmdb rpmdbGetPool(rpmioPool pool)
static int _rpmmi_usermem
FD_t Fopen(const char *path, const char *_fmode)
fopen(3) clone.
static uint32_t _ntoh_ui(uint32_t ui)
char * rpmGetPath(const char *path,...)
Return (malloc'ed) expanded, canonicalized, file path.
static unsigned char nibble(char c)
Convert hex to binary nibble.
rpmioItem rpmioLinkPoolItem(rpmioItem item, const char *msg, const char *fn, unsigned ln)
Increment a pool item refcount.
int rpmioMkpath(const char *path, mode_t mode, uid_t uid, gid_t gid)
Insure that directories in path exist, creating as needed.
int mireRegcomp(miRE mire, const char *pattern)
Compile pattern match.
int argvAppend(ARGV_t *argvp, ARGV_t av)
Append one argv array to another.
rpmdb rpmdbLink(rpmdb db, const char *msg)
Reference a database instance.
static uint64_t _ntoh_ul(uint64_t ul)
Hash table implemenation.
void * rpmioFreePoolItem(rpmioItem item, const char *msg, const char *fn, unsigned ln)
Free a pool item.
static rpmmi rpmmiGetPool(rpmioPool pool)
int rpmdbCheckSignals(void)
Check for and exit on termination signals.
static void rpmlog(int code, const char *fmt,...)
static size_t dbiTagToDbix(rpmdb db, rpmTag tag)
Return dbi index used for rpm tag.
struct _dbiIndexSet * dbiIndexSet
A single element (i.e.
uint32_t dbiIndexRecordFileNumber(dbiIndexSet set, unsigned int recno)
static int hdrNumCmp(const void *one, const void *two)
static int dbiAppendSet(dbiIndexSet set, const void *recs, int nrecs, size_t recsize, int sortset)
Append element(s) to set of index database items.
int Utime(const char *path, const struct utimbuf *buf)
char * headerSprintf(Header h, const char *fmt, headerTagTableEntry tags, headerSprintfExtension exts, errmsg_t *errmsg)
Return formatted output string from header tags.
rpmTag tagValue(const char *tagstr)
Return tag value from name.
dbiIndexSet dbiFreeIndexSet(dbiIndexSet set)
rpmmi rpmmiInit(rpmdb db, rpmTag tag, const void *keyp, size_t keylen)
Return database iterator.
int rpmdbCheckTerminate(int terminate)
Check rpmdb signal handler for trapped signal and/or requested exit.
int rpmmiGrow(rpmmi mi, const uint32_t *hdrNums, int nHdrNums)
Append items to set of package instances to iterate.
void rpmbfParams(size_t n, double e, size_t *mp, size_t *kp)
Return optimal {m, k} for given n and e.
Yet Another syslog(3) API clone.
miRE mireFree(miRE mire)
Free pattern container.
void * xcalloc(size_t nmemb, size_t size)
const char const bson_bool_t v
rpmbf rpmbfFree(rpmbf bf)
Destroy a Bloom filter.
int rpmmiSort(rpmmi mi)
Sort iterator instances.
static uint16_t _ntoh_us(uint16_t us)
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
static int dbiMireKeys(rpmdb db, rpmTag tag, rpmMireMode mode, const char *pat, dbiIndexSet *matches, const char ***argvp)
Retrieve prinary/secondary keys for a pattern match.
unsigned int tagType(rpmTag tag)
Return tag data type from value.
int rpmdbRemove(rpmdb db, int rid, uint32_t hdrNum, rpmts ts)
Remove package header from rpm database and indices.
char * stpncpy(char *dest, const char *src, size_t n)
const char const bson * data
static int xisspace(int c)
static const char * rpmdbURIPath(const char *uri)
Return macro expanded absolute path to rpmdb.
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
static int rpmdbExportInfo(rpmdb db, Header h, int adding)
Write added/removed header info.
const char * tagName(rpmTag tag)
Return tag name from value.
int rpmdbOpen(const char *prefix, rpmdb *dbp, int mode, mode_t perms)
Open rpm database.
static int blockSignals(rpmdb db, sigset_t *oldMask)
Block all signals, returning previous signal mask.
int Glob_pattern_p(const char *pattern, int quote)
glob_pattern_p(3) clone.
struct tagStore_s * tagStore_t
int rpmdbCloseDBI(rpmdb db, int tag)
Close a single database index.
The FD_t File Handle data structure.
void * dbiStatsAccumulator(dbiIndex dbi, int opx)
struct rpmdb_s * rpmdb
Database of headers and tag value indices.
static int rpmdbOpenDatabase(const char *prefix, const char *dbpath, int _dbapi, rpmdb *dbp, int mode, mode_t perms, int flags)
int argvAdd(ARGV_t *argvp, ARGstr_t val)
Add a string to an argv array.
rpmioItem rpmioPutPool(rpmioItem item)
Put unused item into pool (or free).
int rpmdbMireApply(rpmdb db, rpmTag tag, rpmMireMode mode, const char *pat, const char ***argvp)
Return array of keys matching a pattern.
int mireRegexec(miRE mire, const char *val, size_t vallen)
Execute pattern match.
struct rpmmi_s * rpmmi
Database iterator.
Header headerFree(Header h)
Dereference a header instance.
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
static void rpmmiFini(void *_mi)
Identify a file name path by a unique "finger print".
enum rpmMireMode_e rpmMireMode
Tag value pattern match mode.
rpmmi rpmmiFree(rpmmi mi)
Destroy rpm database iterator.
int Fclose(FD_t fd)
fclose(3) clone.
const char const bson int mongo_write_concern int flags
Header headerLink(Header h)
Reference a header instance.
rpmdb rpmdbNew(const char *root, const char *home, int mode, mode_t perms, int flags)
enum rpmRC_e rpmRC
RPM return codes.
int rpmmiAddPattern(rpmmi mi, rpmTag tag, rpmMireMode mode, const char *pattern)
Add pattern to iterator selector.
int rpmmiSetRewrite(rpmmi mi, int rewrite)
Prepare iterator for lazy writes.
static int miFreeHeader(rpmmi mi, dbiIndex dbi)
Rewrite a header into packages (if necessary) and free the header.
urltype urlPath(const char *url, const char **pathp)
Return path component of URL.
uint32_t dbiIndexRecordOffset(dbiIndexSet set, unsigned int recno)
static const char * prefix[]
Tables for prefixing and suffixing patterns, according to the -w, -x, and -F options.
static void set(char *t, NODE *ip)
static uint32_t _hton_ui(uint32_t ui)
dbiIndex dbiOpen(rpmdb db, rpmTag tag, unsigned int flags)
Methods to handle package elements.
rpmioPool rpmioNewPool(const char *name, size_t size, int limit, int flags, char *(*dbg)(void *item), void(*init)(void *item), void(*fini)(void *item))
Create a memory pool.
int rpmdbCountPackages(rpmdb db, const char *N)
Return number of instances of package in Name index.
uint32_t rpmmiBNTag(rpmmi mi)
Return basename tag for current position of rpmdb iterator.
static char * mireDup(rpmTag tag, rpmMireMode *modep, const char *pattern)
Copy pattern, escaping for appropriate mode.
char * stpcpy(char *dest, const char *src)
struct rpmts_s * rpmts
The RPM Transaction Set.
const char const char size_t size
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
int rpm_mergesort(void *base, size_t nmemb, size_t size, int(*cmp)(const void *, const void *))
Mergesort, same arguments as qsort(2).
int rpmmiSetModified(rpmmi mi, int modified)
Modify iterator to mark header for lazy write on release.
Header rpmmiNext(rpmmi mi)
Return next package header from iteration.
tagStore_t tagStoreFree(tagStore_t dbiTags, size_t dbiNTags)
Destroy tagStore array.
int rpmbfAdd(rpmbf bf, const void *_s, size_t ns)
Add item to a Bloom filter.
static int checkfd(const char *devnull, int fdno, int flags)
static int rpmdbExportHR_MIB(rpmdb db, Header h, int adding)
Write added/removed header info into %{_hrmib_path}.
int argvSplit(ARGV_t *argvp, const char *str, const char *seps)
Split a string into an argv array.
static void dbiTagsInit(tagStore_t *dbiTagsP, size_t *dbiNTagsP)
Initialize database (index, tag) tuple from configuration.
static int mireCmp(const void *a, const void *b)
Compare iterator selectors by rpm tag (qsort/bsearch).
miRE mireGetPool(rpmioPool pool)
Allocate a miRE container from the pool.
int rpmdbCount(rpmdb db, rpmTag tag, const void *keyp, size_t keylen)
Return number of instances of key in a tag index.
static uint64_t _hton_ul(uint64_t ul)
rpmuint32_t hashFunctionString(rpmuint32_t h, const void *data, size_t size)
Return hash value of a string.
int rpmdbAdd(rpmdb db, int iid, Header h, rpmts ts)
Add package header to rpm database and indices.
const char const char * pattern
static int unblockSignals(rpmdb db, sigset_t *oldMask)
Restore signal mask.
miRE mireLink(miRE mire)
Reference a pattern container instance.
static int mireSkip(const rpmmi mi)
Return iterator selector match.
struct _dbiIndexItem * dbiIndexItem
Access RPM indices using Berkeley DB interface(s).
int rpmdbClose(rpmdb db)
Close all database indices and free rpmdb.
int rpmdbBlockDBI(rpmdb db, int tag)
Block access to a single database index.
unsigned int rpmmiCount(rpmmi mi)
Return number of elements in rpm database iterator.
static char * bin2hex(const void *data, size_t size)
Convert binary blob to printable hex string.
char * Realpath(const char *path, char *resolved_path)
realpath(3) clone.
int rpmExpandNumeric(const char *arg)
Return macro expansion as a numeric value.
#define RPMDBI_PACKAGES
Pseudo-tags used by the rpmdb and rpmgi iterator API's.
int rpmsqEnable(int signum, rpmsqAction_t handler)
Enable or disable a signal handler.
headerSprintfExtension headerCompoundFormats
Supported default header extension/tag output formats.
static const char * _str2PCREpat(const char *_pre, const char *s, const char *_post)
static int rpmmiGet(dbiIndex dbi, DBC *dbcursor, DBT *kp, DBT *pk, DBT *vp, unsigned int flags)
int rpmbfChk(rpmbf bf, const void *_s, size_t ns)
Check for item in a Bloom filter.
struct _dbiIndex * dbiIndex
unsigned int dbiIndexSetCount(dbiIndexSet set)
static const char * stemEnd(const char *s)
int Unlink(const char *path)
unlink(2) clone.