hashcmd.cc

/* hashcmd.cc - functions for managing a hash table mapping command names to
               full pathnames. */

/* Copyright (C) 1997-2021 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   Bash is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "config.h"

#include "shell.hh"

namespace bash
{

#if 0
HASH_TABLE *hashed_filenames = (HASH_TABLE *)NULL;

static void phash_freedata (PTR_T);
#endif

void
phash_create ()
{
  if (hashed_filenames == 0)
    hashed_filenames = hash_create (FILENAME_HASH_BUCKETS);
}

static void
phash_freedata (PTR_T data)
{
  free (((PATH_DATA *)data)->path);
  free (data);
}

void
phash_flush ()
{
  if (hashed_filenames)
    hash_flush (hashed_filenames, phash_freedata);
}

/* Remove FILENAME from the table of hashed commands. */
int
phash_remove (const char *filename)
{
  BUCKET_CONTENTS *item;

  if (hashing_enabled == 0 || hashed_filenames == 0)
    return 0;

  item = hash_remove (filename, hashed_filenames, 0);
  if (item)
    {
      if (item->data)
        phash_freedata (item->data);
      free (item->key);
      free (item);
      return 0;
    }
  return 1;
}

/* Place FILENAME (key) and FULL_PATH (data->path) into the
   hash table.  CHECK_DOT if non-null is for future calls to
   phash_search (); it means that this file was found
   in a directory in $PATH that is not an absolute pathname.
   FOUND is the initial value for times_found. */
void
phash_insert (const char *filename, const char *full_path, bool check_dot,
              int found)
{
  BUCKET_CONTENTS *item;

  if (hashing_enabled == 0)
    return;

  if (hashed_filenames == 0)
    phash_create ();

  item = hash_insert ((char *)filename, hashed_filenames, 0);
  if (item->data)
    free (pathdata (item)->path);
  else
    {
      item->key = savestring (filename);
      item->data = xmalloc (sizeof (PATH_DATA));
    }
  pathdata (item)->path = savestring (full_path);
  pathdata (item)->flags = 0;
  if (check_dot)
    pathdata (item)->flags |= HASH_CHKDOT;
  if (*full_path != '/')
    pathdata (item)->flags |= HASH_RELPATH;
  item->times_found = found;
}

/* Return the full pathname that FILENAME hashes to.  If FILENAME
   is hashed, but (data->flags & HASH_CHKDOT) is non-zero, check
   ./FILENAME and return that if it is executable.  This always
   returns a newly-allocated string; the caller is responsible
   for freeing it. */
char *
Shell::phash_search (const char *filename)
{
  BUCKET_CONTENTS *item;
  char *path, *dotted_filename, *tail;
  int same;

  if (hashing_enabled == 0 || hashed_filenames == 0)
    return nullptr;

  item = hash_search (filename, hashed_filenames, 0);

  if (item == NULL)
    return nullptr;

  /* If this filename is hashed, but `.' comes before it in the path,
     see if ./filename is executable.  If the hashed value is not an
     absolute pathname, see if ./`hashed-value' exists. */
  path = pathdata (item)->path;
  if (pathdata (item)->flags & (HASH_CHKDOT | HASH_RELPATH))
    {
      tail = (pathdata (item)->flags & HASH_RELPATH)
                 ? path
                 : (char *)filename; /* XXX - fix const later */
      /* If the pathname does not start with a `./', add a `./' to it. */
      if (tail[0] != '.' || tail[1] != '/')
        {
          dotted_filename = (char *)xmalloc (3 + strlen (tail));
          dotted_filename[0] = '.';
          dotted_filename[1] = '/';
          strcpy (dotted_filename + 2, tail);
        }
      else
        dotted_filename = savestring (tail);

      if (executable_file (dotted_filename))
        return dotted_filename;

      free (dotted_filename);

#if 0
      if (pathdata(item)->flags & HASH_RELPATH)
	return nullptr;
#endif

      /* Watch out.  If this file was hashed to "./filename", and
         "./filename" is not executable, then return NULL. */

      /* Since we already know "./filename" is not executable, what
         we're really interested in is whether or not the `path'
         portion of the hashed filename is equivalent to the current
         directory, but only if it starts with a `.'.  (This catches
         ./. and so on.)  same_file () tests general Unix file
         equivalence -- same device and inode. */
      if (*path == '.')
        {
          same = 0;
          tail = (char *)strrchr (path, '/');

          if (tail)
            {
              *tail = '\0';
              same = same_file (".", path, (struct stat *)NULL,
                                (struct stat *)NULL);
              *tail = '/';
            }

          return same ? nullptr : savestring (path);
        }
    }

  return savestring (path);
}

} // namespace bash