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