rpm  5.4.10
verify.c
Go to the documentation of this file.
1 
6 #include "system.h"
7 
8 #include <rpmiotypes.h>
9 #include <rpmio.h>
10 #include <rpmcb.h>
11 #include "ugid.h"
12 
13 #include <rpmtypes.h>
14 #include <rpmtag.h>
15 #include <pkgio.h>
16 
17 #define _RPMFI_INTERNAL
18 #include <rpmfi.h>
19 
20 #define _RPMSQ_INTERNAL
21 #include "psm.h"
22 
23 #include "legacy.h" /* XXX dodigest(), uidToUname(), gnameToGid */
24 
25 #define _RPMPS_INTERNAL /* XXX rpmps needs iterator. */
26 #define _RPMTS_INTERNAL /* XXX expose rpmtsSetScriptFd */
27 #include <rpmcli.h>
28 
29 #include "debug.h"
30 
31 /*@access rpmts @*/ /* XXX cast */
32 /*@access rpmpsm @*/ /* XXX for %verifyscript through rpmpsmStage() */
33 
34 #define S_ISDEV(m) (S_ISBLK((m)) || S_ISCHR((m)))
35 
36 /*@unchecked@*/
38 
39 typedef struct rpmvf_s * rpmvf;
40 struct rpmvf_s {
41  struct rpmioItem_s _item;
42  const char * fn;
43  const char * flink;
44  struct stat sb;
48  int dalgo;
49  size_t dlen;
50  const unsigned char * digest;
51  const char * fuser;
52  const char * fgroup;
53 #if defined(__LCLINT__NOTYET)
54 /*@refs@*/
55  int nrefs;
56 #endif
57 };
58 
59 #ifdef __cplusplus
60 
61 #define FF_ISSET(_fflags, _FLAG) ((_fflags) & (RPMFILE_##_FLAG))
62 
63 #define VF_ISSET(_vflags, _FLAG) ((_vflags) & (RPMVERIFY_##_FLAG))
64 #define VF_SET(_vflags, _FLAG) \
65  (*((unsigned *)&(_vflags)) |= (RPMVERIFY_##_FLAG))
66 #define VF_CLR(_vflags, _FLAG) \
67  (*((unsigned *)&(_vflags)) &= ~(RPMVERIFY_##_FLAG))
68 
69 #define QVA_ISSET(_qvaflags, _FLAG) ((_qvaflags) & (VERIFY_##_FLAG))
70 
71 #define VSF_ISSET(_vsflags, _FLAG) ((_vsflags) & (RPMVSF_##_FLAG))
72 #define VSF_SET(_vsflags, _FLAG) \
73  (*((unsigned *)&(_vsflags)) |= (RPMVSF_##_FLAG))
74 #define VSF_CLR(_vsflags, _FLAG) \
75  (*((unsigned *)&(_vsflags)) &= ~(RPMVSF_##_FLAG))
76 
77 GENfree(rpmvf)
78 
79 #else /* __cplusplus */
80 
81 #define FF_ISSET(_fflags, _FLAG) ((_fflags) & (RPMFILE_##_FLAG))
82 
83 #define VF_ISSET(_vflags, _FLAG) ((_vflags) & (RPMVERIFY_##_FLAG))
84 #define VF_SET(_vflags, _FLAG) (_vflags) |= (RPMVERIFY_##_FLAG)
85 #define VF_CLR(_vflags, _FLAG) (_vflags) &= ~(RPMVERIFY_##_FLAG)
86 
87 #define QVA_ISSET(_qvaflags, _FLAG) ((_qvaflags) & (VERIFY_##_FLAG))
88 
89 #define VSF_ISSET(_vsflags, _FLAG) ((_vsflags) & (RPMVSF_##_FLAG))
90 #define VSF_SET(_vsflags, _FLAG) (_vsflags) |= (RPMVSF_##_FLAG)
91 #define VSF_CLR(_vsflags, _FLAG) (_vsflags) &= ~(RPMVSF_##_FLAG)
92 
93 #endif /* __cplusplus */
94 
95 static rpmvf rpmvfFree(/*@only@*/ rpmvf vf)
96  /*@modifies vf @*/
97 {
98 
99  if (vf) {
100 #ifdef NOTYET
101  yarnPossess(vf->_item.use);
102  if (yarnPeekLock(vf->_item.use) <= 1L) {
103  yarnLock use = vf->_item.use;
104  vf->fn = _free(vf->fn);
105  vf = _free(vf);
106  yarnTwist(use, TO, 0);
107  use = yarnFreeLock(use);
108  } else
109  yarnTwist(vf->_item.use, BY, -1);
110 #else
111  vf->fn = _free(vf->fn);
112  vf = _free(vf);
113 #endif
114  }
115  return NULL;
116 }
117 
118 /*@only@*/
119 static rpmvf rpmvfNew(rpmts ts, rpmfi fi, int i, rpmVerifyAttrs omitMask)
120  /*@*/
121 {
122  rpmvf vf = (rpmvf) DRD_xcalloc(1, sizeof(*vf));
123 
124 #ifdef NOTYET
125  vf->_item.use = yarnNewLock(1);
126  vf->_item.pool = NULL;
127 #endif
128 
129 /*@-mods@*/
130  vf->fn = rpmGetPath(rpmtsRootDir(ts), fi->dnl[fi->dil[i]], fi->bnl[i], NULL);
131 /*@=mods@*/
132  vf->flink = fi->flinks[i];
133  vf->fuser = fi->fuser[i];
134  vf->fgroup = fi->fgroup[i];
135 
136  { struct stat *st = &vf->sb;
137  st->st_dev =
138  st->st_rdev = fi->frdevs[i];
139  st->st_ino = fi->finodes[i];
140  st->st_mode = fi->fmodes[i];
141 #ifdef NOTNEEDED
142  st->st_nlink = rpmfiFNlink(fi) + (int)S_ISDIR(st->st_mode);
143 #endif
144  if (unameToUid(vf->fuser, &st->st_uid) == -1)
145  st->st_uid = 0; /* XXX */
146  if (gnameToGid(vf->fgroup, &st->st_gid) == -1)
147  st->st_gid = 0; /* XXX */
148  st->st_size = fi->fsizes[i];
149  st->st_blksize = 4 * 1024; /* XXX */
150  st->st_blocks = (st->st_size + (st->st_blksize - 1)) / st->st_blksize;
151  st->st_atime =
152  st->st_ctime =
153  st->st_mtime = fi->fmtimes[i];
154  }
155 
156  vf->fflags = (rpmfileAttrs) fi->fflags[i];
157  vf->fstate = (rpmfileState) fi->fstates[i];
158  vf->vflags = (rpmVerifyAttrs) fi->vflags[i];
159  vf->dalgo = fi->fdigestalgos
160  ? fi->fdigestalgos[i]
161  : fi->digestalgo;
162  vf->dlen = fi->digestlen;
163  vf->digest = fi->digests + (fi->digestlen * i);
164 
165  /* Don't verify any features in omitMask. */
166  { unsigned * _vflagsp = (unsigned *)&vf->vflags;
167  *_vflagsp &= ~(omitMask | RPMVERIFY_FAILURES);
168  }
169 
170  /* Content checks of %ghost files are meaningless. */
171  if (FF_ISSET(vf->fflags, GHOST)) {
172  VF_CLR(vf->vflags, FDIGEST);
173  VF_CLR(vf->vflags, FILESIZE);
174  VF_CLR(vf->vflags, MTIME);
175  VF_CLR(vf->vflags, LINKTO);
176  VF_CLR(vf->vflags, HMAC);
177  }
178 
179  return vf;
180 }
181 
188 static int rpmvfVerify(rpmvf vf, int spew)
189  /*@globals h_errno, fileSystem, internalState @*/
190  /*@modifies vf, fileSystem, internalState @*/
191 {
193  struct stat sb;
194  int ec = 0;
195 
196  /* Check to see if the file was installed - if not pretend all is OK. */
197  switch (vf->fstate) {
198  default:
203  goto exit;
204  /*@notreached@*/ break;
206  break;
207  }
208 
209 assert(vf->fn != NULL);
210  if (vf->fn == NULL || Lstat(vf->fn, &sb) != 0) {
211  VF_SET(res, LSTATFAIL);
212  ec = 1;
213  goto exit;
214  }
215 
216  /* Not all attributes of non-regular files can be verified. */
217  if (S_ISDIR(sb.st_mode)) {
218  VF_CLR(vf->vflags, FDIGEST);
219  VF_CLR(vf->vflags, FILESIZE);
220  VF_CLR(vf->vflags, MTIME);
221  VF_CLR(vf->vflags, LINKTO);
222  VF_CLR(vf->vflags, HMAC);
223  } else if (S_ISLNK(sb.st_mode)) {
224  VF_CLR(vf->vflags, FDIGEST);
225  VF_CLR(vf->vflags, FILESIZE);
226  VF_CLR(vf->vflags, MTIME);
227  VF_CLR(vf->vflags, MODE);
228  VF_CLR(vf->vflags, HMAC);
229 #if CHOWN_FOLLOWS_SYMLINK
230  VF_CLR(vf->vflags, USER);
231  VF_CLR(vf->vflags, GROUP);
232 #endif
233  }
234  else if (S_ISFIFO(sb.st_mode)) {
235  VF_CLR(vf->vflags, FDIGEST);
236  VF_CLR(vf->vflags, FILESIZE);
237  VF_CLR(vf->vflags, MTIME);
238  VF_CLR(vf->vflags, LINKTO);
239  VF_CLR(vf->vflags, HMAC);
240  } else if (S_ISCHR(sb.st_mode)) {
241  VF_CLR(vf->vflags, FDIGEST);
242  VF_CLR(vf->vflags, FILESIZE);
243  VF_CLR(vf->vflags, MTIME);
244  VF_CLR(vf->vflags, LINKTO);
245  VF_CLR(vf->vflags, HMAC);
246  } else if (S_ISBLK(sb.st_mode)) {
247  VF_CLR(vf->vflags, FDIGEST);
248  VF_CLR(vf->vflags, FILESIZE);
249  VF_CLR(vf->vflags, MTIME);
250  VF_CLR(vf->vflags, LINKTO);
251  VF_CLR(vf->vflags, HMAC);
252  } else {
253  VF_CLR(vf->vflags, LINKTO);
254  }
255 
256  if (VF_ISSET(vf->vflags, FDIGEST) || VF_ISSET(vf->vflags, HMAC)) {
257  if (vf->digest == NULL || vf->dlen == 0)
258  VF_SET(res, FDIGEST);
259  else {
260  /* XXX If --nofdigest, then prelinked library sizes fail to verify. */
261  unsigned char * fdigest = (unsigned char *)
262  memset(alloca(vf->dlen), 0, vf->dlen);
263  size_t fsize = 0;
264 #define _mask (RPMVERIFY_FDIGEST|RPMVERIFY_HMAC)
265  unsigned dflags = (vf->vflags & _mask) == RPMVERIFY_HMAC
266  ? 0x2 : 0x0;
267 #undef _mask
268  int rc = dodigest(vf->dalgo, vf->fn, fdigest, dflags, &fsize);
269  sb.st_size = fsize;
270  if (rc) {
271  VF_SET(res, READFAIL);
272  VF_SET(res, FDIGEST);
273  } else
274  if (memcmp(fdigest, vf->digest, vf->dlen))
275  VF_SET(res, FDIGEST);
276  }
277  }
278 
279  if (VF_ISSET(vf->vflags, LINKTO)) {
280  char linkto[1024+1];
281  int size = 0;
282 
283  if ((size = Readlink(vf->fn, linkto, sizeof(linkto)-1)) == -1) {
284  VF_SET(res, READLINKFAIL);
285  VF_SET(res, LINKTO);
286  } else {
287  linkto[size] = '\0';
288  if (vf->flink == NULL || strcmp(linkto, vf->flink))
289  VF_SET(res, LINKTO);
290  }
291  }
292 
293  if (VF_ISSET(vf->vflags, FILESIZE)) {
294  if (sb.st_size != vf->sb.st_size)
295  VF_SET(res, FILESIZE);
296  }
297 
298  if (VF_ISSET(vf->vflags, MODE)) {
299  /* XXX AIX has sizeof(mode_t) > sizeof(unsigned short) */
300  unsigned short metamode = (unsigned short)vf->sb.st_mode;
301  unsigned short filemode = (unsigned short)sb.st_mode;
302 
303  /* Comparing type of %ghost files is meaningless, but perms are OK. */
304  if (FF_ISSET(vf->fflags, GHOST)) {
305  metamode &= ~0xf000;
306  filemode &= ~0xf000;
307  }
308  if (metamode != filemode)
309  VF_SET(res, MODE);
310  }
311 
312  if (VF_ISSET(vf->vflags, RDEV)) {
313  if (S_ISCHR(vf->sb.st_mode) != S_ISCHR(sb.st_mode)
314  || S_ISBLK(vf->sb.st_mode) != S_ISBLK(sb.st_mode))
315  VF_SET(res, RDEV);
316  else if (S_ISDEV(vf->sb.st_mode) && S_ISDEV(sb.st_mode)) {
317  rpmuint16_t st_rdev = (rpmuint16_t)(sb.st_rdev & 0xffff);
318  rpmuint16_t frdev = (rpmuint16_t)(vf->sb.st_rdev & 0xffff);
319  if (st_rdev != frdev)
320  VF_SET(res, RDEV);
321  }
322  }
323 
324  if (VF_ISSET(vf->vflags, MTIME)) {
325  if (sb.st_mtime != vf->sb.st_mtime)
326  VF_SET(res, MTIME);
327  }
328 
329  if (VF_ISSET(vf->vflags, USER)) {
330  const char * fuser = uidToUname(sb.st_uid);
331  if (fuser == NULL || vf->fuser == NULL || strcmp(fuser, vf->fuser))
332  VF_SET(res, USER);
333  }
334 
335  if (VF_ISSET(vf->vflags, GROUP)) {
336  const char * fgroup = gidToGname(sb.st_gid);
337  if (fgroup == NULL || vf->fgroup == NULL || strcmp(fgroup, vf->fgroup))
338  VF_SET(res, GROUP);
339  }
340 
341 exit:
342 
343  if (spew) { /* XXX no output w verify(...) probe. */
344  char buf[BUFSIZ];
345  char * t = buf;
346  char * te = t;
347  *te = '\0';
348  if (ec) {
349  if (!(FF_ISSET(vf->fflags, MISSINGOK) ||FF_ISSET(vf->fflags, GHOST))
350  || rpmIsVerbose())
351  {
352  sprintf(te, _("missing %c %s"),
353  (FF_ISSET(vf->fflags, CONFIG) ? 'c' :
354  FF_ISSET(vf->fflags, DOC) ? 'd' :
355  FF_ISSET(vf->fflags, GHOST) ? 'g' :
356  FF_ISSET(vf->fflags, LICENSE) ? 'l' :
357  FF_ISSET(vf->fflags, PUBKEY) ? 'P' :
358  FF_ISSET(vf->fflags, README) ? 'r' : ' '),
359  vf->fn);
360  if (VF_ISSET(res, LSTATFAIL) && errno != ENOENT) {
361  te += strlen(te);
362  sprintf(te, " (%s)", strerror(errno));
363  }
364  }
365  } else if (res || rpmIsVerbose()) {
366  /*@observer@*/ static const char aok[] = ".";
367  /*@observer@*/ static const char unknown[] = "?";
368 
369 #define _verify(_FLAG, _C) \
370  (VF_ISSET(res, _FLAG) ? _C : aok)
371 #define _verifylink(_FLAG, _C) \
372  (VF_ISSET(res, READLINKFAIL) ? unknown : \
373  VF_ISSET(res, _FLAG) ? _C : aok)
374 #define _verifyfile(_FLAG, _C) \
375  (VF_ISSET(res, READFAIL) ? unknown : \
376  VF_ISSET(res, _FLAG) ? _C : aok)
377 
378  const char * digest = _verifyfile(FDIGEST, "5");
379  const char * size = _verify(FILESIZE, "S");
380  const char * link = _verifylink(LINKTO, "L");
381  const char * mtime = _verify(MTIME, "T");
382  const char * rdev = _verify(RDEV, "D");
383  const char * user = _verify(USER, "U");
384  const char * group = _verify(GROUP, "G");
385  const char * mode = _verify(MODE, "M");
386 
387 #undef _verifyfile
388 #undef _verifylink
389 #undef _verify
390 
391  sprintf(te, "%s%s%s%s%s%s%s%s %c %s",
392  size, mode, digest, rdev, link, user, group, mtime,
393  (FF_ISSET(vf->fflags, CONFIG) ? 'c' :
394  FF_ISSET(vf->fflags, DOC) ? 'd' :
395  FF_ISSET(vf->fflags, GHOST) ? 'g' :
396  FF_ISSET(vf->fflags, LICENSE) ? 'l' :
397  FF_ISSET(vf->fflags, PUBKEY) ? 'P' :
398  FF_ISSET(vf->fflags, README) ? 'r' : ' '),
399  vf->fn);
400 
401  }
402 
403  if (t && *t)
404  rpmlog(RPMLOG_NOTICE, "%s\n", t);
405 
406  }
407 
408  return (res != 0);
409 }
410 
420 static int rpmVerifyScript(/*@unused@*/ QVA_t qva, rpmts ts,
421  rpmfi fi, /*@null@*/ FD_t scriptFd)
422  /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
423  /*@modifies ts, fi, scriptFd, rpmGlobalMacroContext,
424  fileSystem, internalState @*/
425 {
426  rpmpsm psm;
427  rpmRC rc;
428  int ec = 0;
429 
430  if (scriptFd != NULL)
431  rpmtsSetScriptFd(ts, scriptFd);
432 
433  psm = rpmpsmNew(ts, NULL, fi);
434 
436  if (rc != RPMRC_OK)
437  ec = 1;
438 
440  if (rc != RPMRC_OK)
441  ec = 1;
442 
443  psm = rpmpsmFree(psm, __FUNCTION__);
444 
445  if (scriptFd != NULL)
446  rpmtsSetScriptFd(ts, NULL);
447 
448  return ec;
449 }
450 
458 static int verifyDependencies(/*@unused@*/ QVA_t qva, rpmts ts,
459  Header h)
460  /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
461  /*@modifies ts, h, rpmGlobalMacroContext, fileSystem, internalState @*/
462 {
463 #ifdef NOTYET
464  uint32_t hdrNum = headerGetInstance(h);
465 #endif
466  rpmps ps;
467  int rc = 0; /* assume no problems */
468  int xx;
469 
470  rpmtsEmpty(ts);
471 
472 #ifdef NOTYET
473  if (hdrNum > 0)
474  (void) rpmtsAddEraseElement(ts, h, hdrNum);
475  else
476 #endif
477  (void) rpmtsAddInstallElement(ts, h, headerGetOrigin(h), 0, NULL);
478 
479  xx = rpmtsCheck(ts);
480  ps = rpmtsProblems(ts);
481 
482  if (rpmpsNumProblems(ps) > 0) {
483  const char * altNEVR;
484  const char * pkgNEVR = NULL;
485  rpmpsi psi;
486  rpmProblem prob;
487  char * t, * te;
488  int nb = 512;
489 
490  psi = rpmpsInitIterator(ps);
491  while (rpmpsNextIterator(psi) >= 0) {
492  prob = rpmpsProblem(psi);
493  if (pkgNEVR == NULL)
494  pkgNEVR = rpmProblemGetPkgNEVR(prob);
495 
496  altNEVR = rpmProblemGetAltNEVR(prob);
497 assert(altNEVR != NULL);
498  if (altNEVR[0] == 'R' && altNEVR[1] == ' ')
499  nb += sizeof("\tRequires: ")-1;
500  if (altNEVR[0] == 'C' && altNEVR[1] == ' ')
501  nb += sizeof("\tConflicts: ")-1;
502  nb += strlen(altNEVR+2) + sizeof("\n") - 1;
503 
504  }
505  psi = rpmpsFreeIterator(psi);
506 
507  te = t = (char *) alloca(nb);
508  *te = '\0';
509  sprintf(te, _("Unsatisfied dependencies for %s:\n"), pkgNEVR);
510  te += strlen(te);
511 
512  psi = rpmpsInitIterator(ps);
513  while (rpmpsNextIterator(psi) >= 0) {
514  prob = rpmpsProblem(psi);
515 
516  if ((altNEVR = rpmProblemGetAltNEVR(prob)) == NULL)
517  altNEVR = "? ?altNEVR?";
518  if (altNEVR[0] == 'R' && altNEVR[1] == ' ')
519  te = stpcpy(te, "\tRequires: ");
520  if (altNEVR[0] == 'C' && altNEVR[1] == ' ')
521  te = stpcpy(te, "\tConflicts: ");
522  te = stpcpy( stpcpy(te, altNEVR+2), "\n");
523 
524  rc++;
525  }
526  psi = rpmpsFreeIterator(psi);
527 
528  if (te > t) {
529  *te++ = '\n';
530  *te = '\0';
531  rpmlog(RPMLOG_NOTICE, "%s", t);
532  te = t;
533  *t = '\0';
534  }
535  }
536 
537  ps = rpmpsFree(ps);
538 
539  rpmtsEmpty(ts);
540 
541  return rc;
542 }
543 
545 {
546  static int scareMem = 0;
547  rpmVerifyAttrs omitMask = (rpmVerifyAttrs)
548  ((qva->qva_flags & VERIFY_ATTRS) ^ VERIFY_ATTRS);
549  int spew = (qva->qva_mode != 'v'); /* XXX no output w verify(...) probe. */
550  int ec = 0;
551  int i;
552 rpmfi fi = rpmfiNew(ts, h, RPMTAG_BASENAMES, scareMem);
553 uint32_t fc = rpmfiFC(fi);
554 
555  {
556  /* Verify header digest/signature. */
558  {
559  const char * horigin = headerGetOrigin(h);
560  const char * msg = NULL;
561  size_t uhlen = 0;
562  void * uh = headerUnload(h, &uhlen);
563  int lvl = headerCheck(rpmtsDig(ts), uh, uhlen, &msg) == RPMRC_FAIL
565  rpmlog(lvl, "%s: %s\n",
566  (horigin ? horigin : "verify"), (msg ? msg : ""));
567  rpmtsCleanDig(ts);
568  uh = _free(uh);
569  msg = _free(msg);
570  }
571 
572  /* Verify file digests. */
573  if (fc > 0 && (qva->qva_flags & VERIFY_FILES))
574 #if defined(_OPENMP)
575  #pragma omp parallel for private(i) reduction(+:ec)
576 #endif
577  for (i = 0; i < (int)fc; i++) {
578  int fflags = fi->fflags[i];
579  rpmvf vf;
580  int rc;
581 
582  /* If not querying %config, skip config files. */
583  if (FF_ISSET(qva->qva_fflags, CONFIG) && FF_ISSET(fflags, CONFIG))
584  continue;
585 
586  /* If not querying %doc, skip doc files. */
587  if (FF_ISSET(qva->qva_fflags, DOC) && FF_ISSET(fflags, DOC))
588  continue;
589 
590  /* If not verifying %ghost, skip ghost files. */
591  /* XXX the broken!!! logic disables %ghost queries always. */
592  if (!(FF_ISSET(qva->qva_fflags, GHOST) && FF_ISSET(fflags, GHOST)))
593  continue;
594 
595  /* Gather per-file data into a carrier. */
596  vf = rpmvfNew(ts, fi, i, omitMask);
597 
598  /* Verify per-file metadata. */
599  rc = rpmvfVerify(vf, spew);
600  if (rc)
601  ec += rc;
602 
603  (void) rpmvfFree(vf);
604  vf = NULL;
605  }
606 
607  /* Run verify/sanity scripts (if any). */
608  if (qva->qva_flags & VERIFY_SCRIPT)
609  {
610  int rc;
611 
614  {
615  FD_t fdo = fdDup(STDOUT_FILENO);
616 
617  rc = rpmfiSetHeader(fi, h);
618  if ((rc = rpmVerifyScript(qva, ts, fi, fdo)) != 0)
619  ec += rc;
620  if (fdo != NULL)
621  rc = Fclose(fdo);
622  rc = rpmfiSetHeader(fi, NULL);
623  }
624  }
625 
626  /* Verify dependency assertions. */
627  if (qva->qva_flags & VERIFY_DEPS)
628  {
629  int save_noise = _rpmds_unspecified_epoch_noise;
630  int rc;
631 
632 /*@-mods@*/
633  if (rpmIsVerbose())
635  if ((rc = verifyDependencies(qva, ts, h)) != 0)
636  ec += rc;
637  _rpmds_unspecified_epoch_noise = save_noise;
638 /*@=mods@*/
639  }
640  }
641 
642  fi = rpmfiFree(fi);
643 
644  return ec;
645 }
646 
647 int rpmcliVerify(rpmts ts, QVA_t qva, const char ** argv)
648 {
649  rpmdepFlags depFlags = qva->depFlags, odepFlags;
650  rpmtransFlags transFlags = qva->transFlags, otransFlags;
651  rpmVSFlags vsflags, ovsflags;
652  int ec = 0;
653 
654 #if defined(_OPENMP)
655 (void) tagName((rpmTag)0); /* XXX instantiate the tagname store. */
656 omp_set_nested(1); /* XXX permit nested thread teams. */
657 #endif
658 
659  if (qva->qva_showPackage == NULL)
661 
662  /* XXX verify flags are inverted from query. */
663  vsflags = (rpmVSFlags) rpmExpandNumeric("%{?_vsflags_verify}");
664  vsflags = (rpmVSFlags) 0; /* XXX FIXME: ignore default disablers. */
665 #if defined(SUPPORT_NOSIGNATURES)
666  if (!QVA_ISSET(qva->qva_flags, DIGEST)) {
667  VSF_SET(vsflags, NOSHA1HEADER);
668  VSF_SET(vsflags, NOMD5HEADER);
669  VSF_SET(vsflags, NOSHA1);
670  VSF_SET(vsflags, NOMD5);
671  }
672  if (!QVA_ISSET(qva->qva_flags, SIGNATURE)) {
673  VSF_SET(vsflags, NODSAHEADER);
674  VSF_SET(vsflags, NORSAHEADER);
675  VSF_SET(vsflags, NODSA);
676  VSF_SET(vsflags, NORSA);
677  }
678  if (!QVA_ISSET(qva->qva_flags, HDRCHK)) {
679  VSF_SET(vsflags, NOHDRCHK);
680  }
681  VSF_CLR(vsflags, NEEDPAYLOAD);
682 #endif
683 
684  odepFlags = rpmtsSetDFlags(ts, depFlags);
685  otransFlags = rpmtsSetFlags(ts, transFlags);
686  ovsflags = rpmtsSetVSFlags(ts, vsflags);
687  ec = rpmcliArgIter(ts, qva, argv);
688  vsflags = rpmtsSetVSFlags(ts, ovsflags);
689  transFlags = rpmtsSetFlags(ts, otransFlags);
690  depFlags = rpmtsSetDFlags(ts, odepFlags);
691 
693  qva->qva_showPackage = NULL;
694 
695  rpmtsEmpty(ts);
696 
697  return ec;
698 }