lib/legacy.c

   1 /**
   2  * \file lib/legacy.c
   3  */
   4
   5 #include "system.h"
   6
   7 #include <rpm/header.h>
   8 #include <rpm/rpmmacro.h>
   9 #include <rpm/rpmstring.h>
  10 #include <rpm/rpmfi.h>
  11 #include <rpm/rpmds.h>
  12
  13 #include "lib/legacy.h"
  14
  15 #include "debug.h"
  16
  17 #define alloca_strdup(_s)       strcpy(alloca(strlen(_s)+1), (_s))
  18
  19 int _noDirTokens = 0;
  20
  21 static int dncmp(const void * a, const void * b)
  22 {
  23     const char *const * first = a;
  24     const char *const * second = b;
  25     return strcmp(*first, *second);
  26 }
  27
  28 void compressFilelist(Header h)
  29 {
  30     HGE_t hge = (HGE_t)headerGetEntryMinMemory;
  31     HAE_t hae = (HAE_t)headerAddEntry;
  32     HRE_t hre = (HRE_t)headerRemoveEntry;
  33     HFD_t hfd = headerFreeData;
  34     char ** fileNames;
  35     char ** dirNames;
  36     const char ** baseNames;
  37     uint32_t * dirIndexes;
  38     rpmTagType fnt;
  39     rpm_count_t count, i;
  40     int xx;
  41     int dirIndex = -1;
  42
  43     /*
  44      * This assumes the file list is already sorted, and begins with a
  45      * single '/'. That assumption isn't critical, but it makes things go
  46      * a bit faster.
  47      */
  48
  49     if (headerIsEntry(h, RPMTAG_DIRNAMES)) {
  50         xx = hre(h, RPMTAG_OLDFILENAMES);
  51         return;         /* Already converted. */
  52     }
  53
  54     if (!hge(h, RPMTAG_OLDFILENAMES, &fnt, (rpm_data_t *) &fileNames, &count))
  55         return;         /* no file list */
  56     if (fileNames == NULL || count <= 0)
  57         return;
  58
  59     dirNames = xmalloc(sizeof(*dirNames) * count);      /* worst case */
  60     baseNames = xmalloc(sizeof(*dirNames) * count);
  61     dirIndexes = xmalloc(sizeof(*dirIndexes) * count);
  62
  63     if (fileNames[0][0] != '/') {
  64         /* HACK. Source RPM, so just do things differently */
  65         dirIndex = 0;
  66         dirNames[dirIndex] = xstrdup("");
  67         for (i = 0; i < count; i++) {
  68             dirIndexes[i] = dirIndex;
  69             baseNames[i] = fileNames[i];
  70         }
  71         goto exit;
  72     }
  73
  74     for (i = 0; i < count; i++) {
  75         char ** needle;
  76         char savechar;
  77         char * baseName;
  78         size_t len;
  79
  80         if (fileNames[i] == NULL)       /* XXX can't happen */
  81             continue;
  82         baseName = strrchr(fileNames[i], '/') + 1;
  83         len = baseName - fileNames[i];
  84         needle = dirNames;
  85         savechar = *baseName;
  86         *baseName = '\0';
  87         if (dirIndex < 0 ||
  88             (needle = bsearch(&fileNames[i], dirNames, dirIndex + 1, sizeof(dirNames[0]), dncmp)) == NULL) {
  89             char *s = xmalloc(len + 1);
  90             rstrlcpy(s, fileNames[i], len + 1);
  91             dirIndexes[i] = ++dirIndex;
  92             dirNames[dirIndex] = s;
  93         } else
  94             dirIndexes[i] = needle - dirNames;
  95
  96         *baseName = savechar;
  97         baseNames[i] = baseName;
  98     }
  99
 100 exit:
 101     if (count > 0) {
 102         xx = hae(h, RPMTAG_DIRINDEXES, RPM_INT32_TYPE, dirIndexes, count);
 103         xx = hae(h, RPMTAG_BASENAMES, RPM_STRING_ARRAY_TYPE,
 104                         baseNames, count);
 105         xx = hae(h, RPMTAG_DIRNAMES, RPM_STRING_ARRAY_TYPE,
 106                         dirNames, (rpm_count_t) dirIndex + 1);
 107     }
 108
 109     fileNames = hfd(fileNames, fnt);
 110     for (i = 0; i <= dirIndex; i++) {
 111         free(dirNames[i]);
 112     }
 113     free(dirNames);
 114     free(baseNames);
 115     free(dirIndexes);
 116
 117     xx = hre(h, RPMTAG_OLDFILENAMES);
 118 }
 119
 120 void expandFilelist(Header h)
 121 {
 122     HAE_t hae = (HAE_t)headerAddEntry;
 123     HRE_t hre = (HRE_t)headerRemoveEntry;
 124     const char ** fileNames = NULL;
 125     rpm_count_t count = 0;
 126     int xx;
 127
 128     if (!headerIsEntry(h, RPMTAG_OLDFILENAMES)) {
 129         rpmfiBuildFNames(h, RPMTAG_BASENAMES, &fileNames, &count);
 130         if (fileNames == NULL || count <= 0)
 131             return;
 132         xx = hae(h, RPMTAG_OLDFILENAMES, RPM_STRING_ARRAY_TYPE,
 133                         fileNames, count);
 134         fileNames = _free(fileNames);
 135     }
 136
 137     xx = hre(h, RPMTAG_DIRNAMES);
 138     xx = hre(h, RPMTAG_BASENAMES);
 139     xx = hre(h, RPMTAG_DIRINDEXES);
 140 }
 141
 142 /*
 143  * Up to rpm 3.0.4, packages implicitly provided their own name-version-release.
 144  * Retrofit an explicit "Provides: name = epoch:version-release.
 145  */
 146 static void providePackageNVR(Header h)
 147 {
 148     HGE_t hge = (HGE_t)headerGetEntryMinMemory;
 149     HFD_t hfd = headerFreeData;
 150     const char *name;
 151     char *pEVR;
 152     rpmsenseFlags pFlags = RPMSENSE_EQUAL;
 153     const char ** provides = NULL;
 154     const char ** providesEVR = NULL;
 155     rpmTagType pnt, pvt;
 156     rpmsenseFlags * provideFlags = NULL;
 157     rpm_count_t providesCount, i;
 158     int xx;
 159     int bingo = 1;
 160
 161     /* Generate provides for this package name-version-release. */
 162     pEVR = headerGetEVR(h, &name);
 163     if (!(name && pEVR))
 164         return;
 165
 166     /*
 167      * Rpm prior to 3.0.3 does not have versioned provides.
 168      * If no provides at all are available, we can just add.
 169      */
 170     if (!hge(h, RPMTAG_PROVIDENAME, &pnt, (rpm_data_t *) &provides, &providesCount))
 171         goto exit;
 172
 173     /*
 174      * Otherwise, fill in entries on legacy packages.
 175      */
 176     if (!hge(h, RPMTAG_PROVIDEVERSION, &pvt, (rpm_data_t *) &providesEVR, NULL)) {
 177         for (i = 0; i < providesCount; i++) {
 178             const char * vdummy = "";
 179             rpmsenseFlags fdummy = RPMSENSE_ANY;
 180             xx = headerAddOrAppendEntry(h, RPMTAG_PROVIDEVERSION, RPM_STRING_ARRAY_TYPE,
 181                         &vdummy, 1);
 182             xx = headerAddOrAppendEntry(h, RPMTAG_PROVIDEFLAGS, RPM_INT32_TYPE,
 183                         &fdummy, 1);
 184         }
 185         goto exit;
 186     }
 187
 188     xx = hge(h, RPMTAG_PROVIDEFLAGS, NULL, (rpm_data_t *) &provideFlags, NULL);
 189
 190         /* LCL: providesEVR is not NULL */
 191     if (provides && providesEVR && provideFlags)
 192     for (i = 0; i < providesCount; i++) {
 193         if (!(provides[i] && providesEVR[i]))
 194             continue;
 195         if (!(provideFlags[i] == RPMSENSE_EQUAL &&
 196             !strcmp(name, provides[i]) && !strcmp(pEVR, providesEVR[i])))
 197             continue;
 198         bingo = 0;
 199         break;
 200     }
 201
 202 exit:
 203     provides = hfd(provides, pnt);
 204     providesEVR = hfd(providesEVR, pvt);
 205
 206     if (bingo) {
 207         xx = headerAddOrAppendEntry(h, RPMTAG_PROVIDENAME, RPM_STRING_ARRAY_TYPE,
 208                 &name, 1);
 209         xx = headerAddOrAppendEntry(h, RPMTAG_PROVIDEFLAGS, RPM_INT32_TYPE,
 210                 &pFlags, 1);
 211         xx = headerAddOrAppendEntry(h, RPMTAG_PROVIDEVERSION, RPM_STRING_ARRAY_TYPE,
 212                 &pEVR, 1);
 213     }
 214     free(pEVR);
 215 }
 216
 217 void legacyRetrofit(Header h)
 218 {
 219     const char * prefix;
 220
 221     /*
 222      * We don't use these entries (and rpm >= 2 never has) and they are
 223      * pretty misleading. Let's just get rid of them so they don't confuse
 224      * anyone.
 225      */
 226     if (headerIsEntry(h, RPMTAG_FILEUSERNAME))
 227         (void) headerRemoveEntry(h, RPMTAG_FILEUIDS);
 228     if (headerIsEntry(h, RPMTAG_FILEGROUPNAME))
 229         (void) headerRemoveEntry(h, RPMTAG_FILEGIDS);
 230
 231     /*
 232      * We switched the way we do relocatable packages. We fix some of
 233      * it up here, though the install code still has to be a bit
 234      * careful. This fixup makes queries give the new values though,
 235      * which is quite handy.
 236      */
 237     if (headerGetEntry(h, RPMTAG_DEFAULTPREFIX, NULL, (rpm_data_t *) &prefix, NULL))
 238     {
 239         char * nprefix = stripTrailingChar(xstrdup(prefix), '/');
 240         (void) headerAddEntry(h, RPMTAG_PREFIXES, RPM_STRING_ARRAY_TYPE,
 241                 &nprefix, 1);
 242         free(nprefix);
 243     }
 244
 245     /*
 246      * The file list was moved to a more compressed format which not
 247      * only saves memory (nice), but gives fingerprinting a nice, fat
 248      * speed boost (very nice). Go ahead and convert old headers to
 249      * the new style (this is a noop for new headers).
 250      */
 251      compressFilelist(h);
 252
 253     /* XXX binary rpms always have RPMTAG_SOURCERPM, source rpms do not */
 254     if (headerIsSource(h)) {
 255         int32_t one = 1;
 256         if (!headerIsEntry(h, RPMTAG_SOURCEPACKAGE))
 257             (void) headerAddEntry(h, RPMTAG_SOURCEPACKAGE, RPM_INT32_TYPE,
 258                                 &one, 1);
 259     } else {
 260         /* Retrofit "Provide: name = EVR" for binary packages. */
 261         providePackageNVR(h);
 262     }
 263 }