svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r22099:22130
[blender.git] / source / blender / blenlib / intern / fileops.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <string.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33
34 #include "zlib.h"
35
36 #ifdef WIN32
37 #include "BLI_winstuff.h"
38 #include <io.h>
39 #else
40 #include <unistd.h> // for read close
41 #include <sys/param.h>
42 #endif
43
44 #include "BLI_blenlib.h"
45 #include "BLI_storage.h"
46 #include "BLI_fileops.h"
47 #include "BLI_callbacks.h"
48
49 #include <sys/types.h>
50 #include <sys/stat.h>
51 #include <fcntl.h>
52
53 #include "BKE_utildefines.h"
54 #include <errno.h>
55
56 #include "BLO_sys_types.h" // for intptr_t support
57
58 /* implementations: */
59 char *first_slash(char *string) {
60         char *ffslash, *fbslash;
61         
62         ffslash= strchr(string, '/');   
63         fbslash= strchr(string, '\\');
64         
65         if (!ffslash) return fbslash;
66         else if (!fbslash) return ffslash;
67         
68         if ((intptr_t)ffslash < (intptr_t)fbslash) return ffslash;
69         else return fbslash;
70 }
71
72 char *BLI_last_slash(const char *string) {
73         char *lfslash, *lbslash;
74         
75         lfslash= strrchr(string, '/');  
76         lbslash= strrchr(string, '\\');
77
78         if (!lfslash) return lbslash; 
79         else if (!lbslash) return lfslash;
80         
81         if ((intptr_t)lfslash < (intptr_t)lbslash) return lbslash;
82         else return lfslash;
83 }
84
85 /* adds a slash if there isnt one there alredy */
86 int BLI_add_slash(char *string) {
87         int len = strlen(string);
88 #ifdef WIN32
89         if (len==0 || string[len-1]!='\\') {
90                 string[len] = '\\';
91                 string[len+1] = '\0';
92                 return len+1;
93         }
94 #else
95         if (len==0 || string[len-1]!='/') {
96                 string[len] = '/';
97                 string[len+1] = '\0';
98                 return len+1;
99         }
100 #endif
101         return len;
102 }
103
104 /* removes a slash if there is one */
105 void BLI_del_slash(char *string) {
106         int len = strlen(string);
107         while (len) {
108 #ifdef WIN32
109                 if (string[len-1]=='\\') {
110 #else
111                 if (string[len-1]=='/') {
112 #endif
113                         string[len-1] = '\0';
114                         len--;
115                 } else {
116                         break;
117                 }
118         }
119 }
120
121 /* gzip the file in from and write it to "to". 
122  return -1 if zlib fails, -2 if the originating file does not exist
123  note: will remove the "from" file
124   */
125 int BLI_gzip(char *from, char *to) {
126         char buffer[10240];
127         int file;
128         int readsize = 0;
129         
130         gzFile gzfile = gzopen(to,"wb"); 
131         if (NULL == gzfile) return -1;
132         
133         file = open(from,O_BINARY|O_RDONLY);
134         
135         if ( -1 == file )       return -2;
136
137         while ( 1 )
138         {
139                 readsize = read(file, buffer, 10240);
140                 
141                 if (readsize <= 0) break;
142                 
143                 gzwrite(gzfile,buffer,readsize);
144         }
145         
146         gzclose(gzfile);
147         close(file);
148         
149         remove(from);
150
151         return 0;
152 }
153
154 /* return 1 when file can be written */
155 int BLI_is_writable(char *filename)
156 {
157         int file;
158         
159         /* first try to open without creating */
160         file = open(filename, O_BINARY | O_RDWR, 0666);
161         
162         if (file < 0) {
163                 /* now try to open and create. a test without actually
164                  * creating a file would be nice, but how? */
165                 file = open(filename, O_BINARY | O_RDWR | O_CREAT, 0666);
166                 
167                 if(file < 0) {
168                         return 0;
169                 }
170                 else {
171                         /* success, delete the file we create */
172                         close(file);
173                         BLI_delete(filename, 0, 0);
174                         return 1;
175                 }
176         }
177         else {
178                 close(file);
179                 return 1;
180         }
181 }
182
183 int BLI_touch(const char *file)
184 {
185    FILE *f = fopen(file,"r+b");
186    if (f != NULL) {
187                 char c = getc(f);
188                 rewind(f);
189                 putc(c,f);
190         } else {
191            f = fopen(file,"wb");
192         }
193         if (f) {
194                 fclose(f);
195                 return 1;
196         }
197         return 0;
198 }
199
200 #ifdef WIN32
201
202 static char str[MAXPATHLEN+12];
203
204 int BLI_delete(char *file, int dir, int recursive) {
205         int err;
206
207         if (recursive) {
208                 callLocalErrorCallBack("Recursive delete is unsupported on Windows");
209                 err= 1;
210         } else if (dir) {
211                 err= !RemoveDirectory(file);
212                 if (err) printf ("Unable to remove directory");
213         } else {
214                 err= !DeleteFile(file);
215                 if (err) callLocalErrorCallBack("Unable to delete file");
216         }
217
218         return err;
219 }
220
221 int BLI_move(char *file, char *to) {
222         int err;
223
224         // windows doesn't support moveing to a directory
225         // it has to be 'mv filename filename' and not
226         // 'mv filename destdir'
227
228         strcpy(str, to);
229         // points 'to' to a directory ?
230         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
231                 if (BLI_last_slash(file) != NULL) {
232                         strcat(str, BLI_last_slash(file) + 1);
233                 }
234         }
235
236         err= !MoveFile(file, str);
237         if (err) {
238                 callLocalErrorCallBack("Unable to move file");
239                 printf(" Move from '%s' to '%s' failed\n", file, str);
240         }
241
242         return err;
243 }
244
245
246 int BLI_copy_fileops(char *file, char *to) {
247         int err;
248
249         // windows doesn't support copying to a directory
250         // it has to be 'cp filename filename' and not
251         // 'cp filename destdir'
252
253         strcpy(str, to);
254         // points 'to' to a directory ?
255         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
256                 if (BLI_last_slash(file) != NULL) {
257                         strcat(str, BLI_last_slash(file) + 1);
258                 }
259         }
260
261         err= !CopyFile(file,str,FALSE);
262         
263         if (err) {
264                 callLocalErrorCallBack("Unable to copy file!");
265                 printf(" Copy from '%s' to '%s' failed\n", file, str);
266         }
267
268         return err;
269 }
270
271 int BLI_link(char *file, char *to) {
272         callLocalErrorCallBack("Linking files is unsupported on Windows");
273         
274         return 1;
275 }
276
277 int BLI_exists(char *file) {
278         return (GetFileAttributes(file) != 0xFFFFFFFF);
279 }
280
281 void BLI_recurdir_fileops(char *dirname) {
282         char *lslash;
283         char tmp[MAXPATHLEN];
284         
285         // First remove possible slash at the end of the dirname.
286         // This routine otherwise tries to create
287         // blah1/blah2/ (with slash) after creating
288         // blah1/blah2 (without slash)
289
290         strcpy(tmp, dirname);
291         lslash= BLI_last_slash(tmp);
292
293         if (lslash == tmp + strlen(tmp) - 1) {
294                 *lslash = 0;
295         }
296         
297         if (BLI_exists(tmp)) return;
298                 
299         lslash= BLI_last_slash(tmp);
300         if (lslash) {
301                         /* Split about the last slash and recurse */    
302                 *lslash = 0;
303                 BLI_recurdir_fileops(tmp);
304         }
305         
306         if(dirname[0]) /* patch, this recursive loop tries to create a nameless directory */
307                 if (!CreateDirectory(dirname, NULL))
308                         callLocalErrorCallBack("Unable to create directory\n");
309 }
310
311 int BLI_rename(char *from, char *to) {
312         if (!BLI_exists(from)) return 0;
313
314         /* make sure the filenames are different (case insensitive) before removing */
315         if (BLI_exists(to) && BLI_strcasecmp(from, to))
316                 if(BLI_delete(to, 0, 0)) return 1;
317
318         return rename(from, to);
319 }
320
321 #else /* The sane UNIX world */
322
323 /*
324  * but the sane UNIX world is tied to the interface, and the system
325  * timer, and... We implement a callback mechanism. The system will
326  * have to initialise the callback before the functions will work!
327  * */
328 static char str[MAXPATHLEN+12];
329
330 int BLI_delete(char *file, int dir, int recursive) 
331 {
332         if(strchr(file, '"')) {
333                 printf("Error: not deleted file %s because of quote!\n", file);
334         }
335         else {
336                 if (recursive) {
337                         sprintf(str, "/bin/rm -rf \"%s\"", file);
338                         return system(str);
339                 }
340                 else if (dir) {
341                         sprintf(str, "/bin/rmdir \"%s\"", file);
342                         return system(str);
343                 }
344                 else {
345                         return remove(file); //sprintf(str, "/bin/rm -f \"%s\"", file);
346                 }
347         }
348         return -1;
349 }
350
351 int BLI_move(char *file, char *to) {
352         sprintf(str, "/bin/mv -f \"%s\" \"%s\"", file, to);
353
354         return system(str);
355 }
356
357 int BLI_copy_fileops(char *file, char *to) {
358         sprintf(str, "/bin/cp -rf \"%s\" \"%s\"", file, to);
359
360         return system(str);
361 }
362
363 int BLI_link(char *file, char *to) {
364         sprintf(str, "/bin/ln -f \"%s\" \"%s\"", file, to);
365         
366         return system(str);
367 }
368
369 int BLI_exists(char *file) {
370         return BLI_exist(file);
371 }
372
373 void BLI_recurdir_fileops(char *dirname) {
374         char *lslash;
375         char tmp[MAXPATHLEN];
376                 
377         if (BLI_exists(dirname)) return;
378
379         strcpy(tmp, dirname);
380                 
381         lslash= BLI_last_slash(tmp);
382         if (lslash) {
383                         /* Split about the last slash and recurse */    
384                 *lslash = 0;
385                 BLI_recurdir_fileops(tmp);
386         }
387
388         mkdir(dirname, 0777);
389 }
390
391 int BLI_rename(char *from, char *to) {
392         if (!BLI_exists(from)) return 0;
393         
394         if (BLI_exists(to))     if(BLI_delete(to, 0, 0)) return 1;
395
396         return rename(from, to);
397 }
398
399 #endif