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 }