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;
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);
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)
238 #if defined(STDOUT_FILENO)
241 #if defined(STDERR_FILENO)
253 if (dbix >= db->db_ndbi)
257 if ((dbi = db->_dbi[dbix]) !=
NULL)
261 assert(_dbapi == 3 || _dbapi == 4);
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; \
365 static int hdrNumCmp(
const void * one,
const void * two)
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)
419 return set->recs[recno].hdrNum;
424 return set->recs[recno].tagNum;
430 set->recs =
_free(set->recs);
464 #if defined(__LCLINT__)
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)";
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 CREATE TABLE IF NOT EXISTS l10n (\n\
667 k TEXT UNIQUE PRIMARY KEY NOT NULL,\n\
672 #include "wdj_l10n_sqlite"
703 char * dn = dirname(_fn);
704 static mode_t _mode = 0755;
705 static uid_t _uid = 0;
706 static gid_t _gid = 0;
709 oneshot = (
rpmioMkpath(dn, _mode, _uid, _gid) ? -1 : 1);
712 t =
rpmExpand(
"%{sql -echo ", fn,
":\n", l10n_sql_init,
"}",
NULL);
724 const char * SQL =
queryHeader(h, (
char *)l10n_sql_qfmt);
726 "BEGIN TRANSACTION;\n",
728 "COMMIT TRANSACTION;\n",
777 if (_rpmdbPool ==
NULL) {
778 _rpmdbPool =
rpmioNewPool(
"db",
sizeof(*db), -1, _rpmdb_debug,
783 memset(((
char *)db)+
sizeof(db->_item), 0,
sizeof(*db)-
sizeof(db->_item));
791 if (db ==
NULL)
return -2;
793 if (db->db_tags !=
NULL && db->_dbi !=
NULL) {
795 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
796 if ((
int)db->db_tags[dbix].tag < 0)
798 if (db->_dbi[dbix] !=
NULL)
800 switch (db->db_tags[dbix].tag) {
815 (
void)
dbiOpen(db, db->db_tags[dbix].tag, db->db_flags);
829 if (db->db_tags !=
NULL)
830 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
831 if (db->db_tags[dbix].tag != tagn)
833 db->db_tags[dbix].tag = (
rpmTag) tag;
847 if (db->db_tags !=
NULL)
848 for (dbix = 0; dbix < db->db_ndbi; dbix++) {
849 if (db->db_tags[dbix].tag != (
rpmTag)tag)
851 if (db->_dbi[dbix] !=
NULL) {
854 xx = dbiClose(db->_dbi[dbix], 0);
855 if (xx && rc == 0) rc =
xx;
856 db->_dbi[dbix] =
NULL;
870 static const char msg[] =
"rpmdbClose";
878 yarnPossess(db->_item.use);
881 fprintf(stderr,
"--> db %p -- %ld %s at %s:%u\n", db, yarnPeekLock(db->_item.use), msg, __FILE__, __LINE__);
884 if (yarnPeekLock(db->_item.use) <= 1
L) {
887 for (dbix = db->db_ndbi; dbix;) {
890 if (db->_dbi[dbix] ==
NULL)
893 xx = dbiClose(db->_dbi[dbix], 0);
894 if (xx && rc == 0) rc =
xx;
895 db->_dbi[dbix] =
NULL;
898 db->db_errpfx =
_free(db->db_errpfx);
899 db->db_root =
_free(db->db_root);
900 db->db_home =
_free(db->db_home);
902 db->_dbi =
_free(db->_dbi);
907 while ((next = *prev) !=
NULL && next != db)
908 prev = &next->db_next;
910 *prev = next->db_next;
911 next->db_next =
NULL;
915 if (rpmdbRock ==
NULL && rpmmiRock ==
NULL) {
929 yarnTwist(db->_item.use, BY, -1);
972 if (fn && *fn && *fn !=
'/') {
978 if (t > dn && t[-1] !=
'/')
980 t =
stpncpy(t, fn, (
sizeof(dn) - (t - dn)));
994 #define _DB_HOME "%{?_dbpath}"
997 #define _DB_PERMS 0644
1000 #define _DB_ERRPFX "rpmdb"
1014 fprintf(stderr,
"==> rpmdbNew(%s, %s, 0x%x, 0%o, 0x%x) db %p\n", root, home, mode, perms, flags, db);
1017 if (!(perms & 0600)) perms = 0644;
1022 if (!(db->db_home && db->db_home[0] && db->db_home[0] !=
'%')) {
1024 db->db_root =
_free(db->db_root);
1025 db->db_home =
_free(db->db_home);
1030 db->db_flags = (flags >= 0) ? flags :
_DB_FLAGS;
1031 db->db_mode = (mode >= 0) ? mode :
_DB_MODE;
1032 db->db_perms = (perms > 0) ? perms :
_DB_PERMS;
1033 #if defined(WITH_DB)
1041 db->db_remove_env = 0;
1042 db->db_chrootDone = 0;
1044 db->db_errcall =
NULL;
1045 db->db_errfile =
NULL;
1046 db->db_malloc =
NULL;
1047 db->db_realloc =
NULL;
1055 db->db_dbenv =
NULL;
1063 memset(&db->db_getops, 0,
sizeof(db->db_getops));
1064 memset(&db->db_putops, 0,
sizeof(db->db_putops));
1065 memset(&db->db_delops, 0,
sizeof(db->db_delops));
1074 const char * dbpath,
1075 int _dbapi,
rpmdb *dbp,
1087 if (_dbapi < -1 || _dbapi > 4)
1094 if (mode & O_WRONLY)
1097 db =
rpmdbNew(prefix, dbpath, mode, perms, flags);
1101 if (rpmdbRock ==
NULL && rpmmiRock ==
NULL) {
1115 db->db_api = _dbapi;
1120 if (db->db_tags !=
NULL)
1121 for (dbix = 0; rc == 0 && dbix < db->db_ndbi; dbix++) {
1146 if (dbi ==
NULL) rc |= 1;
1149 if (db->db_api == 3)
1154 if (dbi ==
NULL) rc |= 1;
1163 if (rc || dbp ==
NULL)
1178 #if defined(WITH_DB)
1180 #elif defined(WITH_SQLITE)
1190 unsigned int count = 0;
1206 keylen = strlen((
char *)keyp);
1209 k.
data = (
void *) keyp;
1213 xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, 0);
1214 rc = dbiGet(dbi, dbcursor, &k, &v,
DB_SET);
1217 rc = dbiCount(dbi, dbcursor, &count, 0);
1228 rc,
tagName(dbi->dbi_rpmtag));
1232 xx = dbiCclose(dbi, dbcursor, 0);
1249 while ((c = (
int)*s)) {
1266 if (*s ==
'\0')
goto exit;
1282 static const char _REchars[] =
"^.*(|)[]+?{}$";
1289 for (se = s; *se !=
'\0'; se++, nt++)
1290 if (strchr(_REchars, *se)) nt++;
1291 nt += strlen(_pre) + strlen(_post);
1294 te = t = (
char *)
xmalloc(nt + 1);
1296 for (se = s; *se !=
'\0'; *te++ = *se++)
1297 if (strchr(_REchars, *se)) *te++ =
'\\';
1319 const char *** argvp)
1332 const char *
b =
NULL;
1342 if (_rpmmi_debug || dbi->dbi_debug)
1343 fprintf(stderr,
"--> %s(%p, %s(%u), %d, \"%s\", %p, %p)\n", __FUNCTION__, db,
tagName(tag), (
unsigned)tag, mode, pat, matches, argvp);
1359 if (*pat ==
'^') pat++;
1370 b = be = (
char *)
xmalloc(nb + 1);
1372 if ((*be = *pat++) !=
'\\')
1383 k.
data = (
void *) b;
1388 k.
data = (
void *) pat;
1397 xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, 0);
1400 while ((rc = dbiPget(dbi, dbcursor, &k, &p, &v, _flags)) == 0) {
1406 if (b !=
NULL && nb > 0) {
1409 if (k.
size < nb || memcmp(b, k.
data, nb))
1414 memset (&k, 0,
sizeof(k));
1415 xx = dbiPget(dbi, dbcursor, &k, &p, &v,
DB_CURRENT);
1421 s = (
const char * ) k.
data;
1429 memcpy(&hdrNum, p.
data,
sizeof(hdrNum));
1442 char * a = (
char *) memcpy(
xmalloc(ns+1),
s,
ns);
1449 xx = dbiCclose(dbi, dbcursor, 0);
1459 rc,
tagName(dbi->dbi_rpmtag));
1477 if (_rpmmi_debug || (dbi && dbi->dbi_debug))
1478 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));
1483 const char *** argvp)
1487 fprintf(stderr,
"<-- %s(%p, %s(%u), %d, \"%s\", %p) rc %d\n", __FUNCTION__, db,
tagName(tag), (
unsigned)tag, mode, pat, argvp, rc);
1507 if (rc == 0 && set !=
NULL) {
1510 for (i = 0; i < set->count; i++)
1511 set->recs[i].tagNum = tagNum;
1520 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));
1536 const char *
s = pat;
1537 size_t ns = (s ? strlen(s) : 0);
1543 if (ns == 0)
goto exit;
1545 xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, 0);
1550 static const char _post_NVRA[] =
"(-[^-]+-[^-]+\\.[^.]+|-[^-]+\\.[^.]+|\\.[^.]+|)$";
1560 _pat = (s[0] ==
'^' || s[ns-1] ==
'$')
1565 if (s[0] ==
'^' || s[ns-1] ==
'$')
1588 ret,
tagName(dbi->dbi_rpmtag));
1592 xx = dbiCclose(dbi, dbcursor, 0);
1597 if (rc !=
RPMRC_OK && matches && *matches)
1608 sw = &dbi->dbi_rpmdb->db_getops;
1611 sw = &dbi->dbi_rpmdb->db_putops;
1615 sw = &dbi->dbi_rpmdb->db_delops;
1651 sigset_t signalMask;
1656 _(
"error(%d) storing record h#%u into %s\n"),
1660 xx = dbiSync(dbi, 0);
1685 while ((next = *prev) !=
NULL && next !=
mi)
1700 xx = dbiCclose(dbi, mi->
mi_dbc, 0);
1733 if (_rpmmiPool ==
NULL) {
1734 _rpmmiPool =
rpmioNewPool(
"mi",
sizeof(*mi), -1, _rpmmi_debug,
1748 fprintf(stderr,
"<-- %s(%p) rc %u\n", __FUNCTION__, mi, (
unsigned)rc);
1755 fprintf(stderr,
"<-- %s(%p) rc %u\n", __FUNCTION__, mi, (
unsigned)rc);
1787 fprintf(stderr,
"<-- %s(%p) rc %u\n", __FUNCTION__, mi, (
unsigned)rc);
1803 return (mireA->tag - mireB->tag);
1836 nb = strlen(pattern) +
sizeof(
"^$");
1842 for (s = pattern; *s !=
'\0'; s++) {
1847 if (!brackets) nb++;
1856 if (c != (
int)
'[') brackets = 0;
1862 pat = t = (
char *)
xmalloc(nb);
1864 if (pattern[0] !=
'^') *t++ =
'^';
1869 for (s = pattern; *s !=
'\0'; s++, t++) {
1873 if (!brackets) *t++ =
'\\';
1876 if (!brackets) *t++ =
'.';
1885 if (c != (
int)
'[') brackets = 0;
1892 if (s > pattern && s[-1] !=
'$') *t++ =
'$';
1912 const char * allpat =
NULL;
1919 if (*t ==
'\0' || !
strcmp(t,
"default"))
1921 else if (!
strcmp(t,
"strcmp"))
1923 else if (!
strcmp(t,
"regex"))
1925 else if (!
strcmp(t,
"glob"))
1936 if (*pattern ==
'!') {
1943 allpat =
mireDup((
rpmTag)nmire->tag, &nmire->mode, pattern);
1946 nmire->mode = defmode;
1957 void *pool = mi->
mi_re->_item.pool;
1962 memset(mire, 0,
sizeof(*mire));
1965 mire->_item.use = use;
1966 mire->_item.pool = pool;
1971 mire->mode = nmire->mode;
1972 mire->pattern = nmire->pattern; nmire->pattern =
NULL;
1973 mire->preg = nmire->preg; nmire->preg =
NULL;
1974 mire->cflags = nmire->cflags;
1975 mire->eflags = nmire->eflags;
1976 mire->fnflags = nmire->fnflags;
1977 mire->tag = nmire->tag;
1978 mire->notmatch = notmatch;
1980 mire->offsets =
NULL;
1988 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));
1989 allpat =
_free(allpat);
2002 if (c >=
'0' && c <=
'9')
2003 return (
unsigned char)(c -
'0');
2004 if (c >=
'A' && c <=
'F')
2005 return (
unsigned char)((
int)(c -
'A') + 10);
2006 if (c >=
'a' && c <=
'f')
2007 return (
unsigned char)((
int)(c -
'a') + 10);
2021 static char hex[] =
"0123456789abcdef";
2022 const char *
s = (
const char *) data;
2024 val = t = (
char *)
xmalloc(size * 2 + 1);
2025 while (size-- > 0) {
2028 *t++ = hex[ (i >> 4) & 0xf ];
2029 *t++ = hex[ (
i ) & 0xf ];
2064 for (i = 0; i < mi->
mi_nre; i++, mire++) {
2084 for (j = 0; j < (
unsigned) he->
c; j++) {
2087 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2092 for (j = 0; j < (
unsigned) he->
c; j++) {
2095 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2100 for (j = 0; j < (
unsigned) he->
c; j++) {
2103 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2109 for (j = 0; j < (
unsigned) he->
c; j++) {
2110 sprintf(numbuf,
"%llu", (
unsigned long long)he->
p.
ui64p[j]);
2112 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2119 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2123 for (j = 0; j < (
unsigned) he->
c; j++) {
2125 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch)) {
2136 if ((rc >= 0 && !mire->notmatch) || (rc < 0 && mire->notmatch))
2141 #if !defined(SUPPORT_I18NSTRING_TYPE)
2147 if ((i+1) < mi->
mi_nre && mire[0].tag == mire[1].tag) {
2162 return (ntags > 0 && ntags == nmatches ? 0 : 1);
2200 switch (dbi->dbi_rpmdb->db_api) {
2201 default: map = 0;
break;
2206 static const int _prot = PROT_READ | PROT_WRITE;
2207 static const int _flags = MAP_PRIVATE| MAP_ANONYMOUS;
2208 static const int _fdno = -1;
2209 static const off_t _off = 0;
2211 memset(vp, 0,
sizeof(*vp));
2213 rc = dbiGet(dbi, dbcursor, kp, vp, flags);
2215 size_t uhlen = vp->
size;
2216 void *
uh = mmap(
NULL, uhlen, _prot, _flags, _fdno, _off);
2217 if (uh ==
NULL || uh == (
void *)-1)
2219 "==> mmap(%p[%u], 0x%x, 0x%x, %d, 0x%x) error(%d): %s\n",
2220 NULL, (
unsigned)uhlen, _prot, _flags, _fdno, (
unsigned)_off,
2223 vp->
ulen = (u_int32_t)uhlen;
2225 if (dbi->dbi_primary && pk)
2226 rc = dbiPget(dbi, dbcursor, kp, pk, vp, flags);
2228 rc = dbiGet(dbi, dbcursor, kp, vp, flags);
2230 if (mprotect(uh, uhlen, PROT_READ) != 0)
2231 fprintf(stderr,
"==> mprotect(%p[%u],0x%x) error(%d): %s\n",
2232 uh, (
unsigned)uhlen, PROT_READ,
2235 if (munmap(uh, uhlen) != 0)
2236 fprintf(stderr,
"==> munmap(%p[%u]) error(%d): %s\n",
2237 uh, (
unsigned)uhlen,
errno, strerror(
errno));
2241 rc = dbiGet(dbi, dbcursor, kp, vp, flags);
2242 if (_rpmmi_debug || dbi->dbi_debug)
2243 fprintf(stderr,
"<-- %s(%p(%s),%p,%p,%p,0x%x) rc %d\n", __FUNCTION__, dbi,
tagName(dbi->dbi_rpmtag), dbcursor, kp, vp, flags, rc);
2257 unsigned int _flags;
2272 switch (dbi->dbi_rpmdb->db_api) {
2273 default: map = 0;
break;
2277 if (_rpmmi_debug || dbi->dbi_debug)
2278 fprintf(stderr,
"--> %s(%p) dbi %p(%s)\n", __FUNCTION__, mi, dbi,
tagName(tag));
2319 else if (dbi->dbi_primary) {
2352 }
while (rc == 0 && mi->
mi_offset == 0);
2385 _(
"rpmdb: header #%u cannot be loaded -- skipping.\n"),
2403 sprintf(origin,
"rpmdb (h#%u)", (
unsigned)hdrNum);
2425 if (mi->
mi_set->count > 1) {
2426 #if defined(__GLIBC__)
2436 {
struct _dbiIndexItem * rec;
2438 for (i = 0, rec = mi->
mi_set->recs; i < mi->mi_set->count; i++, rec++) {
2439 fprintf(stderr,
"\t%p[%u] = %p: %u %u %u\n", mi->
mi_set->recs,
2440 i, rec, rec->hdrNum, rec->tagNum, rec->fpNum);
2451 int rc = (mi ==
NULL || hdrNums ==
NULL || nHdrNums <= 0);
2456 static size_t nRemoves = 2 * 8192;
2457 static double e = 1.0e-4;
2460 rpmbfParams(nRemoves, e, &m, &k);
2461 mi->
mi_bf = rpmbfNew(m, k, 0);
2463 for (i = 0; i < nHdrNums; i++) {
2464 uint32_t mi_offset =
_hton_ui(hdrNums[i]);
2465 int xx = rpmbfAdd(mi->
mi_bf, &mi_offset,
sizeof(mi_offset));
2471 fprintf(stderr,
"<-- %s(%p, %p[%u], %d) rc %d h# %u\n", __FUNCTION__, mi, hdrNums, (
unsigned)nHdrNums, sorted, rc, (
unsigned) (hdrNums ? hdrNums[0] : 0));
2477 int rc = (mi ==
NULL || hdrNums ==
NULL || nHdrNums <= 0);
2486 fprintf(stderr,
"<-- %s(%p, %p[%u]) rc %d h# %u\n", __FUNCTION__, mi, hdrNums, (
unsigned)nHdrNums, rc, (
unsigned) (hdrNums ? hdrNums[0] : 0));
2497 int usePatterns = 0;
2515 #ifdef RPM_VENDOR_MANDRIVA_XXX
2551 if (_rpmmi_debug || (dbi && dbi->dbi_debug))
2552 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);
2566 assert(keylen ==
sizeof(hdrNum));
2567 memcpy(&hdrNum, keyp,
sizeof(hdrNum));
2572 set->recs[0].hdrNum =
hdrNum;
2574 else if (keyp ==
NULL) {
2578 else if (usePatterns) {
2583 #if defined(RPM_VENDOR_MANDRIVA)
2594 if(!rc && ((
const char*)keyp)[0] !=
'^' && tag ==
RPMTAG_NVRA &&
2595 (set ==
NULL || set->count < 1)) {
2597 char *tmp = (
char*)keyp;
2601 for (i = 0; (tmp = strchr(tmp,
'-')); i++)
2607 const char *origkeyp = keyp;
2608 size_t klen = strlen(keyp)+1;
2613 stpcpy((
char*)keyp, origkeyp);
2614 tmp = strrchr(keyp,
'-');
2619 xx = dbiCopen(pdbi, dbiTxnid(pdbi), &pdbc, 0);
2621 for(i = 0; set && i < set->count; i++) {
2630 memset(&k, 0,
sizeof(k));
2631 memset(&v, 0,
sizeof(v));
2635 xx = dbiGet(dbi, pdbc, &k, &v,
DB_SET);
2637 tmp = (
char*)((
size_t)keyp + strlen(keyp) + 1);
2639 for (j = 0; j < (
int)(
sizeof(checkTags)/
sizeof(checkTags[0])) &&
2640 *tmp !=
'\0'; j++) {
2641 he->
tag = checkTags[
j];
2643 size_t len = strlen(he->
p.
str);
2648 if(!strncmp(he->
p.
str, tmp, len))
2653 if(j && *tmp ==
'\0') {
2654 set->recs[
size].hdrNum = set->recs[
i].hdrNum;
2655 set->recs[
size].tagNum = set->recs[
i].tagNum;
2661 if(set && set->count != size) {
2663 set->recs =
xrealloc(set->recs, size *
sizeof(*set->recs));
2666 xx = dbiCclose(pdbi, pdbc, 0);
2679 else if (dbi && dbi->dbi_primary !=
NULL) {
2695 mi->
mi_count = (set ? set->count : 0);
2701 switch (
tagType(tag) & 0xffff) {
2707 memcpy(&he->
p.
ui8p[3], keyp, keylen);
2714 memcpy(&he->
p.
ui16p[1], keyp, keylen);
2717 #if !defined(__LCLINT__)
2732 { uint32_t _tmp = he->
p.
ui32p[0];
2739 #if !defined(SUPPORT_I18NSTRING_TYPE)
2749 ? memcpy(
xmalloc(keylen), (
char *)keyp, keylen)
2777 sigset_t signalMask;
2797 "rpmdbRemove", (
unsigned)hdrNum);
2808 dbix = db->db_ndbi - 1;
2809 if (db->db_tags !=
NULL)
2822 he->
tag = dbiTag->tag;
2842 if (db->db_export !=
NULL)
2843 xx = db->db_export(db, h, 0);
2856 rc = dbiGet(dbi, dbcursor, &k, &v,
DB_SET);
2858 rc = dbiDel(dbi, dbcursor, &k, &v, 0);
2865 if (!dbi->dbi_no_dbsync)
2866 xx = dbiSync(dbi, 0);
2870 }
while (dbix-- > 0);
2886 sigset_t signalMask;
2897 fprintf(stderr,
"--> %s(%p, %u, %p, %p) h# %u\n", __FUNCTION__, db, (
unsigned)iid, h, ts, (
unsigned)hdrNum);
2902 if (iid != 0 && iid != -1) {
2928 if ((xx = dbiSeqno(dbi, &seqno, 0)) == 0) {
2944 dbix = db->db_ndbi - 1;
2945 if (db->db_tags !=
NULL)
2958 he->
tag = dbiTag->tag;
2978 if (db->db_export !=
NULL)
2979 xx = db->db_export(db, h, 1);
2982 k.
data = (
void *) &ui;
2998 xx = dbiPut(dbi, dbcursor, &k, &v,
DB_KEYLAST);
3005 if (!dbi->dbi_no_dbsync)
3006 xx = dbiSync(dbi, 0);
3013 }
while (dbix-- > 0);
static union _dbswap _endian
qsort(mc->macroTable, mc->firstFree, sizeof(mc->macroTable[0]), compareMacroName)
struct rpmmi_s * rpmmi
Database iterator.
miRE mireNew(rpmMireMode mode, int tag)
Create pattern container.
struct rpmdb_s * rpmdb
Database of headers and tag value indices.
rpmlog(RPMLOG_ERR,"%s\n", buf)
struct _setSwap_s * setSwap
static uint16_t _hton_us(uint16_t us)
int rpmmiGrowBasename(rpmmi mi, const char *bn)
Append packages containing common basename to iterator.
static const char * queryHeader(Header h, const char *qfmt)
Return header query string.
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.
static struct _dbiVec * mydbvecs[]
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)
uint32_t rpmmiInstance(rpmmi mi)
Return header instance for current position of rpmdb iterator.
char * rpmGetPath(const char *path,...)
Return (malloc'ed) expanded, canonicalized, file path.
static unsigned char nibble(char c)
Convert hex to binary nibble.
static char *size_t nb
fgets(3) analogue that reads \ continuations.
rpmioItem rpmioLinkPoolItem(rpmioItem item, const char *msg, const char *fn, unsigned ln)
Increment a pool item refcount.
struct rpmts_s * rpmts
The RPM Transaction Set.
static const char l10n_sql_init[]
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 rpmdbClose(rpmdb db)
Close all database indices and free rpmdb.
int argvAppend(ARGV_t *argvp, ARGV_t av)
Append one argv array to another.
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)
static size_t dbiTagToDbix(rpmdb db, rpmTag tag)
Return dbi index used for rpm tag.
int rpmdbAdd(rpmdb db, int iid, Header h, rpmts ts)
Add package header to rpm database and indices.
int rpmmiSetModified(rpmmi mi, int modified)
Modify iterator to mark header for lazy write on release.
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)
int rpmdbRemove(rpmdb db, int rid, uint32_t hdrNum, rpmts ts)
Remove package header from rpm database and indices.
static PyObject *char * mode
rpmTag tagValue(const char *tagstr)
Return tag value from name.
dbiIndexSet dbiFreeIndexSet(dbiIndexSet set)
sprintf(t," (%u)",(unsigned) dig->nbytes)
int rpmdbCountPackages(rpmdb db, const char *N)
Return number of instances of package in Name index.
enum rpmRC_e rpmRC
RPM return codes.
Yet Another syslog(3) API clone.
int rpmmiGrow(rpmmi mi, const uint32_t *hdrNums, int nHdrNums)
Append items to set of package instances to iterate.
memset(_r, 0, sizeof(*_r))
miRE mireFree(miRE mire)
Free pattern container.
void * xcalloc(size_t nmemb, size_t size)
assert(key->size==sizeof(hdrNum))
int rpmdbOpen(const char *prefix, rpmdb *dbp, int mode, mode_t perms)
Open rpm database.
rpmdb rpmdbLink(rpmdb db, const char *msg)
Reference a database instance.
rpmmi rpmmiFree(rpmmi mi)
Destroy rpm database iterator.
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.
struct _dbiIndexSet * dbiIndexSet
A single element (i.e.
fprintf(stderr,"--> %s(%p,%p,%p) sig %p sigp %p\n", __FUNCTION__, dig, t, rsactx, sig, sigp)
unsigned int rpmmiCount(rpmmi mi)
Return number of elements in rpm database iterator.
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.
char * stpncpy(char *dest, const char *src, size_t n)
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.
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.
Header rpmmiNext(rpmmi mi)
Return next package header from iteration.
struct yarnLock_s * yarnLock
int rpmdbCloseDBI(rpmdb db, int tag)
Close a single database index.
int rpmmiAddPattern(rpmmi mi, rpmTag tag, rpmMireMode mode, const char *pattern)
Add pattern to iterator selector.
The FD_t File Handle data structure.
void * dbiStatsAccumulator(dbiIndex dbi, int opx)
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 mireRegexec(miRE mire, const char *val, size_t vallen)
Execute pattern match.
struct tagStore_s * tagStore_t
int rpmdbCheckSignals(void)
Check for and exit on termination signals.
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.
static int rpmdbExportL10N_SQL(rpmdb db, Header h, int adding)
Update added header info into %{__l10ndir} sqlite3 database.
int Fclose(FD_t fd)
fclose(3) clone.
uint32_t rpmmiBNTag(rpmmi mi)
Return basename tag for current position of rpmdb iterator.
rpmdb rpmdbNew(const char *root, const char *home, int mode, mode_t perms, int flags)
static const char *char c
Return text between pl and matching pr characters.
return strcmp(ame->name, bme->name)
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.
int rpmdbCount(rpmdb db, rpmTag tag, const void *keyp, size_t keylen)
Return number of instances of key in a tag index.
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.
static char * mireDup(rpmTag tag, rpmMireMode *modep, const char *pattern)
Copy pattern, escaping for appropriate mode.
char * stpcpy(char *dest, const char *src)
int rpm_mergesort(void *base, size_t nmemb, size_t size, int(*cmp)(const void *, const void *))
Mergesort, same arguments as qsort(2).
int rpmmiSetRewrite(rpmmi mi, int rewrite)
Prepare iterator for lazy writes.
tagStore_t tagStoreFree(tagStore_t dbiTags, size_t dbiNTags)
Destroy tagStore array.
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 rpmdbOpenAll(rpmdb db)
Open all database indices.
static uint64_t _hton_ul(uint64_t ul)
int rpmdbCheckTerminate(int terminate)
Check rpmdb signal handler for trapped signal and/or requested exit.
static void
Print copy of spec file, filling in Group/Description/Summary from specspo.
rpmuint32_t hashFunctionString(rpmuint32_t h, const void *data, size_t size)
Return hash value of a string.
int
Save source and expand field into target.
static int unblockSignals(rpmdb db, sigset_t *oldMask)
Restore signal mask.
int rpmmiPrune(rpmmi mi, uint32_t *hdrNums, int nHdrNums, int sorted)
Remove items from set of package instances to iterate.
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).
static const char l10n_sql_qfmt[]
int rpmdbMireApply(rpmdb db, rpmTag tag, rpmMireMode mode, const char *pat, const char ***argvp)
Return array of keys matching a pattern.
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
int rpmdbBlockDBI(rpmdb db, int tag)
Block access to a single database index.
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.
int rpmmiSort(rpmmi mi)
Sort iterator instances.
static const char * _str2PCREpat(const char *_pre, const char *s, const char *_post)
rpmmi rpmmiInit(rpmdb db, rpmTag tag, const void *keyp, size_t keylen)
Return database iterator.
static int rpmmiGet(dbiIndex dbi, DBC *dbcursor, DBT *kp, DBT *pk, DBT *vp, unsigned int flags)
struct _dbiIndex * dbiIndex
unsigned int dbiIndexSetCount(dbiIndexSet set)
static const char * stemEnd(const char *s)
int Unlink(const char *path)
unlink(2) clone.