user/applications/which/main.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <errno.h>
#include <getopt.h>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <regex>
#include <sstream>
#include <string>
#include <unistd.h>
#include <vector>
 
#include <sys/stat.h>
 
using std::cerr;
using std::cin;
using std::copy;
using std::cout;
using std::endl;
using std::list;
using std::map;
using std::regex;
using std::string;
using std::stringstream;
using std::vector;
 
int processOpts(int argc, char* argv[]);
void usage();
void version();
void split(const std::string& s, char delim, vector<string>& elems);
int findPaths(string filename);
void readAliasesAndFunctions();
void setupFromEnv();
 
enum tty_opts {
  opt_skip_dot,
  opt_show_dot,
  opt_skip_tilde,
  opt_show_tilde,
  opt_tty_only,
};
 
struct CommandLineOptions {
 public:
  CommandLineOptions()
      : all(0),
        readAliases(0),
        readFunctions(0),
        showDot(0),
        skipDot(0),
        showTilde(0),
        skipTilde(0) {};
  int all;
  int readAliases;
  int readFunctions;
  int showDot;
  int skipDot;
  int showTilde;
  int skipTilde;
} static opts;
 
static list<string> aliases, functions;
static string home, cwd;
 
int processOpts(int argc, char* argv[]) {
  int c, longOption, ttyOnly = 0;
  struct option long_options[] = {{"all", no_argument, &opts.all, 1},
                                  {"read-alias", no_argument, &opts.readAliases, 1},
                                  {"skip-alias", no_argument, &opts.readAliases, 0},
                                  {"read-functions", no_argument, &opts.readFunctions, 1},
                                  {"skip-functions", no_argument, &opts.readFunctions, 0},
                                  {"skip-dot", no_argument, &longOption, opt_skip_dot},
                                  {"show-dot", no_argument, &longOption, opt_show_dot},
                                  {"skip-tilde", no_argument, &longOption, opt_skip_tilde},
                                  {"show-tilde", no_argument, &longOption, opt_show_tilde},
                                  {"tty-only", no_argument, &longOption, opt_tty_only},
                                  {"version", no_argument, 0, 'v'},
                                  {"help", no_argument, 0, 'h'},
                                  {0, 0, 0, 0}};
 
  while (1) {
    c = getopt_long(argc, argv, "aivVh", long_options, NULL);
 
    if (c == -1)
      break;
 
    switch (c) {
      case 0:
        switch (longOption) {
          case opt_skip_dot:
            opts.skipDot = !ttyOnly;
            break;
          case opt_show_dot:
            opts.showDot = !ttyOnly;
            break;
          case opt_skip_tilde:
            opts.skipTilde = !ttyOnly;
            break;
          case opt_show_tilde:
            opts.showTilde = !ttyOnly;
            break;
          case opt_tty_only:
            ttyOnly = !isatty(1);
            break;
        }
        break;
      case 'a':
        opts.all = 1;
        break;
      case 'i':
        opts.readAliases = 1;
        break;
      case 'v':
      case 'V':
        version();
        return 1;
      case 'h':
        usage();
        return 1;
    }
  }
 
  return 0;
}
 
void usage() {
  cout << "Usage: which [options] [--] COMMAND [...]" << endl;
  cout << "Write the full path of COMMAND(s) to standard output." << endl;
  cout << endl;
  cout << "  --version, -[vV] Print version and exit successfully." << endl;
  cout << "  --help,          Print this help and exit successfully." << endl;
  cout << "  --skip-dot       Skip directories in PATH that start with a dot." << endl;
  cout << "  --skip-tilde     Skip directories in PATH that start with a "
          "tilde."
       << endl;
  cout << "  --show-dot       Don't expand a dot to current directory in "
          "output."
       << endl;
  cout << "  --show-tilde     Output a tilde for HOME directory for non-root." << endl;
  cout << "  --tty-only       Stop processing options on the right if not on "
          "tty."
       << endl;
  cout << "  --all, -a        Print all matches in PATH, not just the first" << endl;
  cout << "  --read-alias, -i Read list of aliases from stdin." << endl;
  cout << "  --skip-alias     Ignore option --read-alias; don't read stdin." << endl;
  cout << "  --read-functions Read shell functions from stdin." << endl;
  cout << "  --skip-functions Ignore option --read-functions; don't read "
          "stdin."
       << endl;
  cout << endl;
  cout << "Recommended use is to write the output of (alias; declare -f) to "
          "standard"
       << endl;
  cout << "input, so that which can show aliases and shell functions. See "
          "which(1) fo"
       << endl;
  cout << "examples." << endl;
  cout << endl;
  cout << "If the options --read-alias and/or --read-functions are specified "
          "then the"
       << endl;
  cout << "output can be a full alias or function definition, optionally "
          "followed by"
       << endl;
  cout << "the full path of each command used inside of those." << endl;
}
 
void version() {
  cout << "which v1.0, Copyright (C) 2014 Nathan Hoad" << endl;
}
 
void split(const std::string& s, char delim, vector<string>& elems) {
  stringstream ss(s);
  string item;
  while (std::getline(ss, item, delim)) {
    elems.push_back(item);
  }
}
 
int findPaths(string filename) {
  char* path;
  vector<string> dirs;
  int failed;
 
  for (auto& alias : aliases) {
    if (alias.find(filename) == 0) {
      cout << alias << endl;
      if (opts.all == 0)
        return 0;
    }
  }
 
  for (auto& function : functions) {
    if (function.find(filename) == 0) {
      cout << function << endl;
      if (opts.all == 0)
        return 0;
    }
  }
 
  path = getenv("PATH");
  failed = 1;
  split(path ? path : "", ':', dirs);
 
  for (auto& dir : dirs) {
    // clean up paths so we don't render double slashes
    while (dir.rbegin() != dir.rend() && *dir.rbegin() == '/')
      dir.pop_back();
 
    string fullpath = dir + "/" + filename;
    string printed_path;
 
    struct stat sb;
    if ((stat(fullpath.c_str(), &sb) == 0) && sb.st_mode & S_IXUSR) {
      if (opts.showDot && dir[0] == '.' && fullpath.compare(0, cwd.size(), cwd) == 0) {
        printed_path = string("./") + filename;
      } else {
        if (opts.showTilde && !home.empty() && fullpath.compare(0, home.size(), home) == 0) {
          fullpath = fullpath.substr(home.size(), fullpath.size() - home.size());
          printed_path = string("~") + fullpath;
        } else {
          printed_path = fullpath;
        }
      }
 
      if (printed_path.size()) {
        if (opts.skipTilde && printed_path[0] == '~' && geteuid() != 0)
          continue;
        else if (opts.skipDot && printed_path[0] == '.')
          continue;
        cout << printed_path << endl;
        failed = 0;
        if (opts.all == 0)
          break;
      }
    }
  }
 
  return failed;
}
 
void readAliasesAndFunctions() {
  if (!opts.readFunctions && !opts.readAliases)
    return;
 
  if (isatty(0))
    cerr << "which: warning: stdin is a tty" << endl;
 
  string line, function;
 
  while (std::getline(cin, line, '\n')) {
    if (opts.readAliases && regex_match(line, regex("^.+=.+?$")))
      aliases.push_back(line);
    else if (opts.readFunctions) {
      function = line + "\n";
      while (std::getline(cin, line, '\n') && line != "}") {
        function += line + "\n";
      }
 
      if (line == "}") {
        function += "}\n";
        functions.push_back(function);
        function = "";
      }
    } else {
      cerr << "which: line doesn't appear to be an alias and functions "
              "are disabled "
           << line << endl;
      exit(EXIT_FAILURE);
    }
  }
}
 
void setupFromEnv() {
  char* _home;
  char _cwd[PATH_MAX];
 
  _home = getenv("HOME");
  home = _home ? _home : "";
 
  memset(_cwd, 0, PATH_MAX);
  if (getcwd(_cwd, PATH_MAX) == NULL) {
    cerr << "which: unable to retrieve current working directory " << strerror(errno) << endl;
    exit(EXIT_FAILURE);
  }
 
  cwd = _cwd;
}
 
int main(int argc, char* argv[]) {
  int status;
 
  if (processOpts(argc, argv) != 0)
    return EXIT_FAILURE;
 
  setupFromEnv();
  readAliasesAndFunctions();
 
  status = EXIT_SUCCESS;
 
  for (int i = optind; i < argc; i++) {
    if (findPaths(argv[i]) != 0) {
      cout << argv[i] << " not found" << endl;
      status = EXIT_FAILURE;
    }
  }
 
  return status;
}