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