00001
00006 #include "system.h"
00007
00008 #ifndef PATH_MAX
00009
00010 # define PATH_MAX 255
00011
00012 #endif
00013
00014 #include <rpmcli.h>
00015
00016 #include "rpmdb.h"
00017 #include "rpmfi.h"
00018 #include "rpmts.h"
00019
00020 #include "manifest.h"
00021 #include "misc.h"
00022
00023 #include "debug.h"
00024
00027 static void printFileInfo(char * te, const char * name,
00028 unsigned int size, unsigned short mode,
00029 unsigned int mtime,
00030 unsigned short rdev, unsigned int nlink,
00031 const char * owner, const char * group,
00032 const char * linkto)
00033
00034 {
00035 char sizefield[15];
00036 char ownerfield[8+1], groupfield[8+1];
00037 char timefield[100];
00038 time_t when = mtime;
00039 struct tm * tm;
00040 static time_t now;
00041 static struct tm nowtm;
00042 const char * namefield = name;
00043 char * perms = rpmPermsString(mode);
00044
00045
00046 if (now == 0) {
00047 now = time(NULL);
00048 tm = localtime(&now);
00049
00050 if (tm) nowtm = *tm;
00051
00052 }
00053
00054 strncpy(ownerfield, owner, sizeof(ownerfield));
00055 ownerfield[sizeof(ownerfield)-1] = '\0';
00056
00057 strncpy(groupfield, group, sizeof(groupfield));
00058 groupfield[sizeof(groupfield)-1] = '\0';
00059
00060
00061 sprintf(sizefield, "%12u", size);
00062
00063
00064
00065 if (S_ISLNK(mode)) {
00066 char *nf = alloca(strlen(name) + sizeof(" -> ") + strlen(linkto));
00067 sprintf(nf, "%s -> %s", name, linkto);
00068 namefield = nf;
00069 } else if (S_ISCHR(mode)) {
00070 perms[0] = 'c';
00071 sprintf(sizefield, "%3u, %3u", ((unsigned)(rdev >> 8) & 0xff),
00072 ((unsigned)rdev & 0xff));
00073 } else if (S_ISBLK(mode)) {
00074 perms[0] = 'b';
00075 sprintf(sizefield, "%3u, %3u", ((unsigned)(rdev >> 8) & 0xff),
00076 ((unsigned)rdev & 0xff));
00077 }
00078
00079
00080 tm = localtime(&when);
00081 timefield[0] = '\0';
00082 if (tm != NULL)
00083 { const char *fmt;
00084 if (now > when + 6L * 30L * 24L * 60L * 60L ||
00085 now < when - 60L * 60L)
00086 {
00087
00088
00089
00090
00091
00092
00093
00094 fmt = "%b %e %Y";
00095 } else {
00096 fmt = "%b %e %H:%M";
00097 }
00098 (void)strftime(timefield, sizeof(timefield) - 1, fmt, tm);
00099 }
00100
00101 sprintf(te, "%s %4d %-8s%-8s %10s %s %s", perms,
00102 (int)nlink, ownerfield, groupfield, sizefield, timefield, namefield);
00103 perms = _free(perms);
00104 }
00105
00108 static inline const char * queryHeader(Header h, const char * qfmt)
00109
00110 {
00111 const char * errstr = "(unkown error)";
00112 const char * str;
00113
00114
00115 str = headerSprintf(h, qfmt, rpmTagTable, rpmHeaderFormats, &errstr);
00116
00117 if (str == NULL)
00118 rpmError(RPMERR_QFMT, _("incorrect format: %s\n"), errstr);
00119 return str;
00120 }
00121
00122 int showQueryPackage(QVA_t qva, rpmts ts, Header h)
00123 {
00124 int scareMem = 0;
00125 rpmfi fi = NULL;
00126 char * t, * te;
00127 char * prefix = NULL;
00128 int rc = 0;
00129 int nonewline = 0;
00130 int i;
00131
00132 te = t = xmalloc(BUFSIZ);
00133
00134 *te = '\0';
00135
00136
00137 if (qva->qva_queryFormat != NULL) {
00138 const char * str = queryHeader(h, qva->qva_queryFormat);
00139 nonewline = 1;
00140
00141 if (str) {
00142 size_t tb = (te - t);
00143 size_t sb = strlen(str);
00144
00145 if (sb >= (BUFSIZ - tb)) {
00146 t = xrealloc(t, BUFSIZ+sb);
00147 te = t + tb;
00148 }
00149
00150
00151 te = stpcpy(te, str);
00152
00153
00154 str = _free(str);
00155 }
00156
00157 }
00158
00159 if (!(qva->qva_flags & QUERY_FOR_LIST))
00160 goto exit;
00161
00162 fi = rpmfiNew(ts, h, RPMTAG_BASENAMES, scareMem);
00163 if (rpmfiFC(fi) <= 0) {
00164
00165 te = stpcpy(te, _("(contains no files)"));
00166
00167 goto exit;
00168 }
00169
00170 fi = rpmfiInit(fi, 0);
00171 if (fi != NULL)
00172 while ((i = rpmfiNext(fi)) >= 0) {
00173 rpmfileAttrs fflags;
00174 unsigned short fmode;
00175 unsigned short frdev;
00176 unsigned int fmtime;
00177 rpmfileState fstate;
00178 size_t fsize;
00179 const char * fn;
00180 char fmd5[32+1];
00181 const char * fuser;
00182 const char * fgroup;
00183 const char * flink;
00184 int_32 fnlink;
00185
00186 fflags = rpmfiFFlags(fi);
00187 fmode = rpmfiFMode(fi);
00188 frdev = rpmfiFRdev(fi);
00189 fmtime = rpmfiFMtime(fi);
00190 fstate = rpmfiFState(fi);
00191 fsize = rpmfiFSize(fi);
00192 fn = rpmfiFN(fi);
00193
00194 { static char hex[] = "0123456789abcdef";
00195 const char * s = rpmfiMD5(fi);
00196 char * p = fmd5;
00197 int j;
00198 for (j = 0; j < 16; j++) {
00199 unsigned k = *s++;
00200 *p++ = hex[ (k >> 4) & 0xf ];
00201 *p++ = hex[ (k ) & 0xf ];
00202 }
00203 *p = '\0';
00204 }
00205
00206 fuser = rpmfiFUser(fi);
00207 fgroup = rpmfiFGroup(fi);
00208 flink = rpmfiFLink(fi);
00209 fnlink = rpmfiFNlink(fi);
00210
00211
00212 if ((qva->qva_flags & QUERY_FOR_DOCS) && !(fflags & RPMFILE_DOC))
00213 continue;
00214
00215
00216 if ((qva->qva_flags & QUERY_FOR_CONFIG) && !(fflags & RPMFILE_CONFIG))
00217 continue;
00218
00219
00220 if (!(qva->qva_fflags & RPMFILE_GHOST) && (fflags & RPMFILE_GHOST))
00221 continue;
00222
00223
00224 if (!rpmIsVerbose() && prefix)
00225 te = stpcpy(te, prefix);
00226
00227 if (qva->qva_flags & QUERY_FOR_STATE) {
00228 switch (fstate) {
00229 case RPMFILE_STATE_NORMAL:
00230 te = stpcpy(te, _("normal "));
00231 break;
00232 case RPMFILE_STATE_REPLACED:
00233 te = stpcpy(te, _("replaced "));
00234 break;
00235 case RPMFILE_STATE_NOTINSTALLED:
00236 te = stpcpy(te, _("not installed "));
00237 break;
00238 case RPMFILE_STATE_NETSHARED:
00239 te = stpcpy(te, _("net shared "));
00240 break;
00241 case RPMFILE_STATE_WRONGCOLOR:
00242 te = stpcpy(te, _("wrong color "));
00243 break;
00244 case RPMFILE_STATE_MISSING:
00245 te = stpcpy(te, _("(no state) "));
00246 break;
00247 default:
00248 sprintf(te, _("(unknown %3d) "), fstate);
00249 te += strlen(te);
00250 break;
00251 }
00252 }
00253
00254
00255 if (qva->qva_flags & QUERY_FOR_DUMPFILES) {
00256 sprintf(te, "%s %d %d %s 0%o ", fn, (int)fsize, fmtime, fmd5, fmode);
00257 te += strlen(te);
00258
00259 if (fuser && fgroup) {
00260
00261 sprintf(te, "%s %s", fuser, fgroup);
00262
00263 te += strlen(te);
00264 } else {
00265 rpmError(RPMERR_INTERNAL,
00266 _("package has not file owner/group lists\n"));
00267 }
00268
00269 sprintf(te, " %s %s %u ",
00270 fflags & RPMFILE_CONFIG ? "1" : "0",
00271 fflags & RPMFILE_DOC ? "1" : "0",
00272 frdev);
00273 te += strlen(te);
00274
00275 sprintf(te, "%s", (flink && *flink ? flink : "X"));
00276 te += strlen(te);
00277 } else
00278 if (!rpmIsVerbose()) {
00279
00280 te = stpcpy(te, fn);
00281
00282 }
00283 else {
00284
00285
00286 if (S_ISDIR(fmode)) {
00287 fnlink++;
00288 fsize = 0;
00289 }
00290
00291 if (fuser && fgroup) {
00292
00293 printFileInfo(te, fn, fsize, fmode, fmtime, frdev, fnlink,
00294 fuser, fgroup, flink);
00295
00296 te += strlen(te);
00297 } else {
00298 rpmError(RPMERR_INTERNAL,
00299 _("package has neither file owner or id lists\n"));
00300 }
00301 }
00302
00303 if (te > t) {
00304
00305 *te++ = '\n';
00306 *te = '\0';
00307 rpmMessage(RPMMESS_NORMAL, "%s", t);
00308 te = t;
00309 *t = '\0';
00310
00311 }
00312
00313 }
00314
00315 rc = 0;
00316
00317 exit:
00318 if (te > t) {
00319 if (!nonewline) {
00320
00321 *te++ = '\n';
00322 *te = '\0';
00323
00324 }
00325 rpmMessage(RPMMESS_NORMAL, "%s", t);
00326 }
00327 t = _free(t);
00328
00329 fi = rpmfiFree(fi);
00330 return rc;
00331 }
00332
00333 void rpmDisplayQueryTags(FILE * fp)
00334 {
00335 const struct headerTagTableEntry_s * t;
00336 int i;
00337 const struct headerSprintfExtension_s * ext = rpmHeaderFormats;
00338
00339 for (i = 0, t = rpmTagTable; i < rpmTagTableSize; i++, t++)
00340 if (t->name) fprintf(fp, "%s\n", t->name + 7);
00341
00342 while (ext->name != NULL) {
00343 if (ext->type == HEADER_EXT_MORE) {
00344 ext = ext->u.more;
00345 continue;
00346 }
00347
00348 for (i = 0, t = rpmTagTable; i < rpmTagTableSize; i++, t++) {
00349 if (t->name == NULL)
00350 continue;
00351 if (!strcmp(t->name, ext->name))
00352 break;
00353 }
00354 if (i >= rpmTagTableSize && ext->type == HEADER_EXT_TAG)
00355 fprintf(fp, "%s\n", ext->name + 7);
00356 ext++;
00357 }
00358 }
00359
00360 int rpmcliShowMatches(QVA_t qva, rpmts ts)
00361 {
00362 Header h;
00363 int ec = 0;
00364
00365 while ((h = rpmdbNextIterator(qva->qva_mi)) != NULL) {
00366 int rc;
00367 if ((rc = qva->qva_showPackage(qva, ts, h)) != 0)
00368 ec = rc;
00369 }
00370 qva->qva_mi = rpmdbFreeIterator(qva->qva_mi);
00371 return ec;
00372 }
00373
00379 static inline unsigned char nibble(char c)
00380
00381 {
00382 if (c >= '0' && c <= '9')
00383 return (c - '0');
00384 if (c >= 'A' && c <= 'F')
00385 return (c - 'A') + 10;
00386 if (c >= 'a' && c <= 'f')
00387 return (c - 'a') + 10;
00388 return 0;
00389 }
00390
00391
00392 int rpmQueryVerify(QVA_t qva, rpmts ts, const char * arg)
00393 {
00394 const char ** av = NULL;
00395 int res = 0;
00396 Header h;
00397 int rc;
00398 const char * s;
00399 int i;
00400 int provides_checked = 0;
00401
00402 (void) rpmdbCheckSignals();
00403
00404 if (qva->qva_showPackage == NULL)
00405 return 1;
00406
00407
00408 switch (qva->qva_source) {
00409 case RPMQV_RPM:
00410 { int ac = 0;
00411 const char * fileURL = NULL;
00412 rpmRC rpmrc;
00413
00414 rc = rpmGlob(arg, &ac, &av);
00415 if (rc) return 1;
00416
00417 restart:
00418 for (i = 0; i < ac; i++) {
00419 FD_t fd;
00420
00421 fileURL = _free(fileURL);
00422 fileURL = av[i];
00423 av[i] = NULL;
00424
00425
00426 fd = Fopen(fileURL, "r.ufdio");
00427 if (fd == NULL || Ferror(fd)) {
00428 rpmError(RPMERR_OPEN, _("open of %s failed: %s\n"), fileURL,
00429 Fstrerror(fd));
00430 if (fd != NULL) (void) Fclose(fd);
00431 res = 1;
00432 break;
00433 }
00434
00435 rpmrc = rpmReadPackageFile(ts, fd, fileURL, &h);
00436
00437 (void) Fclose(fd);
00438
00439 res = 0;
00440 switch (rpmrc) {
00441 default:
00442 #ifdef DYING
00443 rpmError(RPMERR_QUERY, _("query of %s failed\n"), fileURL);
00444 #endif
00445 res = 1;
00446 break;
00447 case RPMRC_NOTTRUSTED:
00448 case RPMRC_NOKEY:
00449 case RPMRC_OK:
00450 if (h == NULL) {
00451 #ifdef DYING
00452 rpmError(RPMERR_QUERY,
00453 _("old format source packages cannot be queried\n"));
00454 #endif
00455 res = 1;
00456 break;
00457 }
00458
00459
00460 res = qva->qva_showPackage(qva, ts, h);
00461 h = headerFree(h);
00462 rpmtsEmpty(ts);
00463 continue;
00464 break;
00465 case RPMRC_NOTFOUND:
00466 res = 0;
00467 break;
00468 }
00469 if (res)
00470 break;
00471
00472
00473 fd = Fopen(fileURL, "r.fpio");
00474 if (fd == NULL || Ferror(fd)) {
00475 rpmError(RPMERR_OPEN, _("open of %s failed: %s\n"), fileURL,
00476 Fstrerror(fd));
00477 if (fd != NULL) (void) Fclose(fd);
00478 res = 1;
00479 break;
00480 }
00481
00482
00483
00484 res = rpmReadPackageManifest(fd, &ac, &av);
00485
00486 if (res != RPMRC_OK) {
00487 rpmError(RPMERR_MANIFEST,
00488 _("%s: not an rpm package (or package manifest): %s\n"),
00489 fileURL, Fstrerror(fd));
00490 res = 1;
00491 }
00492 (void) Fclose(fd);
00493
00494
00495 if (res == 0)
00496 goto restart;
00497
00498 break;
00499 }
00500
00501 fileURL = _free(fileURL);
00502 if (av) {
00503 for (i = 0; i < ac; i++)
00504 av[i] = _free(av[i]);
00505 av = _free(av);
00506 }
00507 } break;
00508
00509 case RPMQV_SPECFILE:
00510 res = ((qva->qva_specQuery != NULL)
00511 ? qva->qva_specQuery(ts, qva, arg) : 1);
00512 break;
00513
00514 case RPMQV_ALL:
00515 qva->qva_mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES, NULL, 0);
00516 if (qva->qva_mi == NULL) {
00517 rpmError(RPMERR_QUERYINFO, _("no packages\n"));
00518 res = 1;
00519 } else {
00520 if (arg != NULL)
00521 for (av = (const char **) arg; *av != NULL; av++) {
00522 int tag = RPMTAG_NAME;
00523 const char * pat;
00524 char * a, * ae;
00525
00526 pat = a = xstrdup(*av);
00527 tag = RPMTAG_NAME;
00528
00529
00530 if ((ae = strchr(a, '=')) != NULL) {
00531 *ae++ = '\0';
00532 tag = tagValue(a);
00533 if (tag < 0) {
00534 rpmError(RPMERR_QUERYINFO,
00535 _("unknown tag: \"%s\"\n"), a);
00536 res = 1;
00537 }
00538 pat = ae;
00539 }
00540
00541 if (!res)
00542 res = rpmdbSetIteratorRE(qva->qva_mi, tag, RPMMIRE_DEFAULT, pat);
00543 a = _free(a);
00544
00545 if (res == 0)
00546 continue;
00547
00548 qva->qva_mi = rpmdbFreeIterator(qva->qva_mi);
00549 res = 1;
00550 break;
00551 }
00552 if (!res)
00553 res = rpmcliShowMatches(qva, ts);
00554 }
00555 break;
00556
00557 case RPMQV_GROUP:
00558 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_GROUP, arg, 0);
00559 if (qva->qva_mi == NULL) {
00560 rpmError(RPMERR_QUERYINFO,
00561 _("group %s does not contain any packages\n"), arg);
00562 res = 1;
00563 } else
00564 res = rpmcliShowMatches(qva, ts);
00565 break;
00566
00567 case RPMQV_TRIGGEREDBY:
00568 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_TRIGGERNAME, arg, 0);
00569 if (qva->qva_mi == NULL) {
00570 rpmError(RPMERR_QUERYINFO, _("no package triggers %s\n"), arg);
00571 res = 1;
00572 } else
00573 res = rpmcliShowMatches(qva, ts);
00574 break;
00575
00576 case RPMQV_PKGID:
00577 { unsigned char MD5[16];
00578 unsigned char * t;
00579
00580 for (i = 0, s = arg; *s && isxdigit(*s); s++, i++)
00581 {};
00582 if (i != 32) {
00583 rpmError(RPMERR_QUERYINFO, _("malformed %s: %s\n"), "pkgid", arg);
00584 return 1;
00585 }
00586
00587 MD5[0] = '\0';
00588 for (i = 0, t = MD5, s = arg; i < 16; i++, t++, s += 2)
00589 *t = (nibble(s[0]) << 4) | nibble(s[1]);
00590
00591 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_SIGMD5, MD5, sizeof(MD5));
00592 if (qva->qva_mi == NULL) {
00593 rpmError(RPMERR_QUERYINFO, _("no package matches %s: %s\n"),
00594 "pkgid", arg);
00595 res = 1;
00596 } else
00597 res = rpmcliShowMatches(qva, ts);
00598 } break;
00599
00600 case RPMQV_HDRID:
00601 for (i = 0, s = arg; *s && isxdigit(*s); s++, i++)
00602 {};
00603 if (i != 40) {
00604 rpmError(RPMERR_QUERYINFO, _("malformed %s: %s\n"), "hdrid", arg);
00605 return 1;
00606 }
00607
00608 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_SHA1HEADER, arg, 0);
00609 if (qva->qva_mi == NULL) {
00610 rpmError(RPMERR_QUERYINFO, _("no package matches %s: %s\n"),
00611 "hdrid", arg);
00612 res = 1;
00613 } else
00614 res = rpmcliShowMatches(qva, ts);
00615 break;
00616
00617 case RPMQV_FILEID:
00618 { unsigned char MD5[16];
00619 unsigned char * t;
00620
00621 for (i = 0, s = arg; *s && isxdigit(*s); s++, i++)
00622 {};
00623 if (i != 32) {
00624 rpmError(RPMERR_QUERY, _("malformed %s: %s\n"), "fileid", arg);
00625 return 1;
00626 }
00627
00628 MD5[0] = '\0';
00629 for (i = 0, t = MD5, s = arg; i < 16; i++, t++, s += 2)
00630 *t = (nibble(s[0]) << 4) | nibble(s[1]);
00631
00632 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_FILEMD5S, MD5, sizeof(MD5));
00633 if (qva->qva_mi == NULL) {
00634 rpmError(RPMERR_QUERYINFO, _("no package matches %s: %s\n"),
00635 "fileid", arg);
00636 res = 1;
00637 } else
00638 res = rpmcliShowMatches(qva, ts);
00639 } break;
00640
00641 case RPMQV_TID:
00642 { int mybase = 10;
00643 const char * myarg = arg;
00644 char * end = NULL;
00645 unsigned iid;
00646
00647
00648 if (*myarg == '0') {
00649 myarg++;
00650 mybase = 8;
00651 if (*myarg == 'x') {
00652 myarg++;
00653 mybase = 16;
00654 }
00655 }
00656 iid = strtoul(myarg, &end, mybase);
00657 if ((*end) || (end == arg) || (iid == ULONG_MAX)) {
00658 rpmError(RPMERR_QUERY, _("malformed %s: %s\n"), "tid", arg);
00659 return 1;
00660 }
00661 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_INSTALLTID, &iid, sizeof(iid));
00662 if (qva->qva_mi == NULL) {
00663 rpmError(RPMERR_QUERYINFO, _("no package matches %s: %s\n"),
00664 "tid", arg);
00665 res = 1;
00666 } else
00667 res = rpmcliShowMatches(qva, ts);
00668 } break;
00669
00670 case RPMQV_WHATREQUIRES:
00671 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_REQUIRENAME, arg, 0);
00672 if (qva->qva_mi == NULL) {
00673 rpmError(RPMERR_QUERYINFO, _("no package requires %s\n"), arg);
00674 res = 1;
00675 } else
00676 res = rpmcliShowMatches(qva, ts);
00677 break;
00678
00679 case RPMQV_WHATPROVIDES:
00680 if (arg[0] != '/') {
00681 provides_checked = 1;
00682 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_PROVIDENAME, arg, 0);
00683 if (qva->qva_mi == NULL) {
00684 rpmError(RPMERR_QUERYINFO, _("no package provides %s\n"), arg);
00685 res = 1;
00686 } else
00687 res = rpmcliShowMatches(qva, ts);
00688 break;
00689 }
00690
00691 case RPMQV_PATH:
00692 { char * fn;
00693 int myerrno = 0;
00694
00695 for (s = arg; *s != '\0'; s++)
00696 if (!(*s == '.' || *s == '/'))
00697 break;
00698
00699 if (*s == '\0') {
00700 char fnbuf[PATH_MAX];
00701 fn = realpath(arg, fnbuf);
00702 if (fn)
00703 fn = xstrdup(fn);
00704 else
00705 fn = xstrdup(arg);
00706 } else
00707 fn = xstrdup(arg);
00708 (void) rpmCleanPath(fn);
00709
00710 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_BASENAMES, fn, 0);
00711 if (qva->qva_mi == NULL) {
00712 if (access(fn, F_OK) != 0)
00713 myerrno = errno;
00714 else if (!provides_checked)
00715 qva->qva_mi = rpmtsInitIterator(ts, RPMTAG_PROVIDENAME, fn, 0);
00716 }
00717
00718 if (myerrno != 0) {
00719 rpmError(RPMERR_QUERY, _("file %s: %s\n"), fn, strerror(myerrno));
00720 res = 1;
00721 } else if (qva->qva_mi == NULL) {
00722 rpmError(RPMERR_QUERYINFO,
00723 _("file %s is not owned by any package\n"), fn);
00724 res = 1;
00725 } else
00726 res = rpmcliShowMatches(qva, ts);
00727
00728 fn = _free(fn);
00729 } break;
00730
00731 case RPMQV_DBOFFSET:
00732 { int mybase = 10;
00733 const char * myarg = arg;
00734 char * end = NULL;
00735 unsigned recOffset;
00736
00737
00738 if (*myarg == '0') {
00739 myarg++;
00740 mybase = 8;
00741 if (*myarg == 'x') {
00742 myarg++;
00743 mybase = 16;
00744 }
00745 }
00746 recOffset = strtoul(myarg, &end, mybase);
00747 if ((*end) || (end == arg) || (recOffset == ULONG_MAX)) {
00748 rpmError(RPMERR_QUERYINFO, _("invalid package number: %s\n"), arg);
00749 return 1;
00750 }
00751 rpmMessage(RPMMESS_DEBUG, _("package record number: %u\n"), recOffset);
00752
00753 qva->qva_mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES, &recOffset, sizeof(recOffset));
00754 if (qva->qva_mi == NULL) {
00755 rpmError(RPMERR_QUERYINFO,
00756 _("record %u could not be read\n"), recOffset);
00757 res = 1;
00758 } else
00759 res = rpmcliShowMatches(qva, ts);
00760 } break;
00761
00762 case RPMQV_PACKAGE:
00763
00764 qva->qva_mi = rpmtsInitIterator(ts, RPMDBI_LABEL, arg, 0);
00765 if (qva->qva_mi == NULL) {
00766 rpmError(RPMERR_QUERYINFO, _("package %s is not installed\n"), arg);
00767 res = 1;
00768 } else
00769 res = rpmcliShowMatches(qva, ts);
00770 break;
00771 }
00772
00773
00774 return res;
00775 }
00776
00777
00778 int rpmcliQuery(rpmts ts, QVA_t qva, const char ** argv)
00779 {
00780 const char * arg;
00781 rpmVSFlags vsflags, ovsflags;
00782 int ec = 0;
00783
00784 if (qva->qva_showPackage == NULL)
00785 qva->qva_showPackage = showQueryPackage;
00786
00787
00788 if (!(qva->qva_flags & _QUERY_FOR_BITS) && qva->qva_queryFormat == NULL) {
00789 qva->qva_queryFormat = rpmExpand("%{?_query_all_fmt}\n", NULL);
00790 if (!(qva->qva_queryFormat != NULL && *qva->qva_queryFormat != '\0')) {
00791 qva->qva_queryFormat = _free(qva->qva_queryFormat);
00792 qva->qva_queryFormat = xstrdup("%{name}-%{version}-%{release}\n");
00793 }
00794 }
00795
00796 vsflags = rpmExpandNumeric("%{?_vsflags_query}");
00797 if (qva->qva_flags & VERIFY_DIGEST)
00798 vsflags |= _RPMVSF_NODIGESTS;
00799 if (qva->qva_flags & VERIFY_SIGNATURE)
00800 vsflags |= _RPMVSF_NOSIGNATURES;
00801 if (qva->qva_flags & VERIFY_HDRCHK)
00802 vsflags |= RPMVSF_NOHDRCHK;
00803
00804 ovsflags = rpmtsSetVSFlags(ts, vsflags);
00805 if (qva->qva_source == RPMQV_ALL) {
00806
00807 ec = rpmQueryVerify(qva, ts, (const char *) argv);
00808
00809 } else {
00810
00811 if (argv != NULL)
00812 while ((arg = *argv++) != NULL) {
00813 ec += rpmQueryVerify(qva, ts, arg);
00814 rpmtsEmpty(ts);
00815 }
00816
00817 }
00818 vsflags = rpmtsSetVSFlags(ts, ovsflags);
00819
00820 if (qva->qva_showPackage == showQueryPackage)
00821 qva->qva_showPackage = NULL;
00822
00823 return ec;
00824 }