source: trunk/athena/lib/athdir/athdir.c @ 13786

/* Copyright 1998 by the Massachusetts Institute of Technology.
 *
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting
 * documentation, and that the name of M.I.T. not be used in
 * advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.
 * M.I.T. makes no representations about the suitability of
 * this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 */

/* This file implements the main athdir library calls. */

static const char rcsid[] = "$Id: athdir.c,v 1.6 1999-10-23 19:28:46 danw Exp $";

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>          /* MAXPATHLEN */
#include <sys/types.h>
#include <sys/stat.h>
#include "athdir.h"
#include "stringlist.h"

/* Define HOSTTYPE for the platforms where `machtype`bin has historic
 * use.  Never add new platforms to this list.
 */
#if defined(HOSTTYPE_sun4)
#define HOSTTYPE "sun4"
#elif defined(HOSTTYPE_linux)
#define HOSTTYPE "linux"
#elif defined(HOSTTYPE_inbsd)
#define HOSTTYPE "inbsd"
#endif

#ifdef HOSTTYPE
char *hosttype = HOSTTYPE;
#else
char *hosttype = NULL;
#endif

/* Definition of known conventions and what flavors they are.  */

typedef struct {
  char *name;
  int flavor;
} Convention;

#define ARCHflavor (1<<0)
#define MACHflavor (1<<1)
#define PLAINflavor (1<<2)
#define SYSflavor (1<<3)
#define DEPENDENTflavor (1<<8)
#define INDEPENDENTflavor (1<<9)
#define ATSYSflag (1<<16)

#define NUMCONVENTIONS 5

Convention conventions[NUMCONVENTIONS] = {
  { NULL,               ARCHflavor | MACHflavor | PLAINflavor |
                        DEPENDENTflavor | INDEPENDENTflavor },
  { "%p/arch/%s/%t",    ARCHflavor | DEPENDENTflavor | ATSYSflag },
  { "%p/%s/%t",         SYSflavor | DEPENDENTflavor | ATSYSflag },
  { "%p/%m%t",          MACHflavor | DEPENDENTflavor },
  { "%p/%t",            PLAINflavor | INDEPENDENTflavor }
};

/* Editorial tagging for what conventions are acceptable or
 * preferable for what types.
 */

typedef struct {
  char *type;
  int allowedFlavors;   /* searching parameters */
  int preferredFlavor;  /* creating paramaters */
} Editorial;

Editorial editorials[] = {
  { "bin",      ARCHflavor | SYSflavor | MACHflavor,    DEPENDENTflavor },
  { "lib",      ARCHflavor | SYSflavor | MACHflavor,    DEPENDENTflavor },
  { "etc",      ARCHflavor | SYSflavor | MACHflavor,    DEPENDENTflavor },
  { "man",      ARCHflavor | PLAINflavor,               INDEPENDENTflavor },
  { "include",  ARCHflavor | PLAINflavor,               INDEPENDENTflavor },
  { NULL,       ARCHflavor | PLAINflavor,               DEPENDENTflavor }
};

/* path = template(dir, type, sys, machine)
 *      %p = path (dir)
 *      %t = type
 *      %s = sys
 *      %m = machine
 * %foo is inserted if the corresponding string is NULL.
 * If this happens, expand returns 1 (not a valid path).
 * If expand runs out of memory, it returns -1 (and path is NULL).
 * Otherwise, expand returns 0.
 */
static int expand(char **path, char *template, char *dir,
           char *type, char *sys, char *machine)
{
  char *src, *dst, *oldpath;
  int somenull = 0, size;

  src = template;
  size = strlen(template) + 1;
  dst = oldpath = *path = malloc(size);
  *dst = '\0';

  while (*src != '\0')
    {
      if (*src != '%')
        *dst++ = *src++;
      else
        {

#define copystring(casec, cases, string)                        \
        case casec:                                             \
          src++;                                                \
          if (string)                                           \
            {                                                   \
              *path = realloc(*path, size += strlen(string));   \
              if (!*path)                                       \
                return -1;                                      \
              dst = *path + (dst - oldpath);                    \
              oldpath = *path;                                  \
              strcpy(dst, string);                              \
              dst += strlen(string);                            \
            }                                                   \
          else                                                  \
            {                                                   \
              strcpy(dst, cases);                               \
              dst += 2;                                         \
              somenull = 1;                                     \
            }                                                   \
          break;

          src++;
          switch(*src)
            {
              copystring('p', "%p", dir);
              copystring('t', "%t", type);
              copystring('s', "%s", sys);
              copystring('m', "%m", machine);

#undef copystring

            case '\0':
              break;

            default:
              *dst++ = '%';
              *dst++ = *src++;
              break;
            }
        }
    }

  *dst = '\0';
  return somenull;
}

static int template_flavor(char *template)
{
  int flavor = ARCHflavor | MACHflavor | PLAINflavor
    | DEPENDENTflavor | INDEPENDENTflavor;
  char *ptr;

  if (template == NULL)
    return 0;

  for (ptr = strchr(template, '%'); ptr != NULL; ptr = strchr(ptr + 1, '%'))
    {
      if (*(ptr+1) == 's')
        flavor |= ATSYSflag;
    }

  return flavor;
}

int athdir_native(char *what, char *sys)
{
  char *ptr;

  /* If sys is NULL, fall back to ATHENA_SYS if it's set, otherwise
   * use the compiled-in value.
   */
  if (sys == NULL)
    {
      sys = getenv("ATHENA_SYS");
      if (sys == NULL || strchr(sys, '/') != NULL)
        sys = ATHSYS;
    }

  for (ptr = strchr(what, sys[0]); ptr != NULL; ptr = strchr(ptr + 1, sys[0]))
    {
      if (!strncmp(ptr, sys, strlen(sys)))
        return 1;
    }

  return 0;
}

/* You are in a twisty little maze of interconnecting flags, all different.
 */
char **athdir_get_paths(char *base_path, char *type,
                        char *sys, char **syscompat, char *machine,
                        char *aux, int flags)
{
  char *path;
  string_list *path_list = NULL, *compat_list = NULL;
  int t, j, complete, preferredFlavor, want_break;
  struct stat statbuf;
  char **current_compat, **mysyscompat = NULL, *compat_env;

  /* If sys is NULL, fall back to ATHENA_SYS if it's set, otherwise
   * use the compiled-in value.
   */
  if (sys == NULL)
    {
      sys = getenv("ATHENA_SYS");
      if (sys == NULL || strchr(sys, '/') != NULL)
        sys = ATHSYS;
    }

  /* Generate the syscompat array from the environment if it wasn't
   * passed in.
   */
  if (syscompat == NULL)
    {
      /* We're compatible with ourselves. */
      if (athdir__add_string(&compat_list, sys, 0))
        return NULL;
      compat_env = getenv("ATHENA_SYS_COMPAT");
      if (compat_env != NULL && !strchr(compat_env, '/'))
        {
          if (athdir__parse_string(&compat_list, compat_env, ':'))
            return NULL;
        }
      syscompat = mysyscompat = athdir__make_string_array(&compat_list);
    }

  /* If machine is NULL, use whatever was compiled in. */
  if (machine == NULL)
    machine = hosttype;

  /* Zeroeth convention is optionally provided by the caller. */
  conventions[0].name = aux;
  conventions[0].flavor = template_flavor(aux);

  /* Find matching editorial for the type of directory requested
   * (to be consulted later).
   */
  for (t = 0; editorials[t].type != NULL; t++)
    {
      if (type != NULL && !strcmp(type, editorials[t].type))
        break;
    }

  if (flags & ATHDIR_MACHINEDEPENDENT)
    preferredFlavor = DEPENDENTflavor;
  else
    {
      if (flags & ATHDIR_MACHINEINDEPENDENT)
        preferredFlavor = INDEPENDENTflavor;
      else
        preferredFlavor = editorials[t].preferredFlavor;
    }

  /* Cycle through matching conventions */
  for (j = 0; j < NUMCONVENTIONS; j++)
    {
      if (conventions[j].name == NULL)
        continue; /* conventions[0], the caller specified convention,
                   * is not set. */
      want_break = 0;

      if (
          /* If the editorial says this is a reasonable convention
           * for this type
           */
          (editorials[t].allowedFlavors & conventions[j].flavor) ||

          /* or we don't care what the editorials say */
          (flags & ATHDIR_SUPPRESSEDITORIALS) || 

          /* or something more explicit than the editorials has been
           * specified
           */
          (((ATHDIR_MACHINEDEPENDENT | ATHDIR_MACHINEINDEPENDENT) & flags) &&
           (flags & ATHDIR_SUPPRESSSEARCH)))
        {
          /* If we're looking for a specific flavor (machine dependent/
           * machine independent) and this isn't it, keep going.
           */
          if ((ATHDIR_SUPPRESSSEARCH & flags) &&
              !(preferredFlavor & conventions[j].flavor))
            continue;

          for (current_compat = syscompat; *current_compat != NULL;
               current_compat++)
            {
              complete = !expand(&path, conventions[j].name,
                                 base_path, type, *current_compat, hosttype);

              if (!path)
                return NULL;

              /* If we're listing everything, or we only care about the
               * first match for creation purposes (both cases where we
               * don't want to stat()), store this match.
               */
              if ((flags & ATHDIR_LISTSEARCHDIRECTORIES) ||
                  ((flags & ATHDIR_SUPPRESSSEARCH) && complete))
                {
                  if (athdir__add_string(&path_list, path, 0))
                    {
                      free(path);
                      return NULL;
                    }
                  free(path);
                  
                  /* In this case (first match for creation) we're done. */
                  if (flags & ATHDIR_SUPPRESSSEARCH)
                    {
                      want_break = 1;
                      break;
                    }
                }
              else /* If it's there, store it and be done. */
                if (complete && !stat(path, &statbuf))
                  {
                    if (athdir__add_string(&path_list, path, 0))
                      {
                        free(path);
                        return NULL;
                      }
                    free(path);
                    want_break = 1;
                    break;
                  }
              else
                free(path);

              /* Don't loop over @sys values unless ATSYSflag. */
              if (!(conventions[j].flavor & ATSYSflag))
                break;
            }
        }

      if (want_break)
        break;
    }

  athdir__free_string_array(mysyscompat);
  return athdir__make_string_array(&path_list);
}

void athdir_free_paths(char **paths)
{
  athdir__free_string_array(paths);
}