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