d145752c83dae09b3ebfdc7b01dcffecc110d461
[obnox/wireshark/wip.git] / wsutil / file_util.c
1 /* file_util.c
2  *
3  * $Id$
4  *
5  * (Originally part of the Wiretap Library, now part of the Wireshark
6  *  utility library)
7  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  */
24
25 /* file wrapper functions to prevent the file functions from GLib like g_open(),
26  * as code compiled with MSVC 7 and above will collide with libs linked with msvcrt.dll (MSVC 6), lib GLib is
27  *
28  * DO NOT USE THESE FUNCTIONS DIRECTLY, USE ws_open() AND ALIKE FUNCTIONS FROM file_util.h INSTEAD!!!
29  *
30  * the following code is stripped down code copied from the GLib file glib/gstdio.h
31  * stipped down, because this is used on _WIN32 only and we use only wide char functions */
32
33 #ifndef _WIN32
34 #error "This is only for Windows"
35 #endif
36
37 #ifdef HAVE_CONFIG_H
38 #include "config.h"
39 #endif
40
41 #include <glib.h>
42
43 #include <windows.h>
44 #include <errno.h>
45 #include <wchar.h>
46 /*#include <direct.h>*/
47 #include <io.h>
48
49 #include "file_util.h"
50
51
52
53
54 /**
55  * g_open:
56  * @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
57  * @flags: as in open()
58  * @mode: as in open()
59  *
60  * A wrapper for the POSIX open() function. The open() function is
61  * used to convert a pathname into a file descriptor. Note that on
62  * POSIX systems file descriptors are implemented by the operating
63  * system. On Windows, it's the C library that implements open() and
64  * file descriptors. The actual Windows API for opening files is
65  * something different.
66  *
67  * See the C library manual for more details about open().
68  *
69  * Returns: a new file descriptor, or -1 if an error occurred. The
70  * return value can be used exactly like the return value from open().
71  *
72  * Since: 2.6
73  */
74 int
75 ws_stdio_open (const gchar *filename,
76         int          flags,
77         int          mode)
78 {
79       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
80       int retval;
81       int save_errno;
82
83       if (wfilename == NULL)
84         {
85           errno = EINVAL;
86           return -1;
87         }
88
89       retval = _wopen (wfilename, flags, mode);
90       save_errno = errno;
91
92       g_free (wfilename);
93
94       errno = save_errno;
95       return retval;
96 }
97
98
99 /**
100  * g_rename:
101  * @oldfilename: a pathname in the GLib file name encoding (UTF-8 on Windows)
102  * @newfilename: a pathname in the GLib file name encoding
103  *
104  * A wrapper for the POSIX rename() function. The rename() function
105  * renames a file, moving it between directories if required.
106  *
107  * See your C library manual for more details about how rename() works
108  * on your system. Note in particular that on Win9x it is not possible
109  * to rename a file if a file with the new name already exists. Also
110  * it is not possible in general on Windows to rename an open file.
111  *
112  * Returns: 0 if the renaming succeeded, -1 if an error occurred
113  *
114  * Since: 2.6
115  */
116 int
117 ws_stdio_rename (const gchar *oldfilename,
118           const gchar *newfilename)
119 {
120       wchar_t *woldfilename = g_utf8_to_utf16 (oldfilename, -1, NULL, NULL, NULL);
121       wchar_t *wnewfilename;
122       int retval;
123       int save_errno = 0;
124
125       if (woldfilename == NULL)
126         {
127           errno = EINVAL;
128           return -1;
129         }
130
131       wnewfilename = g_utf8_to_utf16 (newfilename, -1, NULL, NULL, NULL);
132
133       if (wnewfilename == NULL)
134         {
135           g_free (woldfilename);
136           errno = EINVAL;
137           return -1;
138         }
139
140       if (MoveFileExW (woldfilename, wnewfilename, MOVEFILE_REPLACE_EXISTING))
141         retval = 0;
142       else
143         {
144           retval = -1;
145           switch (GetLastError ())
146             {
147 #define CASE(a,b) case ERROR_##a: save_errno = b; break
148             CASE (FILE_NOT_FOUND, ENOENT);
149             CASE (PATH_NOT_FOUND, ENOENT);
150             CASE (ACCESS_DENIED, EACCES);
151             CASE (NOT_SAME_DEVICE, EXDEV);
152             CASE (LOCK_VIOLATION, EACCES);
153             CASE (SHARING_VIOLATION, EACCES);
154             CASE (FILE_EXISTS, EEXIST);
155             CASE (ALREADY_EXISTS, EEXIST);
156 #undef CASE
157             default: save_errno = EIO;
158             }
159         }
160
161       g_free (woldfilename);
162       g_free (wnewfilename);
163
164       errno = save_errno;
165       return retval;
166 }
167
168 /**
169  * g_mkdir:
170  * @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
171  * @mode: permissions to use for the newly created directory
172  *
173  * A wrapper for the POSIX mkdir() function. The mkdir() function
174  * attempts to create a directory with the given name and permissions.
175  *
176  * See the C library manual for more details about mkdir().
177  *
178  * Returns: 0 if the directory was successfully created, -1 if an error
179  *    occurred
180  *
181  * Since: 2.6
182  */
183 int
184 ws_stdio_mkdir (const gchar *filename,
185          int          mode)
186 {
187       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
188       int retval;
189       int save_errno;
190
191       if (wfilename == NULL)
192         {
193           errno = EINVAL;
194           return -1;
195         }
196
197       retval = _wmkdir (wfilename);
198       save_errno = errno;
199
200       g_free (wfilename);
201
202       errno = save_errno;
203       return retval;
204 }
205
206 /**
207  * g_stat:
208  * @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
209  * @buf: a pointer to a <structname>stat</structname> struct, which
210  *    will be filled with the file information
211  *
212  * A wrapper for the POSIX stat() function. The stat() function
213  * returns information about a file.
214  *
215  * See the C library manual for more details about stat().
216  *
217  * Returns: 0 if the information was successfully retrieved, -1 if an error
218  *    occurred
219  *
220  * Since: 2.6
221  */
222 int
223 ws_stdio_stat (const gchar *filename,
224         struct stat *buf)
225 {
226       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
227       int retval;
228       int save_errno;
229       size_t len;
230
231       if (wfilename == NULL)
232         {
233           errno = EINVAL;
234           return -1;
235         }
236
237       len = wcslen (wfilename);
238       while (len > 0 && G_IS_DIR_SEPARATOR (wfilename[len-1]))
239         len--;
240       if (len > 0 &&
241           (!g_path_is_absolute (filename) || len > (size_t) (g_path_skip_root (filename) - filename)))
242         wfilename[len] = '\0';
243
244       retval = _wstat (wfilename, (struct _stat *) buf);
245       save_errno = errno;
246
247       g_free (wfilename);
248
249       errno = save_errno;
250       return retval;
251 }
252 /**
253  * g_unlink:
254  * @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
255  *
256  * A wrapper for the POSIX unlink() function. The unlink() function
257  * deletes a name from the filesystem. If this was the last link to the
258  * file and no processes have it opened, the diskspace occupied by the
259  * file is freed.
260  *
261  * See your C library manual for more details about unlink(). Note
262  * that on Windows, it is in general not possible to delete files that
263  * are open to some process, or mapped into memory.
264  *
265  * Returns: 0 if the name was successfully deleted, -1 if an error
266  *    occurred
267  *
268  * Since: 2.6
269  */
270  
271 int
272 ws_stdio_unlink (const gchar *filename)
273 {
274       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
275       int retval;
276       int save_errno;
277
278       if (wfilename == NULL)
279         {
280           errno = EINVAL;
281           return -1;
282         }
283
284       retval = _wunlink (wfilename);
285       save_errno = errno;
286
287       g_free (wfilename);
288
289       errno = save_errno;
290       return retval;
291 }
292
293 /**
294  * g_remove:
295  * @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
296  *
297  * A wrapper for the POSIX remove() function. The remove() function
298  * deletes a name from the filesystem.
299  *
300  * See your C library manual for more details about how remove() works
301  * on your system. On Unix, remove() removes also directories, as it
302  * calls unlink() for files and rmdir() for directories. On Windows,
303  * although remove() in the C library only works for files, this
304  * function tries first remove() and then if that fails rmdir(), and
305  * thus works for both files and directories. Note however, that on
306  * Windows, it is in general not possible to remove a file that is
307  * open to some process, or mapped into memory.
308  *
309  * If this function fails on Windows you can't infer too much from the
310  * errno value. rmdir() is tried regardless of what caused remove() to
311  * fail. Any errno value set by remove() will be overwritten by that
312  * set by rmdir().
313  *
314  * Returns: 0 if the file was successfully removed, -1 if an error
315  *    occurred
316  *
317  * Since: 2.6
318  */
319 int
320 ws_stdio_remove (const gchar *filename)
321 {
322       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
323       int retval;
324       int save_errno;
325
326       if (wfilename == NULL)
327         {
328           errno = EINVAL;
329           return -1;
330         }
331
332       retval = _wremove (wfilename);
333       if (retval == -1)
334         retval = _wrmdir (wfilename);
335       save_errno = errno;
336
337       g_free (wfilename);
338
339       errno = save_errno;
340       return retval;
341 }
342
343 /**
344  * g_fopen:
345  * @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
346  * @mode: a string describing the mode in which the file should be
347  *   opened
348  *
349  * A wrapper for the POSIX fopen() function. The fopen() function opens
350  * a file and associates a new stream with it.
351  *
352  * See the C library manual for more details about fopen().
353  *
354  * Returns: A <type>FILE</type> pointer if the file was successfully
355  *    opened, or %NULL if an error occurred
356  *
357  * Since: 2.6
358  */
359 FILE *
360 ws_stdio_fopen (const gchar *filename,
361          const gchar *mode)
362 {
363       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
364       wchar_t *wmode;
365       FILE *retval;
366       int save_errno;
367
368       if (wfilename == NULL)
369         {
370           errno = EINVAL;
371           return NULL;
372         }
373
374       wmode = g_utf8_to_utf16 (mode, -1, NULL, NULL, NULL);
375
376       if (wmode == NULL)
377         {
378           g_free (wfilename);
379           errno = EINVAL;
380           return NULL;
381         }
382
383       retval = _wfopen (wfilename, wmode);
384       save_errno = errno;
385
386       g_free (wfilename);
387       g_free (wmode);
388
389       errno = save_errno;
390       return retval;
391 }
392
393 /**
394  * g_freopen:
395  * @filename: a pathname in the GLib file name encoding (UTF-8 on Windows)
396  * @mode: a string describing the mode in which the file should be
397  *   opened
398  * @stream: an existing stream which will be reused, or %NULL
399  *
400  * A wrapper for the POSIX freopen() function. The freopen() function
401  * opens a file and associates it with an existing stream.
402  *
403  * See the C library manual for more details about freopen().
404  *
405  * Returns: A <type>FILE</type> pointer if the file was successfully
406  *    opened, or %NULL if an error occurred.
407  *
408  * Since: 2.6
409  */
410 FILE *
411 ws_stdio_freopen (const gchar *filename,
412            const gchar *mode,
413            FILE        *stream)
414 {
415       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
416       wchar_t *wmode;
417       FILE *retval;
418       int save_errno;
419
420       if (wfilename == NULL)
421         {
422           errno = EINVAL;
423           return NULL;
424         }
425
426       wmode = g_utf8_to_utf16 (mode, -1, NULL, NULL, NULL);
427
428       if (wmode == NULL)
429         {
430           g_free (wfilename);
431           errno = EINVAL;
432           return NULL;
433         }
434
435       retval = _wfreopen (wfilename, wmode, stream);
436       save_errno = errno;
437
438       g_free (wfilename);
439       g_free (wmode);
440
441       errno = save_errno;
442       return retval;
443 }