better tests
[pspp] / src / data / file-handle-def.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "data/file-handle-def.h"
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "data/dataset.h"
27 #include "data/variable.h"
28 #include "libpspp/assertion.h"
29 #include "libpspp/cast.h"
30 #include "libpspp/compiler.h"
31 #include "libpspp/hash-functions.h"
32 #include "libpspp/hmap.h"
33 #include "libpspp/i18n.h"
34 #include "libpspp/message.h"
35 #include "libpspp/str.h"
36
37 #include <sys/stat.h>
38
39 #include "gl/dirname.h"
40 #include "gl/xalloc.h"
41
42 #include "gettext.h"
43 #define _(msgid) gettext (msgid)
44
45 #if defined _WIN32 || defined __WIN32__
46 #define WIN32_LEAN_AND_MEAN  /* avoid including junk */
47 #include <windows.h>
48 #endif
49
50 /* File handle. */
51 struct file_handle
52   {
53     struct hmap_node name_node; /* Element in named_handles hmap. */
54     size_t ref_cnt;             /* Number of references. */
55     char *id;                   /* Identifier token, NULL if none. */
56     char *name;                 /* User-friendly identifying name. */
57     enum fh_referent referent;  /* What the file handle refers to. */
58
59     /* FH_REF_FILE only. */
60     char *file_name;            /* File name as provided by user. */
61     char *file_name_encoding;   /* The character encoding of file_name,
62                                    This is NOT the encoding of the file contents! */
63     enum fh_mode mode;          /* File mode. */
64     enum fh_line_ends line_ends; /* Line ends for text files. */
65
66     /* FH_REF_FILE and FH_REF_INLINE only. */
67     size_t record_width;        /* Length of fixed-format records. */
68     size_t tab_width;           /* Tab width, 0=do not expand tabs. */
69     char *encoding;             /* Charset for contents. */
70
71     /* FH_REF_DATASET only. */
72     struct dataset *ds;         /* Dataset. */
73   };
74
75 /* All "struct file_handle"s with nonnull 'id' member. */
76 static struct hmap named_handles = HMAP_INITIALIZER (named_handles);
77
78 /* Default file handle for DATA LIST, REREAD, REPEATING DATA
79    commands. */
80 static struct file_handle *default_handle;
81
82 /* The "file" that reads from BEGIN DATA...END DATA. */
83 static struct file_handle *inline_file;
84
85 static struct file_handle *create_handle (const char *id,
86                                           char *name, enum fh_referent,
87                                           const char *encoding);
88 static void free_handle (struct file_handle *);
89 static void unname_handle (struct file_handle *);
90
91 /* Hash table of all active locks. */
92 static struct hmap locks = HMAP_INITIALIZER (locks);
93
94 static struct file_identity *fh_get_identity (const struct file_handle *);
95 static void fh_free_identity (struct file_identity *);
96 static int fh_compare_file_identities (const struct file_identity *,
97                                 const struct file_identity *);
98 static unsigned int fh_hash_identity (const struct file_identity *);
99
100 /* File handle initialization routine. */
101 void
102 fh_init (void)
103 {
104   inline_file = create_handle ("INLINE", xstrdup ("INLINE"), FH_REF_INLINE,
105                                "Auto");
106   inline_file->record_width = 80;
107   inline_file->tab_width = 8;
108 }
109
110 /* Removes all named file handles from the global list. */
111 void
112 fh_done (void)
113 {
114   struct file_handle *handle, *next;
115
116   HMAP_FOR_EACH_SAFE (handle, next,
117                       struct file_handle, name_node, &named_handles)
118     unname_handle (handle);
119
120   free_handle (inline_file);
121 }
122
123 /* Free HANDLE and remove it from the global list. */
124 static void
125 free_handle (struct file_handle *handle)
126 {
127   if (handle == NULL)
128     return;
129
130   /* Remove handle from global list. */
131   if (handle->id != NULL)
132     hmap_delete (&named_handles, &handle->name_node);
133
134   /* Free data. */
135   free (handle->id);
136   free (handle->name);
137   free (handle->file_name);
138   free (handle->file_name_encoding);
139   free (handle->encoding);
140   free (handle);
141 }
142
143 /* Make HANDLE unnamed, so that it can no longer be referenced by
144    name.  The caller must hold a reference to HANDLE, which is
145    not affected by this function. */
146 static void
147 unname_handle (struct file_handle *handle)
148 {
149   assert (handle->id != NULL);
150   free (handle->id);
151   handle->id = NULL;
152   hmap_delete (&named_handles, &handle->name_node);
153
154   /* Drop the reference held by the named_handles table. */
155   fh_unref (handle);
156 }
157
158 /* Increments HANDLE's reference count and returns HANDLE. */
159 struct file_handle *
160 fh_ref (struct file_handle *handle)
161 {
162   if (handle == fh_inline_file ())
163     return handle;
164   assert (handle->ref_cnt > 0);
165   handle->ref_cnt++;
166   return handle;
167 }
168
169 /* Decrements HANDLE's reference count.
170    If the reference count drops to 0, HANDLE is destroyed. */
171 void
172 fh_unref (struct file_handle *handle)
173 {
174   if (handle != NULL)
175     {
176       if (handle == fh_inline_file ())
177         return;
178       assert (handle->ref_cnt > 0);
179       if (--handle->ref_cnt == 0)
180         free_handle (handle);
181     }
182 }
183
184 /* Make HANDLE unnamed, so that it can no longer be referenced by
185    name.  The caller must hold a reference to HANDLE, which is
186    not affected by this function.
187
188    This function ignores a null pointer as input.  It has no
189    effect on the inline handle, which is always named INLINE.*/
190 void
191 fh_unname (struct file_handle *handle)
192 {
193   assert (handle->ref_cnt > 1);
194   if (handle != fh_inline_file () && handle->id != NULL)
195     unname_handle (handle);
196 }
197
198 /* Returns the handle with the given ID, or a null pointer if
199    there is none. */
200 struct file_handle *
201 fh_from_id (const char *id)
202 {
203   struct file_handle *handle;
204
205   HMAP_FOR_EACH_WITH_HASH (handle, struct file_handle, name_node,
206                            utf8_hash_case_string (id, 0), &named_handles)
207     if (!utf8_strcasecmp (id, handle->id))
208       {
209         return fh_ref (handle);
210       }
211
212   return NULL;
213 }
214
215 /* Creates a new handle with identifier ID (which may be null)
216    and name HANDLE_NAME that refers to REFERENT.  Links the new
217    handle into the global list.  Returns the new handle.
218
219    The new handle is not fully initialized.  The caller is
220    responsible for completing its initialization. */
221 static struct file_handle *
222 create_handle (const char *id, char *handle_name, enum fh_referent referent,
223                const char *encoding)
224 {
225   struct file_handle *handle = XZALLOC (struct file_handle);
226
227   handle->ref_cnt = 1;
228   handle->id = xstrdup_if_nonnull (id);
229   handle->name = handle_name;
230   handle->referent = referent;
231   handle->encoding = xstrdup (encoding);
232
233   if (id != NULL)
234     {
235       hmap_insert (&named_handles, &handle->name_node,
236                    utf8_hash_case_string (handle->id, 0));
237     }
238
239   return handle;
240 }
241
242 /* Returns the unique handle of referent type FH_REF_INLINE,
243    which refers to the "inline file" that represents character
244    data in the command file between BEGIN DATA and END DATA. */
245 struct file_handle *
246 fh_inline_file (void)
247 {
248   return inline_file;
249 }
250
251 /* Creates and returns a new file handle with the given ID, which may be null.
252    If it is non-null, it must be a UTF-8 encoded string that is unique among
253    existing file identifiers.  The new handle is associated with file FILE_NAME
254    and the given PROPERTIES. */
255 struct file_handle *
256 fh_create_file (const char *id, const char *file_name, const char *file_name_encoding,
257                 const struct fh_properties *properties)
258 {
259   char *handle_name;
260   struct file_handle *handle;
261
262   handle_name = id != NULL ? xstrdup (id) : xasprintf ("`%s'", file_name);
263   handle = create_handle (id, handle_name, FH_REF_FILE, properties->encoding);
264   handle->file_name = xstrdup (file_name);
265   handle->file_name_encoding = xstrdup_if_nonnull (file_name_encoding);
266   handle->mode = properties->mode;
267   handle->line_ends = properties->line_ends;
268   handle->record_width = properties->record_width;
269   handle->tab_width = properties->tab_width;
270   return handle;
271 }
272
273 /* Creates a new file handle with the given ID, which must be
274    unique among existing file identifiers.  The new handle is
275    associated with a dataset file (initially empty). */
276 struct file_handle *
277 fh_create_dataset (struct dataset *ds)
278 {
279   const char *name;
280   struct file_handle *handle;
281
282   name = dataset_name (ds);
283   if (name[0] == '\0')
284     name = _("active dataset");
285
286   handle = create_handle (NULL, xstrdup (name), FH_REF_DATASET, C_ENCODING);
287   handle->ds = ds;
288   return handle;
289 }
290
291 /* Returns a set of default properties for a file handle. */
292 const struct fh_properties *
293 fh_default_properties (void)
294 {
295 #if defined _WIN32 || defined __WIN32__
296 #define DEFAULT_LINE_ENDS FH_END_CRLF
297 #else
298 #define DEFAULT_LINE_ENDS FH_END_LF
299 #endif
300
301   static const struct fh_properties default_properties
302     = {FH_MODE_TEXT, DEFAULT_LINE_ENDS, 1024, 4, (char *) "Auto"};
303   return &default_properties;
304 }
305
306 /* Returns the identifier that may be used in syntax to name the
307    given HANDLE, which takes the form of a PSPP identifier.  If
308    HANDLE has no identifier, returns a null pointer.
309
310    Return value is owned by the file handle.*/
311 const char *
312 fh_get_id (const struct file_handle *handle)
313 {
314   return handle->id;
315 }
316
317 /* Returns a user-friendly string to identify the given HANDLE.
318    If HANDLE was created by referring to a file name, returns the
319    file name, enclosed in double quotes.  Return value is owned
320    by the file handle.
321
322    Useful for printing error messages about use of file handles.  */
323 const char *
324 fh_get_name (const struct file_handle *handle)
325 {
326   return handle->name;
327 }
328
329 /* Returns the type of object that HANDLE refers to. */
330 enum fh_referent
331 fh_get_referent (const struct file_handle *handle)
332 {
333   return handle->referent;
334 }
335
336 /* Returns the name of the file associated with HANDLE. */
337 const char *
338 fh_get_file_name (const struct file_handle *handle)
339 {
340   assert (handle->referent == FH_REF_FILE);
341   return handle->file_name;
342 }
343
344
345 /* Returns the character encoding of the name of the file associated with HANDLE. */
346 const char *
347 fh_get_file_name_encoding (const struct file_handle *handle)
348 {
349   assert (handle->referent == FH_REF_FILE);
350   return handle->file_name_encoding;
351 }
352
353
354 /* Returns the mode of HANDLE. */
355 enum fh_mode
356 fh_get_mode (const struct file_handle *handle)
357 {
358   assert (handle->referent == FH_REF_FILE);
359   return handle->mode;
360 }
361
362 /* Returns the line ends of HANDLE, which must be a handle associated with a
363    file. */
364 enum fh_line_ends
365 fh_get_line_ends (const struct file_handle *handle)
366 {
367   assert (handle->referent == FH_REF_FILE);
368   return handle->line_ends;
369 }
370
371 /* Returns the width of a logical record on HANDLE. */
372 size_t
373 fh_get_record_width (const struct file_handle *handle)
374 {
375   assert (handle->referent & (FH_REF_FILE | FH_REF_INLINE));
376   return handle->record_width;
377 }
378
379 /* Returns the number of characters per tab stop for HANDLE, or
380    zero if tabs are not to be expanded.  Applicable only to
381    FH_MODE_TEXT files. */
382 size_t
383 fh_get_tab_width (const struct file_handle *handle)
384 {
385   assert (handle->referent & (FH_REF_FILE | FH_REF_INLINE));
386   return handle->tab_width;
387 }
388
389 /* Returns the encoding of characters read from HANDLE. */
390 const char *
391 fh_get_encoding (const struct file_handle *handle)
392 {
393   return handle->encoding;
394 }
395
396 /* Returns true if A and B refer to the same file or dataset, false
397    otherwise. */
398 bool
399 fh_equal (const struct file_handle *a, const struct file_handle *b)
400 {
401   if (a->referent != b->referent)
402     return false;
403
404   switch (a->referent)
405     {
406     case FH_REF_FILE:
407       {
408         struct file_identity *a_id = fh_get_identity (a);
409         struct file_identity *b_id = fh_get_identity (b);
410
411         int cmp = fh_compare_file_identities (a_id, b_id);
412
413         fh_free_identity (a_id);
414         fh_free_identity (b_id);
415
416         return cmp == 0;
417       }
418
419     case FH_REF_INLINE:
420       return true;
421
422     case FH_REF_DATASET:
423       return a->ds == b->ds;
424
425     default:
426       NOT_REACHED ();
427     }
428 }
429
430 /* Returns the dataset handle associated with HANDLE.
431    Applicable to only FH_REF_DATASET files. */
432 struct dataset *
433 fh_get_dataset (const struct file_handle *handle)
434 {
435   assert (handle->referent == FH_REF_DATASET);
436   return handle->ds;
437 }
438
439 /* Returns the current default handle. */
440 struct file_handle *
441 fh_get_default_handle (void)
442 {
443   return default_handle ? default_handle : fh_inline_file ();
444 }
445
446 /* Sets NEW_DEFAULT_HANDLE as the default handle. */
447 void
448 fh_set_default_handle (struct file_handle *new_default_handle)
449 {
450   assert (new_default_handle == NULL
451           || (new_default_handle->referent & (FH_REF_INLINE | FH_REF_FILE)));
452   if (default_handle != NULL && default_handle != inline_file)
453     fh_unref (default_handle);
454   default_handle = new_default_handle;
455   if (default_handle != NULL)
456     default_handle = fh_ref (default_handle);
457 }
458 \f
459 /* Information about a file handle's readers or writers. */
460 struct fh_lock
461   {
462     struct hmap_node node;      /* hmap_node member. */
463
464     /* Hash key. */
465     enum fh_referent referent;  /* Type of underlying file. */
466     union
467       {
468         struct file_identity *file; /* FH_REF_FILE only. */
469         unsigned int unique_id;    /* FH_REF_DATASET only. */
470       }
471     u;
472     enum fh_access access;      /* Type of file access. */
473
474     /* Number of openers. */
475     size_t open_cnt;
476
477     /* Applicable only when open_cnt > 0. */
478     bool exclusive;             /* No other openers allowed? */
479     const char *type;           /* Human-readable type of file. */
480     void *aux;                  /* Owner's auxiliary data. */
481   };
482
483
484 static void make_key (struct fh_lock *, const struct file_handle *,
485                       enum fh_access);
486 static void free_key (struct fh_lock *);
487 static int compare_fh_locks (const struct fh_lock *a, const struct fh_lock *b);
488 static unsigned int hash_fh_lock (const struct fh_lock *lock);
489
490 /* Tries to lock handle H for the given kind of ACCESS and TYPE
491    of file.  Returns a pointer to a struct fh_lock if successful,
492    otherwise a null pointer.
493
494    H's referent type must be one of the bits in MASK.  The caller
495    must verify this ahead of time; we simply assert it here.
496
497    TYPE is the sort of file, e.g. "system file".  Only one type
498    of access is allowed on a given file at a time for reading,
499    and similarly for writing.  If successful, a reference to TYPE
500    is retained, so it should probably be a string literal.
501
502    TYPE should be marked with N_() in the caller: that is, the
503    caller should not translate it with gettext, but fh_lock will
504    do so.
505
506    ACCESS specifies whether the lock is for reading or writing.
507    EXCLUSIVE is true to require exclusive access, false to allow
508    sharing with other accessors.  Exclusive read access precludes
509    other readers, but not writers; exclusive write access
510    precludes other writers, but not readers.  A sharable read or
511    write lock precludes reader or writers, respectively, of a
512    different TYPE.
513
514    A lock may be associated with auxiliary data.  See
515    fh_lock_get_aux and fh_lock_set_aux for more details. */
516 struct fh_lock *
517 fh_lock (struct file_handle *h, enum fh_referent mask UNUSED,
518          const char *type, enum fh_access access, bool exclusive)
519 {
520   struct fh_lock *key = NULL;
521   size_t hash ;
522   struct fh_lock *lock = NULL;
523   bool found_lock = false;
524
525   assert ((fh_get_referent (h) & mask) != 0);
526   assert (access == FH_ACC_READ || access == FH_ACC_WRITE);
527
528   key = xmalloc (sizeof *key);
529
530   make_key (key, h, access);
531
532   key->open_cnt = 1;
533   key->exclusive = exclusive;
534   key->type = type;
535   key->aux = NULL;
536
537   hash = hash_fh_lock (key);
538
539   HMAP_FOR_EACH_WITH_HASH (lock, struct fh_lock, node, hash, &locks)
540     {
541       if (0 == compare_fh_locks (lock, key))
542         {
543           found_lock = true;
544           break;
545         }
546     }
547
548   if (found_lock)
549     {
550       if (strcmp (lock->type, type))
551         {
552           if (access == FH_ACC_READ)
553             msg (SE, _("Can't read from %s as a %s because it is "
554                        "already being read as a %s."),
555                  fh_get_name (h), gettext (type), gettext (lock->type));
556           else
557             msg (SE, _("Can't write to %s as a %s because it is "
558                        "already being written as a %s."),
559                  fh_get_name (h), gettext (type), gettext (lock->type));
560           return NULL;
561         }
562       else if (exclusive || lock->exclusive)
563         {
564           msg (SE, _("Can't re-open %s as a %s."),
565                fh_get_name (h), gettext (type));
566           return NULL;
567         }
568       lock->open_cnt++;
569
570       free_key (key);
571       free (key);
572
573       return lock;
574     }
575
576   hmap_insert (&locks, &key->node, hash);
577   found_lock = false;
578   HMAP_FOR_EACH_WITH_HASH (lock, struct fh_lock, node, hash, &locks)
579     {
580       if (0 == compare_fh_locks (lock, key))
581         {
582           found_lock = true;
583           break;
584         }
585     }
586
587   assert (found_lock);
588
589   return key;
590 }
591
592 /* Releases LOCK that was acquired with fh_lock.
593    Returns true if LOCK is still locked, because other clients
594    also had it locked.
595
596    Returns false if LOCK has now been destroyed.  In this case
597    the caller must ensure that any auxiliary data associated with
598    LOCK is destroyed, to avoid a memory leak.  The caller must
599    obtain a pointer to the auxiliary data, e.g. via
600    fh_lock_get_aux *before* calling fh_unlock (because it yields
601    undefined behavior to call fh_lock_get_aux on a destroyed
602    lock).  */
603 bool
604 fh_unlock (struct fh_lock *lock)
605 {
606   if (lock != NULL)
607     {
608       assert (lock->open_cnt > 0);
609       if (--lock->open_cnt == 0)
610         {
611           hmap_delete (&locks, &lock->node);
612           free_key (lock);
613           free (lock);
614           return false;
615         }
616     }
617   return true;
618 }
619
620 /* Returns auxiliary data for LOCK.
621
622    Auxiliary data is shared by every client that holds LOCK (for
623    an exclusive lock, this is a single client).  To avoid leaks,
624    auxiliary data must be released before LOCK is destroyed. */
625 void *
626 fh_lock_get_aux (const struct fh_lock *lock)
627 {
628   return lock->aux;
629 }
630
631 /* Sets the auxiliary data for LOCK to AUX. */
632 void
633 fh_lock_set_aux (struct fh_lock *lock, void *aux)
634 {
635   lock->aux = aux;
636 }
637
638 /* Returns true if HANDLE is locked for the given type of ACCESS,
639    false otherwise. */
640 bool
641 fh_is_locked (const struct file_handle *handle, enum fh_access access)
642 {
643   struct fh_lock key;
644   const struct fh_lock *k = NULL;
645   bool is_locked = false;
646   size_t hash ;
647
648   make_key (&key, handle, access);
649
650   hash = hash_fh_lock (&key);
651
652
653   HMAP_FOR_EACH_WITH_HASH (k, struct fh_lock, node, hash, &locks)
654     {
655       if (0 == compare_fh_locks (k, &key))
656         {
657           is_locked = true;
658           break;
659         }
660     }
661
662   free_key (&key);
663
664   return is_locked;
665 }
666
667 /* Initializes the key fields in LOCK for looking up or inserting
668    handle H for the given kind of ACCESS. */
669 static void
670 make_key (struct fh_lock *lock, const struct file_handle *h,
671           enum fh_access access)
672 {
673   lock->referent = fh_get_referent (h);
674   lock->access = access;
675   if (lock->referent == FH_REF_FILE)
676     lock->u.file = fh_get_identity (h);
677   else if (lock->referent == FH_REF_DATASET)
678     lock->u.unique_id = dataset_seqno (fh_get_dataset (h));
679 }
680
681 /* Frees the key fields in LOCK. */
682 static void
683 free_key (struct fh_lock *lock)
684 {
685   if (lock->referent == FH_REF_FILE)
686     fh_free_identity (lock->u.file);
687 }
688
689 /* Compares the key fields in struct fh_lock objects A and B and
690    returns a strcmp()-type result. */
691 static int
692 compare_fh_locks (const struct fh_lock *a, const struct fh_lock *b)
693 {
694   if (a->referent != b->referent)
695     return a->referent < b->referent ? -1 : 1;
696   else if (a->access != b->access)
697     return a->access < b->access ? -1 : 1;
698   else if (a->referent == FH_REF_FILE)
699     return fh_compare_file_identities (a->u.file, b->u.file);
700   else if (a->referent == FH_REF_DATASET)
701     return (a->u.unique_id < b->u.unique_id ? -1
702             : a->u.unique_id > b->u.unique_id);
703   else
704     return 0;
705 }
706
707 /* Returns a hash value for LOCK. */
708 static unsigned int
709 hash_fh_lock (const struct fh_lock *lock)
710 {
711   unsigned int basis;
712   if (lock->referent == FH_REF_FILE)
713     basis = fh_hash_identity (lock->u.file);
714   else if (lock->referent == FH_REF_DATASET)
715     basis = lock->u.unique_id;
716   else
717     basis = 0;
718   return hash_int ((lock->referent << 3) | lock->access, basis);
719 }
720
721 \f
722
723
724
725
726 /* A file's identity:
727
728    - For a file that exists, this is its device and inode.
729
730    - For a file that does not exist, but which has a directory
731      name that exists, this is the device and inode of the
732      directory, plus the file's base name.
733
734    - For a file that does not exist and has a nonexistent
735      directory, this is the file name.
736
737    Windows doesn't have inode numbers, so we just use the name
738    there. */
739 struct file_identity
740 {
741   unsigned long long device;               /* Device number. */
742   unsigned long long inode;                /* Inode number. */
743   char *name;                 /* File name, where needed, otherwise NULL. */
744 };
745
746 /* Returns a pointer to a dynamically allocated structure whose
747    value can be used to tell whether two files are actually the
748    same file.  The caller is responsible for freeing the structure with
749    fh_free_identity() when finished. */
750 static struct file_identity *
751 fh_get_identity (const struct file_handle *fh)
752 {
753   struct file_identity *identity = xmalloc (sizeof *identity);
754
755   const char *file_name = fh_get_file_name (fh);
756
757 #if !(defined _WIN32 || defined __WIN32__)
758   struct stat s;
759   if (lstat (file_name, &s) == 0)
760     {
761       identity->device = s.st_dev;
762       identity->inode = s.st_ino;
763       identity->name = NULL;
764     }
765   else
766     {
767       char *dir = dir_name (file_name);
768       if (last_component (file_name) != NULL && stat (dir, &s) == 0)
769         {
770           identity->device = s.st_dev;
771           identity->inode = s.st_ino;
772           identity->name = base_name (file_name);
773         }
774       else
775         {
776           identity->device = 0;
777           identity->inode = 0;
778           identity->name = xstrdup (file_name);
779         }
780       free (dir);
781     }
782 #else /* Windows */
783   bool ok = false;
784   HANDLE h = CreateFile (file_name, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
785   if (h != INVALID_HANDLE_VALUE)
786   {
787     BY_HANDLE_FILE_INFORMATION fi;
788     ok = GetFileInformationByHandle (h, &fi);
789     if (ok)
790       {
791         identity->device = fi.dwVolumeSerialNumber;
792         identity->inode = fi.nFileIndexHigh;
793         identity->inode <<= (sizeof fi.nFileIndexLow) * CHAR_BIT;
794         identity->inode |= fi.nFileIndexLow;
795         identity->name = 0;
796       }
797     CloseHandle (h);
798   }
799
800   if (!ok)
801     {
802       identity->device = 0;
803       identity->inode = 0;
804
805       size_t bufsize;
806       size_t pathlen = 255;
807       char *cname = NULL;
808       do
809       {
810         bufsize = pathlen;
811         cname = xrealloc (cname, bufsize);
812         pathlen = GetFullPathName (file_name, bufsize, cname, NULL);
813       }
814       while (pathlen > bufsize);
815       identity->name = xstrdup (cname);
816       free (cname);
817       str_lowercase (identity->name);
818     }
819 #endif /* Windows */
820
821   return identity;
822 }
823
824 /* Frees IDENTITY obtained from fh_get_identity(). */
825 void
826 fh_free_identity (struct file_identity *identity)
827 {
828   if (identity != NULL)
829     {
830       free (identity->name);
831       free (identity);
832     }
833 }
834
835 /* Compares A and B, returning a strcmp()-type result. */
836 int
837 fh_compare_file_identities (const struct file_identity *a,
838                             const struct file_identity *b)
839 {
840   if (a->device != b->device)
841     return a->device < b->device ? -1 : 1;
842   else if (a->inode != b->inode)
843     return a->inode < b->inode ? -1 : 1;
844   else if (a->name != NULL)
845     return b->name != NULL ? strcmp (a->name, b->name) : 1;
846   else
847     return b->name != NULL ? -1 : 0;
848 }
849
850 /* Returns a hash value for IDENTITY. */
851 unsigned int
852 fh_hash_identity (const struct file_identity *identity)
853 {
854   unsigned int hash = hash_int (identity->device, identity->inode);
855   if (identity->name != NULL)
856     hash = hash_string (identity->name, hash);
857   return hash;
858 }