@@ -1,2 +1,3 @@

 *.o

 re

+tests

@@ -2,11 +2,13 @@ CC=gcc

 CFLAGS=-g -Wall -Ideps -I/usr/include/SDL2

 LDFLAGS=-lSDL2 -lSDL2_image

-all: re

+all: re tests

+

+recenteditor.o: recenteditor.c recenteditor_data.h

 recenteditor_data.o: recenteditor_data.c recenteditor_data.h

-recenteditor.o: recenteditor.c recenteditor_data.h

+recenteditor_tests.o: recenteditor_tests.c recenteditor_data.h

 sha3.o: sha3/sha3.c sha3/sha3.h

 	$(CC) $(CFLAGS) -Isha3 -c -o sha3.o sha3/sha3.c

@@ -14,5 +16,8 @@ sha3.o: sha3/sha3.c sha3/sha3.h

 re: recenteditor.o recenteditor_data.o sha3.o

 	$(CC) $(LDFLAGS) -o re recenteditor.o recenteditor_data.o sha3.o

+tests: recenteditor_tests.o recenteditor_data.o sha3.o

+	$(CC) $(LDFLAGS) -o tests recenteditor_tests.o recenteditor_data.o sha3.o

+

 clean:

 	rm -f recenteditor.o recenteditor_data.o sha3.o re

@@ -23,12 +23,19 @@

 #include "sha3/sha3.h"

 #define CHUNKSIZE 32768

+#define UNDOBLOCK 1024

+#define UNDOGROWSIZE (256*1024)

 #define UNSAVEDPREFIX "."

 #define UNSAVEDPOSTFIX ".reu"

-

+#define SECURESAVEPREFIX "."

+#define SECURESAVEPOSTFIX ".saving"

+#define UNSAVEDHEADER "REUNSAV\n"

+#define UNSAVEDVERSION "\n000001\0"

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

 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);

 redata_t *

 redata_init(void)

@@ -49,6 +56,7 @@ redata_init(void)

         redata->undo=NULL;

         redata->undobuf=NULL;

         /* unsaved */

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

         redata->unsavedfd=-1;

         redata->flag_unsaveddata=0;

         /* all done */

@@ -59,6 +67,7 @@ void

 redata_free(redata_t *redata)

 {

         int i;

+        char unsname[PATH_MAX];

         if(redata==NULL)

                 return; /* nothing to do */

         /* data */

@@ -75,15 +84,12 @@ redata_free(redata_t *redata)

         if(redata->undobuf!=NULL)

                 free(redata->undobuf),redata->undobuf=NULL;

         /* unsaved */

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

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

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

-        if(redata->unsavedfilename!=NULL) {

-                if(redata->unsavedfilename[0]!='\0') {

-                        /* remove the file, if here, the user has validated exiting without saving */

-                        unlink(redata->unsavedfilename);

-                }

-                free(redata->unsavedfilename),redata->unsavedfilename=NULL;

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

+                        unlink(unsname);

         }

+        redata->flag_unsaveddata=0;

         /* free main struct */

         free(redata),redata=NULL;

         return;

@@ -98,25 +104,48 @@ redata_getsize(redata_t *redata)

 }

 int

-redata_getused(redata_t *redata)

+redata_getavailable(redata_t *redata)

 {

         if(redata==NULL)

                 return(0); /* sanity check failed */

-        return(redata_getsize(redata)-redata_getavailable(redata));

+        return(redata->available);

 }

 int

-redata_getavailable(redata_t *redata)

+redata_getused(redata_t *redata)

 {

+        int used;

         if(redata==NULL)

                 return(0); /* sanity check failed */

-        return(redata->available);

+        used=redata->chunkdatasize*redata->sizechunks-redata->available;

+        return(used);

+}

+

+int

+redata_getposptr(redata_t *redata, int pos, int *numchunk, int *offset)

+{

+        int used;

+        int i;

+        int ipos;

+        used=redata_getused(redata);

+        if(redata==NULL || pos<0 || pos>used || numchunk==NULL || offset==NULL)

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

+        for(ipos=0,i=0;i<redata->sizechunks;ipos+=redata->chunks[i]->useddata,i++) {

+                if(pos>(ipos+redata->chunks[i]->useddata))

+                        continue;

+                /* found */

+                *numchunk=i;

+                *offset=pos-ipos;

+                return(0);

+        }

+        return(-1);

 }

 int

 redata_wipe(redata_t *redata)

 {

         int i;

+        char unsname[PATH_MAX];

         if(redata==NULL)

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

         /* data */

@@ -126,16 +155,13 @@ redata_wipe(redata_t *redata)

         }

         redata->available=redata_getsize(redata);

         /* unsaved */

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

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

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

-        if(redata->unsavedfilename!=NULL) {

-                if(redata->unsavedfilename[0]!='\0') {

-                        /* remove the file, if here, the user has validated exiting without saving */

-                        unlink(redata->unsavedfilename);

-                }

-                free(redata->unsavedfilename),redata->unsavedfilename=NULL;

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

+                        unlink(unsname);

         }

         redata->flag_unsaveddata=0;

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

         /* all done */

         return(0);

 }

@@ -195,8 +221,10 @@ redata_unsaved_exists(redata_t *redata, char *filename)

 {

         char unsname[PATH_MAX+1];

         int fd;

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

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

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

-                return(-1);

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

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

                 return(-1);

         close(fd),fd=-1;

@@ -206,25 +234,84 @@ redata_unsaved_exists(redata_t *redata, char *filename)

 int

 redata_unsaved_check(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];

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

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

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

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

+        if(redata_filehash(redata,filename,filehash)!=0)

+                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) {

+                close(fd),fd=-1;

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

+        }

+        if((nread=read(fd,undohash,128))==-1 || nread!=128 || memcmp(undohash,filehash,128)!=0) {

+                close(fd),fd=-1;

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

+        }

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

+                close(fd),fd=-1;

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

+        }

+        close(fd),fd=-1;

+        return(0);

+}

-#warning TODO

-        return(-1);

+

+int

+redata_unsaved_unlink(redata_t *redata)

+{

+        char unsname[PATH_MAX+1];

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

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

+        if(redata_unsaved_exists(redata,redata->filename)==-1)

+                return(0); /* file not found, nothing to unlink */

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

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

+        unlink(unsname);

+        return(0);

 }

+

+

 int

-redata_unsaved_loadappend(redata_t *redata, char *filename)

+redata_unsaved_trunc(redata_t *redata)

 {

-#warning TODO

-        return(-1);

+        char unsname[PATH_MAX+1];

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

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

+        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=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) {

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

+                unlink(unsname);

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

+        }

+        return(0);

 }

 int

-redata_unsaved_trunc(redata_t *redata, char *filename)

+redata_unsaved_loadappend(redata_t *redata)

 {

 #warning TODO

         return(-1);

 }

+

 int

 redata_unsaved_add(redata_t *redata, undo_t *undo)

 {

@@ -242,12 +329,16 @@ redata_unsaved_unadd(redata_t *redata, undo_t *undo)

 int

 redata_load(redata_t *redata, char *filename, int use_unsaved)

 {

-#warning TODO: use_unsaved (apply unsaved changes after load)

+#warning TODO: make sure a line of len<chunksize is entirely inside one chunk (to simplify the syntax highlighting code)

         int fd,nread,totalread;

         int chunkno, avail;

         struct stat statbuf;

         rechunk_t *chunk;

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

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

         redata_wipe(redata);

+        strncpy(redata->filename,filename,sizeof(redata->filename));

+        redata->filename[sizeof(redata->filename)-1]='\0';

         if((fd=open(filename,O_RDONLY))==-1 || fstat(fd,&statbuf)!=0 || !S_ISREG(statbuf.st_mode)) {

                 if(fd!=-1)

                         close(fd),fd=-1;

@@ -287,12 +378,13 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

         }

         close(fd),fd=-1;

         /* unsaved */

+        redata_hash(redata,redata->initialhash);

         if(use_unsaved) {

                 /* apply missing changes and append new changes to unsaved */

-                redata_unsaved_loadappend(redata,filename);

+                redata_unsaved_loadappend(redata);

         } else {

                 /* nuke existing unsaved (if exists) and prepare new unsaved */

-                redata_unsaved_trunc(redata,filename);

+                redata_unsaved_trunc(redata);

         }

         /* all done */

         return(0);

@@ -301,13 +393,143 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

 int

 redata_save(redata_t *redata, char *filename)

 {

-#warning TODO

-        return(-1);

+        int fd;

+        int i,n;

+        char tmpfile[PATH_MAX+1];

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

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

+        if((securesave_genname(redata->filename,tmpfile,sizeof(tmpfile)))==NULL)

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

+        if((fd=open(tmpfile,O_WRONLY|O_TRUNC|O_CREAT,0644))==-1)

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

+        for(i=0;i<redata->sizechunks;i++) {

+                if(redata->chunks[i]->useddata==0)

+                        continue;

+                if((n=write(fd,redata->chunks[i]->data,redata->chunks[i]->useddata))==-1 || n!=redata->chunks[i]->useddata) {

+                        close(fd),fd=-1;

+                        unlink(tmpfile);

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

+                }

+        }

+        close(fd),fd=-1;

+        if(rename(tmpfile,filename)!=0) {

+                unlink(tmpfile);

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

+        }

+        redata_unsaved_unlink(redata);

+        redata->flag_unsaveddata=0;

+        redata_hash(redata,redata->initialhash);

+        return(0);

+}

+

+int

+redata_undobuf_reserve(redata_t *redata, int minavail)

+{

+        int unused;

+        int newsize;

+        char *newptr;

+        if(redata==NULL || minavail<0)

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

+        unused=redata->sizeundobuf-redata->usedundobuf;

+        if(unused<minavail) {

+                newsize=(redata->sizeundobuf+minavail+UNDOGROWSIZE-1)/UNDOGROWSIZE;

+                newsize*=UNDOGROWSIZE;

+                if((newptr=realloc(redata->undobuf,newsize))==NULL)

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

+                redata->undobuf=newptr;

+                redata->sizeundobuf=newsize;

+        }

+        return(0);

+}

+

+undo_t *

+redata_undo_new(redata_t *redata, char *type)

+{

+        int newsize;

+        undo_t *newptr,*undo;

+        if(redata==NULL || type==NULL)

+                return(NULL); /* sanity check failed */

+        if(redata->sizeundo==redata->usedundo) {

+                newsize=(redata->sizeundo+1+UNDOBLOCK-1)/UNDOBLOCK;

+                newsize*=UNDOBLOCK;

+                if((newptr=realloc(redata->undo,sizeof(undo_t)*newsize))==NULL)

+                        return(NULL);

+                redata->undo=newptr;

+                memset(redata->undo+redata->sizeundo,0,sizeof(undo_t)*(newsize-redata->sizeundo));

+                redata->sizeundo=newsize;

+        }

+        undo=redata->undo+redata->usedundo;

+        redata->usedundo++;

+        strncpy(undo->type,type,sizeof(undo->type));

+        undo->type[sizeof(undo->type)-1]='\0';

+        undo->off=redata->usedundobuf;

+        undo->len=0;

+        return(undo);

+}

+

+undo_t *

+redata_undo_newfromchunks(redata_t *redata,char *type, int pos1, int len)

+{

+        int startpos,startoff,endpos,endoff;

+        undo_t *undo;

+        int k;

+        int used;

+        int copyfrom,copysize;

+        if(redata==NULL || type==NULL || len<=0)

+                return(NULL); /* sanity check failed */

+        if(redata_getposptr(redata,pos1,&startpos,&startoff)==-1 ||

+          redata_getposptr(redata,pos1+len,&endpos,&endoff)==-1) {

+                return(NULL); /* chunk data out of bounds */

+        }

+        if(redata_undobuf_reserve(redata,len)!=0)

+                return(NULL); /* insuf. mem. */

+        if((undo=redata_undo_new(redata,type))==NULL)

+                return(NULL); /* insuf. mem. */

+        undo->off=redata->usedundobuf;

+        /* copy contents */

+        for(k=startpos,used=0;k<=endpos;k++) {

+                if(k==startpos && k==endpos) {

+                        copyfrom=startoff;

+                        copysize=endoff-startoff;

+                } else if(k==startpos) {

+                        copyfrom=startoff;

+                        copysize=redata->chunks[k]->useddata-startoff;

+                } else if(k==endpos) {

+                        copyfrom=0;

+                        copysize=endoff;

+                } else {

+                        copyfrom=0;

+                        copysize=redata->chunks[k]->useddata;

+                }

+                memcpy(redata->undobuf+redata->usedundobuf,redata->chunks[k]->data+copyfrom,copysize);

+                redata->usedundobuf+=copysize;

+                used+=copysize;

+        }

+        undo->len=used;

+        return(undo);

+}

+

+undo_t *

+redata_undobuf_newfrombuf(redata_t *redata, char *type, char *buf, int buflen)

+{

+        undo_t *undo;

+        if(redata==NULL || type==NULL || buflen<=0)

+                return(NULL); /* sanity check failed */

+        if(redata_undobuf_reserve(redata,buflen)!=0)

+                return(NULL); /* insuf. mem. */

+        if((undo=redata_undo_new(redata,type))==NULL)

+                return(NULL); /* insuf. mem. */

+        undo->off=redata->usedundobuf;

+        memcpy(redata->undobuf+redata->usedundobuf,buf,buflen);

+        redata->usedundobuf+=buflen;

+        undo->len=buflen;

+        return(undo);

 }

 int

 redata_op_add(redata_t *redata, char *buf, int sizebuf, int pos)

 {

+

 #warning TODO

         return(-1);

 }

@@ -326,6 +548,20 @@ redata_op_move(redata_t *redata, int posorig, int size, int posdest)

         return(-1);

 }

+int

+redata_op_undo(redata_t *redata)

+{

+#warning TODO

+        return(-1);

+}

+

+int

+redata_op_redo(redata_t *redata)

+{

+#warning TODO

+        return(-1);

+}

+

 int

 redata_hash(redata_t *redata, char *resbuf129bytes)

 {

@@ -395,17 +631,34 @@ redata_hash_gen(redata_t *redata, char *filename, char *resbuf129bytes)

 static char *

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

 {

-        char *name,*ptr;

-        int filenamelen;

-        int len,off;

         static char pre[]={UNSAVEDPREFIX};

         static char post[]={UNSAVEDPOSTFIX};

-        if(filename==NULL)

+        return(genname(filename,pre,post,buf,bufsize));

+}

+

+static char *

+securesave_genname(char *filename, char *buf, int bufsize)

+{

+        static char pre[]={SECURESAVEPREFIX};

+        static char post[]={SECURESAVEPOSTFIX};

+        return(genname(filename,pre,post,buf,bufsize));

+}

+

+

+static char *

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

+{

+        char *name,*ptr;

+        int filenamelen;

+        int prelen,postlen,finallen,off;

+        if(filename==NULL || prefix==NULL || postfix==NULL)

                 return(NULL);

         filenamelen=strlen(filename);

-        len=filenamelen+sizeof(pre)-1+sizeof(post)-1+1;

+        prelen=strlen(prefix);

+        postlen=strlen(postfix);

+        finallen=filenamelen+prelen+postlen+1;

         if(buf==NULL) {

-                if((name=malloc(len))==NULL)

+                if((name=malloc(finallen))==NULL)

                         return(NULL);

         } else {

                 if(bufsize<filenamelen)

@@ -417,13 +670,14 @@ unsaved_genname(char *filename, char *buf, int bufsize)

         off=0;

         memcpy(name+off,filename,ptr-filename);

         off+=ptr-filename;

-        memcpy(name+off,pre,sizeof(pre)-1);

-        off+=sizeof(pre)-1;

+        memcpy(name+off,prefix,prelen);

+        off+=prelen;

         memcpy(name+off,ptr,filenamelen-(ptr-filename));

         off+=filenamelen-(ptr-filename);

-        memcpy(name+off,post,sizeof(post)-1);

-        off+=sizeof(post)-1;

+        memcpy(name+off,postfix,postlen);

+        off+=postlen;

         name[off]='\0';

         return(name);

 }

+

@@ -11,6 +11,8 @@

  * This program is licensed under the terms of GNU GPL v2.1+

  */

+#include <limits.h>

+

 typedef struct whatin_t {

         int nlcount;

 } whatin_t;

@@ -22,7 +24,9 @@ typedef struct rechunk_t {

 } rechunk_t;

 typedef struct undo_t {

-

+        char type[5];

+        int off;

+        int len;

 } undo_t;

 typedef struct redata_t {

@@ -36,9 +40,12 @@ typedef struct redata_t {

         int usedundo;

         int curundo;

         undo_t *undo;

+        int sizeundobuf;

+        int usedundobuf;

         char *undobuf;

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

-        char *unsavedfilename;

+        char filename[PATH_MAX];

+        char initialhash[129];

         int unsavedfd;

         int flag_unsaveddata;

 } redata_t;

@@ -51,6 +58,10 @@ void redata_free(redata_t *redata);

 int redata_getsize(redata_t *redata);

 int redata_getused(redata_t *redata);

 int redata_getavailable(redata_t *redata);

+int redata_getused(redata_t *redata);

+int redata_getposptr(redata_t *redata, int pos, int *numchunk, int *offset);

+

+

 int redata_wipe(redata_t *redata);

 int redata_preallocate(redata_t *redata, int size);

@@ -58,8 +69,9 @@ int redata_fill_whatin(redata_t *redata, int chunkno);

 int redata_unsaved_exists(redata_t *redata, char *filename);

 int redata_unsaved_check(redata_t *redata, char *filename);

-int redata_unsaved_loadappend(redata_t *redata, char *filename);

-int redata_unsaved_trunc(redata_t *redata, char *filename);

+int redata_unsaved_loadappend(redata_t *redata);

+int redata_unsaved_unlink(redata_t *redata);

+int redata_unsaved_trunc(redata_t *redata);

 int redata_unsaved_add(redata_t *redata, undo_t *undo);

 int redata_unsaved_unadd(redata_t *redata, undo_t *undo);

@@ -70,7 +82,7 @@ int redata_op_add(redata_t *redata, char *buf, int sizebuf, int pos);

 int redata_op_del(redata_t *redata, int pos, int size);

 int redata_op_move(redata_t *redata, int posorig, int size, int posdest);

 int redata_op_undo(redata_t *redata);

-int redata_op_redor(redata_t *redata);

+int redata_op_redo(redata_t *redata);

 int redata_hash(redata_t *redata, char *resbuf129bytes);

 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);

new file mode 100644

@@ -0,0 +1,32 @@

+/*

+ * recenteditor_data.c

+ *

+ * A programmers editor

+ *

+ * Tests (ensure correct functionality of modules)

+ *

+ * Author: Dario Rodriguez dario@softhome.net

+ * This program is licensed under the terms of GNU GPL v2.1+

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <unistd.h>

+#include <string.h>

+#include <limits.h>

+

+#include "recenteditor_data.h"

+

+int

+main(int argc, char *argv[])

+{

+        redata_t *redata;

+        if((redata=redata_init())==NULL) {

+                fprintf(stderr,"ERROR: problem initializong redata module\n");

+                return(1);

+        }

+#warning TODO

+        redata_free(redata),redata=NULL;

+}

+

+