lib/header.c

   1 /** \ingroup header
   2  * \file lib/header.c
   3  */
   4
   5 /* RPM - Copyright (C) 1995-2002 Red Hat Software */
   6
   7 /* Data written to file descriptors is in network byte order.    */
   8 /* Data read from file descriptors is expected to be in          */
   9 /* network byte order and is converted on the fly to host order. */
  10
  11 #include "system.h"
  12
  13 #include <rpm/rpmtypes.h>
  14 #include <rpm/rpmstring.h>
  15 #include "lib/header_internal.h"
  16
  17 #include "debug.h"
  18
  19 int _hdr_debug = 0;
  20
  21 /** \ingroup header
  22  */
  23 const unsigned char rpm_header_magic[8] = {
  24         0x8e, 0xad, 0xe8, 0x01, 0x00, 0x00, 0x00, 0x00
  25 };
  26
  27 /** \ingroup header
  28  * Alignment needed for header data types.
  29  */
  30 static const int typeAlign[16] =  {
  31     1,  /*!< RPM_NULL_TYPE */
  32     1,  /*!< RPM_CHAR_TYPE */
  33     1,  /*!< RPM_INT8_TYPE */
  34     2,  /*!< RPM_INT16_TYPE */
  35     4,  /*!< RPM_INT32_TYPE */
  36     8,  /*!< RPM_INT64_TYPE */
  37     1,  /*!< RPM_STRING_TYPE */
  38     1,  /*!< RPM_BIN_TYPE */
  39     1,  /*!< RPM_STRING_ARRAY_TYPE */
  40     1,  /*!< RPM_I18NSTRING_TYPE */
  41     0,
  42     0,
  43     0,
  44     0,
  45     0,
  46     0
  47 };
  48
  49 /** \ingroup header
  50  * Size of header data types.
  51  */
  52 static const int typeSizes[16] =  {
  53     0,  /*!< RPM_NULL_TYPE */
  54     1,  /*!< RPM_CHAR_TYPE */
  55     1,  /*!< RPM_INT8_TYPE */
  56     2,  /*!< RPM_INT16_TYPE */
  57     4,  /*!< RPM_INT32_TYPE */
  58     8,  /*!< RPM_INT64_TYPE */
  59     -1, /*!< RPM_STRING_TYPE */
  60     1,  /*!< RPM_BIN_TYPE */
  61     -1, /*!< RPM_STRING_ARRAY_TYPE */
  62     -1, /*!< RPM_I18NSTRING_TYPE */
  63     0,
  64     0,
  65     0,
  66     0,
  67     0,
  68     0
  69 };
  70
  71 /** \ingroup header
  72  * Maximum no. of bytes permitted in a header.
  73  */
  74 static const size_t headerMaxbytes = (32*1024*1024);
  75
  76 /** \ingroup header
  77  * HEADER_EXT_TAG format function prototype.
  78  * This is allowed to fail, which indicates the tag doesn't exist.
  79  *
  80  * @param h             header
  81  * @retval td           tag data container
  82  * @param flags         modifier flags
  83  * @return              0 on success
  84  */
  85 typedef int (*headerTagTagFunction) (Header h, rpmtd td, headerGetFlags hgflags);
  86
  87 extern void *rpmHeaderTagFunc(rpmTag tag);
  88
  89 Header headerLink(Header h)
  90 {
  91     if (h == NULL) return NULL;
  92
  93     h->nrefs++;
  94 if (_hdr_debug)
  95 fprintf(stderr, "--> h  %p ++ %d at %s:%u\n", h, h->nrefs, __FILE__, __LINE__);
  96
  97     return h;
  98 }
  99
 100 Header headerUnlink(Header h)
 101 {
 102     if (h == NULL) return NULL;
 103 if (_hdr_debug)
 104 fprintf(stderr, "--> h  %p -- %d at %s:%u\n", h, h->nrefs, __FILE__, __LINE__);
 105     h->nrefs--;
 106     return NULL;
 107 }
 108
 109 Header headerFree(Header h)
 110 {
 111     (void) headerUnlink(h);
 112
 113     if (h == NULL || h->nrefs > 0)
 114         return NULL;    /* XXX return previous header? */
 115
 116     if (h->index) {
 117         indexEntry entry = h->index;
 118         int i;
 119         for (i = 0; i < h->indexUsed; i++, entry++) {
 120             if ((h->flags & HEADERFLAG_ALLOCATED) && ENTRY_IS_REGION(entry)) {
 121                 if (entry->length > 0) {
 122                     int32_t * ei = entry->data;
 123                     if ((ei - 2) == h->blob) h->blob = _free(h->blob);
 124                     entry->data = NULL;
 125                 }
 126             } else if (!ENTRY_IN_REGION(entry)) {
 127                 entry->data = _free(entry->data);
 128             }
 129             entry->data = NULL;
 130         }
 131         h->index = _free(h->index);
 132     }
 133
 134     h = _free(h);
 135     return h;
 136 }
 137
 138 Header headerNew(void)
 139 {
 140     Header h = xcalloc(1, sizeof(*h));
 141
 142     h->blob = NULL;
 143     h->indexAlloced = INDEX_MALLOC_SIZE;
 144     h->indexUsed = 0;
 145     h->instance = 0;
 146     h->flags |= HEADERFLAG_SORTED;
 147
 148     h->index = (h->indexAlloced
 149         ? xcalloc(h->indexAlloced, sizeof(*h->index))
 150         : NULL);
 151
 152     h->nrefs = 0;
 153     return headerLink(h);
 154 }
 155
 156 int headerVerifyInfo(int il, int dl, const void * pev, void * iv, int negate)
 157 {
 158     entryInfo pe = (entryInfo) pev;
 159     entryInfo info = iv;
 160     int i;
 161
 162     for (i = 0; i < il; i++) {
 163         info->tag = ntohl(pe[i].tag);
 164         info->type = ntohl(pe[i].type);
 165         info->offset = ntohl(pe[i].offset);
 166         if (negate)
 167             info->offset = -info->offset;
 168         info->count = ntohl(pe[i].count);
 169
 170         if (hdrchkType(info->type))
 171             return i;
 172         if (hdrchkAlign(info->type, info->offset))
 173             return i;
 174         if (!negate && hdrchkRange(dl, info->offset))
 175             return i;
 176         if (hdrchkData(info->count))
 177             return i;
 178
 179     }
 180     return -1;
 181 }
 182
 183 /**
 184  */
 185 static int indexCmp(const void * avp, const void * bvp)
 186 {
 187     indexEntry ap = (indexEntry) avp, bp = (indexEntry) bvp;
 188     return (ap->info.tag - bp->info.tag);
 189 }
 190
 191 void headerSort(Header h)
 192 {
 193     if (!(h->flags & HEADERFLAG_SORTED)) {
 194         qsort(h->index, h->indexUsed, sizeof(*h->index), indexCmp);
 195         h->flags |= HEADERFLAG_SORTED;
 196     }
 197 }
 198
 199 /**
 200  */
 201 static int offsetCmp(const void * avp, const void * bvp)
 202 {
 203     indexEntry ap = (indexEntry) avp, bp = (indexEntry) bvp;
 204     int rc = (ap->info.offset - bp->info.offset);
 205
 206     if (rc == 0) {
 207         /* Within a region, entries sort by address. Added drips sort by tag. */
 208         if (ap->info.offset < 0)
 209             rc = (((char *)ap->data) - ((char *)bp->data));
 210         else
 211             rc = (ap->info.tag - bp->info.tag);
 212     }
 213     return rc;
 214 }
 215
 216 /** \ingroup header
 217  * Restore tags in header to original ordering.
 218  * @param h             header
 219  */
 220 void headerUnsort(Header h)
 221 {
 222     qsort(h->index, h->indexUsed, sizeof(*h->index), offsetCmp);
 223 }
 224
 225 unsigned headerSizeof(Header h, enum hMagic magicp)
 226 {
 227     indexEntry entry;
 228     unsigned int size = 0;
 229     unsigned int pad = 0;
 230     int i;
 231
 232     if (h == NULL)
 233         return size;
 234
 235     headerSort(h);
 236
 237     switch (magicp) {
 238     case HEADER_MAGIC_YES:
 239         size += sizeof(rpm_header_magic);
 240         break;
 241     case HEADER_MAGIC_NO:
 242         break;
 243     }
 244
 245     size += 2 * sizeof(int32_t);        /* count of index entries */
 246
 247     for (i = 0, entry = h->index; i < h->indexUsed; i++, entry++) {
 248         unsigned diff;
 249         rpmTagType type;
 250
 251         /* Regions go in as is ... */
 252         if (ENTRY_IS_REGION(entry)) {
 253             size += entry->length;
 254             /* XXX Legacy regions do not include the region tag and data. */
 255             if (i == 0 && (h->flags & HEADERFLAG_LEGACY))
 256                 size += sizeof(struct entryInfo_s) + entry->info.count;
 257             continue;
 258         }
 259
 260         /* ... and region elements are skipped. */
 261         if (entry->info.offset < 0)
 262             continue;
 263
 264         /* Alignment */
 265         type = entry->info.type;
 266         if (typeSizes[type] > 1) {
 267             diff = typeSizes[type] - (size % typeSizes[type]);
 268             if (diff != typeSizes[type]) {
 269                 size += diff;
 270                 pad += diff;
 271             }
 272         }
 273
 274         size += sizeof(struct entryInfo_s) + entry->length;
 275     }
 276
 277     return size;
 278 }
 279
 280 /**
 281  * Return length of entry data.
 282  * @param type          entry data type
 283  * @param p             entry data
 284  * @param count         entry item count
 285  * @param onDisk        data is concatenated strings (with NUL's))?
 286  * @param pend          pointer to end of data (or NULL)
 287  * @return              no. bytes in data, -1 on failure
 288  */
 289 static int dataLength(rpmTagType type, rpm_constdata_t p, rpm_count_t count,
 290                          int onDisk, rpm_constdata_t pend)
 291 {
 292     const unsigned char * s = p;
 293     const unsigned char * se = pend;
 294     int length = 0;
 295
 296     switch (type) {
 297     case RPM_STRING_TYPE:
 298         if (count != 1)
 299             return -1;
 300         while (*s++) {
 301             if (se && s > se)
 302                 return -1;
 303             length++;
 304         }
 305         length++;       /* count nul terminator too. */
 306         break;
 307
 308     case RPM_STRING_ARRAY_TYPE:
 309     case RPM_I18NSTRING_TYPE:
 310         /* These are like RPM_STRING_TYPE, except they're *always* an array */
 311         /* Compute sum of length of all strings, including nul terminators */
 312
 313         if (onDisk) {
 314             while (count--) {
 315                 length++;       /* count nul terminator too */
 316                while (*s++) {
 317                     if (se && s > se)
 318                         return -1;
 319                     length++;
 320                 }
 321             }
 322         } else {
 323             const char ** av = (const char **)p;
 324             while (count--) {
 325                 /* add one for null termination */
 326                 length += strlen(*av++) + 1;
 327             }
 328         }
 329         break;
 330
 331     default:
 332         if (typeSizes[type] == -1)
 333             return -1;
 334         length = typeSizes[(type & 0xf)] * count;
 335         if (length < 0 || (se && (s + length) > se))
 336             return -1;
 337         break;
 338     }
 339
 340     return length;
 341 }
 342
 343 /** \ingroup header
 344  * Swap int32_t and int16_t arrays within header region.
 345  *
 346  * If a header region tag is in the set to be swabbed, as the data for a
 347  * a header region is located after all other tag data.
 348  *
 349  * @param entry         header entry
 350  * @param il            no. of entries
 351  * @param dl            start no. bytes of data
 352  * @param pe            header physical entry pointer (swapped)
 353  * @param dataStart     header data start
 354  * @param dataEnd       header data end
 355  * @param regionid      region offset
 356  * @return              no. bytes of data in region, -1 on error
 357  */
 358 static int regionSwab(indexEntry entry, int il, int dl,
 359                 entryInfo pe,
 360                 unsigned char * dataStart,
 361                 const unsigned char * dataEnd,
 362                 int regionid)
 363 {
 364     struct indexEntry_s ieprev;
 365
 366     memset(&ieprev, 0, sizeof(ieprev));
 367     for (; il > 0; il--, pe++) {
 368         struct indexEntry_s ie;
 369         rpmTagType type;
 370         unsigned char * t = NULL;
 371
 372         ie.info.tag = ntohl(pe->tag);
 373         ie.info.type = ntohl(pe->type);
 374         ie.info.count = ntohl(pe->count);
 375         ie.info.offset = ntohl(pe->offset);
 376
 377         if (hdrchkType(ie.info.type))
 378             return -1;
 379         if (hdrchkData(ie.info.count))
 380             return -1;
 381         if (hdrchkData(ie.info.offset))
 382             return -1;
 383         if (hdrchkAlign(ie.info.type, ie.info.offset))
 384             return -1;
 385
 386         ie.data = t = dataStart + ie.info.offset;
 387         if (dataEnd && t >= dataEnd)
 388             return -1;
 389
 390         ie.length = dataLength(ie.info.type, ie.data, ie.info.count, 1, dataEnd);
 391         if (ie.length < 0 || hdrchkData(ie.length))
 392             return -1;
 393
 394         ie.rdlen = 0;
 395
 396         if (entry) {
 397             ie.info.offset = regionid;
 398             *entry = ie;        /* structure assignment */
 399             entry++;
 400         }
 401
 402         /* Alignment */
 403         type = ie.info.type;
 404         if (typeSizes[type] > 1) {
 405             unsigned diff;
 406             diff = typeSizes[type] - (dl % typeSizes[type]);
 407             if (diff != typeSizes[type]) {
 408                 dl += diff;
 409                 if (ieprev.info.type == RPM_I18NSTRING_TYPE)
 410                     ieprev.length += diff;
 411             }
 412         }
 413
 414         /* Perform endian conversions */
 415         switch (ntohl(pe->type)) {
 416         case RPM_INT64_TYPE:
 417         {   uint64_t * it = (uint64_t *)t;
 418             for (; ie.info.count > 0; ie.info.count--, it += 1) {
 419                 if (dataEnd && ((unsigned char *)it) >= dataEnd)
 420                     return -1;
 421                 *it = htonll(*it);
 422             }
 423             t = (unsigned char *) it;
 424         }   break;
 425         case RPM_INT32_TYPE:
 426         {   int32_t * it = (int32_t *)t;
 427             for (; ie.info.count > 0; ie.info.count--, it += 1) {
 428                 if (dataEnd && ((unsigned char *)it) >= dataEnd)
 429                     return -1;
 430                 *it = htonl(*it);
 431             }
 432             t = (unsigned char *) it;
 433         }   break;
 434         case RPM_INT16_TYPE:
 435         {   int16_t * it = (int16_t *) t;
 436             for (; ie.info.count > 0; ie.info.count--, it += 1) {
 437                 if (dataEnd && ((unsigned char *)it) >= dataEnd)
 438                     return -1;
 439                 *it = htons(*it);
 440             }
 441             t = (unsigned char *) it;
 442         }   break;
 443         }
 444
 445         dl += ie.length;
 446         ieprev = ie;    /* structure assignment */
 447     }
 448
 449     return dl;
 450 }
 451
 452 /** \ingroup header
 453  * doHeaderUnload.
 454  * @param h             header
 455  * @retval *lengthPtr   no. bytes in unloaded header blob
 456  * @return              unloaded header blob (NULL on error)
 457  */
 458 static void * doHeaderUnload(Header h,
 459                 size_t * lengthPtr)
 460 {
 461     int32_t * ei = NULL;
 462     entryInfo pe;
 463     char * dataStart;
 464     char * te;
 465     unsigned pad;
 466     unsigned len;
 467     int32_t il = 0;
 468     int32_t dl = 0;
 469     indexEntry entry;
 470     rpmTagType type;
 471     int i;
 472     int drlen, ndribbles;
 473     int driplen, ndrips;
 474     int legacy = 0;
 475
 476     /* Sort entries by (offset,tag). */
 477     headerUnsort(h);
 478
 479     /* Compute (il,dl) for all tags, including those deleted in region. */
 480     pad = 0;
 481     drlen = ndribbles = driplen = ndrips = 0;
 482     for (i = 0, entry = h->index; i < h->indexUsed; i++, entry++) {
 483         if (ENTRY_IS_REGION(entry)) {
 484             int32_t rdl = -entry->info.offset;  /* negative offset */
 485             int32_t ril = rdl/sizeof(*pe);
 486             int rid = entry->info.offset;
 487
 488             il += ril;
 489             dl += entry->rdlen + entry->info.count;
 490             /* XXX Legacy regions do not include the region tag and data. */
 491             if (i == 0 && (h->flags & HEADERFLAG_LEGACY))
 492                 il += 1;
 493
 494             /* Skip rest of entries in region, but account for dribbles. */
 495             for (; i < h->indexUsed && entry->info.offset <= rid+1; i++, entry++) {
 496                 if (entry->info.offset <= rid)
 497                     continue;
 498
 499                 /* Alignment */
 500                 type = entry->info.type;
 501                 if (typeSizes[type] > 1) {
 502                     unsigned diff;
 503                     diff = typeSizes[type] - (dl % typeSizes[type]);
 504                     if (diff != typeSizes[type]) {
 505                         drlen += diff;
 506                         pad += diff;
 507                         dl += diff;
 508                     }
 509                 }
 510
 511                 ndribbles++;
 512                 il++;
 513                 drlen += entry->length;
 514                 dl += entry->length;
 515             }
 516             i--;
 517             entry--;
 518             continue;
 519         }
 520
 521         /* Ignore deleted drips. */
 522         if (entry->data == NULL || entry->length <= 0)
 523             continue;
 524
 525         /* Alignment */
 526         type = entry->info.type;
 527         if (typeSizes[type] > 1) {
 528             unsigned diff;
 529             diff = typeSizes[type] - (dl % typeSizes[type]);
 530             if (diff != typeSizes[type]) {
 531                 driplen += diff;
 532                 pad += diff;
 533                 dl += diff;
 534             } else
 535                 diff = 0;
 536         }
 537
 538         ndrips++;
 539         il++;
 540         driplen += entry->length;
 541         dl += entry->length;
 542     }
 543
 544     /* Sanity checks on header intro. */
 545     if (hdrchkTags(il) || hdrchkData(dl))
 546         goto errxit;
 547
 548     len = sizeof(il) + sizeof(dl) + (il * sizeof(*pe)) + dl;
 549
 550     ei = xmalloc(len);
 551     ei[0] = htonl(il);
 552     ei[1] = htonl(dl);
 553
 554     pe = (entryInfo) &ei[2];
 555     dataStart = te = (char *) (pe + il);
 556
 557     pad = 0;
 558     for (i = 0, entry = h->index; i < h->indexUsed; i++, entry++) {
 559         const char * src;
 560         unsigned char *t;
 561         int count;
 562         int rdlen;
 563
 564         if (entry->data == NULL || entry->length <= 0)
 565             continue;
 566
 567         t = (unsigned char*)te;
 568         pe->tag = htonl(entry->info.tag);
 569         pe->type = htonl(entry->info.type);
 570         pe->count = htonl(entry->info.count);
 571
 572         if (ENTRY_IS_REGION(entry)) {
 573             int32_t rdl = -entry->info.offset;  /* negative offset */
 574             int32_t ril = rdl/sizeof(*pe) + ndribbles;
 575             int rid = entry->info.offset;
 576
 577             src = (char *)entry->data;
 578             rdlen = entry->rdlen;
 579
 580             /* XXX Legacy regions do not include the region tag and data. */
 581             if (i == 0 && (h->flags & HEADERFLAG_LEGACY)) {
 582                 int32_t stei[4];
 583
 584                 legacy = 1;
 585                 memcpy(pe+1, src, rdl);
 586                 memcpy(te, src + rdl, rdlen);
 587                 te += rdlen;
 588
 589                 pe->offset = htonl(te - dataStart);
 590                 stei[0] = pe->tag;
 591                 stei[1] = pe->type;
 592                 stei[2] = htonl(-rdl-entry->info.count);
 593                 stei[3] = pe->count;
 594                 memcpy(te, stei, entry->info.count);
 595                 te += entry->info.count;
 596                 ril++;
 597                 rdlen += entry->info.count;
 598
 599                 count = regionSwab(NULL, ril, 0, pe, t, NULL, 0);
 600                 if (count != rdlen)
 601                     goto errxit;
 602
 603             } else {
 604
 605                 memcpy(pe+1, src + sizeof(*pe), ((ril-1) * sizeof(*pe)));
 606                 memcpy(te, src + (ril * sizeof(*pe)), rdlen+entry->info.count+drlen);
 607                 te += rdlen;
 608                 {
 609                     entryInfo se = (entryInfo)src;
 610                     int off = ntohl(se->offset);
 611                     pe->offset = (off) ? htonl(te - dataStart) : htonl(off);
 612                 }
 613                 te += entry->info.count + drlen;
 614
 615                 count = regionSwab(NULL, ril, 0, pe, t, NULL, 0);
 616                 if (count != (rdlen + entry->info.count + drlen))
 617                     goto errxit;
 618             }
 619
 620             /* Skip rest of entries in region. */
 621             while (i < h->indexUsed && entry->info.offset <= rid+1) {
 622                 i++;
 623                 entry++;
 624             }
 625             i--;
 626             entry--;
 627             pe += ril;
 628             continue;
 629         }
 630
 631         /* Ignore deleted drips. */
 632         if (entry->data == NULL || entry->length <= 0)
 633             continue;
 634
 635         /* Alignment */
 636         type = entry->info.type;
 637         if (typeSizes[type] > 1) {
 638             unsigned diff;
 639             diff = typeSizes[type] - ((te - dataStart) % typeSizes[type]);
 640             if (diff != typeSizes[type]) {
 641                 memset(te, 0, diff);
 642                 te += diff;
 643                 pad += diff;
 644             }
 645         }
 646
 647         pe->offset = htonl(te - dataStart);
 648
 649         /* copy data w/ endian conversions */
 650         switch (entry->info.type) {
 651         case RPM_INT64_TYPE:
 652             count = entry->info.count;
 653             src = entry->data;
 654             while (count--) {
 655                 *((uint64_t *)te) = htonll(*((uint64_t *)src));
 656                 te += sizeof(uint64_t);
 657                 src += sizeof(uint64_t);
 658             }
 659             break;
 660
 661         case RPM_INT32_TYPE:
 662             count = entry->info.count;
 663             src = entry->data;
 664             while (count--) {
 665                 *((int32_t *)te) = htonl(*((int32_t *)src));
 666                 te += sizeof(int32_t);
 667                 src += sizeof(int32_t);
 668             }
 669             break;
 670
 671         case RPM_INT16_TYPE:
 672             count = entry->info.count;
 673             src = entry->data;
 674             while (count--) {
 675                 *((int16_t *)te) = htons(*((int16_t *)src));
 676                 te += sizeof(int16_t);
 677                 src += sizeof(int16_t);
 678             }
 679             break;
 680
 681         default:
 682             memcpy(te, entry->data, entry->length);
 683             te += entry->length;
 684             break;
 685         }
 686         pe++;
 687     }
 688
 689     /* Insure that there are no memcpy underruns/overruns. */
 690     if (((char *)pe) != dataStart)
 691         goto errxit;
 692     if ((((char *)ei)+len) != te)
 693         goto errxit;
 694
 695     if (lengthPtr)
 696         *lengthPtr = len;
 697
 698     h->flags &= ~HEADERFLAG_SORTED;
 699     headerSort(h);
 700
 701     return (void *) ei;
 702
 703 errxit:
 704     ei = _free(ei);
 705     return (void *) ei;
 706 }
 707
 708 void * headerUnload(Header h)
 709 {
 710     size_t length;
 711     void * uh = doHeaderUnload(h, &length);
 712     return uh;
 713 }
 714
 715 /**
 716  * Find matching (tag,type) entry in header.
 717  * @param h             header
 718  * @param tag           entry tag
 719  * @param type          entry type
 720  * @return              header entry
 721  */
 722 static
 723 indexEntry findEntry(Header h, rpmTag tag, rpmTagType type)
 724 {
 725     indexEntry entry, entry2, last;
 726     struct indexEntry_s key;
 727
 728     if (h == NULL) return NULL;
 729     if (!(h->flags & HEADERFLAG_SORTED)) headerSort(h);
 730
 731     key.info.tag = tag;
 732
 733     entry2 = entry =
 734         bsearch(&key, h->index, h->indexUsed, sizeof(*h->index), indexCmp);
 735     if (entry == NULL)
 736         return NULL;
 737
 738     if (type == RPM_NULL_TYPE)
 739         return entry;
 740
 741     /* look backwards */
 742     while (entry->info.tag == tag && entry->info.type != type &&
 743            entry > h->index) entry--;
 744
 745     if (entry->info.tag == tag && entry->info.type == type)
 746         return entry;
 747
 748     last = h->index + h->indexUsed;
 749     /* FIX: entry2 = entry. Code looks bogus as well. */
 750     while (entry2->info.tag == tag && entry2->info.type != type &&
 751            entry2 < last) entry2++;
 752
 753     if (entry->info.tag == tag && entry->info.type == type)
 754         return entry;
 755
 756     return NULL;
 757 }
 758
 759 int headerDel(Header h, rpmTag tag)
 760 {
 761     indexEntry last = h->index + h->indexUsed;
 762     indexEntry entry, first;
 763     int ne;
 764
 765     entry = findEntry(h, tag, RPM_NULL_TYPE);
 766     if (!entry) return 1;
 767
 768     /* Make sure entry points to the first occurence of this tag. */
 769     while (entry > h->index && (entry - 1)->info.tag == tag)
 770         entry--;
 771
 772     /* Free data for tags being removed. */
 773     for (first = entry; first < last; first++) {
 774         rpm_data_t data;
 775         if (first->info.tag != tag)
 776             break;
 777         data = first->data;
 778         first->data = NULL;
 779         first->length = 0;
 780         if (ENTRY_IN_REGION(first))
 781             continue;
 782         data = _free(data);
 783     }
 784
 785     ne = (first - entry);
 786     if (ne > 0) {
 787         h->indexUsed -= ne;
 788         ne = last - first;
 789         if (ne > 0)
 790             memmove(entry, first, (ne * sizeof(*entry)));
 791     }
 792
 793     return 0;
 794 }
 795
 796 Header headerLoad(void * uh)
 797 {
 798     int32_t * ei = (int32_t *) uh;
 799     int32_t il = ntohl(ei[0]);          /* index length */
 800     int32_t dl = ntohl(ei[1]);          /* data length */
 801     size_t pvlen = sizeof(il) + sizeof(dl) +
 802                (il * sizeof(struct entryInfo_s)) + dl;
 803     void * pv = uh;
 804     Header h = NULL;
 805     entryInfo pe;
 806     unsigned char * dataStart;
 807     unsigned char * dataEnd;
 808     indexEntry entry;
 809     int rdlen;
 810     int i;
 811
 812     /* Sanity checks on header intro. */
 813     if (hdrchkTags(il) || hdrchkData(dl))
 814         goto errxit;
 815
 816     ei = (int32_t *) pv;
 817     pe = (entryInfo) &ei[2];
 818     dataStart = (unsigned char *) (pe + il);
 819     dataEnd = dataStart + dl;
 820
 821     h = xcalloc(1, sizeof(*h));
 822     h->blob = uh;
 823     h->indexAlloced = il + 1;
 824     h->indexUsed = il;
 825     h->instance = 0;
 826     h->index = xcalloc(h->indexAlloced, sizeof(*h->index));
 827     h->flags |= HEADERFLAG_SORTED;
 828     h->nrefs = 0;
 829     h = headerLink(h);
 830
 831     entry = h->index;
 832     i = 0;
 833     if (!(htonl(pe->tag) < HEADER_I18NTABLE)) {
 834         h->flags |= HEADERFLAG_LEGACY;
 835         entry->info.type = REGION_TAG_TYPE;
 836         entry->info.tag = HEADER_IMAGE;
 837         entry->info.count = REGION_TAG_COUNT;
 838         entry->info.offset = ((unsigned char *)pe - dataStart); /* negative offset */
 839
 840         entry->data = pe;
 841         entry->length = pvlen - sizeof(il) - sizeof(dl);
 842         rdlen = regionSwab(entry+1, il, 0, pe, dataStart, dataEnd, entry->info.offset);
 843         if (rdlen != dl)
 844             goto errxit;
 845         entry->rdlen = rdlen;
 846         entry++;
 847         h->indexUsed++;
 848     } else {
 849         int32_t rdl;
 850         int32_t ril;
 851
 852         h->flags &= ~HEADERFLAG_LEGACY;
 853
 854         entry->info.type = htonl(pe->type);
 855         entry->info.count = htonl(pe->count);
 856
 857         if (hdrchkType(entry->info.type))
 858             goto errxit;
 859         if (hdrchkTags(entry->info.count))
 860             goto errxit;
 861
 862         {   int off = ntohl(pe->offset);
 863
 864             if (hdrchkData(off))
 865                 goto errxit;
 866             if (off) {
 867                 size_t nb = REGION_TAG_COUNT;
 868                 int32_t stei[nb];
 869                 /* XXX Hmm, why the copy? */
 870                 memcpy(&stei, dataStart + off, nb);
 871                 rdl = -ntohl(stei[2]);  /* negative offset */
 872                 ril = rdl/sizeof(*pe);
 873                 if (hdrchkTags(ril) || hdrchkData(rdl))
 874                     goto errxit;
 875                 entry->info.tag = htonl(pe->tag);
 876             } else {
 877                 ril = il;
 878                 rdl = (ril * sizeof(struct entryInfo_s));
 879                 entry->info.tag = HEADER_IMAGE;
 880             }
 881         }
 882         entry->info.offset = -rdl;      /* negative offset */
 883
 884         entry->data = pe;
 885         entry->length = pvlen - sizeof(il) - sizeof(dl);
 886         rdlen = regionSwab(entry+1, ril-1, 0, pe+1, dataStart, dataEnd, entry->info.offset);
 887         if (rdlen < 0)
 888             goto errxit;
 889         entry->rdlen = rdlen;
 890
 891         if (ril < h->indexUsed) {
 892             indexEntry newEntry = entry + ril;
 893             int ne = (h->indexUsed - ril);
 894             int rid = entry->info.offset+1;
 895             int rc;
 896
 897             /* Load dribble entries from region. */
 898             rc = regionSwab(newEntry, ne, 0, pe+ril, dataStart, dataEnd, rid);
 899             if (rc < 0)
 900                 goto errxit;
 901             rdlen += rc;
 902
 903           { indexEntry firstEntry = newEntry;
 904             int save = h->indexUsed;
 905             int j;
 906
 907             /* Dribble entries replace duplicate region entries. */
 908             h->indexUsed -= ne;
 909             for (j = 0; j < ne; j++, newEntry++) {
 910                 (void) headerDel(h, newEntry->info.tag);
 911                 if (newEntry->info.tag == RPMTAG_BASENAMES)
 912                     (void) headerDel(h, RPMTAG_OLDFILENAMES);
 913             }
 914
 915             /* If any duplicate entries were replaced, move new entries down. */
 916             if (h->indexUsed < (save - ne)) {
 917                 memmove(h->index + h->indexUsed, firstEntry,
 918                         (ne * sizeof(*entry)));
 919             }
 920             h->indexUsed += ne;
 921           }
 922         }
 923     }
 924
 925     h->flags &= ~HEADERFLAG_SORTED;
 926     headerSort(h);
 927     h->flags |= HEADERFLAG_ALLOCATED;
 928
 929     return h;
 930
 931 errxit:
 932     if (h) {
 933         h->index = _free(h->index);
 934         h = _free(h);
 935     }
 936     return h;
 937 }
 938
 939 Header headerReload(Header h, rpmTag tag)
 940 {
 941     Header nh;
 942     size_t length;
 943     void * uh = doHeaderUnload(h, &length);
 944
 945     h = headerFree(h);
 946     if (uh == NULL)
 947         return NULL;
 948     nh = headerLoad(uh);
 949     if (nh == NULL) {
 950         uh = _free(uh);
 951         return NULL;
 952     }
 953     if (ENTRY_IS_REGION(nh->index)) {
 954         if (tag == HEADER_SIGNATURES || tag == HEADER_IMMUTABLE)
 955             nh->index[0].info.tag = tag;
 956     }
 957     return nh;
 958 }
 959
 960 Header headerCopyLoad(const void * uh)
 961 {
 962     int32_t * ei = (int32_t *) uh;
 963     int32_t il = ntohl(ei[0]);          /* index length */
 964     int32_t dl = ntohl(ei[1]);          /* data length */
 965     size_t pvlen = sizeof(il) + sizeof(dl) +
 966                         (il * sizeof(struct entryInfo_s)) + dl;
 967     void * nuh = NULL;
 968     Header h = NULL;
 969
 970     /* Sanity checks on header intro. */
 971     if (!(hdrchkTags(il) || hdrchkData(dl)) && pvlen < headerMaxbytes) {
 972         nuh = memcpy(xmalloc(pvlen), uh, pvlen);
 973         if ((h = headerLoad(nuh)) == NULL)
 974             nuh = _free(nuh);
 975     }
 976     return h;
 977 }
 978
 979 /** \ingroup header
 980  * Read (and load) header from file handle.
 981  * @param fd            file handle
 982  * @param magicp        read (and verify) 8 bytes of (magic, 0)?
 983  * @return              header (or NULL on error)
 984  */
 985 Header headerRead(FD_t fd, enum hMagic magicp)
 986 {
 987     int32_t block[4];
 988     int32_t reserved;
 989     int32_t * ei = NULL;
 990     int32_t il;
 991     int32_t dl;
 992     int32_t magic;
 993     Header h = NULL;
 994     size_t len;
 995     int i;
 996
 997     memset(block, 0, sizeof(block));
 998     i = 2;
 999     if (magicp == HEADER_MAGIC_YES)
1000         i += 2;
1001
1002     /* FIX: cast? */
1003     if (timedRead(fd, (char *)block, i*sizeof(*block)) != (i * sizeof(*block)))
1004         goto exit;
1005
1006     i = 0;
1007
1008     if (magicp == HEADER_MAGIC_YES) {
1009         magic = block[i++];
1010         if (memcmp(&magic, rpm_header_magic, sizeof(magic)))
1011             goto exit;
1012         reserved = block[i++];
1013     }
1014
1015     il = ntohl(block[i]);       i++;
1016     dl = ntohl(block[i]);       i++;
1017
1018     len = sizeof(il) + sizeof(dl) + (il * sizeof(struct entryInfo_s)) + dl;
1019
1020     /* Sanity checks on header intro. */
1021     if (hdrchkTags(il) || hdrchkData(dl) || len > headerMaxbytes)
1022         goto exit;
1023
1024     ei = xmalloc(len);
1025     ei[0] = htonl(il);
1026     ei[1] = htonl(dl);
1027     len -= sizeof(il) + sizeof(dl);
1028
1029     /* FIX: cast? */
1030     if (timedRead(fd, (char *)&ei[2], len) != len)
1031         goto exit;
1032
1033     h = headerLoad(ei);
1034
1035 exit:
1036     if (h == NULL && ei != NULL) {
1037         free(ei);
1038     }
1039     return h;
1040 }
1041
1042 int headerWrite(FD_t fd, Header h, enum hMagic magicp)
1043 {
1044     ssize_t nb;
1045     size_t length;
1046     void * uh;
1047
1048     if (h == NULL)
1049         return 1;
1050     uh = doHeaderUnload(h, &length);
1051     if (uh == NULL)
1052         return 1;
1053     switch (magicp) {
1054     case HEADER_MAGIC_YES:
1055         nb = Fwrite(rpm_header_magic, sizeof(uint8_t), sizeof(rpm_header_magic), fd);
1056         if (nb != sizeof(rpm_header_magic))
1057             goto exit;
1058         break;
1059     case HEADER_MAGIC_NO:
1060         break;
1061     }
1062
1063     nb = Fwrite(uh, sizeof(char), length, fd);
1064
1065 exit:
1066     uh = _free(uh);
1067     return (nb == length ? 0 : 1);
1068 }
1069
1070 int headerIsEntry(Header h, rpmTag tag)
1071 {
1072                 /* FIX: h modified by sort. */
1073     return (findEntry(h, tag, RPM_NULL_TYPE) ? 1 : 0);
1074
1075 }
1076
1077 /** \ingroup header
1078  * Retrieve data from header entry.
1079  * Relevant flags (others are ignored), if neither is set allocation
1080  * behavior depends on data type(!)
1081  *     HEADERGET_MINMEM: return pointers to header memory
1082  *     HEADERGET_ALLOC: always return malloced memory, overrides MINMEM
1083  *
1084  * @todo Permit retrieval of regions other than HEADER_IMUTABLE.
1085  * @param entry         header entry
1086  * @param td            tag data container
1087  * @param minMem        string pointers refer to header memory?
1088  * @param flags         flags to control memory allocation
1089  * @return              1 on success, otherwise error.
1090  */
1091 static int copyTdEntry(const indexEntry entry, rpmtd td, headerGetFlags flags)
1092 {
1093     rpm_count_t count = entry->info.count;
1094     int rc = 1;         /* XXX 1 on success. */
1095     /* ALLOC overrides MINMEM */
1096     int allocMem = flags & HEADERGET_ALLOC;
1097     int minMem = allocMem ? 0 : flags & HEADERGET_MINMEM;
1098     int argvArray = (flags & HEADERGET_ARGV) ? 1 : 0;
1099
1100     assert(td != NULL);
1101     td->flags = RPMTD_IMMUTABLE;
1102     switch (entry->info.type) {
1103     case RPM_BIN_TYPE:
1104         /*
1105          * XXX This only works for
1106          * XXX  "sealed" HEADER_IMMUTABLE/HEADER_SIGNATURES/HEADER_IMAGE.
1107          * XXX This will *not* work for unsealed legacy HEADER_IMAGE (i.e.
1108          * XXX a legacy header freshly read, but not yet unloaded to the rpmdb).
1109          */
1110         if (ENTRY_IS_REGION(entry)) {
1111             int32_t * ei = ((int32_t *)entry->data) - 2;
1112             entryInfo pe = (entryInfo) (ei + 2);
1113             unsigned char * dataStart = (unsigned char *) (pe + ntohl(ei[0]));
1114             int32_t rdl = -entry->info.offset;  /* negative offset */
1115             int32_t ril = rdl/sizeof(*pe);
1116
1117             rdl = entry->rdlen;
1118             count = 2 * sizeof(*ei) + (ril * sizeof(*pe)) + rdl;
1119             if (entry->info.tag == HEADER_IMAGE) {
1120                 ril -= 1;
1121                 pe += 1;
1122             } else {
1123                 count += REGION_TAG_COUNT;
1124                 rdl += REGION_TAG_COUNT;
1125             }
1126
1127             td->data = xmalloc(count);
1128             ei = (int32_t *) td->data;
1129             ei[0] = htonl(ril);
1130             ei[1] = htonl(rdl);
1131
1132             pe = (entryInfo) memcpy(ei + 2, pe, (ril * sizeof(*pe)));
1133
1134             dataStart = (unsigned char *) memcpy(pe + ril, dataStart, rdl);
1135
1136             rc = regionSwab(NULL, ril, 0, pe, dataStart, dataStart + rdl, 0);
1137             /* don't return data on failure */
1138             if (rc < 0) {
1139                 td->data = _free(td->data);
1140             }
1141             /* XXX 1 on success. */
1142             rc = (rc < 0) ? 0 : 1;
1143         } else {
1144             count = entry->length;
1145             td->data = (!minMem
1146                 ? memcpy(xmalloc(count), entry->data, count)
1147                 : entry->data);
1148         }
1149         break;
1150     case RPM_STRING_TYPE:
1151         if (count == 1) {
1152             td->data = allocMem ? xstrdup(entry->data) : entry->data;
1153             break;
1154         }
1155     case RPM_STRING_ARRAY_TYPE:
1156     case RPM_I18NSTRING_TYPE:
1157     {   const char ** ptrEntry;
1158         int tableSize = (count + argvArray) * sizeof(char *);
1159         char * t;
1160         int i;
1161
1162         if (minMem) {
1163             td->data = xmalloc(tableSize);
1164             ptrEntry = (const char **) td->data;
1165             t = entry->data;
1166         } else {
1167             t = xmalloc(tableSize + entry->length);
1168             td->data = (void *)t;
1169             ptrEntry = (const char **) td->data;
1170             t += tableSize;
1171             memcpy(t, entry->data, entry->length);
1172         }
1173         for (i = 0; i < count; i++) {
1174             *ptrEntry++ = t;
1175             t = strchr(t, 0);
1176             t++;
1177         }
1178         if (argvArray) {
1179             *ptrEntry = NULL;
1180             td->flags |= RPMTD_ARGV;
1181         }
1182     }   break;
1183     case RPM_CHAR_TYPE:
1184     case RPM_INT8_TYPE:
1185     case RPM_INT16_TYPE:
1186     case RPM_INT32_TYPE:
1187     case RPM_INT64_TYPE:
1188         if (allocMem) {
1189             td->data = xmalloc(entry->length);
1190             memcpy(td->data, entry->data, entry->length);
1191         } else {
1192             td->data = entry->data;
1193         }
1194         break;
1195     default:
1196         /* WTH? Don't mess with unknown data types... */
1197         rc = 0;
1198         td->data = NULL;
1199         break;
1200     }
1201     td->type = entry->info.type;
1202     td->count = count;
1203
1204     if (td->data && entry->data != td->data) {
1205         td->flags |= RPMTD_ALLOCED;
1206     }
1207
1208     return rc;
1209 }
1210
1211 /**
1212  * Does locale match entry in header i18n table?
1213  *
1214  * \verbatim
1215  * The range [l,le) contains the next locale to match:
1216  *    ll[_CC][.EEEEE][@dddd]
1217  * where
1218  *    ll        ISO language code (in lowercase).
1219  *    CC        (optional) ISO coutnry code (in uppercase).
1220  *    EEEEE     (optional) encoding (not really standardized).
1221  *    dddd      (optional) dialect.
1222  * \endverbatim
1223  *
1224  * @param td            header i18n table data, NUL terminated
1225  * @param l             start of locale to match
1226  * @param le            end of locale to match
1227  * @return              1 on good match, 2 on weak match, 0 on no match
1228  */
1229 static int headerMatchLocale(const char *td, const char *l, const char *le)
1230 {
1231     const char *fe;
1232
1233     /* First try a complete match. */
1234     if (strlen(td) == (le-l) && rstreqn(td, l, (le - l)))
1235         return 1;
1236
1237     /* Next, try stripping optional dialect and matching.  */
1238     for (fe = l; fe < le && *fe != '@'; fe++)
1239         {};
1240     if (fe < le && rstreqn(td, l, (fe - l)))
1241         return 1;
1242
1243     /* Next, try stripping optional codeset and matching.  */
1244     for (fe = l; fe < le && *fe != '.'; fe++)
1245         {};
1246     if (fe < le && rstreqn(td, l, (fe - l)))
1247         return 1;
1248
1249     /* Finally, try stripping optional country code and matching. */
1250     for (fe = l; fe < le && *fe != '_'; fe++)
1251         {};
1252     if (fe < le && rstreqn(td, l, (fe - l)))
1253         return 2;
1254
1255     return 0;
1256 }
1257
1258 /**
1259  * Return i18n string from header that matches locale.
1260  * @param h             header
1261  * @param entry         i18n string data
1262  * @retval td           tag data container
1263  * @param flags         flags to control allocation
1264  * @return              1 always
1265  */
1266 static int copyI18NEntry(Header h, indexEntry entry, rpmtd td,
1267                                                 headerGetFlags flags)
1268 {
1269     const char *lang, *l, *le;
1270     indexEntry table;
1271
1272     td->type = RPM_STRING_TYPE;
1273     td->count = 1;
1274     /* if no match, just return the first string */
1275     td->data = entry->data;
1276
1277     /* XXX Drepper sez' this is the order. */
1278     if ((lang = getenv("LANGUAGE")) == NULL &&
1279         (lang = getenv("LC_ALL")) == NULL &&
1280         (lang = getenv("LC_MESSAGES")) == NULL &&
1281         (lang = getenv("LANG")) == NULL)
1282             goto exit;
1283
1284     if ((table = findEntry(h, HEADER_I18NTABLE, RPM_STRING_ARRAY_TYPE)) == NULL)
1285         goto exit;
1286
1287     for (l = lang; *l != '\0'; l = le) {
1288         const char *t;
1289         char *ed, *ed_weak = NULL;
1290         int langNum;
1291
1292         while (*l && *l == ':')                 /* skip leading colons */
1293             l++;
1294         if (*l == '\0')
1295             break;
1296         for (le = l; *le && *le != ':'; le++)   /* find end of this locale */
1297             {};
1298
1299         /* For each entry in the header ... */
1300         for (langNum = 0, t = table->data, ed = entry->data;
1301              langNum < entry->info.count;
1302              langNum++, t += strlen(t) + 1, ed += strlen(ed) + 1) {
1303
1304             int match = headerMatchLocale(t, l, le);
1305             if (match == 1) {
1306                 td->data = ed;
1307                 goto exit;
1308             } else if (match == 2) {
1309                 ed_weak = ed;
1310             }
1311         }
1312         if (ed_weak) {
1313             td->data = ed_weak;
1314             goto exit;
1315         }
1316     }
1317
1318 exit:
1319     if (flags & HEADERGET_ALLOC) {
1320         td->data = xstrdup(td->data);
1321         td->flags |= RPMTD_ALLOCED;
1322     }
1323
1324     return 1;
1325 }
1326
1327 /**
1328  * Retrieve tag data from header.
1329  * @param h             header
1330  * @retval td           tag data container
1331  * @param flags         flags to control retrieval
1332  * @return              1 on success, 0 on not found
1333  */
1334 static int intGetTdEntry(Header h, rpmtd td, headerGetFlags flags)
1335 {
1336     indexEntry entry;
1337     int rc;
1338
1339     /* First find the tag */
1340     /* FIX: h modified by sort. */
1341     entry = findEntry(h, td->tag, RPM_NULL_TYPE);
1342     if (entry == NULL) {
1343         /* Td is zeroed above, just return... */
1344         return 0;
1345     }
1346
1347     if (flags & HEADERGET_RAW) {
1348         rc = copyTdEntry(entry, td, flags);
1349     } else {
1350         switch (entry->info.type) {
1351         case RPM_I18NSTRING_TYPE:
1352             rc = copyI18NEntry(h, entry, td, flags);
1353             break;
1354         default:
1355             rc = copyTdEntry(entry, td, flags);
1356             break;
1357         }
1358     }
1359
1360     /* XXX 1 on success */
1361     return ((rc == 1) ? 1 : 0);
1362 }
1363
1364 int headerGet(Header h, rpmTag tag, rpmtd td, headerGetFlags flags)
1365 {
1366     int rc;
1367     headerTagTagFunction tagfunc = intGetTdEntry;
1368
1369     if (td == NULL) return 0;
1370
1371     rpmtdReset(td);
1372     td->tag = tag;
1373
1374     if (flags & HEADERGET_EXT) {
1375         headerTagTagFunction extfunc = rpmHeaderTagFunc(tag);
1376         if (extfunc) tagfunc = extfunc;
1377     }
1378     rc = tagfunc(h, td, flags);
1379
1380     assert(tag == td->tag);
1381     return rc;
1382 }
1383
1384 /**
1385  */
1386 static void copyData(rpmTagType type, rpm_data_t dstPtr,
1387                 rpm_constdata_t srcPtr, rpm_count_t cnt, int dataLength)
1388 {
1389     switch (type) {
1390     case RPM_STRING_ARRAY_TYPE:
1391     case RPM_I18NSTRING_TYPE:
1392     {   const char ** av = (const char **) srcPtr;
1393         char * t = dstPtr;
1394
1395         while (cnt-- > 0 && dataLength > 0) {
1396             const char * s;
1397             if ((s = *av++) == NULL)
1398                 continue;
1399             do {
1400                 *t++ = *s++;
1401             } while (s[-1] && --dataLength > 0);
1402         }
1403     }   break;
1404
1405     default:
1406         memmove(dstPtr, srcPtr, dataLength);
1407         break;
1408     }
1409 }
1410
1411 /**
1412  * Return (malloc'ed) copy of entry data.
1413  * @param type          entry data type
1414  * @param p             entry data
1415  * @param c             entry item count
1416  * @retval lengthPtr    no. bytes in returned data
1417  * @return              (malloc'ed) copy of entry data, NULL on error
1418  */
1419 static void *
1420 grabData(rpmTagType type, rpm_constdata_t p, rpm_count_t c, int * lengthPtr)
1421 {
1422     rpm_data_t data = NULL;
1423     int length;
1424
1425     length = dataLength(type, p, c, 0, NULL);
1426     if (length > 0) {
1427         data = xmalloc(length);
1428         copyData(type, data, p, c, length);
1429     }
1430
1431     if (lengthPtr)
1432         *lengthPtr = length;
1433     return data;
1434 }
1435
1436 static int intAddEntry(Header h, rpmtd td)
1437 {
1438     indexEntry entry;
1439     rpm_data_t data;
1440     int length;
1441
1442     /* Count must always be >= 1 for headerAddEntry. */
1443     if (td->count <= 0)
1444         return 0;
1445
1446     if (hdrchkType(td->type))
1447         return 0;
1448     if (hdrchkData(td->count))
1449         return 0;
1450
1451     length = 0;
1452     data = grabData(td->type, td->data, td->count, &length);
1453     if (data == NULL || length <= 0)
1454         return 0;
1455
1456     /* Allocate more index space if necessary */
1457     if (h->indexUsed == h->indexAlloced) {
1458         h->indexAlloced += INDEX_MALLOC_SIZE;
1459         h->index = xrealloc(h->index, h->indexAlloced * sizeof(*h->index));
1460     }
1461
1462     /* Fill in the index */
1463     entry = h->index + h->indexUsed;
1464     entry->info.tag = td->tag;
1465     entry->info.type = td->type;
1466     entry->info.count = td->count;
1467     entry->info.offset = 0;
1468     entry->data = data;
1469     entry->length = length;
1470
1471     if (h->indexUsed > 0 && td->tag < h->index[h->indexUsed-1].info.tag)
1472         h->flags &= ~HEADERFLAG_SORTED;
1473     h->indexUsed++;
1474
1475     return 1;
1476 }
1477
1478 static int intAppendEntry(Header h, rpmtd td)
1479 {
1480     indexEntry entry;
1481     int length;
1482
1483     if (td->type == RPM_STRING_TYPE || td->type == RPM_I18NSTRING_TYPE) {
1484         /* we can't do this */
1485         return 0;
1486     }
1487
1488     /* Find the tag entry in the header. */
1489     entry = findEntry(h, td->tag, td->type);
1490     if (!entry)
1491         return 0;
1492
1493     length = dataLength(td->type, td->data, td->count, 0, NULL);
1494     if (length < 0)
1495         return 0;
1496
1497     if (ENTRY_IN_REGION(entry)) {
1498         char * t = xmalloc(entry->length + length);
1499         memcpy(t, entry->data, entry->length);
1500         entry->data = t;
1501         entry->info.offset = 0;
1502     } else
1503         entry->data = xrealloc(entry->data, entry->length + length);
1504
1505     copyData(td->type, ((char *) entry->data) + entry->length,
1506              td->data, td->count, length);
1507
1508     entry->length += length;
1509
1510     entry->info.count += td->count;
1511
1512     return 1;
1513 }
1514
1515 int headerPut(Header h, rpmtd td, headerPutFlags flags)
1516 {
1517     int rc;
1518
1519     assert(td != NULL);
1520     if (flags & HEADERPUT_APPEND) {
1521         rc = findEntry(h, td->tag, td->type) ?
1522                 intAppendEntry(h, td) :
1523                 intAddEntry(h, td);
1524     } else {
1525         rc = intAddEntry(h, td);
1526     }
1527     return rc;
1528 }
1529
1530 /*
1531  * Sanity check data types against tag table before putting. Assume
1532  * append on all array-types.
1533  */
1534 static int headerPutType(Header h, rpmTag tag, rpmTagType reqtype,
1535                         rpm_constdata_t data, rpm_count_t size)
1536 {
1537     struct rpmtd_s td;
1538     rpmTagType type = rpmTagGetType(tag);
1539     headerPutFlags flags = HEADERPUT_APPEND;
1540     int valid = 1;
1541
1542     /* Basic sanity checks: type must match and there must be data to put */
1543     if ((type & RPM_MASK_TYPE) != reqtype
1544         || size < 1 || data == NULL || h == NULL) {
1545         valid = 0;
1546     }
1547
1548     /*
1549      * Non-array types can't be appended to. Binary types use size
1550      * for data length, for other non-array types size must be 1.
1551      */
1552     if ((type & RPM_MASK_RETURN_TYPE) != RPM_ARRAY_RETURN_TYPE) {
1553         flags = HEADERPUT_DEFAULT;
1554         if ((type & RPM_MASK_TYPE) != RPM_BIN_TYPE && size != 1) {
1555             valid = 0;
1556         }
1557     }
1558
1559     if (valid) {
1560         rpmtdReset(&td);
1561         td.tag = tag;
1562         td.type = type & RPM_MASK_TYPE;
1563         td.data = (void *) data;
1564         td.count = size;
1565
1566         valid = headerPut(h, &td, flags);
1567     }
1568
1569     return valid;
1570 }
1571
1572 int headerPutString(Header h, rpmTag tag, const char *val)
1573 {
1574     rpmTagType type = rpmTagGetType(tag) & RPM_MASK_TYPE;
1575     const void *sptr = NULL;
1576
1577     /* string arrays expect char **, arrange that */
1578     if (type == RPM_STRING_ARRAY_TYPE || type == RPM_I18NSTRING_TYPE) {
1579         sptr = &val;
1580     } else if (type == RPM_STRING_TYPE) {
1581         sptr = val;
1582     } else {
1583         return 0;
1584     }
1585
1586     return headerPutType(h, tag, type, sptr, 1);
1587 }
1588
1589 int headerPutStringArray(Header h, rpmTag tag, const char **array, rpm_count_t size)
1590 {
1591     return headerPutType(h, tag, RPM_STRING_ARRAY_TYPE, array, size);
1592 }
1593
1594 int headerPutChar(Header h, rpmTag tag, char *val, rpm_count_t size)
1595 {
1596     return headerPutType(h, tag, RPM_CHAR_TYPE, val, size);
1597 }
1598
1599 int headerPutUint8(Header h, rpmTag tag, uint8_t *val, rpm_count_t size)
1600 {
1601     return headerPutType(h, tag, RPM_INT8_TYPE, val, size);
1602 }
1603
1604 int headerPutUint16(Header h, rpmTag tag, uint16_t *val, rpm_count_t size)
1605 {
1606     return headerPutType(h, tag, RPM_INT16_TYPE, val, size);
1607 }
1608
1609 int headerPutUint32(Header h, rpmTag tag, uint32_t *val, rpm_count_t size)
1610 {
1611     return headerPutType(h, tag, RPM_INT32_TYPE, val, size);
1612 }
1613
1614 int headerPutUint64(Header h, rpmTag tag, uint64_t *val, rpm_count_t size)
1615 {
1616     return headerPutType(h, tag, RPM_INT64_TYPE, val, size);
1617 }
1618
1619 int headerPutBin(Header h, rpmTag tag, uint8_t *val, rpm_count_t size)
1620 {
1621     return headerPutType(h, tag, RPM_BIN_TYPE, val, size);
1622 }
1623
1624 int headerAddI18NString(Header h, rpmTag tag, const char * string,
1625                 const char * lang)
1626 {
1627     indexEntry table, entry;
1628     const char ** strArray;
1629     int length;
1630     int ghosts;
1631     rpm_count_t i, langNum;
1632     char * buf;
1633
1634     table = findEntry(h, HEADER_I18NTABLE, RPM_STRING_ARRAY_TYPE);
1635     entry = findEntry(h, tag, RPM_I18NSTRING_TYPE);
1636
1637     if (!table && entry)
1638         return 0;               /* this shouldn't ever happen!! */
1639
1640     if (!table && !entry) {
1641         const char * charArray[2];
1642         rpm_count_t count = 0;
1643         struct rpmtd_s td;
1644         if (!lang || (lang[0] == 'C' && lang[1] == '\0')) {
1645             charArray[count++] = "C";
1646         } else {
1647             charArray[count++] = "C";
1648             charArray[count++] = lang;
1649         }
1650
1651         rpmtdReset(&td);
1652         td.tag = HEADER_I18NTABLE;
1653         td.type = RPM_STRING_ARRAY_TYPE;
1654         td.data = (void *) charArray;
1655         td.count = count;
1656         if (!headerPut(h, &td, HEADERPUT_DEFAULT))
1657             return 0;
1658         table = findEntry(h, HEADER_I18NTABLE, RPM_STRING_ARRAY_TYPE);
1659     }
1660
1661     if (!table)
1662         return 0;
1663     if (!lang) lang = "C";
1664
1665     {   const char * l = table->data;
1666         for (langNum = 0; langNum < table->info.count; langNum++) {
1667             if (rstreq(l, lang)) break;
1668             l += strlen(l) + 1;
1669         }
1670     }
1671
1672     if (langNum >= table->info.count) {
1673         length = strlen(lang) + 1;
1674         if (ENTRY_IN_REGION(table)) {
1675             char * t = xmalloc(table->length + length);
1676             memcpy(t, table->data, table->length);
1677             table->data = t;
1678             table->info.offset = 0;
1679         } else
1680             table->data = xrealloc(table->data, table->length + length);
1681         memmove(((char *)table->data) + table->length, lang, length);
1682         table->length += length;
1683         table->info.count++;
1684     }
1685
1686     if (!entry) {
1687         int rc;
1688         struct rpmtd_s td;
1689         strArray = xmalloc(sizeof(*strArray) * (langNum + 1));
1690         for (i = 0; i < langNum; i++)
1691             strArray[i] = "";
1692         strArray[langNum] = string;
1693
1694         rpmtdReset(&td);
1695         td.tag = tag;
1696         td.type = RPM_I18NSTRING_TYPE;
1697         td.data = strArray;
1698         td.count = langNum + 1;
1699         rc = headerPut(h, &td, HEADERPUT_DEFAULT);
1700         free(strArray);
1701         return rc;
1702     } else if (langNum >= entry->info.count) {
1703         ghosts = langNum - entry->info.count;
1704
1705         length = strlen(string) + 1 + ghosts;
1706         if (ENTRY_IN_REGION(entry)) {
1707             char * t = xmalloc(entry->length + length);
1708             memcpy(t, entry->data, entry->length);
1709             entry->data = t;
1710             entry->info.offset = 0;
1711         } else
1712             entry->data = xrealloc(entry->data, entry->length + length);
1713
1714         memset(((char *)entry->data) + entry->length, '\0', ghosts);
1715         memmove(((char *)entry->data) + entry->length + ghosts, string, strlen(string)+1);
1716
1717         entry->length += length;
1718         entry->info.count = langNum + 1;
1719     } else {
1720         char *b, *be, *e, *ee, *t;
1721         size_t bn, sn, en;
1722
1723         /* Set beginning/end pointers to previous data */
1724         b = be = e = ee = entry->data;
1725         for (i = 0; i < table->info.count; i++) {
1726             if (i == langNum)
1727                 be = ee;
1728             ee += strlen(ee) + 1;
1729             if (i == langNum)
1730                 e  = ee;
1731         }
1732
1733         /* Get storage for new buffer */
1734         bn = (be-b);
1735         sn = strlen(string) + 1;
1736         en = (ee-e);
1737         length = bn + sn + en;
1738         t = buf = xmalloc(length);
1739
1740         /* Copy values into new storage */
1741         memcpy(t, b, bn);
1742         t += bn;
1743         memcpy(t, string, sn);
1744         t += sn;
1745         memcpy(t, e, en);
1746         t += en;
1747
1748         /* Replace i18N string array */
1749         entry->length -= strlen(be) + 1;
1750         entry->length += sn;
1751
1752         if (ENTRY_IN_REGION(entry)) {
1753             entry->info.offset = 0;
1754         } else
1755             entry->data = _free(entry->data);
1756         entry->data = buf;
1757     }
1758
1759     return 0;
1760 }
1761
1762 int headerMod(Header h, rpmtd td)
1763 {
1764     indexEntry entry;
1765     rpm_data_t oldData;
1766     rpm_data_t data;
1767     int length;
1768
1769     /* First find the tag */
1770     entry = findEntry(h, td->tag, td->type);
1771     if (!entry)
1772         return 0;
1773
1774     length = 0;
1775     data = grabData(td->type, td->data, td->count, &length);
1776     if (data == NULL || length <= 0)
1777         return 0;
1778
1779     /* make sure entry points to the first occurence of this tag */
1780     while (entry > h->index && (entry - 1)->info.tag == td->tag)
1781         entry--;
1782
1783     /* free after we've grabbed the new data in case the two are intertwined;
1784        that's a bad idea but at least we won't break */
1785     oldData = entry->data;
1786
1787     entry->info.count = td->count;
1788     entry->info.type = td->type;
1789     entry->data = data;
1790     entry->length = length;
1791
1792     if (ENTRY_IN_REGION(entry)) {
1793         entry->info.offset = 0;
1794     } else
1795         oldData = _free(oldData);
1796
1797     return 1;
1798 }
1799
1800 /**
1801  * Header tag iterator data structure.
1802  */
1803 struct headerIterator_s {
1804     Header h;           /*!< Header being iterated. */
1805     int next_index;     /*!< Next tag index. */
1806 };
1807
1808 HeaderIterator headerFreeIterator(HeaderIterator hi)
1809 {
1810     if (hi != NULL) {
1811         hi->h = headerFree(hi->h);
1812         hi = _free(hi);
1813     }
1814     return hi;
1815 }
1816
1817 HeaderIterator headerInitIterator(Header h)
1818 {
1819     HeaderIterator hi = xmalloc(sizeof(*hi));
1820
1821     headerSort(h);
1822
1823     hi->h = headerLink(h);
1824     hi->next_index = 0;
1825     return hi;
1826 }
1827
1828 int headerNext(HeaderIterator hi, rpmtd td)
1829 {
1830     Header h = hi->h;
1831     int slot = hi->next_index;
1832     indexEntry entry = NULL;
1833     int rc;
1834
1835     assert(td != NULL);
1836     rpmtdReset(td);
1837
1838     for (slot = hi->next_index; slot < h->indexUsed; slot++) {
1839         entry = h->index + slot;
1840         if (!ENTRY_IS_REGION(entry))
1841             break;
1842     }
1843     hi->next_index = slot;
1844     if (entry == NULL || slot >= h->indexUsed)
1845         return 0;
1846
1847     hi->next_index++;
1848
1849     td->tag = entry->info.tag;
1850
1851     rc = copyTdEntry(entry, td, HEADERGET_DEFAULT);
1852
1853     /* XXX 1 on success */
1854     return ((rc == 1) ? 1 : 0);
1855 }
1856
1857 /** \ingroup header
1858  * Duplicate a header.
1859  * @param h             header
1860  * @return              new header instance
1861  */
1862 Header headerCopy(Header h)
1863 {
1864     Header nh = headerNew();
1865     HeaderIterator hi;
1866     struct rpmtd_s td;
1867
1868     hi = headerInitIterator(h);
1869     while (headerNext(hi, &td)) {
1870         if (rpmtdCount(&td) > 0) {
1871             (void) headerPut(nh, &td, HEADERPUT_DEFAULT);
1872         }
1873         rpmtdFreeData(&td);
1874     }
1875     hi = headerFreeIterator(hi);
1876
1877     return headerReload(nh, HEADER_IMAGE);
1878 }
1879
1880 void headerCopyTags(Header headerFrom, Header headerTo,
1881                     const rpmTag * tagstocopy)
1882 {
1883     const rpmTag * p;
1884     struct rpmtd_s td;
1885
1886     if (headerFrom == headerTo)
1887         return;
1888
1889     for (p = tagstocopy; *p != 0; p++) {
1890         if (headerIsEntry(headerTo, *p))
1891             continue;
1892         if (!headerGet(headerFrom, *p, &td, HEADERGET_MINMEM))
1893             continue;
1894         (void) headerPut(headerTo, &td, HEADERPUT_DEFAULT);
1895         rpmtdFreeData(&td);
1896     }
1897 }
1898
1899 unsigned int headerGetInstance(Header h)
1900 {
1901     return h ? h->instance : 0;
1902 }
1903
1904 void headerSetInstance(Header h, unsigned int instance)
1905 {
1906     h->instance = instance;
1907 }