Undo: unified undo system w/ linear history
[blender.git] / source / blender / blenloader / intern / undofile.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2004 Blender Foundation
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  * .blend file reading entry point
27  */
28
29 /** \file blender/blenloader/intern/undofile.c
30  *  \ingroup blenloader
31  */
32
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <math.h>
37 #include <fcntl.h>
38 #include <errno.h>
39
40 /* open/close */
41 #ifndef _WIN32
42 #  include <unistd.h>
43 #else
44 #  include <io.h>
45 #endif
46
47 #include "MEM_guardedalloc.h"
48
49 #include "DNA_listBase.h"
50
51 #include "BLI_blenlib.h"
52
53 #include "BLO_undofile.h"
54 #include "BLO_readfile.h"
55
56 #include "BKE_main.h"
57
58 /* keep last */
59 #include "BLI_strict_flags.h"
60
61 /* **************** support for memory-write, for undo buffers *************** */
62
63 /* not memfile itself */
64 void BLO_memfile_free(MemFile *memfile)
65 {
66         MemFileChunk *chunk;
67         
68         while ((chunk = BLI_pophead(&memfile->chunks))) {
69                 if (chunk->is_identical == false) {
70                         MEM_freeN((void *)chunk->buf);
71                 }
72                 MEM_freeN(chunk);
73         }
74         memfile->size = 0;
75 }
76
77 /* to keep list of memfiles consistent, 'first' is always first in list */
78 /* result is that 'first' is being freed */
79 void BLO_memfile_merge(MemFile *first, MemFile *second)
80 {
81         MemFileChunk *fc, *sc;
82         
83         fc = first->chunks.first;
84         sc = second->chunks.first;
85         while (fc || sc) {
86                 if (fc && sc) {
87                         if (sc->is_identical) {
88                                 sc->is_identical = false;
89                                 fc->is_identical = true;
90                         }
91                 }
92                 if (fc) fc = fc->next;
93                 if (sc) sc = sc->next;
94         }
95         
96         BLO_memfile_free(first);
97 }
98
99 void memfile_chunk_add(MemFile *compare, MemFile *current, const char *buf, unsigned int size)
100 {
101         static MemFileChunk *compchunk = NULL;
102         MemFileChunk *curchunk;
103         
104         /* this function inits when compare != NULL or when current == NULL  */
105         if (compare) {
106                 compchunk = compare->chunks.first;
107                 return;
108         }
109         if (current == NULL) {
110                 compchunk = NULL;
111                 return;
112         }
113         
114         curchunk = MEM_mallocN(sizeof(MemFileChunk), "MemFileChunk");
115         curchunk->size = size;
116         curchunk->buf = NULL;
117         curchunk->is_identical = false;
118         BLI_addtail(&current->chunks, curchunk);
119         
120         /* we compare compchunk with buf */
121         if (compchunk) {
122                 if (compchunk->size == curchunk->size) {
123                         if (memcmp(compchunk->buf, buf, size) == 0) {
124                                 curchunk->buf = compchunk->buf;
125                                 curchunk->is_identical = true;
126                         }
127                 }
128                 compchunk = compchunk->next;
129         }
130
131         /* not equal... */
132         if (curchunk->buf == NULL) {
133                 char *buf_new = MEM_mallocN(size, "Chunk buffer");
134                 memcpy(buf_new, buf, size);
135                 curchunk->buf = buf_new;
136                 current->size += size;
137         }
138 }
139
140 struct Main *BLO_memfile_main_get(struct MemFile *memfile, struct Main *oldmain, struct Scene **r_scene)
141 {
142         struct Main *bmain_undo = NULL;
143         BlendFileData *bfd = BLO_read_from_memfile(oldmain, oldmain->name, memfile, NULL, BLO_READ_SKIP_NONE);
144
145         if (bfd) {
146                 bmain_undo = bfd->main;
147                 if (r_scene) {
148                         *r_scene = bfd->curscene;
149                 }
150
151                 MEM_freeN(bfd);
152         }
153
154         return bmain_undo;
155 }
156
157
158 /**
159  * Saves .blend using undo buffer.
160  *
161  * \return success.
162  */
163 bool BLO_memfile_write_file(struct MemFile *memfile, const char *filename)
164 {
165         MemFileChunk *chunk;
166         int file, oflags;
167
168         /* note: This is currently used for autosave and 'quit.blend', where _not_ following symlinks is OK,
169          * however if this is ever executed explicitly by the user, we may want to allow writing to symlinks.
170          */
171
172         oflags = O_BINARY | O_WRONLY | O_CREAT | O_TRUNC;
173 #ifdef O_NOFOLLOW
174         /* use O_NOFOLLOW to avoid writing to a symlink - use 'O_EXCL' (CVE-2008-1103) */
175         oflags |= O_NOFOLLOW;
176 #else
177         /* TODO(sergey): How to deal with symlinks on windows? */
178 #  ifndef _MSC_VER
179 #    warning "Symbolic links will be followed on undo save, possibly causing CVE-2008-1103"
180 #  endif
181 #endif
182         file = BLI_open(filename,  oflags, 0666);
183
184         if (file == -1) {
185                 fprintf(stderr, "Unable to save '%s': %s\n",
186                         filename, errno ? strerror(errno) : "Unknown error opening file");
187                 return false;
188         }
189
190         for (chunk = memfile->chunks.first; chunk; chunk = chunk->next) {
191                 if (write(file, chunk->buf, chunk->size) != chunk->size) {
192                         break;
193                 }
194         }
195
196         close(file);
197
198         if (chunk) {
199                 fprintf(stderr, "Unable to save '%s': %s\n",
200                         filename, errno ? strerror(errno) : "Unknown error writing file");
201                 return false;
202         }
203         return true;
204 }