13 #define __HEADER_PROTOTYPES__
34 #define PARSER_BEGIN 0
35 #define PARSER_IN_ARRAY 1
36 #define PARSER_IN_EXPR 2
42 0x8e, 0xad, 0xe8, 0x01, 0x00, 0x00, 0x00, 0x00
101 #define hdrchkTags(_ntags) ((_ntags) & 0xffff0000)
106 #define hdrchkType(_type) ((_type) < RPM_MIN_TYPE || (_type) > RPM_MAX_TYPE)
112 #define hdrchkData(_nbytes) ((_nbytes) & 0xff000000)
117 #define hdrchkAlign(_type, _off) ((_off) & (typeAlign[_type]-1))
122 #define hdrchkRange(_dl, _off) ((_off) < 0 || (_off) > (_dl))
151 if (h == NULL)
return NULL;
157 fprintf(stderr,
"--> h %p ++ %d at %s:%u\n", h, h->
nrefs, __FILE__, __LINE__);
174 if (h == NULL)
return NULL;
177 fprintf(stderr,
"--> h %p -- %d at %s:%u\n", h, h->
nrefs, __FILE__, __LINE__);
195 if (h == NULL || h->
nrefs > 0)
201 for (i = 0; i < h->
indexUsed; i++, entry++) {
258 static int indexCmp(
const void * avp,
const void * bvp)
264 return (ap->
info.
tag - bp->info.tag);
283 static int offsetCmp(
const void * avp,
const void * bvp)
293 rc = (((
char *)ap->
data) - ((
char *)bp->data));
295 rc = (ap->
info.
tag - bp->info.tag);
322 unsigned int size = 0;
323 unsigned int pad = 0;
340 size += 2 *
sizeof(
int_32);
343 for (i = 0, entry = h->
index; i < h->indexUsed; i++, entry++) {
373 size +=
sizeof(
struct entryInfo_s) + entry->length;
393 const unsigned char * s = (*p).ui8p;
394 const unsigned char * se = (pend ? (*pend).
ui8p : NULL);
422 const char ** av = (*p).argv;
425 length += strlen(*av++) + 1;
432 length =
typeSizes[(type & 0xf)] * count;
433 if (length < 0 || (se && (s + length) > se))
469 unsigned char * dataStart,
470 const unsigned char * dataEnd,
476 unsigned char * tprev = NULL;
477 unsigned char * t = NULL;
482 memset(&ieprev, 0,
sizeof(ieprev));
483 for (; il > 0; il--, pe++) {
502 if (dataEnd && t >= dataEnd)
506 pend.
ui8p = (
unsigned char *) dataEnd;
530 tdel = (tprev ? (t - tprev) : 0);
546 switch (ntohl(pe->
type)) {
551 if (dataEnd && ((
unsigned char *)it) >= dataEnd)
553 b[1] = htonl(((
int_32 *)it)[0]);
554 b[0] = htonl(((
int_32 *)it)[1]);
555 if (b[1] != ((
int_32 *)it)[0])
556 memcpy(it, b,
sizeof(b));
558 t = (
unsigned char *) it;
563 if (dataEnd && ((
unsigned char *)it) >= dataEnd)
567 t = (
unsigned char *) it;
572 if (dataEnd && ((
unsigned char *)it) >= dataEnd)
576 t = (
unsigned char *) it;
584 if (dataEnd && (dataStart + dl) > dataEnd)
return -1;
589 tdel = (tprev ? (t - tprev) : 0);
619 unsigned char * dataStart;
628 int drlen, ndribbles;
640 drlen = ndribbles = driplen = ndrips = 0;
641 for (i = 0, entry = h->
index; i < h->indexUsed; i++, entry++) {
644 int_32 ril = rdl/
sizeof(*pe);
681 if (entry->
data == NULL || entry->
length <= 0)
707 len =
sizeof(il) +
sizeof(dl) + (il *
sizeof(*pe)) + dl;
714 dataStart = te = (
unsigned char *) (pe + il);
717 for (i = 0, entry = h->
index; i < h->indexUsed; i++, entry++) {
723 if (entry->
data == NULL || entry->
length <= 0)
733 int_32 ril = rdl/
sizeof(*pe) + ndribbles;
736 src = (
char *)entry->
data;
737 rdlen = entry->
rdlen;
744 memcpy(pe+1, src, rdl);
745 memcpy(te, src + rdl, rdlen);
748 pe->
offset = htonl(te - dataStart);
758 count =
regionSwab(NULL, ril, 0, pe, t, NULL, 0);
764 memcpy(pe+1, src +
sizeof(*pe), ((ril-1) *
sizeof(*pe)));
765 memcpy(te, src + (ril *
sizeof(*pe)), rdlen+entry->
info.
count+drlen);
770 int off = ntohl(se->
offset);
771 pe->
offset = (off) ? htonl(te - dataStart) : htonl(off);
775 count =
regionSwab(NULL, ril, 0, pe, t, NULL, 0);
776 if (count != (rdlen + entry->
info.
count + drlen))
781 while (i < h->indexUsed && entry->
info.
offset <= rid+1) {
792 if (entry->
data == NULL || entry->
length <= 0)
807 pe->
offset = htonl(te - dataStart);
816 b[1] = htonl(((
int_32 *)src)[0]);
817 b[0] = htonl(((
int_32 *)src)[1]);
818 if (b[1] == ((
int_32 *)src)[0])
819 memcpy(te, src,
sizeof(b));
821 memcpy(te, b,
sizeof(b));
860 if (((
unsigned char *)pe) != dataStart)
862 if ((((
unsigned char *)ei)+len) != te)
871 if (sw != NULL) (void)
rpmswExit(sw, len);
876 if (sw != NULL) (void)
rpmswExit(sw, len);
911 if (h == NULL)
return NULL;
926 entry > h->
index) entry--;
934 entry2 < last) entry2++;
961 if (!entry)
return 1;
964 while (entry > h->
index && (entry - 1)->
info.
tag == tag)
968 for (first = entry; first < last; first++) {
980 ne = (first - entry);
985 memmove(entry, first, (ne *
sizeof(*entry)));
1002 int_32 il = ntohl(ei[0]);
1003 int_32 dl = ntohl(ei[1]);
1005 size_t pvlen =
sizeof(il) +
sizeof(dl) +
1011 unsigned char * dataStart;
1012 unsigned char * dataEnd;
1025 dataStart = (
unsigned char *) (pe + il);
1026 dataEnd = dataStart + dl;
1053 entry->
info.
offset = ((
unsigned char *)pe - dataStart);
1058 entry->
length = pvlen -
sizeof(il) -
sizeof(dl);
1064 entry->
rdlen = rdlen;
1081 {
int off = ntohl(pe->
offset);
1089 int_32 * stei = memcpy(
alloca(nb), dataStart + off, nb);
1090 rdl = -ntohl(stei[2]);
1091 ril = rdl/
sizeof(*pe);
1108 entry->
length = pvlen -
sizeof(il) -
sizeof(dl);
1112 entry->
rdlen = rdlen;
1114 if (ril < h->indexUsed) {
1121 rc =
regionSwab(newEntry, ne, 0, pe+ril, dataStart, dataEnd, rid);
1132 for (j = 0; j < ne; j++, newEntry++) {
1141 (ne *
sizeof(*entry)));
1151 if (sw != NULL) (void)
rpmswExit(sw, pvlen);
1158 if (sw != NULL) (void)
rpmswExit(sw, pvlen);
1181 return (h != NULL ? h->
origin : NULL);
1204 return (h != NULL ? h->
baseurl : NULL);
1226 if (h != NULL && st != NULL)
1227 memcpy(&h->
sb, st,
sizeof(h->
sb));
1234 return (h != NULL ? h->
digest : NULL);
1251 return (h != NULL ? h->
instance : 0);
1266 return (h != NULL ? h->
startoff : 0);
1280 return (h != NULL ? h->
endoff : 0);
1308 struct stat sb = h->
sb;
1330 if (origin != NULL) {
1332 origin =
_free(origin);
1334 if (baseurl != NULL) {
1336 baseurl =
_free(baseurl);
1338 if (digest != NULL) {
1340 digest =
_free(digest);
1357 int_32 il = ntohl(ei[0]);
1358 int_32 dl = ntohl(ei[1]);
1360 size_t pvlen =
sizeof(il) +
sizeof(dl) +
1368 nuh = memcpy(
xmalloc(pvlen), uh, pvlen);
1398 memset(block, 0,
sizeof(block));
1404 if (
timedRead(fd, (
char *)block, i*
sizeof(*block)) != (i *
sizeof(*block)))
1414 reserved = block[i++];
1417 il = ntohl(block[i]); i++;
1418 dl = ntohl(block[i]); i++;
1421 len =
sizeof(il) +
sizeof(dl) + (il *
sizeof(
struct entryInfo_s)) + dl;
1431 len -=
sizeof(il) +
sizeof(dl);
1434 if (
timedRead(fd, (
char *)&ei[2], len) != len)
1492 nb =
Fwrite(uh,
sizeof(
char), length, fd);
1497 return (nb == length ? 0 : 1);
1550 unsigned char * dataStart = (
unsigned char *) (pe + ntohl(ei[0]));
1551 unsigned char * dataEnd;
1553 int_32 ril = rdl/
sizeof(*pe);
1557 count = 2 *
sizeof(*ei) + (ril *
sizeof(*pe)) + rdl;
1566 (*p).i32p = ei =
xmalloc(count);
1571 pe = (
entryInfo) memcpy(ei + 2, pe, (ril *
sizeof(*pe)));
1574 dataStart = (
unsigned char *) memcpy(pe + ril, dataStart, rdl);
1575 dataEnd = dataStart + rdl;
1578 rc =
regionSwab(NULL, ril, 0, pe, dataStart, dataEnd, 0);
1580 rc = (rc < 0) ? 0 : 1;
1590 (*p).str = entry->
data;
1596 {
const char ** argv;
1597 size_t nb = count *
sizeof(*argv);
1603 (*p).argv = argv =
xmalloc(nb);
1607 t = (
char *) &argv[count];
1611 for (i = 0; i <
count; i++) {
1621 (*p).ptr = entry->
data;
1624 if (type) *type = entry->
info.
type;
1654 {
const char *s, *ll, *CC, *EE, *dd;
1658 lbuf =
alloca(le - l + 1);
1659 for (s = l, ll = t = lbuf; *s; s++, t++) {
1680 for (t = ll; *t; t++) *t = tolower(*t);
1682 for (t = CC; *t; t++) *t = toupper(*t);
1689 if (strlen(td) == (le-l) && !strncmp(td, l, (le - l)))
1693 for (fe = l; fe < le && *fe !=
'@'; fe++)
1695 if (fe < le && !strncmp(td, l, (fe - l)))
1699 for (fe = l; fe < le && *fe !=
'.'; fe++)
1701 if (fe < le && !strncmp(td, l, (fe - l)))
1705 for (fe = l; fe < le && *fe !=
'_'; fe++)
1707 if (fe < le && !strncmp(td, l, (fe - l)))
1723 const char *
lang, *l, *le;
1727 if ((lang =
getenv(
"LANGUAGE")) == NULL &&
1728 (lang =
getenv(
"LC_ALL")) == NULL &&
1729 (lang =
getenv(
"LC_MESSAGES")) == NULL &&
1730 (lang =
getenv(
"LANG")) == NULL)
1738 for (l = lang; *l !=
'\0'; l = le) {
1743 while (*l && *l ==
':')
1747 for (le = l; *le && *le !=
':'; le++)
1751 for (langNum = 0, td = table->
data, ed = entry->
data;
1752 langNum < entry->info.count;
1753 langNum++, td += strlen(td) + 1, ed += strlen(ed) + 1) {
1762 return ((entry->
data != NULL) && *(
char*)(entry->
data)) ?
_(entry->
data) : entry->
data;
1790 if (entry == NULL) {
1792 if (p) (*p).ptr = NULL;
1807 rc =
copyEntry(entry, type, p, c, minMem);
1812 return ((rc == 1) ? 1 : 0);
1865 if (sw != NULL) (void)
rpmswExit(sw, 0);
1895 if (sw != NULL) (void)
rpmswExit(sw, 0);
1911 if (p) *(
void **)p = NULL;
1919 return ((rc == 1) ? 1 : 0);
1931 {
const char ** av = (*src).argv;
1932 char * t = (
char *) (*dest).str;
1934 while (cnt-- > 0 && len > 0) {
1936 if ((s = *av++) == NULL)
1940 }
while (s[-1] && --len > 0);
1944 memmove((*dest).ptr, (*src).ptr, len);
1969 copyData(type, &data, p, c, length);
2011 if (data.
ptr == NULL || length <= 0)
2052 const void * p,
int_32 c)
2083 copyData(type, &dest, &src, c, length);
2103 const void * p,
int_32 c)
2146 if (!table && entry)
2149 if (!table && !entry) {
2150 const char * argv[2];
2153 if (!lang || (lang[0] ==
'C' && lang[1] ==
'\0')) {
2155 p.
argv[count++] =
"C";
2159 p.
argv[count++] =
"C";
2171 if (!lang) lang =
"C";
2173 {
const char * l = table->
data;
2174 for (langNum = 0; langNum < table->
info.
count; langNum++) {
2175 if (!strcmp(l, lang))
break;
2181 length = strlen(lang) + 1;
2189 memmove(((
char *)table->
data) + table->
length, lang, length);
2196 for (i = 0; i < langNum; i++)
2198 p.
argv[langNum] =
string;
2200 }
else if (langNum >= entry->
info.
count) {
2203 length = strlen(
string) + 1 + ghosts;
2212 memset(((
char *)entry->
data) + entry->
length,
'\0', ghosts);
2213 memmove(((
char *)entry->
data) + entry->
length + ghosts,
string, strlen(
string)+1);
2218 char *b, *be, *e, *ee, *t;
2222 b = be = e = ee = entry->
data;
2223 for (i = 0; i < table->
info.
count; i++) {
2226 ee += strlen(ee) + 1;
2233 sn = strlen(
string) + 1;
2235 length = bn + sn + en;
2242 memcpy(t,
string, sn);
2249 entry->
length -= strlen(be) + 1;
2276 const void * p,
int_32 c)
2292 if (newData.
ptr == NULL || length <= 0)
2296 while (entry > h->
index && (entry - 1)->
info.
tag == tag)
2322 fprintf(stderr,
"\t\t\\%c\n", ch);
2325 case 'a':
return '\a';
2326 case 'b':
return '\b';
2327 case 'f':
return '\f';
2328 case 'n':
return '\n';
2329 case 'r':
return '\r';
2330 case 't':
return '\t';
2331 case 'v':
return '\v';
2368 memset(he, 0,
sizeof(*he));
2385 if (format == NULL)
return NULL;
2387 for (i = 0; i < num; i++) {
2388 switch (format[i].type) {
2397 format[i].
u.
array.format =
2399 format[i].
u.
array.numTokens);
2402 format[i].
u.
cond.ifFormat =
2404 format[i].
u.
cond.numIfTokens);
2405 format[i].
u.
cond.elseFormat =
2407 format[i].
u.
cond.numElseTokens);
2412 format[i].
u.
cond.tag.fmtfuncs =
_free(format[i].u.
cond.tag.fmtfuncs);
2420 format =
_free(format);
2493 for (slot = hi->
next_index; slot < h->indexUsed; slot++) {
2494 entry = h->
index + slot;
2499 if (entry == NULL || slot >= h->
indexUsed)
2514 if (sw != NULL) (void)
rpmswExit(sw, 0);
2517 return ((rc == 1) ? 1 : 0);
2529 HE_t he = memset(
alloca(
sizeof(*he)), 0,
sizeof(*he));
2585 if (tag != NULL && tag->
tagno == -2)
2610 if (hsa != NULL && hsa->
i >= 0 && hsa->
i < hsa->
numTokens) {
2612 if (hsa->
hi == NULL) {
2681 static char name[128];
2685 for (; tbl->
name != NULL; tbl++) {
2686 if (tbl->
val == val)
2689 if ((s = tbl->
name) == NULL)
2691 s +=
sizeof(
"RPMTAG_") - 1;
2705 for (; tbl->
name != NULL; tbl++) {
2706 if (tbl->
val == val)
2709 return (tbl->
name != NULL ? tbl->
type : 0);
2722 for (; tbl->
name != NULL; tbl++) {
2750 if (!strcmp(name,
"*")) {
2755 if (strncmp(
"RPMTAG_", name,
sizeof(
"RPMTAG_")-1)) {
2756 char * t =
alloca(strlen(name) +
sizeof(
"RPMTAG_"));
2776 if (stag->
tagno != 0)
2783 if (stag->
av != NULL) {
2786 for (i = 0; stag->
av[i] != NULL; i++) {
2792 if (strcmp(ext->
name, stag->
av[i]+1))
2811 int ix = (he->
ix > 0 ? he->
ix : 0);
2813 const char * istr = NULL;
2817 if (fmt == NULL || *fmt ==
'\0')
2822 return xstrdup(
_(
"(not a number)"));
2826 ival = he->
p.
i8p[ix];
2832 ival = he->
p.
i32p[ix];
2835 ival = he->
p.
i64p[ix];
2841 istr = he->
p.
argv[ix];
2846 {
static char hex[] =
"0123456789abcdef";
2847 const char * s = he->
p.
str;
2856 *t++ = hex[ (i >> 4) & 0xf ];
2857 *t++ = hex[ (i ) & 0xf ];
2867 char myfmt[] =
"%llX";
2928 val =
xstrdup(
_(
"(not a number)"));
2930 struct tm * tstruct;
2934 { time_t dateint = data.
ui64p[0];
2935 tstruct = localtime(&dateint);
2939 (void) strftime(buf,
sizeof(buf) - 1, strftimeFormat, tstruct);
2940 buf[
sizeof(buf) - 1] =
'\0';
2995 const char * s = he->
p.
str;
3000 for (s = he->
p.
str; (c = (
int)*s) != 0; s++) {
3008 for (s = he->
p.
str; (c = (
int)*s) != 0; s++) {
3009 if (c == (
int)
'\'') {
3056 char * str,
char ** endPtr)
3073 char ** endPtr,
int state)
3079 static const char *pstates[] = {
3080 "NORMAL",
"ARRAY",
"EXPR",
"WTF?"
3082 char * chptr, * start, *
next, * dst;
3092 fprintf(stderr,
"--> parseFormat(%p, \"%.20s...\", %p, %p, %p, %s)\n", hsa, str, formatPtr, numTokensPtr, endPtr, pstates[(state & 0x3)]);
3098 for (chptr = str; *chptr !=
'\0'; chptr++)
3099 if (*chptr ==
'%') numTokens++;
3100 numTokens = numTokens * 2 + 1;
3102 format =
xcalloc(numTokens,
sizeof(*format));
3103 if (endPtr) *endPtr = NULL;
3110 while (*start !=
'\0') {
3114 if (*(start + 1) ==
'%') {
3115 if (token == NULL || token->
type != PTOK_STRING) {
3116 token = format + numTokens++;
3117 token->
type = PTOK_STRING;
3119 dst = token->
u.
string.string = start;
3127 token = format + numTokens++;
3131 if (*start ==
'|') {
3152 while (*chptr && *chptr !=
'{' && *chptr !=
'%') chptr++;
3153 if (!*chptr || *chptr ==
'%') {
3154 hsa->
errmsg =
_(
"missing { after %");
3161 fprintf(stderr,
"\tchptr *%p = NUL\n", chptr);
3165 while (start < chptr) {
3167 i = strtoul(start, &start, 10);
3176 if (*start ==
'=') {
3179 }
else if (*start ==
'#') {
3186 while (*next && *next !=
'}') next++;
3188 hsa->
errmsg =
_(
"missing } after %{");
3194 fprintf(stderr,
"\tnext *%p = NUL\n", next);
3198 #define isSEP(_c) ((_c) == ':' || (_c) == '|')
3200 while (!(*chptr ==
'\0' ||
isSEP(*chptr))) chptr++;
3202 while (
isSEP(*chptr)) {
3203 if (chptr[1] ==
'\0' ||
isSEP(chptr[1])) {
3204 hsa->
errmsg =
_(
"empty tag format");
3209 {
char * te = chptr + 1;
3210 char * t = strchr(te,
'(');
3213 while (!(*te ==
'\0' ||
isSEP(*te))) {
3215 if (te[0] ==
'\\' && te[1] !=
'\0') te++;
3219 c = *te; *te =
'\0';
3223 if (te <= t || te[-1] !=
')') {
3224 hsa->
errmsg =
_(
"malformed parameter list");
3234 fprintf(stderr,
"\tformat \"%s\" params \"%s\"\n", chptr, (t ? t :
""));
3244 if (*start ==
'\0') {
3245 hsa->
errmsg =
_(
"empty tag name");
3251 token->
type = PTOK_TAG;
3253 if (
findTag(hsa, token, start)) {
3254 hsa->
errmsg =
_(
"unknown tag");
3262 fprintf(stderr,
"\tdst = start = next %p\n", dst);
3269 fprintf(stderr,
"\t%s => %s *%p = NUL\n", pstates[(state & 0x3)], pstates[
PARSER_IN_ARRAY], start);
3272 token = format + numTokens++;
3276 &token->
u.
array.numTokens,
3277 &start, PARSER_IN_ARRAY))
3284 hsa->
errmsg =
_(
"] expected at end of array");
3292 fprintf(stderr,
"\tdst = start %p\n", dst);
3295 token->
type = PTOK_ARRAY;
3300 if (state != PARSER_IN_ARRAY) {
3301 hsa->
errmsg =
_(
"unexpected ]");
3308 fprintf(stderr,
"\t<= %s %p[-1] = NUL\n", pstates[(state & 0x3)], start);
3310 if (endPtr) *endPtr = start;
3316 hsa->
errmsg =
_(
"unexpected }");
3323 fprintf(stderr,
"\t<= %s %p[-1] = NUL\n", pstates[(state & 0x3)], start);
3325 if (endPtr) *endPtr = start;
3330 if (token == NULL || token->
type != PTOK_STRING) {
3331 token = format + numTokens++;
3332 token->
type = PTOK_STRING;
3334 dst = token->
u.
string.string = start;
3340 fprintf(stderr,
"\t*%p = *%p \"%.30s\"\n", dst, start, start);
3342 if (start[0] ==
'\\' && start[1] !=
'\0') {
3349 if (dst < start) *dst =
'\0';
3360 for (i = 0; i < (unsigned) numTokens; i++) {
3362 switch(token->
type) {
3371 if (numTokensPtr != NULL)
3372 *numTokensPtr = numTokens;
3373 if (formatPtr != NULL)
3374 *formatPtr = format;
3380 char * str,
char ** endPtr)
3387 fprintf(stderr,
"--> parseExpression(%p, %p, \"%.20s...\", %p)\n", hsa, token, str, endPtr);
3392 while (*chptr && *chptr !=
'?') chptr++;
3394 if (*chptr !=
'?') {
3395 hsa->
errmsg =
_(
"? expected in expression");
3401 if (*chptr !=
'{') {
3402 hsa->
errmsg =
_(
"{ expected after ? in expression");
3413 if (!(end && *end)) {
3414 hsa->
errmsg =
_(
"} expected in expression");
3415 token->
u.
cond.ifFormat =
3421 if (*chptr !=
':' && *chptr !=
'|') {
3422 hsa->
errmsg =
_(
": expected following ? subexpression");
3423 token->
u.
cond.ifFormat =
3428 if (*chptr ==
'|') {
3432 token->
u.
cond.ifFormat =
3439 if (*chptr !=
'{') {
3440 hsa->
errmsg =
_(
"{ expected after : in expression");
3441 token->
u.
cond.ifFormat =
3453 if (!(end && *end)) {
3454 hsa->
errmsg =
_(
"} expected in expression");
3455 token->
u.
cond.ifFormat =
3461 if (*chptr !=
'|') {
3462 hsa->
errmsg =
_(
"| expected at end of expression");
3463 token->
u.
cond.ifFormat =
3465 token->
u.
cond.elseFormat =
3475 token->
type = PTOK_COND;
3477 (void)
findTag(hsa, token, str);
3497 rc = fn(hsa->
h, he);
3518 HE_t vhe = memset(
alloca(
sizeof(*vhe)), 0,
sizeof(*vhe));
3534 xx = headerGetExtension(hsa->
h, he->
tag, &he->
t, &he->
p, &he->
c);
3549 he->
p.
str =
"(none)";
3559 he->
p.
i32p = &countBuf;
3567 val =
xstrdup(
"(unknown type)");
3568 need = strlen(val) + 1;
3595 ival = he->
p.
i8p[element];
3598 ival = he->
p.
ui16p[element];
3601 ival = he->
p.
i32p[element];
3604 ival = he->
p.
i64p[element];
3608 vhe->
p.
i64p = &ival;
3610 vhe->
ix = (he->
c > 1 ? 0 : -1);
3629 for (i = 0; tag->
av[i] != NULL; i++) {
3632 if ((fmt = tag->
fmtfuncs[i]) == NULL)
3635 if (val != NULL && *tag->
av[i] ==
'|') {
3649 nval = fmt(vhe, av);
3653 fprintf(stderr,
"\t%s(%s) %p(%p,%p) ret \"%s\"\n", tag->
av[i], tag->
params[i], fmt, vhe, (av ? av : NULL), val);
3658 val =
xstrdup((nval ? nval :
""));
3662 val =
rpmExpand(val, (*val ?
" | " :
""), nval, NULL);
3672 assert(val != NULL);
3674 need = strlen(val) + 1;
3680 if (val && need > 0) {
3683 nb = strlen(tag->
format) +
sizeof(
"%s");
3686 nb = tag->
pad + strlen(val) + 1;
3728 switch (token->
type) {
3734 if (need == 0)
break;
3749 if (token->
u.
cond.tag.ext
3752 spft = token->
u.
cond.ifFormat;
3753 condNumFormats = token->
u.
cond.numIfTokens;
3755 spft = token->
u.
cond.elseFormat;
3756 condNumFormats = token->
u.
cond.numElseTokens;
3759 need = condNumFormats * 20;
3760 if (spft == NULL || need == 0)
break;
3763 for (i = 0; i < condNumFormats; i++, spft++) {
3772 spft = token->
u.
array.format;
3773 for (i = 0; i < token->
u.
array.numTokens; i++, spft++)
3786 xx = headerGetExtension(hsa->
h, he->
tag, &he->
t, &he->
p, &he->
c);
3808 if (numElements == -1) {
3809 numElements = he->
c;
3812 if (he->
c == numElements)
3815 _(
"array iterator used with different sized arrays");
3823 if (numElements == -1)
3830 spft = token->
u.
array.format;
3832 if (numElements == -1) {
3834 need =
sizeof(
"(none)\n") - 1;
3836 te =
stpcpy(t,
"(none)\n");
3843 need = numElements * token->
u.
array.numTokens;
3844 if (need == 0)
break;
3849 isxml = (spft->
type == PTOK_TAG && tag->
av != NULL &&
3850 tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"xml"));
3851 isyaml = (spft->
type == PTOK_TAG && tag->
av != NULL &&
3852 tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"yaml"));
3858 (void)
snprintf(numbuf,
sizeof(numbuf),
"Tag_0x%08x",
3860 numbuf[
sizeof(numbuf)-1] =
'\0';
3863 need =
sizeof(
" <rpmTag name=\"\">\n") + strlen(tagN);
3873 (void)
snprintf(numbuf,
sizeof(numbuf),
"Tag_0x%08x",
3875 numbuf[
sizeof(numbuf)-1] =
'\0';
3877 tagT = numElements > 1
3880 need =
sizeof(
" : - ") + strlen(tagN);
3892 need = numElements * token->
u.
array.numTokens * 10;
3894 for (j = 0; j < numElements; j++) {
3895 spft = token->
u.
array.format;
3896 for (i = 0; i < token->
u.
array.numTokens; i++, spft++) {
3904 need =
sizeof(
" </rpmTag>\n") - 1;
3906 te =
stpcpy(te,
" </rpmTag>\n");
3911 need =
sizeof(
"\n") - 1;
3947 ec =
xcalloc(extNum+1,
sizeof(*ec));
4005 fprintf(stderr,
"==> headerSprintf(%p, \"%s\", %p, %p, %p)\n", h, fmt, tags, exts, errmsg);
4034 isxml = (tag != NULL && tag->
tagno == -2 && tag->
av != NULL
4035 && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"xml"));
4036 isyaml = (tag != NULL && tag->
tagno == -2 && tag->
av != NULL
4037 && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"yaml"));
4040 need =
sizeof(
"<rpmHeader>\n") - 1;
4042 te =
stpcpy(t,
"<rpmHeader>\n");
4046 need =
sizeof(
"- !!omap\n") - 1;
4048 te =
stpcpy(t,
"- !!omap\n");
4053 while ((nextfmt =
hsaNext(hsa)) != NULL) {
4063 need =
sizeof(
"</rpmHeader>\n") - 1;
4065 te =
stpcpy(t,
"</rpmHeader>\n");
4069 need =
sizeof(
"\n") - 1;
4104 if (headerFrom == headerTo)
4107 for (tagno = tagstocopy; *tagno != 0; tagno++) {