8 #if defined(HAVE_ICONV)
10 #if defined(__LCLINT__)
12 extern iconv_t iconv_open(
const char *__tocode,
const char *__fromcode)
15 extern size_t iconv(iconv_t __cd,
char ** __inbuf,
16 size_t * __inbytesleft,
18 size_t * __outbytesleft)
22 extern int iconv_close( iconv_t __cd)
28 #if defined(HAVE_LANGINFO_H)
30 #if defined(__LCLINT__)
32 extern char *nl_langinfo (nl_item __item)
38 #define _MIRE_INTERNAL
47 #define _RPMTAG_INTERNAL
49 #define _RPMEVR_INTERNAL
93 const char * istr = NULL;
98 if (fmt == NULL || *fmt ==
'\0')
103 return xstrdup(
_(
"(not a number)"));
121 istr = he->
p.
argv[ix];
124 {
static char hex[] =
"0123456789abcdef";
125 const char * s = he->
p.
str;
134 *t++ = hex[ (i >> 4) & 0xf ];
135 *t++ = hex[ (i ) & 0xf ];
145 char myfmt[] =
"%llX";
146 myfmt[3] = ((fmt != NULL && *fmt !=
'\0') ? *fmt :
'd');
203 const char * strftimeFormat)
215 { time_t dateint = he->
p.
ui64p[0];
216 tstruct = localtime(&dateint);
220 (void) strftime(buf,
sizeof(buf) - 1, strftimeFormat, tstruct);
221 buf[
sizeof(buf) - 1] =
'\0';
275 xx =
snprintf(val, nb,
"%llu", (
unsigned long long)he->
p.
ui64p[0]);
279 const char * s = he->
p.
str;
284 for (s = he->
p.
str; (c = (
int)*s) != 0; s++) {
292 for (s = he->
p.
str; (c = (
int)*s) != 0; s++) {
293 if (c == (
int)
'\'') {
309 { HEADER_EXT_FORMAT,
"octal",
311 { HEADER_EXT_FORMAT,
"oct",
313 { HEADER_EXT_FORMAT,
"hex",
315 { HEADER_EXT_FORMAT,
"decimal",
317 { HEADER_EXT_FORMAT,
"dec",
319 { HEADER_EXT_FORMAT,
"date",
321 { HEADER_EXT_FORMAT,
"day",
323 { HEADER_EXT_FORMAT,
"shescape",
325 { HEADER_EXT_LAST, NULL, { NULL } }
339 char * (*spew_strcpy) (
char * t,
const char * s,
int lvl)
356 while ((c = (
int) *s++) != (
int)
'\0') {
359 case '>': len +=
sizeof(
"<") - 1;
break;
360 case '&': len +=
sizeof(
"&") - 1;
break;
361 default: len += 1;
break;
381 while ((c = (
int) *s++) != (
int)
'\0') {
383 case '<': te =
stpcpy(te,
"<");
break;
384 case '>': te =
stpcpy(te,
">");
break;
385 case '&': te =
stpcpy(te,
"&");
break;
386 default: *te++ = (char) c;
break;
396 .spew_init =
"<rpmHeader>\n",
397 .spew_fini =
"</rpmHeader>\n",
417 while ((c = (
int) *s++) != (int)
'\0')
445 while ((c = (
int) *s++) != (int)
'\0') {
448 for (i = 0; i < lvl; i++) {
465 .spew_init =
"- !!omap\n",
485 while ((c = (
int) *s++) != (
int)
'\0') {
494 default: len += 1;
break;
515 while ((c = (
int) *s++) != (
int)
'\0') {
517 case '\b': *te++ =
'\\'; *te++ =
'b';
break;
518 case '\t': *te++ =
'\\'; *te++ =
't';
break;
519 case '\n': *te++ =
'\\'; *te++ =
'n';
break;
520 case '\f': *te++ =
'\\'; *te++ =
'f';
break;
521 case '\r': *te++ =
'\\'; *te++ =
'r';
break;
522 case '"': *te++ =
'\\'; *te++ =
'"';
break;
523 case '\\': *te++ =
'\\'; *te++ =
'\\';
break;
524 default: *te++ = (char) c;
break;
536 .spew_init =
"db.%{?__mongodb_collection}%{!?__mongodb_collection:packages}.save({\n",
537 .spew_fini =
"});\n",
556 while ((c = (
int) *s++) != (
int)
'\0') {
559 default: len += 1;
break;
579 while ((c = (
int) *s++) != (
int)
'\0') {
581 case '\'': *te++ = (char) c;
582 default: *te++ = (char) c;
break;
604 char *perms =
xstrdup(
"----------");
608 else if (S_ISDIR(mode))
612 else if (S_ISFIFO(mode))
618 else if (S_ISCHR(mode))
620 else if (S_ISBLK(mode))
625 if (mode & S_IRUSR) perms[1] =
'r';
626 if (mode & S_IWUSR) perms[2] =
'w';
627 if (mode & S_IXUSR) perms[3] =
'x';
629 if (mode & S_IRGRP) perms[4] =
'r';
630 if (mode & S_IWGRP) perms[5] =
'w';
631 if (mode & S_IXGRP) perms[6] =
'x';
633 if (mode & S_IROTH) perms[7] =
'r';
634 if (mode & S_IWOTH) perms[8] =
'w';
635 if (mode & S_IXOTH) perms[9] =
'x';
638 perms[3] = ((mode & S_IXUSR) ?
's' :
'S');
641 perms[6] = ((mode & S_IXGRP) ?
's' :
'S');
644 perms[9] = ((mode & S_IXOTH) ?
't' :
'T');
658 int ix = (he->
ix > 0 ? he->
ix : 0);
666 if (anint & RPMSENSE_TRIGGERPREIN)
668 else if (anint & RPMSENSE_TRIGGERIN)
670 else if (anint & RPMSENSE_TRIGGERUN)
672 else if (anint & RPMSENSE_TRIGGERPOSTUN)
689 int ix = (he->
ix > 0 ? he->
ix : 0);
712 int ix = (he->
ix >= 0 ? he->
ix : 0);
754 int ix = (he->
ix > 0 ? he->
ix : 0);
756 const unsigned char * s;
764 s = (
unsigned char *) he->
p.
ui8p;
774 if (b64decode(enc, (
void *)&s, &ns))
779 #if defined(SUPPORT_I18NSTRING_TYPE)
787 return xstrdup(
_(
"(invalid type)"));
807 int ix = (he->
ix > 0 ? he->
ix : 0);
818 val =
xstrdup(
_(
"(invalid type :base64)"));
822 ns =
sizeof(he->
p.
ui64p[0]);
825 ns = strlen(he->
p.
str);
832 nt = ((ns + 2) / 3) * 4;
836 if (b64encode_chars_per_line > 0 && b64encode_eolstr != NULL) {
837 lc = (nt + b64encode_chars_per_line - 1) / b64encode_chars_per_line;
838 if (((nt + b64encode_chars_per_line - 1) % b64encode_chars_per_line) != 0)
840 nt += lc * strlen(b64encode_eolstr);
848 {
unsigned char * _data =
xcalloc(1, ns+1);
849 assert(he->
p.
ptr != NULL);
850 memcpy(_data, he->
p.
ptr, ns);
852 if ((enc = b64encode(_data, ns)) != NULL) {
857 _data =
_free(_data);
868 #if defined(__GLIBC__)
876 static const char * _iconv_tocode =
"UTF-8";
878 static const char * _iconv_fromcode = NULL;
886 const char *s = buffer;
888 #if defined(HAVE_ICONV)
892 assert(buffer != NULL);
896 assert(tocode != NULL);
898 #ifdef HAVE_LANGINFO_H
900 if (fromcode == NULL)
901 fromcode = nl_langinfo (CODESET);
903 assert(fromcode != NULL);
905 if ((fd = iconv_open(tocode, fromcode)) != (iconv_t)-1) {
906 size_t ileft = strlen(s);
908 char * te = t =
xmalloc((nt + 1) *
sizeof(*t));
909 size_t oleft = ileft;
910 size_t err = iconv(fd, NULL, NULL, NULL, NULL);
911 const char *sprev = NULL;
912 int _iconv_errno = 0;
915 while (done == 0 && _iconv_errno == 0) {
916 err = iconv(fd, (
char **)&s, &ileft, &te, &oleft);
917 if (err == (
size_t)-1) {
920 {
size_t used = (size_t)(te - t);
922 t =
xrealloc(t, (nt + 1) *
sizeof(*t));
931 _iconv_errno =
errno;
943 _iconv_errno =
errno;
948 fprintf(stderr,
"warning: %s: from iconv(%s -> %s) for \"%s\" -> \"%s\"\n", strerror(_iconv_errno), fromcode, tocode, buffer, t);
966 int ix = (he->
ix > 0 ? he->
ix : 0);
997 int ix = (he->
ix > 0 ? he->
ix : 0);
1004 val =
xstrdup(
_(
"(not a string)"));
1018 int ix = (he->
ix > 0 ? he->
ix : 0);
1019 const char * xtag = NULL;
1021 const char * s = NULL;
1039 {
int cpl = b64encode_chars_per_line;
1040 b64encode_chars_per_line = 0;
1044 b64encode_chars_per_line = cpl;
1049 anint = (uint64_t)he->
p.
ui8p[ix];
1052 anint = (uint64_t)he->
p.
ui16p[ix];
1055 anint = (uint64_t)he->
p.
ui32p[ix];
1061 val =
xstrdup(
_(
"(invalid xml type)"));
1067 static int tlen = 64;
1073 xx =
snprintf(t, tlen,
"%llu", (
unsigned long long)anint);
1083 nb += strlen(xtag) +
sizeof(
"\t</>");
1087 nb += 2 * strlen(xtag) +
sizeof(
"\t<></>");
1113 int element = he->
ix;
1114 int ix = (he->
ix > 0 ? he->
ix : 0);
1115 const char * xtag = NULL;
1118 const char * s = NULL;
1135 if (strchr(
"[", s[0]))
1138 while ((c = (
int) *s++) != (int)
'\0') {
1144 if (s[0] ==
' ' || s[0] ==
'\t')
1149 if (s[0] !=
' ' && s[0] !=
'\0' && s[1] !=
'"')
1158 xtag =
xmalloc(strlen(
"- |##-\n") + 1);
1162 sprintf((
char *)xtag,
"- |%d-\n", lvl);
1165 if (he->
ix < 0) lvl++;
1166 sprintf((
char *)xtag,
"|%d-\n", lvl);
1175 if (he->
ix < 0) lvl++;
1179 xtag = (element >= 0 ?
"- " : NULL);
1186 {
int cpl = b64encode_chars_per_line;
1187 b64encode_chars_per_line = 0;
1192 b64encode_chars_per_line = cpl;
1197 anint = (uint64_t)he->
p.
ui8p[ix];
1200 anint = (uint64_t)he->
p.
ui16p[ix];
1203 anint = (uint64_t)he->
p.
ui32p[ix];
1209 val =
xstrdup(
_(
"(invalid yaml type)"));
1215 static int tlen = 64;
1218 xx =
snprintf(t, tlen,
"%llu", (
unsigned long long)anint);
1221 xtag = (element >= 0 ?
"- " : NULL);
1230 nb +=
sizeof(
" ") - 1;
1231 nb +=
sizeof(
"- ~") - 1;
1239 nb +=
sizeof(
" ") - 1;
1275 int element = he->
ix;
1276 int ix = (he->
ix > 0 ? he->
ix : 0);
1278 const char * s = NULL;
1296 {
int cpl = b64encode_chars_per_line;
1297 b64encode_chars_per_line = 0;
1300 b64encode_chars_per_line = cpl;
1303 anint = (uint64_t)he->
p.
ui8p[ix];
1306 anint = (uint64_t)he->
p.
ui16p[ix];
1309 anint = (uint64_t)he->
p.
ui32p[ix];
1315 val =
xstrdup(
_(
"(invalid json type)"));
1321 static int tlen = 64;
1323 xx =
snprintf(t, tlen,
"%llu", (
unsigned long long)anint);
1333 te = t =
alloca(nb +
sizeof(
"\"\","));
1334 if (c !=
'\0') *te++ = c;
1339 if (c !=
'\0') *te++ = c;
1364 int ix = (he->
ix > 0 ? he->
ix : 0);
1372 unsigned int pktlen = 0;
1373 unsigned int v = (
unsigned int) *pkt;
1376 unsigned int hlen = 0;
1381 plen =
pgpLen(pkt+1, &hlen);
1383 tag = (v >> 2) & 0xf;
1384 plen = (1 << (v & 0x3));
1388 pktlen = 1 + plen + hlen;
1392 val =
xstrdup(
_(
"(not an OpenPGP signature)"));
1397 const char *tempstr;
1406 switch (sigp->pubkey_algo) {
1414 (void)
snprintf(t, nb - (t - val),
"%u", (unsigned)sigp->pubkey_algo);
1418 if (t + 5 >= val + nb)
1421 switch (sigp->hash_algo) {
1429 (void)
snprintf(t, nb - (t - val),
"%u", (unsigned)sigp->hash_algo);
1433 if (t + strlen (
", ") + 1 >= val + nb)
1439 { time_t dateint =
pgpGrab(sigp->time,
sizeof(sigp->time));
1440 struct tm * tstruct = localtime(&dateint);
1442 (void) strftime(t, (nb - (t - val)),
"%c", tstruct);
1445 if (t + strlen (
", Key ID ") + 1 >= val + nb)
1447 t =
stpcpy(t,
", Key ID ");
1448 tempstr =
pgpHexStr(sigp->signid,
sizeof(sigp->signid));
1449 if (t + strlen (tempstr) > val + nb)
1470 int ix = (he->
ix > 0 ? he->
ix : 0);
1475 val =
xstrdup(
_(
"(invalid type)"));
1484 if (anint & RPMSENSE_SCRIPT_PRE)
1486 else if (anint & RPMSENSE_SCRIPT_POST)
1488 else if (anint & RPMSENSE_SCRIPT_PREUN)
1489 t =
stpcpy(t,
"(preun)");
1490 else if (anint & RPMSENSE_SCRIPT_POSTUN)
1491 t =
stpcpy(t,
"(postun)");
1501 if (anint & RPMSENSE_SENSEMASK)
1522 int ix = (he->
ix > 0 ? he->
ix : 0);
1527 val =
xstrdup(
_(
"(invalid type)"));
1535 if (anint & RPMSENSE_SCRIPT_PRE)
1537 else if (anint & RPMSENSE_SCRIPT_POST)
1539 else if (anint & RPMSENSE_SCRIPT_PREUN)
1541 else if (anint & RPMSENSE_SCRIPT_POSTUN)
1543 else if (anint & RPMSENSE_SCRIPT_VERIFY)
1545 else if (anint & RPMSENSE_RPMLIB)
1547 else if (anint & RPMSENSE_INTERP)
1549 else if (anint & (RPMSENSE_FIND_PROVIDES | RPMSENSE_FIND_REQUIRES))
1562 static const char * bfstring(
unsigned int x,
const char * xbf)
1564 const char * s = xbf;
1565 static char digits[] =
"0123456789abcdefghijklmnopqrstuvwxyz";
1566 static char buf[BUFSIZ];
1571 radix = (s != NULL ? *s++ : 16);
1573 if (radix <= 1 || radix >= 32)
1578 case 8: *t++ =
'0';
break;
1579 case 16: *t++ =
'0'; *t++ =
'x';
break;
1584 do { i++; k /= radix; }
while (k);
1589 do { --i; t[i] = digits[k % radix]; k /= radix; }
while (k);
1594 while ((c = *s++) !=
'\0') {
1595 if (c >
' ')
continue;
1598 if (!(x & k))
continue;
1600 if (t == te) *t++ =
'=';
1607 if (t > te) *t++ =
'>';
1623 int ix = (he->
ix > 0 ? he->
ix : 0);
1628 val =
xstrdup(
_(
"(invalid type)"));
1636 if (anint & RPMSENSE_MISSINGOK)
1683 (tv->tv_usec * 10) + 0x01B21DD213814000ULL;
1695 he->
p.
ui8p[6] &= 0xf0;
1696 he->
p.
ui8p[8] &= 0xc0;
1697 he->
p.
ui8p[9] &= 0x00;
1730 tv.tv_sec = (long) he->
p.
ui32p[0];
1731 tv.tv_usec = (
long) (he->
c > 1 ? he->
p.
ui32p[1] : 0);
1823 static const char uuid_auth[] =
"%{?_uuid_auth}%{!?_uuid_auth:http://rpm5.org}";
1825 static const char uuid_path[] =
"%{?_uuid_path}%{!?_uuid_path:/package}";
1842 const char * ns = NULL;
1844 const char * s = NULL;
1845 char * t = (val ? val :
alloca(40));
1849 if (!strcmp(
"Sigmd5", tagn))
1851 else if (!strcmp(
"Sha1header", tagn))
1862 s =
rpmGetPath(uuid_auth,
"/", uuid_path,
"/", tagn,
"/",
1900 static const char hex[] =
"0123456789abcdef";
1906 for (i = 0; i < he->
c; i++) {
1907 *te++ = hex[ (int)((he->
p.
ui8p[i] >> 4) & 0x0f) ];
1908 *te++ = hex[ (int)((he->
p.
ui8p[i] ) & 0x0f) ];
1920 return str2uuid(he, NULL, 0, NULL);
2022 for (i = 0; i < (unsigned) he->
c; i++) {
2023 char * item, * flagsStr;
2028 for (j = 0; j < Nhe->
c; j++) {
2029 if (Ihe->
p.
ui32p[j] != i)
2037 sprintf(item,
"%s%s%s", Nhe->
p.
argv[j], flagsStr, Vhe->
p.
argv[j]);
2038 flagsStr =
_free(flagsStr);
2040 strcpy(item, Nhe->
p.
argv[j]);
2043 chptr =
xrealloc(chptr, strlen(chptr) + strlen(item) + 5);
2044 if (*chptr !=
'\0') strcat(chptr,
", ");
2045 strcat(chptr, item);
2049 he->
p.
argv[i] = chptr;
2101 numScripts = _he->
c;
2109 for (i = 0; i < (unsigned) he->
c; i++) {
2110 for (j = 0; j < (unsigned) numNames; j++) {
2111 if (indices.
ui32p[j] != i) {
2112 he->
p.
argv[i] = NULL;
2117 if (flags.
ui32p[j] & RPMSENSE_TRIGGERPREIN)
2119 else if (flags.
ui32p[j] & RPMSENSE_TRIGGERIN)
2121 else if (flags.
ui32p[j] & RPMSENSE_TRIGGERUN)
2123 else if (flags.
ui32p[j] & RPMSENSE_TRIGGERPOSTUN)
2141 #if defined(ENABLE_NLS)
2144 extern int _nl_msg_cat_cntr;
2163 char * dstring =
rpmExpand(_macro_i18ndomains, NULL);
2171 if (dstring && *dstring) {
2173 const char * langval;
2174 const char * msgkey;
2177 {
HE_t nhe = (
HE_t) memset(
alloca(
sizeof(*nhe)), 0,
sizeof(*nhe));
2180 size_t nb =
sizeof(
"()");
2191 if (tn) nb += strlen(tn);
2192 if (nhe->
p.
str) nb += strlen(nhe->
p.
str);
2195 (nhe->
p.
str ? nhe->
p.
str :
""), (tn ? tn :
""));
2202 langval =
getenv(language);
2203 (void)
setenv(language,
"en_US", 1);
2204 #if defined(ENABLE_NLS)
2209 for (domain = dstring; domain != NULL; domain = de) {
2210 de = strchr(domain,
':');
2211 if (de) *de++ =
'\0';
2215 if (msgid != msgkey)
break;
2220 (void)
setenv(language, langval, 1);
2223 #if defined(ENABLE_NLS)
2227 if (domain && msgid) {
2229 const char * s =
dgettext(domain, msgid);
2241 dstring =
_free(dstring);
2272 if (!rc || he->
p.
str == NULL || he->
c == 0) {
2287 {
const char ** argv;
2291 for (i = 0; i < (unsigned) he->
c; i++) {
2294 assert(he->
p.
argv[i] != NULL);
2295 l += strlen(he->
p.
argv[i]) + 1;
2297 argv =
xmalloc(he->
c *
sizeof(*argv) + l);
2298 te = (
char *)&argv[he->
c];
2299 for (i = 0; i < (unsigned) he->
c; i++) {
2436 const char * origin;
2462 const char * baseurl;
2487 const char * digest;
2552 const char * N = NULL;
2553 const char * V = NULL;
2554 const char * R = NULL;
2555 const char * A = NULL;
2560 if (N) nb += strlen(N);
2561 if (V) nb += strlen(V) + 1;
2562 if (R) nb += strlen(R) + 1;
2563 #if defined(RPM_VENDOR_OPENPKG)
2570 if (A) nb += strlen(A) + 1;
2578 #if defined(RPM_VENDOR_OPENPKG)
2636 rpmTag dirIndexesTag = 0;
2657 if (fnp) *fnp = NULL;
2666 if (xx == 0 && isSource) {
2671 dirNames.
argv[0] = (
const char *)&dirNames.
argv[2];
2679 if (fnp) *fnp = NULL;
2684 he->
tag = dirNameTag;
2688 he->
tag = dirIndexesTag;
2693 size =
sizeof(*fileNames.
argv) * count;
2694 for (i = 0; i < (unsigned)count; i++) {
2695 const char * dn = NULL;
2697 size += strlen(baseNames.
argv[i]) + strlen(dn) + 1;
2701 t = (
char *)&fileNames.
argv[count];
2702 for (i = 0; i < (unsigned)count; i++) {
2703 const char * dn = NULL;
2705 fileNames.
argv[i] = t;
2715 *fnp = fileNames.
argv;
2719 if (fcp) *fcp = count;
2789 for (Nhe->
ix = 0; Nhe->
ix < (
int)Nhe->
c; Nhe->
ix++) {
2790 nb +=
sizeof(*he->
p.
argv);
2791 nb += strlen(Nhe->
p.
argv[Nhe->
ix]) + 1;
2792 if (*EVRhe->
p.
argv[Nhe->
ix] !=
'\0')
2793 nb += strlen(EVRhe->
p.
argv[Nhe->
ix]) + (
sizeof(
" (== )")-1);
2796 nb +=
sizeof(*he->
p.
argv);
2799 te = (
char *) &he->
p.
argv[he->
c+1];
2802 for (Nhe->
ix = 0; Nhe->
ix < (
int)Nhe->
c; Nhe->
ix++) {
2803 he->
p.
argv[he->
c++] = te;
2804 if (*EVRhe->
p.
argv[Nhe->
ix] !=
'\0') {
2805 char opstr[4], * op = opstr;
2814 " (", opstr,
" ", EVRhe->
p.
argv[Nhe->
ix],
")", NULL);
2821 he->
p.
argv[he->
c] = NULL;
2841 HE_t EVRhe = (
HE_t) memset(
alloca(
sizeof(*EVRhe)), 0,
sizeof(*EVRhe));
2849 EVRhe->
tag = tagEVR;
2852 assert(EVRhe->
c == Nhe->
c);
2856 assert(Fhe->
c == Nhe->
c);
2932 assert(Dhe->
c == Nhe->
c);
2938 for (Dhe->
ix = 0; Dhe->
ix < (
int)Dhe->
c; Dhe->
ix++) {
2941 nb +=
sizeof(*he->
p.
argv);
2942 nb += strlen(Dhe->
p.
argv[Dhe->
ix]) +
sizeof(
" ") + strlen(Nhe->
p.
argv[Dhe->
ix]) - 1;
2945 nb +=
sizeof(*he->
p.
argv);
2948 te = (
char *) &he->
p.
argv[he->
c+1];
2951 for (Dhe->
ix = 0; Dhe->
ix < (
int)Dhe->
c; Dhe->
ix++) {
2954 he->
p.
argv[he->
c++] = te;
2960 he->
p.
argv[he->
c] = NULL;
3010 HE_t NVRAhe = (
HE_t) memset(
alloca(
sizeof(*NVRAhe)), 0,
sizeof(*NVRAhe));
3011 HE_t RNhe = (
HE_t) memset(
alloca(
sizeof(*RNhe)), 0,
sizeof(*RNhe));
3012 HE_t REVRhe = (
HE_t) memset(
alloca(
sizeof(*REVRhe)), 0,
sizeof(*REVRhe));
3013 HE_t RFhe = (
HE_t) memset(
alloca(
sizeof(*RFhe)), 0,
sizeof(*RFhe));
3015 const char * key = PNhe->
p.
argv[PNhe->
ix];
3038 REVRhe->
tag = tagEVR;
3041 mi =
rpmmiInit(_rpmdb, tagN, key, keylen);
3047 if (PEVRhe != NULL) {
3050 assert(REVRhe->
c == RNhe->
c);
3053 assert(RFhe->
c == RNhe->
c);
3056 for (RNhe->
ix = 0; RNhe->
ix < (
int)RNhe->
c; RNhe->
ix++) {
3063 if (!(PFlags && RFlags))
3077 NVRAhe->
tag = tagNVRA;
3079 if (!(*avp != NULL &&
argvSearch(*avp, NVRAhe->
p.
str, NULL) != NULL)) {
3104 HE_t NVRAhe = (
HE_t) memset(
alloca(
sizeof(*NVRAhe)), 0,
sizeof(*NVRAhe));
3105 HE_t PNhe = (
HE_t) memset(
alloca(
sizeof(*PNhe)), 0,
sizeof(*PNhe));
3106 HE_t PEVRhe = (
HE_t) memset(
alloca(
sizeof(*PEVRhe)), 0,
sizeof(*PEVRhe));
3107 HE_t PFhe = (
HE_t) memset(
alloca(
sizeof(*PFhe)), 0,
sizeof(*PFhe));
3108 HE_t FNhe = (
HE_t) memset(
alloca(
sizeof(*FNhe)), 0,
sizeof(*FNhe));
3120 assert(PEVRhe->
c == PNhe->
c);
3124 assert(PFhe->
c == PNhe->
c);
3130 NVRAhe->
tag = tagNVRA;;
3136 for (PNhe->
ix = 0; PNhe->
ix < (
int)PNhe->
c; PNhe->
ix++)
3137 (
void)
wnlookupTag(h, tagNVRA, &pkgs, &hits, PNhe, PEVRhe, PFhe);
3138 for (FNhe->
ix = 0; FNhe->
ix < (
int)FNhe->
c; FNhe->
ix++)
3139 (void)
wnlookupTag(h, tagNVRA, &pkgs, &hits, FNhe, NULL, NULL);
3149 for (i = 0; i < he->
c; i++) {
3150 nb +=
sizeof(*he->
p.
argv);
3151 nb += strlen(pkgs[i]) + 1;
3153 nb +=
sizeof(*he->
p.
argv);
3156 te = (
char *) &he->
p.
argv[he->
c+1];
3158 for (i = 0; i < he->
c; i++) {
3160 te =
stpcpy(te, pkgs[i]);
3163 he->
p.
argv[he->
c] = NULL;
3186 HE_t NVRAhe = (
HE_t) memset(
alloca(
sizeof(*NVRAhe)), 0,
sizeof(*NVRAhe));
3187 HE_t PNhe = (
HE_t) memset(
alloca(
sizeof(*PNhe)), 0,
sizeof(*PNhe));
3188 HE_t PEVRhe = (
HE_t) memset(
alloca(
sizeof(*PEVRhe)), 0,
sizeof(*PEVRhe));
3189 HE_t PFhe = (
HE_t) memset(
alloca(
sizeof(*PFhe)), 0,
sizeof(*PFhe));
3191 const char * key = RNhe->
p.
argv[RNhe->
ix];
3215 PEVRhe->
tag = tagEVR;
3218 mi =
rpmmiInit(_rpmdb, tagN, key, keylen);
3224 if (REVRhe != NULL) {
3227 assert(PEVRhe->
c == PNhe->
c);
3230 assert(PFhe->
c == PNhe->
c);
3233 for (PNhe->
ix = 0; PNhe->
ix < (
int)PNhe->
c; PNhe->
ix++) {
3240 if (!(PFlags && RFlags))
3254 NVRAhe->
tag = tagNVRA;
3256 if (!(*avp != NULL &&
argvSearch(*avp, NVRAhe->
p.
str, NULL) != NULL)) {
3281 HE_t NVRAhe = (
HE_t) memset(
alloca(
sizeof(*NVRAhe)), 0,
sizeof(*NVRAhe));
3282 HE_t RNhe = (
HE_t) memset(
alloca(
sizeof(*RNhe)), 0,
sizeof(*RNhe));
3283 HE_t REVRhe = (
HE_t) memset(
alloca(
sizeof(*REVRhe)), 0,
sizeof(*REVRhe));
3284 HE_t RFhe = (
HE_t) memset(
alloca(
sizeof(*RFhe)), 0,
sizeof(*RFhe));
3296 assert(REVRhe->
c == RNhe->
c);
3300 assert(RFhe->
c == RNhe->
c);
3302 NVRAhe->
tag = tagNVRA;;
3308 for (RNhe->
ix = 0; RNhe->
ix < (
int)RNhe->
c; RNhe->
ix++) {
3309 if (*RNhe->
p.
argv[RNhe->
ix] ==
'/' || *REVRhe->
p.
argv[RNhe->
ix] ==
'\0')
3310 (void)
nwlookupTag(h, tagNVRA, &pkgs, &hits, RNhe, NULL, NULL);
3312 (
void)
nwlookupTag(h, tagNVRA, &pkgs, &hits, RNhe, REVRhe, RFhe);
3323 for (i = 0; i < he->
c; i++) {
3324 nb +=
sizeof(*he->
p.
argv);
3325 nb += strlen(pkgs[i]) + 1;
3327 nb +=
sizeof(*he->
p.
argv);
3330 te = (
char *) &he->
p.
argv[he->
c+1];
3332 for (i = 0; i < he->
c; i++) {
3334 te =
stpcpy(te, pkgs[i]);
3337 he->
p.
argv[he->
c] = NULL;
3359 assert(N.
argv[i] != NULL && *N.
argv[i] !=
'\0');
3362 && !(a=strcmp(N.
argv[i], N.
argv[i-1]))
3363 && !(b=strcmp(EVR.
argv[i], EVR.
argv[i-1]))
3364 && (F.
ui32p[i] & 0x4e) == ((F.
ui32p[i-1] & 0x4e)) )
3389 if (xx == 0)
goto exit;
3395 if (xx == 0)
goto exit;
3400 if (xx == 0)
goto exit;
3403 nb =
sizeof(*he->
p.
argv);
3405 for (i = 0; i < c; i++) {
3411 nb +=
sizeof(*he->
p.
argv);
3412 nb +=
sizeof(
"<rpm:entry name=\"\"/>");
3413 if (*N.
argv[i] ==
'/')
3416 nb += strlen(N.
argv[i]);
3417 if (EVR.
argv != NULL && EVR.
argv[i] != NULL && *EVR.
argv[i] !=
'\0') {
3418 nb +=
sizeof(
" flags=\"EQ\" epoch=\"0\" ver=\"\"") - 1;
3419 nb += strlen(EVR.
argv[i]);
3420 if (strchr(EVR.
argv[i],
':') != NULL)
3422 if (strchr(EVR.
argv[i],
'-') != NULL)
3423 nb +=
sizeof(
" rel=\"\"") - 2;
3427 nb +=
sizeof(
" pre=\"1\"") - 1;
3435 t = (
char *) &he->
p.
argv[he->
c + 1];
3437 for (i = 0; i < c; i++) {
3442 he->
p.
argv[ac++] = t;
3443 t =
stpcpy(t,
"<rpm:entry");
3444 t =
stpcpy(t,
" name=\"");
3445 if (*N.
argv[i] ==
'/') {
3451 if (EVR.
argv != NULL && EVR.
argv[i] != NULL && *EVR.
argv[i] !=
'\0') {
3452 static char *Fstr[] = {
"?0",
"LT",
"GT",
"?3",
"EQ",
"LE",
"GE",
"?7" };
3454 const char *E, *V, *R;
3457 f = (
char *) EVR.
argv[i];
3458 for (fe = f; *fe !=
'\0' && *fe >=
'0' && *fe <=
'9'; fe++)
3460 if (*fe ==
':') { *fe++ =
'\0'; E = f; f = fe; }
else E = NULL;
3462 for (fe = f; *fe !=
'\0' && *fe !=
'-'; fe++)
3464 if (*fe ==
'-') { *fe++ =
'\0'; R = fe; }
else R = NULL;
3473 t =
stpcpy(t,
" pre=\"1\"");
3478 he->
p.
argv[he->
c] = NULL;
3534 spew_t spew,
int lvl)
3537 int ix = (he->
ix > 0 ? he->
ix : 0);
3542 val =
xstrdup(
_(
"(not a string)"));
3575 static char q =
'"';
3591 if (xx == 0)
goto exit;
3597 if (xx == 0)
goto exit;
3602 if (xx == 0)
goto exit;
3608 for (i = 0; i < c; i++) {
3614 nb += strlen(instance) +
sizeof(
", '', '', '', '', ''") - 1;
3616 nb +=
sizeof(
", ''") - 1;
3617 nb += strlen(N.
argv[i]);
3618 if (EVR.
argv != NULL && EVR.
argv[i] != NULL && *EVR.
argv[i] !=
'\0') {
3619 uint32_t Fx = ((F.
ui32p[i] >> 1) & 0x7);
3622 const char * E = Revr->F[RPMEVR_E];
3623 const char * V = Revr->F[RPMEVR_V];
3625 const char * T = Revr->F[RPMEVR_T];
3627 const char * R = Revr->F[RPMEVR_R];
3629 const char * D = Revr->F[RPMEVR_D];
3632 nb += (
sizeof(
", 'EQ'")-1);
3633 nb += (
sizeof(
", ''")-1) + strlen(E);
3634 nb += (
sizeof(
", ''")-1) + strlen(V);
3636 nb += (
sizeof(
", ''")-1) + strlen(T);
3638 nb += (
sizeof(
", ''")-1) + strlen(R);
3640 nb += (
sizeof(
", ''")-1) + strlen(D);
3646 nb +=
sizeof(
"1") - 1;
3651 nb += (ac + 1) *
sizeof(*he->
p.
argv);
3657 te = (
char *) &he->
p.
argv[ac + 1];
3660 for (i = 0; i < c; i++) {
3665 he->
p.
argv[ac++] = te;
3666 te =
stpcpy(te, instance);
3667 *te++ =
','; *te++ =
' ';
3668 *te++ = q; te =
stpcpy(te, N.
argv[i]); *te++ = q;
3670 if (EVR.
argv != NULL && EVR.
argv[i] != NULL && *EVR.
argv[i] !=
'\0') {
3671 static const char *Fstr[] = {
"?0",
"LT",
"GT",
"?3",
"EQ",
"LE",
"GE",
"?7" };
3672 uint32_t Fx = ((F.
ui32p[i] >> 1) & 0x7);
3675 const char * E = Revr->F[RPMEVR_E];
3676 const char * V = Revr->F[RPMEVR_V];
3678 const char * T = Revr->F[RPMEVR_T];
3680 const char * R = Revr->F[RPMEVR_R];
3682 const char * D = Revr->F[RPMEVR_D];
3685 *te++ =
','; *te++ =
' ';
3686 *te++ = q; te =
stpcpy(te, Fstr[Fx]); *te++ = q;
3687 *te++ =
','; *te++ =
' ';
3688 *te++ = q; te =
stpcpy(te, E); *te++ = q;
3689 *te++ =
','; *te++ =
' ';
3690 *te++ = q; te =
stpcpy(te, V); *te++ = q;
3692 *te++ =
','; *te++ =
' ';
3693 *te++ = q; te =
stpcpy(te, T); *te++ = q;
3695 *te++ =
','; *te++ =
' ';
3696 *te++ = q; te =
stpcpy(te, R); *te++ = q;
3698 *te++ =
','; *te++ =
' ';
3699 *te++ = q; te =
stpcpy(te, D); *te++ = q;
3704 *te++ =
','; *te++ =
' ';
3705 *te++ = q; *te++ = q;
3706 *te++ =
','; *te++ =
' ';
3707 *te++ = q; *te++ = q;
3708 *te++ =
','; *te++ =
' ';
3709 *te++ = q; *te++ = q;
3710 *te++ =
','; *te++ =
' ';
3711 *te++ = q; *te++ = q;
3720 he->
p.
argv[ac] = NULL;
3787 if (xx == 0)
goto exit;
3793 if (xx == 0)
goto exit;
3798 if (xx == 0)
goto exit;
3801 nb =
sizeof(*he->
p.
argv);
3803 for (i = 0; i < c; i++) {
3809 nb +=
sizeof(*he->
p.
argv);
3811 if (*N.
argv[i] ==
'/')
3814 nb += strlen(N.
argv[i]);
3815 if (EVR.
argv != NULL && EVR.
argv[i] != NULL && *EVR.
argv[i] !=
'\0') {
3816 nb +=
sizeof(
" >= ") - 1;
3817 nb += strlen(EVR.
argv[i]);
3825 t = (
char *) &he->
p.
argv[he->
c + 1];
3827 for (i = 0; i < c; i++) {
3832 he->
p.
argv[ac++] = t;
3834 if (*N.
argv[i] ==
'/') {
3839 if (EVR.
argv != NULL && EVR.
argv[i] != NULL && *EVR.
argv[i] !=
'\0') {
3840 static char *Fstr[] = {
"?0",
"<",
">",
"?3",
"=",
"<=",
">=",
"?7" };
3848 he->
p.
argv[he->
c] = NULL;
3911 size_t dnlen = strlen(dn);
3914 if (strstr(dn,
"bin/") != NULL)
3916 if (dnlen >=
sizeof(
"/etc/")-1 && !strncmp(dn,
"/etc/", dnlen))
3918 if (!strcmp(dn,
"/usr/lib/") && !strcmp(BN.
argv[i],
"sendmail"))
3944 if (xx == 0)
goto exit;
3950 if (xx == 0)
goto exit;
3955 if (xx == 0)
goto exit;
3960 if (xx == 0)
goto exit;
3965 if (xx == 0)
goto exit;
3968 nb =
sizeof(*he->
p.
argv);
3970 for (i = 0; i < c; i++) {
3971 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
3974 nb +=
sizeof(*he->
p.
argv);
3975 nb +=
sizeof(
"<file></file>");
3978 if (FFLAGS.
ui32p[i] & 0x40)
3979 nb +=
sizeof(
" type=\"ghost\"") - 1;
3980 else if (S_ISDIR(FMODES.
ui16p[i])) {
3981 nb +=
sizeof(
" type=\"dir\"") - 1;
3983 nb +=
sizeof(
"/") - 1;
3992 t = (
char *) &he->
p.
argv[he->
c + 1];
3995 for (i = 0; i < c; i++) {
3996 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
3998 if (FFLAGS.
ui32p[i] & 0x40)
4000 if (S_ISDIR(FMODES.
ui16p[i]))
4002 he->
p.
argv[ac++] = t;
4006 t =
stpcpy(t,
"</file>");
4009 for (i = 0; i < c; i++) {
4010 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4012 if (FFLAGS.
ui32p[i] & 0x40)
4014 if (!S_ISDIR(FMODES.
ui16p[i]))
4016 he->
p.
argv[ac++] = t;
4017 t =
stpcpy(t,
"<file type=\"dir\">");
4025 t =
stpcpy(t,
"</file>");
4028 for (i = 0; i < c; i++) {
4029 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4031 if (!(FFLAGS.
ui32p[i] & 0x40))
4033 he->
p.
argv[ac++] = t;
4034 t =
stpcpy(t,
"<file type=\"ghost\">");
4037 t =
stpcpy(t,
"</file>");
4041 he->
p.
argv[he->
c] = NULL;
4097 if (xx == 0)
goto exit;
4103 if (xx == 0)
goto exit;
4108 if (xx == 0)
goto exit;
4113 if (xx == 0)
goto exit;
4118 if (xx == 0)
goto exit;
4122 nb =
sizeof(*he->
p.
argv);
4124 for (i = 0; i < c; i++) {
4125 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4128 nb +=
sizeof(*he->
p.
argv);
4129 nb += strlen(instance) +
sizeof(
", '', ''");
4131 nb += strlen(BN.
argv[i]);
4132 if (FFLAGS.
ui32p[i] & 0x40)
4133 nb +=
sizeof(
"ghost") - 1;
4134 else if (S_ISDIR(FMODES.
ui16p[i])) {
4135 nb +=
sizeof(
"dir") - 1;
4137 nb +=
sizeof(
"/") - 1;
4140 nb +=
sizeof(
"file") - 1;
4147 t = (
char *) &he->
p.
argv[he->
c + 1];
4150 for (i = 0; i < c; i++) {
4151 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4153 if (FFLAGS.
ui32p[i] & 0x40)
4155 if (S_ISDIR(FMODES.
ui16p[i]))
4157 he->
p.
argv[ac++] = t;
4159 t = strcpy(t, DN.
argv[DI.
ui32p[i]]); t += strlen(t);
4160 t = strcpy(t, BN.
argv[i]); t += strlen(t);
4161 t =
stpcpy(t,
"', 'file'");
4164 for (i = 0; i < c; i++) {
4165 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4167 if (FFLAGS.
ui32p[i] & 0x40)
4169 if (!S_ISDIR(FMODES.
ui16p[i]))
4171 he->
p.
argv[ac++] = t;
4173 t = strcpy(t, DN.
argv[DI.
ui32p[i]]); t += strlen(t);
4174 t = strcpy(t, BN.
argv[i]); t += strlen(t);
4180 t =
stpcpy(t,
"', 'dir'");
4183 for (i = 0; i < c; i++) {
4184 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4186 if (!(FFLAGS.
ui32p[i] & 0x40))
4188 he->
p.
argv[ac++] = t;
4190 t = strcpy(t, DN.
argv[DI.
ui32p[i]]); t += strlen(t);
4191 t = strcpy(t, BN.
argv[i]); t += strlen(t);
4192 t =
stpcpy(t,
"', 'ghost'");
4196 he->
p.
argv[he->
c] = NULL;
4253 if (xx == 0)
goto exit;
4259 if (xx == 0)
goto exit;
4264 if (xx == 0)
goto exit;
4269 if (xx == 0)
goto exit;
4274 if (xx == 0)
goto exit;
4277 nb =
sizeof(*he->
p.
argv);
4279 for (i = 0; i < c; i++) {
4280 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4283 nb +=
sizeof(*he->
p.
argv);
4287 if (FFLAGS.
ui32p[i] & 0x40)
4288 nb +=
sizeof(
"") - 1;
4289 else if (S_ISDIR(FMODES.
ui16p[i]))
4290 nb +=
sizeof(
"/") - 1;
4297 t = (
char *) &he->
p.
argv[he->
c + 1];
4300 for (i = 0; i < c; i++) {
4301 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4303 if (FFLAGS.
ui32p[i] & 0x40)
4305 if (S_ISDIR(FMODES.
ui16p[i]))
4307 he->
p.
argv[ac++] = t;
4314 for (i = 0; i < c; i++) {
4315 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4317 if (FFLAGS.
ui32p[i] & 0x40)
4319 if (!S_ISDIR(FMODES.
ui16p[i]))
4321 he->
p.
argv[ac++] = t;
4330 for (i = 0; i < c; i++) {
4331 if (lvl > 0 &&
FDGSkip(DN, BN, DI, i) != lvl)
4333 if (!(FFLAGS.
ui32p[i] & 0x40))
4335 he->
p.
argv[ac++] = t;
4342 he->
p.
argv[he->
c] = NULL;
4389 val =
xstrdup(
_(
"(not a string)"));
4398 assert(he->
p.
str != NULL);
4400 if ((bn = strrchr(he->
p.
str,
'/')) != NULL)
4417 typedef struct key_s {
4468 STAT_KEYS_FLAGS = (1U << 13),
4473 STAT_KEYS_FCONTEXT = (1U << 16),
4491 {
"fcontext", STAT_KEYS_FCONTEXT },
4492 {
"flags", STAT_KEYS_FLAGS },
4536 UUID_KEYS_STRING = (0U << 4),
4537 UUID_KEYS_SIV = (1U << 4),
4538 UUID_KEYS_BINARY = (2U << 4),
4539 UUID_KEYS_TEXT = (3U << 4),
4546 {
"binary", UUID_KEYS_BINARY },
4547 {
"siv", UUID_KEYS_SIV },
4548 {
"string", UUID_KEYS_STRING },
4549 {
"text", UUID_KEYS_TEXT },
4576 if (name && * name) {
4578 KEY *k = (
KEY *)bsearch(&needle, keys, nkeys,
sizeof(*keys),
keyCmp);
4594 int ix = (he->
ix > 0 ? he->
ix : 0);
4601 val =
xstrdup(
_(
"(invalid type :digest)"));
4605 ns =
sizeof(he->
p.
ui64p[0]);
4608 ns = strlen(he->
p.
str);
4615 assert(he->
p.
ptr != NULL);
4639 static const char *avdefault[] = {
"mode", NULL };
4641 const char * fn = NULL;
4642 struct stat sb, *st = &sb;
4643 int ix = (he->
ix > 0 ? he->
ix : 0);
4648 memset(st, 0,
sizeof(*st));
4654 if ((
size_t)he->
c ==
sizeof(*st)) {
4655 st = (
struct stat *)he->
p.
ptr;
4660 val =
xstrdup(
_(
"(invalid type :stat)"));
4665 if (
Lstat(fn, st) == 0)
4674 if (!(av && av[0] && *av[0]))
4676 for (i = 0; av[i] != NULL; i++) {
4678 size_t nb =
sizeof(b);
4690 xx =
snprintf(b, nb,
"0x%lx", (
unsigned long)st->st_dev);
4693 xx =
snprintf(b, nb,
"0x%lx", (
unsigned long)st->st_ino);
4696 xx =
snprintf(b, nb,
"%06o", (
unsigned)st->st_mode);
4699 xx =
snprintf(b, nb,
"0x%ld", (
unsigned long)st->st_nlink);
4702 xx =
snprintf(b, nb,
"%ld", (
unsigned long)st->st_uid);
4705 xx =
snprintf(b, nb,
"%ld", (
unsigned long)st->st_gid);
4708 xx =
snprintf(b, nb,
"0x%lx", (
unsigned long)st->st_rdev);
4711 xx =
snprintf(b, nb,
"%ld", (
unsigned long)st->st_size);
4714 xx =
snprintf(b, nb,
"%ld", (
unsigned long)st->st_blksize);
4717 xx =
snprintf(b, nb,
"%ld", (
unsigned long)st->st_blocks);
4720 (void)
stpcpy(b, ctime((time_t *)&st->st_atime));
4723 (void)
stpcpy(b, ctime((time_t *)&st->st_ctime));
4726 (void)
stpcpy(b, ctime((time_t *)&st->st_mtime));
4729 case STAT_KEYS_FLAGS:
4733 if (fn != NULL &&
S_ISLNK(st->st_mode)) {
4734 ssize_t size =
Readlink(fn, b, nb);
4736 nval =
rpmExpand(
"(Readlink:", fn,
":", strerror(
errno),
")", NULL);
4744 if (fn != NULL && S_ISREG(st->st_mode)) {
4748 if (fd == NULL ||
Ferror(fd)) {
4751 static int asAscii = 1;
4752 char buffer[16 * 1024];
4754 while (
Fread(buffer,
sizeof(buffer[0]),
sizeof(buffer), fd) > 0)
4770 {
const char * uname =
uidToUname(st->st_uid);
4774 xx =
snprintf(b, nb,
"%u", (
unsigned)st->st_uid);
4777 {
const char * gname =
gidToGname(st->st_gid);
4781 xx =
snprintf(b, nb,
"%u", (
unsigned)st->st_gid);
4811 static const char hex[] =
"0123456789abcdef";
4816 static const char *avdefault[] = {
"v5", NULL };
4818 int ix = (he->
ix > 0 ? he->
ix : 0);
4826 val =
xmalloc((128/4 + 4) + 1);
4834 val =
xstrdup(
_(
"(invalid type :uuid)"));
4842 val =
xstrdup(
_(
"(invalid tag :uuid)"));
4853 tv.tv_sec = (long) he->
p.
ui64p[0];
4854 tv.tv_usec = (
long) (he->
c > 1 ? he->
p.
ui64p[1] : 0);
4859 for (i = 0; i < nhe->
c; i++) {
4860 *te++ = hex[ (int)((nhe->
p.
ui8p[i] >> 4) & 0x0f) ];
4861 *te++ = hex[ (int)((nhe->
p.
ui8p[i] ) & 0x0f) ];
4862 if (i == 3 || i == 5 || i == 7 || i == 9)
4875 val =
xstrdup(
_(
"(invalid tag :uuid)"));
4882 for (i = 0; i < he->
c; i++) {
4883 *te++ = hex[ (int)((he->
p.
ui8p[i] >> 4) & 0x0f) ];
4884 *te++ = hex[ (int)((he->
p.
ui8p[i] ) & 0x0f) ];
4899 if (!(av && av[0] && *av[0]))
4902 for (i = 0; av[i] != NULL; i++) {
4903 uint32_t keyval =
keyValue(keyUuids, nkeyUuids, av[i]);
4912 ix =
str2uuid(nhe, NULL, keyval, val);
4933 int64_t * stack = memset(
alloca(ac*
sizeof(*stack)), 0, (ac*
sizeof(*stack)));
4941 val =
xstrdup(
_(
"(invalid type :rpn)"));
4945 stack[ix] = he->
p.
ui64p[0];
4950 stack[ix] = strtoll(he->
p.
str, &end, 0);
4952 if (end && *end !=
'\0') {
4953 val =
xstrdup(
_(
"(invalid string :rpn)"));
4960 for (i = 0; av[i] != NULL; i++) {
4961 const char * arg = av[i];
4962 size_t len = strlen(arg);
4967 }
else if (len > 1) {
4969 val =
xstrdup(
_(
"(expected number :rpn)"));
4973 val =
xstrdup(
_(
"(stack overflow :rpn)"));
4977 stack[ix] = strtoll(arg, &end, 0);
4978 if (end && *end !=
'\0') {
4979 val =
xstrdup(
_(
"(invalid number :rpn)"));
4984 val =
xstrdup(
_(
"(stack underflow :rpn)"));
4988 case '&': stack[ix] &= stack[ix+1];
break;
4989 case '|': stack[ix] |= stack[ix+1];
break;
4990 case '^': stack[ix] ^= stack[ix+1];
break;
4991 case '+': stack[ix] += stack[ix+1];
break;
4992 case '-': stack[ix] -= stack[ix+1];
break;
4993 case '*': stack[ix] *= stack[ix+1];
break;
4996 if (stack[ix+1] == 0) {
4997 val =
xstrdup(
_(
"(divide by zero :rpn)"));
5001 stack[ix] %= stack[ix+1];
5003 stack[ix] /= stack[ix+1];
5009 {
HE_t nhe = (
HE_t) memset(
alloca(
sizeof(*nhe)), 0,
sizeof(*nhe));
5040 val =
xstrdup(
_(
"(invalid type :strsub)"));
5044 if (ac < 2 || (ac % 2) != 0) {
5045 val =
xstrdup(
_(
"(invalid args :strsub)"));
5054 for (i = 0; av[i] != NULL; i += 2)
5058 if (mires != NULL) {
5061 const char * s, * se;
5067 for (i = 0; i < nmires; i++) {
5068 miRE mire = mires + i;
5078 while (*s !=
'\0') {
5080 if ((se = strchr(s,
'\n')) == NULL)
5085 offsets[0] = offsets[1] = -1;
5091 nb += offsets[0] + strlen(av[2*i+1]);
5093 if (xx != 0 || offsets[1] == offsets[0])
5094 nb += (se - (s + offsets[1]));
5104 if (xx != 0 || offsets[1] == offsets[0]) {
5106 te =
stpncpy(te, s, (se - s));
5128 { HEADER_EXT_TAG,
"RPMTAG_BUILDTIMEUUID",
5130 { HEADER_EXT_TAG,
"RPMTAG_CHANGELOGNAME",
5132 { HEADER_EXT_TAG,
"RPMTAG_CHANGELOGTEXT",
5134 { HEADER_EXT_TAG,
"RPMTAG_DESCRIPTION",
5136 { HEADER_EXT_TAG,
"RPMTAG_GROUP",
5138 { HEADER_EXT_TAG,
"RPMTAG_HDRUUID",
5140 { HEADER_EXT_TAG,
"RPMTAG_INSTALLPREFIX",
5142 { HEADER_EXT_TAG,
"RPMTAG_INSTALLTIDUUID",
5144 { HEADER_EXT_TAG,
"RPMTAG_INSTALLTIMEUUID",
5146 { HEADER_EXT_TAG,
"RPMTAG_ORIGINTIDUUID",
5148 { HEADER_EXT_TAG,
"RPMTAG_ORIGINTIMEUUID",
5150 { HEADER_EXT_TAG,
"RPMTAG_PKGUUID",
5152 { HEADER_EXT_TAG,
"RPMTAG_REMOVETIDUUID",
5154 { HEADER_EXT_TAG,
"RPMTAG_SOURCEPKGUUID",
5156 { HEADER_EXT_TAG,
"RPMTAG_SUMMARY",
5158 { HEADER_EXT_TAG,
"RPMTAG_TRIGGERCONDS",
5160 { HEADER_EXT_TAG,
"RPMTAG_TRIGGERTYPE",
5162 { HEADER_EXT_TAG,
"RPMTAG_DBINSTANCE",
5164 { HEADER_EXT_TAG,
"RPMTAG_HEADERSTARTOFF",
5166 { HEADER_EXT_TAG,
"RPMTAG_HEADERENDOFF",
5168 { HEADER_EXT_TAG,
"RPMTAG_PACKAGEBASEURL",
5170 { HEADER_EXT_TAG,
"RPMTAG_PACKAGEDIGEST",
5172 { HEADER_EXT_TAG,
"RPMTAG_PACKAGEORIGIN",
5174 { HEADER_EXT_TAG,
"RPMTAG_PACKAGESIZE",
5176 { HEADER_EXT_TAG,
"RPMTAG_PACKAGETIME",
5178 { HEADER_EXT_TAG,
"RPMTAG_NVRA",
5180 { HEADER_EXT_TAG,
"RPMTAG_FILENAMES",
5182 { HEADER_EXT_TAG,
"RPMTAG_FILEPATHS",
5184 { HEADER_EXT_TAG,
"RPMTAG_ORIGPATHS",
5186 { HEADER_EXT_TAG,
"RPMTAG_FILESTAT",
5188 { HEADER_EXT_TAG,
"RPMTAG_PROVIDEXMLENTRY",
5190 { HEADER_EXT_TAG,
"RPMTAG_REQUIREXMLENTRY",
5192 { HEADER_EXT_TAG,
"RPMTAG_CONFLICTXMLENTRY",
5194 { HEADER_EXT_TAG,
"RPMTAG_OBSOLETEXMLENTRY",
5196 { HEADER_EXT_TAG,
"RPMTAG_FILESXMLENTRY1",
5198 { HEADER_EXT_TAG,
"RPMTAG_FILESXMLENTRY2",
5200 { HEADER_EXT_TAG,
"RPMTAG_PROVIDEYAMLENTRY",
5202 { HEADER_EXT_TAG,
"RPMTAG_REQUIREYAMLENTRY",
5204 { HEADER_EXT_TAG,
"RPMTAG_CONFLICTYAMLENTRY",
5206 { HEADER_EXT_TAG,
"RPMTAG_OBSOLETEYAMLENTRY",
5208 { HEADER_EXT_TAG,
"RPMTAG_FILESYAMLENTRY1",
5210 { HEADER_EXT_TAG,
"RPMTAG_FILESYAMLENTRY2",
5212 { HEADER_EXT_TAG,
"RPMTAG_PROVIDESQLENTRY",
5214 { HEADER_EXT_TAG,
"RPMTAG_REQUIRESQLENTRY",
5216 { HEADER_EXT_TAG,
"RPMTAG_CONFLICTSQLENTRY",
5218 { HEADER_EXT_TAG,
"RPMTAG_OBSOLETESQLENTRY",
5220 { HEADER_EXT_TAG,
"RPMTAG_FILESSQLENTRY1",
5222 { HEADER_EXT_TAG,
"RPMTAG_FILESSQLENTRY2",
5224 { HEADER_EXT_TAG,
"RPMTAG_DEBCONFLICTS",
5226 { HEADER_EXT_TAG,
"RPMTAG_DEBDEPENDS",
5228 { HEADER_EXT_TAG,
"RPMTAG_DEBMD5SUMS",
5230 { HEADER_EXT_TAG,
"RPMTAG_DEBOBSOLETES",
5232 { HEADER_EXT_TAG,
"RPMTAG_DEBPROVIDES",
5234 { HEADER_EXT_TAG,
"RPMTAG_NEEDSWHAT",
5236 { HEADER_EXT_TAG,
"RPMTAG_WHATNEEDS",
5238 { HEADER_EXT_FORMAT,
"armor",
5240 { HEADER_EXT_FORMAT,
"base64",
5242 { HEADER_EXT_FORMAT,
"bncdata",
5244 { HEADER_EXT_FORMAT,
"cdata",
5246 { HEADER_EXT_FORMAT,
"depflags",
5248 { HEADER_EXT_FORMAT,
"deptype",
5250 { HEADER_EXT_FORMAT,
"digest",
5252 { HEADER_EXT_FORMAT,
"fflags",
5254 { HEADER_EXT_FORMAT,
"hint",
5256 { HEADER_EXT_FORMAT,
"iconv",
5258 { HEADER_EXT_FORMAT,
"json",
5261 { HEADER_EXT_FORMAT,
"jsonescape",
5264 { HEADER_EXT_FORMAT,
"perms",
5266 { HEADER_EXT_FORMAT,
"permissions",
5268 { HEADER_EXT_FORMAT,
"pgpsig",
5270 { HEADER_EXT_FORMAT,
"rpn",
5272 { HEADER_EXT_FORMAT,
"sqlescape",
5274 { HEADER_EXT_FORMAT,
"stat",
5276 { HEADER_EXT_FORMAT,
"strsub",
5278 { HEADER_EXT_FORMAT,
"triggertype",
5280 { HEADER_EXT_FORMAT,
"utf8",
5282 { HEADER_EXT_FORMAT,
"uuid",
5284 { HEADER_EXT_FORMAT,
"xml",
5286 { HEADER_EXT_FORMAT,
"yaml",
5288 { HEADER_EXT_MORE, NULL, { (
void *) &headerDefaultFormats } }
5297 const struct headerTagTableEntry_s * t;
5304 if (_rpmTagTable == NULL)
5308 if (_rpmHeaderFormats == NULL)
5311 for (t = _rpmTagTable; t && t->name; t++) {
5313 static const char * tagtypes[] = {
5314 "",
"char",
"uint8",
"uint16",
"uint32",
"uint64",
5315 "string",
"octets",
"argv",
"i18nstring",
5320 fprintf(fp,
"%-20s %6d", t->name + 7, t->val);
5325 fprintf(fp,
" openpgp");
5327 fprintf(fp,
" x509");
5329 fprintf(fp,
" asn1");
5331 fprintf(fp,
" opaque");
5332 fprintf(fp,
" %s", tagtypes[ttype]);
5334 fprintf(fp,
" array");
5336 fprintf(fp,
" mapping");
5338 fprintf(fp,
" probe");
5340 fprintf(fp,
" tree");
5342 fprintf(fp,
"%s", t->name + 7);
5347 for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST;
5348 ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++)
5350 if (ext->name == NULL || ext->type != HEADER_EXT_TAG)
5356 fprintf(fp,
"%s\n", ext->name + 7);
5362 #define PARSER_BEGIN 0
5363 #define PARSER_IN_ARRAY 1
5364 #define PARSER_IN_EXPR 2
5473 fprintf(stderr,
"\t\t\\%c\n", ch);
5476 case 'a':
return '\a';
5477 case 'b':
return '\b';
5478 case 'f':
return '\f';
5479 case 'n':
return '\n';
5480 case 'r':
return '\r';
5481 case 't':
return '\t';
5482 case 'v':
return '\v';
5498 memset(he, 0,
sizeof(*he));
5515 if (format == NULL)
return NULL;
5517 for (i = 0; i < (unsigned) num; i++) {
5518 switch (format[i].type) {
5529 format[i].
u.
array.format =
5531 format[i].
u.
array.numTokens);
5534 format[i].
u.
cond.ifFormat =
5536 format[i].
u.
cond.numIfTokens);
5537 format[i].
u.
cond.elseFormat =
5539 format[i].
u.
cond.numElseTokens);
5545 format[i].
u.
cond.tag.fmtfuncs =
_free(format[i].u.
cond.tag.fmtfuncs);
5554 format =
_free(format);
5563 static headerSprintfArgs
hsaInit( headerSprintfArgs hsa)
5590 static sprintfToken
hsaNext( headerSprintfArgs hsa)
5594 sprintfToken fmt = NULL;
5602 if (hsa != NULL && hsa->
i < hsa->
numTokens) {
5604 if (hsa->
hi == NULL) {
5628 static headerSprintfArgs
hsaFini( headerSprintfArgs hsa)
5672 static char name[128];
5679 if (s != NULL && typep != NULL)
5684 for (; tbl->name != NULL; tbl++) {
5685 if (tbl->val == val)
5688 if ((s = tbl->name) == NULL)
5690 s +=
sizeof(
"RPMTAG_") - 1;
5716 for (; tbl->name != NULL; tbl++) {
5732 static int findTag(headerSprintfArgs hsa, sprintfToken token,
const char *
name)
5746 if (!strcmp(name,
"*")) {
5751 if (strncmp(
"RPMTAG_", name,
sizeof(
"RPMTAG_")-1)) {
5752 char * t =
alloca(strlen(name) +
sizeof(
"RPMTAG_"));
5758 for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST;
5759 ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++)
5761 if (ext->name == NULL || ext->type != HEADER_EXT_TAG)
5764 stag->
ext = ext->u.tagFunction;
5780 stag->
tagno[0] = tagno;
5782 if (stag->
av != NULL) {
5787 for (i = 0; stag->
av[i] != NULL; i++) {
5788 for (ext = exts; ext != NULL && ext->type != HEADER_EXT_LAST;
5789 ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1))
5791 if (ext->name == NULL || ext->type != HEADER_EXT_FORMAT)
5793 if (strcmp(ext->name, stag->
av[i]+1))
5795 stag->
fmtfuncs[i] = ext->u.fmtFunction;
5813 char * str,
char ** endPtr)
5828 sprintfToken * formatPtr,
5829 size_t * numTokensPtr,
5830 char ** endPtr,
int state)
5836 static const char *pstates[] = {
5837 "NORMAL",
"ARRAY",
"EXPR",
"WTF?"
5839 char * chptr, * start, * next, * dst;
5840 sprintfToken format;
5849 fprintf(stderr,
"--> parseFormat(%p, \"%.20s...\", %p, %p, %p, %s)\n", hsa, str, formatPtr, numTokensPtr, endPtr, pstates[(state & 0x3)]);
5855 for (chptr = str; *chptr !=
'\0'; chptr++)
5856 if (*chptr ==
'%' || *chptr ==
'[') numTokens++;
5857 numTokens = numTokens * 2 + 1;
5859 format =
xcalloc(numTokens,
sizeof(*format));
5860 if (endPtr) *endPtr = NULL;
5867 while (*start !=
'\0') {
5871 if (*(start + 1) ==
'%') {
5873 token = format + numTokens++;
5876 dst = token->
u.
string.string = start;
5884 token = format + numTokens++;
5888 if (*start ==
'|') {
5909 while (*chptr && *chptr !=
'{' && *chptr !=
'%') chptr++;
5910 if (!*chptr || *chptr ==
'%') {
5911 hsa->
errmsg =
_(
"missing { after %");
5918 fprintf(stderr,
"\tchptr *%p = NUL\n", chptr);
5922 while (start < chptr) {
5924 i = strtoul(start, &start, 10);
5933 if (*start ==
'=') {
5936 }
else if (*start ==
'#') {
5943 while (*next && *next !=
'}') next++;
5945 hsa->
errmsg =
_(
"missing } after %{");
5951 fprintf(stderr,
"\tnext *%p = NUL\n", next);
5955 #define isSEP(_c) ((_c) == ':' || (_c) == '|')
5957 while (!(*chptr ==
'\0' ||
isSEP(*chptr))) chptr++;
5959 while (
isSEP(*chptr)) {
5960 if (chptr[1] ==
'\0' ||
isSEP(chptr[1])) {
5961 hsa->
errmsg =
_(
"empty tag format");
5966 {
char * te = chptr + 1;
5967 char * t = strchr(te,
'(');
5970 while (!(*te ==
'\0' ||
isSEP(*te))) {
5972 if (te[0] ==
'\\' && te[1] !=
'\0') te++;
5976 c = *te; *te =
'\0';
5980 if (te <= t || te[-1] !=
')') {
5981 hsa->
errmsg =
_(
"malformed parameter list");
5991 fprintf(stderr,
"\tformat \"%s\" params \"%s\"\n", chptr, (t ? t :
""));
6001 if (*start ==
'\0') {
6002 hsa->
errmsg =
_(
"empty tag name");
6010 if (
findTag(hsa, token, start)) {
6011 hsa->
errmsg =
_(
"unknown tag");
6019 fprintf(stderr,
"\tdst = start = next %p\n", dst);
6026 fprintf(stderr,
"\t%s => %s *%p = NUL\n", pstates[(state & 0x3)], pstates[
PARSER_IN_ARRAY], start);
6029 token = format + numTokens++;
6033 &token->
u.
array.numTokens,
6034 &start, PARSER_IN_ARRAY))
6041 hsa->
errmsg =
_(
"] expected at end of array");
6049 fprintf(stderr,
"\tdst = start %p\n", dst);
6057 if (state != PARSER_IN_ARRAY) {
6058 hsa->
errmsg =
_(
"unexpected ]");
6065 fprintf(stderr,
"\t<= %s %p[-1] = NUL\n", pstates[(state & 0x3)], start);
6067 if (endPtr) *endPtr = start;
6073 hsa->
errmsg =
_(
"unexpected }");
6080 fprintf(stderr,
"\t<= %s %p[-1] = NUL\n", pstates[(state & 0x3)], start);
6082 if (endPtr) *endPtr = start;
6088 token = format + numTokens++;
6091 dst = token->
u.
string.string = start;
6097 fprintf(stderr,
"\t*%p = *%p \"%.30s\"\n", dst, start, start);
6099 if (start[0] ==
'\\' && start[1] !=
'\0') {
6108 if (dst < start) *dst =
'\0';
6117 for (i = 0; i < (unsigned) numTokens; i++) {
6119 switch(token->
type) {
6128 if (numTokensPtr != NULL)
6129 *numTokensPtr = numTokens;
6130 if (formatPtr != NULL)
6131 *formatPtr = format;
6137 char * str,
char ** endPtr)
6144 fprintf(stderr,
"--> parseExpression(%p, %p, \"%.20s...\", %p)\n", hsa, token, str, endPtr);
6149 while (*chptr && *chptr !=
'?') chptr++;
6151 if (*chptr !=
'?') {
6152 hsa->
errmsg =
_(
"? expected in expression");
6158 if (*chptr !=
'{') {
6159 hsa->
errmsg =
_(
"{ expected after ? in expression");
6170 if (!(end && *end)) {
6171 hsa->
errmsg =
_(
"} expected in expression");
6172 token->
u.
cond.ifFormat =
6178 if (*chptr !=
':' && *chptr !=
'|') {
6179 hsa->
errmsg =
_(
": expected following ? subexpression");
6180 token->
u.
cond.ifFormat =
6185 if (*chptr ==
'|') {
6189 token->
u.
cond.ifFormat =
6196 if (*chptr !=
'{') {
6197 hsa->
errmsg =
_(
"{ expected after : in expression");
6198 token->
u.
cond.ifFormat =
6210 if (!(end && *end)) {
6211 hsa->
errmsg =
_(
"} expected in expression");
6212 token->
u.
cond.ifFormat =
6218 if (*chptr !=
'|') {
6219 hsa->
errmsg =
_(
"| expected at end of expression");
6220 token->
u.
cond.ifFormat =
6222 token->
u.
cond.elseFormat =
6234 (void)
findTag(hsa, token, str);
6254 rc = fn(hsa->
h, he);
6318 val =
xstrdup(
"(unknown type)");
6319 need = strlen(val) + 1;
6322 #if defined(SUPPORT_I18NSTRING_TYPE)
6331 #if !defined(SUPPORT_I18NSTRING_TYPE)
6359 ival = he->
p.
ui64p[element];
6365 vhe->
ix = (he->
c > 1 ? 0 : -1);
6382 for (i = 0; tag->
av[i] != NULL; i++) {
6383 headerTagFormatFunction fmt;
6385 if ((fmt = tag->
fmtfuncs[i]) == NULL)
6388 if (val != NULL && *tag->
av[i] ==
'|') {
6402 nval = fmt(vhe, av);
6406 fprintf(stderr,
"\t%s(%s) %p(%p,%p) |%s|\n", tag->
av[i], (tag->
params ? tag->
params[i] : NULL), (
void *)fmt, (
void *)vhe, (
void *)(av ? av : NULL), (nval ? nval :
"(null)"));
6411 val =
xstrdup((nval ? nval :
""));
6415 val =
rpmExpand(val, (*val !=
'\0' ?
" | " :
""), nval, NULL);
6426 assert(val != NULL);
6428 need = strlen(val) + 1;
6431 if (val && need > 0) {
6434 nb = strlen(tag->
format) +
sizeof(
"%s");
6437 nb = tag->
pad + strlen(val) + 1;
6473 sprintfTag tag = NULL;
6475 size_t condNumFormats;
6481 switch (token->
type) {
6487 if (need == 0)
break;
6504 if (token->
u.
cond.tag.ext
6507 spft = token->
u.
cond.ifFormat;
6508 condNumFormats = token->
u.
cond.numIfTokens;
6510 spft = token->
u.
cond.elseFormat;
6511 condNumFormats = token->
u.
cond.numElseTokens;
6514 need = condNumFormats * 20;
6515 if (spft == NULL || need == 0)
break;
6518 for (i = 0; i < condNumFormats; i++, spft++) {
6529 spft = token->
u.
array.format;
6530 for (i = 0; i < token->
u.
array.numTokens; i++, spft++)
6552 if (numElements == 0) {
6553 numElements = he->
c;
6556 if ((
size_t)he->
c == numElements)
6559 _(
"array iterator used with different sized arrays");
6565 if (numElements == 0)
6570 spft = token->
u.
array.format;
6572 if (numElements == 0) {
6574 need =
sizeof(
"(none)\n") - 1;
6576 te =
stpcpy(t,
"(none)\n");
6581 const char * tagN = NULL;
6584 need = numElements * token->
u.
array.numTokens;
6585 if (need == 0)
break;
6592 && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"xml"))
6595 && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"yaml"))
6598 && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"json"))
6601 if (spew == &_xml_spew) {
6602 assert(tag->
tagno != NULL);
6604 if (tag->
tagno[0] & 0x40000000) {
6608 need =
sizeof(
" <rpmTag name=\"\">\n") + strlen(tagN);
6613 if (spew == &_yaml_spew) {
6614 assert(tag->
tagno != NULL);
6616 if (tag->
tagno[0] & 0x40000000) {
6618 tagT = numElements > 1
6622 need =
sizeof(
" : - ") + strlen(tagN);
6633 if (spew == &_json_spew) {
6634 assert(tag->
tagno != NULL);
6636 if (tag->
tagno[0] & 0x40000000) {
6638 tagT = numElements > 1
6645 need =
sizeof(
" : [ ") + strlen(tagN);
6653 need = numElements * token->
u.
array.numTokens * 10;
6655 for (j = 0; j < numElements; j++) {
6656 spft = token->
u.
array.format;
6657 for (i = 0; i < token->
u.
array.numTokens; i++, spft++) {
6666 if (spew == &_xml_spew) {
6667 need =
sizeof(
" </rpmTag>\n") - 1;
6669 te =
stpcpy(te,
" </rpmTag>\n");
6672 if (spew == &_json_spew) {
6674 need =
sizeof(
" ],\n") - 1;
6676 te =
stpcpy(te,
" ],\n");
6679 need =
sizeof(
"\n") - 1;
6708 for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST;
6709 ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++)
6732 for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST;
6733 ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++)
6748 sprintfToken nextfmt;
6756 fprintf(stderr,
"==> headerSprintf(%p, \"%s\", %p, %p, %p)\n", h, fmt, tags, exts, errmsg);
6793 && tag->
av != NULL && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"xml"))
6796 && tag->
av != NULL && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"yaml"))
6799 && tag->
av != NULL && tag->
av[0] != NULL && !strcmp(tag->
av[0]+1,
"json"))
6804 need = strlen(spew_init);
6806 te =
stpcpy(t, spew_init);
6808 spew_init =
_free(spew_init);
6812 while ((nextfmt =
hsaNext(hsa)) != NULL) {
6825 need = strlen(spew_fini);
6827 te =
stpcpy(t, spew_fini);
6829 spew_fini =
_free(spew_fini);