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