Merging r58475 through r58700 from trunk into soc-2013-depsgraph_mt
[blender.git] / source / blender / blenlib / intern / fileops.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) 2001-2002 by NaN Holding BV.
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  */
27
28 /** \file blender/blenlib/intern/fileops.c
29  *  \ingroup bli
30  */
31
32
33 #include <stdlib.h>  /* malloc */
34 #include <string.h>
35
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <fcntl.h>
39
40 #include <errno.h>
41
42 #include "zlib.h"
43
44 #ifdef WIN32
45 #  ifdef __MINGW32__
46 #    include <ctype.h>
47 #  endif
48 #  include <io.h>
49 #  include "BLI_winstuff.h"
50 #  include "BLI_callbacks.h"
51 #  include "utf_winfunc.h"
52 #  include "utfconv.h"
53 #else
54 #  include <unistd.h> // for read close
55 #  include <sys/param.h>
56 #  include <dirent.h>
57 #  include <unistd.h>
58 #  include <sys/stat.h>
59 #endif
60
61 #include "MEM_guardedalloc.h"
62
63 #include "BLI_utildefines.h"
64 #include "BLI_listbase.h"
65 #include "BLI_string.h"
66 #include "BLI_path_util.h"
67 #include "BLI_fileops.h"
68 #include "BLI_sys_types.h" // for intptr_t support
69
70
71 /* gzip the file in from and write it to "to". 
72  * return -1 if zlib fails, -2 if the originating file does not exist
73  * note: will remove the "from" file
74  */
75 int BLI_file_gzip(const char *from, const char *to)
76 {
77         char buffer[10240];
78         int file;
79         int readsize = 0;
80         int rval = 0, err;
81         gzFile gzfile;
82
83         /* level 1 is very close to 3 (the default) in terms of file size,
84          * but about twice as fast, best use for speedy saving - campbell */
85         gzfile = BLI_gzopen(to, "wb1");
86         if (gzfile == NULL)
87                 return -1;
88         file = BLI_open(from, O_BINARY | O_RDONLY, 0);
89         if (file < 0)
90                 return -2;
91
92         while (1) {
93                 readsize = read(file, buffer, sizeof(buffer));
94
95                 if (readsize < 0) {
96                         rval = -2; /* error happened in reading */
97                         fprintf(stderr, "Error reading file %s: %s.\n", from, strerror(errno));
98                         break;
99                 }
100                 else if (readsize == 0)
101                         break;  /* done reading */
102                 
103                 if (gzwrite(gzfile, buffer, readsize) <= 0) {
104                         rval = -1; /* error happened in writing */
105                         fprintf(stderr, "Error writing gz file %s: %s.\n", to, gzerror(gzfile, &err));
106                         break;
107                 }
108         }
109         
110         gzclose(gzfile);
111         close(file);
112
113         return rval;
114 }
115
116 /* gzip the file in from_file and write it to memory to_mem, at most size bytes.
117  * return the unziped size
118  */
119 char *BLI_file_ungzip_to_mem(const char *from_file, int *size_r)
120 {
121         gzFile gzfile;
122         int readsize, size, alloc_size = 0;
123         char *mem = NULL;
124         const int chunk_size = 512 * 1024;
125
126         size = 0;
127
128         gzfile = BLI_gzopen(from_file, "rb");
129         for (;; ) {
130                 if (mem == NULL) {
131                         mem = MEM_callocN(chunk_size, "BLI_ungzip_to_mem");
132                         alloc_size = chunk_size;
133                 }
134                 else {
135                         mem = MEM_reallocN(mem, size + chunk_size);
136                         alloc_size += chunk_size;
137                 }
138
139                 readsize = gzread(gzfile, mem + size, chunk_size);
140                 if (readsize > 0) {
141                         size += readsize;
142                 }
143                 else {
144                         break;
145                 }
146         }
147         
148         gzclose(gzfile);
149
150         if (size == 0) {
151                 MEM_freeN(mem);
152                 mem = NULL;
153         }
154         else if (alloc_size != size)
155                 mem = MEM_reallocN(mem, size);
156
157         *size_r = size;
158
159         return mem;
160 }
161
162 /**
163  * Returns true if the file with the specified name can be written.
164  * This implementation uses access(2), which makes the check according
165  * to the real UID and GID of the process, not its effective UID and GID.
166  * This shouldn't matter for Blender, which is not going to run privileged
167  * anyway.
168  */
169 bool BLI_file_is_writable(const char *filename)
170 {
171         bool writable;
172         if (BLI_access(filename, W_OK) == 0) {
173                 /* file exists and I can write to it */
174                 writable = true;
175         }
176         else if (errno != ENOENT) {
177                 /* most likely file or containing directory cannot be accessed */
178                 writable = false;
179         }
180         else {
181                 /* file doesn't exist -- check I can create it in parent directory */
182                 char parent[FILE_MAX];
183                 BLI_split_dirfile(filename, parent, NULL, sizeof(parent), 0);
184 #ifdef WIN32
185                 /* windows does not have X_OK */
186                 writable = BLI_access(parent, W_OK) == 0;
187 #else
188                 writable = BLI_access(parent, X_OK | W_OK) == 0;
189 #endif
190         }
191         return writable;
192 }
193
194 /**
195  * Creates the file with nothing in it, or updates its last-modified date if it already exists.
196  * Returns true if successful. (like the unix touch command)
197  */
198 bool BLI_file_touch(const char *file)
199 {
200         FILE *f = BLI_fopen(file, "r+b");
201         if (f != NULL) {
202                 int c = getc(f);
203                 rewind(f);
204                 putc(c, f);
205         }
206         else {
207                 f = BLI_fopen(file, "wb");
208         }
209         if (f) {
210                 fclose(f);
211                 return true;
212         }
213         return false;
214 }
215
216 #ifdef WIN32
217
218 static char str[MAXPATHLEN + 12];
219
220 FILE *BLI_fopen(const char *filename, const char *mode)
221 {
222         return ufopen(filename, mode);
223 }
224
225 void BLI_get_short_name(char short_name[256], const char *filename)
226 {
227         wchar_t short_name_16[256];
228         int i = 0;
229
230         UTF16_ENCODE(filename);
231
232         GetShortPathNameW(filename_16, short_name_16, 256);
233
234         for (i = 0; i < 256; i++) {
235                 short_name[i] = (char)short_name_16[i];
236         }
237
238         UTF16_UN_ENCODE(filename);
239 }
240
241 void *BLI_gzopen(const char *filename, const char *mode)
242 {
243         gzFile gzfile;
244
245         if (!filename || !mode) {
246                 return 0;
247         }
248         else {
249                 /* xxx Creates file before transcribing the path */
250                 if (mode[0] == 'w')
251                         fclose(ufopen(filename, "a"));
252
253                 /* temporary #if until we update all libraries to 1.2.7
254                  * for correct wide char path handling */
255 #if ZLIB_VERNUM >= 0x1270 && !defined(FREE_WINDOWS)
256                 UTF16_ENCODE(filename);
257
258                 gzfile = gzopen_w(filename_16, mode);
259
260                 UTF16_UN_ENCODE(filename);
261 #else
262                 {
263                         char short_name[256];
264                         BLI_get_short_name(short_name, filename);
265                         gzfile = gzopen(short_name, mode);
266                 }
267 #endif
268         }
269
270         return gzfile;
271 }
272
273 int   BLI_open(const char *filename, int oflag, int pmode)
274 {
275         return uopen(filename, oflag, pmode);
276 }
277
278 int   BLI_access(const char *filename, int mode)
279 {
280         return uaccess(filename, mode);
281 }
282
283 int BLI_delete(const char *file, bool dir, bool recursive)
284 {
285         int err;
286         
287         UTF16_ENCODE(file);
288
289         if (recursive) {
290                 callLocalErrorCallBack("Recursive delete is unsupported on Windows");
291                 err = 1;
292         }
293         else if (dir) {
294                 err = !RemoveDirectoryW(file_16);
295                 if (err) printf("Unable to remove directory");
296         }
297         else {
298                 err = !DeleteFileW(file_16);
299                 if (err) callLocalErrorCallBack("Unable to delete file");
300         }
301
302         UTF16_UN_ENCODE(file);
303
304         return err;
305 }
306
307 /* Not used anywhere! */
308 #if 0
309 int BLI_move(const char *file, const char *to)
310 {
311         int err;
312
313         /* windows doesn't support moving to a directory
314          * it has to be 'mv filename filename' and not
315          * 'mv filename destdir' */
316
317         BLI_strncpy(str, to, sizeof(str));
318         /* points 'to' to a directory ? */
319         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
320                 if (BLI_last_slash(file) != NULL) {
321                         strcat(str, BLI_last_slash(file) + 1);
322                 }
323         }
324         
325         UTF16_ENCODE(file);
326         UTF16_ENCODE(str);
327         err = !MoveFileW(file_16, str_16);
328         UTF16_UN_ENCODE(str);
329         UTF16_UN_ENCODE(file);
330
331         if (err) {
332                 callLocalErrorCallBack("Unable to move file");
333                 printf(" Move from '%s' to '%s' failed\n", file, str);
334         }
335
336         return err;
337 }
338 #endif
339
340 int BLI_copy(const char *file, const char *to)
341 {
342         int err;
343
344         /* windows doesn't support copying to a directory
345          * it has to be 'cp filename filename' and not
346          * 'cp filename destdir' */
347
348         BLI_strncpy(str, to, sizeof(str));
349         /* points 'to' to a directory ? */
350         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
351                 if (BLI_last_slash(file) != NULL) {
352                         strcat(str, BLI_last_slash(file) + 1);
353                 }
354         }
355
356         UTF16_ENCODE(file);
357         UTF16_ENCODE(str);
358         err = !CopyFileW(file_16, str_16, FALSE);
359         UTF16_UN_ENCODE(str);
360         UTF16_UN_ENCODE(file);
361
362         if (err) {
363                 callLocalErrorCallBack("Unable to copy file!");
364                 printf(" Copy from '%s' to '%s' failed\n", file, str);
365         }
366
367         return err;
368 }
369
370 int BLI_create_symlink(const char *file, const char *to)
371 {
372         callLocalErrorCallBack("Linking files is unsupported on Windows");
373         (void)file;
374         (void)to;
375         return 1;
376 }
377
378 void BLI_dir_create_recursive(const char *dirname)
379 {
380         char *lslash;
381         char tmp[MAXPATHLEN];
382
383         /* First remove possible slash at the end of the dirname.
384          * This routine otherwise tries to create
385          * blah1/blah2/ (with slash) after creating
386          * blah1/blah2 (without slash) */
387
388         BLI_strncpy(tmp, dirname, sizeof(tmp));
389         lslash = (char *)BLI_last_slash(tmp);
390
391         if (lslash && (*(lslash + 1) == '\0')) {
392                 *lslash = '\0';
393         }
394
395         /* check special case "c:\foo", don't try create "c:", harmless but prints an error below */
396         if (isalpha(tmp[0]) && (tmp[1] == ':') && tmp[2] == '\0') return;
397
398         if (BLI_exists(tmp)) return;
399
400         lslash = (char *)BLI_last_slash(tmp);
401
402         if (lslash) {
403                 /* Split about the last slash and recurse */
404                 *lslash = 0;
405                 BLI_dir_create_recursive(tmp);
406         }
407
408         if (dirname[0]) {  /* patch, this recursive loop tries to create a nameless directory */
409                 if (umkdir(dirname) == -1) {
410                         printf("Unable to create directory %s\n", dirname);
411                 }
412         }
413 }
414
415 int BLI_rename(const char *from, const char *to)
416 {
417         if (!BLI_exists(from)) return 0;
418
419         /* make sure the filenames are different (case insensitive) before removing */
420         if (BLI_exists(to) && BLI_strcasecmp(from, to))
421                 if (BLI_delete(to, false, false)) return 1;
422         
423         return urename(from, to);
424 }
425
426 #else /* The UNIX world */
427
428 /* results from recursive_operation and its callbacks */
429 enum {
430         /* operation succeeded */
431         RecursiveOp_Callback_OK = 0,
432
433         /* operation requested not to perform recursive digging for current path */
434         RecursiveOp_Callback_StopRecurs = 1,
435
436         /* error occured in callback and recursive walking should stop immediately */
437         RecursiveOp_Callback_Error = 2
438 };
439
440 typedef int (*RecursiveOp_Callback)(const char *from, const char *to);
441
442 /* appending of filename to dir (ensures for buffer size before appending) */
443 static void join_dirfile_alloc(char **dst, size_t *alloc_len, const char *dir, const char *file)
444 {
445         size_t len = strlen(dir) + strlen(file) + 1;
446
447         if (*dst == NULL)
448                 *dst = MEM_mallocN(len + 1, "join_dirfile_alloc path");
449         else if (*alloc_len < len)
450                 *dst = MEM_reallocN(*dst, len + 1);
451
452         *alloc_len = len;
453
454         BLI_join_dirfile(*dst, len + 1, dir, file);
455 }
456
457 static char *strip_last_slash(const char *dir)
458 {
459         char *result = BLI_strdup(dir);
460         BLI_del_slash(result);
461
462         return result;
463 }
464
465
466
467 /**
468  * Scans \a startfrom, generating a corresponding destination name for each item found by
469  * prefixing it with startto, recursively scanning subdirectories, and invoking the specified
470  * callbacks for files and subdirectories found as appropriate.
471  *
472  * \param startfrom  Top-level source path.
473  * \param startto  Top-level destination path.
474  * \param callback_dir_pre  Optional, to be invoked before entering a subdirectory, can return
475  *                          RecursiveOp_Callback_StopRecurs to skip the subdirectory.
476  * \param callback_file  Optional, to be invoked on each file found.
477  * \param callback_dir_post  optional, to be invoked after leaving a subdirectory.
478  * \return
479  */
480 static int recursive_operation(const char *startfrom, const char *startto,
481                                RecursiveOp_Callback callback_dir_pre,
482                                RecursiveOp_Callback callback_file, RecursiveOp_Callback callback_dir_post)
483 {
484         struct stat st;
485         char *from = NULL, *to = NULL;
486         char *from_path = NULL, *to_path = NULL;
487         struct dirent **dirlist = NULL;
488         size_t from_alloc_len = -1, to_alloc_len = -1;
489         int i, n, ret = 0;
490
491         do {  /* once */
492                 /* ensure there's no trailing slash in file path */
493                 from = strip_last_slash(startfrom);
494                 if (startto)
495                         to = strip_last_slash(startto);
496
497                 ret = lstat(from, &st);
498                 if (ret < 0)
499                         /* source wasn't found, nothing to operate with */
500                         break;
501
502                 if (!S_ISDIR(st.st_mode)) {
503                         /* source isn't a directory, can't do recursive walking for it,
504                          * so just call file callback and leave */
505                         if (callback_file != NULL) {
506                                 ret = callback_file(from, to);
507                                 if (ret != RecursiveOp_Callback_OK)
508                                         ret = -1;
509                         }
510                         break;
511                 }
512
513                 n = scandir(startfrom, &dirlist, NULL, alphasort);
514                 if (n < 0) {
515                         /* error opening directory for listing */
516                         perror("scandir");
517                         ret = -1;
518                         break;
519                 }
520
521                 if (callback_dir_pre != NULL) {
522                         ret = callback_dir_pre(from, to);
523                         if (ret != RecursiveOp_Callback_OK) {
524                                 if (ret == RecursiveOp_Callback_StopRecurs)
525                                         /* callback requested not to perform recursive walking, not an error */
526                                         ret = 0;
527                                 else
528                                         ret = -1;
529                                 break;
530                         }
531                 }
532
533                 for (i = 0; i < n; i++) {
534                         const struct dirent * const dirent = dirlist[i];
535
536                         if (!strcmp(dirent->d_name, ".") || !strcmp(dirent->d_name, ".."))
537                                 continue;
538
539                         join_dirfile_alloc(&from_path, &from_alloc_len, from, dirent->d_name);
540                         if (to)
541                                 join_dirfile_alloc(&to_path, &to_alloc_len, to, dirent->d_name);
542
543                         if (dirent->d_type == DT_DIR) {
544                                 /* recursively dig into a subfolder */
545                                 ret = recursive_operation(from_path, to_path, callback_dir_pre, callback_file, callback_dir_post);
546                         }
547                         else if (callback_file != NULL) {
548                                 ret = callback_file(from_path, to_path);
549                                 if (ret != RecursiveOp_Callback_OK)
550                                         ret = -1;
551                         }
552
553                         if (ret != 0)
554                                 break;
555                 }
556                 if (ret != 0)
557                         break;
558
559                 if (callback_dir_post != NULL) {
560                         ret = callback_dir_post(from, to);
561                         if (ret != RecursiveOp_Callback_OK)
562                                 ret = -1;
563                 }
564         }
565         while (false);
566
567         if (dirlist != NULL) {
568                 for (i = 0; i < n; i++) {
569                         free(dirlist[i]);
570                 }
571                 free(dirlist);
572         }
573         if (from_path != NULL)
574                 MEM_freeN(from_path);
575         if (to_path != NULL)
576                 MEM_freeN(to_path);
577         if (from != NULL)
578                 MEM_freeN(from);
579         if (to != NULL)
580                 MEM_freeN(to);
581
582         return ret;
583 }
584
585 static int delete_callback_post(const char *from, const char *UNUSED(to))
586 {
587         if (rmdir(from)) {
588                 perror("rmdir");
589
590                 return RecursiveOp_Callback_Error;
591         }
592
593         return RecursiveOp_Callback_OK;
594 }
595
596 static int delete_single_file(const char *from, const char *UNUSED(to))
597 {
598         if (unlink(from)) {
599                 perror("unlink");
600
601                 return RecursiveOp_Callback_Error;
602         }
603
604         return RecursiveOp_Callback_OK;
605 }
606
607 FILE *BLI_fopen(const char *filename, const char *mode)
608 {
609         return fopen(filename, mode);
610 }
611
612 void *BLI_gzopen(const char *filename, const char *mode)
613 {
614         return gzopen(filename, mode);
615 }
616
617 int BLI_open(const char *filename, int oflag, int pmode)
618 {
619         return open(filename, oflag, pmode);
620 }
621
622 int   BLI_access(const char *filename, int mode)
623 {
624         return access(filename, mode);
625 }
626
627
628 /**
629  * Deletes the specified file or directory (depending on dir), optionally
630  * doing recursive delete of directory contents.
631  */
632 int BLI_delete(const char *file, bool dir, bool recursive)
633 {
634         if (strchr(file, '"')) {
635                 printf("Error: not deleted file %s because of quote!\n", file);
636         }
637         else {
638                 if (recursive) {
639                         return recursive_operation(file, NULL, NULL, delete_single_file, delete_callback_post);
640                 }
641                 else if (dir) {
642                         return rmdir(file);
643                 }
644                 else {
645                         return remove(file); //BLI_snprintf(str, sizeof(str), "/bin/rm -f \"%s\"", file);
646                 }
647         }
648         return -1;
649 }
650
651 /**
652  * Do the two paths denote the same filesystem object?
653  */
654 static bool check_the_same(const char *path_a, const char *path_b)
655 {
656         struct stat st_a, st_b;
657
658         if (lstat(path_a, &st_a))
659                 return false;
660
661         if (lstat(path_b, &st_b))
662                 return false;
663
664         return st_a.st_dev == st_b.st_dev && st_a.st_ino == st_b.st_ino;
665 }
666
667 /**
668  * Sets the mode and ownership of file to the values from st.
669  */
670 static int set_permissions(const char *file, const struct stat *st)
671 {
672         if (chown(file, st->st_uid, st->st_gid)) {
673                 perror("chown");
674                 return -1;
675         }
676
677         if (chmod(file, st->st_mode)) {
678                 perror("chmod");
679                 return -1;
680         }
681
682         return 0;
683 }
684
685 /* pre-recursive callback for copying operation
686  * creates a destination directory where all source content fill be copied to */
687 static int copy_callback_pre(const char *from, const char *to)
688 {
689         struct stat st;
690
691         if (check_the_same(from, to)) {
692                 fprintf(stderr, "%s: '%s' is the same as '%s'\n", __func__, from, to);
693                 return RecursiveOp_Callback_Error;
694         }
695
696         if (lstat(from, &st)) {
697                 perror("stat");
698                 return RecursiveOp_Callback_Error;
699         }
700
701         /* create a directory */
702         if (mkdir(to, st.st_mode)) {
703                 perror("mkdir");
704                 return RecursiveOp_Callback_Error;
705         }
706
707         /* set proper owner and group on new directory */
708         if (chown(to, st.st_uid, st.st_gid)) {
709                 perror("chown");
710                 return RecursiveOp_Callback_Error;
711         }
712
713         return RecursiveOp_Callback_OK;
714 }
715
716 static int copy_single_file(const char *from, const char *to)
717 {
718         FILE *from_stream, *to_stream;
719         struct stat st;
720         char buf[4096];
721         size_t len;
722
723         if (check_the_same(from, to)) {
724                 fprintf(stderr, "%s: '%s' is the same as '%s'\n", __func__, from, to);
725                 return RecursiveOp_Callback_Error;
726         }
727
728         if (lstat(from, &st)) {
729                 perror("lstat");
730                 return RecursiveOp_Callback_Error;
731         }
732
733         if (S_ISLNK(st.st_mode)) {
734                 /* symbolic links should be copied in special way */
735                 char *link_buffer;
736                 int need_free;
737                 ssize_t link_len;
738
739                 /* get large enough buffer to read link content */
740                 if (st.st_size < sizeof(buf)) {
741                         link_buffer = buf;
742                         need_free = 0;
743                 }
744                 else {
745                         link_buffer = MEM_callocN(st.st_size + 2, "copy_single_file link_buffer");
746                         need_free = 1;
747                 }
748
749                 link_len = readlink(from, link_buffer, st.st_size + 1);
750                 if (link_len < 0) {
751                         perror("readlink");
752
753                         if (need_free) MEM_freeN(link_buffer);
754
755                         return RecursiveOp_Callback_Error;
756                 }
757
758                 link_buffer[link_len] = 0;
759
760                 if (symlink(link_buffer, to)) {
761                         perror("symlink");
762                         if (need_free) MEM_freeN(link_buffer);
763                         return RecursiveOp_Callback_Error;
764                 }
765
766                 if (need_free)
767                         MEM_freeN(link_buffer);
768
769                 return RecursiveOp_Callback_OK;
770         }
771         else if (S_ISCHR(st.st_mode) ||
772                  S_ISBLK(st.st_mode) ||
773                  S_ISFIFO(st.st_mode) ||
774                  S_ISSOCK(st.st_mode))
775         {
776                 /* copy special type of file */
777                 if (mknod(to, st.st_mode, st.st_rdev)) {
778                         perror("mknod");
779                         return RecursiveOp_Callback_Error;
780                 }
781
782                 if (set_permissions(to, &st))
783                         return RecursiveOp_Callback_Error;
784
785                 return RecursiveOp_Callback_OK;
786         }
787         else if (!S_ISREG(st.st_mode)) {
788                 fprintf(stderr, "Copying of this kind of files isn't supported yet\n");
789                 return RecursiveOp_Callback_Error;
790         }
791
792         from_stream = fopen(from, "rb");
793         if (!from_stream) {
794                 perror("fopen");
795                 return RecursiveOp_Callback_Error;
796         }
797
798         to_stream = fopen(to, "wb");
799         if (!to_stream) {
800                 perror("fopen");
801                 fclose(from_stream);
802                 return RecursiveOp_Callback_Error;
803         }
804
805         while ((len = fread(buf, 1, sizeof(buf), from_stream)) > 0) {
806                 fwrite(buf, 1, len, to_stream);
807         }
808
809         fclose(to_stream);
810         fclose(from_stream);
811
812         if (set_permissions(to, &st))
813                 return RecursiveOp_Callback_Error;
814
815         return RecursiveOp_Callback_OK;
816 }
817
818 /* Not used anywhere! */
819 #if 0
820 static int move_callback_pre(const char *from, const char *to)
821 {
822         int ret = rename(from, to);
823
824         if (ret)
825                 return copy_callback_pre(from, to);
826
827         return RecursiveOp_Callback_StopRecurs;
828 }
829
830 static int move_single_file(const char *from, const char *to)
831 {
832         int ret = rename(from, to);
833
834         if (ret)
835                 return copy_single_file(from, to);
836
837         return RecursiveOp_Callback_OK;
838 }
839
840 /* if *file represents a directory, moves all its contents into *to, else renames
841  * file itself to *to. */
842 int BLI_move(const char *file, const char *to)
843 {
844         int ret = recursive_operation(file, to, move_callback_pre, move_single_file, NULL);
845
846         if (ret && ret != -1) {
847                 return recursive_operation(file, NULL, NULL, delete_single_file, delete_callback_post);
848         }
849
850         return ret;
851 }
852 #endif
853
854 static char *check_destination(const char *file, const char *to)
855 {
856         struct stat st;
857
858         if (!stat(to, &st)) {
859                 if (S_ISDIR(st.st_mode)) {
860                         char *str, *path;
861                         const char *filename;
862                         size_t len = 0;
863
864                         str = strip_last_slash(file);
865                         filename = BLI_last_slash(str);
866
867                         if (!filename) {
868                                 MEM_freeN(str);
869                                 return (char *)to;
870                         }
871
872                         /* skip slash */
873                         filename += 1;
874
875                         len = strlen(to) + strlen(filename) + 1;
876                         path = MEM_callocN(len + 1, "check_destination path");
877                         BLI_join_dirfile(path, len + 1, to, filename);
878
879                         MEM_freeN(str);
880
881                         return path;
882                 }
883         }
884
885         return (char *)to;
886 }
887
888 int BLI_copy(const char *file, const char *to)
889 {
890         char *actual_to = check_destination(file, to);
891         int ret;
892
893         ret = recursive_operation(file, actual_to, copy_callback_pre, copy_single_file, NULL);
894
895         if (actual_to != to)
896                 MEM_freeN(actual_to);
897
898         return ret;
899 }
900
901 int BLI_create_symlink(const char *file, const char *to)
902 {
903         return symlink(to, file);
904 }
905
906 void BLI_dir_create_recursive(const char *dirname)
907 {
908         char *lslash;
909         size_t size;
910 #ifdef MAXPATHLEN
911         char static_buf[MAXPATHLEN];
912 #endif
913         char *tmp;
914
915         if (BLI_exists(dirname)) return;
916
917 #ifdef MAXPATHLEN
918         size = MAXPATHLEN;
919         tmp = static_buf;
920 #else
921         size = strlen(dirname) + 1;
922         tmp = MEM_callocN(size, __func__);
923 #endif
924
925         BLI_strncpy(tmp, dirname, size);
926                 
927         lslash = (char *)BLI_last_slash(tmp);
928         if (lslash) {
929                 /* Split about the last slash and recurse */
930                 *lslash = 0;
931                 BLI_dir_create_recursive(tmp);
932         }
933
934 #ifndef MAXPATHLEN
935         MEM_freeN(tmp);
936 #endif
937
938         mkdir(dirname, 0777);
939 }
940
941 int BLI_rename(const char *from, const char *to)
942 {
943         if (!BLI_exists(from)) return 0;
944         
945         if (BLI_exists(to))
946                 if (BLI_delete(to, false, false)) return 1;
947
948         return rename(from, to);
949 }
950
951 #endif