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