@@ -29,10 +29,10 @@

 #define UNSAVEDPOSTFIX ".reu"

 #define SECURESAVEPREFIX "."

 #define SECURESAVEPOSTFIX ".saving"

-#define UNSAVEDHEADER "REUNSAV\n"

-#define UNSAVEDVERSION "\n000001\0"

+#define UNSAVEDHEADER "reunsaved00,"

 static int redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *resbuf129bytes);

+static int redata_unsaved_check_gen(redata_t *redata, char *filename);

 static char *unsaved_genname(char *filename, char *buf, int bufsize);

 static char *securesave_genname(char *filename, char *buf, int bufsize);

 static char *genname(char *filename,char *prefix, char *postfix, char *buf, int bufsize);

@@ -57,7 +57,6 @@ redata_init(void)

         /* unsaved */

         redata->filename[0]='\0';

         redata->unsavedfd=-1;

-        redata->flag_unsaveddata=0;

         /* all done */

         return(redata);

 }

@@ -84,13 +83,22 @@ redata_free(redata_t *redata)

                 free(redata->undostack.undo),redata->undostack.undo=NULL;

         if(redata->undostack.buf!=NULL)

                 free(redata->undostack.buf),redata->undostack.buf=NULL;

+        /* redo */

+        if(redata->redostack.undo!=NULL)

+                free(redata->redostack.undo),redata->redostack.undo=NULL;

+        if(redata->redostack.buf!=NULL)

+                free(redata->redostack.buf),redata->redostack.buf=NULL;

         /* unsaved */

         if(redata->unsavedfd!=-1) {

                 close(redata->unsavedfd),redata->unsavedfd=-1;

                 if(unsaved_genname(redata->filename,unsname,sizeof(unsname))!=NULL)

                         unlink(unsname);

         }

-        redata->flag_unsaveddata=0;

+        if(redata->unsaved.buf!=NULL) {

+                free(redata->unsaved.buf),redata->unsaved.buf=NULL;

+                redata->unsaved.sizebuf=redata->unsaved.usedbuf=0;

+                redata->unsaved.lastsize=0;

+        }

         /* free main struct */

         free(redata),redata=NULL;

         return;

@@ -171,8 +179,8 @@ redata_wipe(redata_t *redata)

                 if(unsaved_genname(redata->filename,unsname,sizeof(unsname))!=NULL)

                         unlink(unsname);

         }

-        redata->flag_unsaveddata=0;

         redata->filename[0]='\0';

+        redata->unsaved.usedbuf=0;

         /* all done */

         return(0);

 }

@@ -427,14 +435,14 @@ redata_unsaved_exists(redata_t *redata, char *filename)

         return(0);

 }

-int

-redata_unsaved_check(redata_t *redata, char *filename)

+static int

+redata_unsaved_check_gen(redata_t *redata, char *filename)

 {

         char unsname[PATH_MAX+1];

         int fd,nread;

-        static char header[9]={UNSAVEDHEADER};

-        static char version[9]={UNSAVEDVERSION};

-        char filehash[129],undohash[129],buf[64];

+        static char header[]={UNSAVEDHEADER};

+        char filehash[129],undohash[129],buf[16];

+        char fileheader[]={UNSAVEDHEADER};

         if(redata==NULL || filename==NULL)

                 return(-1); /* sanity check failed */

         if((unsaved_genname(filename,unsname,sizeof(unsname)))==NULL)

@@ -443,7 +451,9 @@ redata_unsaved_check(redata_t *redata, char *filename)

                 return(-1);

         if((fd=open(unsname,O_RDONLY))==-1)

                 return(-1);

-        if((nread=read(fd,buf,8))==-1 || nread!=8 || memcmp(buf,header,8)!=0) {

+        memset(fileheader,0,sizeof(fileheader));

+        if((nread=read(fd,fileheader,sizeof(fileheader)-1))==-1

+          || nread!=(sizeof(fileheader)-1) || memcmp(fileheader,header,sizeof(fileheader))!=0) {

                 close(fd),fd=-1;

                 return(-1); /* corrupted header */

         }

@@ -451,10 +461,19 @@ redata_unsaved_check(redata_t *redata, char *filename)

                 close(fd),fd=-1;

                 return(-1); /* wrong hash */

         }

-        if((nread=read(fd,buf,8))==-1 || nread!=8 || memcmp(buf,version,8)!=0) {

+        if((nread=read(fd,buf,1))==-1 || nread!=1 || *buf!=',') {

                 close(fd),fd=-1;

-                return(-1); /* wrong version */

+                return(-1); /* wrong hash separator */

         }

+        return(fd);

+}

+

+int

+redata_unsaved_check(redata_t *redata, char *filename)

+{

+        int fd;

+        if((fd=redata_unsaved_check(redata,filename))==-1)

+                return(-1); /* check failed */

         close(fd),fd=-1;

         return(0);

 }

@@ -474,28 +493,28 @@ redata_unsaved_unlink(redata_t *redata)

         return(0);

 }

-

-

 int

 redata_unsaved_trunc(redata_t *redata)

 {

         char unsname[PATH_MAX+1];

-        static char header[9]={UNSAVEDHEADER};

-        static char version[9]={UNSAVEDVERSION};

+        static char header[]={UNSAVEDHEADER};

         int n;

         if(redata==NULL || redata->filename[0]=='\0')

                 return(-1); /* sanity check failed */

         redata_unsaved_unlink(redata);

         if((unsaved_genname(redata->filename,unsname,sizeof(unsname)))==NULL)

                 return(-1); /* malformed filename */

+        if(redata->unsavedfd!=-1)

+                close(redata->unsavedfd),redata->unsavedfd=-1;

         if((redata->unsavedfd=open(unsname,O_WRONLY|O_TRUNC|O_CREAT,0644))==-1)

                 return(-1); /* couldn't open file for writing */

-        if((n=write(redata->unsavedfd,header,8))==-1 || n!=8 ||

-          (n=write(redata->unsavedfd,redata->initialhash,128))==-1 || n!=128 ||

-          (n=write(redata->unsavedfd,version,8))==-1 || n!=8) {

+        if((n=write(redata->unsavedfd,header,sizeof(header)-1))==-1

+          || n!=(sizeof(header)-1)

+          || (n=write(redata->unsavedfd,redata->initialhash,128))==-1 || n!=128

+          || (n=write(redata->unsavedfd,",",1))==-1 || n!=1) {

                 close(redata->unsavedfd),redata->unsavedfd=-1;

                 unlink(unsname);

-                return(-1); /* couldn't write header/hash/version */

+                return(-1); /* couldn't write header/hash */

         }

         return(0);

 }

@@ -503,6 +522,40 @@ redata_unsaved_trunc(redata_t *redata)

 int

 redata_unsaved_loadappend(redata_t *redata)

 {

+        int fd;

+        struct stat statbuf;

+        static char header[]={UNSAVEDHEADER};

+        long headerhashsize;

+        char *newptr;

+        long nread,lim;

+        if((fd=redata_unsaved_check(redata,redata->filename))==-1)

+                return(-1); /* check failed */

+        if(fstat(fd,&statbuf)!=0 || !S_ISREG(statbuf.st_mode)) {

+                close(fd),fd=-1;

+                return(-1); /* couldn't query size or not regular file */

+        }

+        headerhashsize=(sizeof(header)-1)+1+128+1;

+        /* load unsaved to memory */

+        if(redata->unsaved.sizebuf<(statbuf.st_size-headerhashsize)) {

+                if((newptr=realloc(redata->unsaved.buf,(statbuf.st_size-headerhashsize)))==NULL) {

+                        close(fd),fd=-1;

+                        return(-1); /* insuf. mem. */

+                }

+                redata->unsaved.buf=newptr;

+                redata->unsaved.sizebuf=(statbuf.st_size-headerhashsize);

+        }

+        redata->unsaved.lastsize=0;

+        redata->unsaved.usedbuf=0;

+        lim=(statbuf.st_size-headerhashsize);

+        for(nread=0;redata->unsaved.usedbuf<lim;redata->unsaved.usedbuf+=nread,nread=0) {

+                if((nread=read(fd,redata->unsaved.buf+redata->unsaved.usedbuf,lim-redata->unsaved.usedbuf))<=0) {

+                        redata->unsaved.usedbuf=0;

+                        close(fd),fd=-1;

+                        return(-1); /* short read */

+                }

+        }

+        close(fd),fd=-1;

+        /* process unsaved data */

 #warning TODO

         return(-1);

 }

@@ -511,6 +564,8 @@ redata_unsaved_loadappend(redata_t *redata)

 int

 redata_unsaved_add(redata_t *redata, undo_t *undo)

 {

+        /* separator is '$' , '@'  or '%' (whatever makes the longest string) */

+        /* if len is omitted, then it goes inmediatly after the last op (probably there separator character was used in the string) */

 #warning TODO

         return(-1);

 }

@@ -615,8 +670,8 @@ redata_save(redata_t *redata, char *filename)

                 return(-1); /* couldn't overwrite old file */

         }

         redata_unsaved_unlink(redata);

-        redata->flag_unsaveddata=0;

         redata_hash(redata,redata->initialhash);

+        redata->unsaved.usedbuf=0;

         return(0);

 }

@@ -38,11 +38,18 @@ typedef struct undostack_t {

         int sizeundo;

         int usedundo;

         undo_t *undo;

-        int sizebuf;

-        int usedbuf;

+        long sizebuf;

+        long usedbuf;

         char *buf;

 } undostack_t;

+typedef struct unsaved_t {

+        long sizebuf;

+        long usedbuf;

+        char *buf;

+        long lastsize;

+} unsaved_t;

+

 typedef struct redata_t {

         /* data */

         long chunkdatasize;

@@ -54,11 +61,10 @@ typedef struct redata_t {

         undostack_t undostack;

         undostack_t redostack;

         /* unsaved (for recovery when the program closes unexpectedly) */

-        undostack_t unsavedstack;

         char filename[PATH_MAX];

         char initialhash[129];

         int unsavedfd;

-        int flag_unsaveddata;

+        unsaved_t unsaved;

 } redata_t;

 redata_t *redata_init(void);

@@ -47,7 +47,7 @@ main(int argc, char *argv[])

                 {"newfile_32768",test_newfile,PREFIX "FILE", NULL, 32768, 0},

                 {"newfile_32769",test_newfile,PREFIX "FILE", NULL, 32769, 0},

                 {"newfile_131072",test_newfile,PREFIX "FILE", NULL, 131072, 0},

-                {"testedit_add",test_edit,PREFIX "EDIT", "A,0,$,Testing add$",0,0},

+                {"testedit_add",test_edit,PREFIX "EDIT", "A,0,$Testing add$",0,0},

         };

         redata_t *redata;

         int i;

@@ -186,7 +186,6 @@ if(k!=0) redata_save(redata,"test.pre");

                                 ptr+=(*ptr==',')?1:0;

                                 endcode=*ptr;

                                 ptr+=(*ptr!='\0')?1:0;

-                                ptr+=(*ptr==',')?1:0;

                                 ptrend=strchr(ptr,endcode);

                                 ptrend=(ptrend==NULL)?ptr+strlen(ptr):ptrend;

                                 size=ptrend-ptr;