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