CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plResMgr/plBSDiffBuffer.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//
//	plBSDiffBuffer - A utility class for writing and applying a difference
//					buffer--i.e. a buffer containing a series of modifications
//					that will modify an old data buffer to match a new one. 
//					It's a useful utility class when doing binary file
//				    patching, for example, as you can write out the changes
//				    to this class, get back a data buffer suitable for writing,
//					then use this class again later to reconstruct the new buffer.
//
//////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "plBSDiffBuffer.h"
#include "hsUtils.h"
#include "hsStream.h"

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

//////////////////////////////////////////////////////////////////////////////
//// Constructor/Destructors /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

//// Creation Constructor ////////////////////////////////////////////////////
//	Use this constructor when creating a new diff buffer. Pass in the length
//	of the final new buffer. You don't need to pass in the length of the old
//	buffer, but if you do, it'll help this class do some internal space 
//	optimization.

plBSDiffBuffer::plBSDiffBuffer( UInt32 newLength, UInt32 oldLength )
: fNewLength( newLength )
, fPatchLength( 0 )
{
	fPatchBuffer = nil;
	fWriting = true;
}

//// Application Constructor /////////////////////////////////////////////////
//	Use this constructor when taking a diff buffer and applying it to an old
//	buffer. Pass in a pointer to the diff buffer and its length. The buffer
//	will be copied, so you don't need to keep it around after you construct
//	this object.

plBSDiffBuffer::plBSDiffBuffer( void *buffer, UInt32 length )
: fNewLength( 0 )
, fPatchLength( 0 )
, fPatchBuffer( nil )
, fWriting( false )
{
	if (!buffer || length < 32)
		hsAssert(false, "Corrupt Patch Buffer!");

	if((fPatchBuffer=TRACKED_NEW unsigned char[length+1])!=nil)
	{
		fPatchLength = length;
		memcpy(fPatchBuffer, buffer, fPatchLength);
	}
}

plBSDiffBuffer::~plBSDiffBuffer()
{
	if ( fPatchBuffer )
		delete[] fPatchBuffer;
}


//////////////////////////////////////////////////////////////////////////////
//// Creation/Write Functions ////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

//// Diff /////////////////////////////////////////////////////////////////////
//	Diff() creates the diff buffer from the new and old. 
UInt32 plBSDiffBuffer::Diff( UInt32 oldLength, void *oldBuffer, UInt32 newLength, void *newBuffer )
{
	hsAssert( fWriting, "Trying to Add() to a difference buffer that's reading" );

	Int32 *I,*V;

	Int32 scan,pos,len;
	Int32 lastscan,lastpos,lastoffset;
	Int32 oldscore,scsc;

	Int32 s,Sf,lenf,Sb,lenb;
	Int32 overlap,Ss,lens;
	Int32 i;

	UInt32 cblen,dblen,eblen;
	unsigned char *oldbuf, *newbuf;
	unsigned char *cb,*db,*eb;

	unsigned char header[32];

	if (oldBuffer == nil ||
            oldLength < 0 ||
            newBuffer == nil ||
            newLength < 0)
    {
		return (-1);
    }

	oldbuf = (unsigned char *)oldBuffer;
	newbuf = (unsigned char *)newBuffer;

	if(((I=TRACKED_NEW Int32[oldLength+1])==nil) ||
		((V=TRACKED_NEW Int32[oldLength+1])==nil))
	{
		delete[] I;
		delete[] V;
		return fPatchLength;
	}

	IQSuffixSort(I,V,oldbuf,oldLength);

	delete[] V;

	/*
	 *	These could probably be smaller, especially cb.
	 */
	if(((cb=TRACKED_NEW unsigned char[newLength+1])==nil) ||
	   ((db=TRACKED_NEW unsigned char[newLength+1])==nil) ||
	   ((eb=TRACKED_NEW unsigned char[newLength+1])==nil))
	{
		delete[] I;
		delete[] cb;
		delete[] db;
		delete[] eb;
		return fPatchLength;
	}
	cblen=0;
	dblen=0;
	eblen=0;

	/* 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);
	memset(header+8,0,24);

	scan=0;len=0;
	lastscan=0;lastpos=0;lastoffset=0;
	while(scan<newLength) {
		oldscore=0;

		for(scsc=scan+=len;scan<newLength;scan++) {
			len=ISearch(I,oldbuf,oldLength,newbuf+scan,newLength-scan,
					0,oldLength,&pos);

			for(;scsc<scan+len;scsc++)
			if((scsc+lastoffset<oldLength) &&
				(oldbuf[scsc+lastoffset] == newbuf[scsc]))
				oldscore++;

			if(((len==oldscore) && (len!=0)) || 
				(len>oldscore+8)) break;

			if((scan+lastoffset<oldLength) &&
				(oldbuf[scan+lastoffset] == newbuf[scan]))
				oldscore--;
		};

		if((len!=oldscore) || (scan==newLength)) {
			s=0;Sf=0;lenf=0;
			for(i=0;(lastscan+i<scan)&&(lastpos+i<oldLength);) {
				if(oldbuf[lastpos+i]==newbuf[lastscan+i]) s++;
				i++;
				if(s*2-i>Sf*2-lenf) { Sf=s; lenf=i; };
			};

			lenb=0;
			if(scan<newLength) {
				s=0;Sb=0;
				for(i=1;(scan>=lastscan+i)&&(pos>=i);i++) {
					if(oldbuf[pos-i]==newbuf[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(newbuf[lastscan+lenf-overlap+i]==
					   oldbuf[lastpos+lenf-overlap+i]) s++;
					if(newbuf[scan-lenb+i]==
					   oldbuf[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]=newbuf[lastscan+i]-oldbuf[lastpos+i];
			for(i=0;i<(scan-lenb)-(lastscan+lenf);i++)
				eb[eblen+i]=newbuf[lastscan+lenf+i];

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

			IWriteUnsignedInt8(lenf,cb+cblen);
			IWriteUnsignedInt8((scan-lenb)-(lastscan+lenf),cb+cblen+8);
			IWriteUnsignedInt8((pos-lenb)-(lastpos+lenf),cb+cblen+16);
			cblen+=24;

			lastscan=scan-lenb;
			lastpos=pos-lenb;
			lastoffset=pos-scan;
		};
	};

	IWriteUnsignedInt8(cblen,header+8);
	IWriteUnsignedInt8(dblen,header+16);
	IWriteUnsignedInt8(newLength,header+24);

	fPatchLength = 32 + cblen + dblen + eblen;
	fPatchBuffer = nil;
	if((fPatchBuffer=TRACKED_NEW unsigned char[fPatchLength])!=nil)
	{
		memcpy(fPatchBuffer,header,32);
		memcpy(fPatchBuffer+32,cb,cblen);
		memcpy(fPatchBuffer+32+cblen,db,dblen);
		memcpy(fPatchBuffer+32+cblen+dblen,eb,eblen);
	}
	else
	{
		fPatchLength = 0;
	}

	delete[] cb;
	delete[] db;
	delete[] eb;
	delete[] I;

	return fPatchLength;
}

//// GetBuffer ///////////////////////////////////////////////////////////////
//	GetBuffer() will copy the diff stream into a new buffer and return it.
//	You are responsible for freeing the buffer. Call this once you're done 
//	adding ops and want the raw data to write out somewhere. Note: this
//	function will rewind the diff stream, so once you call it, you can't do
//	anything else on the object.

void plBSDiffBuffer::GetBuffer( UInt32 &length, void *&bufferPtr )
{
	hsAssert( fWriting, "Trying to GetBuffer() on a difference buffer that's reading" );

	if (fPatchBuffer && fPatchLength)
	{
		length = fPatchLength;
		if (bufferPtr = (void *)TRACKED_NEW unsigned char[ length ])
			memcpy(bufferPtr, fPatchBuffer, length);
	}
	else
	{
		length = 0;
		bufferPtr = nil;
	}
}

//////////////////////////////////////////////////////////////////////////////
//// Application Functions ///////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#define hsAssertAndBreak( cond, msg ) { if( cond ) { hsAssert( false, msg ); break; } }

// Patch() will take this diff buffer and apply it to the given old buffer,
// allocating and producing a new buffer. You are responsible for freeing the new buffer.
UInt32 plBSDiffBuffer::Patch( UInt32 oldLength, void *oldBuffer, UInt32 &newLength, void *&newBuffer )
{
	hsAssert( !fWriting, "Trying to Patch() a difference buffer that's writing" );

	unsigned char *ctrlpipe, *ctrlend;
	unsigned char *diffpipe, *diffend;
	unsigned char *extrapipe;
	UInt32 ctrllen,datalen;
	int version=0;
	unsigned char *newpos, *newend;
	unsigned char *oldpos, *oldend;
	unsigned char *patchend;
	UInt32 ctrl[3];
	UInt32 i;

	if (oldBuffer == nil ||
		oldLength < 0 ||
		newBuffer != nil ||
		newLength != 0 ||
		fPatchBuffer == nil ||
		fPatchLength < 32)
	{
		return (-1);
	}

	patchend = fPatchBuffer + fPatchLength;
	/*
	  Ok, this is going to be messy.  There are two different patch
	formats which we need to support.

	  The old format (pre-4.0) is:
		0	8	"QSUFDIFF" or "BSDIFF30"
		8	8	X
		16	8	Y
		24	8	sizeof(newfile)
		32	X	bzip2(control block)
		32+X	Y	bzip2(data block)
	with control block a set of pairs (x,y) meaning "seek forward
	in oldfile by y bytes, and add the next x bytes to x bytes from
	the data block".

	  The new format (4.0) is:
		0	8	"BSDIFF40"
		8	8	X
		16	8	Y
		24	8	sizeof(newfile)
		32	X	bzip2(control block)
		32+X	Y	bzip2(diff block)
		32+X+Y	???	bzip2(extra block)
	with control block a set of triples (x,y,z) meaning "add x bytes
	from oldfile to x bytes from the diff block; copy y bytes from the
	extra block; seek forwards in oldfile by z bytes".
	*/

	if(memcmp(fPatchBuffer,"QSUFDIFF",8)==0) version=1;
	if(memcmp(fPatchBuffer,"BSDIFF30",8)==0) version=1;
	if(memcmp(fPatchBuffer,"BSDIFF40",8)==0) version=2;

	if(!version) return (-1);

	ctrllen=IReadUnsignedInt8(fPatchBuffer+8);
	datalen=IReadUnsignedInt8(fPatchBuffer+16);
	newLength=IReadUnsignedInt8(fPatchBuffer+24);
	if((ctrllen<0) || (datalen<0) || (newLength<0) ||
		((version==1) && (32+ctrllen+datalen!=fPatchLength)))
		return (-1);

	ctrlpipe=fPatchBuffer+32;
	ctrlend =ctrlpipe+ctrllen; 
	diffpipe=ctrlend;
	diffend = diffpipe + datalen;
	if(version==2) {
		extrapipe=diffpipe+datalen;
	};

	if((newBuffer=(void *)TRACKED_NEW unsigned char[newLength+1])==nil) return(-1);
	newpos = (unsigned char *)newBuffer;
	newend = (unsigned char *)newBuffer + newLength;
	oldpos = (unsigned char *)oldBuffer;
	oldend = (unsigned char *)oldBuffer + oldLength;
	while(newpos<newend) {
		for(i=0;i<=version;i++) {
			if(ctrlend-ctrlpipe < 8) return (-1);
			ctrl[i]=IReadUnsignedInt8(ctrlpipe);
			ctrlpipe += 8;
		};

		if(version==1) oldpos+=ctrl[1];

		ISafeMemcpy(newpos, diffpipe, ctrl[0], newend, diffend);
		diffpipe += ctrl[0];

		for(i=0;i<ctrl[0];i++)
			if(oldpos<oldend)
			{
				*newpos += *oldpos;
				newpos++;
				oldpos++;
			}

		if(version==2) {
			ISafeMemcpy(newpos,extrapipe,ctrl[1],newend,patchend);
			extrapipe += ctrl[1];
			newpos+=ctrl[1];
			oldpos+=ctrl[2];
		};
	};

	if((ctrlpipe != ctrlend) ||
	   (diffpipe != diffend) ||
	   ((version==2) && (extrapipe != patchend)))
	{
		return (-1);
	}

	if(newpos != newend)
	{
		delete[] newBuffer;
		newLength = 0;
	}

	return newLength;
}

//////////////////////////////////////////////////////////////////////////////
//// Private Helper Functions ///////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

// Reads in an 8-byte unsigned integer least significant byte first and returns a
// UInt32. We'll ignore the top four bytes.
UInt32 plBSDiffBuffer::IReadUnsignedInt8(unsigned char *buf)
{
	UInt32 y;

	y=buf[7]&0x7F;
	y=y*256;y+=buf[6];
	y=y*256;y+=buf[5];
	y=y*256;y+=buf[4];
	y=y*256;y+=buf[3];
	y=y*256;y+=buf[2];
	y=y*256;y+=buf[1];
	y=y*256;y+=buf[0];

	// casting added so compiler doesn't warn about negating an unsigned value
	Int32 signedY = (Int32)y;
	if(buf[7]&0x80) signedY=-signedY;
	y = (UInt32)signedY;

	return y;
}

void plBSDiffBuffer::IWriteUnsignedInt8(UInt32 x,unsigned char *buf)
{
	UInt32 y;
	Int32 signedY, signedX = (Int32)x;

	// casting added so compiler doesn't warn about negating an unsigned value
	if(x<0) signedY=-signedX; else signedY=signedX;
	y = (UInt32)signedY;

	buf[0]=(unsigned char)(y%256);y-=buf[0];
	y=y/256;buf[1]=(unsigned char)(y%256);y-=buf[1];
	y=y/256;buf[2]=(unsigned char)(y%256);y-=buf[2];
	y=y/256;buf[3]=(unsigned char)(y%256);y-=buf[3];
	y=y/256;buf[4]=(unsigned char)(y%256);y-=buf[4];
	y=y/256;buf[5]=(unsigned char)(y%256);y-=buf[5];
	y=y/256;buf[6]=(unsigned char)(y%256);y-=buf[6];
	y=y/256;buf[7]=(unsigned char)(y%256);

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

/*
 *	This function will ensure that no boundary errors occur. It also increments *src
 *  by nbytes when done.
 */
void plBSDiffBuffer::ISafeMemcpy(unsigned char *dest, unsigned char *src, size_t nbytes,
								 unsigned char *destend, unsigned char *srcend)
{
	if((destend - dest < nbytes) ||
	   (srcend - src < nbytes))
	{
		hsAssert(false,"Corrupt patch\n");
	}
	memcpy(dest,src,nbytes);
}

void plBSDiffBuffer::ISplit(Int32 *I,Int32 *V,UInt32 start,UInt32 len,UInt32 h)
{
	UInt32 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) ISplit(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) ISplit(I,V,kk,start+len-kk,h);
}

void plBSDiffBuffer::IQSuffixSort(Int32 *I,Int32 *V,unsigned char *old,UInt32 oldsize)
{
	UInt32 buckets[256];
	UInt32 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;

	// oldsize converted to Int32 to stop warning about negating unsigned numbers
	for(h=1;I[0]!=-(Int32)(oldsize+1);h+=h) {
		len=0;
		for(i=0;i<oldsize+1;) {
			if(I[i]<0) {
				len-=I[i];
				i-=I[i];
			} else {
				// len converted to Int32 to stop the warning about negating an unsigned number
				if(len) I[i-len]=-(Int32)len;
				len=V[I[i]]+1-i;
				ISplit(I,V,i,len,h);
				i+=len;
				len=0;
			};
		};
		// len converted to Int32 to stop the warning about negating an unsigned number
		if(len) I[i-len]=-(Int32)len;
	};

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

UInt32 plBSDiffBuffer::IMatchLen( unsigned char *oldBuffer, UInt32 oldLength,
								  unsigned char *newBuffer, UInt32 newLength)
{
	UInt32 i;

	for(i=0;(i<oldLength)&&(i<newLength);i++)
		if(oldBuffer[i]!=newBuffer[i]) break;

	return i;
}

UInt32 plBSDiffBuffer::ISearch( Int32 *I,
							    unsigned char *oldBuffer, UInt32 oldLength,
								unsigned char *newBuffer, UInt32 newLength,
								UInt32 st, UInt32 en, Int32 *pos)
{
	UInt32 x,y;

	if(en-st<2) {
		x=IMatchLen(oldBuffer+I[st],oldLength-I[st],newBuffer,newLength);
		y=IMatchLen(oldBuffer+I[en],oldLength-I[en],newBuffer,newLength);

		if(x>y) {
			*pos=I[st];
			return x;
		} else {
			*pos=I[en];
			return y;
		}
	};

	x=st+(en-st)/2;
	if(memcmp(oldBuffer+I[x],newBuffer,plBSDiffBuffer_MIN(oldLength-I[x],newLength))<0) {
		return ISearch(I,oldBuffer,oldLength,newBuffer,newLength,x,en,pos);
	} else {
		return ISearch(I,oldBuffer,oldLength,newBuffer,newLength,st,x,pos);
	};
}