converted more mixed tab/space indentations to tabs. only whitespace changes.
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 /** \file blender/blenlib/intern/fileops.c
31  *  \ingroup bli
32  */
33
34
35 #include <string.h>
36 #include <stdio.h>
37
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <fcntl.h>
41
42 #include <errno.h>
43
44 #include "zlib.h"
45
46 #ifdef WIN32
47 #include <io.h>
48 #include "BLI_winstuff.h"
49 #include "BLI_callbacks.h"
50 #else
51 #include <unistd.h> // for read close
52 #include <sys/param.h>
53 #endif
54
55 #include "BLI_blenlib.h"
56
57 #include "BKE_utildefines.h"
58
59 #include "BLO_sys_types.h" // for intptr_t support
60
61
62 /* gzip the file in from and write it to "to". 
63  return -1 if zlib fails, -2 if the originating file does not exist
64  note: will remove the "from" file
65   */
66 int BLI_gzip(const char *from, const char *to) {
67         char buffer[10240];
68         int file;
69         int readsize = 0;
70         int rval= 0, err;
71         gzFile gzfile;
72         
73         gzfile = gzopen(to, "wb"); 
74         if(gzfile == NULL)
75                 return -1;
76         
77         file = open(from, O_BINARY|O_RDONLY);
78         if(file < 0)
79                 return -2;
80
81         while(1) {
82                 readsize = read(file, buffer, 10240);
83
84                 if(readsize < 0) {
85                         rval= -2; /* error happened in reading */
86                         fprintf(stderr, "Error reading file %s: %s.\n", from, strerror(errno));
87                         break;
88                 }
89                 else if(readsize == 0)
90                         break; /* done reading */
91                 
92                 if(gzwrite(gzfile, buffer, readsize) <= 0) {
93                         rval= -1; /* error happened in writing */
94                         fprintf(stderr, "Error writing gz file %s: %s.\n", to, gzerror(gzfile, &err));
95                         break;
96                 }
97         }
98         
99         gzclose(gzfile);
100         close(file);
101
102         return rval;
103 }
104
105 /* return 1 when file can be written */
106 int BLI_is_writable(const char *filename)
107 {
108         int file;
109         
110         /* first try to open without creating */
111         file = open(filename, O_BINARY | O_RDWR, 0666);
112         
113         if (file < 0) {
114                 /* now try to open and create. a test without actually
115                  * creating a file would be nice, but how? */
116                 file = open(filename, O_BINARY | O_RDWR | O_CREAT, 0666);
117                 
118                 if(file < 0) {
119                         return 0;
120                 }
121                 else {
122                         /* success, delete the file we create */
123                         close(file);
124                         BLI_delete(filename, 0, 0);
125                         return 1;
126                 }
127         }
128         else {
129                 close(file);
130                 return 1;
131         }
132 }
133
134 int BLI_touch(const char *file)
135 {
136         FILE *f = fopen(file,"r+b");
137         if (f != NULL) {
138                 char c = getc(f);
139                 rewind(f);
140                 putc(c,f);
141         } else {
142                 f = fopen(file,"wb");
143         }
144         if (f) {
145                 fclose(f);
146                 return 1;
147         }
148         return 0;
149 }
150
151 int BLI_exists(const char *file) {
152         return BLI_exist(file);
153 }
154
155 #ifdef WIN32
156
157 static char str[MAXPATHLEN+12];
158
159 int BLI_delete(const char *file, int dir, int recursive) {
160         int err;
161
162         if (recursive) {
163                 callLocalErrorCallBack("Recursive delete is unsupported on Windows");
164                 err= 1;
165         } else if (dir) {
166                 err= !RemoveDirectory(file);
167                 if (err) printf ("Unable to remove directory");
168         } else {
169                 err= !DeleteFile(file);
170                 if (err) callLocalErrorCallBack("Unable to delete file");
171         }
172
173         return err;
174 }
175
176 int BLI_move(const char *file, const char *to) {
177         int err;
178
179         // windows doesn't support moveing to a directory
180         // it has to be 'mv filename filename' and not
181         // 'mv filename destdir'
182
183         strcpy(str, to);
184         // points 'to' to a directory ?
185         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
186                 if (BLI_last_slash(file) != NULL) {
187                         strcat(str, BLI_last_slash(file) + 1);
188                 }
189         }
190
191         err= !MoveFile(file, str);
192         if (err) {
193                 callLocalErrorCallBack("Unable to move file");
194                 printf(" Move from '%s' to '%s' failed\n", file, str);
195         }
196
197         return err;
198 }
199
200
201 int BLI_copy_fileops(const char *file, const char *to) {
202         int err;
203
204         // windows doesn't support copying to a directory
205         // it has to be 'cp filename filename' and not
206         // 'cp filename destdir'
207
208         strcpy(str, to);
209         // points 'to' to a directory ?
210         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
211                 if (BLI_last_slash(file) != NULL) {
212                         strcat(str, BLI_last_slash(file) + 1);
213                 }
214         }
215
216         err= !CopyFile(file,str,FALSE);
217         
218         if (err) {
219                 callLocalErrorCallBack("Unable to copy file!");
220                 printf(" Copy from '%s' to '%s' failed\n", file, str);
221         }
222
223         return err;
224 }
225
226 int BLI_link(const char *file, const char *to) {
227         callLocalErrorCallBack("Linking files is unsupported on Windows");
228         (void)file;
229         (void)to;
230         return 1;
231 }
232
233 void BLI_recurdir_fileops(const char *dirname) {
234         char *lslash;
235         char tmp[MAXPATHLEN];
236         
237         // First remove possible slash at the end of the dirname.
238         // This routine otherwise tries to create
239         // blah1/blah2/ (with slash) after creating
240         // blah1/blah2 (without slash)
241
242         strcpy(tmp, dirname);
243         lslash= BLI_last_slash(tmp);
244
245         if (lslash == tmp + strlen(tmp) - 1) {
246                 *lslash = 0;
247         }
248         
249         if (BLI_exists(tmp)) return;
250                 
251         lslash= BLI_last_slash(tmp);
252         if (lslash) {
253                         /* Split about the last slash and recurse */    
254                 *lslash = 0;
255                 BLI_recurdir_fileops(tmp);
256         }
257         
258         if(dirname[0]) /* patch, this recursive loop tries to create a nameless directory */
259                 if (!CreateDirectory(dirname, NULL))
260                         callLocalErrorCallBack("Unable to create directory\n");
261 }
262
263 int BLI_rename(const char *from, const char *to) {
264         if (!BLI_exists(from)) return 0;
265
266         /* make sure the filenames are different (case insensitive) before removing */
267         if (BLI_exists(to) && BLI_strcasecmp(from, to))
268                 if(BLI_delete(to, 0, 0)) return 1;
269
270         return rename(from, to);
271 }
272
273 #else /* The UNIX world */
274
275 /*
276  * but the UNIX world is tied to the interface, and the system
277  * timer, and... We implement a callback mechanism. The system will
278  * have to initialise the callback before the functions will work!
279  * */
280 static char str[12 + (MAXPATHLEN * 2)];
281
282 int BLI_delete(const char *file, int dir, int recursive) 
283 {
284         if(strchr(file, '"')) {
285                 printf("Error: not deleted file %s because of quote!\n", file);
286         }
287         else {
288                 if (recursive) {
289                         BLI_snprintf(str, sizeof(str), "/bin/rm -rf \"%s\"", file);
290                         return system(str);
291                 }
292                 else if (dir) {
293                         BLI_snprintf(str, sizeof(str), "/bin/rmdir \"%s\"", file);
294                         return system(str);
295                 }
296                 else {
297                         return remove(file); //BLI_snprintf(str, sizeof(str), "/bin/rm -f \"%s\"", file);
298                 }
299         }
300         return -1;
301 }
302
303 int BLI_move(const char *file, const char *to) {
304         BLI_snprintf(str, sizeof(str), "/bin/mv -f \"%s\" \"%s\"", file, to);
305
306         return system(str);
307 }
308
309 int BLI_copy_fileops(const char *file, const char *to) {
310         BLI_snprintf(str, sizeof(str), "/bin/cp -rf \"%s\" \"%s\"", file, to);
311
312         return system(str);
313 }
314
315 int BLI_link(const char *file, const char *to) {
316         BLI_snprintf(str, sizeof(str), "/bin/ln -f \"%s\" \"%s\"", file, to);
317         
318         return system(str);
319 }
320
321 void BLI_recurdir_fileops(const char *dirname) {
322         char *lslash;
323         char tmp[MAXPATHLEN];
324                 
325         if (BLI_exists(dirname)) return;
326
327         strcpy(tmp, dirname);
328                 
329         lslash= BLI_last_slash(tmp);
330         if (lslash) {
331                         /* Split about the last slash and recurse */    
332                 *lslash = 0;
333                 BLI_recurdir_fileops(tmp);
334         }
335
336         mkdir(dirname, 0777);
337 }
338
339 int BLI_rename(const char *from, const char *to) {
340         if (!BLI_exists(from)) return 0;
341         
342         if (BLI_exists(to))     if(BLI_delete(to, 0, 0)) return 1;
343
344         return rename(from, to);
345 }
346
347 #endif