Cleanup work for 2.5 branch. Target is to get it compile and link
[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 #include <unistd.h>
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 #include "zlib.h"
40
41 #ifdef WIN32
42 #include "BLI_winstuff.h"
43 #include <io.h>
44 #else
45 #include <sys/param.h>
46 #endif
47
48 #include "BLI_blenlib.h"
49 #include "BLI_storage.h"
50 #include "BLI_fileops.h"
51 #include "BLI_callbacks.h"
52
53 #include <sys/types.h>
54 #include <sys/stat.h>
55 #include <fcntl.h>
56
57 #include "BKE_utildefines.h"
58 #include <errno.h>
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 ((long)ffslash < (long)fbslash) return ffslash;
71         else return fbslash;
72 }
73
74 char *BLI_last_slash(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 ((long)lfslash < (long)lbslash) return lbslash;
84         else return lfslash;
85 }
86
87 /* gzip the file in from and write it to "to". 
88  return -1 if zlib fails, -2 if the originating file does not exist
89  note: will remove the "from" file
90   */
91 int BLI_gzip(char *from, char *to) {
92         char buffer[10240];
93         int file;
94         int readsize = 0;
95         
96         gzFile gzfile = gzopen(to,"wb"); 
97         if (NULL == gzfile) return -1;
98         
99         file = open(from,O_BINARY|O_RDONLY);
100         
101         if ( -1 == file )       return -2;
102
103         while ( 1 )
104         {
105                 readsize = read(file, buffer, 10240);
106                 
107                 if (readsize <= 0) break;
108                 
109                 gzwrite(gzfile,buffer,readsize);
110         }
111         
112         gzclose(gzfile);
113         close(file);
114         
115         remove(from);
116
117         return 0;
118 }
119
120 /* return 1 when file can be written */
121 int BLI_is_writable(char *filename)
122 {
123         int file;
124         
125         file = open(filename, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
126         
127         if (file < 0)
128                 return 0;
129         else {
130                 close(file);
131                 return 1;
132         }
133 }
134
135 #ifdef WIN32
136
137 static char str[MAXPATHLEN+12];
138
139 int BLI_delete(char *file, int dir, int recursive) {
140         int err;
141
142         if (recursive) {
143                 callLocalErrorCallBack("Recursive delete is unsupported on Windows");
144                 err= 1;
145         } else if (dir) {
146                 err= !RemoveDirectory(file);
147                 if (err) printf ("Unable to remove directory");
148         } else {
149                 err= !DeleteFile(file);
150                 if (err) callLocalErrorCallBack("Unable to delete file");
151         }
152
153         return err;
154 }
155
156 int BLI_touch(char *file) {
157         callLocalErrorCallBack("Touching files is unsupported on Windows");
158         
159         return 1;
160 }
161
162 int BLI_move(char *file, char *to) {
163         int err;
164
165         // windows doesn't support moveing to a directory
166         // it has to be 'mv filename filename' and not
167         // 'mv filename destdir'
168
169         strcpy(str, to);
170         // points 'to' to a directory ?
171         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
172                 if (BLI_last_slash(file) != NULL) {
173                         strcat(str, BLI_last_slash(file) + 1);
174                 }
175         }
176
177         err= !MoveFile(file, str);
178         if (err) {
179                 callLocalErrorCallBack("Unable to move file");
180                 printf(" Move from '%s' to '%s' failed\n", file, str);
181         }
182
183         return err;
184 }
185
186
187 int BLI_copy_fileops(char *file, char *to) {
188         int err;
189
190         // windows doesn't support copying to a directory
191         // it has to be 'cp filename filename' and not
192         // 'cp filename destdir'
193
194         strcpy(str, to);
195         // points 'to' to a directory ?
196         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
197                 if (BLI_last_slash(file) != NULL) {
198                         strcat(str, BLI_last_slash(file) + 1);
199                 }
200         }
201
202         err= !CopyFile(file,str,FALSE);
203         
204         if (err) {
205                 callLocalErrorCallBack("Unable to copy file!");
206                 printf(" Copy from '%s' to '%s' failed\n", file, str);
207         }
208
209         return err;
210 }
211
212 int BLI_link(char *file, char *to) {
213         callLocalErrorCallBack("Linking files is unsupported on Windows");
214         
215         return 1;
216 }
217
218 int BLI_backup(char *file, char *from, char *to) {
219         callLocalErrorCallBack("Backing up files is unsupported on Windows");
220         
221         return 1;
222 }
223
224 int BLI_exists(char *file) {
225         return (GetFileAttributes(file) != 0xFFFFFFFF);
226 }
227
228 void BLI_recurdir_fileops(char *dirname) {
229         char *lslash;
230         char tmp[MAXPATHLEN];
231         
232         // First remove possible slash at the end of the dirname.
233         // This routine otherwise tries to create
234         // blah1/blah2/ (with slash) after creating
235         // blah1/blah2 (without slash)
236
237         strcpy(tmp, dirname);
238         lslash= BLI_last_slash(tmp);
239
240         if (lslash == tmp + strlen(tmp) - 1) {
241                 *lslash = 0;
242         }
243         
244         if (BLI_exists(tmp)) return;
245                 
246         lslash= BLI_last_slash(tmp);
247         if (lslash) {
248                         /* Split about the last slash and recurse */    
249                 *lslash = 0;
250                 BLI_recurdir_fileops(tmp);
251         }
252         
253         if(dirname[0]) /* patch, this recursive loop tries to create a nameless directory */
254                 if (!CreateDirectory(dirname, NULL))
255                         callLocalErrorCallBack("Unable to create directory\n");
256 }
257
258 int BLI_rename(char *from, char *to) {
259         if (!BLI_exists(from)) return 0;
260
261         if (BLI_exists(to))
262                 if(BLI_delete(to, 0, 0)) return 1;
263                 
264         return rename(from, to);
265 }
266
267 #else /* The sane UNIX world */
268
269 /*
270  * but the sane 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) sprintf(str, "/bin/rm -rf \"%s\"", file);
283                 else if (dir) sprintf(str, "/bin/rmdir \"%s\"", file);
284                 else sprintf(str, "/bin/rm -f \"%s\"", file);
285
286                 return system(str);
287         }
288         return -1;
289 }
290
291 int BLI_touch(char *file) 
292 {
293         
294         if( BLI_exists("/bin/touch") )
295                 sprintf(str, "/bin/touch %s", file);
296         else
297                 sprintf(str, "/usr/bin/touch %s", file);
298         
299         return system(str);
300 }
301
302 int BLI_move(char *file, char *to) {
303         sprintf(str, "/bin/mv -f \"%s\" \"%s\"", file, to);
304
305         return system(str);
306 }
307
308 int BLI_copy_fileops(char *file, char *to) {
309         sprintf(str, "/bin/cp -rf \"%s\" \"%s\"", file, to);
310
311         return system(str);
312 }
313
314 int BLI_link(char *file, char *to) {
315         sprintf(str, "/bin/ln -f \"%s\" \"%s\"", file, to);
316         
317         return system(str);
318 }
319
320 int BLI_backup(char *file, char *from, char *to) {
321         sprintf(str, "/bin/su root -c 'cd %s; /bin/tar cf - \"%s\" | (/bin/cd %s; /bin/tar xf -)'", from, file, to);
322         
323         return system(str);
324 }
325
326 int BLI_exists(char *file) {
327         return BLI_exist(file);
328 }
329
330 void BLI_recurdir_fileops(char *dirname) {
331         char *lslash;
332         char tmp[MAXPATHLEN];
333                 
334         if (BLI_exists(dirname)) return;
335
336         strcpy(tmp, dirname);
337                 
338         lslash= BLI_last_slash(tmp);
339         if (lslash) {
340                         /* Split about the last slash and recurse */    
341                 *lslash = 0;
342                 BLI_recurdir_fileops(tmp);
343         }
344
345         mkdir(dirname, 0777);
346 }
347
348 int BLI_rename(char *from, char *to) {
349         if (!BLI_exists(from)) return 0;
350         
351         if (BLI_exists(to))     if(BLI_delete(to, 0, 0)) return 1;
352                 
353         return rename(from, to);
354 }
355
356 #endif