00001
00004 #include "system.h"
00005
00006 #if defined(WITH_CPUINFO)
00007 #include <cpuinfo.h>
00008 #endif
00009
00010 #if defined(HAVE_GELF_H) && !defined(__FreeBSD__)
00011 #if LIBELF_H_LFS_CONFLICT
00012
00013
00014
00015 # undef _LARGEFILE64_SOURCE
00016 # undef _LARGEFILE_SOURCE
00017 # undef _FILE_OFFSET_BITS
00018 # define _FILE_OFFSET_BITS 32
00019 #endif
00020
00021 #if defined(__LCLINT__)
00022 typedef long long loff_t;
00023 #endif
00024 #include <gelf.h>
00025
00026
00027
00028
00029
00030
00031 #if defined(__sun)
00032 #if defined(ENABLE_NLS) && !defined(__LCLINT__)
00033 # define _(Text) gettext (Text)
00034 #else
00035 # define _(Text) Text
00036 #endif
00037 #endif
00038 #endif
00039
00040 #if defined(HAVE_LIBELF) && !defined(HAVE_GELF_GETVERNAUX) && !defined(__FreeBSD__)
00041
00042
00043
00044
00045
00046 static GElf_Verdef *gelf_getverdef(Elf_Data *data, int offset,
00047 GElf_Verdef *dst)
00048 {
00049 return (GElf_Verdef *) ((char *) data->d_buf + offset);
00050 }
00051
00052 static GElf_Verdaux *gelf_getverdaux(Elf_Data *data, int offset,
00053 GElf_Verdaux *dst)
00054 {
00055 return (GElf_Verdaux *) ((char *) data->d_buf + offset);
00056 }
00057
00058 static GElf_Verneed *gelf_getverneed(Elf_Data *data, int offset,
00059 GElf_Verneed *dst)
00060 {
00061 return (GElf_Verneed *) ((char *) data->d_buf + offset);
00062 }
00063
00064 static GElf_Vernaux *gelf_getvernaux(Elf_Data *data, int offset,
00065 GElf_Vernaux *dst)
00066 {
00067 return (GElf_Vernaux *) ((char *) data->d_buf + offset);
00068 }
00069
00070
00071
00072
00073
00074 #if !defined(SHT_GNU_verdef) && defined(__sun) && defined(SHT_SUNW_verdef)
00075 # define SHT_GNU_verdef SHT_SUNW_verdef
00076 # define SHT_GNU_verneed SHT_SUNW_verneed
00077 #endif
00078
00079 #endif
00080
00081 #if !defined(DT_GNU_HASH)
00082 #define DT_GNU_HASH 0x6ffffef5
00083 #endif
00084
00085 #define _RPMIOB_INTERNAL
00086 #include <rpmiotypes.h>
00087 #include <rpmio_internal.h>
00088 #include <rpmcb.h>
00089 #include <rpmmacro.h>
00090 #include <argv.h>
00091
00092 #include <rpmtypes.h>
00093 #include <rpmtag.h>
00094
00095 #define _RPMDS_INTERNAL
00096 #define _RPMEVR_INTERNAL
00097 #define _RPMPRCO_INTERNAL
00098 #include <rpmds.h>
00099
00100 #include "debug.h"
00101
00102
00103
00104
00105 #define _isspace(_c) \
00106 ((_c) == ' ' || (_c) == '\t' || (_c) == '\r' || (_c) == '\n')
00107
00111
00112 static int _noisy_range_comparison_debug_message = 0;
00113
00114
00115 int _rpmds_debug = 0;
00116
00117
00118 int _rpmds_nopromote = 1;
00119
00120
00121
00122 int _rpmds_unspecified_epoch_noise = 0;
00123
00124
00130
00131 static const char * rpmdsTagName(rpmTag tagN)
00132
00133 {
00134 const char * Type;
00135
00136
00137 switch (tagN) {
00138 default: Type = tagName(tagN); break;
00139 case RPMTAG_PROVIDENAME: Type = "Provides"; break;
00140 case RPMTAG_REQUIRENAME: Type = "Requires"; break;
00141 case RPMTAG_CONFLICTNAME: Type = "Conflicts"; break;
00142 case RPMTAG_OBSOLETENAME: Type = "Obsoletes"; break;
00143 case RPMTAG_TRIGGERNAME: Type = "Triggers"; break;
00144 case RPMTAG_SUGGESTSNAME: Type = "Suggests"; break;
00145 case RPMTAG_ENHANCESNAME: Type = "Enhances"; break;
00146 case RPMTAG_DIRNAMES: Type = "Dirs"; break;
00147 case RPMTAG_BASENAMES: Type = "Files"; break;
00148 case RPMTAG_FILELINKTOS: Type = "Linktos"; break;
00149 case 0: Type = "Unknown"; break;
00150 }
00151 return Type;
00152 }
00153
00154 const char * rpmdsType(const rpmds ds)
00155 {
00156 return rpmdsTagName(rpmdsTagN(ds));
00157 }
00158
00159 static void rpmdsFini(void * _ds)
00160 {
00161 rpmds ds = _ds;
00162
00163 if (ds->Count > 0) {
00164 ds->N = _free(ds->N);
00165 ds->EVR = _free(ds->EVR);
00166 ds->Flags = _free(ds->Flags);
00167 (void)headerFree(ds->h);
00168 ds->h = NULL;
00169 }
00170
00171 ds->DNEVR = _free(ds->DNEVR);
00172 ds->ns.str = _free(ds->ns.str);
00173 memset(&ds->ns, 0, sizeof(ds->ns));
00174 ds->A = _free(ds->A);
00175 ds->Color = _free(ds->Color);
00176 ds->Refs = _free(ds->Refs);
00177 ds->Result = _free(ds->Result);
00178 ds->exclude = mireFreeAll(ds->exclude, ds->nexclude);
00179 ds->include = mireFreeAll(ds->include, ds->ninclude);
00180 }
00181
00182
00183 rpmioPool _rpmdsPool;
00184
00185 static rpmds rpmdsGetPool( rpmioPool pool)
00186
00187
00188 {
00189 rpmds ds;
00190
00191 if (_rpmdsPool == NULL) {
00192 _rpmdsPool = rpmioNewPool("ds", sizeof(*ds), -1, _rpmds_debug,
00193 NULL, NULL, rpmdsFini);
00194 pool = _rpmdsPool;
00195 }
00196 return (rpmds) rpmioGetPool(pool, sizeof(*ds));
00197 }
00198
00199 static
00200 const char ** rpmdsDupArgv( const char ** argv, int argc)
00201
00202 {
00203 const char ** av;
00204 size_t nb = 0;
00205 int ac = 0;
00206 char * t;
00207
00208 if (argv == NULL)
00209 return NULL;
00210 for (ac = 0; ac < argc; ac++) {
00211 assert(argv[ac] != NULL);
00212 nb += strlen(argv[ac]) + 1;
00213 }
00214 nb += (ac + 1) * sizeof(*av);
00215
00216 av = xmalloc(nb);
00217 t = (char *) (av + ac + 1);
00218 for (ac = 0; ac < argc; ac++) {
00219 av[ac] = t;
00220 t = stpcpy(t, argv[ac]) + 1;
00221 }
00222 av[ac] = NULL;
00223
00224 return av;
00225
00226 }
00227
00228 rpmds rpmdsNew(Header h, rpmTag tagN, int flags)
00229 {
00230 int scareMem = (flags & 0x1);
00231 int delslash = 1;
00232 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00233 rpmTag tagEVR, tagF;
00234 rpmds ds = NULL;
00235 const char * Type = NULL;
00236 const char ** N;
00237 rpmuint32_t Count;
00238 int xx;
00239
00240 assert(scareMem == 0);
00241
00242 if (tagN == RPMTAG_NAME)
00243 return rpmdsThis(h, tagN, RPMSENSE_EQUAL);
00244
00245 switch (tagN) {
00246 default:
00247 goto exit;
00248 break;
00249 case RPMTAG_PROVIDENAME:
00250 tagEVR = RPMTAG_PROVIDEVERSION;
00251 tagF = RPMTAG_PROVIDEFLAGS;
00252 break;
00253 case RPMTAG_REQUIRENAME:
00254 tagEVR = RPMTAG_REQUIREVERSION;
00255 tagF = RPMTAG_REQUIREFLAGS;
00256 break;
00257 case RPMTAG_CONFLICTNAME:
00258 tagEVR = RPMTAG_CONFLICTVERSION;
00259 tagF = RPMTAG_CONFLICTFLAGS;
00260 break;
00261 case RPMTAG_OBSOLETENAME:
00262 tagEVR = RPMTAG_OBSOLETEVERSION;
00263 tagF = RPMTAG_OBSOLETEFLAGS;
00264 break;
00265 case RPMTAG_TRIGGERNAME:
00266 tagEVR = RPMTAG_TRIGGERVERSION;
00267 tagF = RPMTAG_TRIGGERFLAGS;
00268 break;
00269 case RPMTAG_SUGGESTSNAME:
00270 tagEVR = RPMTAG_SUGGESTSVERSION;
00271 tagF = RPMTAG_SUGGESTSFLAGS;
00272 break;
00273 case RPMTAG_ENHANCESNAME:
00274 tagEVR = RPMTAG_ENHANCESVERSION;
00275 tagF = RPMTAG_ENHANCESFLAGS;
00276 break;
00277 case RPMTAG_DIRNAMES:
00278 tagEVR = 0;
00279 tagF = 0;
00280 delslash = (flags & 0x2) ? 0 : 1;
00281 break;
00282 case RPMTAG_BASENAMES:
00283 tagEVR = RPMTAG_DIRNAMES;
00284 tagF = RPMTAG_DIRINDEXES;
00285 break;
00286 case RPMTAG_FILELINKTOS:
00287 tagEVR = RPMTAG_DIRNAMES;
00288 tagF = RPMTAG_DIRINDEXES;
00289 break;
00290 }
00291
00292 if (Type == NULL)
00293 Type = rpmdsTagName(tagN);
00294
00295 he->tag = tagN;
00296 xx = headerGet(h, he, 0);
00297 N = he->p.argv;
00298 Count = he->c;
00299 if (xx && N != NULL && Count > 0) {
00300 ds = rpmdsGetPool(_rpmdsPool);
00301 ds->Type = Type;
00302 ds->h = NULL;
00303 ds->i = -1;
00304 ds->DNEVR = NULL;
00305 ds->tagN = tagN;
00306 ds->N = N;
00307 ds->Count = Count;
00308 ds->nopromote = _rpmds_nopromote;
00309
00310 if (tagEVR > 0) {
00311 he->tag = tagEVR;
00312 xx = headerGet(h, he, 0);
00313 ds->EVR = he->p.argv;
00314 }
00315 if (tagF > 0) {
00316 he->tag = tagF;
00317 xx = headerGet(h, he, 0);
00318 ds->Flags = (evrFlags * ) he->p.ui32p;
00319 }
00320 {
00321 he->tag = RPMTAG_ARCH;
00322 xx = headerGet(h, he, 0);
00323 ds->A = he->p.str;
00324 }
00325 {
00326 he->tag = RPMTAG_BUILDTIME;
00327 xx = headerGet(h, he, 0);
00328 ds->BT = (he->p.ui32p ? he->p.ui32p[0] : 0);
00329 he->p.ptr = _free(he->p.ptr);
00330 }
00331
00332 if (tagN == RPMTAG_DIRNAMES) {
00333 char * dn;
00334 size_t len;
00335 unsigned i;
00336
00337 if (delslash)
00338 for (i = 0; i < Count; i++) {
00339 (void) urlPath(N[i], (const char **)&dn);
00340 if (dn > N[i])
00341 N[i] = dn;
00342 dn = (char *)N[i];
00343 len = strlen(dn);
00344
00345 if (len > 1 && dn[len-1] == '/')
00346 dn[len-1] = '\0';
00347 }
00348 } else
00349 if (tagN == RPMTAG_BASENAMES) {
00350 const char ** av = xcalloc(Count+1, sizeof(*av));
00351 char * dn;
00352 unsigned i;
00353
00354 for (i = 0; i < Count; i++) {
00355 (void) urlPath(ds->EVR[ds->Flags[i]], (const char **)&dn);
00356 av[i] = rpmGenPath(NULL, dn, N[i]);
00357 }
00358 av[Count] = NULL;
00359
00360
00361 N = ds->N = _free(ds->N);
00362
00363 N = ds->N = rpmdsDupArgv(av, Count);
00364 av = argvFree(av);
00365 ds->EVR = _free(ds->EVR);
00366 ds->Flags = _free(ds->Flags);
00367 } else
00368 if (tagN == RPMTAG_FILELINKTOS) {
00369
00370 const char ** av = xcalloc(Count+1, sizeof(*av));
00371 unsigned i;
00372
00373 for (i = 0; i < Count; i++) {
00374 if (N[i] == NULL || *N[i] == '\0')
00375 av[i] = xstrdup("");
00376 else if (*N[i] == '/')
00377 av[i] = xstrdup(N[i]);
00378 else if (ds->EVR != NULL && ds->Flags != NULL)
00379 av[i] = rpmGenPath(NULL, ds->EVR[ds->Flags[i]], N[i]);
00380 else
00381 av[i] = xstrdup("");
00382 }
00383 av[Count] = NULL;
00384
00385
00386 N = ds->N = _free(ds->N);
00387
00388 N = ds->N = rpmdsDupArgv(av, Count);
00389 av = argvFree(av);
00390 ds->EVR = _free(ds->EVR);
00391 ds->Flags = _free(ds->Flags);
00392 }
00393
00394
00395 if (_rpmds_debug < 0)
00396 fprintf(stderr, "*** ds %p\t%s[%d]\n", ds, ds->Type, ds->Count);
00397
00398
00399 }
00400
00401 exit:
00402
00403
00404 ds = rpmdsLink(ds, (ds ? ds->Type : NULL));
00405
00406
00407 return ds;
00408
00409 }
00410
00411 const char * rpmdsNewN(rpmds ds)
00412 {
00413 rpmns ns = &ds->ns;
00414 const char * Name = ds->N[ds->i];
00415 int xx;
00416
00417 memset(ns, 0, sizeof(*ns));
00418 xx = rpmnsParse(Name, ns);
00419
00420
00421 return ns->N;
00422
00423 }
00424
00425 char * rpmdsNewDNEVR(const char * dspfx, rpmds ds)
00426 {
00427 const char * N = rpmdsNewN(ds);
00428 const char * NS = ds->ns.NS;
00429 const char * A = ds->ns.A;
00430 evrFlags dsFlags = 0;
00431 char * tbuf, * t;
00432 size_t nb = 0;
00433
00434 if (dspfx) nb += strlen(dspfx) + 1;
00435 if (ds->ns.str[0] == '!') nb++;
00436 if (NS) nb += strlen(NS) + sizeof("()") - 1;
00437 if (N) nb += strlen(N);
00438 if (A) {
00439 if (_rpmns_N_at_A && _rpmns_N_at_A[0])
00440 nb += sizeof(_rpmns_N_at_A[0]);
00441 nb += strlen(A);
00442 }
00443
00444 if (ds->Flags != NULL
00445 && (dsFlags = (ds->Flags[ds->i] & RPMSENSE_SENSEMASK)))
00446 {
00447 if (nb) nb++;
00448 if (dsFlags == RPMSENSE_NOTEQUAL)
00449 nb += 2;
00450 else {
00451 if (dsFlags & RPMSENSE_LESS) nb++;
00452 if (dsFlags & RPMSENSE_GREATER) nb++;
00453 if (dsFlags & RPMSENSE_EQUAL) nb++;
00454 }
00455 }
00456
00457 ds->ns.Flags = dsFlags;
00458
00459
00460 if (ds->EVR != NULL && ds->EVR[ds->i] && *ds->EVR[ds->i]) {
00461 if (nb) nb++;
00462 nb += strlen(ds->EVR[ds->i]);
00463 }
00464
00465 t = tbuf = xmalloc(nb + 1);
00466 if (dspfx) {
00467 t = stpcpy(t, dspfx);
00468 *t++ = ' ';
00469 }
00470 if (ds->ns.str[0] == '!')
00471 *t++ = '!';
00472 if (NS)
00473 t = stpcpy( stpcpy(t, NS), "(");
00474 if (N)
00475 t = stpcpy(t, N);
00476 if (NS)
00477 t = stpcpy(t, ")");
00478 if (A) {
00479 if (_rpmns_N_at_A && _rpmns_N_at_A[0])
00480 *t++ = _rpmns_N_at_A[0];
00481 t = stpcpy(t, A);
00482 }
00483
00484
00485 if (ds->Flags != NULL && (ds->Flags[ds->i] & RPMSENSE_SENSEMASK)) {
00486 if (t != tbuf) *t++ = ' ';
00487 if (dsFlags == RPMSENSE_NOTEQUAL)
00488 t = stpcpy(t, "!=");
00489 else {
00490 if (dsFlags & RPMSENSE_LESS) *t++ = '<';
00491 if (dsFlags & RPMSENSE_GREATER) *t++ = '>';
00492 if (dsFlags & RPMSENSE_EQUAL) *t++ = '=';
00493 }
00494 }
00495
00496 if (ds->EVR != NULL && ds->EVR[ds->i] && *ds->EVR[ds->i]) {
00497 if (t != tbuf) *t++ = ' ';
00498 t = stpcpy(t, ds->EVR[ds->i]);
00499 }
00500 *t = '\0';
00501 return tbuf;
00502 }
00503
00504 rpmds rpmdsThis(Header h, rpmTag tagN, evrFlags Flags)
00505 {
00506 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00507 rpmds ds = NULL;
00508 const char * Type;
00509 const char * Name, * V, * R;
00510 #ifdef RPM_VENDOR_MANDRIVA
00511 const char * D = NULL;
00512 #endif
00513 rpmuint32_t E;
00514 const char ** N, ** EVR;
00515 char * t;
00516 size_t nb;
00517 int xx;
00518
00519 if (tagN == RPMTAG_NAME)
00520 tagN = RPMTAG_PROVIDENAME;
00521
00522 Type = rpmdsTagName(tagN);
00523
00524 he->tag = RPMTAG_EPOCH;
00525 xx = headerGet(h, he, 0);
00526 E = (he->p.ui32p ? he->p.ui32p[0] : 0);
00527 he->p.ptr = _free(he->p.ptr);
00528
00529 #if defined(NOTYET) || defined(RPM_VENDOR_MANDRIVA)
00530 he->tag = RPMTAG_DISTEPOCH;
00531 xx = headerGet(h, he, 0);
00532 D = (he->p.str ? he->p.str : NULL);
00533 #endif
00534
00535 xx = headerNEVRA(h, &Name, NULL, &V, &R, NULL);
00536
00537
00538 t = xmalloc(sizeof(*N) + strlen(Name) + 1);
00539 N = (const char **) t;
00540 t += sizeof(*N);
00541 *t = '\0';
00542 N[0] = t;
00543 t = stpcpy(t, Name);
00544 Name = _free(Name);
00545
00546 nb = sizeof(*EVR) + 20 + strlen(V) + strlen(R) + sizeof("-");
00547 #ifdef RPM_VENDOR_MANDRIVA
00548 nb += (D ? strlen(D) + sizeof(":") : 0);
00549 #endif
00550 t = xmalloc(nb);
00551 EVR = (const char **) t;
00552 t += sizeof(*EVR);
00553 *t = '\0';
00554 EVR[0] = t;
00555 sprintf(t, "%d:", E);
00556 t += strlen(t);
00557 t = stpcpy( stpcpy( stpcpy( t, V), "-"), R);
00558 #ifdef RPM_VENDOR_MANDRIVA
00559 if (D != NULL) {
00560 t = stpcpy( stpcpy( t, ":"), D);
00561 D = _free(D);
00562 }
00563 #endif
00564 V = _free(V);
00565 R = _free(R);
00566
00567 ds = rpmdsGetPool(_rpmdsPool);
00568 ds->Type = Type;
00569 ds->tagN = tagN;
00570 ds->Count = 1;
00571 ds->N = N;
00572 ds->EVR = EVR;
00573 ds->Flags = xmalloc(sizeof(*ds->Flags)); ds->Flags[0] = Flags;
00574
00575 he->tag = RPMTAG_ARCH;
00576 xx = headerGet(h, he, 0);
00577 ds->A = he->p.str;
00578
00579 he->tag = RPMTAG_BUILDTIME;
00580 xx = headerGet(h, he, 0);
00581 ds->BT = (he->p.ui32p ? he->p.ui32p[0] : 0);
00582 he->p.ptr = _free(he->p.ptr);
00583
00584 { char pre[2];
00585 pre[0] = ds->Type[0];
00586 pre[1] = '\0';
00587
00588 ds->i = 0;
00589 ds->DNEVR = rpmdsNewDNEVR(pre, ds);
00590
00591 }
00592
00593 return rpmdsLink(ds, (ds ? ds->Type : NULL));
00594 }
00595
00596 rpmds rpmdsSingle(rpmTag tagN, const char * N, const char * EVR, evrFlags Flags)
00597 {
00598 rpmds ds = rpmdsGetPool(_rpmdsPool);
00599 const char * Type = rpmdsTagName(tagN);
00600
00601 ds->Type = Type;
00602 ds->tagN = tagN;
00603 ds->A = NULL;
00604 { time_t now = time(NULL);
00605 ds->BT = (rpmuint32_t)now;
00606 }
00607 ds->Count = 1;
00608
00609 ds->N = xcalloc(2, sizeof(*ds->N)); ds->N[0] = N;
00610 ds->EVR = xcalloc(2, sizeof(*ds->EVR)); ds->EVR[0] = EVR;
00611
00612 ds->Flags = xmalloc(sizeof(*ds->Flags)); ds->Flags[0] = Flags;
00613 { char t[2];
00614 t[0] = ds->Type[0];
00615 t[1] = '\0';
00616 ds->i = 0;
00617 ds->DNEVR = rpmdsNewDNEVR(t, ds);
00618 }
00619
00620 return rpmdsLink(ds, (ds ? ds->Type : NULL));
00621 }
00622
00623 int rpmdsCount(const rpmds ds)
00624 {
00625 return (ds != NULL ? ds->Count : 0);
00626 }
00627
00628 int rpmdsIx(const rpmds ds)
00629 {
00630 return (ds != NULL ? ds->i : -1);
00631 }
00632
00633 int rpmdsSetIx(rpmds ds, int ix)
00634 {
00635 int i = -1;
00636
00637 if (ds != NULL) {
00638 i = ds->i;
00639 ds->i = ix;
00640 }
00641 return i;
00642 }
00643
00644 const char * rpmdsDNEVR(const rpmds ds)
00645 {
00646 const char * DNEVR = NULL;
00647
00648 if (ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count) {
00649 if (ds->DNEVR != NULL)
00650 DNEVR = ds->DNEVR;
00651 }
00652 return DNEVR;
00653 }
00654
00655 const char * rpmdsN(const rpmds ds)
00656 {
00657 const char * N = NULL;
00658
00659 if (ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count) {
00660
00661 N = (ds->ns.N ? ds->ns.N : rpmdsNewN(ds));
00662
00663 }
00664 return N;
00665 }
00666
00667 const char * rpmdsEVR(const rpmds ds)
00668 {
00669 const char * EVR = NULL;
00670
00671 if (ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count) {
00672 if (ds->EVR != NULL)
00673 EVR = ds->EVR[ds->i];
00674 }
00675 return EVR;
00676 }
00677
00678 evrFlags rpmdsFlags(const rpmds ds)
00679 {
00680 evrFlags Flags = 0;
00681
00682 if (ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count) {
00683 if (ds->Flags != NULL)
00684 Flags = ds->Flags[ds->i];
00685 }
00686 return Flags;
00687 }
00688
00689 rpmTag rpmdsTagN(const rpmds ds)
00690 {
00691 rpmTag tagN = 0;
00692
00693 if (ds != NULL)
00694 tagN = ds->tagN;
00695 return tagN;
00696 }
00697
00698 const char * rpmdsA(const rpmds ds)
00699 {
00700 const char * A = NULL;
00701
00702 if (ds != NULL)
00703 A = ds->A;
00704 return A;
00705 }
00706
00707 time_t rpmdsBT(const rpmds ds)
00708 {
00709 time_t BT = 0;
00710 if (ds != NULL && ds->BT > 0)
00711 BT = ds->BT;
00712 return BT;
00713 }
00714
00715 time_t rpmdsSetBT(const rpmds ds, time_t BT)
00716 {
00717 time_t oBT = 0;
00718 if (ds != NULL) {
00719 oBT = (time_t)ds->BT;
00720 ds->BT = (rpmuint32_t)BT;
00721 }
00722 return oBT;
00723 }
00724
00725 nsType rpmdsNSType(const rpmds ds)
00726 {
00727 nsType NSType = RPMNS_TYPE_UNKNOWN;
00728 if (ds != NULL)
00729 NSType = ds->ns.Type;
00730 return NSType;
00731 }
00732
00733 int rpmdsNoPromote(const rpmds ds)
00734 {
00735 int nopromote = 0;
00736
00737 if (ds != NULL)
00738 nopromote = ds->nopromote;
00739 return nopromote;
00740 }
00741
00742 int rpmdsSetNoPromote(rpmds ds, int nopromote)
00743 {
00744 int onopromote = 0;
00745
00746 if (ds != NULL) {
00747 onopromote = ds->nopromote;
00748 ds->nopromote = nopromote;
00749 }
00750 return onopromote;
00751 }
00752
00753 void * rpmdsSetEVRparse(rpmds ds,
00754 int (*EVRparse)(const char *evrstr, EVR_t evr))
00755 {
00756 void * oEVRparse = NULL;
00757
00758 if (ds != NULL) {
00759 oEVRparse = ds->EVRparse;
00760 ds->EVRparse = EVRparse;
00761 }
00762 return oEVRparse;
00763 }
00764
00765 void * rpmdsSetEVRcmp(rpmds ds, int (*EVRcmp)(const char *a, const char *b))
00766 {
00767 void * oEVRcmp = NULL;
00768
00769 if (ds != NULL) {
00770 oEVRcmp = ds->EVRcmp;
00771 ds->EVRcmp = EVRcmp;
00772 }
00773 return oEVRcmp;
00774 }
00775
00776 rpmuint32_t rpmdsColor(const rpmds ds)
00777 {
00778 rpmuint32_t Color = 0;
00779
00780 if (ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count) {
00781 if (ds->Color != NULL)
00782 Color = ds->Color[ds->i];
00783 }
00784 return Color;
00785 }
00786
00787 rpmuint32_t rpmdsSetColor(const rpmds ds, rpmuint32_t color)
00788 {
00789 rpmuint32_t ocolor = 0;
00790
00791 if (ds == NULL)
00792 return ocolor;
00793
00794 if (ds->Color == NULL && ds->Count > 0)
00795 ds->Color = xcalloc(ds->Count, sizeof(*ds->Color));
00796
00797 if (ds->i >= 0 && ds->i < (int)ds->Count) {
00798 if (ds->Color != NULL) {
00799 ocolor = ds->Color[ds->i];
00800 ds->Color[ds->i] = color;
00801 }
00802 }
00803 return ocolor;
00804 }
00805
00806 void * rpmdsExclude(const rpmds ds)
00807 {
00808 return (ds != NULL ? ds->exclude : NULL);
00809 }
00810
00811 int rpmdsNExclude(const rpmds ds)
00812 {
00813 return (ds != NULL ? ds->nexclude : 0);
00814 }
00815
00816 void * rpmdsInclude(const rpmds ds)
00817 {
00818 return (ds != NULL ? ds->include : NULL);
00819 }
00820
00821 int rpmdsNInclude(const rpmds ds)
00822 {
00823 return (ds != NULL ? ds->ninclude : 0);
00824 }
00825
00826 rpmuint32_t rpmdsRefs(const rpmds ds)
00827 {
00828 rpmuint32_t Refs = 0;
00829
00830 if (ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count) {
00831 if (ds->Refs != NULL)
00832 Refs = ds->Refs[ds->i];
00833 }
00834 return Refs;
00835 }
00836
00837 rpmuint32_t rpmdsSetRefs(const rpmds ds, rpmuint32_t refs)
00838 {
00839 rpmuint32_t orefs = 0;
00840
00841 if (ds == NULL)
00842 return orefs;
00843
00844 if (ds->Refs == NULL && ds->Count > 0)
00845 ds->Refs = xcalloc(ds->Count, sizeof(*ds->Refs));
00846
00847 if (ds->i >= 0 && ds->i < (int)ds->Count) {
00848 if (ds->Refs != NULL) {
00849 orefs = ds->Refs[ds->i];
00850 ds->Refs[ds->i] = refs;
00851 }
00852 }
00853 return orefs;
00854 }
00855
00856 rpmint32_t rpmdsResult(const rpmds ds)
00857 {
00858 rpmint32_t result = 0;
00859
00860 if (ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count) {
00861 if (ds->Result != NULL)
00862 result = ds->Result[ds->i];
00863 }
00864 return result;
00865 }
00866
00867 rpmint32_t rpmdsSetResult(const rpmds ds, rpmint32_t result)
00868 {
00869 rpmint32_t oresult = 0;
00870
00871 if (ds == NULL)
00872 return oresult;
00873
00874 if (ds->Result == NULL && ds->Count > 0)
00875 ds->Result = xcalloc(ds->Count, sizeof(*ds->Result));
00876
00877 if (ds->i >= 0 && ds->i < (int)ds->Count) {
00878 if (ds->Result != NULL) {
00879 oresult = ds->Result[ds->i];
00880 ds->Result[ds->i] = result;
00881 }
00882 }
00883 return oresult;
00884 }
00885
00886 void rpmdsNotify(rpmds ds, const char * where, int rc)
00887 {
00888 if (!(ds != NULL && ds->i >= 0 && ds->i < (int)ds->Count))
00889 return;
00890 if (ds->DNEVR == NULL)
00891 return;
00892
00893 rpmlog(RPMLOG_DEBUG, "%9s: %-45s %-s %s\n", rpmdsTagName(ds->tagN),
00894 (!strcmp(ds->DNEVR, "cached") ? ds->DNEVR : ds->DNEVR+2),
00895 (rc ? _("NO ") : _("YES")),
00896 (where != NULL ? where : ""));
00897 }
00898
00899 int rpmdsNext( rpmds ds)
00900
00901 {
00902 int i = -1;
00903
00904 if (ds != NULL && ++ds->i >= 0) {
00905 if (ds->i < (int)ds->Count) {
00906 char t[2];
00907 i = ds->i;
00908 ds->DNEVR = _free(ds->DNEVR);
00909 ds->ns.str = _free(ds->ns.str);
00910 memset(&ds->ns, 0, sizeof(ds->ns));
00911 t[0] = ((ds->Type != NULL) ? ds->Type[0] : '\0');
00912 t[1] = '\0';
00913
00914 ds->DNEVR = rpmdsNewDNEVR(t, ds);
00915
00916
00917 } else
00918 ds->i = -1;
00919
00920
00921 if (_rpmds_debug < 0 && i != -1)
00922 fprintf(stderr, "*** ds %p\t%s[%d]: %s\n", ds, (ds->Type ? ds->Type : "?Type?"), i, (ds->DNEVR ? ds->DNEVR : "?DNEVR?"));
00923
00924
00925 }
00926
00927 return i;
00928 }
00929
00930 rpmds rpmdsInit( rpmds ds)
00931
00932 {
00933 if (ds != NULL)
00934 ds->i = -1;
00935
00936 return ds;
00937
00938 }
00939
00940
00941 static rpmds rpmdsDup(const rpmds ods)
00942
00943 {
00944 rpmds ds = rpmdsGetPool(_rpmdsPool);
00945 size_t nb;
00946
00947
00948 ds->h = (ods->h != NULL ? headerLink(ods->h) : NULL);
00949 ds->Type = ods->Type;
00950
00951 ds->tagN = ods->tagN;
00952 ds->Count = ods->Count;
00953 ds->i = ods->i;
00954 ds->l = ods->l;
00955 ds->u = ods->u;
00956
00957 nb = (ds->Count+1) * sizeof(*ds->N);
00958 ds->N = (ds->h != NULL
00959 ? memcpy(xmalloc(nb), ods->N, nb)
00960 : rpmdsDupArgv(ods->N, ods->Count) );
00961
00962
00963 assert(ods->EVR != NULL);
00964 assert(ods->Flags != NULL);
00965
00966 nb = (ds->Count+1) * sizeof(*ds->EVR);
00967 ds->EVR = (ds->h != NULL
00968 ? memcpy(xmalloc(nb), ods->EVR, nb)
00969 : rpmdsDupArgv(ods->EVR, ods->Count) );
00970
00971 nb = (ds->Count * sizeof(*ds->Flags));
00972 ds->Flags = (ds->h != NULL
00973 ? ods->Flags
00974 : memcpy(xmalloc(nb), ods->Flags, nb) );
00975 ds->nopromote = ods->nopromote;
00976
00977 ds->EVRcmp = ods->EVRcmp;;
00978
00979
00980
00981 return rpmdsLink(ds, (ds ? ds->Type : NULL));
00982
00983
00984 }
00985
00986 int rpmdsFind(rpmds ds, const rpmds ods)
00987 {
00988 int comparison;
00989
00990 if (ds == NULL || ods == NULL)
00991 return -1;
00992
00993 ds->l = 0;
00994 ds->u = ds->Count;
00995 while (ds->l < ds->u) {
00996 ds->i = (ds->l + ds->u) / 2;
00997
00998 comparison = strcmp(ods->N[ods->i], ds->N[ds->i]);
00999
01000
01001
01002 if (comparison == 0 && ods->EVR && ds->EVR)
01003 comparison = strcmp(ods->EVR[ods->i], ds->EVR[ds->i]);
01004 if (comparison == 0 && ods->Flags && ds->Flags)
01005 comparison = (ods->Flags[ods->i] - ds->Flags[ds->i]);
01006
01007
01008 if (comparison < 0)
01009 ds->u = ds->i;
01010 else if (comparison > 0)
01011 ds->l = ds->i + 1;
01012 else
01013 return ds->i;
01014 }
01015 return -1;
01016 }
01017
01018 int rpmdsMerge(rpmds * dsp, rpmds ods)
01019 {
01020 rpmds ds;
01021 const char ** N;
01022 const char ** EVR;
01023 evrFlags * Flags;
01024 int j;
01025 int save;
01026
01027 if (dsp == NULL || ods == NULL)
01028 return -1;
01029
01030
01031 if (*dsp == NULL) {
01032 save = ods->Count;
01033 ods->Count = 1;
01034 *dsp = rpmdsDup(ods);
01035 ods->Count = save;
01036 }
01037 ds = *dsp;
01038 if (ds == NULL)
01039 return -1;
01040
01041
01042
01043
01044 save = ods->i;
01045 ods = rpmdsInit(ods);
01046 if (ods != NULL)
01047 while (rpmdsNext(ods) >= 0) {
01048
01049
01050
01051 if (rpmdsFind(ds, ods) >= 0)
01052 continue;
01053
01054
01055
01056
01057 for (j = ds->Count; j > (int)ds->u; j--)
01058 ds->N[j] = ds->N[j-1];
01059 ds->N[ds->u] = ods->N[ods->i];
01060 N = rpmdsDupArgv(ds->N, ds->Count+1);
01061 ds->N = _free(ds->N);
01062 ds->N = N;
01063
01064
01065
01066 assert(ods->EVR != NULL);
01067 assert(ods->Flags != NULL);
01068
01069 for (j = ds->Count; j > (int)ds->u; j--)
01070 ds->EVR[j] = ds->EVR[j-1];
01071 ds->EVR[ds->u] = ods->EVR[ods->i];
01072 EVR = rpmdsDupArgv(ds->EVR, ds->Count+1);
01073 ds->EVR = _free(ds->EVR);
01074 ds->EVR = EVR;
01075
01076 Flags = xmalloc((ds->Count+1) * sizeof(*Flags));
01077 if (ds->u > 0)
01078 memcpy(Flags, ds->Flags, ds->u * sizeof(*Flags));
01079 if (ds->u < ds->Count)
01080 memcpy(Flags + ds->u + 1, ds->Flags + ds->u, (ds->Count - ds->u) * sizeof(*Flags));
01081 Flags[ds->u] = ods->Flags[ods->i];
01082 ds->Flags = _free(ds->Flags);
01083 ds->Flags = Flags;
01084
01085
01086 ds->i = -1;
01087 ds->Count++;
01088
01089 }
01090
01091 ods->i = save;
01092
01093 return 0;
01094 }
01095
01096 int rpmdsSearch(rpmds ds, rpmds ods)
01097 {
01098 int comparison;
01099 int i, l, u;
01100
01101 if (ds == NULL || ods == NULL)
01102 return -1;
01103
01104
01105 i = -1;
01106 l = 0;
01107 u = ds->Count;
01108 while (l < u) {
01109 i = (l + u) / 2;
01110
01111 comparison = strcmp(ods->N[ods->i], ds->N[i]);
01112
01113 if (comparison < 0)
01114 u = i;
01115 else if (comparison > 0)
01116 l = i + 1;
01117 else {
01118
01119 if (strcmp(ods->N[ods->i], ds->N[l]))
01120 l = i;
01121 while (l > 0 && !strcmp(ods->N[ods->i], ds->N[l-1]))
01122 l--;
01123
01124 if (u >= (int)ds->Count || strcmp(ods->N[ods->i], ds->N[u]))
01125 u = i;
01126 while (++u < (int)ds->Count) {
01127 if (strcmp(ods->N[ods->i], ds->N[u]))
01128 break;
01129 }
01130 break;
01131 }
01132 }
01133
01134
01135 i = -1;
01136 if (l < u) {
01137 int save = rpmdsSetIx(ds, l-1);
01138 while ((l = rpmdsNext(ds)) >= 0 && (l < u)) {
01139 if ((i = rpmdsCompare(ods, ds)) != 0)
01140 break;
01141 }
01142
01143 if (i)
01144 i = rpmdsIx(ds);
01145 else {
01146 (void) rpmdsSetIx(ds, save);
01147 i = -1;
01148 }
01149
01150 if (ods->Result != NULL)
01151 (void) rpmdsSetResult(ods, (i != -1 ? 1 : 0));
01152 }
01153 return i;
01154 }
01155
01164 static void rpmdsNSAdd( rpmds *dsp, const char * NS,
01165 const char *N, const char *EVR, evrFlags Flags)
01166
01167 {
01168 char *t;
01169 rpmds ds;
01170 int xx;
01171
01172 t = alloca(strlen(NS)+sizeof("()")+strlen(N));
01173 *t = '\0';
01174 (void) stpcpy( stpcpy( stpcpy( stpcpy(t, NS), "("), N), ")");
01175
01176 ds = rpmdsSingle(RPMTAG_PROVIDENAME, t, EVR, Flags);
01177 xx = rpmdsMerge(dsp, ds);
01178 (void)rpmdsFree(ds);
01179 ds = NULL;
01180 }
01181
01182 #if defined(WITH_CPUINFO)
01183 int rpmdsCpuinfo(rpmds *dsp, const char * fn)
01184 {
01185 const char * NS = "cpuinfo";
01186 struct cpuinfo *cip = cpuinfo_new();
01187 cpuinfo_feature_t feature;
01188 char tmp[20];
01189 union _dbswap {
01190 rpmuint32_t ui;
01191 unsigned char uc[4];
01192 };
01193 static union _dbswap orderedbytes = { .ui = 0x11223344 };
01194 const char * endian = NULL;
01195
01196 snprintf(tmp, 19, "%d", cpuinfo_get_frequency(cip));
01197 tmp[19] = '\0';
01198 rpmdsNSAdd(dsp, NS, "cpu_MHz", tmp, RPMSENSE_PROBE|RPMSENSE_EQUAL);
01199 snprintf(tmp, 19, "%d", cpuinfo_get_cores(cip));
01200 rpmdsNSAdd(dsp, NS, "cpu_cores", tmp, RPMSENSE_PROBE|RPMSENSE_EQUAL);
01201 snprintf(tmp, 19, "%d", cpuinfo_get_threads(cip));
01202 rpmdsNSAdd(dsp, NS, "cpu_threads", tmp, RPMSENSE_PROBE|RPMSENSE_EQUAL);
01203
01204 if(orderedbytes.uc[0] == 0x44)
01205 endian = "little";
01206 else if(orderedbytes.uc[0] == 0x11)
01207 endian = "big";
01208 else if(orderedbytes.uc[0] == 0x22)
01209 endian = "pdp";
01210 rpmdsNSAdd(dsp, NS, "endian", endian, RPMSENSE_PROBE|RPMSENSE_EQUAL);
01211
01212 for (feature = cpuinfo_feature_common; feature != cpuinfo_feature_architecture_max; feature++) {
01213 if(feature == cpuinfo_feature_common_max)
01214 feature = cpuinfo_feature_architecture;
01215 if (cpuinfo_has_feature(cip, feature)) {
01216 const char *name = cpuinfo_string_of_feature(feature);
01217 if (name)
01218 rpmdsNSAdd(dsp, NS, name, "", RPMSENSE_PROBE);
01219 }
01220 }
01221 cpuinfo_destroy(cip);
01222
01223 return RPMRC_OK;
01224 }
01225
01226 #else
01227
01228 struct cpuinfo_s {
01229
01230 const char *name;
01231 int done;
01232 int flags;
01233 };
01234
01235
01236 static struct cpuinfo_s ctags[] = {
01237 { "processor", 0, 0 },
01238 { "vendor_id", 0, 0 },
01239 { "cpu_family", 0, 1 },
01240 { "model", 0, 1 },
01241 { "model_name", 0, 0 },
01242 { "stepping", 0, 1 },
01243 { "cpu_MHz", 0, 1 },
01244 { "cache_size", 0, 1 },
01245 { "physical_id", 0, 0 },
01246 { "siblings", 0, 0 },
01247 { "core_id", 0, 0 },
01248 { "cpu_cores", 0, 0 },
01249 { "fdiv_bug", 0, 3 },
01250 { "hlt_bug", 0, 3 },
01251 { "f00f_bug", 0, 3 },
01252 { "coma_bug", 0, 3 },
01253 { "fpu", 0, 0 },
01254 { "fpu_exception", 0, 3 },
01255 { "cpuid_level", 0, 0 },
01256 { "wp", 0, 3 },
01257 { "flags", 0, 4 },
01258 { "bogomips", 0, 1 },
01259 { "clflush_size", 0, 1 },
01260 { NULL, 0, -1 }
01261 };
01262
01268 static int rpmdsCpuinfoCtagFlags(const char * name)
01269
01270
01271 {
01272 struct cpuinfo_s * ct;
01273 int flags = -1;
01274
01275 for (ct = ctags; ct->name != NULL; ct++) {
01276 if (strcmp(ct->name, name))
01277 continue;
01278 if (ct->done)
01279 continue;
01280 ct->done = 1;
01281 flags = ct->flags;
01282 break;
01283 }
01284 return flags;
01285 }
01286
01287 #define _PROC_CPUINFO "/proc/cpuinfo"
01288
01290
01291 const char * _cpuinfo_path = NULL;
01292
01293 int rpmdsCpuinfo(rpmds *dsp, const char * fn)
01294
01295
01296 {
01297 struct cpuinfo_s * ct;
01298 const char * NS = "cpuinfo";
01299 rpmiob iob = NULL;
01300 char * f, * fe, * fend;
01301 char * g, * ge;
01302 char * t;
01303 int rc = -1;
01304 int xx;
01305
01306
01307 if (_cpuinfo_path == NULL) {
01308 _cpuinfo_path = rpmExpand("%{?_rpmds_cpuinfo_path}", NULL);
01309
01310 if (!(_cpuinfo_path != NULL && *_cpuinfo_path == '/')) {
01311
01312 _cpuinfo_path = _free(_cpuinfo_path);
01313
01314 _cpuinfo_path = xstrdup(_PROC_CPUINFO);
01315 }
01316 }
01317
01318
01319 if (fn == NULL)
01320 fn = _cpuinfo_path;
01321
01322
01323 for (ct = ctags; ct->name != NULL; ct++)
01324 ct->done = 0;
01325
01326 xx = rpmiobSlurp(fn, &iob);
01327 if (!(xx == 0 && iob != NULL))
01328 goto exit;
01329
01330 for (f = (char *)iob->b; *f != '\0'; f = fend) {
01331
01332 fe = f;
01333 while (*fe != '\0' && !(*fe == '\n' || *fe == '\r'))
01334 fe++;
01335 ge = fe;
01336 while (*fe != '\0' && (*fe == '\n' || *fe == '\r'))
01337 *fe++ = '\0';
01338 fend = fe;
01339
01340
01341 while (--ge > f && _isspace(*ge))
01342 *ge = '\0';
01343
01344
01345 while (*f && _isspace(*f))
01346 f++;
01347
01348
01349 fe = f;
01350 while (*fe && *fe != ':')
01351 fe++;
01352 if (*fe == '\0')
01353 continue;
01354 g = fe + 1;
01355
01356
01357 *fe = '\0';
01358 while (--fe > f && _isspace(*fe))
01359 *fe = '\0';
01360 if (*f == '\0')
01361 continue;
01362
01363
01364 while (*g && _isspace(*g))
01365 g++;
01366 if (*g == '\0')
01367 continue;
01368
01369 for (t = f; *t != '\0'; t++) {
01370 if (_isspace(*t))
01371 *t = '_';
01372 }
01373
01374 switch (rpmdsCpuinfoCtagFlags(f)) {
01375 case -1:
01376 case 0:
01377 default:
01378 continue;
01379 break;
01380 case 1:
01381 for (t = g; *t != '\0'; t++) {
01382 if (_isspace(*t) || *t == '(' || *t == ')')
01383 *t = '_';
01384 }
01385 rpmdsNSAdd(dsp, NS, f, g, RPMSENSE_PROBE|RPMSENSE_EQUAL);
01386 break;
01387 case 2:
01388 for (t = g; *t != '\0'; t++) {
01389 if (_isspace(*t) || *t == '(' || *t == ')')
01390 *t = '_';
01391 }
01392 rpmdsNSAdd(dsp, NS, g, "", RPMSENSE_PROBE);
01393 break;
01394 case 3:
01395 if (!strcmp(g, "yes"))
01396 rpmdsNSAdd(dsp, NS, f, "", RPMSENSE_PROBE);
01397 break;
01398 case 4:
01399 { char ** av = NULL;
01400 int i = 0;
01401 rc = poptParseArgvString(g, NULL, (const char ***)&av);
01402 if (!rc && av != NULL)
01403 while ((t = av[i++]) != NULL)
01404 rpmdsNSAdd(dsp, NS, t, "", RPMSENSE_PROBE);
01405 t = NULL;
01406 if (av != NULL)
01407 free(av);
01408 } break;
01409 }
01410 }
01411
01412 exit:
01413 iob = rpmiobFree(iob);
01414 return rc;
01415 }
01416 #endif
01417
01418 struct rpmlibProvides_s {
01419
01420 const char * featureName;
01421
01422 const char * featureEVR;
01423 evrFlags featureFlags;
01424
01425 const char * featureDescription;
01426 };
01427
01428
01429 static struct rpmlibProvides_s rpmlibProvides[] = {
01430 { "rpmlib(VersionedDependencies)", "3.0.3-1",
01431 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01432 N_("PreReq:, Provides:, and Obsoletes: dependencies support versions.") },
01433 { "rpmlib(CompressedFileNames)", "3.0.4-1",
01434 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01435 N_("file name(s) stored as (dirName,baseName,dirIndex) tuple, not as path.")},
01436 #if defined(WITH_BZIP2)
01437 { "rpmlib(PayloadIsBzip2)", "3.0.5-1",
01438 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01439 N_("package payload can be compressed using bzip2.") },
01440 #endif
01441 { "rpmlib(PayloadFilesHavePrefix)", "4.0-1",
01442 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01443 N_("package payload file(s) have \"./\" prefix.") },
01444 { "rpmlib(ExplicitPackageProvide)", "4.0-1",
01445 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01446 N_("package name-version-release is not implicitly provided.") },
01447 { "rpmlib(HeaderLoadSortsTags)", "4.0.1-1",
01448 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01449 N_("header tags are always sorted after being loaded.") },
01450 { "rpmlib(ScriptletInterpreterArgs)", "4.0.3-1",
01451 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01452 N_("the scriptlet interpreter can use arguments from header.") },
01453 { "rpmlib(PartialHardlinkSets)", "4.0.4-1",
01454 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01455 N_("a hardlink file set may be installed without being complete.") },
01456 { "rpmlib(ConcurrentAccess)", "4.1-1",
01457 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01458 N_("package scriptlets may access the rpm database while installing.") },
01459 #if defined(WITH_LUA)
01460 { "rpmlib(BuiltinLuaScripts)", "4.2.2-1",
01461 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01462 N_("internal embedded lua scripts.") },
01463 #endif
01464 #if defined(WITH_FICL)
01465 { "rpmlib(BuiltinFiclScripts)", "5.2-1",
01466 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01467 N_("internal embedded FICL.") },
01468 #endif
01469 #if defined(WITH_JS)
01470 { "rpmlib(BuiltinJavaScript)", "5.2-1",
01471 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01472 N_("internal embedded JavaScript.") },
01473 #endif
01474 #if defined(WITH_PERLEMBED)
01475 { "rpmlib(BuiltinPerlScripts)", "5.2-1",
01476 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01477 N_("internal embedded perl scripts.") },
01478 #endif
01479 #if defined(WITH_PYTHONEMBED)
01480 { "rpmlib(BuiltinPythonScripts)", "5.2-1",
01481 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01482 N_("internal embedded python scripts.") },
01483 #endif
01484 #if defined(WITH_RUBYEMBED)
01485 { "rpmlib(BuiltinRubyScripts)", "5.2-1",
01486 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01487 N_("internal embedded ruby scripts.") },
01488 #endif
01489 #if defined(WITH_TCL)
01490 { "rpmlib(BuiltinTclScripts)", "5.2-1",
01491 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01492 N_("internal embedded tcl scripts.") },
01493 #endif
01494 { "rpmlib(HeaderTagTypeInt64)", "4.4.3-1",
01495 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01496 N_("header tag data can be of type uint64_t.") },
01497 { "rpmlib(PayloadIsUstar)", "4.4.4-1",
01498 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01499 N_("package payload can be in ustar tar archive format.") },
01500 #if defined(WITH_XZ)
01501 { "rpmlib(PayloadIsLzma)", "4.4.6-1",
01502 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01503 N_("package payload can be compressed using lzma.") },
01504 #endif
01505 { "rpmlib(FileDigestParameterized)", "4.4.6-1",
01506 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01507 N_("file digests can be other than MD5.") },
01508 { "rpmlib(FileDigests)", "4.6.0-1",
01509 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01510 N_("file digests can be other than MD5.") },
01511 #if defined(SUPPORT_AR_PAYLOADS)
01512 { "rpmlib(PayloadIsAr)", "5.1-1",
01513 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01514 N_("package payload can be in ar archive format.") },
01515 #endif
01516 #if defined(WITH_XZ)
01517 { "rpmlib(PayloadIsXz)", "5.2-1",
01518 (RPMSENSE_RPMLIB|RPMSENSE_EQUAL),
01519 N_("package payload can be compressed using xz.") },
01520 #endif
01521 { NULL, NULL, 0, NULL }
01522 };
01523
01530 int rpmdsRpmlib(rpmds * dsp, void * tblp)
01531 {
01532 const struct rpmlibProvides_s * rltblp = tblp;
01533 const struct rpmlibProvides_s * rlp;
01534 int xx;
01535
01536 if (rltblp == NULL)
01537 rltblp = rpmlibProvides;
01538
01539 for (rlp = rltblp; rlp->featureName != NULL; rlp++) {
01540 rpmds ds = rpmdsSingle(RPMTAG_PROVIDENAME, rlp->featureName,
01541 rlp->featureEVR, rlp->featureFlags);
01542 xx = rpmdsMerge(dsp, ds);
01543 (void)rpmdsFree(ds);
01544 ds = NULL;
01545 }
01546 return 0;
01547 }
01548
01556 static int rpmdsSysinfoFile(rpmPRCO PRCO, const char * fn, int tagN)
01557
01558
01559 {
01560 char buf[BUFSIZ];
01561 const char *N, *EVR;
01562 evrFlags Flags;
01563 rpmds ds;
01564 char * f, * fe;
01565 char * g, * ge;
01566 FD_t fd = NULL;
01567 FILE * fp;
01568 int rc = -1;
01569 int ln;
01570 int xx;
01571
01572
01573 if (tagN == RPMTAG_DIRNAMES || tagN == RPMTAG_FILELINKTOS)
01574 tagN = RPMTAG_PROVIDENAME;
01575
01576 assert(fn != NULL);
01577 fd = Fopen(fn, "r.fpio");
01578 if (fd == NULL || Ferror(fd))
01579 goto exit;
01580 fp = fdGetFILE(fd);
01581
01582 ln = 0;
01583 if (fp != NULL)
01584 while((f = fgets(buf, (int)sizeof(buf), fp)) != NULL) {
01585 ln++;
01586
01587
01588 buf[sizeof(buf)-1] = '\0';
01589
01590
01591 while (*f && _isspace(*f))
01592 f++;
01593
01594
01595 if (f[0] == '-' && _isspace(f[1])) {
01596 f += sizeof("- ")-1;
01597 while (*f && _isspace(*f))
01598 f++;
01599 }
01600
01601
01602 if (*f == '\0' || *f == '#')
01603 continue;
01604
01605
01606 fe = f + strlen(f);
01607 while (--fe > f && _isspace(*fe))
01608 *fe = '\0';
01609
01610 if (!(xisalnum(f[0]) || strchr("/_%!", f[0]) != NULL)) {
01611 fprintf(stderr, _("%s:%d \"%s\" has invalid name. Skipping ...\n"),
01612 fn, ln, f);
01613 continue;
01614 }
01615
01616
01617 fe = f;
01618 if (*f == '!') fe++;
01619 while (*fe && !_isspace(*fe) && strchr("!<=>", *fe) == NULL)
01620 fe++;
01621 while (*fe && _isspace(*fe))
01622 *fe++ = '\0';
01623
01624 N = f;
01625 EVR = NULL;
01626 Flags = 0;
01627
01628
01629 if (*f != '/' && *fe != '\0') {
01630
01631 g = fe;
01632 Flags = rpmEVRflags(fe, (const char **)&g);
01633 if (Flags == 0) {
01634 fprintf(stderr, _("%s:%d \"%s\" has no comparison operator. Skipping ...\n"),
01635 fn, ln, fe);
01636 continue;
01637 }
01638 *fe = '\0';
01639
01640
01641 while (*g && _isspace(*g))
01642 g++;
01643 if (*g == '\0') {
01644
01645 fprintf(stderr, _("%s:%d \"%s\" has no EVR string. Skipping ...\n"),
01646 fn, ln, f);
01647 continue;
01648 }
01649
01650 ge = g + 1;
01651 while (*ge && !_isspace(*ge))
01652 ge++;
01653
01654 if (*ge != '\0')
01655 *ge = '\0';
01656
01657 EVR = g;
01658 }
01659
01660 if (EVR == NULL)
01661 EVR = "";
01662 Flags |= RPMSENSE_PROBE;
01663 ds = rpmdsSingle(tagN, N, EVR , Flags);
01664 if (ds) {
01665 xx = rpmdsMergePRCO(PRCO, ds);
01666 (void)rpmdsFree(ds);
01667 ds = NULL;
01668 }
01669 }
01670 rc = 0;
01671
01672 exit:
01673 if (fd != NULL) (void) Fclose(fd);
01674 return rc;
01675 }
01676
01677 #if defined(RPM_VENDOR_WINDRIVER)
01678 #define _ETC_RPM_SYSINFO "%{_etcrpm}/sysinfo"
01679 #else
01680 #define _ETC_RPM_SYSINFO SYSCONFIGDIR "/sysinfo"
01681 #endif
01682
01683
01684 const char *_sysinfo_path = NULL;
01685
01686
01687
01688 static const char *_sysinfo_tags[] = {
01689 "Providename",
01690 "Requirename",
01691 "Conflictname",
01692 "Obsoletename",
01693 "Dirnames",
01694 "Filelinktos",
01695 NULL
01696 };
01697
01698
01699 int rpmdsSysinfo(rpmPRCO PRCO, const char * fn)
01700
01701
01702 {
01703 struct stat * st = memset(alloca(sizeof(*st)), 0, sizeof(*st));
01704 int rc = -1;
01705 int xx;
01706
01707
01708 if (_sysinfo_path == NULL) {
01709 _sysinfo_path = rpmExpand("%{?_rpmds_sysinfo_path}", NULL);
01710
01711 if (!(_sysinfo_path != NULL && *_sysinfo_path == '/')) {
01712
01713 _sysinfo_path = _free(_sysinfo_path);
01714
01715 _sysinfo_path = xstrdup(_ETC_RPM_SYSINFO);
01716 }
01717 }
01718
01719
01720 if (fn == NULL)
01721 fn = _sysinfo_path;
01722
01723 if (fn == NULL)
01724 goto exit;
01725
01726 xx = Stat(fn, st);
01727 if (xx < 0)
01728 goto exit;
01729
01730 if (S_ISDIR(st->st_mode)) {
01731 const char *dn = fn;
01732 const char **av;
01733 int tagN;
01734 rc = 0;
01735 for (av = _sysinfo_tags; av && *av; av++) {
01736 tagN = tagValue(*av);
01737 if (tagN < 0)
01738 continue;
01739 fn = rpmGetPath(dn, "/", *av, NULL);
01740 st = memset(st, 0, sizeof(*st));
01741 xx = Stat(fn, st);
01742 if (xx == 0 && S_ISREG(st->st_mode))
01743 rc = rpmdsSysinfoFile(PRCO, fn, tagN);
01744 fn = _free(fn);
01745 if (rc)
01746 break;
01747 }
01748 } else
01749
01750 if (S_ISREG(st->st_mode))
01751 rc = rpmdsSysinfoFile(PRCO, fn, RPMTAG_PROVIDENAME);
01752
01753 exit:
01754 return rc;
01755 }
01756
01757 struct conf {
01758
01759 const char *name;
01760 const int call_name;
01761 const enum { SYSCONF, CONFSTR, PATHCONF } call;
01762 };
01763
01764
01765 static const struct conf vars[] = {
01766 #ifdef _PC_LINK_MAX
01767 { "LINK_MAX", _PC_LINK_MAX, PATHCONF },
01768 #endif
01769 #ifdef _PC_LINK_MAX
01770 { "_POSIX_LINK_MAX", _PC_LINK_MAX, PATHCONF },
01771 #endif
01772 #ifdef _PC_MAX_CANON
01773 { "MAX_CANON", _PC_MAX_CANON, PATHCONF },
01774 #endif
01775 #ifdef _PC_MAX_CANON
01776 { "_POSIX_MAX_CANON", _PC_MAX_CANON, PATHCONF },
01777 #endif
01778 #ifdef _PC_MAX_INPUT
01779 { "MAX_INPUT", _PC_MAX_INPUT, PATHCONF },
01780 #endif
01781 #ifdef _PC_MAX_INPUT
01782 { "_POSIX_MAX_INPUT", _PC_MAX_INPUT, PATHCONF },
01783 #endif
01784 #ifdef _PC_NAME_MAX
01785 { "NAME_MAX", _PC_NAME_MAX, PATHCONF },
01786 #endif
01787 #ifdef _PC_NAME_MAX
01788 { "_POSIX_NAME_MAX", _PC_NAME_MAX, PATHCONF },
01789 #endif
01790 #ifdef _PC_PATH_MAX
01791 { "PATH_MAX", _PC_PATH_MAX, PATHCONF },
01792 #endif
01793 #ifdef _PC_PATH_MAX
01794 { "_POSIX_PATH_MAX", _PC_PATH_MAX, PATHCONF },
01795 #endif
01796 #ifdef _PC_PIPE_BUF
01797 { "PIPE_BUF", _PC_PIPE_BUF, PATHCONF },
01798 #endif
01799 #ifdef _PC_PIPE_BUF
01800 { "_POSIX_PIPE_BUF", _PC_PIPE_BUF, PATHCONF },
01801 #endif
01802 #ifdef _PC_SOCK_MAXBUF
01803 { "SOCK_MAXBUF", _PC_SOCK_MAXBUF, PATHCONF },
01804 #endif
01805 #ifdef _PC_ASYNC_IO
01806 { "_POSIX_ASYNC_IO", _PC_ASYNC_IO, PATHCONF },
01807 #endif
01808 #ifdef _PC_CHOWN_RESTRICTED
01809 { "_POSIX_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED, PATHCONF },
01810 #endif
01811 #ifdef _PC_NO_TRUNC
01812 { "_POSIX_NO_TRUNC", _PC_NO_TRUNC, PATHCONF },
01813 #endif
01814 #ifdef _PC_PRIO_IO
01815 { "_POSIX_PRIO_IO", _PC_PRIO_IO, PATHCONF },
01816 #endif
01817 #ifdef _PC_SYNC_IO
01818 { "_POSIX_SYNC_IO", _PC_SYNC_IO, PATHCONF },
01819 #endif
01820 #ifdef _PC_VDISABLE
01821 { "_POSIX_VDISABLE", _PC_VDISABLE, PATHCONF },
01822 #endif
01823
01824 #ifdef _SC_ARG_MAX
01825 { "ARG_MAX", _SC_ARG_MAX, SYSCONF },
01826 #endif
01827 #ifdef _SC_ATEXIT_MAX
01828 { "ATEXIT_MAX", _SC_ATEXIT_MAX, SYSCONF },
01829 #endif
01830 #ifdef _SC_CHAR_BIT
01831 { "CHAR_BIT", _SC_CHAR_BIT, SYSCONF },
01832 #endif
01833 #ifdef _SC_CHAR_MAX
01834 { "CHAR_MAX", _SC_CHAR_MAX, SYSCONF },
01835 #endif
01836 #ifdef _SC_CHAR_MIN
01837 { "CHAR_MIN", _SC_CHAR_MIN, SYSCONF },
01838 #endif
01839 #ifdef _SC_CHILD_MAX
01840 { "CHILD_MAX", _SC_CHILD_MAX, SYSCONF },
01841 #endif
01842 #ifdef _SC_CLK_TCK
01843 { "CLK_TCK", _SC_CLK_TCK, SYSCONF },
01844 #endif
01845 #ifdef _SC_INT_MAX
01846 { "INT_MAX", _SC_INT_MAX, SYSCONF },
01847 #endif
01848 #ifdef _SC_INT_MIN
01849 { "INT_MIN", _SC_INT_MIN, SYSCONF },
01850 #endif
01851 #ifdef _SC_UIO_MAXIOV
01852 { "IOV_MAX", _SC_UIO_MAXIOV, SYSCONF },
01853 #endif
01854 #ifdef _SC_LOGIN_NAME_MAX
01855 { "LOGNAME_MAX", _SC_LOGIN_NAME_MAX, SYSCONF },
01856 #endif
01857 #ifdef _SC_LONG_BIT
01858 { "LONG_BIT", _SC_LONG_BIT, SYSCONF },
01859 #endif
01860 #ifdef _SC_MB_LEN_MAX
01861 { "MB_LEN_MAX", _SC_MB_LEN_MAX, SYSCONF },
01862 #endif
01863 #ifdef _SC_NGROUPS_MAX
01864 { "NGROUPS_MAX", _SC_NGROUPS_MAX, SYSCONF },
01865 #endif
01866 #ifdef _SC_NL_ARGMAX
01867 { "NL_ARGMAX", _SC_NL_ARGMAX, SYSCONF },
01868 #endif
01869 #ifdef _SC_NL_LANGMAX
01870 { "NL_LANGMAX", _SC_NL_LANGMAX, SYSCONF },
01871 #endif
01872 #ifdef _SC_NL_MSGMAX
01873 { "NL_MSGMAX", _SC_NL_MSGMAX, SYSCONF },
01874 #endif
01875 #ifdef _SC_NL_NMAX
01876 { "NL_NMAX", _SC_NL_NMAX, SYSCONF },
01877 #endif
01878 #ifdef _SC_NL_SETMAX
01879 { "NL_SETMAX", _SC_NL_SETMAX, SYSCONF },
01880 #endif
01881 #ifdef _SC_NL_TEXTMAX
01882 { "NL_TEXTMAX", _SC_NL_TEXTMAX, SYSCONF },
01883 #endif
01884 #ifdef _SC_GETGR_R_SIZE_MAX
01885 { "NSS_BUFLEN_GROUP", _SC_GETGR_R_SIZE_MAX, SYSCONF },
01886 #endif
01887 #ifdef _SC_GETPW_R_SIZE_MAX
01888 { "NSS_BUFLEN_PASSWD", _SC_GETPW_R_SIZE_MAX, SYSCONF },
01889 #endif
01890 #ifdef _SC_NZERO
01891 { "NZERO", _SC_NZERO, SYSCONF },
01892 #endif
01893 #ifdef _SC_OPEN_MAX
01894 { "OPEN_MAX", _SC_OPEN_MAX, SYSCONF },
01895 #endif
01896 #ifdef _SC_PAGESIZE
01897 { "PAGESIZE", _SC_PAGESIZE, SYSCONF },
01898 #endif
01899 #ifdef _SC_PAGESIZE
01900 { "PAGE_SIZE", _SC_PAGESIZE, SYSCONF },
01901 #endif
01902 #ifdef _SC_PASS_MAX
01903 { "PASS_MAX", _SC_PASS_MAX, SYSCONF },
01904 #endif
01905 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
01906 { "PTHREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS, SYSCONF },
01907 #endif
01908 #ifdef _SC_THREAD_KEYS_MAX
01909 { "PTHREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX, SYSCONF },
01910 #endif
01911 #ifdef _SC_THREAD_STACK_MIN
01912 { "PTHREAD_STACK_MIN", _SC_THREAD_STACK_MIN, SYSCONF },
01913 #endif
01914 #ifdef _SC_THREAD_THREADS_MAX
01915 { "PTHREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX, SYSCONF },
01916 #endif
01917 #ifdef _SC_SCHAR_MAX
01918 { "SCHAR_MAX", _SC_SCHAR_MAX, SYSCONF },
01919 #endif
01920 #ifdef _SC_SCHAR_MIN
01921 { "SCHAR_MIN", _SC_SCHAR_MIN, SYSCONF },
01922 #endif
01923 #ifdef _SC_SHRT_MAX
01924 { "SHRT_MAX", _SC_SHRT_MAX, SYSCONF },
01925 #endif
01926 #ifdef _SC_SHRT_MIN
01927 { "SHRT_MIN", _SC_SHRT_MIN, SYSCONF },
01928 #endif
01929 #ifdef _SC_SSIZE_MAX
01930 { "SSIZE_MAX", _SC_SSIZE_MAX, SYSCONF },
01931 #endif
01932 #ifdef _SC_TTY_NAME_MAX
01933 { "TTY_NAME_MAX", _SC_TTY_NAME_MAX, SYSCONF },
01934 #endif
01935 #ifdef _SC_TZNAME_MAX
01936 { "TZNAME_MAX", _SC_TZNAME_MAX, SYSCONF },
01937 #endif
01938 #ifdef _SC_UCHAR_MAX
01939 { "UCHAR_MAX", _SC_UCHAR_MAX, SYSCONF },
01940 #endif
01941 #ifdef _SC_UINT_MAX
01942 { "UINT_MAX", _SC_UINT_MAX, SYSCONF },
01943 #endif
01944 #ifdef _SC_UIO_MAXIOV
01945 { "UIO_MAXIOV", _SC_UIO_MAXIOV, SYSCONF },
01946 #endif
01947 #ifdef _SC_ULONG_MAX
01948 { "ULONG_MAX", _SC_ULONG_MAX, SYSCONF },
01949 #endif
01950 #ifdef _SC_USHRT_MAX
01951 { "USHRT_MAX", _SC_USHRT_MAX, SYSCONF },
01952 #endif
01953 #ifdef _SC_WORD_BIT
01954 { "WORD_BIT", _SC_WORD_BIT, SYSCONF },
01955 #endif
01956 #ifdef _SC_AVPHYS_PAGES
01957 { "_AVPHYS_PAGES", _SC_AVPHYS_PAGES, SYSCONF },
01958 #endif
01959 #ifdef _SC_NPROCESSORS_CONF
01960 { "_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF, SYSCONF },
01961 #endif
01962 #ifdef _SC_NPROCESSORS_ONLN
01963 { "_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN, SYSCONF },
01964 #endif
01965 #ifdef _SC_PHYS_PAGES
01966 { "_PHYS_PAGES", _SC_PHYS_PAGES, SYSCONF },
01967 #endif
01968 #ifdef _SC_ARG_MAX
01969 { "_POSIX_ARG_MAX", _SC_ARG_MAX, SYSCONF },
01970 #endif
01971 #ifdef _SC_ASYNCHRONOUS_IO
01972 { "_POSIX_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO, SYSCONF },
01973 #endif
01974 #ifdef _SC_CHILD_MAX
01975 { "_POSIX_CHILD_MAX", _SC_CHILD_MAX, SYSCONF },
01976 #endif
01977 #ifdef _SC_FSYNC
01978 { "_POSIX_FSYNC", _SC_FSYNC, SYSCONF },
01979 #endif
01980 #ifdef _SC_JOB_CONTROL
01981 { "_POSIX_JOB_CONTROL", _SC_JOB_CONTROL, SYSCONF },
01982 #endif
01983 #ifdef _SC_MAPPED_FILES
01984 { "_POSIX_MAPPED_FILES", _SC_MAPPED_FILES, SYSCONF },
01985 #endif
01986 #ifdef _SC_MEMLOCK
01987 { "_POSIX_MEMLOCK", _SC_MEMLOCK, SYSCONF },
01988 #endif
01989 #ifdef _SC_MEMLOCK_RANGE
01990 { "_POSIX_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE, SYSCONF },
01991 #endif
01992 #ifdef _SC_MEMORY_PROTECTION
01993 { "_POSIX_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION, SYSCONF },
01994 #endif
01995 #ifdef _SC_MESSAGE_PASSING
01996 { "_POSIX_MESSAGE_PASSING", _SC_MESSAGE_PASSING, SYSCONF },
01997 #endif
01998 #ifdef _SC_NGROUPS_MAX
01999 { "_POSIX_NGROUPS_MAX", _SC_NGROUPS_MAX, SYSCONF },
02000 #endif
02001 #ifdef _SC_OPEN_MAX
02002 { "_POSIX_OPEN_MAX", _SC_OPEN_MAX, SYSCONF },
02003 #endif
02004 #ifdef _SC_PII
02005 { "_POSIX_PII", _SC_PII, SYSCONF },
02006 #endif
02007 #ifdef _SC_PII_INTERNET
02008 { "_POSIX_PII_INTERNET", _SC_PII_INTERNET, SYSCONF },
02009 #endif
02010 #ifdef _SC_PII_INTERNET_DGRAM
02011 { "_POSIX_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM, SYSCONF },
02012 #endif
02013 #ifdef _SC_PII_INTERNET_STREAM
02014 { "_POSIX_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM, SYSCONF },
02015 #endif
02016 #ifdef _SC_PII_OSI
02017 { "_POSIX_PII_OSI", _SC_PII_OSI, SYSCONF },
02018 #endif
02019 #ifdef _SC_PII_OSI_CLTS
02020 { "_POSIX_PII_OSI_CLTS", _SC_PII_OSI_CLTS, SYSCONF },
02021 #endif
02022 #ifdef _SC_PII_OSI_COTS
02023 { "_POSIX_PII_OSI_COTS", _SC_PII_OSI_COTS, SYSCONF },
02024 #endif
02025 #ifdef _SC_PII_OSI_M
02026 { "_POSIX_PII_OSI_M", _SC_PII_OSI_M, SYSCONF },
02027 #endif
02028 #ifdef _SC_PII_SOCKET
02029 { "_POSIX_PII_SOCKET", _SC_PII_SOCKET, SYSCONF },
02030 #endif
02031 #ifdef _SC_PII_XTI
02032 { "_POSIX_PII_XTI", _SC_PII_XTI, SYSCONF },
02033 #endif
02034 #ifdef _SC_POLL
02035 { "_POSIX_POLL", _SC_POLL, SYSCONF },
02036 #endif
02037 #ifdef _SC_PRIORITIZED_IO
02038 { "_POSIX_PRIORITIZED_IO", _SC_PRIORITIZED_IO, SYSCONF },
02039 #endif
02040 #ifdef _SC_PRIORITY_SCHEDULING
02041 { "_POSIX_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING, SYSCONF },
02042 #endif
02043 #ifdef _SC_REALTIME_SIGNALS
02044 { "_POSIX_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS, SYSCONF },
02045 #endif
02046 #ifdef _SC_SAVED_IDS
02047 { "_POSIX_SAVED_IDS", _SC_SAVED_IDS, SYSCONF },
02048 #endif
02049 #ifdef _SC_SELECT
02050 { "_POSIX_SELECT", _SC_SELECT, SYSCONF },
02051 #endif
02052 #ifdef _SC_SEMAPHORES
02053 { "_POSIX_SEMAPHORES", _SC_SEMAPHORES, SYSCONF },
02054 #endif
02055 #ifdef _SC_SHARED_MEMORY_OBJECTS
02056 { "_POSIX_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS, SYSCONF },
02057 #endif
02058 #ifdef _SC_SSIZE_MAX
02059 { "_POSIX_SSIZE_MAX", _SC_SSIZE_MAX, SYSCONF },
02060 #endif
02061 #ifdef _SC_STREAM_MAX
02062 { "_POSIX_STREAM_MAX", _SC_STREAM_MAX, SYSCONF },
02063 #endif
02064 #ifdef _SC_SYNCHRONIZED_IO
02065 { "_POSIX_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO, SYSCONF },
02066 #endif
02067 #ifdef _SC_THREADS
02068 { "_POSIX_THREADS", _SC_THREADS, SYSCONF },
02069 #endif
02070 #ifdef _SC_THREAD_ATTR_STACKADDR
02071 { "_POSIX_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR, SYSCONF },
02072 #endif
02073 #ifdef _SC_THREAD_ATTR_STACKSIZE
02074 { "_POSIX_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE, SYSCONF },
02075 #endif
02076 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
02077 { "_POSIX_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING, SYSCONF },
02078 #endif
02079 #ifdef _SC_THREAD_PRIO_INHERIT
02080 { "_POSIX_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT, SYSCONF },
02081 #endif
02082 #ifdef _SC_THREAD_PRIO_PROTECT
02083 { "_POSIX_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT, SYSCONF },
02084 #endif
02085 #ifdef _SC_THREAD_PROCESS_SHARED
02086 { "_POSIX_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED, SYSCONF },
02087 #endif
02088 #ifdef _SC_THREAD_SAFE_FUNCTIONS
02089 { "_POSIX_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS, SYSCONF },
02090 #endif
02091 #ifdef _SC_TIMERS
02092 { "_POSIX_TIMERS", _SC_TIMERS, SYSCONF },
02093 #endif
02094 #ifdef _SC_TIMER_MAX
02095 { "TIMER_MAX", _SC_TIMER_MAX, SYSCONF },
02096 #endif
02097 #ifdef _SC_TZNAME_MAX
02098 { "_POSIX_TZNAME_MAX", _SC_TZNAME_MAX, SYSCONF },
02099 #endif
02100 #ifdef _SC_VERSION
02101 { "_POSIX_VERSION", _SC_VERSION, SYSCONF },
02102 #endif
02103 #ifdef _SC_T_IOV_MAX
02104 { "_T_IOV_MAX", _SC_T_IOV_MAX, SYSCONF },
02105 #endif
02106 #ifdef _SC_XOPEN_CRYPT
02107 { "_XOPEN_CRYPT", _SC_XOPEN_CRYPT, SYSCONF },
02108 #endif
02109 #ifdef _SC_XOPEN_ENH_I18N
02110 { "_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N, SYSCONF },
02111 #endif
02112 #ifdef _SC_XOPEN_LEGACY
02113 { "_XOPEN_LEGACY", _SC_XOPEN_LEGACY, SYSCONF },
02114 #endif
02115 #ifdef _SC_XOPEN_REALTIME
02116 { "_XOPEN_REALTIME", _SC_XOPEN_REALTIME, SYSCONF },
02117 #endif
02118 #ifdef _SC_XOPEN_REALTIME_THREADS
02119 { "_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS, SYSCONF },
02120 #endif
02121 #ifdef _SC_XOPEN_SHM
02122 { "_XOPEN_SHM", _SC_XOPEN_SHM, SYSCONF },
02123 #endif
02124 #ifdef _SC_XOPEN_UNIX
02125 { "_XOPEN_UNIX", _SC_XOPEN_UNIX, SYSCONF },
02126 #endif
02127 #ifdef _SC_XOPEN_VERSION
02128 { "_XOPEN_VERSION", _SC_XOPEN_VERSION, SYSCONF },
02129 #endif
02130 #ifdef _SC_XOPEN_XCU_VERSION
02131 { "_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION, SYSCONF },
02132 #endif
02133 #ifdef _SC_XOPEN_XPG2
02134 { "_XOPEN_XPG2", _SC_XOPEN_XPG2, SYSCONF },
02135 #endif
02136 #ifdef _SC_XOPEN_XPG3
02137 { "_XOPEN_XPG3", _SC_XOPEN_XPG3, SYSCONF },
02138 #endif
02139 #ifdef _SC_XOPEN_XPG4
02140 { "_XOPEN_XPG4", _SC_XOPEN_XPG4, SYSCONF },
02141 #endif
02142
02143 #ifdef _SC_BC_BASE_MAX
02144 { "BC_BASE_MAX", _SC_BC_BASE_MAX, SYSCONF },
02145 #endif
02146 #ifdef _SC_BC_DIM_MAX
02147 { "BC_DIM_MAX", _SC_BC_DIM_MAX, SYSCONF },
02148 #endif
02149 #ifdef _SC_BC_SCALE_MAX
02150 { "BC_SCALE_MAX", _SC_BC_SCALE_MAX, SYSCONF },
02151 #endif
02152 #ifdef _SC_BC_STRING_MAX
02153 { "BC_STRING_MAX", _SC_BC_STRING_MAX, SYSCONF },
02154 #endif
02155 #ifdef _SC_CHARCLASS_NAME_MAX
02156 { "CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX, SYSCONF },
02157 #endif
02158 #ifdef _SC_COLL_WEIGHTS_MAX
02159 { "COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX, SYSCONF },
02160 #endif
02161 #ifdef _SC_EQUIV_CLASS_MAX
02162 { "EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX, SYSCONF },
02163 #endif
02164 #ifdef _SC_EXPR_NEST_MAX
02165 { "EXPR_NEST_MAX", _SC_EXPR_NEST_MAX, SYSCONF },
02166 #endif
02167 #ifdef _SC_LINE_MAX
02168 { "LINE_MAX", _SC_LINE_MAX, SYSCONF },
02169 #endif
02170 #ifdef _SC_BC_BASE_MAX
02171 { "POSIX2_BC_BASE_MAX", _SC_BC_BASE_MAX, SYSCONF },
02172 #endif
02173 #ifdef _SC_BC_DIM_MAX
02174 { "POSIX2_BC_DIM_MAX", _SC_BC_DIM_MAX, SYSCONF },
02175 #endif
02176 #ifdef _SC_BC_SCALE_MAX
02177 { "POSIX2_BC_SCALE_MAX", _SC_BC_SCALE_MAX, SYSCONF },
02178 #endif
02179 #ifdef _SC_BC_STRING_MAX
02180 { "POSIX2_BC_STRING_MAX", _SC_BC_STRING_MAX, SYSCONF },
02181 #endif
02182 #ifdef _SC_2_CHAR_TERM
02183 { "POSIX2_CHAR_TERM", _SC_2_CHAR_TERM, SYSCONF },
02184 #endif
02185 #ifdef _SC_COLL_WEIGHTS_MAX
02186 { "POSIX2_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX, SYSCONF },
02187 #endif
02188 #ifdef _SC_2_C_BIND
02189 { "POSIX2_C_BIND", _SC_2_C_BIND, SYSCONF },
02190 #endif
02191 #ifdef _SC_2_C_DEV
02192 { "POSIX2_C_DEV", _SC_2_C_DEV, SYSCONF },
02193 #endif
02194 #ifdef _SC_2_C_VERSION
02195 { "POSIX2_C_VERSION", _SC_2_C_VERSION, SYSCONF },
02196 #endif
02197 #ifdef _SC_EXPR_NEST_MAX
02198 { "POSIX2_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX, SYSCONF },
02199 #endif
02200 #ifdef _SC_2_FORT_DEV
02201 { "POSIX2_FORT_DEV", _SC_2_FORT_DEV, SYSCONF },
02202 #endif
02203 #ifdef _SC_2_FORT_RUN
02204 { "POSIX2_FORT_RUN", _SC_2_FORT_RUN, SYSCONF },
02205 #endif
02206 #ifdef _SC_LINE_MAX
02207 { "_POSIX2_LINE_MAX", _SC_LINE_MAX, SYSCONF },
02208 #endif
02209 #ifdef _SC_2_LOCALEDEF
02210 { "POSIX2_LOCALEDEF", _SC_2_LOCALEDEF, SYSCONF },
02211 #endif
02212 #ifdef _SC_RE_DUP_MAX
02213 { "POSIX2_RE_DUP_MAX", _SC_RE_DUP_MAX, SYSCONF },
02214 #endif
02215 #ifdef _SC_2_SW_DEV
02216 { "POSIX2_SW_DEV", _SC_2_SW_DEV, SYSCONF },
02217 #endif
02218 #ifdef _SC_2_UPE
02219 { "POSIX2_UPE", _SC_2_UPE, SYSCONF },
02220 #endif
02221 #ifdef _SC_2_VERSION
02222 { "POSIX2_VERSION", _SC_2_VERSION, SYSCONF },
02223 #endif
02224 #ifdef _SC_RE_DUP_MAX
02225 { "RE_DUP_MAX", _SC_RE_DUP_MAX, SYSCONF },
02226 #endif
02227
02228 #ifdef _CS_PATH
02229 { "PATH", _CS_PATH, CONFSTR },
02230 { "CS_PATH", _CS_PATH, CONFSTR },
02231 #endif
02232
02233
02234 #ifdef _CS_LFS_CFLAGS
02235 { "LFS_CFLAGS", _CS_LFS_CFLAGS, CONFSTR },
02236 #endif
02237 #ifdef _CS_LFS_LDFLAGS
02238 { "LFS_LDFLAGS", _CS_LFS_LDFLAGS, CONFSTR },
02239 #endif
02240 #ifdef _CS_LFS_LIBS
02241 { "LFS_LIBS", _CS_LFS_LIBS, CONFSTR },
02242 #endif
02243 #ifdef _CS_LFS_LINTFLAGS
02244 { "LFS_LINTFLAGS", _CS_LFS_LINTFLAGS, CONFSTR },
02245 #endif
02246 #ifdef _CS_LFS64_CFLAGS
02247 { "LFS64_CFLAGS", _CS_LFS64_CFLAGS, CONFSTR },
02248 #endif
02249 #ifdef _CS_LFS64_LDFLAGS
02250 { "LFS64_LDFLAGS", _CS_LFS64_LDFLAGS, CONFSTR },
02251 #endif
02252 #ifdef _CS_LFS64_LIBS
02253 { "LFS64_LIBS", _CS_LFS64_LIBS, CONFSTR },
02254 #endif
02255 #ifdef _CS_LFS64_LINTFLAGS
02256 { "LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS, CONFSTR },
02257 #endif
02258
02259
02260 #ifdef _SC_XBS5_ILP32_OFF32
02261 { "_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32, SYSCONF },
02262 #endif
02263 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
02264 { "XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS, CONFSTR },
02265 #endif
02266 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
02267 { "XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS, CONFSTR },
02268 #endif
02269 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
02270 { "XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS, CONFSTR },
02271 #endif
02272 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
02273 { "XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS, CONFSTR },
02274 #endif
02275
02276 #ifdef _SC_XBS5_ILP32_OFFBIG
02277 { "_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG, SYSCONF },
02278 #endif
02279 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
02280 { "XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS, CONFSTR },
02281 #endif
02282 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
02283 { "XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS, CONFSTR },
02284 #endif
02285 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
02286 { "XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS, CONFSTR },
02287 #endif
02288 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
02289 { "XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS, CONFSTR },
02290 #endif
02291
02292 #ifdef _SC_XBS5_LP64_OFF64
02293 { "_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64, SYSCONF },
02294 #endif
02295 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
02296 { "XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS, CONFSTR },
02297 #endif
02298 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
02299 { "XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS, CONFSTR },
02300 #endif
02301 #ifdef _CS_XBS5_LP64_OFF64_LIBS
02302 { "XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS, CONFSTR },
02303 #endif
02304 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
02305 { "XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS, CONFSTR },
02306 #endif
02307
02308 #ifdef _SC_XBS5_LPBIG_OFFBIG
02309 { "_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG, SYSCONF },
02310 #endif
02311 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
02312 { "XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS, CONFSTR },
02313 #endif
02314 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
02315 { "XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS, CONFSTR },
02316 #endif
02317 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
02318 { "XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS, CONFSTR },
02319 #endif
02320 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
02321 { "XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS, CONFSTR },
02322 #endif
02323
02324 #ifdef _SC_V6_ILP32_OFF32
02325 { "_POSIX_V6_ILP32_OFF32", _SC_V6_ILP32_OFF32, SYSCONF },
02326 #endif
02327 #ifdef _CS_POSIX_V6_ILP32_OFF32_CFLAGS
02328 { "POSIX_V6_ILP32_OFF32_CFLAGS", _CS_POSIX_V6_ILP32_OFF32_CFLAGS, CONFSTR },
02329 #endif
02330 #ifdef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
02331 { "POSIX_V6_ILP32_OFF32_LDFLAGS", _CS_POSIX_V6_ILP32_OFF32_LDFLAGS, CONFSTR },
02332 #endif
02333 #ifdef _CS_POSIX_V6_ILP32_OFF32_LIBS
02334 { "POSIX_V6_ILP32_OFF32_LIBS", _CS_POSIX_V6_ILP32_OFF32_LIBS, CONFSTR },
02335 #endif
02336 #ifdef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
02337 { "POSIX_V6_ILP32_OFF32_LINTFLAGS", _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS, CONFSTR },
02338 #endif
02339
02340 #ifdef _CS_V6_WIDTH_RESTRICTED_ENVS
02341 { "_POSIX_V6_WIDTH_RESTRICTED_ENVS", _CS_V6_WIDTH_RESTRICTED_ENVS, CONFSTR },
02342 #endif
02343
02344 #ifdef _SC_V6_ILP32_OFFBIG
02345 { "_POSIX_V6_ILP32_OFFBIG", _SC_V6_ILP32_OFFBIG, SYSCONF },
02346 #endif
02347 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
02348 { "POSIX_V6_ILP32_OFFBIG_CFLAGS", _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS, CONFSTR },
02349 #endif
02350 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
02351 { "POSIX_V6_ILP32_OFFBIG_LDFLAGS", _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS, CONFSTR },
02352 #endif
02353 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LIBS
02354 { "POSIX_V6_ILP32_OFFBIG_LIBS", _CS_POSIX_V6_ILP32_OFFBIG_LIBS, CONFSTR },
02355 #endif
02356 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
02357 { "POSIX_V6_ILP32_OFFBIG_LINTFLAGS", _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS, CONFSTR },
02358 #endif
02359
02360 #ifdef _SC_V6_LP64_OFF64
02361 { "_POSIX_V6_LP64_OFF64", _SC_V6_LP64_OFF64, SYSCONF },
02362 #endif
02363 #ifdef _CS_POSIX_V6_LP64_OFF64_CFLAGS
02364 { "POSIX_V6_LP64_OFF64_CFLAGS", _CS_POSIX_V6_LP64_OFF64_CFLAGS, CONFSTR },
02365 #endif
02366 #ifdef _CS_POSIX_V6_LP64_OFF64_LDFLAGS
02367 { "POSIX_V6_LP64_OFF64_LDFLAGS", _CS_POSIX_V6_LP64_OFF64_LDFLAGS, CONFSTR },
02368 #endif
02369 #ifdef _CS_POSIX_V6_LP64_OFF64_LIBS
02370 { "POSIX_V6_LP64_OFF64_LIBS", _CS_POSIX_V6_LP64_OFF64_LIBS, CONFSTR },
02371 #endif
02372 #ifdef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
02373 { "POSIX_V6_LP64_OFF64_LINTFLAGS", _CS_POSIX_V6_LP64_OFF64_LINTFLAGS, CONFSTR },
02374 #endif
02375
02376 #ifdef _SC_V6_LPBIG_OFFBIG
02377 { "_POSIX_V6_LPBIG_OFFBIG", _SC_V6_LPBIG_OFFBIG, SYSCONF },
02378 #endif
02379 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
02380 { "POSIX_V6_LPBIG_OFFBIG_CFLAGS", _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS, CONFSTR },
02381 #endif
02382 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
02383 { "POSIX_V6_LPBIG_OFFBIG_LDFLAGS", _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS, CONFSTR },
02384 #endif
02385 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
02386 { "POSIX_V6_LPBIG_OFFBIG_LIBS", _CS_POSIX_V6_LPBIG_OFFBIG_LIBS, CONFSTR },
02387 #endif
02388 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
02389 { "POSIX_V6_LPBIG_OFFBIG_LINTFLAGS", _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS, CONFSTR },
02390 #endif
02391
02392 #ifdef _SC_ADVISORY_INFO
02393 { "_POSIX_ADVISORY_INFO", _SC_ADVISORY_INFO, SYSCONF },
02394 #endif
02395 #ifdef _SC_BARRIERS
02396 { "_POSIX_BARRIERS", _SC_BARRIERS, SYSCONF },
02397 #endif
02398 #ifdef _SC_BASE
02399 { "_POSIX_BASE", _SC_BASE, SYSCONF },
02400 #endif
02401 #ifdef _SC_C_LANG_SUPPORT
02402 { "_POSIX_C_LANG_SUPPORT", _SC_C_LANG_SUPPORT, SYSCONF },
02403 #endif
02404 #ifdef _SC_C_LANG_SUPPORT_R
02405 { "_POSIX_C_LANG_SUPPORT_R", _SC_C_LANG_SUPPORT_R, SYSCONF },
02406 #endif
02407 #ifdef _SC_CLOCK_SELECTION
02408 { "_POSIX_CLOCK_SELECTION", _SC_CLOCK_SELECTION, SYSCONF },
02409 #endif
02410 #ifdef _SC_CPUTIME
02411 { "_POSIX_CPUTIME", _SC_CPUTIME, SYSCONF },
02412 #endif
02413 #ifdef _SC_THREAD_CPUTIME
02414 { "_POSIX_THREAD_CPUTIME", _SC_THREAD_CPUTIME, SYSCONF },
02415 #endif
02416 #ifdef _SC_DEVICE_SPECIFIC
02417 { "_POSIX_DEVICE_SPECIFIC", _SC_DEVICE_SPECIFIC, SYSCONF },
02418 #endif
02419 #ifdef _SC_DEVICE_SPECIFIC_R
02420 { "_POSIX_DEVICE_SPECIFIC_R", _SC_DEVICE_SPECIFIC_R, SYSCONF },
02421 #endif
02422 #ifdef _SC_FD_MGMT
02423 { "_POSIX_FD_MGMT", _SC_FD_MGMT, SYSCONF },
02424 #endif
02425 #ifdef _SC_FIFO
02426 { "_POSIX_FIFO", _SC_FIFO, SYSCONF },
02427 #endif
02428 #ifdef _SC_PIPE
02429 { "_POSIX_PIPE", _SC_PIPE, SYSCONF },
02430 #endif
02431 #ifdef _SC_FILE_ATTRIBUTES
02432 { "_POSIX_FILE_ATTRIBUTES", _SC_FILE_ATTRIBUTES, SYSCONF },
02433 #endif
02434 #ifdef _SC_FILE_LOCKING
02435 { "_POSIX_FILE_LOCKING", _SC_FILE_LOCKING, SYSCONF },
02436 #endif
02437 #ifdef _SC_FILE_SYSTEM
02438 { "_POSIX_FILE_SYSTEM", _SC_FILE_SYSTEM, SYSCONF },
02439 #endif
02440 #ifdef _SC_MONOTONIC_CLOCK
02441 { "_POSIX_MONOTONIC_CLOCK", _SC_MONOTONIC_CLOCK, SYSCONF },
02442 #endif
02443 #ifdef _SC_MULTI_PROCESS
02444 { "_POSIX_MULTI_PROCESS", _SC_MULTI_PROCESS, SYSCONF },
02445 #endif
02446 #ifdef _SC_SINGLE_PROCESS
02447 { "_POSIX_SINGLE_PROCESS", _SC_SINGLE_PROCESS, SYSCONF },
02448 #endif
02449 #ifdef _SC_NETWORKING
02450 { "_POSIX_NETWORKING", _SC_NETWORKING, SYSCONF },
02451 #endif
02452 #ifdef _SC_READER_WRITER_LOCKS
02453 { "_POSIX_READER_WRITER_LOCKS", _SC_READER_WRITER_LOCKS, SYSCONF },
02454 #endif
02455 #ifdef _SC_SPIN_LOCKS
02456 { "_POSIX_SPIN_LOCKS", _SC_SPIN_LOCKS, SYSCONF },
02457 #endif
02458 #ifdef _SC_REGEXP
02459 { "_POSIX_REGEXP", _SC_REGEXP, SYSCONF },
02460 #endif
02461 #ifdef _SC_REGEX_VERSION
02462 { "_REGEX_VERSION", _SC_REGEX_VERSION, SYSCONF },
02463 #endif
02464 #ifdef _SC_SHELL
02465 { "_POSIX_SHELL", _SC_SHELL, SYSCONF },
02466 #endif
02467 #ifdef _SC_SIGNALS
02468 { "_POSIX_SIGNALS", _SC_SIGNALS, SYSCONF },
02469 #endif
02470 #ifdef _SC_SPAWN
02471 { "_POSIX_SPAWN", _SC_SPAWN, SYSCONF },
02472 #endif
02473 #ifdef _SC_SPORADIC_SERVER
02474 { "_POSIX_SPORADIC_SERVER", _SC_SPORADIC_SERVER, SYSCONF },
02475 #endif
02476 #ifdef _SC_THREAD_SPORADIC_SERVER
02477 { "_POSIX_THREAD_SPORADIC_SERVER", _SC_THREAD_SPORADIC_SERVER, SYSCONF },
02478 #endif
02479 #ifdef _SC_SYSTEM_DATABASE
02480 { "_POSIX_SYSTEM_DATABASE", _SC_SYSTEM_DATABASE, SYSCONF },
02481 #endif
02482 #ifdef _SC_SYSTEM_DATABASE_R
02483 { "_POSIX_SYSTEM_DATABASE_R", _SC_SYSTEM_DATABASE_R, SYSCONF },
02484 #endif
02485 #ifdef _SC_TIMEOUTS
02486 { "_POSIX_TIMEOUTS", _SC_TIMEOUTS, SYSCONF },
02487 #endif
02488 #ifdef _SC_TYPED_MEMORY_OBJECTS
02489 { "_POSIX_TYPED_MEMORY_OBJECTS", _SC_TYPED_MEMORY_OBJECTS, SYSCONF },
02490 #endif
02491 #ifdef _SC_USER_GROUPS
02492 { "_POSIX_USER_GROUPS", _SC_USER_GROUPS, SYSCONF },
02493 #endif
02494 #ifdef _SC_USER_GROUPS_R
02495 { "_POSIX_USER_GROUPS_R", _SC_USER_GROUPS_R, SYSCONF },
02496 #endif
02497 #ifdef _SC_2_PBS
02498 { "POSIX2_PBS", _SC_2_PBS, SYSCONF },
02499 #endif
02500 #ifdef _SC_2_PBS_ACCOUNTING
02501 { "POSIX2_PBS_ACCOUNTING", _SC_2_PBS_ACCOUNTING, SYSCONF },
02502 #endif
02503 #ifdef _SC_2_PBS_LOCATE
02504 { "POSIX2_PBS_LOCATE", _SC_2_PBS_LOCATE, SYSCONF },
02505 #endif
02506 #ifdef _SC_2_PBS_TRACK
02507 { "POSIX2_PBS_TRACK", _SC_2_PBS_TRACK, SYSCONF },
02508 #endif
02509 #ifdef _SC_2_PBS_MESSAGE
02510 { "POSIX2_PBS_MESSAGE", _SC_2_PBS_MESSAGE, SYSCONF },
02511 #endif
02512 #ifdef _SC_SYMLOOP_MAX
02513 { "SYMLOOP_MAX", _SC_SYMLOOP_MAX, SYSCONF },
02514 #endif
02515 #ifdef _SC_STREAM_MAX
02516 { "STREAM_MAX", _SC_STREAM_MAX, SYSCONF },
02517 #endif
02518 #ifdef _SC_AIO_LISTIO_MAX
02519 { "AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX, SYSCONF },
02520 #endif
02521 #ifdef _SC_AIO_MAX
02522 { "AIO_MAX", _SC_AIO_MAX, SYSCONF },
02523 #endif
02524 #ifdef _SC_AIO_PRIO_DELTA_MAX
02525 { "AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX, SYSCONF },
02526 #endif
02527 #ifdef _SC_DELAYTIMER_MAX
02528 { "DELAYTIMER_MAX", _SC_DELAYTIMER_MAX, SYSCONF },
02529 #endif
02530 #ifdef _SC_HOST_NAME_MAX
02531 { "HOST_NAME_MAX", _SC_HOST_NAME_MAX, SYSCONF },
02532 #endif
02533 #ifdef _SC_LOGIN_NAME_MAX
02534 { "LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX, SYSCONF },
02535 #endif
02536 #ifdef _SC_MQ_OPEN_MAX
02537 { "MQ_OPEN_MAX", _SC_MQ_OPEN_MAX, SYSCONF },
02538 #endif
02539 #ifdef _SC_MQ_PRIO_MAX
02540 { "MQ_PRIO_MAX", _SC_MQ_PRIO_MAX, SYSCONF },
02541 #endif
02542 #ifdef _SC_DEVICE_IO
02543 { "_POSIX_DEVICE_IO", _SC_DEVICE_IO, SYSCONF },
02544 #endif
02545 #ifdef _SC_TRACE
02546 { "_POSIX_TRACE", _SC_TRACE, SYSCONF },
02547 #endif
02548 #ifdef _SC_TRACE_EVENT_FILTER
02549 { "_POSIX_TRACE_EVENT_FILTER", _SC_TRACE_EVENT_FILTER, SYSCONF },
02550 #endif
02551 #ifdef _SC_TRACE_INHERIT
02552 { "_POSIX_TRACE_INHERIT", _SC_TRACE_INHERIT, SYSCONF },
02553 #endif
02554 #ifdef _SC_TRACE_LOG
02555 { "_POSIX_TRACE_LOG", _SC_TRACE_LOG, SYSCONF },
02556 #endif
02557 #ifdef _SC_RTSIG_MAX
02558 { "RTSIG_MAX", _SC_RTSIG_MAX, SYSCONF },
02559 #endif
02560 #ifdef _SC_SEM_NSEMS_MAX
02561 { "SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX, SYSCONF },
02562 #endif
02563 #ifdef _SC_SEM_VALUE_MAX
02564 { "SEM_VALUE_MAX", _SC_SEM_VALUE_MAX, SYSCONF },
02565 #endif
02566 #ifdef _SC_SIGQUEUE_MAX
02567 { "SIGQUEUE_MAX", _SC_SIGQUEUE_MAX, SYSCONF },
02568 #endif
02569 #ifdef _PC_FILESIZEBITS
02570 { "FILESIZEBITS", _PC_FILESIZEBITS, PATHCONF },
02571 #endif
02572 #ifdef _PC_ALLOC_SIZE_MIN
02573 { "POSIX_ALLOC_SIZE_MIN", _PC_ALLOC_SIZE_MIN, PATHCONF },
02574 #endif
02575 #ifdef _PC_REC_INCR_XFER_SIZE
02576 { "POSIX_REC_INCR_XFER_SIZE", _PC_REC_INCR_XFER_SIZE, PATHCONF },
02577 #endif
02578 #ifdef _PC_REC_MAX_XFER_SIZE
02579 { "POSIX_REC_MAX_XFER_SIZE", _PC_REC_MAX_XFER_SIZE, PATHCONF },
02580 #endif
02581 #ifdef _PC_REC_MIN_XFER_SIZE
02582 { "POSIX_REC_MIN_XFER_SIZE", _PC_REC_MIN_XFER_SIZE, PATHCONF },
02583 #endif
02584 #ifdef _PC_REC_XFER_ALIGN
02585 { "POSIX_REC_XFER_ALIGN", _PC_REC_XFER_ALIGN, PATHCONF },
02586 #endif
02587 #ifdef _PC_SYMLINK_MAX
02588 { "SYMLINK_MAX", _PC_SYMLINK_MAX, PATHCONF },
02589 #endif
02590 #ifdef _CS_GNU_LIBC_VERSION
02591 { "GNU_LIBC_VERSION", _CS_GNU_LIBC_VERSION, CONFSTR },
02592 #endif
02593 #ifdef _CS_GNU_LIBPTHREAD_VERSION
02594 { "GNU_LIBPTHREAD_VERSION", _CS_GNU_LIBPTHREAD_VERSION, CONFSTR },
02595 #endif
02596 #ifdef _PC_2_SYMLINKS
02597 { "POSIX2_SYMLINKS", _PC_2_SYMLINKS, PATHCONF },
02598 #endif
02599
02600 #ifdef _SC_LEVEL1_ICACHE_SIZE
02601 { "LEVEL1_ICACHE_SIZE", _SC_LEVEL1_ICACHE_SIZE, SYSCONF },
02602 #endif
02603 #ifdef _SC_LEVEL1_ICACHE_ASSOC
02604 { "LEVEL1_ICACHE_ASSOC", _SC_LEVEL1_ICACHE_ASSOC, SYSCONF },
02605 #endif
02606 #ifdef _SC_LEVEL1_ICACHE_LINESIZE
02607 { "LEVEL1_ICACHE_LINESIZE", _SC_LEVEL1_ICACHE_LINESIZE, SYSCONF },
02608 #endif
02609 #ifdef _SC_LEVEL1_DCACHE_SIZE
02610 { "LEVEL1_DCACHE_SIZE", _SC_LEVEL1_DCACHE_SIZE, SYSCONF },
02611 #endif
02612 #ifdef _SC_LEVEL1_DCACHE_ASSOC
02613 { "LEVEL1_DCACHE_ASSOC", _SC_LEVEL1_DCACHE_ASSOC, SYSCONF },
02614 #endif
02615 #ifdef _SC_LEVEL1_DCACHE_LINESIZE
02616 { "LEVEL1_DCACHE_LINESIZE", _SC_LEVEL1_DCACHE_LINESIZE, SYSCONF },
02617 #endif
02618 #ifdef _SC_LEVEL2_CACHE_SIZE
02619 { "LEVEL2_CACHE_SIZE", _SC_LEVEL2_CACHE_SIZE, SYSCONF },
02620 #endif
02621 #ifdef _SC_LEVEL2_CACHE_ASSOC
02622 { "LEVEL2_CACHE_ASSOC", _SC_LEVEL2_CACHE_ASSOC, SYSCONF },
02623 #endif
02624 #ifdef _SC_LEVEL2_CACHE_LINESIZE
02625 { "LEVEL2_CACHE_LINESIZE", _SC_LEVEL2_CACHE_LINESIZE, SYSCONF },
02626 #endif
02627 #ifdef _SC_LEVEL3_CACHE_SIZE
02628 { "LEVEL3_CACHE_SIZE", _SC_LEVEL3_CACHE_SIZE, SYSCONF },
02629 #endif
02630 #ifdef _SC_LEVEL3_CACHE_ASSOC
02631 { "LEVEL3_CACHE_ASSOC", _SC_LEVEL3_CACHE_ASSOC, SYSCONF },
02632 #endif
02633 #ifdef _SC_LEVEL3_CACHE_LINESIZE
02634 { "LEVEL3_CACHE_LINESIZE", _SC_LEVEL3_CACHE_LINESIZE, SYSCONF },
02635 #endif
02636 #ifdef _SC_LEVEL4_CACHE_SIZE
02637 { "LEVEL4_CACHE_SIZE", _SC_LEVEL4_CACHE_SIZE, SYSCONF },
02638 #endif
02639 #ifdef _SC_LEVEL4_CACHE_ASSOC
02640 { "LEVEL4_CACHE_ASSOC", _SC_LEVEL4_CACHE_ASSOC, SYSCONF },
02641 #endif
02642
02643 #ifdef _SC_IPV6
02644 { "IPV6", _SC_IPV6, SYSCONF },
02645 #endif
02646 #ifdef _SC_RAW_SOCKETS
02647 { "RAW_SOCKETS", _SC_RAW_SOCKETS, SYSCONF },
02648 #endif
02649
02650 { NULL, 0, SYSCONF }
02651 };
02652
02653 #define _GETCONF_PATH "/"
02654
02655 static const char *_getconf_path = NULL;
02656
02657 int
02658 rpmdsGetconf(rpmds * dsp, const char *path)
02659
02660
02661 {
02662 const struct conf *c;
02663 size_t clen;
02664 long int value;
02665 const char * NS = "getconf";
02666 const char *N;
02667 char * EVR;
02668 char * t;
02669 evrFlags Flags;
02670
02671
02672 if (_getconf_path == NULL) {
02673 _getconf_path = rpmExpand("%{?_rpmds__getconf_path}", NULL);
02674
02675 if (!(_getconf_path != NULL && *_getconf_path == '/')) {
02676
02677 _getconf_path = _free(_getconf_path);
02678
02679 _getconf_path = xstrdup(_GETCONF_PATH);
02680 }
02681 }
02682
02683
02684 if (path == NULL)
02685 path = _getconf_path;
02686
02687 for (c = vars; c->name != NULL; ++c) {
02688 N = c->name;
02689 EVR = NULL;
02690 switch (c->call) {
02691 case PATHCONF:
02692 value = pathconf(path, c->call_name);
02693 if (value != -1) {
02694 EVR = xmalloc(32);
02695 sprintf(EVR, "%ld", value);
02696 }
02697 break;
02698 case SYSCONF:
02699 value = sysconf(c->call_name);
02700 if (value == -1l) {
02701 #if defined(_SC_UINT_MAX) && defined(_SC_ULONG_MAX)
02702
02703 if (c->call_name == _SC_UINT_MAX
02704 || c->call_name == _SC_ULONG_MAX) {
02705 EVR = xmalloc(32);
02706 sprintf(EVR, "%lu", value);
02707 }
02708
02709 #endif
02710 } else {
02711 EVR = xmalloc(32);
02712 sprintf(EVR, "%ld", value);
02713 }
02714 break;
02715 case CONFSTR:
02716 #ifndef __CYGWIN__
02717 clen = confstr(c->call_name, (char *) NULL, 0);
02718 EVR = xmalloc(clen+1);
02719 *EVR = '\0';
02720 if (confstr (c->call_name, EVR, clen) != clen) {
02721 fprintf(stderr, "confstr: %s\n", strerror(errno));
02722 exit (EXIT_FAILURE);
02723 }
02724 EVR[clen] = '\0';
02725 #endif
02726 break;
02727 }
02728 if (EVR == NULL)
02729 continue;
02730
02731 for (t = EVR; *t; t++) {
02732 if (*t == '\n') *t = ' ';
02733 }
02734 if (!strcmp(N, "GNU_LIBC_VERSION")
02735 || !strcmp(N, "GNU_LIBPTHREAD_VERSION"))
02736 {
02737 for (t = EVR; *t; t++) {
02738 if (*t == ' ') *t = '-';
02739 }
02740 }
02741
02742 if (*EVR == '\0' || strchr(EVR, ' ') != NULL
02743 || (EVR[0] == '-' && strchr("0123456789", EVR[1]) == NULL))
02744 {
02745 EVR = _free(EVR);
02746 continue;
02747 }
02748
02749 Flags = RPMSENSE_PROBE|RPMSENSE_EQUAL;
02750 rpmdsNSAdd(dsp, NS, N, EVR, Flags);
02751 EVR = _free(EVR);
02752 }
02753 return 0;
02754 }
02755
02756 int rpmdsMergePRCO(void * context, rpmds ds)
02757 {
02758 rpmPRCO PRCO = context;
02759 int rc = -1;
02760
02761
02762 if (_rpmds_debug < 0)
02763 fprintf(stderr, "*** rpmdsMergePRCO(%p, %p) %s\n", context, ds, rpmdsTagName(rpmdsTagN(ds)));
02764
02765 switch(rpmdsTagN(ds)) {
02766 default:
02767 break;
02768 case RPMTAG_PROVIDENAME:
02769 rc = rpmdsMerge(PRCO->Pdsp, ds);
02770 break;
02771 case RPMTAG_REQUIRENAME:
02772 rc = rpmdsMerge(PRCO->Rdsp, ds);
02773 break;
02774 case RPMTAG_CONFLICTNAME:
02775 rc = rpmdsMerge(PRCO->Cdsp, ds);
02776 break;
02777 case RPMTAG_OBSOLETENAME:
02778 rc = rpmdsMerge(PRCO->Odsp, ds);
02779 break;
02780 case RPMTAG_TRIGGERNAME:
02781 rc = rpmdsMerge(PRCO->Tdsp, ds);
02782 break;
02783 case RPMTAG_DIRNAMES:
02784 rc = rpmdsMerge(PRCO->Ddsp, ds);
02785 break;
02786 case RPMTAG_FILELINKTOS:
02787 rc = rpmdsMerge(PRCO->Ldsp, ds);
02788 break;
02789 }
02790 return rc;
02791 }
02792
02793 rpmPRCO rpmdsFreePRCO(rpmPRCO PRCO)
02794 {
02795 if (PRCO) {
02796 (void)rpmdsFree(PRCO->this);
02797 PRCO->this = NULL;
02798 (void)rpmdsFree(PRCO->P);
02799 PRCO->P = NULL;
02800 (void)rpmdsFree(PRCO->R);
02801 PRCO->R = NULL;
02802 (void)rpmdsFree(PRCO->C);
02803 PRCO->C = NULL;
02804 (void)rpmdsFree(PRCO->O);
02805 PRCO->O = NULL;
02806 (void)rpmdsFree(PRCO->T);
02807 PRCO->T = NULL;
02808 (void)rpmdsFree(PRCO->D);
02809 PRCO->D = NULL;
02810 (void)rpmdsFree(PRCO->L);
02811 PRCO->L = NULL;
02812 memset(PRCO, 0, sizeof(*PRCO));
02813 PRCO = _free(PRCO);
02814 }
02815 return NULL;
02816 }
02817
02818 rpmPRCO rpmdsNewPRCO(Header h)
02819 {
02820 rpmPRCO PRCO = xcalloc(1, sizeof(*PRCO));
02821
02822 if (h != NULL) {
02823 static int scareMem = 0;
02824 PRCO->this = rpmdsNew(h, RPMTAG_NAME, scareMem);
02825 PRCO->P = rpmdsNew(h, RPMTAG_PROVIDENAME, scareMem);
02826 PRCO->R = rpmdsNew(h, RPMTAG_REQUIRENAME, scareMem);
02827 PRCO->C = rpmdsNew(h, RPMTAG_CONFLICTNAME, scareMem);
02828 PRCO->O = rpmdsNew(h, RPMTAG_OBSOLETENAME, scareMem);
02829 PRCO->T = rpmdsNew(h, RPMTAG_TRIGGERNAME, scareMem);
02830 PRCO->D = rpmdsNew(h, RPMTAG_DIRNAMES, scareMem);
02831 PRCO->L = rpmdsNew(h, RPMTAG_FILELINKTOS, scareMem);
02832 }
02833 PRCO->Pdsp = &PRCO->P;
02834 PRCO->Rdsp = &PRCO->R;
02835 PRCO->Cdsp = &PRCO->C;
02836 PRCO->Odsp = &PRCO->O;
02837 PRCO->Tdsp = &PRCO->T;
02838 PRCO->Ddsp = &PRCO->D;
02839 PRCO->Ldsp = &PRCO->L;
02840 return PRCO;
02841 }
02842
02843 rpmds rpmdsFromPRCO(rpmPRCO PRCO, rpmTag tagN)
02844 {
02845
02846 if (PRCO != NULL)
02847 switch (tagN) {
02848 default: break;
02849 case RPMTAG_NAME: return PRCO->this; break;
02850 case RPMTAG_PROVIDENAME: return *PRCO->Pdsp; break;
02851 case RPMTAG_REQUIRENAME: return *PRCO->Rdsp; break;
02852 case RPMTAG_CONFLICTNAME: return *PRCO->Cdsp; break;
02853 case RPMTAG_OBSOLETENAME: return *PRCO->Odsp; break;
02854 case RPMTAG_TRIGGERNAME: return *PRCO->Tdsp; break;
02855 case RPMTAG_DIRNAMES: return *PRCO->Ddsp; break;
02856 case RPMTAG_FILELINKTOS: return *PRCO->Ldsp; break;
02857 }
02858 return NULL;
02859
02860 }
02861
02868 #if defined(HAVE_GELF_H) && defined(HAVE_LIBELF) && !defined(__FreeBSD__)
02869 static char * sonameDep( char * t, const char * s, int isElf64)
02870
02871 {
02872 *t = '\0';
02873 #if !defined(__alpha__) && !defined(__sun)
02874 if (isElf64) {
02875 if (s[strlen(s)-1] != ')')
02876 (void) stpcpy( stpcpy(t, s), "()(64bit)");
02877 else
02878 (void) stpcpy( stpcpy(t, s), "(64bit)");
02879 }else
02880 #endif
02881 (void) stpcpy(t, s);
02882 return t;
02883 }
02884 #endif
02885
02886
02887 int rpmdsELF(const char * fn, int flags,
02888 int (*add) (void * context, rpmds ds), void * context)
02889 {
02890 #if defined(HAVE_GELF_H) && defined(HAVE_LIBELF) && !defined(__FreeBSD__)
02891 Elf * elf;
02892 Elf_Scn * scn;
02893 Elf_Data * data;
02894 GElf_Ehdr ehdr_mem, * ehdr;
02895 GElf_Shdr shdr_mem, * shdr;
02896 GElf_Verdef def_mem, * def;
02897 GElf_Verneed need_mem, * need;
02898 GElf_Dyn dyn_mem, * dyn;
02899 unsigned int auxoffset;
02900 unsigned int offset;
02901 int fdno;
02902 int cnt2;
02903 int cnt;
02904 char buf[BUFSIZ];
02905 const char * s;
02906 int is_executable;
02907 const char * soname = NULL;
02908 rpmds ds;
02909 char * t;
02910 int xx;
02911 int isElf64;
02912 int isDSO;
02913 int gotSONAME = 0;
02914 int gotDEBUG = 0;
02915 int gotHASH = 0;
02916 int gotGNUHASH = 0;
02917 int skipP = (flags & RPMELF_FLAG_SKIPPROVIDES);
02918 int skipR = (flags & RPMELF_FLAG_SKIPREQUIRES);
02919 static int filter_GLIBC_PRIVATE = 0;
02920 static int oneshot = 0;
02921
02922
02923 if (_rpmds_debug < 0)
02924 fprintf(stderr, "*** rpmdsELF(%s, %d, %p, %p)\n", fn, flags, (void *)add, context);
02925
02926 if (oneshot == 0) {
02927 oneshot = 1;
02928 filter_GLIBC_PRIVATE = rpmExpandNumeric("%{?_filter_GLIBC_PRIVATE}");
02929 }
02930
02931
02932 { struct stat sb, * st = &sb;
02933 if (stat(fn, st) != 0)
02934 return -1;
02935 is_executable = (int)(st->st_mode & (S_IXUSR|S_IXGRP|S_IXOTH));
02936 }
02937
02938 fdno = open(fn, O_RDONLY);
02939 if (fdno < 0)
02940 return fdno;
02941
02942 (void) elf_version(EV_CURRENT);
02943
02944
02945 elf = NULL;
02946 if ((elf = elf_begin (fdno, ELF_C_READ, NULL)) == NULL
02947 || elf_kind(elf) != ELF_K_ELF
02948 || (ehdr = gelf_getehdr(elf, &ehdr_mem)) == NULL
02949 || !(ehdr->e_type == ET_DYN || ehdr->e_type == ET_EXEC))
02950 goto exit;
02951
02952
02953 isElf64 = ehdr->e_ident[EI_CLASS] == ELFCLASS64;
02954 isDSO = ehdr->e_type == ET_DYN;
02955
02956
02957 scn = NULL;
02958 while ((scn = elf_nextscn(elf, scn)) != NULL) {
02959 shdr = gelf_getshdr(scn, &shdr_mem);
02960 if (shdr == NULL)
02961 break;
02962
02963 soname = _free(soname);
02964 switch (shdr->sh_type) {
02965 default:
02966 continue;
02967 break;
02968 case SHT_GNU_verdef:
02969 data = NULL;
02970 if (!skipP)
02971 while ((data = elf_getdata (scn, data)) != NULL) {
02972 offset = 0;
02973 for (cnt = (int)shdr->sh_info; --cnt >= 0; ) {
02974
02975 def = gelf_getverdef (data, offset, &def_mem);
02976 if (def == NULL)
02977 break;
02978 auxoffset = (unsigned)(offset + def->vd_aux);
02979 for (cnt2 = (int)def->vd_cnt; --cnt2 >= 0; ) {
02980 GElf_Verdaux aux_mem, * aux;
02981
02982 aux = gelf_getverdaux (data, auxoffset, &aux_mem);
02983 if (aux == NULL)
02984 break;
02985
02986 s = elf_strptr(elf, shdr->sh_link, aux->vda_name);
02987 if (s == NULL)
02988 break;
02989
02990 if (def->vd_flags & VER_FLG_BASE) {
02991 soname = _free(soname);
02992 soname = xstrdup(s);
02993 } else
02994 if (soname != NULL
02995 && !(filter_GLIBC_PRIVATE != 0
02996 && !strcmp(s, "GLIBC_PRIVATE")))
02997 {
02998 buf[0] = '\0';
02999 t = buf;
03000 t = stpcpy( stpcpy( stpcpy( stpcpy(t, soname), "("), s), ")");
03001
03002 t++;
03003
03004
03005 ds = rpmdsSingle(RPMTAG_PROVIDES,
03006 sonameDep(t, buf, isElf64),
03007 "", RPMSENSE_FIND_PROVIDES);
03008 xx = add(context, ds);
03009 (void)rpmdsFree(ds);
03010 ds = NULL;
03011 }
03012 auxoffset += aux->vda_next;
03013 }
03014 offset += def->vd_next;
03015 }
03016 }
03017 break;
03018 case SHT_GNU_verneed:
03019 data = NULL;
03020
03021 if (!skipR && is_executable)
03022 while ((data = elf_getdata (scn, data)) != NULL) {
03023 offset = 0;
03024 for (cnt = (int)shdr->sh_info; --cnt >= 0; ) {
03025 need = gelf_getverneed (data, offset, &need_mem);
03026 if (need == NULL)
03027 break;
03028
03029 s = elf_strptr(elf, shdr->sh_link, need->vn_file);
03030 if (s == NULL)
03031 break;
03032 soname = _free(soname);
03033 soname = xstrdup(s);
03034 auxoffset = (unsigned)(offset + need->vn_aux);
03035 for (cnt2 = (int)need->vn_cnt; --cnt2 >= 0; ) {
03036 GElf_Vernaux aux_mem, * aux;
03037
03038 aux = gelf_getvernaux (data, auxoffset, &aux_mem);
03039 if (aux == NULL)
03040 break;
03041
03042 s = elf_strptr(elf, shdr->sh_link, aux->vna_name);
03043 if (s == NULL)
03044 break;
03045
03046
03047 if (soname != NULL
03048 && !(filter_GLIBC_PRIVATE != 0
03049 && !strcmp(s, "GLIBC_PRIVATE")))
03050 {
03051 buf[0] = '\0';
03052 t = buf;
03053 t = stpcpy( stpcpy( stpcpy( stpcpy(t, soname), "("), s), ")");
03054
03055 t++;
03056
03057
03058 ds = rpmdsSingle(RPMTAG_REQUIRENAME,
03059 sonameDep(t, buf, isElf64),
03060 "", RPMSENSE_FIND_REQUIRES);
03061 xx = add(context, ds);
03062 (void)rpmdsFree(ds);
03063 ds = NULL;
03064 }
03065 auxoffset += aux->vna_next;
03066 }
03067 offset += need->vn_next;
03068 }
03069 }
03070 break;
03071 case SHT_DYNAMIC:
03072 data = NULL;
03073 while ((data = elf_getdata (scn, data)) != NULL) {
03074 for (cnt = 0; cnt < (int)(shdr->sh_size / shdr->sh_entsize); ++cnt) {
03075 dyn = gelf_getdyn (data, cnt, &dyn_mem);
03076 if (dyn == NULL)
03077 break;
03078 s = NULL;
03079 switch (dyn->d_tag) {
03080 default:
03081 continue;
03082 break;
03083 case DT_HASH:
03084 gotHASH= 1;
03085 continue;
03086 case DT_GNU_HASH:
03087 gotGNUHASH= 1;
03088 continue;
03089 case DT_DEBUG:
03090 gotDEBUG = 1;
03091 continue;
03092 case DT_NEEDED:
03093
03094 if (skipR || !is_executable)
03095 continue;
03096
03097 s = elf_strptr(elf, shdr->sh_link, dyn->d_un.d_val);
03098 assert(s != NULL);
03099 buf[0] = '\0';
03100 ds = rpmdsSingle(RPMTAG_REQUIRENAME,
03101 sonameDep(buf, s, isElf64),
03102 "", RPMSENSE_FIND_REQUIRES);
03103 xx = add(context, ds);
03104 (void)rpmdsFree(ds);
03105 ds = NULL;
03106 break;
03107 case DT_SONAME:
03108 gotSONAME = 1;
03109 if (skipP)
03110 continue;
03111 s = elf_strptr(elf, shdr->sh_link, dyn->d_un.d_val);
03112 assert(s != NULL);
03113
03114 buf[0] = '\0';
03115 ds = rpmdsSingle(RPMTAG_PROVIDENAME,
03116 sonameDep(buf, s, isElf64),
03117 "", RPMSENSE_FIND_PROVIDES);
03118 xx = add(context, ds);
03119 (void)rpmdsFree(ds);
03120 ds = NULL;
03121 break;
03122 }
03123 }
03124 }
03125 break;
03126 }
03127 }
03128
03129
03130
03131
03132 if (gotGNUHASH && !gotHASH) {
03133 ds = rpmdsSingle(RPMTAG_REQUIRENAME, "rtld(GNU_HASH)", "",
03134 RPMSENSE_FIND_REQUIRES);
03135 xx = add(context, ds);
03136 (void)rpmdsFree(ds);
03137 ds = NULL;
03138 }
03139
03140
03141 if (!skipP && isDSO && !gotDEBUG && !gotSONAME) {
03142 s = strrchr(fn, '/');
03143 if (s != NULL)
03144 s++;
03145 else
03146 s = fn;
03147 assert(s != NULL);
03148
03149
03150 buf[0] = '\0';
03151 ds = rpmdsSingle(RPMTAG_PROVIDENAME,
03152 sonameDep(buf, s, isElf64), "", RPMSENSE_FIND_PROVIDES);
03153 xx = add(context, ds);
03154 (void)rpmdsFree(ds);
03155 ds = NULL;
03156 }
03157
03158 exit:
03159 soname = _free(soname);
03160 if (elf) (void) elf_end(elf);
03161 if (fdno > 0)
03162 xx = close(fdno);
03163 return 0;
03164 #else
03165 return -1;
03166 #endif
03167 }
03168
03169
03170 #define _SBIN_LDCONFIG_P "/sbin/ldconfig -p"
03171
03172 static const char * _ldconfig_cmd = _SBIN_LDCONFIG_P;
03173
03174 #define _LD_SO_CACHE "/etc/ld.so.cache"
03175
03176 static const char * _ldconfig_cache = NULL;
03177
03178 int rpmdsLdconfig(rpmPRCO PRCO, const char * fn)
03179
03180
03181 {
03182 char buf[BUFSIZ];
03183 const char *DSOfn;
03184 const char *N, *EVR;
03185 evrFlags Flags = 0;
03186 rpmds ds;
03187 char * f, * fe;
03188 char * g, * ge;
03189 char * t;
03190 FILE * fp = NULL;
03191 int rc = -1;
03192 int xx;
03193
03194 if (PRCO == NULL)
03195 return -1;
03196
03197
03198 if (_ldconfig_cmd == NULL) {
03199 _ldconfig_cmd = rpmExpand("%{?_rpmds_ldconfig_cmd}", NULL);
03200 if (!(_ldconfig_cmd != NULL && *_ldconfig_cmd == '/')) {
03201
03202 _ldconfig_cmd = _free(_ldconfig_cmd);
03203
03204 _ldconfig_cmd = xstrdup(_SBIN_LDCONFIG_P);
03205 }
03206 }
03207
03208 if (_ldconfig_cache == NULL) {
03209 _ldconfig_cache = rpmExpand("%{?_rpmds_ldconfig_cache}", NULL);
03210
03211 if (!(_ldconfig_cache != NULL && *_ldconfig_cache == '/')) {
03212
03213 _ldconfig_cache = _free(_ldconfig_cache);
03214
03215 _ldconfig_cache = xstrdup(_LD_SO_CACHE);
03216 }
03217 }
03218
03219
03220 if (fn == NULL)
03221 fn = _ldconfig_cache;
03222
03223 if (_rpmds_debug < 0)
03224 fprintf(stderr, "*** rpmdsLdconfig(%p, %s) P %p R %p C %p O %p T %p D %p L %p\n", PRCO, fn, PRCO->Pdsp, PRCO->Rdsp, PRCO->Cdsp, PRCO->Odsp, PRCO->Tdsp, PRCO->Ddsp, PRCO->Ldsp);
03225
03226 fp = popen(_ldconfig_cmd, "r");
03227 if (fp == NULL)
03228 goto exit;
03229
03230 while((f = fgets(buf, (int)sizeof(buf), fp)) != NULL) {
03231 EVR = NULL;
03232
03233 ge = f + strlen(f);
03234 while (--ge > f && _isspace(*ge))
03235 *ge = '\0';
03236
03237
03238 while (*f && _isspace(*f))
03239 f++;
03240
03241
03242 fe = f;
03243 while (*fe && !(fe[0] == '=' && fe[1] == '>'))
03244 fe++;
03245 if (*fe == '\0')
03246 continue;
03247
03248
03249 DSOfn = fe + 2;
03250
03251
03252 while (*DSOfn && _isspace(*DSOfn))
03253 DSOfn++;
03254 if (*DSOfn == '\0')
03255 continue;
03256
03257
03258 if (fe > f && fe[-1] == ' ') fe[-1] = '\0';
03259 *fe++ = '\0';
03260 *fe++ = '\0';
03261 g = fe;
03262
03263
03264 while (*g && _isspace(*g))
03265 g++;
03266 if (*g == '\0')
03267 continue;
03268
03269
03270 for (t = f; *t != '\0'; t++) {
03271 if (!_isspace(*t))
03272 continue;
03273 *t++ = '\0';
03274 break;
03275 }
03276
03277
03278
03279
03280
03281
03282
03283
03284
03285 N = f;
03286 if (EVR == NULL)
03287 EVR = "";
03288 Flags |= RPMSENSE_PROBE;
03289 ds = rpmdsSingle(RPMTAG_PROVIDENAME, N, EVR, Flags);
03290 xx = rpmdsMerge(PRCO->Pdsp, ds);
03291 (void)rpmdsFree(ds);
03292 ds = NULL;
03293
03294 xx = rpmdsELF(DSOfn, 0, rpmdsMergePRCO, PRCO);
03295 }
03296 rc = 0;
03297
03298 exit:
03299 if (fp != NULL) (void) pclose(fp);
03300 return rc;
03301 }
03302
03303
03304 #if defined(__sun)
03305 #define _RLD_SEARCH_PATH "/lib:/usr/lib"
03306
03307 static const char * _rld_search_path = NULL;
03308
03309
03310 int rpmdsRldpath(rpmPRCO PRCO, const char * rldp)
03311
03312
03313 {
03314 char buf[BUFSIZ];
03315 const char *N, *EVR;
03316 evrFlags Flags = 0;
03317 rpmds ds;
03318 const char * f;
03319 const char * g;
03320 int rc = -1;
03321 int xx;
03322 glob_t gl;
03323 char ** gp;
03324
03325 if (PRCO == NULL)
03326 return -1;
03327
03328
03329 if (_rld_search_path == NULL) {
03330 _rld_search_path = rpmExpand("%{?_rpmds_rld_search_path}", NULL);
03331
03332 if (!(_rld_search_path != NULL && *_rld_search_path == '/')) {
03333
03334 _rld_search_path = _free(_rld_search_path);
03335
03336 _rld_search_path = xstrdup(_RLD_SEARCH_PATH);
03337 }
03338 }
03339
03340
03341 if (rldp == NULL)
03342 rldp = _rld_search_path;
03343
03344 if (_rpmds_debug > 0)
03345 fprintf(stderr, "*** rpmdsRldpath(%p, %s) P %p R %p C %p O %p\n", PRCO, rldp, PRCO->Pdsp, PRCO->Rdsp, PRCO->Cdsp, PRCO->Odsp);
03346
03347 f = rldp;
03348
03349 while (f) {
03350 EVR = NULL;
03351 g = strchr(f, ':');
03352 if (g == NULL) {
03353 strcpy(buf, f);
03354
03355 f = NULL;
03356 } else {
03357
03358 strncpy(buf, f, g - f + 1);
03359 buf[g-f] = '\0';
03360
03361
03362 f = g + 1;
03363 }
03364
03365 if ( !(strlen(buf) > 0 && buf[0] == '/') )
03366 continue;
03367
03368
03369
03370 strcat(buf, "/*.so.*");
03371
03372 if (_rpmds_debug > 0)
03373 fprintf(stderr, "*** rpmdsRldpath(%p, %s) globbing %s\n", PRCO, rldp, buf);
03374
03375 xx = Glob(buf, 0, NULL, &gl);
03376 if (xx)
03377 continue;
03378
03379 if (_rpmds_debug > 0)
03380 fprintf(stderr, "*** rpmdsRldpath(%p, %s) glob matched %d files\n", PRCO, rldp, gl.gl_pathc);
03381
03382 gp = gl.gl_pathv;
03383
03384 while (gp && *gp) {
03385 const char *DSOfn;
03386
03387 DSOfn = *gp;
03388 gp++;
03389 if (EVR == NULL)
03390 EVR = "";
03391
03392
03393 N = DSOfn + strlen(DSOfn);
03394 while (N > DSOfn && *N != '/')
03395 --N;
03396
03397 Flags |= RPMSENSE_PROBE;
03398 ds = rpmdsSingle(RPMTAG_PROVIDENAME, N, EVR, Flags);
03399 xx = rpmdsMerge(PRCO->Pdsp, ds);
03400 (void)rpmdsFree(ds);
03401 ds = NULL;
03402
03403 xx = rpmdsELF(DSOfn, 0, rpmdsMergePRCO, PRCO);
03404 }
03405
03406 Globfree(&gl);
03407
03408 }
03409 rc = 0;
03410
03411 return rc;
03412 }
03413
03414 #define _SOLARIS_CRLE "/usr/sbin/crle"
03415
03416 static const char * _crle_cmd = NULL;
03417
03418 int rpmdsCrle(rpmPRCO PRCO, const char * fn)
03419
03420
03421 {
03422 char buf[BUFSIZ];
03423 char * f;
03424 char * g, * ge;
03425 FILE * fp = NULL;
03426 int rc = -1;
03427 int xx;
03428 int found_dlp = 0;
03429
03430 if (PRCO == NULL)
03431 return -1;
03432
03433
03434 if (_crle_cmd == NULL) {
03435 _crle_cmd = rpmExpand("%{?_rpmds_crle_cmd}", NULL);
03436 if (!(_crle_cmd != NULL && *_crle_cmd == '/')) {
03437
03438 _crle_cmd = _free(_crle_cmd);
03439
03440 _crle_cmd = xstrdup(_SOLARIS_CRLE);
03441 }
03442 }
03443
03444
03445 fp = popen(_crle_cmd, "r");
03446 if (fp == NULL)
03447 return rc;
03448
03449
03450
03451
03452
03453
03454 while((f = fgets(buf, sizeof(buf), fp)) != NULL) {
03455 if (found_dlp)
03456 continue;
03457
03458 g = strstr(f, "(ELF):");
03459 if (g == NULL)
03460 continue;
03461
03462 found_dlp = 1;
03463 f = g + (sizeof("(ELF):")-1);
03464 while (_isspace(*f))
03465 f++;
03466
03467
03468 ge = f + strlen(f);
03469 while (--ge > f && _isspace(*ge))
03470 *ge = '\0';
03471 }
03472 xx = pclose(fp);
03473
03474
03475 if (found_dlp)
03476 rc = rpmdsRldpath(PRCO, f);
03477
03478 return rc;
03479 }
03480 #endif
03481
03482 int rpmdsUname(rpmds *dsp, const struct utsname * un)
03483 {
03484
03485 static const char * NS = "uname";
03486 struct utsname myun;
03487 int rc = -1;
03488 int xx;
03489
03490 if (un == NULL) {
03491 xx = uname(&myun);
03492 if (xx != 0)
03493 goto exit;
03494 un = &myun;
03495 }
03496
03497
03498
03499 if (un->sysname != NULL)
03500 rpmdsNSAdd(dsp, NS, "sysname", un->sysname, RPMSENSE_EQUAL);
03501 if (un->nodename != NULL)
03502 rpmdsNSAdd(dsp, NS, "nodename", un->nodename, RPMSENSE_EQUAL);
03503 if (un->release != NULL)
03504 rpmdsNSAdd(dsp, NS, "release", un->release, RPMSENSE_EQUAL);
03505 #if 0
03506 if (un->version != NULL)
03507 rpmdsNSAdd(dsp, NS, "version", un->version, RPMSENSE_EQUAL);
03508 #endif
03509 if (un->machine != NULL)
03510 rpmdsNSAdd(dsp, NS, "machine", un->machine, RPMSENSE_EQUAL);
03511 #if defined(__linux__)
03512 if (un->domainname != NULL && strcmp(un->domainname, "(none)"))
03513 rpmdsNSAdd(dsp, NS, "domainname", un->domainname, RPMSENSE_EQUAL);
03514 #endif
03515
03516 rc = 0;
03517
03518 exit:
03519 return rc;
03520 }
03521
03522 #define _PERL_PROVIDES "/usr/bin/find /usr/lib/perl5 | /usr/lib/rpm/perl.prov"
03523
03524 static const char * _perldeps_cmd = NULL;
03525
03526 int rpmdsPipe(rpmds * dsp, rpmTag tagN, const char * cmd)
03527
03528
03529 {
03530 char buf[BUFSIZ];
03531 const char *N, *EVR;
03532 evrFlags Flags = 0;
03533 rpmds ds;
03534 char * f, * fe;
03535 char * g, * ge;
03536 FILE * fp = NULL;
03537 const char * fn = "pipe";
03538 int rc = -1;
03539 int cmdprinted;
03540 int ln;
03541 int xx;
03542
03543
03544 if (_perldeps_cmd == NULL) {
03545 _perldeps_cmd = rpmExpand("%{?_rpmds_perldeps_cmd}", NULL);
03546
03547 if (!(_perldeps_cmd != NULL && *_perldeps_cmd == '/')) {
03548
03549 _perldeps_cmd = _free(_perldeps_cmd);
03550
03551 _perldeps_cmd = xstrdup(_PERL_PROVIDES);
03552 }
03553 }
03554
03555
03556 if (tagN <= 0)
03557 tagN = RPMTAG_PROVIDENAME;
03558 if (cmd == NULL)
03559 cmd = _perldeps_cmd;
03560
03561 fp = popen(cmd, "r");
03562 if (fp == NULL)
03563 goto exit;
03564
03565 ln = 0;
03566 cmdprinted = 0;
03567 while((f = fgets(buf, (int)sizeof(buf), fp)) != NULL) {
03568 ln++;
03569
03570
03571 buf[sizeof(buf)-1] = '\0';
03572
03573
03574 while (*f && _isspace(*f))
03575 f++;
03576
03577
03578 if (*f == '\0' || *f == '#')
03579 continue;
03580
03581
03582 fe = f + strlen(f);
03583 while (--fe > f && _isspace(*fe))
03584 *fe = '\0';
03585
03586
03587 fe = f;
03588 if (*f == '!') fe++;
03589 while (*fe && !_isspace(*fe) && strchr("!<=>", *fe) == NULL)
03590 fe++;
03591 while (*fe && _isspace(*fe))
03592 *fe++ = '\0';
03593
03594 if (!(xisalnum(f[0]) || strchr("/_%!", f[0]) != NULL)) {
03595 if (!cmdprinted++)
03596 fprintf(stderr, _("running \"%s\" pipe command\n"), cmd);
03597 fprintf(stderr, _("%s:%d \"%s\" has invalid name. Skipping ...\n"),
03598 fn, ln, f);
03599 continue;
03600 }
03601
03602 N = f;
03603 EVR = NULL;
03604 Flags = 0;
03605
03606
03607 if (*f != '/' && *fe != '\0') {
03608
03609 g = fe;
03610 Flags = rpmEVRflags(fe, (const char **)&g);
03611 if (Flags == 0) {
03612 if (!cmdprinted++)
03613 fprintf(stderr, _("running \"%s\" pipe command\n"), cmd),
03614 fprintf(stderr, _("%s:%d \"%s\" has no comparison operator. Skipping ...\n"),
03615 fn, ln, fe);
03616 continue;
03617 }
03618 *fe = '\0';
03619
03620
03621 while (*g && _isspace(*g))
03622 g++;
03623 if (*g == '\0') {
03624 if (!cmdprinted++)
03625 fprintf(stderr, _("running \"%s\" pipe command\n"), cmd),
03626
03627 fprintf(stderr, _("\tline %d: No EVR comparison value found.\n Skipping ..."),
03628 ln);
03629 fprintf(stderr, _("%s:%d \"%s\" has no EVR string. Skipping ...\n"),
03630 fn, ln, f);
03631 continue;
03632 }
03633
03634 ge = g + 1;
03635 while (*ge && !_isspace(*ge))
03636 ge++;
03637
03638 if (*ge != '\0')
03639 *ge = '\0';
03640
03641 EVR = g;
03642 }
03643
03644 if (EVR == NULL)
03645 EVR = "";
03646 Flags |= RPMSENSE_PROBE;
03647 ds = rpmdsSingle(tagN, N, EVR, Flags);
03648 xx = rpmdsMerge(dsp, ds);
03649 (void)rpmdsFree(ds);
03650 ds = NULL;
03651 }
03652 rc = 0;
03653
03654 exit:
03655 if (fp != NULL) (void) pclose(fp);
03656 return rc;
03657 }
03658
03659 static int rpmdsNAcmp(rpmds A, rpmds B)
03660
03661 {
03662 const char * AN = A->ns.N;
03663 const char * AA = A->ns.A;
03664 const char * BN = B->ns.N;
03665 const char * BA = B->ns.A;
03666 int rc;
03667
03668 if (!AA && !BA) {
03669 rc = strcmp(AN, BN);
03670 } else if (AA && !BA) {
03671 rc = strncmp(AN, BN, (AA - AN)) || BN[AA - AN];
03672 if (!rc)
03673 rc = strcmp(AA, B->A);
03674 } else if (!AA && BA) {
03675 rc = strncmp(AN, BN, (BA - BN)) || AN[BA - BN];
03676 if (!rc)
03677 rc = strcmp(BA, A->A);
03678 } else {
03679 rc = strcmp(AN, BN);
03680 }
03681 return rc;
03682 }
03683
03684
03685 const char * evr_tuple_order = NULL;
03686
03691
03692 static const char * rpmdsEVRorder(void)
03693
03694
03695 {
03696 if (evr_tuple_order == NULL) {
03697
03698 evr_tuple_order = rpmExpand("%{?evr_tuple_order}", NULL);
03699
03700 if (evr_tuple_order == NULL || evr_tuple_order[0] == '\0')
03701 evr_tuple_order = xstrdup("EVR");
03702 }
03703 assert(evr_tuple_order != NULL && evr_tuple_order[0] != '\0');
03704
03705 return evr_tuple_order;
03706
03707 }
03708
03709 int rpmdsCompare(const rpmds A, const rpmds B)
03710 {
03711 const char *aDepend = (A->DNEVR != NULL ? xstrdup(A->DNEVR+2) : "");
03712 const char *bDepend = (B->DNEVR != NULL ? xstrdup(B->DNEVR+2) : "");
03713 EVR_t a = memset(alloca(sizeof(*a)), 0, sizeof(*a));
03714 EVR_t b = memset(alloca(sizeof(*a)), 0, sizeof(*a));
03715 evrFlags aFlags = A->ns.Flags;
03716 evrFlags bFlags = B->ns.Flags;
03717 int (*EVRcmp) (const char *a, const char *b);
03718 int result = 1;
03719 const char * s;
03720 int sense;
03721 int xx;
03722
03723 assert((rpmdsFlags(A) & RPMSENSE_SENSEMASK) == A->ns.Flags);
03724 assert((rpmdsFlags(B) & RPMSENSE_SENSEMASK) == B->ns.Flags);
03725
03726 if (rpmdsNAcmp(A, B)) {
03727 result = 0;
03728 goto exit;
03729 }
03730
03731
03732
03733 if (!(A->EVR && A->Flags && B->EVR && B->Flags))
03734 goto exit;
03735
03736
03737 if (!(aFlags && bFlags))
03738 goto exit;
03739
03740
03741 if (!(A->EVR[A->i] && *A->EVR[A->i] && B->EVR[B->i] && *B->EVR[B->i]))
03742 goto exit;
03743
03744
03745 xx = (A->EVRparse ? A->EVRparse : rpmEVRparse) (A->EVR[A->i], a);
03746 xx = (B->EVRparse ? B->EVRparse : rpmEVRparse) (B->EVR[B->i], b);
03747
03748
03749 EVRcmp = (A->EVRcmp && B->EVRcmp && A->EVRcmp == B->EVRcmp)
03750 ? A->EVRcmp : rpmvercmp;
03751
03752
03753 sense = 0;
03754 for (s = rpmdsEVRorder(); *s; s++) {
03755 int ix;
03756 switch ((int)*s) {
03757 default: continue; break;
03758 case 'E':
03759 ix = RPMEVR_E;
03760 if (a->F[ix] && *a->F[ix] && b->F[ix] && *b->F[ix])
03761 break;
03762
03763 if (a->F[ix] && *a->F[ix] && atol(a->F[ix]) > 0) {
03764 if (!B->nopromote) {
03765 int lvl = (_rpmds_unspecified_epoch_noise
03766 ? RPMLOG_WARNING : RPMLOG_DEBUG);
03767 rpmlog(lvl, _("The \"B\" dependency needs an epoch (assuming same epoch as \"A\")\n\tA = \"%s\"\tB = \"%s\"\n"),
03768 aDepend, bDepend);
03769 sense = 0;
03770 } else
03771 sense = 1;
03772 } else
03773 if (b->F[ix] && *b->F[ix] && atol(b->F[ix]) > 0)
03774 sense = -1;
03775 break;
03776 case 'V': ix = RPMEVR_V; break;
03777 case 'R': ix = RPMEVR_R; break;
03778 case 'D': ix = RPMEVR_D; break;
03779 }
03780 if (a->F[ix] && *a->F[ix] && b->F[ix] && *b->F[ix])
03781 sense = EVRcmp(a->F[ix], b->F[ix]);
03782 if (sense)
03783 break;
03784 }
03785
03786 a->str = _free(a->str);
03787 b->str = _free(b->str);
03788
03789
03790 if (aFlags == RPMSENSE_NOTEQUAL || bFlags == RPMSENSE_NOTEQUAL) {
03791 result = (sense != 0);
03792 } else if (sense < 0 && ((aFlags & RPMSENSE_GREATER) || (bFlags & RPMSENSE_LESS))) {
03793 result = 1;
03794 } else if (sense > 0 && ((aFlags & RPMSENSE_LESS) || (bFlags & RPMSENSE_GREATER))) {
03795 result = 1;
03796 } else if (sense == 0 &&
03797 (((aFlags & RPMSENSE_EQUAL) && (bFlags & RPMSENSE_EQUAL)) ||
03798 ((aFlags & RPMSENSE_LESS) && (bFlags & RPMSENSE_LESS)) ||
03799 ((aFlags & RPMSENSE_GREATER) && (bFlags & RPMSENSE_GREATER)))) {
03800 result = 1;
03801 } else
03802 result = 0;
03803
03804
03805 exit:
03806 if (_noisy_range_comparison_debug_message)
03807 rpmlog(RPMLOG_DEBUG, _(" %s A %s\tB %s\n"),
03808 (result ? _("YES") : _("NO ")), aDepend, bDepend);
03809 aDepend = _free(aDepend);
03810 bDepend = _free(bDepend);
03811 return result;
03812 }
03813
03814 int rpmdsMatch(const rpmds A, rpmds B)
03815 {
03816 int result = 0;
03817
03818
03819 if ((B = rpmdsInit(B)) != NULL)
03820 while (rpmdsNext(B) >= 0)
03821 if ((result = rpmdsCompare(A, B)))
03822 break;
03823 return result;
03824 }
03825
03826 void rpmdsProblem(rpmps ps, const char * pkgNEVR, const rpmds ds,
03827 const fnpyKey * suggestedKeys, int adding)
03828 {
03829 const char * Name = rpmdsN(ds);
03830 const char * DNEVR = rpmdsDNEVR(ds);
03831 const char * EVR = rpmdsEVR(ds);
03832 rpmProblemType type;
03833 fnpyKey key;
03834
03835 if (ps == NULL) return;
03836
03837 if (Name == NULL) Name = "?N?";
03838 if (EVR == NULL) EVR = "?EVR?";
03839 if (DNEVR == NULL) DNEVR = "? ?N? ?OP? ?EVR?";
03840
03841 rpmlog(RPMLOG_DEBUG, D_("package %s has unsatisfied %s: %s\n"),
03842 pkgNEVR, ds->Type, DNEVR+2);
03843
03844 switch ((unsigned)DNEVR[0]) {
03845 case 'C': type = RPMPROB_CONFLICT; break;
03846 default:
03847 case 'R': type = RPMPROB_REQUIRES; break;
03848 }
03849
03850 key = (suggestedKeys ? suggestedKeys[0] : NULL);
03851 rpmpsAppend(ps, type, pkgNEVR, key, NULL, NULL, DNEVR, adding);
03852 }
03853
03854 int rpmdsAnyMatchesDep (const Header h, const rpmds req, int nopromote)
03855 {
03856 int scareMem = 0;
03857 rpmds provides = NULL;
03858 evrFlags reqFlags = req->ns.Flags;
03859 int result = 1;
03860
03861 assert((rpmdsFlags(req) & RPMSENSE_SENSEMASK) == req->ns.Flags);
03862
03863 if (req->EVR == NULL || req->Flags == NULL)
03864 goto exit;
03865
03866 switch(req->ns.Type) {
03867 default:
03868
03869 if (!reqFlags || !req->EVR[req->i] || *req->EVR[req->i] == '\0')
03870 goto exit;
03871
03872 case RPMNS_TYPE_ARCH:
03873 break;
03874 }
03875
03876
03877 provides = rpmdsInit(rpmdsNew(h, RPMTAG_PROVIDENAME, scareMem));
03878 if (provides == NULL) {
03879 result = 0;
03880 goto exit;
03881 }
03882 if (nopromote)
03883 (void) rpmdsSetNoPromote(provides, nopromote);
03884
03885
03886
03887
03888
03889
03890 if (provides->EVR == NULL)
03891 goto exit;
03892
03893
03894 result = 0;
03895 if (provides != NULL)
03896 while (rpmdsNext(provides) >= 0)
03897 if ((result = rpmdsCompare(provides, req)))
03898 break;
03899
03900 exit:
03901 (void)rpmdsFree(provides);
03902 provides = NULL;
03903
03904 return result;
03905 }
03906
03907 int rpmdsNVRMatchesDep(const Header h, const rpmds req, int nopromote)
03908 {
03909 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
03910 const char * pkgN, * V, * R;
03911 #ifdef RPM_VENDOR_MANDRIVA
03912 const char * D;
03913 int gotD = 0;
03914 #endif
03915 rpmuint32_t E;
03916 int gotE = 0;
03917 const char * pkgEVR;
03918 char * t;
03919 evrFlags reqFlags = req->ns.Flags;
03920 evrFlags pkgFlags = RPMSENSE_EQUAL;
03921 int result = 1;
03922 rpmds pkg;
03923 size_t nb;
03924
03925 assert((rpmdsFlags(req) & RPMSENSE_SENSEMASK) == req->ns.Flags);
03926
03927 if (req->EVR == NULL || req->Flags == NULL)
03928 goto exit;
03929
03930 if (!(reqFlags && req->EVR[req->i] && *req->EVR[req->i]))
03931 goto exit;
03932
03933
03934
03935 (void) headerNEVRA(h, &pkgN, NULL, &V, &R, NULL);
03936
03937 he->tag = RPMTAG_EPOCH;
03938 gotE = headerGet(h, he, 0);
03939 E = (he->p.ui32p ? he->p.ui32p[0] : 0);
03940 he->p.ptr = _free(he->p.ptr);
03941
03942 #if defined(NOTYET) || defined(RPM_VENDOR_MANDRIVA)
03943 he->tag = RPMTAG_DISTEPOCH;
03944 gotD = headerGet(h, he, 0);
03945 D = (he->p.str ? he->p.str : NULL);
03946 #endif
03947
03948 nb = 21 + 1 + 1;
03949 if (V) nb += strlen(V);
03950 if (R) nb += strlen(R);
03951 #ifdef RPM_VENDOR_MANDRIVA
03952 if (gotD) nb += strlen(D) + 1;
03953 #endif
03954 pkgEVR = t = alloca(nb);
03955 *t = '\0';
03956 if (gotE) {
03957 sprintf(t, "%d:", E);
03958 t += strlen(t);
03959 }
03960 t = stpcpy( stpcpy( stpcpy(t, V) , "-") , R);
03961 #ifdef RPM_VENDOR_MANDRIVA
03962 if (gotD) {
03963 t = stpcpy( stpcpy( t, ":"), D);
03964 D = _free(D);
03965 }
03966 #endif
03967 V = _free(V);
03968 R = _free(R);
03969
03970 if ((pkg = rpmdsSingle(RPMTAG_PROVIDENAME, pkgN, pkgEVR, pkgFlags)) != NULL) {
03971 if (nopromote)
03972 (void) rpmdsSetNoPromote(pkg, nopromote);
03973 result = rpmdsCompare(pkg, req);
03974 (void)rpmdsFree(pkg);
03975 pkg = NULL;
03976 }
03977 pkgN = _free(pkgN);
03978
03979 exit:
03980 return result;
03981 }
03982
03983 int rpmdsNegateRC(const rpmds ds, int rc)
03984 {
03985 if (ds->ns.str[0] == '!')
03986 rc = (rc == 0);
03987 return rc;
03988 }