CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.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
22  * \ingroup blenloader
23  */
24
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <math.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 /* open/close */
33 #ifndef _WIN32
34 #  include <unistd.h>
35 #else
36 #  include <io.h>
37 #endif
38
39 #include "MEM_guardedalloc.h"
40
41 #include "DNA_listBase.h"
42
43 #include "BLI_blenlib.h"
44
45 #include "BLO_readfile.h"
46 #include "BLO_undofile.h"
47
48 #include "BKE_main.h"
49
50 /* keep last */
51 #include "BLI_strict_flags.h"
52
53 /* **************** support for memory-write, for undo buffers *************** */
54
55 /* not memfile itself */
56 void BLO_memfile_free(MemFile *memfile)
57 {
58   MemFileChunk *chunk;
59
60   while ((chunk = BLI_pophead(&memfile->chunks))) {
61     if (chunk->is_identical == false) {
62       MEM_freeN((void *)chunk->buf);
63     }
64     MEM_freeN(chunk);
65   }
66   memfile->size = 0;
67 }
68
69 /* to keep list of memfiles consistent, 'first' is always first in list */
70 /* result is that 'first' is being freed */
71 void BLO_memfile_merge(MemFile *first, MemFile *second)
72 {
73   MemFileChunk *fc, *sc;
74
75   fc = first->chunks.first;
76   sc = second->chunks.first;
77   while (fc || sc) {
78     if (fc && sc) {
79       if (sc->is_identical) {
80         sc->is_identical = false;
81         fc->is_identical = true;
82       }
83     }
84     if (fc) {
85       fc = fc->next;
86     }
87     if (sc) {
88       sc = sc->next;
89     }
90   }
91
92   BLO_memfile_free(first);
93 }
94
95 /* Clear is_identical_future before adding next memfile. */
96 void BLO_memfile_clear_future(MemFile *memfile)
97 {
98   LISTBASE_FOREACH (MemFileChunk *, chunk, &memfile->chunks) {
99     chunk->is_identical_future = false;
100   }
101 }
102
103 void memfile_chunk_add(MemFile *memfile, const char *buf, uint size, MemFileChunk **compchunk_step)
104 {
105   MemFileChunk *curchunk = MEM_mallocN(sizeof(MemFileChunk), "MemFileChunk");
106   curchunk->size = size;
107   curchunk->buf = NULL;
108   curchunk->is_identical = false;
109   /* This is unsafe in the sense that an app handler or other code that does not
110    * perform an undo push may make changes after the last undo push that
111    * will then not be undo. Though it's not entirely clear that is wrong behavior. */
112   curchunk->is_identical_future = true;
113   BLI_addtail(&memfile->chunks, curchunk);
114
115   /* we compare compchunk with buf */
116   if (*compchunk_step != NULL) {
117     MemFileChunk *compchunk = *compchunk_step;
118     if (compchunk->size == curchunk->size) {
119       if (memcmp(compchunk->buf, buf, size) == 0) {
120         curchunk->buf = compchunk->buf;
121         curchunk->is_identical = true;
122         compchunk->is_identical_future = true;
123       }
124     }
125     *compchunk_step = compchunk->next;
126   }
127
128   /* not equal... */
129   if (curchunk->buf == NULL) {
130     char *buf_new = MEM_mallocN(size, "Chunk buffer");
131     memcpy(buf_new, buf, size);
132     curchunk->buf = buf_new;
133     memfile->size += size;
134   }
135 }
136
137 struct Main *BLO_memfile_main_get(struct MemFile *memfile,
138                                   struct Main *oldmain,
139                                   struct Scene **r_scene)
140 {
141   struct Main *bmain_undo = NULL;
142   BlendFileData *bfd = BLO_read_from_memfile(oldmain,
143                                              BKE_main_blendfile_path(oldmain),
144                                              memfile,
145                                              &(const struct BlendFileReadParams){0},
146                                              NULL);
147
148   if (bfd) {
149     bmain_undo = bfd->main;
150     if (r_scene) {
151       *r_scene = bfd->curscene;
152     }
153
154     MEM_freeN(bfd);
155   }
156
157   return bmain_undo;
158 }
159
160 /**
161  * Saves .blend using undo buffer.
162  *
163  * \return success.
164  */
165 bool BLO_memfile_write_file(struct MemFile *memfile, const char *filename)
166 {
167   MemFileChunk *chunk;
168   int file, oflags;
169
170   /* note: This is currently used for autosave and 'quit.blend',
171    * where _not_ following symlinks is OK,
172    * however if this is ever executed explicitly by the user,
173    * we may want to allow writing to symlinks.
174    */
175
176   oflags = O_BINARY | O_WRONLY | O_CREAT | O_TRUNC;
177 #ifdef O_NOFOLLOW
178   /* use O_NOFOLLOW to avoid writing to a symlink - use 'O_EXCL' (CVE-2008-1103) */
179   oflags |= O_NOFOLLOW;
180 #else
181   /* TODO(sergey): How to deal with symlinks on windows? */
182 #  ifndef _MSC_VER
183 #    warning "Symbolic links will be followed on undo save, possibly causing CVE-2008-1103"
184 #  endif
185 #endif
186   file = BLI_open(filename, oflags, 0666);
187
188   if (file == -1) {
189     fprintf(stderr,
190             "Unable to save '%s': %s\n",
191             filename,
192             errno ? strerror(errno) : "Unknown error opening file");
193     return false;
194   }
195
196   for (chunk = memfile->chunks.first; chunk; chunk = chunk->next) {
197     if ((size_t)write(file, chunk->buf, chunk->size) != chunk->size) {
198       break;
199     }
200   }
201
202   close(file);
203
204   if (chunk) {
205     fprintf(stderr,
206             "Unable to save '%s': %s\n",
207             filename,
208             errno ? strerror(errno) : "Unknown error writing file");
209     return false;
210   }
211   return true;
212 }