/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/EventFilter/HltUtilities/HltTools/HltTools-01-00-02/src/PathResolver.cxx

Go to the documentation of this file.

#include "HltTools/PathResolver.h"

#include <cstdlib>
#include <cstdio>

#include <iostream>
#include <vector>
#include <string.h>

#include <sys/stat.h>

#ifdef WIN32
#define stat _stat
#include <direct.h>
#else
#include <unistd.h>
#include <dirent.h>
#endif

typedef enum
  {
    PR_regular_file,
    PR_directory
  } PR_file_type;

typedef enum
  {
    PR_local,
    PR_recursive
  } PR_search_type;

static void PR_compress_path (std::string& dir)
{
#ifdef WIN32
  static const char pattern[] = "\\..\\";
#else
  static const char pattern[] = "/../";
#endif

#ifdef WIN32
  static const char file_separator = '\\';
  static const char double_file_separator[] = "\\\\";
#else
  static const char file_separator = '/';
  static const char double_file_separator[] = "//";
#endif

  if (dir.size () == 0) return;

    //
    // We first synchronize to using file_separator() in any case.
    //

  for (;;)
    {
      std::string::size_type pos;
      pos = dir.find (double_file_separator);
      if (pos == std::string::npos) break;
      dir.erase (pos, 1);
    }

  for (;;)
    {
      std::string::size_type pos1;
      std::string::size_type pos2;

      pos1 = dir.find (pattern);
      if (pos1 == std::string::npos) break;

        //
        // extract "aaaa/xxxx" from "aaaa/xxxx/../bbbb"
        //
      std::string p = dir.substr (0, pos1);
      
        //
        // Is "aaaa/xxxx" only made of "xxxx" ?
        // 
      pos2 = p.find_last_of (file_separator);
      
      if (pos2 == std::string::npos) break;
      
        //    01234567890123456
        //    aaaa/xxxx/../bbbb
        //        2    1   3
        //
        // erase the "/xxxx/../" pattern
        // result will be "aaaa/bbbb"
        //
      dir.erase (pos2, pos1 + 4 - pos2 - 1);
    }

    //if (dir[dir.size () - 1] == file_separator ()) dir.erase (dir.size () - 1);
}

static void PR_dirname (const std::string& file_name, std::string& result)
{
  std::string::size_type pos = file_name.find_last_of ('/');
  if (pos == std::string::npos)
    {
      pos = file_name.find_last_of ('\\');
    }

  if (pos == std::string::npos)
    {
      result = "";
    }
  else
    {
      result = file_name;
      result.erase (pos);
    }
}

static bool PR_absolute_path (const std::string& name)
{
  if (name.size () == 0) return (false);

  if ((name[0] == '/') ||
      (name[0] == '\\')) return (true);

  if (name.size () >= 2)
    {
      if (name[1] == ':')
        {
          return (true);
        }
    }
  return (false);
}

static void PR_basename (const std::string& file_name, std::string& result)
{
  std::string::size_type pos = file_name.find_last_of ('/');

  if (pos == std::string::npos)
    {
      pos = file_name.find_last_of ('\\');
    }

  if (pos == std::string::npos)
    {
      result = file_name;
    }
  else
    {
      result = file_name.substr (pos + 1);
    }
}

static bool PR_test_exist (const std::string& name, std::string& real_name, PR_file_type file_type)
{
  struct stat file_stat;
  int status;

  char buf[1024];

  strcpy (buf, name.c_str ());

#ifdef WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif

  real_name = name;

  //std::cout << "test_file> name=" << name << std::endl;

  for (;;)
    {
      status = lstat (buf, &file_stat);

      if (status == 0)
        {
          if (S_ISLNK (file_stat.st_mode) != 0)
            {
              //std::cout << "#1 " << buf << " stat=" << std::oct << file_stat.st_mode << std::dec << std::endl;

              int n = readlink (buf, buf, sizeof (buf));
              if (n >= 0) buf[n] = 0;

              //std::cout << "test_exist> buf=" << buf << std::endl;

              if (PR_absolute_path (buf))
                {
                  real_name = buf;
                }
              else
                {
                  PR_dirname (real_name, real_name);
                  real_name += file_separator;
                  real_name += buf;

                  PR_compress_path (real_name);

                  strcpy (buf, real_name.c_str ());
                }

              //std::cout << "#2 " << real_name << std::endl;

              //break;
            }
          else
            {
              break;
            }
        }
      else
        {
          break;
        }
    }

  status = stat (name.c_str (), &file_stat);

  if (status == 0)
    {
      if ((file_stat.st_mode & S_IFDIR) == 0)
        {
          return (file_type == PR_regular_file);
        }
      else
        {
          return (file_type == PR_directory);
        }
    }
  else
    {
      return (false);
    }
}

static void PR_scan_dir (const std::string& dir_name,
                         std::vector<std::string>& list)
{
#ifdef WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif

  static std::string dir_prefix;
  static std::string name_prefix;
  static std::string real_name;

  dir_prefix = dir_name;
  if (dir_name == "") dir_prefix = ".";

  //std::cout << "PR_scan_dir1> dir_name=" << dir_name << " dir_prefix=" << dir_prefix << std::endl;

  if (!PR_test_exist (dir_prefix, real_name, PR_directory))
    {
      PR_dirname (dir_prefix, dir_prefix);
      PR_basename (dir_name, name_prefix);
    }

  bool need_filter = false;

  std::string::size_type wild_card;
    //unsigned int wild_card;

  wild_card = name_prefix.find ('*');
  if (wild_card != std::string::npos)
    {
      name_prefix.erase (wild_card);

      if (name_prefix.size () > 0)
        {
          need_filter = true;
        }

    }

  list.clear ();

#ifdef WIN32

  long dir;
  struct _finddata_t entry;

  static std::string search;

  search = dir_prefix;
  search += file_separator;
  search += "*";

  dir = _findfirst (search.c_str (), &entry);
  if (dir > 0)
    {
      for (;;)
        {
          if ((strcmp ((char*) entry.name, ".") != 0) &&
              (strcmp ((char*) entry.name, "..") != 0) &&
              (strncmp ((char*) entry.name, ".nfs", 4) != 0))
            {
              const char* name = entry.name;

              if (!need_filter ||
                  (strncmp (name, name_prefix.c_str (), name_prefix.size ()) == 0))
                {
                  std::string& name_entry = list.add ();

                  name_entry = dir_prefix;
                  name_entry += file_separator;
                  name_entry += name;
                }
            }

          int status = _findnext (dir, &entry);
          if (status != 0)
            {
              break;
            }
        }

      _findclose (dir);
    }
#else

  //std::cout << "scan_dir2> dir_prefix=" << dir_prefix << std::endl;

  DIR* dir = opendir (dir_prefix.c_str ());

  struct dirent* entry;

  if (dir != 0)
    {

      //std::cout << "scan_dir3> need_filter=" << need_filter << std::endl;

      while ((entry = readdir (dir)) != 0)
        {
          //if (entry->d_name[0] == '.') continue;
          if (!strcmp ((char*) entry->d_name, ".")) continue;
          if (!strcmp ((char*) entry->d_name, "..")) continue;
          if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue;

          const char* name = entry->d_name;

          //std::cout << "scan_dir4> name=" << name << std::endl;

          if (need_filter &&
              (strncmp (name, name_prefix.c_str (), name_prefix.size ()) != 0)) continue;

          std::string name_entry;

          name_entry = dir_prefix;
          name_entry += file_separator;
          name_entry += name;

          list.push_back (name_entry);
        }

      closedir (dir);
    }
#endif

}

static void PR_indent (int level)
{
  while (level > 0)
    {
      std::cout << "  ";
      level --;
    }
}

static bool PR_find (const std::string& search_base, 
                     const std::string& logical_file_prefix, 
                     const std::string& logical_file_name, 
                     PR_file_type file_type,
                     PathResolver::SearchType search_type,
                     std::string& result)
{
  static int level = 0;

#ifdef WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif

  std::string file_path = "";
  std::string real_name = "";

  bool found = false;

  //PR_indent (level); std::cout << "PR_find> sb=" << search_base << " lfp=" << logical_file_prefix << " lfn=" << logical_file_name << std::endl;

  if (search_base != "")
    {
      file_path = search_base;
      file_path += file_separator;
    }
  else
    {
      file_path = "";
    }

  file_path += logical_file_name;

  //PR_indent (level); std::cout << "PR_find> test1 file_path=" << file_path << std::endl;

  result = file_path;
  if (PR_test_exist (file_path, result, file_type))
    {
      found = true;
    }

  if (!found && (logical_file_prefix != ""))
    {
      if (search_base != "")
        {
          file_path = search_base;
          file_path += file_separator;
        }
      else
        {
          file_path = "";
        }

      file_path += logical_file_prefix;
      file_path += file_separator;
      file_path += logical_file_name;

      //PR_indent (level); std::cout << "PR_find> test2 file_path=" << file_path << std::endl;

      result = file_path;
      if (PR_test_exist (file_path, result, file_type))
        {
          found = true;
        }
    }

  //PR_indent (level); std::cout << "PR_find> test3 found=" << found << " search_type=" << search_type << std::endl;

  if (!found && (search_type == PathResolver::RecursiveSearch))
    {
      std::string dir_name = "";
      std::string file_name = "";
      std::vector<std::string> list;

      PR_scan_dir (search_base, list);

      std::vector<std::string>::iterator it;

      for (it = list.begin (); it != list.end (); ++it)
        {
          const std::string& d = *it;

          if (PR_test_exist (d, file_path, PR_directory))
            {
              //PR_indent (level); std::cout << "d=" << d << std::endl;

              level++;
              bool s = PR_find (d, logical_file_prefix, logical_file_name, file_type, search_type, result);
              level--;

              if (s)
                {
                  //PR_indent (level); std::cout << "PR_find> result=" << result << std::endl;
                  found = true;
                  break;
                }
            }
        }
    }

  return (found);
}

static bool PR_find_from_list (const std::string& logical_file_name,
                               const std::string& search_list,
                               PR_file_type file_type,
                               PathResolver::SearchType search_type,
                               std::string& result)
{
#ifdef WIN32
  static const char path_separator = ';';
#else
  static const char path_separator = ':';
#endif

  std::string::size_type pos = 0;

  std::string file_name = "";
  std::string file_prefix = "";

  PR_basename (logical_file_name, file_name);
  PR_dirname (logical_file_name, file_prefix);

  std::string real_name = "";

  bool found = false;

  if (PR_find ("", file_prefix, file_name, file_type, search_type, result))
    {
      found = true;
    }

  if (!found)
    {
      for (int i = 0;;i++)
        {
          bool ending = false;

          std::string::size_type next = search_list.find (path_separator, pos);

          std::string path = search_list.substr (pos, next - pos);

          if (next == std::string::npos)
            {
              path = search_list.substr (pos);
              ending = true;
            }
          else
            {
              path = search_list.substr (pos, next - pos);
              pos = next + 1;
            }
          
          //std::cout << "path[" << i << "]=" << path << std::endl;
          
          if (PR_find (path, file_prefix, file_name, file_type, search_type, result))
            {
              found = true;
              break;
            }
          
          if (ending) break;
        }
    }

  return (found);
}

std::string PathResolver::find_file (const std::string& logical_file_name,
                                     const std::string& search_path,
                                     SearchType search_type)
{
  const char* path_env = ::getenv (search_path.c_str ());

  std::string path_list;

  if (path_env != 0)
    {
      path_list = path_env;
    }

  return (find_file_from_list (logical_file_name, path_list, search_type));
}

std::string PathResolver::find_file_from_list (const std::string& logical_file_name,
                                               const std::string& search_list,
                                               SearchType search_type)
{
  std::string result;

  if (!PR_find_from_list (logical_file_name, search_list, PR_regular_file, search_type, result))
    {
      result = "";
    }

  return (result);
}

std::string PathResolver::find_directory (const std::string& logical_file_name,
                                          const std::string& search_path,
                                          SearchType search_type)
{
  const char* path_env = ::getenv (search_path.c_str ());

  std::string path_list;

  if (path_env != 0)
    {
      path_list = path_env;
    }

  return (find_directory_from_list (logical_file_name, path_list, search_type));
}

std::string PathResolver::find_directory_from_list (const std::string& logical_file_name,
                                                    const std::string& search_list,
                                                    SearchType search_type)
{
  std::string result;

  if (!PR_find_from_list (logical_file_name, search_list, PR_directory, search_type, result))
    {
      result = "";
    }

  return (result);
}

PathResolver::SearchPathStatus PathResolver::check_search_path (const std::string& search_path)
{
  const char* path_env = ::getenv (search_path.c_str ());

  if (path_env == 0) return (EnvironmentVariableUndefined);

#ifdef WIN32
  static const char path_separator = ';';
#else
  static const char path_separator = ':';
#endif

  std::string path_list (path_env);

  std::string::size_type pos = 0;

  for (int i = 0;;i++)
    {
      bool ending = false;

      std::string::size_type next = path_list.find (path_separator, pos);

      std::string path = path_list.substr (pos, next - pos);

      if (next == std::string::npos)
        {
          path = path_list.substr (pos);
          ending = true;
        }
      else
        {
          path = path_list.substr (pos, next - pos);
          pos = next + 1;
        }

      std::string real_name = "";

      if (!PR_test_exist (path, real_name, PR_directory))
        {
          return (UnknownDirectory);
        }

      if (ending) break;
    }

  return (Ok);
}




extern "C"
{
  PathResolver::SearchPathStatus PathResolverCheckSearchPath (const std::string& search_path)
  {
    return PathResolver::check_search_path (search_path);
  }
  
  std::string PathResolverFindDirectory (const std::string& logical_file_name,
                                         const std::string& search_path)
  {
    return PathResolver::find_directory (logical_file_name, search_path);
  }
  
  std::string PathResolverFindDirectoryFromList (const std::string& logical_file_name,
                                                 const std::string& search_list)
  {
    return PathResolver::find_directory_from_list (logical_file_name, search_list);
  }
  
  std::string PathResolverFindFile (const std::string& logical_file_name,
                                    const std::string& search_path)
  {
    return PathResolver::find_file (logical_file_name, search_path);
  }
  
  std::string PathResolverFindFileFromList (const std::string& logical_file_name,
                                            const std::string& search_list)
  {
    return PathResolver::find_file_from_list (logical_file_name, search_list);
  }
  
  std::string PathResolverFindXMLFile (const std::string& logical_file_name)
  {
    return PathResolver::find_file (logical_file_name, "XMLPATH");
  }
  
  std::string PathResolverFindDataFile (const std::string& logical_file_name)
  {
    return PathResolver::find_file (logical_file_name, "DATAPATH");
  }
}

---