1 /* PSPP - computes sample statistics.
2 Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
3 Written by Ben Pfaff <blp@gnu.org>.
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
33 #include "xreadlink.h"
36 #define _(msgid) gettext (msgid)
38 #include "debug-print.h"
40 /* PORTME: Everything in this file is system dependent. */
48 #include "stat-macros.h"
55 #include <win32/windows.h>
64 const char *config_path;
69 config_path = fn_getenv_default ("STAT_CONFIG_PATH", default_config_path);
72 /* Functions for performing operations on filenames. */
74 /* Substitutes $variables as defined by GETENV into INPUT and returns
75 a copy of the resultant string. Supports $var and ${var} syntaxes;
76 $$ substitutes as $. */
78 fn_interp_vars (const char *input, const char *(*getenv) (const char *))
82 if (NULL == strchr (input, '$'))
83 return xstrdup (input);
85 ds_init (&output, strlen (input));
91 return ds_c_str (&output);
98 ds_putc (&output, '$');
107 start = ds_length (&output);
114 else if (*input == '{')
122 while (*input && *input != stop
123 && (stop || isalpha ((unsigned char) *input)))
124 ds_putc (&output, *input++);
126 value = getenv (ds_c_str (&output) + start);
127 ds_truncate (&output, start);
128 ds_puts (&output, value);
130 if (stop && *input == stop)
135 ds_putc (&output, *input++);
140 /* Expands csh tilde notation from the path INPUT into a malloc()'d
143 fn_tilde_expand (const char *input)
146 struct string output;
148 if (NULL == strchr (input, '~'))
149 return xstrdup (input);
150 ds_init (&output, strlen (input));
154 for (ip = input; *ip; )
155 if (*ip != '~' || (ip != input && ip[-1] != PATH_DELIMITER))
156 ds_putc (&output, *ip++);
159 static const char stop_set[3] = {DIR_SEPARATOR, PATH_DELIMITER, 0};
164 cp = ip + strcspn (ip, stop_set);
171 strncpy (username, ip, cp - ip + 1);
173 pwd = getpwnam (username);
175 if (!pwd || !pwd->pw_dir)
176 ds_putc (&output, *ip++);
178 ds_puts (&output, pwd->pw_dir);
182 const char *home = fn_getenv ("HOME");
184 ds_putc (&output, *ip++);
186 ds_puts (&output, home);
192 return ds_c_str (&output);
196 fn_tilde_expand (const char *input)
198 return xstrdup (input);
202 /* Searches for a configuration file with name NAME in the path given
203 by PATH, which is tilde- and environment-interpolated. Directories
204 in PATH are delimited by PATH_DELIMITER, defined in <pref.h>.
205 Returns the malloc'd full name of the first file found, or NULL if
208 If PREPEND is non-NULL, then it is prepended to each filename;
209 i.e., it looks like PREPEND/PATH_COMPONENT/NAME. This is not done
210 with absolute directories in the path. */
211 #if defined (unix) || defined (__MSDOS__) || defined (__WIN32__)
213 fn_search_path (const char *basename, const char *path, const char *prepend)
216 struct string filename;
219 if (fn_absolute_p (basename))
220 return fn_tilde_expand (basename);
223 char *temp = fn_interp_vars (path, fn_getenv);
224 bp = subst_path = fn_tilde_expand (temp);
228 msg (VM (4), _("Searching for `%s'..."), basename);
229 ds_init (&filename, 64);
236 msg (VM (4), _("Search unsuccessful!"));
237 ds_destroy (&filename);
242 for (ep = bp; *ep && *ep != PATH_DELIMITER; ep++)
245 /* Paste together PREPEND/PATH/BASENAME. */
246 ds_clear (&filename);
247 if (prepend && !fn_absolute_p (bp))
249 ds_puts (&filename, prepend);
250 ds_putc (&filename, DIR_SEPARATOR);
252 ds_concat (&filename, bp, ep - bp);
254 && ds_c_str (&filename)[ds_length (&filename) - 1] != DIR_SEPARATOR)
255 ds_putc (&filename, DIR_SEPARATOR);
256 ds_puts (&filename, basename);
258 msg (VM (5), " - %s", ds_c_str (&filename));
259 if (fn_exists_p (ds_c_str (&filename)))
261 msg (VM (4), _("Found `%s'."), ds_c_str (&filename));
263 return ds_c_str (&filename);
268 msg (VM (4), _("Search unsuccessful!"));
270 ds_destroy (&filename);
276 #else /* not unix, msdog, lose32 */
278 fn_search_path (const char *basename, const char *path, const char *prepend)
280 size_t size = strlen (path) + 1 + strlen (basename) + 1;
285 size += strlen (prepend) + 1;
286 string = xmalloc (size);
291 cp = stpcpy (cp, prepend);
292 *cp++ = DIR_SEPARATOR;
294 cp = stpcpy (cp, path);
295 *cp++ = DIR_SEPARATOR;
296 strcpy (cp, basename);
300 #endif /* not unix, msdog, lose32 */
302 /* Prepends directory DIR to filename FILE and returns a malloc()'d
305 fn_prepend_dir (const char *file, const char *dir)
310 if (fn_absolute_p (file))
311 return xstrdup (file);
313 temp = xmalloc (strlen (file) + 1 + strlen (dir) + 1);
314 cp = stpcpy (temp, dir);
315 if (cp != temp && cp[-1] != DIR_SEPARATOR)
316 *cp++ = DIR_SEPARATOR;
317 cp = stpcpy (cp, file);
322 /* fn_normalize(): This very OS-dependent routine canonicalizes
323 filename FN1. The filename should not need to be the name of an
324 existing file. Returns a malloc()'d copy of the canonical name.
325 This function must always succeed; if it needs to bail out then it
326 should return xstrdup(FN1). */
329 fn_normalize (const char *filename)
332 char *fn1, *fn2, *dest;
335 if (fn_special_p (filename))
336 return xstrdup (filename);
338 fn1 = fn_tilde_expand (filename);
340 /* Follow symbolic links. */
344 fn1 = fn_readlink (fn1);
353 maxlen = strlen (fn1) * 2;
356 dest = fn2 = xmalloc (maxlen + 1);
359 if (*src == DIR_SEPARATOR)
364 while (getcwd (dest, maxlen - (dest - fn2)) == NULL && errno == ERANGE)
367 dest = fn2 = xrealloc (fn2, maxlen + 1);
376 dest = strchr (fn2, '\0');
377 if (dest - fn2 >= maxlen)
379 int ofs = dest - fn2;
381 fn2 = xrealloc (fn2, maxlen + 1);
384 if (dest[-1] != DIR_SEPARATOR)
385 *dest++ = DIR_SEPARATOR;
395 if (c == DIR_SEPARATOR || c == 0)
397 /* remove `./', `../' from directory */
398 if (dest[-1] == '.' && dest[-2] == DIR_SEPARATOR)
400 else if (dest[-1] == '.' && dest[-2] == '.' && dest[-3] == DIR_SEPARATOR)
405 while (dest[-1] != DIR_SEPARATOR)
408 else if (dest[-1] != DIR_SEPARATOR) /* remove extra slashes */
413 if (dest[-1] == DIR_SEPARATOR && dest > fn2 + 1)
418 return xrealloc (fn2, strlen (fn2) + 1);
426 if (dest - fn2 >= maxlen)
428 int ofs = dest - fn2;
430 fn2 = xrealloc (fn2, maxlen + 1);
437 #elif defined (__WIN32__)
439 fn_normalize (const char *fn1)
445 /* Don't change special filenames. */
446 if (is_special_filename (filename))
447 return xstrdup (filename);
449 /* First find the required buffer length. */
450 len = GetFullPathName (fn1, 0, NULL, NULL);
457 /* Then make a buffer that big. */
459 success = GetFullPathName (fn1, len, fn2, NULL);
460 if (success >= len || success == 0)
470 fn_normalize (const char *fn1)
472 char *fn2 = _fullpath (NULL, fn1, 0);
476 for (cp = fn2; *cp; cp++)
477 *cp = toupper ((unsigned char) (*cp));
480 return xstrdup (fn1);
484 fn_normalize (const char *fn1)
486 char *fn2 = xmalloc (1024);
488 fn2 = xrealloc (fn2, strlen (fn2) + 1);
491 #else /* not Lose32, Unix, or DJGPP */
493 fn_normalize (const char *fn)
497 #endif /* not Lose32, Unix, or DJGPP */
499 /* Returns the directory part of FILENAME, as a malloc()'d
502 fn_dirname (const char *filename)
508 len = strlen (filename);
509 if (len == 1 && filename[0] == '/')
511 else if (len && filename[len - 1] == DIR_SEPARATOR)
512 p = buf_find_reverse (filename, len - 1, filename + len - 1, 1);
514 p = strrchr (filename, DIR_SEPARATOR);
518 s = xmalloc (p - filename + 1);
519 memcpy (s, filename, p - filename);
525 /* Returns the basename part of FILENAME as a malloc()'d string. */
528 fn_basename (const char *filename)
530 /* Not used, not implemented. */
535 /* Returns the extension part of FILENAME as a malloc()'d string.
536 If FILENAME does not have an extension, returns an empty
539 fn_extension (const char *filename)
541 const char *extension = strrchr (filename, '.');
542 if (extension == NULL)
544 return xstrdup (extension);
548 /* Returns the current working directory, as a malloc()'d string.
554 char *buffer = xmalloc (size);
558 char *value = getcwd (buffer, size);
564 buffer = xmalloc (size);
572 char *buffer = xmalloc (size);
584 /* Find out information about files. */
586 /* Returns nonzero iff NAME specifies an absolute filename. */
588 fn_absolute_p (const char *name)
592 || !strncmp (name, "./", 2)
593 || !strncmp (name, "../", 3)
596 #elif defined (__MSDOS__)
598 || !strncmp (name, ".\\", 2)
599 || !strncmp (name, "..\\", 3)
600 || (name[0] && name[1] == ':'))
607 /* Returns 1 if the filename specified is a virtual file that doesn't
608 really exist on disk, 0 if it's a real filename. */
610 fn_special_p (const char *filename)
612 if (!strcmp (filename, "-") || !strcmp (filename, "stdin")
613 || !strcmp (filename, "stdout") || !strcmp (filename, "stderr")
615 || filename[0] == '|'
616 || (*filename && filename[strlen (filename) - 1] == '|')
624 /* Returns nonzero if file with name NAME exists. */
626 fn_exists_p (const char *name)
631 return stat (name, &temp) == 0;
633 FILE *f = fopen (name, "r");
641 /* Returns the symbolic link value for FILENAME as a dynamically
642 allocated buffer, or a null pointer on failure. */
644 fn_readlink (const char *filename)
646 return xreadlink (filename, 32);
649 /* Environment variables. */
651 /* Simulates $VER and $ARCH environment variables. */
653 fn_getenv (const char *s)
655 if (!strcmp (s, "VER"))
656 return fn_getenv_default ("STAT_VER", bare_version);
657 else if (!strcmp (s, "ARCH"))
658 return fn_getenv_default ("STAT_ARCH", host_system);
663 /* Returns getenv(KEY) if that's non-NULL; else returns DEF. */
665 fn_getenv_default (const char *key, const char *def)
667 const char *value = getenv (key);
668 return value ? value : def;
671 /* Basic file handling. */
673 /* Used for giving an error message on a set_safer security
676 safety_violation (const char *fn)
678 msg (SE, _("Not opening pipe file `%s' because SAFER option set."), fn);
683 /* As a general comment on the following routines, a `sensible value'
684 for errno includes 0 if there is no associated system error. The
685 routines will only set errno to 0 if there is an error in a
686 callback that sets errno to 0; they themselves won't. */
688 /* File open routine that understands `-' as stdin/stdout and `|cmd'
689 as a pipe to command `cmd'. Returns resultant FILE on success,
690 NULL on failure. If NULL is returned then errno is set to a
693 fn_open (const char *fn, const char *mode)
695 assert (mode[0] == 'r' || mode[0] == 'w');
697 if (mode[0] == 'r' && (!strcmp (fn, "stdin") || !strcmp (fn, "-")))
699 else if (mode[0] == 'w' && (!strcmp (fn, "stdout") || !strcmp (fn, "-")))
701 else if (mode[0] == 'w' && !strcmp (fn, "stderr"))
707 if (get_safer_mode ())
708 return safety_violation (fn);
710 return popen (&fn[1], mode);
712 else if (*fn && fn[strlen (fn) - 1] == '|')
717 if (get_safer_mode ())
718 return safety_violation (fn);
720 s = local_alloc (strlen (fn));
721 memcpy (s, fn, strlen (fn) - 1);
722 s[strlen (fn) - 1] = 0;
733 FILE *f = fopen (fn, mode);
735 if (f && mode[0] == 'w')
736 setvbuf (f, NULL, _IOLBF, 0);
742 /* Counterpart to fn_open that closes file F with name FN; returns 0
743 on success, EOF on failure. If EOF is returned, errno is set to a
746 fn_close (const char *fn, FILE *f)
748 if (!strcmp (fn, "-"))
751 else if (fn[0] == '|' || (*fn && fn[strlen (fn) - 1] == '|'))
761 /* More extensive file handling. */
763 /* File open routine that extends fn_open(). Opens or reopens a
764 file according to the contents of file_ext F. Returns nonzero on
765 success. If 0 is returned, errno is set to a sensible value. */
767 fn_open_ext (struct file_ext *f)
771 p = strstr (f->filename, "%d");
774 char *s = local_alloc (strlen (f->filename)
775 + INT_STRLEN_BOUND (int) - 1);
778 memcpy (s, f->filename, p - f->filename);
779 cp = spprintf (&s[p - f->filename], "%d", *f->sequence_no);
787 if (f->preclose (f) == 0)
790 if (EOF == fn_close (f->filename, f->file) || error)
804 f->file = fn_open (s, f->mode);
807 if (f->file && f->postopen)
808 if (f->postopen (f) == 0)
811 fn_close (f->filename, f->file);
817 return (f->file != NULL);
823 f->file = fn_open (f->filename, f->mode);
825 if (f->file && f->postopen)
826 if (f->postopen (f) == 0)
829 fn_close (f->filename, f->file);
835 return (f->file != NULL);
839 /* Properly closes the file associated with file_ext F, if any.
840 Return nonzero on success. If zero is returned, errno is set to a
843 fn_close_ext (struct file_ext *f)
850 if (f->preclose (f) == 0)
853 if (EOF == fn_close (f->filename, f->file) || error)
869 /* A file's identity. */
872 dev_t device; /* Device number. */
873 ino_t inode; /* Inode number. */
876 /* Returns a pointer to a dynamically allocated structure whose
877 value can be used to tell whether two files are actually the
878 same file. Returns a null pointer if no information about the
879 file is available, perhaps because it does not exist. The
880 caller is responsible for freeing the structure with
881 fn_free_identity() when finished. */
882 struct file_identity *
883 fn_get_identity (const char *filename)
887 if (stat (filename, &s) == 0)
889 struct file_identity *identity = xmalloc (sizeof *identity);
890 identity->device = s.st_dev;
891 identity->inode = s.st_ino;
898 /* Frees IDENTITY obtained from fn_get_identity(). */
900 fn_free_identity (struct file_identity *identity)
905 /* Compares A and B, returning a strcmp()-type result. */
907 fn_compare_file_identities (const struct file_identity *a,
908 const struct file_identity *b)
912 if (a->device != b->device)
913 return a->device < b->device ? -1 : 1;
915 return a->inode < b->inode ? -1 : a->inode > b->inode;
918 /* A file's identity. */
921 char *normalized_filename; /* File's normalized name. */
924 /* Returns a pointer to a dynamically allocated structure whose
925 value can be used to tell whether two files are actually the
926 same file. Returns a null pointer if no information about the
927 file is available, perhaps because it does not exist. The
928 caller is responsible for freeing the structure with
929 fn_free_identity() when finished. */
930 struct file_identity *
931 fn_get_identity (const char *filename)
933 struct file_identity *identity = xmalloc (sizeof *identity);
934 identity->normalized_filename = fn_normalize (filename);
938 /* Frees IDENTITY obtained from fn_get_identity(). */
940 fn_free_identity (struct file_identity *identity)
942 if (identity != NULL)
944 free (identity->normalized_filename);
949 /* Compares A and B, returning a strcmp()-type result. */
951 fn_compare_file_identities (const struct file_identity *a,
952 const struct file_identity *b)
954 return strcmp (a->normalized_filename, b->normalized_filename);
956 #endif /* not unix */