home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / octave-1.1.1p1-src.tgz / tar.out / fsf / octave / info / filesys.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  16KB  |  626 lines
  1. /* filesys.c -- File system specific functions for hacking this system. */
  2.  
  3. /* This file is part of GNU Info, a program for reading online documentation
  4.    stored in Info format.
  5.  
  6.    Copyright (C) 1993 Free Software Foundation, Inc.
  7.  
  8.    This program is free software; you can redistribute it and/or modify
  9.    it under the terms of the GNU General Public License as published by
  10.    the Free Software Foundation; either version 2, or (at your option)
  11.    any later version.
  12.  
  13.    This program is distributed in the hope that it will be useful,
  14.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.    GNU General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU General Public License
  19.    along with this program; if not, write to the Free Software
  20.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22.    Written by Brian Fox (bfox@ai.mit.edu). */
  23.  
  24. #include <stdio.h>
  25. #include <sys/types.h>
  26. #include <sys/stat.h>
  27. #include <sys/file.h>
  28. #include <sys/errno.h>
  29. #include "general.h"
  30. #include "tilde.h"
  31. #include "filesys.h"
  32.  
  33. #if !defined (O_RDONLY)
  34. #if defined (HAVE_SYS_FCNTL_H)
  35. #include <sys/fcntl.h>
  36. #else /* !HAVE_SYS_FCNTL_H */
  37. #include <fcntl.h>
  38. #endif /* !HAVE_SYS_FCNTL_H */
  39. #endif /* !O_RDONLY */
  40.  
  41. #if !defined (errno)
  42. extern int errno;
  43. #endif /* !errno */
  44.  
  45. /* Found in info-utils.c. */
  46. extern char *filename_non_directory ();
  47.  
  48. #if !defined (BUILDING_LIBRARY)
  49. /* Found in session.c */
  50. extern int info_windows_initialized_p;
  51.  
  52. /* Found in window.c. */
  53. extern void message_in_echo_area (), unmessage_in_echo_area ();
  54. #endif /* !BUILDING_LIBRARY */
  55.  
  56. /* Local to this file. */
  57. static char *info_file_in_path (), *lookup_info_filename ();
  58. static void remember_info_filename (), maybe_initialize_infopath ();
  59.  
  60. #if !defined (NULL)
  61. #  define NULL 0x0
  62. #endif /* !NULL */
  63.  
  64. typedef struct {
  65.   char *suffix;
  66.   char *decompressor;
  67. } COMPRESSION_ALIST;
  68.  
  69. static char *info_suffixes[] = {
  70.   "",
  71.   ".info",
  72.   "-info",
  73.   (char *)NULL
  74. };
  75.  
  76. static COMPRESSION_ALIST compress_suffixes[] = {
  77.   { ".Z", "uncompress" },
  78.   { ".Y", "unyabba" },
  79.   { ".z", "gunzip" },
  80.   { ".gz", "gunzip" },
  81.   { (char *)NULL, (char *)NULL }
  82. };
  83.  
  84. /* The path on which we look for info files.  You can initialize this
  85.    from the environment variable INFOPATH if there is one, or you can
  86.    call info_add_path () to add paths to the beginning or end of it.
  87.    You can call zap_infopath () to make the path go away. */
  88. char *infopath = (char *)NULL;
  89. static int infopath_size = 0;
  90.  
  91. /* Expand the filename in PARTIAL to make a real name for this operating
  92.    system.  This looks in INFO_PATHS in order to find the correct file.
  93.    If it can't find the file, it returns NULL. */
  94. static char *local_temp_filename = (char *)NULL;
  95. static int local_temp_filename_size = 0;
  96.  
  97. char *
  98. info_find_fullpath (partial)
  99.      char *partial;
  100. {
  101.   int initial_character;
  102.   char *temp;
  103.  
  104.   filesys_error_number = 0;
  105.  
  106.   maybe_initialize_infopath ();
  107.  
  108.   if (partial && (initial_character = *partial))
  109.     {
  110.       char *expansion;
  111.  
  112.       expansion = lookup_info_filename (partial);
  113.  
  114.       if (expansion)
  115.     return (expansion);
  116.  
  117.       /* If we have the full path to this file, we still may have to add
  118.      various extensions to it.  I guess we have to stat this file
  119.      after all. */
  120.       if (initial_character == '/')
  121.     temp = info_file_in_path (partial + 1, "/");
  122.       else if (initial_character == '~')
  123.     {
  124.       expansion = tilde_expand_word (partial);
  125.       if (*expansion == '/')
  126.         {
  127.           temp = info_file_in_path (expansion + 1, "/");
  128.           free (expansion);
  129.         }
  130.       else
  131.         temp = expansion;
  132.     }
  133.       else if (initial_character == '.' &&
  134.            (partial[1] == '/' || (partial[1] == '.' && partial[2] == '/')))
  135.     {
  136.       if (local_temp_filename_size < 1024)
  137.         local_temp_filename = (char *)xrealloc
  138.           (local_temp_filename, (local_temp_filename_size = 1024));
  139. #if defined (HAVE_GETCWD)
  140.       if (!getcwd (local_temp_filename, local_temp_filename_size))
  141. #else /*  !HAVE_GETCWD */
  142.       if (!getwd (local_temp_filename))
  143. #endif /* !HAVE_GETCWD */
  144.         {
  145.           filesys_error_number = errno;
  146.           return (partial);
  147.         }
  148.  
  149.       strcat (local_temp_filename, "/");
  150.       strcat (local_temp_filename, partial);
  151.       return (local_temp_filename);
  152.     }
  153.       else
  154.     temp = info_file_in_path (partial, infopath);
  155.  
  156.       if (temp)
  157.     {
  158.       remember_info_filename (partial, temp);
  159.       if (strlen (temp) > local_temp_filename_size)
  160.         local_temp_filename = (char *) xrealloc
  161.           (local_temp_filename,
  162.            (local_temp_filename_size = (50 + strlen (temp))));
  163.       strcpy (local_temp_filename, temp);
  164.       free (temp);
  165.       return (local_temp_filename);
  166.     }
  167.     }
  168.   return (partial);
  169. }
  170.  
  171. /* Scan the list of directories in PATH looking for FILENAME.  If we find
  172.    one that is a regular file, return it as a new string.  Otherwise, return
  173.    a NULL pointer. */
  174. static char *
  175. info_file_in_path (filename, path)
  176.      char *filename, *path;
  177. {
  178.   struct stat finfo;
  179.   char *temp_dirname;
  180.   int statable, dirname_index;
  181.  
  182.   dirname_index = 0;
  183.  
  184.   while (temp_dirname = extract_colon_unit (path, &dirname_index))
  185.     {
  186.       register int i, pre_suffix_length;
  187.       char *temp;
  188.  
  189.       /* Expand a leading tilde if one is present. */
  190.       if (*temp_dirname == '~')
  191.     {
  192.       char *expanded_dirname;
  193.  
  194.       expanded_dirname = tilde_expand_word (temp_dirname);
  195.       free (temp_dirname);
  196.       temp_dirname = expanded_dirname;
  197.     }
  198.  
  199.       temp = (char *)xmalloc (30 + strlen (temp_dirname) + strlen (filename));
  200.       strcpy (temp, temp_dirname);
  201.       if (temp[(strlen (temp)) - 1] != '/')
  202.     strcat (temp, "/");
  203.       strcat (temp, filename);
  204.  
  205.       pre_suffix_length = strlen (temp);
  206.  
  207.       free (temp_dirname);
  208.  
  209.       for (i = 0; info_suffixes[i]; i++)
  210.     {
  211.       strcpy (temp + pre_suffix_length, info_suffixes[i]);
  212.  
  213.       statable = (stat (temp, &finfo) == 0);
  214.  
  215.       /* If we have found a regular file, then use that.  Else, if we
  216.          have found a directory, look in that directory for this file. */
  217.       if (statable)
  218.         {
  219.           if (S_ISREG (finfo.st_mode))
  220.         {
  221.           return (temp);
  222.         }
  223.           else if (S_ISDIR (finfo.st_mode))
  224.         {
  225.           char *newpath, *filename_only, *newtemp;
  226.  
  227.           newpath = savestring (temp);
  228.           filename_only = filename_non_directory (filename);
  229.           newtemp = info_file_in_path (filename_only, newpath);
  230.  
  231.           free (newpath);
  232.           if (newtemp)
  233.             {
  234.               free (temp);
  235.               return (newtemp);
  236.             }
  237.         }
  238.         }
  239.       else
  240.         {
  241.           /* Add various compression suffixes to the name to see if
  242.          the file is present in compressed format. */
  243.           register int j, pre_compress_suffix_length;
  244.  
  245.           pre_compress_suffix_length = strlen (temp);
  246.  
  247.           for (j = 0; compress_suffixes[j].suffix; j++)
  248.         {
  249.           strcpy (temp + pre_compress_suffix_length,
  250.               compress_suffixes[j].suffix);
  251.  
  252.           statable = (stat (temp, &finfo) == 0);
  253.           if (statable && (S_ISREG (finfo.st_mode)))
  254.             return (temp);
  255.         }
  256.         }
  257.     }
  258.       free (temp);
  259.     }
  260.   return ((char *)NULL);
  261. }
  262.  
  263. /* Given a string containing units of information separated by colons,
  264.    return the next one pointed to by IDX, or NULL if there are no more.
  265.    Advance IDX to the character after the colon. */
  266. char *
  267. extract_colon_unit (string, idx)
  268.      char *string;
  269.      int *idx;
  270. {
  271.   register int i, start;
  272.  
  273.   i = start = *idx;
  274.   if ((i >= strlen (string)) || !string)
  275.     return ((char *) NULL);
  276.  
  277.   while (string[i] && string[i] != ':')
  278.     i++;
  279.   if (i == start)
  280.     {
  281.       return ((char *) NULL);
  282.     }
  283.   else
  284.     {
  285.       char *value = (char *) xmalloc (1 + (i - start));
  286.       strncpy (value, &string[start], (i - start));
  287.       value[i - start] = '\0';
  288.       if (string[i])
  289.     ++i;
  290.       *idx = i;
  291.       return (value);
  292.     }
  293. }
  294.  
  295. /* A structure which associates a filename with its expansion. */
  296. typedef struct {
  297.   char *filename;
  298.   char *expansion;
  299. } FILENAME_LIST;
  300.  
  301. /* An array of remembered arguments and results. */
  302. static FILENAME_LIST **names_and_files = (FILENAME_LIST **)NULL;
  303. static int names_and_files_index = 0;
  304. static int names_and_files_slots = 0;
  305.  
  306. /* Find the result for having already called info_find_fullpath () with
  307.    FILENAME. */
  308. static char *
  309. lookup_info_filename (filename)
  310.      char *filename;
  311. {
  312.   if (filename && names_and_files)
  313.     {
  314.       register int i;
  315.       for (i = 0; names_and_files[i]; i++)
  316.     {
  317.       if (strcmp (names_and_files[i]->filename, filename) == 0)
  318.         return (names_and_files[i]->expansion);
  319.     }
  320.     }
  321.   return (char *)NULL;;
  322. }
  323.  
  324. /* Add a filename and its expansion to our list. */
  325. static void
  326. remember_info_filename (filename, expansion)
  327.      char *filename, *expansion;
  328. {
  329.   FILENAME_LIST *new;
  330.  
  331.   if (names_and_files_index + 2 > names_and_files_slots)
  332.     {
  333.       int alloc_size;
  334.       names_and_files_slots += 10;
  335.  
  336.       alloc_size = names_and_files_slots * sizeof (FILENAME_LIST *);
  337.  
  338.       names_and_files =
  339.     (FILENAME_LIST **) xrealloc (names_and_files, alloc_size);
  340.     }
  341.  
  342.   new = (FILENAME_LIST *)xmalloc (sizeof (FILENAME_LIST));
  343.   new->filename = savestring (filename);
  344.   new->expansion = expansion ? savestring (expansion) : (char *)NULL;
  345.  
  346.   names_and_files[names_and_files_index++] = new;
  347.   names_and_files[names_and_files_index] = (FILENAME_LIST *)NULL;
  348. }
  349.  
  350. static void
  351. maybe_initialize_infopath ()
  352. {
  353.   if (!infopath_size)
  354.     {
  355.       infopath = (char *)
  356.     xmalloc (infopath_size = (1 + strlen (DEFAULT_INFOPATH)));
  357.  
  358.       strcpy (infopath, DEFAULT_INFOPATH);
  359.     }
  360. }
  361.  
  362. /* Add PATH to the list of paths found in INFOPATH.  2nd argument says
  363.    whether to put PATH at the front or end of INFOPATH. */
  364. void
  365. info_add_path (path, where)
  366.      char *path;
  367.      int where;
  368. {
  369.   int len;
  370.  
  371.   if (!infopath)
  372.     {
  373.       infopath = (char *)xmalloc (infopath_size = 200 + strlen (path));
  374.       infopath[0] = '\0';
  375.     }
  376.  
  377.   len = strlen (path) + strlen (infopath);
  378.  
  379.   if (len + 2 >= infopath_size)
  380.     infopath = (char *)xrealloc (infopath, (infopath_size += (2 * len) + 2));
  381.  
  382.   if (!*infopath)
  383.     strcpy (infopath, path);
  384.   else if (where == INFOPATH_APPEND)
  385.     {
  386.       strcat (infopath, ":");
  387.       strcat (infopath, path);
  388.     }
  389.   else if (where == INFOPATH_PREPEND)
  390.     {
  391.       char *temp = savestring (infopath);
  392.       strcpy (infopath, path);
  393.       strcat (infopath, ":");
  394.       strcat (infopath, temp);
  395.       free (temp);
  396.     }
  397. }
  398.  
  399. /* Make INFOPATH have absolutely nothing in it. */
  400. void
  401. zap_infopath ()
  402. {
  403.   if (infopath)
  404.     free (infopath);
  405.  
  406.   infopath = (char *)NULL;
  407.   infopath_size = 0;
  408. }
  409.  
  410. /* Read the contents of PATHNAME, returning a buffer with the contents of
  411.    that file in it, and returning the size of that buffer in FILESIZE.
  412.    FINFO is a stat struct which has already been filled in by the caller.
  413.    If the file cannot be read, return a NULL pointer. */
  414. char *
  415. filesys_read_info_file (pathname, filesize, finfo)
  416.      char *pathname;
  417.      long *filesize;
  418.      struct stat *finfo;
  419. {
  420.   *filesize = filesys_error_number = 0;
  421.  
  422.   if (compressed_filename_p (pathname))
  423.     return (filesys_read_compressed (pathname, filesize, finfo));
  424.   else
  425.     {
  426.       int descriptor;
  427.       char *contents;
  428.  
  429.       descriptor = open (pathname, O_RDONLY, 0666);
  430.  
  431.       /* If the file couldn't be opened, give up. */
  432.       if (descriptor < 0)
  433.     {
  434.       filesys_error_number = errno;
  435.       return ((char *)NULL);
  436.     }
  437.  
  438.       /* Try to read the contents of this file. */
  439.       contents = (char *)xmalloc (1 + finfo->st_size);
  440.       if ((read (descriptor, contents, finfo->st_size)) != finfo->st_size)
  441.     {
  442.       filesys_error_number = errno;
  443.       close (descriptor);
  444.       free (contents);
  445.       return ((char *)NULL);
  446.     }
  447.  
  448.       close (descriptor);
  449.  
  450.       *filesize = finfo->st_size;
  451.       return (contents);
  452.     }
  453. }
  454.  
  455. /* Typically, pipe buffers are 4k. */
  456. #define BASIC_PIPE_BUFFER (4 * 1024)
  457.  
  458. /* We use some large multiple of that. */
  459. #define FILESYS_PIPE_BUFFER_SIZE (16 * BASIC_PIPE_BUFFER)
  460.  
  461. char *
  462. filesys_read_compressed (pathname, filesize, finfo)
  463.      char *pathname;
  464.      long *filesize;
  465.      struct stat *finfo;
  466. {
  467.   FILE *stream;
  468.   char *command, *decompressor;
  469.   char *contents = (char *)NULL;
  470.  
  471.   *filesize = filesys_error_number = 0;
  472.  
  473.   decompressor = filesys_decompressor_for_file (pathname);
  474.  
  475.   if (!decompressor)
  476.     return ((char *)NULL);
  477.  
  478.   command = (char *)xmalloc (10 + strlen (pathname) + strlen (decompressor));
  479.   sprintf (command, "%s < %s", decompressor, pathname);
  480.  
  481. #if !defined (BUILDING_LIBRARY)
  482.   if (info_windows_initialized_p)
  483.     {
  484.       char *temp;
  485.  
  486.       temp = (char *)xmalloc (5 + strlen (command));
  487.       sprintf (temp, "%s...", command);
  488.       message_in_echo_area ("%s", temp);
  489.       free (temp);
  490.     }
  491. #endif /* !BUILDING_LIBRARY */
  492.  
  493.   stream = popen (command, "r");
  494.   free (command);
  495.  
  496.   /* Read chunks from this file until there are none left to read. */
  497.   if (stream)
  498.     {
  499.       int offset, size;
  500.       char *chunk;
  501.     
  502.       offset = size = 0;
  503.       chunk = (char *)xmalloc (FILESYS_PIPE_BUFFER_SIZE);
  504.  
  505.       while (1)
  506.     {
  507.       int bytes_read;
  508.  
  509.       bytes_read = fread (chunk, 1, FILESYS_PIPE_BUFFER_SIZE, stream);
  510.  
  511.       if (bytes_read + offset >= size)
  512.         contents = (char *)xrealloc
  513.           (contents, size += (2 * FILESYS_PIPE_BUFFER_SIZE));
  514.  
  515.       memcpy (contents + offset, chunk, bytes_read);
  516.       offset += bytes_read;
  517.       if (bytes_read != FILESYS_PIPE_BUFFER_SIZE)
  518.         break;
  519.     }
  520.  
  521.       free (chunk);
  522.       pclose (stream);
  523.       contents = (char *)xrealloc (contents, offset + 1);
  524.       *filesize = offset;
  525.     }
  526.   else
  527.     {
  528.       filesys_error_number = errno;
  529.     }
  530.  
  531. #if !defined (BUILDING_LIBARARY)
  532.   if (info_windows_initialized_p)
  533.     unmessage_in_echo_area ();
  534. #endif /* !BUILDING_LIBRARY */
  535.   return (contents);
  536. }
  537.  
  538. /* Return non-zero if FILENAME belongs to a compressed file. */
  539. int
  540. compressed_filename_p (filename)
  541.      char *filename;
  542. {
  543.   char *decompressor;
  544.  
  545.   /* Find the final extension of this filename, and see if it matches one
  546.      of our known ones. */
  547.   decompressor = filesys_decompressor_for_file (filename);
  548.  
  549.   if (decompressor)
  550.     return (1);
  551.   else
  552.     return (0);
  553. }
  554.  
  555. /* Return the command string that would be used to decompress FILENAME. */
  556. char *
  557. filesys_decompressor_for_file (filename)
  558.      char *filename;
  559. {
  560.   register int i;
  561.   char *extension = (char *)NULL;
  562.  
  563.   /* Find the final extension of FILENAME, and see if it appears in our
  564.      list of known compression extensions. */
  565.   for (i = strlen (filename) - 1; i > 0; i--)
  566.     if (filename[i] == '.')
  567.       {
  568.     extension = filename + i;
  569.     break;
  570.       }
  571.  
  572.   if (!extension)
  573.     return ((char *)NULL);
  574.  
  575.   for (i = 0; compress_suffixes[i].suffix; i++)
  576.     if (strcmp (extension, compress_suffixes[i].suffix) == 0)
  577.       return (compress_suffixes[i].decompressor);
  578.  
  579.   return ((char *)NULL);
  580. }
  581.  
  582. /* The number of the most recent file system error. */
  583. int filesys_error_number = 0;
  584.  
  585. #if !defined (HAVE_STRERROR)
  586. extern char *sys_errlist[];
  587. extern int sys_nerr;
  588.  
  589. char *
  590. strerror (num)
  591.      int num;
  592. {
  593.   if (num >= sys_nerr)
  594.     return ("");
  595.   else
  596.     return (sys_errlist[num]);
  597. }
  598. #endif /* !HAVE_STRERROR */
  599.  
  600. /* A function which returns a pointer to a static buffer containing
  601.    an error message for FILENAME and ERROR_NUM. */
  602. static char *errmsg_buf = (char *)NULL;
  603. static int errmsg_buf_size = 0;
  604.  
  605. char *
  606. filesys_error_string (filename, error_num)
  607.      char *filename;
  608.      int error_num;
  609. {
  610.   int len;
  611.   char *result;
  612.  
  613.   if (error_num == 0)
  614.     return ((char *)NULL);
  615.  
  616.   result = strerror (error_num);
  617.  
  618.   len = 4 + strlen (filename) + strlen (result);
  619.   if (len >= errmsg_buf_size)
  620.     errmsg_buf = (char *)xrealloc (errmsg_buf, (errmsg_buf_size = 2 + len));
  621.  
  622.   sprintf (errmsg_buf, "%s: %s", filename, result);
  623.   return (errmsg_buf);
  624. }
  625.  
  626.