Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2fffcb17 authored by Sen Jiang's avatar Sen Jiang
Browse files

applypatch: Use bsdiff from external/bsdiff. 

external/bsdiff uses divsufsort which is much faster, and also include
some bug fixes.

Bug: 26982501
Test: ./imgdiff_test.sh

Change-Id: I089a301c291ee55d79938c7a3ca6d509895440d1
parent ecd6e2af

applypatch/Android.mk

+7 −2
Original line number Diff line number Diff line
@@ -89,8 +89,13 @@ include $(BUILD_EXECUTABLE) 
# ===============================

include $(CLEAR_VARS)

LOCAL_CLANG := true

LOCAL_SRC_FILES := imgdiff.cpp utils.cpp bsdiff.cpp

LOCAL_SRC_FILES := imgdiff.cpp utils.cpp

LOCAL_MODULE := imgdiff

LOCAL_STATIC_LIBRARIES += libz libbz

LOCAL_STATIC_LIBRARIES += \

    libbsdiff \

    libbz \

    libdivsufsort64 \

    libdivsufsort \

    libz

LOCAL_FORCE_STATIC_EXECUTABLE := true

include $(BUILD_HOST_EXECUTABLE)

applypatch/bsdiff.cpp

deleted100644 → 0
+0 −409
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2009 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



/*

 * Most of this code comes from bsdiff.c from the bsdiff-4.3

 * distribution, which is:

 */



/*-

 * Copyright 2003-2005 Colin Percival

 * All rights reserved

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted providing that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */



#include <sys/types.h>



#include <bzlib.h>

#include <err.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>



#define MIN(x,y) (((x)<(y)) ? (x) : (y))



static void split(off_t *I,off_t *V,off_t start,off_t len,off_t h)

{

	off_t i,j,k,x,tmp,jj,kk;



	if(len<16) {

		for(k=start;k<start+len;k+=j) {

			j=1;x=V[I[k]+h];

			for(i=1;k+i<start+len;i++) {

				if(V[I[k+i]+h]<x) {

					x=V[I[k+i]+h];

					j=0;

				};

				if(V[I[k+i]+h]==x) {

					tmp=I[k+j];I[k+j]=I[k+i];I[k+i]=tmp;

					j++;

				};

			};

			for(i=0;i<j;i++) V[I[k+i]]=k+j-1;

			if(j==1) I[k]=-1;

		};

		return;

	};



	x=V[I[start+len/2]+h];

	jj=0;kk=0;

	for(i=start;i<start+len;i++) {

		if(V[I[i]+h]<x) jj++;

		if(V[I[i]+h]==x) kk++;

	};

	jj+=start;kk+=jj;



	i=start;j=0;k=0;

	while(i<jj) {

		if(V[I[i]+h]<x) {

			i++;

		} else if(V[I[i]+h]==x) {

			tmp=I[i];I[i]=I[jj+j];I[jj+j]=tmp;

			j++;

		} else {

			tmp=I[i];I[i]=I[kk+k];I[kk+k]=tmp;

			k++;

		};

	};



	while(jj+j<kk) {

		if(V[I[jj+j]+h]==x) {

			j++;

		} else {

			tmp=I[jj+j];I[jj+j]=I[kk+k];I[kk+k]=tmp;

			k++;

		};

	};



	if(jj>start) split(I,V,start,jj-start,h);



	for(i=0;i<kk-jj;i++) V[I[jj+i]]=kk-1;

	if(jj==kk-1) I[jj]=-1;



	if(start+len>kk) split(I,V,kk,start+len-kk,h);

}



static void qsufsort(off_t *I,off_t *V,u_char *old,off_t oldsize)

{

	off_t buckets[256];

	off_t i,h,len;



	for(i=0;i<256;i++) buckets[i]=0;

	for(i=0;i<oldsize;i++) buckets[old[i]]++;

	for(i=1;i<256;i++) buckets[i]+=buckets[i-1];

	for(i=255;i>0;i--) buckets[i]=buckets[i-1];

	buckets[0]=0;



	for(i=0;i<oldsize;i++) I[++buckets[old[i]]]=i;

	I[0]=oldsize;

	for(i=0;i<oldsize;i++) V[i]=buckets[old[i]];

	V[oldsize]=0;

	for(i=1;i<256;i++) if(buckets[i]==buckets[i-1]+1) I[buckets[i]]=-1;

	I[0]=-1;



	for(h=1;I[0]!=-(oldsize+1);h+=h) {

		len=0;

		for(i=0;i<oldsize+1;) {

			if(I[i]<0) {

				len-=I[i];

				i-=I[i];

			} else {

				if(len) I[i-len]=-len;

				len=V[I[i]]+1-i;

				split(I,V,i,len,h);

				i+=len;

				len=0;

			};

		};

		if(len) I[i-len]=-len;

	};



	for(i=0;i<oldsize+1;i++) I[V[i]]=i;

}



static off_t matchlen(u_char *olddata,off_t oldsize,u_char *newdata,off_t newsize)

{

	off_t i;



	for(i=0;(i<oldsize)&&(i<newsize);i++)

		if(olddata[i]!=newdata[i]) break;



	return i;

}



static off_t search(off_t *I,u_char *old,off_t oldsize,

		u_char *newdata,off_t newsize,off_t st,off_t en,off_t *pos)

{

	off_t x,y;



	if(en-st<2) {

		x=matchlen(old+I[st],oldsize-I[st],newdata,newsize);

		y=matchlen(old+I[en],oldsize-I[en],newdata,newsize);



		if(x>y) {

			*pos=I[st];

			return x;

		} else {

			*pos=I[en];

			return y;

		}

	};



	x=st+(en-st)/2;

	if(memcmp(old+I[x],newdata,MIN(oldsize-I[x],newsize))<0) {

		return search(I,old,oldsize,newdata,newsize,x,en,pos);

	} else {

		return search(I,old,oldsize,newdata,newsize,st,x,pos);

	};

}



static void offtout(off_t x,u_char *buf)

{

	off_t y;



	if(x<0) y=-x; else y=x;



		buf[0]=y%256;y-=buf[0];

	y=y/256;buf[1]=y%256;y-=buf[1];

	y=y/256;buf[2]=y%256;y-=buf[2];

	y=y/256;buf[3]=y%256;y-=buf[3];

	y=y/256;buf[4]=y%256;y-=buf[4];

	y=y/256;buf[5]=y%256;y-=buf[5];

	y=y/256;buf[6]=y%256;y-=buf[6];

	y=y/256;buf[7]=y%256;



	if(x<0) buf[7]|=0x80;

}



// This is main() from bsdiff.c, with the following changes:

//

//    - old, oldsize, newdata, newsize are arguments; we don't load this

//      data from files.  old and newdata are owned by the caller; we

//      don't free them at the end.

//

//    - the "I" block of memory is owned by the caller, who passes a

//      pointer to *I, which can be NULL.  This way if we call

//      bsdiff() multiple times with the same 'old' data, we only do

//      the qsufsort() step the first time.

//

int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* newdata, off_t newsize,

           const char* patch_filename)

{

	off_t *I;

	off_t scan,pos,len;

	off_t lastscan,lastpos,lastoffset;

	off_t oldscore,scsc;

	off_t s,Sf,lenf,Sb,lenb;

	off_t overlap,Ss,lens;

	off_t i;

	off_t dblen,eblen;

	u_char *db,*eb;

	u_char buf[8];

	u_char header[32];

	FILE * pf;

	BZFILE * pfbz2;

	int bz2err;



        if (*IP == NULL) {

            off_t* V;

            *IP = reinterpret_cast<off_t*>(malloc((oldsize+1) * sizeof(off_t)));

            V = reinterpret_cast<off_t*>(malloc((oldsize+1) * sizeof(off_t)));

            qsufsort(*IP, V, old, oldsize);

            free(V);

        }

        I = *IP;



	if(((db=reinterpret_cast<u_char*>(malloc(newsize+1)))==NULL) ||

		((eb=reinterpret_cast<u_char*>(malloc(newsize+1)))==NULL)) err(1,NULL);

	dblen=0;

	eblen=0;



	/* Create the patch file */

	if ((pf = fopen(patch_filename, "w")) == NULL)

              err(1, "%s", patch_filename);



	/* Header is

		0	8	 "BSDIFF40"

		8	8	length of bzip2ed ctrl block

		16	8	length of bzip2ed diff block

		24	8	length of new file */

	/* File is

		0	32	Header

		32	??	Bzip2ed ctrl block

		??	??	Bzip2ed diff block

		??	??	Bzip2ed extra block */

	memcpy(header,"BSDIFF40",8);

	offtout(0, header + 8);

	offtout(0, header + 16);

	offtout(newsize, header + 24);

	if (fwrite(header, 32, 1, pf) != 1)

		err(1, "fwrite(%s)", patch_filename);



	/* Compute the differences, writing ctrl as we go */

	if ((pfbz2 = BZ2_bzWriteOpen(&bz2err, pf, 9, 0, 0)) == NULL)

		errx(1, "BZ2_bzWriteOpen, bz2err = %d", bz2err);

	scan=0;len=0;

	lastscan=0;lastpos=0;lastoffset=0;

	while(scan<newsize) {

		oldscore=0;



		for(scsc=scan+=len;scan<newsize;scan++) {

			len=search(I,old,oldsize,newdata+scan,newsize-scan,

					0,oldsize,&pos);



			for(;scsc<scan+len;scsc++)

			if((scsc+lastoffset<oldsize) &&

				(old[scsc+lastoffset] == newdata[scsc]))

				oldscore++;



			if(((len==oldscore) && (len!=0)) ||

				(len>oldscore+8)) break;



			if((scan+lastoffset<oldsize) &&

				(old[scan+lastoffset] == newdata[scan]))

				oldscore--;

		};



		if((len!=oldscore) || (scan==newsize)) {

			s=0;Sf=0;lenf=0;

			for(i=0;(lastscan+i<scan)&&(lastpos+i<oldsize);) {

				if(old[lastpos+i]==newdata[lastscan+i]) s++;

				i++;

				if(s*2-i>Sf*2-lenf) { Sf=s; lenf=i; };

			};



			lenb=0;

			if(scan<newsize) {

				s=0;Sb=0;

				for(i=1;(scan>=lastscan+i)&&(pos>=i);i++) {

					if(old[pos-i]==newdata[scan-i]) s++;

					if(s*2-i>Sb*2-lenb) { Sb=s; lenb=i; };

				};

			};



			if(lastscan+lenf>scan-lenb) {

				overlap=(lastscan+lenf)-(scan-lenb);

				s=0;Ss=0;lens=0;

				for(i=0;i<overlap;i++) {

					if(newdata[lastscan+lenf-overlap+i]==

					   old[lastpos+lenf-overlap+i]) s++;

					if(newdata[scan-lenb+i]==

					   old[pos-lenb+i]) s--;

					if(s>Ss) { Ss=s; lens=i+1; };

				};



				lenf+=lens-overlap;

				lenb-=lens;

			};



			for(i=0;i<lenf;i++)

				db[dblen+i]=newdata[lastscan+i]-old[lastpos+i];

			for(i=0;i<(scan-lenb)-(lastscan+lenf);i++)

				eb[eblen+i]=newdata[lastscan+lenf+i];



			dblen+=lenf;

			eblen+=(scan-lenb)-(lastscan+lenf);



			offtout(lenf,buf);

			BZ2_bzWrite(&bz2err, pfbz2, buf, 8);

			if (bz2err != BZ_OK)

				errx(1, "BZ2_bzWrite, bz2err = %d", bz2err);



			offtout((scan-lenb)-(lastscan+lenf),buf);

			BZ2_bzWrite(&bz2err, pfbz2, buf, 8);

			if (bz2err != BZ_OK)

				errx(1, "BZ2_bzWrite, bz2err = %d", bz2err);



			offtout((pos-lenb)-(lastpos+lenf),buf);

			BZ2_bzWrite(&bz2err, pfbz2, buf, 8);

			if (bz2err != BZ_OK)

				errx(1, "BZ2_bzWrite, bz2err = %d", bz2err);



			lastscan=scan-lenb;

			lastpos=pos-lenb;

			lastoffset=pos-scan;

		};

	};

	BZ2_bzWriteClose(&bz2err, pfbz2, 0, NULL, NULL);

	if (bz2err != BZ_OK)

		errx(1, "BZ2_bzWriteClose, bz2err = %d", bz2err);



	/* Compute size of compressed ctrl data */

	if ((len = ftello(pf)) == -1)

		err(1, "ftello");

	offtout(len-32, header + 8);



	/* Write compressed diff data */

	if ((pfbz2 = BZ2_bzWriteOpen(&bz2err, pf, 9, 0, 0)) == NULL)

		errx(1, "BZ2_bzWriteOpen, bz2err = %d", bz2err);

	BZ2_bzWrite(&bz2err, pfbz2, db, dblen);

	if (bz2err != BZ_OK)

		errx(1, "BZ2_bzWrite, bz2err = %d", bz2err);

	BZ2_bzWriteClose(&bz2err, pfbz2, 0, NULL, NULL);

	if (bz2err != BZ_OK)

		errx(1, "BZ2_bzWriteClose, bz2err = %d", bz2err);



	/* Compute size of compressed diff data */

	if ((newsize = ftello(pf)) == -1)

		err(1, "ftello");

	offtout(newsize - len, header + 16);



	/* Write compressed extra data */

	if ((pfbz2 = BZ2_bzWriteOpen(&bz2err, pf, 9, 0, 0)) == NULL)

		errx(1, "BZ2_bzWriteOpen, bz2err = %d", bz2err);

	BZ2_bzWrite(&bz2err, pfbz2, eb, eblen);

	if (bz2err != BZ_OK)

		errx(1, "BZ2_bzWrite, bz2err = %d", bz2err);

	BZ2_bzWriteClose(&bz2err, pfbz2, 0, NULL, NULL);

	if (bz2err != BZ_OK)

		errx(1, "BZ2_bzWriteClose, bz2err = %d", bz2err);



	/* Seek to the beginning, write the header, and close the file */

	if (fseeko(pf, 0, SEEK_SET))

		err(1, "fseeko");

	if (fwrite(header, 32, 1, pf) != 1)

		err(1, "fwrite(%s)", patch_filename);

	if (fclose(pf))

		err(1, "fclose");



	/* Free the memory we used */

	free(db);

	free(eb);



	return 0;

}

applypatch/imgdiff.cpp

+3 −14
Original line number Diff line number Diff line
@@ -130,6 +130,8 @@ 
#include <unistd.h>

#include <sys/types.h>



#include <bsdiff.h>



#include "zlib.h"

#include "imgdiff.h"

#include "utils.h"
@@ -144,8 +146,6 @@ typedef struct { 
  size_t source_start;

  size_t source_len;



  off_t* I;             // used by bsdiff



  // --- for CHUNK_DEFLATE chunks only: ---



  // original (compressed) deflate data
@@ -179,10 +179,6 @@ static int fileentry_compare(const void* a, const void* b) { 
  }

}



// from bsdiff.c

int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* newdata, off_t newsize,

           const char* patch_filename);



unsigned char* ReadZip(const char* filename,

                       int* num_chunks, ImageChunk** chunks,

                       int include_pseudo_chunk) {
@@ -296,7 +292,6 @@ unsigned char* ReadZip(const char* filename, 
    curr->len = st.st_size;

    curr->data = img;

    curr->filename = NULL;

    curr->I = NULL;

    ++curr;

    ++*num_chunks;

  }
@@ -311,7 +306,6 @@ unsigned char* ReadZip(const char* filename, 
      curr->deflate_len = temp_entries[nextentry].deflate_len;

      curr->deflate_data = img + pos;

      curr->filename = temp_entries[nextentry].filename;

      curr->I = NULL;



      curr->len = temp_entries[nextentry].uncomp_len;

      curr->data = reinterpret_cast<unsigned char*>(malloc(curr->len));
@@ -356,7 +350,6 @@ unsigned char* ReadZip(const char* filename, 
    }

    curr->data = img + pos;

    curr->filename = NULL;

    curr->I = NULL;

    pos += curr->len;



    ++*num_chunks;
@@ -424,7 +417,6 @@ unsigned char* ReadImage(const char* filename, 
      curr->type = CHUNK_NORMAL;

      curr->len = GZIP_HEADER_LEN;

      curr->data = p;

      curr->I = NULL;



      pos += curr->len;

      p += curr->len;
@@ -432,7 +424,6 @@ unsigned char* ReadImage(const char* filename, 


      curr->type = CHUNK_DEFLATE;

      curr->filename = NULL;

      curr->I = NULL;



      // We must decompress this chunk in order to discover where it

      // ends, and so we can put the uncompressed data and its length
@@ -491,7 +482,6 @@ unsigned char* ReadImage(const char* filename, 
      curr->start = pos;

      curr->len = GZIP_FOOTER_LEN;

      curr->data = img+pos;

      curr->I = NULL;



      pos += curr->len;

      p += curr->len;
@@ -515,7 +505,6 @@ unsigned char* ReadImage(const char* filename, 
      *chunks = reinterpret_cast<ImageChunk*>(realloc(*chunks, *num_chunks * sizeof(ImageChunk)));

      ImageChunk* curr = *chunks + (*num_chunks-1);

      curr->start = pos;

      curr->I = NULL;



      // 'pos' is not the offset of the start of a gzip chunk, so scan

      // forward until we find a gzip header.
@@ -642,7 +631,7 @@ unsigned char* MakePatch(ImageChunk* src, ImageChunk* tgt, size_t* size) { 
  close(fd); // temporary file is created and we don't need its file

             // descriptor



  int r = bsdiff(src->data, src->len, &(src->I), tgt->data, tgt->len, ptemp);

  int r = bsdiff::bsdiff(src->data, src->len, tgt->data, tgt->len, ptemp);

  if (r != 0) {

    printf("bsdiff() failed: %d\n", r);

    return NULL;