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