00001
00005 #include "system.h"
00006
00007 #include <rpmiotypes.h>
00008 #include <rpmmacro.h>
00009
00010 #define _RPMTAG_INTERNAL
00011 #include "header_internal.h"
00012
00013 #include "debug.h"
00014
00019
00020 static struct tagMacro {
00021
00022 const char *macroname;
00023 rpmTag tag;
00024 } tagMacros[] = {
00025 { "name", RPMTAG_NAME },
00026 { "version", RPMTAG_VERSION },
00027 { "release", RPMTAG_RELEASE },
00028 { "distepoch", RPMTAG_DISTEPOCH },
00029 { "epoch", RPMTAG_EPOCH },
00030 { "arch", RPMTAG_ARCH },
00031 { "os", RPMTAG_OS },
00032 { NULL, 0 }
00033 };
00034
00035
00036 int headerMacrosLoad(Header h)
00037
00038
00039 {
00040 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00041 struct tagMacro * tagm;
00042 char numbuf[64];
00043 const char * val;
00044 rpmuint64_t ival;
00045 int xx;
00046
00047 numbuf[0] = '\0';
00048
00049 { const char *s = rpmExpand("%{?buildroot}", NULL);
00050 if (s && *s)
00051 (void) addMacro(NULL, "..buildroot", NULL, s, -1);
00052 s = _free(s);
00053 }
00054 { const char *s = rpmExpand("%{?_builddir}", NULL);
00055 if (s && *s)
00056 (void) addMacro(NULL, ".._builddir", NULL, s, -1);
00057 s = _free(s);
00058 }
00059
00060 for (tagm = tagMacros; tagm->macroname != NULL; tagm++) {
00061 he->tag = tagm->tag;
00062 xx = headerGet(h, he, 0);
00063 if (!xx)
00064 continue;
00065 val = NULL;
00066 ival = 0;
00067 switch (he->t) {
00068 case RPM_UINT8_TYPE:
00069 ival = (rpmuint64_t)he->p.ui8p[0];
00070 val = numbuf;
00071 break;
00072 case RPM_UINT16_TYPE:
00073 ival = (rpmuint64_t)he->p.ui16p[0];
00074 val = numbuf;
00075 break;
00076 case RPM_UINT32_TYPE:
00077 ival = (rpmuint64_t)he->p.ui32p[0];
00078 val = numbuf;
00079 break;
00080 case RPM_UINT64_TYPE:
00081 ival = he->p.ui64p[0];
00082 val = numbuf;
00083 break;
00084 case RPM_STRING_TYPE:
00085 val = he->p.str;
00086 break;
00087 case RPM_STRING_ARRAY_TYPE:
00088 case RPM_I18NSTRING_TYPE:
00089 case RPM_BIN_TYPE:
00090 default:
00091 break;
00092 }
00093
00094 if (val) {
00095
00096 if (val == numbuf)
00097 sprintf(numbuf, "%llu", (unsigned long long)ival);
00098
00099 addMacro(NULL, tagm->macroname, NULL, val, -1);
00100 }
00101 he->p.ptr = _free(he->p.ptr);
00102 }
00103 return 0;
00104 }
00105
00106
00107
00108 int headerMacrosUnload(Header h)
00109
00110
00111 {
00112 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00113 struct tagMacro * tagm;
00114 int xx;
00115
00116 for (tagm = tagMacros; tagm->macroname != NULL; tagm++) {
00117 he->tag = tagm->tag;
00118 xx = headerGet(h, he, 0);
00119 if (!xx)
00120 continue;
00121 switch (he->t) {
00122 case RPM_UINT32_TYPE:
00123 delMacro(NULL, tagm->macroname);
00124 break;
00125 case RPM_STRING_TYPE:
00126 delMacro(NULL, tagm->macroname);
00127 break;
00128 case RPM_STRING_ARRAY_TYPE:
00129 case RPM_I18NSTRING_TYPE:
00130 case RPM_BIN_TYPE:
00131 case RPM_UINT8_TYPE:
00132 case RPM_UINT16_TYPE:
00133 case RPM_UINT64_TYPE:
00134 default:
00135 break;
00136 }
00137 he->p.ptr = _free(he->p.ptr);
00138 }
00139
00140
00141 { const char *s = rpmExpand("%{?_builddir}", NULL);
00142 if (s && *s)
00143 (void) delMacro(NULL, "_builddir");
00144 s = _free(s);
00145 }
00146 { const char *s = rpmExpand("%{?buildroot}", NULL);
00147 if (s && *s)
00148 (void) delMacro(NULL, "buildroot");
00149 s = _free(s);
00150 }
00151
00152 return 0;
00153 }
00154
00155
00156 int headerNEVRA(Header h, const char **np, const char **ep,
00157 const char **vp, const char **rp, const char **ap)
00158 {
00159 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00160
00161
00162 if (np) {
00163 he->tag = RPMTAG_NAME;
00164 if (headerGet(h, he, 0)
00165 && he->t == RPM_STRING_TYPE && he->c == 1)
00166 *np = xstrdup(he->p.str);
00167 else
00168 *np = NULL;
00169 he->p.ptr = _free(he->p.ptr);
00170 }
00171 if (vp) {
00172 he->tag = RPMTAG_VERSION;
00173 if (headerGet(h, he, 0)
00174 && he->t == RPM_STRING_TYPE && he->c == 1)
00175 *vp = xstrdup(he->p.str);
00176 else
00177 *vp = NULL;
00178 he->p.ptr = _free(he->p.ptr);
00179 }
00180 if (rp) {
00181 he->tag = RPMTAG_RELEASE;
00182 if (headerGet(h, he, 0)
00183 && he->t == RPM_STRING_TYPE && he->c == 1)
00184 *rp = xstrdup(he->p.str);
00185 else
00186 *rp = NULL;
00187 he->p.ptr = _free(he->p.ptr);
00188 }
00189 if (ap) {
00190 #if !defined(RPM_VENDOR_OPENPKG)
00191
00192
00193
00194
00195
00196 he->tag = RPMTAG_ARCH;
00197
00198 if (!headerIsEntry(h, he->tag))
00199 *ap = xstrdup("pubkey");
00200 else
00201 if (!headerIsEntry(h, RPMTAG_SOURCERPM))
00202 *ap = xstrdup("src");
00203
00204 else
00205 if (headerGet(h, he, 0)
00206 && he->t == RPM_STRING_TYPE && he->c == 1)
00207 *ap = xstrdup(he->p.str);
00208 else
00209 #endif
00210 *ap = NULL;
00211 he->p.ptr = _free(he->p.ptr);
00212 }
00213
00214 return 0;
00215 }
00216
00217 rpmuint32_t hGetColor(Header h)
00218 {
00219 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00220 rpmuint32_t hcolor = 0;
00221 int xx;
00222
00223 he->tag = RPMTAG_FILECOLORS;
00224 xx = headerGet(h, he, 0);
00225 if (xx && he->p.ptr != NULL && he->c > 0) {
00226 unsigned i;
00227 for (i = 0; i < (unsigned) he->c; i++)
00228 hcolor |= he->p.ui32p[i];
00229 }
00230 he->p.ptr = _free(he->p.ptr);
00231 hcolor &= 0x0f;
00232
00233 return hcolor;
00234 }
00235
00236 void headerMergeLegacySigs(Header h, const Header sigh)
00237 {
00238 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00239 HeaderIterator hi;
00240 int xx;
00241
00242 if (h == NULL || sigh == NULL)
00243 return;
00244
00245 for (hi = headerInit(sigh);
00246 headerNext(hi, he, 0);
00247 he->p.ptr = _free(he->p.ptr))
00248 {
00249
00250 switch ((rpmSigTag)he->tag) {
00251 case RPMSIGTAG_SIZE:
00252 he->tag = RPMTAG_SIGSIZE;
00253 break;
00254 case RPMSIGTAG_MD5:
00255 he->tag = RPMTAG_SIGMD5;
00256 break;
00257 case RPMSIGTAG_PAYLOADSIZE:
00258 he->tag = RPMTAG_ARCHIVESIZE;
00259 break;
00260 case RPMSIGTAG_SHA1:
00261 case RPMSIGTAG_DSA:
00262 case RPMSIGTAG_RSA:
00263 default:
00264
00265 if (!(he->tag >= HEADER_SIGBASE && he->tag < HEADER_TAGBASE))
00266 continue;
00267 break;
00268 }
00269 assert(he->p.ptr != NULL);
00270 if (!headerIsEntry(h, he->tag)) {
00271 if (hdrchkType(he->t))
00272 continue;
00273 if (hdrchkData(he->c))
00274 continue;
00275 switch(he->t) {
00276 default:
00277 assert(0);
00278 break;
00279 case RPM_UINT8_TYPE:
00280 case RPM_UINT16_TYPE:
00281 case RPM_UINT32_TYPE:
00282 case RPM_UINT64_TYPE:
00283 if (he->c != 1)
00284 continue;
00285 break;
00286 case RPM_STRING_TYPE:
00287 case RPM_BIN_TYPE:
00288 if (he->c >= 16*1024)
00289 continue;
00290 break;
00291 case RPM_STRING_ARRAY_TYPE:
00292 case RPM_I18NSTRING_TYPE:
00293 continue;
00294 break;
00295 }
00296 xx = headerPut(h, he, 0);
00297 assert(xx == 1);
00298 }
00299 }
00300 hi = headerFini(hi);
00301 }
00302
00303 Header headerRegenSigHeader(const Header h, int noArchiveSize)
00304 {
00305 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00306 Header sigh = headerNew();
00307 HeaderIterator hi;
00308 int xx;
00309
00310 for (hi = headerInit(h);
00311 headerNext(hi, he, 0);
00312 he->p.ptr = _free(he->p.ptr))
00313 {
00314
00315 switch (he->tag) {
00316 case RPMTAG_SIGSIZE:
00317 he->tag = (rpmTag) RPMSIGTAG_SIZE;
00318 break;
00319 case RPMTAG_SIGMD5:
00320 he->tag = (rpmTag) RPMSIGTAG_MD5;
00321 break;
00322 case RPMTAG_ARCHIVESIZE:
00323
00324 if (noArchiveSize)
00325 continue;
00326 he->tag = (rpmTag) RPMSIGTAG_PAYLOADSIZE;
00327 break;
00328 case RPMTAG_SHA1HEADER:
00329 case RPMTAG_DSAHEADER:
00330 case RPMTAG_RSAHEADER:
00331 default:
00332
00333 if (!(he->tag >= HEADER_SIGBASE && he->tag < HEADER_TAGBASE))
00334 continue;
00335 break;
00336 }
00337 assert(he->p.ptr != NULL);
00338 if (!headerIsEntry(sigh, he->tag)) {
00339 xx = headerPut(sigh, he, 0);
00340 assert(xx == 1);
00341 }
00342 }
00343 hi = headerFini(hi);
00344 return sigh;
00345 }