Rebuild file from original file and differences file in RAM

Dear friends, I am trying to implement a program that reconstructs a binary file, starting from the old file and a file of differences. The work is based on the ingenious thesis Olin Percival, Naive differences of executable code, Binary diff , 2003. I want to use the rebuilder (bspatch) on a microcontroller ARM M4. I'm trying to eliminate disk access with operations on simple vectors. The operation is not trivial because the Olin program is complicated! Of course in addition to the file pointer, the Olin program uses functions to access the file, such as fgetc FSEEK that must be replaced. To start I am working in C in visual studio and when the program will work on the PC i will move it on ARM M4.
To begin with, I add static vectors of char as long as the files in input,then I copy-paste the files in to the vectors. From this point on I no longer want to make disk accesses. However, the program keeps making unwanted disk access.

Has anyone ever replaced a file pointer with a vector of char to use only RAM?

Look the original program of Olin (found in the link) there is a Visual Studio project.

Thank You and Happy Happy Happy New Year
Stefano Fredella

I'm not sure why you keep saying 'olin' when the link you refer to quite clearly says "Colin Percival"

As for the rest, start with a global edit which changes fseek(FILE *stream, long offset, int whence) into my_fseek(FILE *stream, long offset, int whence)

And you implement

Code:

---

int my_fseek(FILE *stream, long offset, int whence) {
  return fseek(stream,offset,whence);
}

---

When you have done that for all the FILE* API you're using, then you can start to redefine the interface to use arrays.

Thank You, I made the changement and also load the files in array of chars:

Code:

---

    /*-
    * 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 <stdlib.h>
    #include <stdio.h>
    //#include <err.h>
    #include "bzlib.h"
    #include <io.h>
    #include <fcntl.h>




    #include <sys/types.h>
    typedef unsigned char u_char;
    typedef signed int ssize_t;


    template<class T1, class T2>
    void err(int i, const char* str, T1 arg1, T2 arg2) {
        char lastErrorTxt[1024];
        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,GetLastError(),0,lastErrorTxt,1024,NULL);
        printf("%s",lastErrorTxt);
        printf(str, arg1, arg2);
        exit(i);
    }
    template<class T>
    void err(int i, const char* str, T arg) {
        char lastErrorTxt[1024];
        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,GetLastError(),0,lastErrorTxt,1024,NULL);
        printf("%s",lastErrorTxt);
        printf(str, arg);
        exit(i);
    }
    void err(int i, const char* str) {
        char lastErrorTxt[1024];
        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,GetLastError(),0,lastErrorTxt,1024,NULL);
        printf("%s",lastErrorTxt);
        if (str!=NULL) {
            printf("%s",str);
        }
        exit(i);
    }
    template<class T>
    void errx(int i, const char* str, T arg) {
        printf(str, arg);
        exit(i);
    }
    void errx(int i, const char* str) {
        printf("%s",str);
        exit(i);
    }




    static off_t offtin(u_char *buf)
    {
        off_t 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];


        if(buf[7]&0x80) y=-y;


        return y;
    }


    int my_fseek(FILE *stream, long offset, int whence)
    {
        return fseek(stream, offset, whence);
    }


    int main(void)
    {
        FILE * f, * cpf, * dpf, * epf;
        BZFILE * cpfbz2, * dpfbz2, * epfbz2;
        int cbz2err, dbz2err, ebz2err;
        int fd;
        ssize_t oldsize,newsize;
        ssize_t bzctrllen,bzdatalen;
        u_char header[32],buf[8];
        u_char *old, *_new;
        off_t oldpos,newpos;
        off_t ctrl[3];
        off_t lenread;
        off_t i;


        char OldFile[]= "old.txt";
        char NewFile[]= "newPatched.txt";
        char PatchFile[]= "patch.txt";
        char * VECTOR_PATCH;//[10*1024];
        char * VECTOR_OLD;//[200*1024];
        unsigned char c;
        int j,k,m,fileLen;
   
        /* load the file old in a vector---------------------------------------------------------------*/
        //Open file
        f = fopen(PatchFile, "rb");
        if (!f)
        {
            fprintf(stderr, "Unable to open file %s", PatchFile);
            return 1;
        }
   
        //Get file length
        my_fseek(f, 0, SEEK_END);                //fseek(f, 0, SEEK_END);
        fileLen=ftell(f);
        my_fseek(f, 0, SEEK_SET);                //fseek(f, 0, SEEK_END);


        //Allocate memory
        VECTOR_PATCH=(char *)malloc(fileLen+1);
        if (!VECTOR_PATCH)
        {
            fprintf(stderr, "Memory error!");
                                    fclose(f);
            return 1;
        }


        //Read file contents into buffer
        fread(VECTOR_PATCH, fileLen, 1, f);
        fclose(f);




        /* load the file old in a vector--------------------------------------------------------------------------------------*/


        f = fopen(OldFile, "rb");
        if (!f)
        {
            fprintf(stderr, "Unable to open file %s", OldFile);
            return 1;
        }
   
        //Get file length
        my_fseek(f, 0, SEEK_END);
        fileLen=ftell(f);
        my_fseek(f, 0, SEEK_SET);


        //Allocate memory
        VECTOR_OLD=(char *)malloc(fileLen+1);
        if (!VECTOR_OLD)
        {
            fprintf(stderr, "Memory error!");
                                    fclose(f);
            return 1;
        }


        //Read file contents into buffer
        fread(VECTOR_OLD, fileLen, 1, f);
        fclose(f);








        /*
        File format:
            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".
        */


        /* Read header */


        for(i=0; i<32;i++)
            header[i] = VECTOR_PATCH[i];


        /* Check for appropriate magic */
        if (memcmp(header, "BSDIFF40", 8) != 0)
            errx(1, "Corrupt patch\n");


        /* Read lengths from header */
        bzctrllen=offtin(header+8);
        bzdatalen=offtin(header+16);
        newsize=offtin(header+24);
        if((bzctrllen<0) || (bzdatalen<0) || (newsize<0))
            errx(1,"Corrupt patch\n");


        /* open it via libbzip2 at the right places */
        if ((cpf = fopen(PatchFile, "rb")) == NULL)
            err(1, "fopen(%s)", PatchFile);
        if (my_fseek(cpf, 32, SEEK_SET))
            err(1, "fseeko(%s, %d)", PatchFile, 32);
   
        if ((cpfbz2 = BZ2_bzReadOpen(&cbz2err, (FILE *)&VECTOR_PATCH[32], 0, 0, NULL, 0)) == NULL)
            errx(1, "BZ2_bzReadOpen, bz2err = %d", cbz2err);


    /*----------------------------------------------------------------------------------*/
        if ((cpf = fopen(PatchFile, "rb")) == NULL)
            err(1, "fopen(%s)", PatchFile);
        if (my_fseek(cpf, 32, SEEK_SET))
            err(1, "fseeko(%s, %d)", PatchFile, 32);
        if ((cpfbz2 = BZ2_bzReadOpen(&cbz2err, cpf, 0, 0, NULL, 0)) == NULL)
            errx(1, "BZ2_bzReadOpen, bz2err = %d", cbz2err);
    /*----------------------------------------------------------------------------------*/


        if ((dpf = fopen(PatchFile, "rb")) == NULL)
            err(1, "fopen(%s)", PatchFile);
        if (my_fseek(dpf, 32 + bzctrllen, SEEK_SET))
            err(1, "fseeko(%s, %d)", PatchFile,
                (32 + bzctrllen));
        if ((dpfbz2 = BZ2_bzReadOpen(&dbz2err, dpf, 0, 0, NULL, 0)) == NULL)
            errx(1, "BZ2_bzReadOpen, bz2err = %d", dbz2err);
        if ((epf = fopen(PatchFile, "rb")) == NULL)
            err(1, "fopen(%s)", PatchFile);
        if (my_fseek(epf, 32 + bzctrllen + bzdatalen, SEEK_SET))
            err(1, "fseeko(%s, %d)", PatchFile,
                (32 + bzctrllen + bzdatalen));
        if ((epfbz2 = BZ2_bzReadOpen(&ebz2err, epf, 0, 0, NULL, 0)) == NULL)
            errx(1, "BZ2_bzReadOpen, bz2err = %d", ebz2err);


        //org:
        //if(((fd=open(argv[1],O_RDONLY,0))<0) ||
        //    ((oldsize=lseek(fd,0,SEEK_END))==-1) ||
        //    ((old=malloc(oldsize+1))==NULL) ||
        //    (lseek(fd,0,SEEK_SET)!=0) ||
        //    (read(fd,old,oldsize)!=oldsize) ||
        //    (close(fd)==-1)) err(1,"%s",argv[1]);
        //new:
        //Read in chunks, don't rely on read always returns full data!
        if(((fd=open(OldFile,O_RDONLY|O_BINARY|O_NOINHERIT,0))<0) ||
            ((oldsize=_lseek(fd,0,SEEK_END))==-1) ||
            ((old=(u_char*)malloc(oldsize+1))==NULL) ||
            (_lseek(fd,0,SEEK_SET)!=0))
                    err(1,"%s",OldFile);
        int r=oldsize;
        while (r>0 && (i=read(fd,old+oldsize-r,r))>0) r-=i;
        if (r>0 || close(fd)==-1) err(1,"%s",OldFile);


        if((_new=(u_char*)malloc(newsize+1))==NULL)
            err(1,NULL);


        oldpos=0;newpos=0;
        while(newpos<newsize) {
            /* Read control data */
            for(i=0;i<=2;i++) {
                lenread = BZ2_bzRead(&cbz2err, cpfbz2, buf, 8);
                if ((lenread < 8) || ((cbz2err != BZ_OK) &&
                    (cbz2err != BZ_STREAM_END)))
                    errx(1, "Corrupt patch\n");
                ctrl[i]=offtin(buf);
            };


            /* Sanity-check */
            if(newpos+ctrl[0]>newsize)
                errx(1,"Corrupt patch\n");


            /* Read diff string */
            lenread = BZ2_bzRead(&dbz2err, dpfbz2, _new + newpos, ctrl[0]);
            if ((lenread < ctrl[0]) ||
                ((dbz2err != BZ_OK) && (dbz2err != BZ_STREAM_END)))
                errx(1, "Corrupt patch\n");


            /* Add old data to diff string */
            for(i=0;i<ctrl[0];i++)
                if((oldpos+i>=0) && (oldpos+i<oldsize))
                    _new[newpos+i]+=old[oldpos+i];


            /* Adjust pointers */
            newpos+=ctrl[0];
            oldpos+=ctrl[0];


            /* Sanity-check */
            if(newpos+ctrl[1]>newsize)
                errx(1,"Corrupt patch\n");


            /* Read extra string */
            lenread = BZ2_bzRead(&ebz2err, epfbz2, _new + newpos, ctrl[1]);
            if ((lenread < ctrl[1]) ||
                ((ebz2err != BZ_OK) && (ebz2err != BZ_STREAM_END)))
                errx(1, "Corrupt patch\n");


            /* Adjust pointers */
                newpos+=ctrl[1];
                oldpos+=ctrl[2];
            };


        /* Clean up the bzip2 reads */
        BZ2_bzReadClose(&cbz2err, cpfbz2);
        BZ2_bzReadClose(&dbz2err, dpfbz2);
        BZ2_bzReadClose(&ebz2err, epfbz2);
        if (fclose(cpf) || fclose(dpf) || fclose(epf))
            err(1, "fclose(%s)", PatchFile);


        /* Write the new file */
        //org:
        //if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0666))<0) ||
        //new:
        if(((fd=open(NewFile,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,0666))<0) ||
            (write(fd,_new,newsize)!=newsize) || (close(fd)==-1))
            err(1,"%s",NewFile);


        free(_new);
        free(old);


        return 0;
    }

---

But now how can pass vector to openread function and read?

Unfortunatly row 243 that i added not produce the same effect of row 252 that I want eliminate.

I think these functions must be cange to accept vector instead file pointer:

Code:

---

BZFILE* BZ_API(BZ2_bzReadOpen)
                  ( int*  bzerror,
                    FILE* f,
                    int  verbosity,
                    int  small,
                    void* unused,
                    int  nUnused )
{
  bzFile* bzf = NULL;
  int    ret;
 
  BZ_SETERR(BZ_OK);
 
  if (f == NULL ||
      (small != 0 && small != 1) ||
      (verbosity < 0 || verbosity > 4) ||
      (unused == NULL && nUnused != 0) ||
      (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)))
      { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
 
  if (ferror(f))
      { BZ_SETERR(BZ_IO_ERROR); return NULL; };
 
  bzf = malloc ( sizeof(bzFile) );
  if (bzf == NULL)
      { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
 
  BZ_SETERR(BZ_OK);
 
  bzf->initialisedOk = False;
  bzf->handle        = f;
  bzf->bufN          = 0;
  bzf->writing      = False;
  bzf->strm.bzalloc  = NULL;
  bzf->strm.bzfree  = NULL;
  bzf->strm.opaque  = NULL;
 
  while (nUnused > 0) {
      bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
      unused = ((void*)( 1 + ((UChar*)(unused))  ));
      nUnused--;
  }
 
  ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
  if (ret != BZ_OK)
      { BZ_SETERR(ret); free(bzf); return NULL; };
 
  bzf->strm.avail_in = bzf->bufN;
  bzf->strm.next_in  = bzf->buf;
 
  bzf->initialisedOk = True;
  return bzf; 
}
 
int BZ_API(BZ2_bzRead)
          ( int*    bzerror,
            BZFILE* b,
            void*  buf,
            int    len )
{
  Int32  n, ret;
  bzFile* bzf = (bzFile*)b;
 
  BZ_SETERR(BZ_OK);
 
  if (bzf == NULL || buf == NULL || len < 0)
      { BZ_SETERR(BZ_PARAM_ERROR); return 0; };
 
  if (bzf->writing)
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };
 
  if (len == 0)
      { BZ_SETERR(BZ_OK); return 0; };
 
  bzf->strm.avail_out = len;
  bzf->strm.next_out = buf;
 
  while (True) {
 
      if (ferror(bzf->handle))
        { BZ_SETERR(BZ_IO_ERROR); return 0; };
 
      if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) {
        n = fread ( bzf->buf, sizeof(UChar),
                    BZ_MAX_UNUSED, bzf->handle );
        if (ferror(bzf->handle))
            { BZ_SETERR(BZ_IO_ERROR); return 0; };
        bzf->bufN = n;
        bzf->strm.avail_in = bzf->bufN;
        bzf->strm.next_in = bzf->buf;
      }
 
      ret = BZ2_bzDecompress ( &(bzf->strm) );
 
      if (ret != BZ_OK && ret != BZ_STREAM_END)
        { BZ_SETERR(ret); return 0; };
 
      if (ret == BZ_OK && myfeof(bzf->handle) &&
          bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
        { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
 
      if (ret == BZ_STREAM_END)
        { BZ_SETERR(BZ_STREAM_END);
          return len - bzf->strm.avail_out; };
      if (bzf->strm.avail_out == 0)
        { BZ_SETERR(BZ_OK); return len; };
 
  }
 
  return 0; /*not reached*/
}
static Bool myfeof ( FILE* f )
{
  Int32 c = fgetc ( f );
  if (c == EOF) return True;
  ungetc ( c, f );
  return False;
}

---

You've only done an half-assed job of what I told you to do.

Do the same for
fopen
fclose
fread
fwrite
ftell
f....anyotherfunctiontakingFILE* as a parameter.

But then you have to also consider what the POSIX API functions open/read/write/close etc have to do as well.

I have change all functions:

Code:

---

        /*-
        * 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 <stdlib.h>
        #include <stdio.h>
        //#include <err.h>
        #include "bzlib.h"
        #include <io.h>
        #include <fcntl.h>




        #include <sys/types.h>
        typedef unsigned char u_char;
        typedef signed int ssize_t;


        template<class T1, class T2>
        void err(int i, const char* str, T1 arg1, T2 arg2) {
                char lastErrorTxt[1024];
                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,GetLastError(),0,lastErrorTxt,1024,NULL);
                printf("%s",lastErrorTxt);
                printf(str, arg1, arg2);
                exit(i);
        }
        template<class T>
        void err(int i, const char* str, T arg) {
                char lastErrorTxt[1024];
                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,GetLastError(),0,lastErrorTxt,1024,NULL);
                printf("%s",lastErrorTxt);
                printf(str, arg);
                exit(i);
        }
        void err(int i, const char* str) {
                char lastErrorTxt[1024];
                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,GetLastError(),0,lastErrorTxt,1024,NULL);
                printf("%s",lastErrorTxt);
                if (str!=NULL) {
                        printf("%s",str);
                }
                exit(i);
        }
        template<class T>
        void errx(int i, const char* str, T arg) {
                printf(str, arg);
                exit(i);
        }
        void errx(int i, const char* str) {
                printf("%s",str);
                exit(i);
        }




        static off_t offtin(u_char *buf)
        {
                off_t 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];


                if(buf[7]&0x80) y=-y;


                return y;
        }


        int my_fseek(FILE *stream, long offset, int whence)
        {
                return fseek(stream, offset, whence);
        }
       
        FILE *my_fopen(const char * filename, const char * mode)
        {
                return fopen(filename, mode);
        }
       
        size_t my_fread(void *buffer, size_t size, size_t count, FILE *stream)
        {


                return fread(buffer, size, count, stream);
        }


        int my_fclose(FILE * filestream)
        {
                return fclose(filestream);
        }


        int my_ftell(FILE *filestream)
        {
                return ftell(filestream);
        }


        int main(void)
        {
                FILE * f, * cpf, * dpf, * epf;
                BZFILE * cpfbz2, * dpfbz2, * epfbz2;
                int cbz2err, dbz2err, ebz2err;
                int fd;
                ssize_t oldsize,newsize;
                ssize_t bzctrllen,bzdatalen;
                u_char header[32],buf[8];
                u_char *old, *_new;
                off_t oldpos,newpos;
                off_t ctrl[3];
                off_t lenread;
                off_t i;


                char OldFile[]= "old.txt";
                char NewFile[]= "newPatched.txt";
                char PatchFile[]= "patch.txt";
                char * VECTOR_PATCH;//[10*1024];
                char * VECTOR_OLD;//[200*1024];
                unsigned char c;
                int j,k,m,fileLen;
       
                /* load the file old in a vector---------------------------------------------------------------*/
                //Open file
                f = my_fopen(PatchFile, "rb");
                if (!f)
                {
                        fprintf(stderr, "Unable to open file %s", PatchFile);
                        return 1;
                }
       
                //Get file length
                my_fseek(f, 0, SEEK_END);                                //fseek(f, 0, SEEK_END);
                fileLen=my_ftell(f);
                my_fseek(f, 0, SEEK_SET);                                //fseek(f, 0, SEEK_END);


                //Allocate memory
                VECTOR_PATCH=(char *)malloc(fileLen+1);
                if (!VECTOR_PATCH)
                {
                        fprintf(stderr, "Memory error!");
                                                                        my_fclose(f);
                        return 1;
                }


                //Read file contents into buffer
                my_fread(VECTOR_PATCH, fileLen, 1, f);
                my_fclose(f);




                /* load the file old in a vector--------------------------------------------------------------------------------------*/


                f = my_fopen(OldFile, "rb");
                if (!f)
                {
                        fprintf(stderr, "Unable to open file %s", OldFile);
                        return 1;
                }
       
                //Get file length
                my_fseek(f, 0, SEEK_END);
                fileLen=my_ftell(f);
                my_fseek(f, 0, SEEK_SET);


                //Allocate memory
                VECTOR_OLD=(char *)malloc(fileLen+1);
                if (!VECTOR_OLD)
                {
                        fprintf(stderr, "Memory error!");
                                                                        fclose(f);
                        return 1;
                }


                //Read file contents into buffer
                my_fread(VECTOR_OLD, fileLen, 1, f);
                my_fclose(f);








                /*
                File format:
                        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".
                */


                /* Read header */


                for(i=0; i<32;i++)
                        header[i] = VECTOR_PATCH[i];


                /* Check for appropriate magic */
                if (memcmp(header, "BSDIFF40", 8) != 0)
                        errx(1, "Corrupt patch\n");


                /* Read lengths from header */
                bzctrllen=offtin(header+8);
                bzdatalen=offtin(header+16);
                newsize=offtin(header+24);
                if((bzctrllen<0) || (bzdatalen<0) || (newsize<0))
                        errx(1,"Corrupt patch\n");


                /* open it via libbzip2 at the right places */
                if ((cpf = my_fopen(PatchFile, "rb")) == NULL)
                        err(1, "fopen(%s)", PatchFile);
                if (my_fseek(cpf, 32, SEEK_SET))
                        err(1, "fseeko(%s, %d)", PatchFile, 32);
       


        /*----------------------------------------------------------------------------------*/
                if ((cpf = my_fopen(PatchFile, "rb")) == NULL)
                        err(1, "fopen(%s)", PatchFile);
                if (my_fseek(cpf, 32, SEEK_SET))
                        err(1, "fseeko(%s, %d)", PatchFile, 32);
                if ((cpfbz2 = BZ2_bzReadOpen(&cbz2err, cpf, 0, 0, NULL, 0)) == NULL)
                        errx(1, "BZ2_bzReadOpen, bz2err = %d", cbz2err);
        /*----------------------------------------------------------------------------------*/


                if ((dpf = fopen(PatchFile, "rb")) == NULL)
                        err(1, "fopen(%s)", PatchFile);
                if (my_fseek(dpf, 32 + bzctrllen, SEEK_SET))
                        err(1, "fseeko(%s, %d)", PatchFile,
                                (32 + bzctrllen));
                if ((dpfbz2 = BZ2_bzReadOpen(&dbz2err, dpf, 0, 0, NULL, 0)) == NULL)
                        errx(1, "BZ2_bzReadOpen, bz2err = %d", dbz2err);
                if ((epf = fopen(PatchFile, "rb")) == NULL)
                        err(1, "fopen(%s)", PatchFile);
                if (my_fseek(epf, 32 + bzctrllen + bzdatalen, SEEK_SET))
                        err(1, "fseeko(%s, %d)", PatchFile,
                                (32 + bzctrllen + bzdatalen));
                if ((epfbz2 = BZ2_bzReadOpen(&ebz2err, epf, 0, 0, NULL, 0)) == NULL)
                        errx(1, "BZ2_bzReadOpen, bz2err = %d", ebz2err);


                //org:
                //if(((fd=open(argv[1],O_RDONLY,0))<0) ||
                //        ((oldsize=lseek(fd,0,SEEK_END))==-1) ||
                //        ((old=malloc(oldsize+1))==NULL) ||
                //        (lseek(fd,0,SEEK_SET)!=0) ||
                //        (read(fd,old,oldsize)!=oldsize) ||
                //        (close(fd)==-1)) err(1,"%s",argv[1]);
                //new:
                //Read in chunks, don't rely on read always returns full data!
                if(((fd=open(OldFile,O_RDONLY|O_BINARY|O_NOINHERIT,0))<0) ||
                        ((oldsize=_lseek(fd,0,SEEK_END))==-1) ||
                        ((old=(u_char*)malloc(oldsize+1))==NULL) ||
                        (_lseek(fd,0,SEEK_SET)!=0))
                                        err(1,"%s",OldFile);
                int r=oldsize;
                while (r>0 && (i=read(fd,old+oldsize-r,r))>0) r-=i;
                if (r>0 || close(fd)==-1) err(1,"%s",OldFile);


                if((_new=(u_char*)malloc(newsize+1))==NULL)
                        err(1,NULL);


                oldpos=0;newpos=0;
                while(newpos<newsize) {
                        /* Read control data */
                        for(i=0;i<=2;i++) {
                                lenread = BZ2_bzRead(&cbz2err, cpfbz2, buf, 8);
                                if ((lenread < 8) || ((cbz2err != BZ_OK) &&
                                        (cbz2err != BZ_STREAM_END)))
                                        errx(1, "Corrupt patch\n");
                                ctrl[i]=offtin(buf);
                        };


                        /* Sanity-check */
                        if(newpos+ctrl[0]>newsize)
                                errx(1,"Corrupt patch\n");


                        /* Read diff string */
                        lenread = BZ2_bzRead(&dbz2err, dpfbz2, _new + newpos, ctrl[0]);
                        if ((lenread < ctrl[0]) ||
                                ((dbz2err != BZ_OK) && (dbz2err != BZ_STREAM_END)))
                                errx(1, "Corrupt patch\n");


                        /* Add old data to diff string */
                        for(i=0;i<ctrl[0];i++)
                                if((oldpos+i>=0) && (oldpos+i<oldsize))
                                        _new[newpos+i]+=old[oldpos+i];


                        /* Adjust pointers */
                        newpos+=ctrl[0];
                        oldpos+=ctrl[0];


                        /* Sanity-check */
                        if(newpos+ctrl[1]>newsize)
                                errx(1,"Corrupt patch\n");


                        /* Read extra string */
                        lenread = BZ2_bzRead(&ebz2err, epfbz2, _new + newpos, ctrl[1]);
                        if ((lenread < ctrl[1]) ||
                                ((ebz2err != BZ_OK) && (ebz2err != BZ_STREAM_END)))
                                errx(1, "Corrupt patch\n");


                        /* Adjust pointers */
                                newpos+=ctrl[1];
                                oldpos+=ctrl[2];
                        };


                /* Clean up the bzip2 reads */
                BZ2_bzReadClose(&cbz2err, cpfbz2);
                BZ2_bzReadClose(&dbz2err, dpfbz2);
                BZ2_bzReadClose(&ebz2err, epfbz2);
                if (my_fclose(cpf) || my_fclose(dpf) || my_fclose(epf))
                        err(1, "fclose(%s)", PatchFile);


                /* Write the new file */
                //org:
                //if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0666))<0) ||
                //new:
                if(((fd=open(NewFile,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,0666))<0) ||
                        (write(fd,_new,newsize)!=newsize) || (close(fd)==-1))
                        err(1,"%s",NewFile);


                free(_new);
                free(old);


                return 0;
        }

---

When You write: "When you have done that for all the FILE* API you're using, then you can start to redefine the interface to use arrays" You are talking about fill the FILE structure with all field to obtain file from vector of chars?
I thinking this structure:

Code:

---

struct _iobuf {
        char *_ptr;
        int  _cnt;
        char *_base;
        int  _flag;
        int  _file;
        int  _charbuf;
        int  _bufsiz;
        char *_tmpfname;
        };
typedef struct _iobuf FILE;

---

OK, so now you refactor all the my_ functions to use arrays in memory.