m4/path.c

   1 /* GNU m4 -- A simple macro processor
   2    Copyright (C) 1989-1993, 1998, 2004, 2006-2010, 2013-2014 Free
   3    Software Foundation, Inc.
   4
   5    This file is part of GNU M4.
   6
   7    GNU M4 is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    GNU M4 is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 /* Handling of path search of included files via the builtins "include"
  22    and "sinclude".  */
  23
  24 #include <config.h>
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30
  31 #include "m4private.h"
  32
  33 #include "configmake.h"
  34 #include "dirname.h"
  35 #include "filenamecat.h"
  36
  37 #if OS2 /* Any others? */
  38 #  define TRUNCATE_FILENAME 1
  39 #endif
  40
  41 /* Define this to see runtime debug info.  Implied by DEBUG.  */
  42 /*#define DEBUG_INCL */
  43
  44 static const char *FILE_SUFFIXES[] = {
  45   "",
  46   ".m4f",
  47   ".m4",
  48   LT_MODULE_EXT,
  49   NULL
  50 };
  51
  52 static const char *NO_SUFFIXES[] = { "", NULL };
  53
  54 static void search_path_add (m4__search_path_info *, const char *, bool);
  55 static void search_path_env_init (m4__search_path_info *, char *, bool);
  56 static void include_env_init (m4 *context);
  57
  58 #ifdef DEBUG_INCL
  59 static void include_dump (m4 *context);
  60 #endif
  61
  62 \f
  63 /*
  64  * General functions for search paths
  65  */
  66
  67 static void
  68 search_path_add (m4__search_path_info *info, const char *dir, bool prepend)
  69 {
  70   m4__search_path *path = (m4__search_path *) xmalloc (sizeof *path);
  71
  72   path->len = strlen (dir);
  73   path->dir = xstrdup (dir);
  74
  75   if (path->len > info->max_length) /* remember len of longest directory */
  76     info->max_length = path->len;
  77
  78   if (prepend)
  79     {
  80       path->next = info->list;
  81       info->list = path;
  82       if (info->list_end == NULL)
  83         info->list_end = path;
  84     }
  85   else
  86     {
  87       path->next = NULL;
  88
  89       if (info->list_end == NULL)
  90         info->list = path;
  91       else
  92         info->list_end->next = path;
  93       info->list_end = path;
  94     }
  95 }
  96
  97 static void
  98 search_path_env_init (m4__search_path_info *info, char *path, bool isabs)
  99 {
 100   char *path_end;
 101
 102   if (info == NULL || path == NULL)
 103     return;
 104
 105   do
 106     {
 107       path_end = strchr (path, PATH_SEPARATOR);
 108       if (path_end)
 109         *path_end = '\0';
 110       if (!isabs || *path == '/')
 111         search_path_add (info, path, false);
 112       path = path_end + 1;
 113     }
 114   while (path_end);
 115 }
 116
 117 static void
 118 include_env_init (m4 *context)
 119 {
 120   char *m4path;
 121
 122   if (m4_get_posixly_correct_opt (context))
 123     return;
 124
 125   m4path = getenv ("M4PATH");
 126   if (m4path)
 127     m4path = xstrdup (m4path);
 128   search_path_env_init (m4__get_search_path (context), m4path, false);
 129   free (m4path);
 130 }
 131
 132
 133 #if TRUNCATE_FILENAME
 134 /* Destructively modify PATH to contain no more than 8 non-`.'
 135    characters, optionally followed by a `.' and a filenname extension
 136    of 3 characters or fewer. */
 137 static char *
 138 path_truncate (char *path)
 139 {
 140   char *p, *beg = path;                 /* following final '/' */
 141   for (p = path; *p != '\0'; ++p)
 142     {
 143       if (ISSLASH (*p))
 144         beg = 1+ p;
 145     }
 146
 147   char *end = strchr (beg, '.');        /* first period */
 148   char *ext = strrchr (beg, '.');       /* last period */
 149
 150   size_t len = (size_t) (end - beg);    /* length of filename element */
 151   if (len > 8)
 152     end = beg + 8;
 153
 154   if (ext == NULL)
 155     {
 156       *end = '\0';
 157     }
 158   else if (ext != end)
 159     {
 160       stpncpy (end, ext, 4);
 161     }
 162
 163   return path;
 164 }
 165 #else
 166 #  define path_truncate(path) (path)
 167 #endif
 168
 169
 170 \f
 171 /* Functions for normal input path search */
 172
 173 void
 174 m4_add_include_directory (m4 *context, const char *dir, bool prepend)
 175 {
 176   if (m4_get_posixly_correct_opt (context))
 177     return;
 178
 179   search_path_add (m4__get_search_path (context), dir, prepend);
 180
 181 #ifdef DEBUG_INCL
 182   xfprintf (stderr, "add_include_directory (%s) %s;\n", dir,
 183             prepend ? "prepend" : "append");
 184 #endif
 185 }
 186
 187
 188 /* Search for FILENAME according to -B options, `.', -I options, then
 189    M4PATH environment.  If successful, return the open file, and if
 190    RESULT is not NULL, set *RESULT to a malloc'd string that
 191    represents the file found with respect to the current working
 192    directory.  Otherwise, return NULL, and errno reflects the failure
 193    from searching `.' (regardless of what else was searched).  */
 194 char *
 195 m4_path_search (m4 *context, const char *filename, const char **suffixes)
 196 {
 197   m4__search_path *incl;
 198   char *filepath;               /* buffer for constructed name */
 199   size_t max_suffix_len = 0;
 200   int i, e = 0;
 201
 202   /* Reject empty file.  */
 203   if (*filename == '\0')
 204     {
 205       errno = ENOENT;
 206       return NULL;
 207     }
 208
 209   /* Use no suffixes by default.  */
 210   if (suffixes == NULL)
 211     suffixes = NO_SUFFIXES;
 212
 213   /* Find the longest suffix, so that we will always allocate enough
 214      memory for a filename with suffix.  */
 215   for (i = 0; suffixes && suffixes[i]; ++i)
 216     {
 217       size_t len = strlen (suffixes[i]);
 218       if (len > max_suffix_len)
 219         max_suffix_len = len;
 220     }
 221
 222   /* If file is absolute, or if we are not searching a path, a single
 223      lookup will do the trick.  */
 224   if (IS_ABSOLUTE_FILE_NAME (filename))
 225     {
 226       size_t mem = strlen (filename);
 227
 228       /* Try appending each of the suffixes we were given.  */
 229       filepath = path_truncate (strncpy (xmalloc (mem + max_suffix_len +1), filename, mem));
 230       for (i = 0; suffixes && suffixes[i]; ++i)
 231         {
 232           strcpy (filepath + mem, suffixes[i]);
 233           if (access (filepath, R_OK) == 0)
 234             return filepath;
 235
 236           /* If search fails, we'll use the error we got from the first
 237              access (usually with no suffix).  */
 238           if (i == 0)
 239             e = errno;
 240         }
 241       free (filepath);
 242
 243       /* No such file.  */
 244       errno = e;
 245       return NULL;
 246     }
 247
 248   for (incl = m4__get_search_path (context)->list;
 249        incl != NULL; incl = incl->next)
 250     {
 251       char *pathname = file_name_concat (incl->dir, filename, NULL);
 252       size_t mem = strlen (pathname);
 253
 254 #ifdef DEBUG_INCL
 255       xfprintf (stderr, "path_search (%s) -- trying %s\n", filename, pathname);
 256 #endif
 257
 258       if (access (pathname, R_OK) == 0)
 259         {
 260           m4_debug_message (context, M4_DEBUG_TRACE_PATH,
 261                             _("path search for %s found %s"),
 262                             quotearg_style (locale_quoting_style, filename),
 263                             quotearg_n_style (1, locale_quoting_style, pathname));
 264           return pathname;
 265         }
 266       else if (!incl->len)
 267         /* Capture errno only when searching `.'.  */
 268         e = errno;
 269
 270       filepath = path_truncate (strncpy (xmalloc (mem + max_suffix_len +1), pathname, mem));
 271       free (pathname);
 272
 273       for (i = 0; suffixes && suffixes[i]; ++i)
 274         {
 275           strcpy (filepath + mem, suffixes[i]);
 276           if (access (filepath, R_OK) == 0)
 277             return filepath;
 278         }
 279       free (filepath);
 280     }
 281
 282   errno = e;
 283   return NULL;
 284 }
 285
 286
 287 /* Attempt to open FILE; if it opens, verify that it is not a
 288    directory, and ensure it does not leak across execs.  */
 289 FILE *
 290 m4_fopen (m4 *context, const char *file, const char *mode)
 291 {
 292   FILE *fp = NULL;
 293
 294   if (file)
 295     {
 296       struct stat st;
 297       int fd;
 298
 299       fp = fopen (file, mode);
 300       fd = fileno (fp);
 301
 302       if (fstat (fd, &st) == 0 && S_ISDIR (st.st_mode))
 303         {
 304           fclose (fp);
 305           errno = EISDIR;
 306           return NULL;
 307         }
 308       if (set_cloexec_flag (fileno (fp), true) != 0)
 309         m4_error (context, 0, errno, NULL,
 310                   _("cannot protect input file across forks"));
 311     }
 312   return fp;
 313 }
 314
 315
 316 /* Generic load function.  Push the input file or load the module named
 317    FILENAME, if it can be found in the search path.  Complain
 318    about inaccesible files iff SILENT is false.  */
 319 bool
 320 m4_load_filename (m4 *context, const m4_call_info *caller,
 321                   const char *filename, m4_obstack *obs, bool silent)
 322 {
 323   char *filepath = NULL;
 324   char *suffix   = NULL;
 325   bool new_input = false;
 326
 327   if (m4_get_posixly_correct_opt (context))
 328     {
 329       if (access (filename, R_OK) == 0)
 330         filepath = xstrdup (filename);
 331     }
 332   else
 333     filepath = m4_path_search (context, filename, FILE_SUFFIXES);
 334
 335   if (filepath)
 336     suffix = strrchr (filepath, '.');
 337
 338   if (!m4_get_posixly_correct_opt (context)
 339       && suffix
 340       && STREQ (suffix, ".so"))
 341     {
 342       m4_module_load (context, filename, obs);
 343     }
 344   else
 345     {
 346       FILE *fp = NULL;
 347
 348       if (filepath)
 349         fp = m4_fopen (context, filepath, "r");
 350
 351       if (fp == NULL)
 352         {
 353           if (!silent)
 354             m4_error (context, 0, errno, caller, _("cannot open file '%s'"),
 355                       filename);
 356           free (filepath);
 357           return false;
 358         }
 359
 360       m4_push_file (context, fp, filepath, true);
 361       new_input = true;
 362     }
 363   free (filepath);
 364
 365   return new_input;
 366 }
 367
 368
 369 void
 370 m4__include_init (m4 *context)
 371 {
 372   include_env_init (context);
 373
 374   {
 375     m4__search_path_info *info = m4__get_search_path (context);
 376
 377     /* If M4PATH was not set, then search just the current directory by
 378        default. */
 379     assert (info);
 380     if (info->list_end == NULL)
 381       search_path_add (info, "", false);
 382
 383     /* Non-core modules installation directory. */
 384     search_path_add (info, PKGLIBDIR, false);
 385   }
 386
 387 #ifdef DEBUG_INCL
 388   fputs ("initial include search path...\n", stderr);
 389   include_dump (context);
 390 #endif
 391 }
 392
 393
 394 \f
 395 #ifdef DEBUG_INCL
 396
 397 static void
 398 include_dump (m4 *context)
 399 {
 400   m4__search_path *incl;
 401
 402   fputs ("include_dump:\n", stderr);
 403   for (incl = m4__get_search_path (context)->list;
 404        incl != NULL; incl = incl->next)
 405     xfprintf (stderr, "\t'%s'\n", incl->dir);
 406 }
 407
 408 #endif /* DEBUG_INCL */