15 #define _RPMTAG_INTERNAL
36 0x8e, 0xad, 0xe8, 0x01, 0x00, 0x00, 0x00, 0x00
103 if (h->
index != NULL) {
107 for (i = 0; i < h->
indexUsed; i++, entry++) {
111 if ((ei - 2) == h->
blob) {
115 "==> munmap(%p[%u]) error(%d): %s\n",
157 if (_headerPool == NULL) {
176 memset(&h->
sb, 0,
sizeof(h->
sb));
197 static int indexCmp(
const void * avp,
const void * bvp)
203 return ((
int)ap->
info.
tag - (int)bp->info.tag);
222 static int offsetCmp(
const void * avp,
const void * bvp)
227 int rc = ((int)ap->
info.
offset - (
int)bp->info.offset);
232 rc = (((
char *)ap->
data) - ((
char *)bp->data));
234 rc = ((int)ap->
info.
tag - (
int)bp->info.tag);
268 for (i = 0, entry = h->
index; i < h->indexUsed; i++, entry++) {
298 size +=
sizeof(
struct entryInfo_s) + entry->length;
318 const unsigned char * s = (
unsigned char *) (*p).ui8p;
319 const unsigned char * se = (
unsigned char *) (pend ? (*pend).
ui8p : NULL);
326 while (*s++ !=
'\0') {
340 while (*s++ !=
'\0') {
347 const char ** av = (*p).argv;
350 length += strlen(*av++) + 1;
357 length =
typeSizes[(type & 0xf)] * count;
358 if ((se && (s + length) > se))
370 static unsigned char *
tagSwab(
unsigned char * t,
371 const HE_t he,
size_t nb)
379 assert(nb == (he->
c *
sizeof(*tt)));
380 for (i = 0; i < he->
c; i++) {
389 assert(nb == (he->
c *
sizeof(*tt)));
390 for (i = 0; i < he->
c; i++)
395 assert(nb == (he->
c *
sizeof(*tt)));
396 for (i = 0; i < he->
c; i++)
400 assert(he->
p.
ptr != NULL);
401 if ((
void *)t != he->
p.
ptr && nb)
402 memcpy(t, he->
p.
ptr, nb);
430 nb = he->
c *
sizeof(*he->
p.
ui8p);
433 nb = he->
c *
sizeof(*he->
p.
ui16p);
436 nb = he->
c *
sizeof(*he->
p.
ui32p);
439 nb = he->
c *
sizeof(*he->
p.
ui64p);
443 nb = strlen(he->
p.
str) + 1;
455 if (
tagSwab(ptr, he, nb) != NULL)
498 unsigned char * dataStart,
499 const unsigned char * dataEnd,
503 HE_t he = memset(
alloca(
sizeof(*he)), 0,
sizeof(*he));
506 unsigned char * tprev = NULL;
507 unsigned char * t = NULL;
512 assert(dataEnd != NULL);
513 assert(entry != NULL);
516 memset(&ieprev, 0,
sizeof(ieprev));
517 for (; il > 0; il--, pe++) {
537 if (dataEnd && t >= dataEnd)
576 tdel = (tprev ? (t - tprev) : 0);
596 if (dataEnd && (dataStart + dl) > dataEnd)
return 0;
601 tdel = (tprev ? (t - tprev) : 0);
623 unsigned char * dataStart;
646 drlen = ndribbles = driplen = ndrips = 0;
647 for (i = 0, entry = h->
index; i < h->indexUsed; i++, entry++) {
691 if (entry->
data == NULL || entry->
length == 0)
716 len =
sizeof(il) +
sizeof(dl) + (il *
sizeof(*pe)) + dl;
723 dataStart = te = (
unsigned char *) (pe + il);
726 for (i = 0, entry = h->
index; i < h->indexUsed; i++, entry++) {
731 if (entry->
data == NULL || entry->
length == 0)
750 src = (
char *)entry->
data;
751 rdlen = entry->
rdlen;
758 memcpy(pe+1, src, rdl);
759 memcpy(te, src + rdl, rdlen);
774 memcpy(pe+1, src +
sizeof(*pe), ((ril-1) *
sizeof(*pe)));
775 memcpy(te, src + (ril *
sizeof(*pe)), rdlen+entry->
info.
count+drlen);
782 ? htonl(te - dataStart) : htonl(off));
789 while (i < h->indexUsed && entry->
info.
offset <= rid+1) {
800 if (entry->
data == NULL || entry->
length == 0)
823 if (((
unsigned char *)pe) != dataStart)
825 if ((((
unsigned char *)ei)+len) != te)
834 if (sw != NULL) (void)
rpmswExit(sw, len);
839 if (sw != NULL) (void)
rpmswExit(sw, len);
860 if (h == NULL)
return NULL;
875 entry > h->
index) entry--;
883 entry2 < last) entry2++;
910 if (!entry)
return 1;
913 while (entry > h->
index && (entry - 1)->
info.
tag == tag)
917 for (first = entry; first < last; first++) {
929 ne = (first - entry);
934 memmove(entry, first, (ne *
sizeof(*entry)));
947 size_t pvlen =
sizeof(il) +
sizeof(dl) +
953 unsigned char * dataStart;
954 unsigned char * dataEnd;
967 dataStart = (
unsigned char *) (pe + il);
968 dataEnd = dataStart + dl;
975 (void) memcpy(h->
magic, hmagic,
sizeof(h->
magic));
985 memset(&h->
sb, 0,
sizeof(h->
sb));
1006 entry->
info.
offset = ((
unsigned char *)pe - dataStart);
1011 entry->
length = pvlen -
sizeof(il) -
sizeof(dl);
1017 entry->
rdlen = rdlen;
1062 entry->
length = pvlen -
sizeof(il) -
sizeof(dl);
1066 entry->
rdlen = rdlen;
1086 for (j = 0; j < ne; j++, newEntry++) {
1095 (ne *
sizeof(*entry)));
1105 if (sw != NULL) (void)
rpmswExit(sw, pvlen);
1112 if (sw != NULL) (void)
rpmswExit(sw, pvlen);
1129 *magicp = (h ? h->
magic : hmagic);
1137 if (nmagic >
sizeof(h->
magic))
1138 nmagic =
sizeof(h->
magic);
1142 memmove(h->
magic, magic, nmagic);
1149 return (h != NULL ? h->
origin : NULL);
1164 return (h != NULL ? h->
baseurl : NULL);
1180 return (h != NULL ? &h->
sb : NULL);
1186 if (h != NULL && st != NULL)
1187 memcpy(&h->
sb, st,
sizeof(h->
sb));
1194 return (h != NULL ? h->
digest : NULL);
1210 return (h != NULL ? h->
rpmdb : NULL);
1225 return (h != NULL ? h->
instance : 0);
1237 return (h != NULL ? h->
startoff : 0);
1249 return (h != NULL ? h->
endoff : 0);
1266 struct stat sb = h->
sb;
1288 if (origin != NULL) {
1290 origin =
_free(origin);
1292 if (baseurl != NULL) {
1294 baseurl =
_free(baseurl);
1296 if (digest != NULL) {
1298 digest =
_free(digest);
1315 size_t pvlen =
sizeof(il) +
sizeof(dl) +
1326 static const int prot = PROT_READ | PROT_WRITE;
1327 static const int flags = MAP_PRIVATE| MAP_ANONYMOUS;
1328 static const int fdno = -1;
1329 static const off_t off = 0;
1330 nuh = mmap(NULL, pvlen, prot, flags, fdno, off);
1331 if (nuh == NULL || nuh == (
void *)-1)
1333 "==> mmap(%p[%u], 0x%x, 0x%x, %d, 0x%x) error(%d): %s\n",
1334 NULL, pvlen, prot, flags, fdno, (
unsigned)off,
1336 memcpy(nuh, uh, pvlen);
1337 if (mprotect(nuh, pvlen, PROT_READ) != 0)
1338 fprintf(stderr,
"==> mprotect(%p[%u],0x%x) error(%d): %s\n",
1339 nuh, pvlen, PROT_READ,
1347 if (munmap(nuh, pvlen) != 0)
1348 fprintf(stderr,
"==> munmap(%p[%u]) error(%d): %s\n",
1352 nuh = memcpy(
xmalloc(pvlen), uh, pvlen);
1364 static const int map = 1;
1402 unsigned char * dataStart = (
unsigned char *) (pe + ntohl(ei[0]));
1411 count = 2 *
sizeof(*ei) + (ril *
sizeof(*pe)) + rdl;
1425 pe = (
entryInfo) memcpy(ei + 2, pe, (ril *
sizeof(*pe)));
1428 (void) memcpy(pe + ril, dataStart, rdl);
1431 he->
p.
ptr = (!minMem
1444 {
const char ** argv;
1445 size_t nb = count *
sizeof(*argv);
1455 t = (
char *) &argv[count];
1459 for (i = 0; i < (unsigned) count; i++) {
1500 {
const char *s, *ll, *CC, *EE, *dd;
1504 lbuf =
alloca(le - l + 1);
1505 for (s = l, ll = t = lbuf; *s; s++, t++) {
1526 for (t = ll; *t; t++) *t = tolower(*t);
1528 for (t = CC; *t; t++) *t = toupper(*t);
1535 if (strlen(td) == (
size_t)(le - l) && !strncmp(td, l, (
size_t)(le - l)))
1539 for (fe = l; fe < le && *fe !=
'@'; fe++)
1541 if (fe < le && !strncmp(td, l, (fe - l)))
1545 for (fe = l; fe < le && *fe !=
'.'; fe++)
1547 if (fe < le && !strncmp(td, l, (fe - l)))
1551 for (fe = l; fe < le && *fe !=
'_'; fe++)
1553 if (fe < le && !strncmp(td, l, (fe - l)))
1569 const char *
lang, *l, *le;
1573 if ((lang =
getenv(
"LANGUAGE")) == NULL &&
1574 (lang =
getenv(
"LC_ALL")) == NULL &&
1575 (lang =
getenv(
"LC_MESSAGES")) == NULL &&
1576 (lang =
getenv(
"LANG")) == NULL)
1584 for (l = lang; *l !=
'\0'; l = le) {
1586 char *ed, *ed_weak = NULL;
1589 while (*l && *l ==
':')
1593 for (le = l; *le && *le !=
':'; le++)
1597 for (langNum = 0, td = table->
data, ed = entry->
data;
1598 langNum < entry->info.count;
1599 langNum++, td += strlen(td) + 1, ed += strlen(ed) + 1)
1602 if (match == 1)
return ed;
1603 else if (match == 2) ed_weak = ed;
1605 if (ed_weak)
return ed_weak;
1629 if (entry == NULL) {
1654 return (rc == 1 ? 1 : 0);
1672 {
const char ** av = he->
p.
argv;
1676 while (cnt-- > 0 && nb > 0) {
1677 if ((s = *av++) != NULL)
1680 }
while (s[-1] && --nb > 0);
1684 if (
tagSwab((
unsigned char *)t, he, nb) == NULL)
1747 if (data.
ptr == NULL || length == 0)
1843 HE_t he = memset(
alloca(
sizeof(*he)), 0,
sizeof(*he));
1856 if (!table && entry)
1859 if (!table && !entry) {
1860 const char * argv[2];
1863 if (!lang || (lang[0] ==
'C' && lang[1] ==
'\0')) {
1865 p.
argv[count++] =
"C";
1869 p.
argv[count++] =
"C";
1885 if (!lang) lang =
"C";
1887 {
const char * l = table->
data;
1888 for (langNum = 0; langNum < table->
info.
count; langNum++) {
1889 if (!strcmp(l, lang))
break;
1895 length = strlen(lang) + 1;
1903 memmove(((
char *)table->
data) + table->
length, lang, length);
1911 for (i = 0; i < langNum; i++)
1914 p.
argv[langNum] =
string;
1918 he->
c = langNum + 1;
1923 }
else if (langNum >= entry->
info.
count) {
1926 length = strlen(
string) + 1 + ghosts;
1935 memset(((
char *)entry->
data) + entry->
length, 0, ghosts);
1936 memmove(((
char *)entry->
data) + entry->
length + ghosts,
string, strlen(
string)+1);
1941 char *b, *be, *e, *ee, *t;
1945 b = be = e = ee = entry->
data;
1946 for (i = 0; i < table->
info.
count; i++) {
1949 ee += strlen(ee) + 1;
1956 sn = strlen(
string) + 1;
1958 length = bn + sn + en;
1965 memcpy(t,
string, sn);
1972 entry->
length -= strlen(be) + 1;
2009 if (newData.
ptr == NULL || length == 0)
2060 assert(hi->
h != NULL);
2074 memset(he, 0,
sizeof(*he));
2076 for (slot = hi->
next_index; slot < h->indexUsed; slot++) {
2077 entry = h->
index + slot;
2082 if (entry == NULL || slot >= h->
indexUsed)
2095 if (sw != NULL) (void)
rpmswExit(sw, 0);
2098 return ((rc == 1) ? 1 : 0);
2103 HE_t he = memset(
alloca(
sizeof(*he)), 0,
sizeof(*he));
2120 HE_t he = memset(
alloca(
sizeof(*he)), 0,
sizeof(*he));
2124 if (headerFrom == headerTo)
2127 for (tagno = tagstocopy; *tagno != 0; tagno++) {
2147 if (h == NULL || he == NULL)
return 0;
2151 memset(he, 0,
sizeof(*he));
2161 for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST;
2162 ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++)
2164 if (ext->name == NULL || ext->type != HEADER_EXT_TAG)
2170 if (ext && ext->name != NULL && ext->type == HEADER_EXT_TAG) {
2171 rc = ext->u.tagFunction(h, he);
2179 if (sw != NULL) (void)
rpmswExit(sw, 0);
2181 #if defined(SUPPORT_IMPLICIT_TAG_DATA_TYPES)
2185 tagTypeValidate(he);
2190 if (!((rc == 0 && he->
freeData == 0 && he->
p.
ptr == NULL) ||
2194 fprintf(stderr,
"==> %s(%u) %u %p[%u] free %u rc %d\n", name, (
unsigned) he->
tag, (
unsigned) he->
t, he->
p.
ptr, (
unsigned) he->
c, he->
freeData, rc);
2205 #if defined(SUPPORT_IMPLICIT_TAG_DATA_TYPES)
2208 tagTypeValidate(he);
2230 #if defined(SUPPORT_IMPLICIT_TAG_DATA_TYPES)
2233 tagTypeValidate(he);