CWE-ou-minkata/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);
    };
}