Added a --enable-debug option to configure and
[pspp-builds.git] / src / filename.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
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.
9
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.
14
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., 59 Temple Place - Suite 330, Boston, MA
18    02111-1307, USA. */
19
20 /* AIX requires this to be the first thing in the file.  */
21 #include <config.h>
22 #if __GNUC__
23 #define alloca __builtin_alloca
24 #else
25 #if HAVE_ALLOCA_H
26 #include <alloca.h>
27 #else
28 #ifdef _AIX
29 #pragma alloca
30 #else
31 #ifndef alloca                  /* predefined by HP cc +Olibcalls */
32 char *alloca ();
33 #endif
34 #endif
35 #endif
36 #endif
37
38 #include <assert.h>
39 #include <stdlib.h>
40 #include <ctype.h>
41 #include <errno.h>
42 #include "alloc.h"
43 #include "error.h"
44 #include "filename.h"
45 #include "settings.h"
46 #include "str.h"
47 #include "version.h"
48
49 #include "debug-print.h"
50
51 /* PORTME: Everything in this file is system dependent. */
52
53 #if unix
54 #include <pwd.h>
55 #if HAVE_UNISTD_H
56 #include <unistd.h>
57 #endif
58 #include "stat.h"
59 #endif
60
61 #if __WIN32__
62 #define NOGDI
63 #define NOUSER
64 #define NONLS
65 #include <win32/windows.h>
66 #endif
67
68 #if __DJGPP__
69 #include <sys/stat.h>
70 #endif
71 \f
72 /* Initialization. */
73
74 const char *config_path;
75
76 void
77 fn_init (void)
78 {
79   config_path = fn_getenv_default ("STAT_CONFIG_PATH", default_config_path);
80 }
81 \f
82 /* Functions for performing operations on filenames. */
83
84 /* Substitutes $variables as defined by GETENV into INPUT and returns
85    a copy of the resultant string.  Supports $var and ${var} syntaxes;
86    $$ substitutes as $. */
87 char *
88 fn_interp_vars (const char *input, const char *(*getenv) (const char *))
89 {
90   struct string output;
91
92   if (NULL == strchr (input, '$'))
93     return xstrdup (input);
94
95   ds_init (NULL, &output, strlen (input));
96
97   for (;;)
98     switch (*input)
99       {
100       case '\0':
101         return ds_value (&output);
102         
103       case '$':
104         input++;
105
106         if (*input == '$')
107           {
108             ds_putchar (&output, '$');
109             input++;
110           }
111         else
112           {
113             int stop;
114             int start;
115             const char *value;
116
117             start = ds_length (&output);
118
119             if (*input == '(')
120               {
121                 stop = ')';
122                 input++;
123               }
124             else if (*input == '{')
125               {
126                 stop = '}';
127                 input++;
128               }
129             else
130               stop = 0;
131
132             while (*input && *input != stop
133                    && (stop || isalpha ((unsigned char) *input)))
134               ds_putchar (&output, *input++);
135             
136             value = getenv (ds_value (&output) + start);
137             ds_truncate (&output, start);
138             ds_concat (&output, value);
139
140             if (stop && *input == stop)
141               input++;
142           }
143
144       default:
145         ds_putchar (&output, *input++);
146       }
147 }
148
149 #if unix
150 /* Expands csh tilde notation from the path INPUT into a malloc()'d
151    returned string. */
152 char *
153 fn_tilde_expand (const char *input)
154 {
155   const char *ip;
156   struct string output;
157
158   if (NULL == strchr (input, '~'))
159     return xstrdup (input);
160   ds_init (NULL, &output, strlen (input));
161
162   ip = input;
163
164   for (ip = input; *ip; )
165     if (*ip != '~' || (ip != input && ip[-1] != PATH_DELIMITER))
166       ds_putchar (&output, *ip++);
167     else
168       {
169         static const char stop_set[3] = {DIR_SEPARATOR, PATH_DELIMITER, 0};
170         const char *cp;
171         
172         ip++;
173
174         cp = ip + strcspn (ip, stop_set);
175
176         if (cp > ip)
177           {
178             struct passwd *pwd;
179             char username[9];
180
181             strncpy (username, ip, cp - ip + 1);
182             username[8] = 0;
183             pwd = getpwnam (username);
184
185             if (!pwd || !pwd->pw_dir)
186               ds_putchar (&output, *ip++);
187             else
188               ds_concat (&output, pwd->pw_dir);
189           }
190         else
191           {
192             const char *home = fn_getenv ("HOME");
193             if (!home)
194               ds_putchar (&output, *ip++);
195             else
196               ds_concat (&output, home);
197           }
198
199         ip = cp;
200       }
201
202   return ds_value (&output);
203 }
204 #else /* !unix */
205 char *
206 fn_tilde_expand (char *input)
207 {
208   return xstrdup (input);
209 }
210 #endif /* !unix */
211
212 /* Searches for a configuration file with name NAME in the path given
213    by PATH, which is tilde- and environment-interpolated.  Directories
214    in PATH are delimited by PATH_DELIMITER, defined in <pref.h>.
215    Returns the malloc'd full name of the first file found, or NULL if
216    none is found.
217
218    If PREPEND is non-NULL, then it is prepended to each filename;
219    i.e., it looks like PREPEND/PATH_COMPONENT/NAME.  This is not done
220    with absolute directories in the path. */
221 #if unix || __MSDOS__ || __WIN32__
222 char *
223 fn_search_path (const char *basename, const char *path, const char *prepend)
224 {
225   char *subst_path;
226   struct string filename;
227   const char *bp;
228
229   if (fn_absolute_p (basename))
230     return fn_tilde_expand (basename);
231   
232   {
233     char *temp = fn_interp_vars (path, fn_getenv);
234     bp = subst_path = fn_tilde_expand (temp);
235     free (temp);
236   }
237
238   msg (VM (4), _("Searching for `%s'..."), basename);
239   ds_init (NULL, &filename, 64);
240
241   for (;;)
242     {
243       const char *ep;
244       if (0 == *bp)
245         {
246           msg (VM (4), _("Search unsuccessful!"));
247           ds_destroy (&filename);
248           free (subst_path);
249           return NULL;
250         }
251
252       for (ep = bp; *ep && *ep != PATH_DELIMITER; ep++)
253         ;
254
255       /* Paste together PREPEND/PATH/BASENAME. */
256       ds_clear (&filename);
257       if (prepend && !fn_absolute_p (bp))
258         {
259           ds_concat (&filename, prepend);
260           ds_putchar (&filename, DIR_SEPARATOR);
261         }
262       ds_concat_buffer (&filename, bp, ep - bp);
263       if (ep - bp
264           && ds_value (&filename)[ds_length (&filename) - 1] != DIR_SEPARATOR)
265         ds_putchar (&filename, DIR_SEPARATOR);
266       ds_concat (&filename, basename);
267       
268       msg (VM (5), " - %s", ds_value (&filename));
269       if (fn_exists_p (ds_value (&filename)))
270         {
271           msg (VM (4), _("Found `%s'."), ds_value (&filename));
272           free (subst_path);
273           return ds_value (&filename);
274         }
275
276       if (0 == *ep)
277         {
278           msg (VM (4), _("Search unsuccessful!"));
279           free (subst_path);
280           ds_destroy (&filename);
281           return NULL;
282         }
283       bp = ep + 1;
284     }
285 }
286 #else /* not unix, msdog, lose32 */
287 char *
288 fn_search_path (const char *basename, const char *path, const char *prepend)
289 {
290   size_t size = strlen (path) + 1 + strlen (basename) + 1;
291   char *string;
292   char *cp;
293   
294   if (prepend)
295     size += strlen (prepend) + 1;
296   string = xmalloc (size);
297   
298   cp = string;
299   if (prepend)
300     {
301       cp = stpcpy (cp, prepend);
302       *cp++ = DIR_SEPARATOR;
303     }
304   cp = stpcpy (cp, path);
305   *cp++ = DIR_SEPARATOR;
306   strcpy (cp, basename);
307
308   return string;
309 }
310 #endif /* not unix, msdog, lose32 */
311
312 /* Prepends directory DIR to filename FILE and returns a malloc()'d
313    copy of it. */
314 char *
315 fn_prepend_dir (const char *file, const char *dir)
316 {
317   char *temp;
318   char *cp;
319   
320   if (fn_absolute_p (file))
321     return xstrdup (file);
322
323   temp = xmalloc (strlen (file) + 1 + strlen (dir) + 1);
324   cp = stpcpy (temp, dir);
325   if (cp != temp && cp[-1] != DIR_SEPARATOR)
326     *cp++ = DIR_SEPARATOR;
327   cp = stpcpy (cp, file);
328
329   return temp;
330 }
331
332 /* fn_normalize(): This very OS-dependent routine canonicalizes
333    filename FN1.  The filename should not need to be the name of an
334    existing file.  Returns a malloc()'d copy of the canonical name.
335    This function must always succeed; if it needs to bail out then it
336    should return xstrdup(FN1).  */
337 #if unix
338 char *
339 fn_normalize (const char *filename)
340 {
341   const char *src;
342   char *fn1, *fn2, *dest;
343   int maxlen;
344
345   if (fn_special_p (filename))
346     return xstrdup (filename);
347   
348   fn1 = fn_tilde_expand (filename);
349
350   /* Follow symbolic links. */
351   for (;;)
352     {
353       fn2 = fn1;
354       fn1 = fn_readlink (fn1);
355       if (!fn1)
356         {
357           fn1 = fn2;
358           break;
359         }
360       free (fn2);
361     }
362
363   maxlen = strlen (fn1) * 2;
364   if (maxlen < 31)
365     maxlen = 31;
366   dest = fn2 = xmalloc (maxlen + 1);
367   src = fn1;
368
369   if (*src == DIR_SEPARATOR)
370     *dest++ = *src++;
371   else
372     {
373       errno = 0;
374       while (getcwd (dest, maxlen - (dest - fn2)) == NULL && errno == ERANGE)
375         {
376           maxlen *= 2;
377           dest = fn2 = xrealloc (fn2, maxlen + 1);
378           errno = 0;
379         }
380       if (errno)
381         {
382           free (fn1);
383           free (fn2);
384           return NULL;
385         }
386       dest = strchr (fn2, '\0');
387       if (dest - fn2 >= maxlen)
388         {
389           int ofs = dest - fn2;
390           maxlen *= 2;
391           fn2 = xrealloc (fn2, maxlen + 1);
392           dest = fn2 + ofs;
393         }
394       if (dest[-1] != DIR_SEPARATOR)
395         *dest++ = DIR_SEPARATOR;
396     }
397
398   for (;;)
399     {
400       int c, f;
401
402       c = *src++;
403
404       f = 0;
405       if (c == DIR_SEPARATOR || c == 0)
406         {
407           /* remove `./', `../' from directory */
408           if (dest[-1] == '.' && dest[-2] == DIR_SEPARATOR)
409             dest--;
410           else if (dest[-1] == '.' && dest[-2] == '.' && dest[-3] == DIR_SEPARATOR)
411             {
412               dest -= 3;
413               if (dest == fn2)
414                 dest++;
415               while (dest[-1] != DIR_SEPARATOR)
416                 dest--;
417             }
418           else if (dest[-1] != DIR_SEPARATOR)   /* remove extra slashes */
419             f = 1;
420
421           if (c == 0)
422             {
423               if (dest[-1] == DIR_SEPARATOR && dest > fn2 + 1)
424                 dest--;
425               *dest = 0;
426               free (fn1);
427
428               return xrealloc (fn2, strlen (fn2) + 1);
429             }
430         }
431       else
432         f = 1;
433
434       if (f)
435         {
436           if (dest - fn2 >= maxlen)
437             {
438               int ofs = dest - fn2;
439               maxlen *= 2;
440               fn2 = xrealloc (fn2, maxlen + 1);
441               dest = fn2 + ofs;
442             }
443           *dest++ = c;
444         }
445     }
446 }
447 #elif __WIN32__
448 char *
449 fn_normalize (const char *fn1)
450 {
451   DWORD len;
452   DWORD success;
453   char *fn2;
454
455   /* Don't change special filenames. */
456   if (is_special_filename (filename))
457     return xstrdup (filename);
458
459   /* First find the required buffer length. */
460   len = GetFullPathName (fn1, 0, NULL, NULL);
461   if (!len)
462     {
463       fn2 = xstrdup (fn1);
464       return fn2;
465     }
466
467   /* Then make a buffer that big. */
468   fn2 = xmalloc (len);
469   success = GetFullPathName (fn1, len, fn2, NULL);
470   if (success >= len || success == 0)
471     {
472       free (fn2);
473       fn2 = xstrdup (fn1);
474       return fn2;
475     }
476   return fn2;
477 }
478 #elif __BORLANDC__
479 char *
480 fn_normalize (const char *fn1)
481 {
482   char *fn2 = _fullpath (NULL, fn1, 0);
483   if (fn2)
484     {
485       char *cp;
486       for (cp = fn2; *cp; cp++)
487         *cp = toupper ((unsigned char) (*cp));
488       return fn2;
489     }
490   return xstrdup (fn1);
491 }
492 #elif __DJGPP__
493 char *
494 fn_normalize (const char *fn1)
495 {
496   char *fn2 = xmalloc (1024);
497   _fixpath (fn1, fn2);
498   fn2 = xrealloc (fn2, strlen (fn2) + 1);
499   return fn2;
500 }
501 #else /* not Lose32, Unix, or DJGPP */
502 char *
503 fn_normalize (const char *fn)
504 {
505   return xstrdup (fn);
506 }
507 #endif /* not Lose32, Unix, or DJGPP */
508
509 /* Returns the directory part of FILENAME, as a malloc()'d
510    string. */
511 char *
512 fn_dirname (const char *filename)
513 {
514   const char *p;
515   char *s;
516   size_t len;
517
518   len = strlen (filename);
519   if (len == 1 && filename[0] == '/')
520     p = filename + 1;
521   else if (len && filename[len - 1] == DIR_SEPARATOR)
522     p = mm_find_reverse (filename, len - 1, filename + len - 1, 1);
523   else
524     p = strrchr (filename, DIR_SEPARATOR);
525   if (p == NULL)
526     p = filename;
527
528   s = xmalloc (p - filename + 1);
529   memcpy (s, filename, p - filename);
530   s[p - filename] = 0;
531
532   return s;
533 }
534
535 /* Returns the basename part of FILENAME as a malloc()'d string. */
536 #if 0
537 char *
538 fn_basename (const char *filename)
539 {
540   /* Not used, not implemented. */
541   abort ();
542 }
543 #endif
544 \f
545 /* Returns the current working directory, as a malloc()'d string.
546    From libc.info. */
547 char *
548 fn_get_cwd (void)
549 {
550   int size = 100;
551   char *buffer = xmalloc (size);
552      
553   for (;;)
554     {
555       char *value = getcwd (buffer, size);
556       if (value != 0)
557         return buffer;
558
559       size *= 2;
560       free (buffer);
561       buffer = xmalloc (size);
562     }
563 }
564 \f
565 /* Find out information about files. */
566
567 /* Returns nonzero iff NAME specifies an absolute filename. */
568 int
569 fn_absolute_p (const char *name)
570 {
571 #if unix
572   if (name[0] == '/'
573       || !strncmp (name, "./", 2)
574       || !strncmp (name, "../", 3)
575       || name[0] == '~')
576     return 1;
577 #elif __MSDOS__
578   if (name[0] == '\\'
579       || !strncmp (name, ".\\", 2)
580       || !strncmp (name, "..\\", 3)
581       || (name[0] && name[1] == ':'))
582     return 1;
583 #endif
584   
585   return 0;
586 }
587   
588 /* Returns 1 if the filename specified is a virtual file that doesn't
589    really exist on disk, 0 if it's a real filename. */
590 int
591 fn_special_p (const char *filename)
592 {
593   if (!strcmp (filename, "-") || !strcmp (filename, "stdin")
594       || !strcmp (filename, "stdout") || !strcmp (filename, "stderr")
595 #if unix
596       || filename[0] == '|'
597       || (*filename && filename[strlen (filename) - 1] == '|')
598 #endif
599       )
600     return 1;
601
602   return 0;
603 }
604
605 /* Returns nonzero if file with name NAME exists. */
606 int
607 fn_exists_p (const char *name)
608 {
609 #if unix
610   struct stat temp;
611
612   return stat (name, &temp) == 0;
613 #else
614   FILE *f = fopen (name, "r");
615   if (!f)
616     return 0;
617   fclose (f);
618   return 1;
619 #endif
620 }
621
622 #if unix
623 /* Stolen from libc.info but heavily modified, this is a wrapper
624    around readlink() that allows for arbitrary filename length. */
625 char *
626 fn_readlink (const char *filename)
627 {
628   int size = 128;
629
630   for (;;)
631     {
632       char *buffer = xmalloc (size);
633       int nchars  = readlink (filename, buffer, size);
634       if (nchars == -1)
635         {
636           free (buffer);
637           return NULL;
638         }
639
640       if (nchars < size - 1)
641         {
642           buffer[nchars] = 0;
643           return buffer;
644         }
645       free (buffer);
646       size *= 2;
647     }
648 }
649 #else /* Not UNIX. */
650 char *
651 fn_readlink (const char *filename)
652 {
653   return NULL;
654 }
655 #endif /* Not UNIX. */
656 \f
657 /* Environment variables. */
658
659 /* Simulates $VER and $ARCH environment variables. */
660 const char *
661 fn_getenv (const char *s)
662 {
663   if (!strcmp (s, "VER"))
664     return fn_getenv_default ("STAT_VER", bare_version);
665   else if (!strcmp (s, "ARCH"))
666     return fn_getenv_default ("STAT_ARCH", host_system);
667   else
668     return getenv (s);
669 }
670
671 /* Returns getenv(KEY) if that's non-NULL; else returns DEF. */
672 const char *
673 fn_getenv_default (const char *key, const char *def)
674 {
675   const char *value = getenv (key);
676   return value ? value : def;
677 }
678 \f
679 /* Basic file handling. */
680
681 /* Used for giving an error message on a set_safer security
682    violation. */
683 static FILE *
684 safety_violation (const char *fn)
685 {
686   msg (SE, _("Not opening pipe file `%s' because SAFER option set."), fn);
687   errno = EPERM;
688   return NULL;
689 }
690
691 /* As a general comment on the following routines, a `sensible value'
692    for errno includes 0 if there is no associated system error.  The
693    routines will only set errno to 0 if there is an error in a
694    callback that sets errno to 0; they themselves won't. */
695
696 /* File open routine that understands `-' as stdin/stdout and `|cmd'
697    as a pipe to command `cmd'.  Returns resultant FILE on success,
698    NULL on failure.  If NULL is returned then errno is set to a
699    sensible value.  */
700 FILE *
701 fn_open (const char *fn, const char *mode)
702 {
703   assert (mode[0] == 'r' || mode[0] == 'w');
704
705   if (mode[0] == 'r' && (!strcmp (fn, "stdin") || !strcmp (fn, "-"))) 
706     return stdin;
707   else if (mode[0] == 'w' && (!strcmp (fn, "stdout") || !strcmp (fn, "-")))
708     return stdout;
709   else if (mode[0] == 'w' && !strcmp (fn, "stderr"))
710     return stderr;
711   
712 #if unix
713   if (fn[0] == '|')
714     {
715       if (set_safer)
716         return safety_violation (fn);
717
718       return popen (&fn[1], mode);
719     }
720   else if (*fn && fn[strlen (fn) - 1] == '|')
721     {
722       char *s;
723       FILE *f;
724
725       if (set_safer)
726         return safety_violation (fn);
727       
728       s = local_alloc (strlen (fn));
729       memcpy (s, fn, strlen (fn) - 1);
730       s[strlen (fn) - 1] = 0;
731       
732       f = popen (s, mode);
733
734       local_free (s);
735
736       return f;
737     }
738   else
739 #endif
740     {
741       FILE *f = fopen (fn, mode);
742
743       if (f && mode[0] == 'w')
744         setvbuf (f, NULL, _IOLBF, 0);
745
746       return f;
747     }
748 }
749
750 /* Counterpart to fn_open that closes file F with name FN; returns 0
751    on success, EOF on failure.  If EOF is returned, errno is set to a
752    sensible value. */
753 int
754 fn_close (const char *fn, FILE *f)
755 {
756   if (!strcmp (fn, "-"))
757     return 0;
758 #if unix
759   else if (fn[0] == '|' || (*fn && fn[strlen (fn) - 1] == '|'))
760     {
761       pclose (f);
762       return 0;
763     }
764 #endif
765   else
766     return fclose (f);
767 }
768 \f
769 /* More extensive file handling. */
770
771 /* File open routine that extends fn_open().  Opens or reopens a
772    file according to the contents of file_ext F.  Returns nonzero on
773    success.  If 0 is returned, errno is set to a sensible value. */
774 int
775 fn_open_ext (struct file_ext *f)
776 {
777   char *p;
778
779   p = strstr (f->filename, "%d");
780   if (p)
781     {
782       char *s = local_alloc (strlen (f->filename) + INT_DIGITS - 1);
783       char *cp;
784
785       memcpy (s, f->filename, p - f->filename);
786       cp = spprintf (&s[p - f->filename], "%d", *f->sequence_no);
787       strcpy (cp, &p[2]);
788
789       if (f->file)
790         {
791           int error = 0;
792
793           if (f->preclose)
794             if (f->preclose (f) == 0)
795               error = errno;
796
797           if (EOF == fn_close (f->filename, f->file) || error)
798             {
799               f->file = NULL;
800               local_free (s);
801
802               if (error)
803                 errno = error;
804
805               return 0;
806             }
807
808           f->file = NULL;
809         }
810
811       f->file = fn_open (s, f->mode);
812       local_free (s);
813
814       if (f->file && f->postopen)
815         if (f->postopen (f) == 0)
816           {
817             int error = errno;
818             fn_close (f->filename, f->file);
819             errno = error;
820
821             return 0;
822           }
823
824       return (f->file != NULL);
825     }
826   else if (f->file)
827     return 1;
828   else
829     {
830       f->file = fn_open (f->filename, f->mode);
831
832       if (f->file && f->postopen)
833         if (f->postopen (f) == 0)
834           {
835             int error = errno;
836             fn_close (f->filename, f->file);
837             errno = error;
838
839             return 0;
840           }
841
842       return (f->file != NULL);
843     }
844 }
845
846 /* Properly closes the file associated with file_ext F, if any.
847    Return nonzero on success.  If zero is returned, errno is set to a
848    sensible value. */
849 int
850 fn_close_ext (struct file_ext *f)
851 {
852   if (f->file)
853     {
854       int error = 0;
855
856       if (f->preclose)
857         if (f->preclose (f) == 0)
858           error = errno;
859
860       if (EOF == fn_close (f->filename, f->file) || error)
861         {
862           f->file = NULL;
863
864           if (error)
865             errno = error;
866
867           return 0;
868         }
869
870       f->file = NULL;
871     }
872   return 1;
873 }