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