/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/diff-delta.c

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-07-20 08:56:45 UTC
  • mfrom: (4526.9.23 apply-inventory-delta)
  • Revision ID: pqm@pqm.ubuntu.com-20090720085645-54mtgybxua0yx6hw
(robertc) Add checks for inventory deltas which try to ensure that
        deltas that are not an exact fit are not applied. (Robert
        Collins, bug 397705, bug 367633)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff-delta.c
688
688
    const unsigned char *data, *buffer, *top;
689
689
    unsigned char cmd;
690
690
    struct delta_index *new_index;
691
 
    struct index_entry *entry, *entries;
 
691
    struct index_entry *entry, *entries, *old_entry;
692
692
 
693
693
    if (!src->buf || !src->size)
694
694
        return NULL;
713
713
    prev_val = ~0;
714
714
    data = buffer;
715
715
    /* target size */
716
 
    /* get_delta_hdr_size doesn't mutate the content, just moves the
717
 
     * start-of-data pointer, so it is safe to do the cast.
718
 
     */
719
 
    get_delta_hdr_size((unsigned char**)&data, top);
 
716
    get_delta_hdr_size(&data, top);
720
717
    entry = entries; /* start at the first slot */
721
718
    num_entries = 0; /* calculate the real number of entries */
722
719
    while (data < top) {
789
786
    entry = entries;
790
787
    num_inserted = 0;
791
788
    for (; num_entries > 0; --num_entries, ++entry) {
792
 
        struct index_entry *next_bucket_entry, *cur_entry, *bucket_first_entry;
793
789
        hash_offset = (entry->val & old_index->hash_mask);
794
790
        /* The basic structure is a hash => packed_entries that fit in that
795
791
         * hash bucket. Things are structured such that the hash-pointers are
798
794
         * forward. If there are no NULL targets, then we know because
799
795
         * entry->ptr will not be NULL.
800
796
         */
801
 
        // The start of the next bucket, this may point past the end of the
802
 
        // entry table if hash_offset is the last bucket.
803
 
        next_bucket_entry = old_index->hash[hash_offset + 1];
804
 
        // First entry in this bucket
805
 
        bucket_first_entry = old_index->hash[hash_offset];
806
 
        cur_entry = next_bucket_entry - 1;
807
 
        while (cur_entry->ptr == NULL && cur_entry >= bucket_first_entry) {
808
 
            cur_entry--;
 
797
        old_entry = old_index->hash[hash_offset + 1];
 
798
        old_entry--;
 
799
        while (old_entry->ptr == NULL
 
800
               && old_entry >= old_index->hash[hash_offset]) {
 
801
            old_entry--;
809
802
        }
810
 
        // cur_entry now either points at the first NULL, or it points to
811
 
        // next_bucket_entry if there were no blank spots.
812
 
        cur_entry++;
813
 
        if (cur_entry >= next_bucket_entry || cur_entry->ptr != NULL) {
 
803
        old_entry++;
 
804
        if (old_entry->ptr != NULL
 
805
            || old_entry >= old_index->hash[hash_offset + 1]) {
814
806
            /* There is no room for this entry, we have to resize */
815
807
            // char buff[128];
816
808
            // get_text(buff, entry->ptr);
827
819
            break;
828
820
        }
829
821
        num_inserted++;
830
 
        *cur_entry = *entry;
 
822
        *old_entry = *entry;
831
823
        /* For entries which we *do* manage to insert into old_index, we don't
832
824
         * want them double copied into the final output.
833
825
         */