CommandLine.c

/*
htop - CommandLine.c
(C) 2004-2011 Hisham H. Muhammad
(C) 2020-2021 htop dev team
Released under the GNU GPLv2+, see the COPYING file
in the source distribution for its full text.
*/

#include "config.h" // IWYU pragma: keep

#include "CommandLine.h"

#include <assert.h>
#include <ctype.h>
#include <getopt.h>
#include <locale.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "Action.h"
#include "CRT.h"
#include "DynamicColumn.h"
#include "DynamicMeter.h"
#include "DynamicScreen.h"
#include "Hashtable.h"
#include "Header.h"
#include "IncSet.h"
#include "Machine.h"
#include "MainPanel.h"
#include "MetersPanel.h"
#include "Panel.h"
#include "Platform.h"
#include "Process.h"
#include "ProcessTable.h"
#include "ScreenManager.h"
#include "Settings.h"
#include "Table.h"
#include "UsersTable.h"
#include "XUtils.h"


static void printVersionFlag(const char* name) {
   printf("%s " VERSION "\n", name);
}

static void printHelpFlag(const char* name) {
   printf("%s " VERSION "\n"
          COPYRIGHT "\n"
          "Released under the GNU GPLv2+.\n\n"
          "-C --no-color                   Use a monochrome color scheme\n"
          "-d --delay=DELAY                Set the delay between updates, in tenths of seconds\n"
          "-F --filter=FILTER              Show only the commands matching the given filter\n"
          "-h --help                       Print this help screen\n"
          "-H --highlight-changes[=DELAY]  Highlight new and old processes\n", name);
#ifdef HAVE_GETMOUSE
   printf("-M --no-mouse                   Disable the mouse\n");
#endif
   printf("-n --max-iterations=NUMBER      Exit htop after NUMBER iterations/frame updates\n"
          "-p --pid=PID[,PID,PID...]       Show only the given PIDs\n"
          "   --readonly                   Disable all system and process changing features\n"
          "-s --sort-key=COLUMN            Sort by COLUMN in list view (try --sort-key=help for a list)\n"
          "-t --tree                       Show the tree view (can be combined with -s)\n"
          "-u --user[=USERNAME]            Show only processes for a given user (or $USER)\n"
          "-U --no-unicode                 Do not use unicode but plain ASCII\n"
          "-V --version                    Print version info\n");
   Platform_longOptionsUsage(name);
   printf("\n"
          "Press F1 inside %s for online help.\n"
          "See 'man %s' for more information.\n", name, name);
}

// ----------------------------------------

typedef struct CommandLineSettings_ {
   Hashtable* pidMatchList;
   char* commFilter;
   uid_t userId;
   int sortKey;
   int delay;
   int iterationsRemaining;
   bool useColors;
#ifdef HAVE_GETMOUSE
   bool enableMouse;
#endif
   bool treeView;
   bool allowUnicode;
   bool highlightChanges;
   int highlightDelaySecs;
   bool readonly;
} CommandLineSettings;

static CommandLineStatus parseArguments(int argc, char** argv, CommandLineSettings* flags) {

   *flags = (CommandLineSettings) {
      .pidMatchList = NULL,
      .commFilter = NULL,
      .userId = (uid_t)-1, // -1 is guaranteed to be an invalid uid_t (see setreuid(2))
      .sortKey = 0,
      .delay = -1,
      .iterationsRemaining = -1,
      .useColors = true,
#ifdef HAVE_GETMOUSE
      .enableMouse = true,
#endif
      .treeView = false,
      .allowUnicode = true,
      .highlightChanges = false,
      .highlightDelaySecs = -1,
      .readonly = false,
   };

   const struct option long_opts[] =
   {
      {"help",       no_argument,         0, 'h'},
      {"version",    no_argument,         0, 'V'},
      {"delay",      required_argument,   0, 'd'},
      {"max-iterations", required_argument, 0, 'n'},
      {"sort-key",   required_argument,   0, 's'},
      {"user",       optional_argument,   0, 'u'},
      {"no-color",   no_argument,         0, 'C'},
      {"no-colour",  no_argument,         0, 'C'},
      {"no-mouse",   no_argument,         0, 'M'},
      {"no-unicode", no_argument,         0, 'U'},
      {"tree",       no_argument,         0, 't'},
      {"pid",        required_argument,   0, 'p'},
      {"filter",     required_argument,   0, 'F'},
      {"highlight-changes", optional_argument, 0, 'H'},
      {"readonly",   no_argument,         0, 128},
      PLATFORM_LONG_OPTIONS
      {0, 0, 0, 0}
   };

   int opt, opti = 0;
   /* Parse arguments */
   while ((opt = getopt_long(argc, argv, "hVMCs:td:n:u::Up:F:H::", long_opts, &opti))) {
      if (opt == EOF)
         break;

      switch (opt) {
         case 'h':
            printHelpFlag(program);
            return STATUS_OK_EXIT;
         case 'V':
            printVersionFlag(program);
            return STATUS_OK_EXIT;
         case 's':
            assert(optarg); /* please clang analyzer, cause optarg can be NULL in the 'u' case */
            if (String_eq(optarg, "help")) {
               for (int j = 1; j < LAST_PROCESSFIELD; j++) {
                  const char* name = Process_fields[j].name;
                  const char* description = Process_fields[j].description;
                  if (name)
                     printf("%19s %s\n", name, description);
               }
               return STATUS_OK_EXIT;
            }
            flags->sortKey = 0;
            for (int j = 1; j < LAST_PROCESSFIELD; j++) {
               if (Process_fields[j].name == NULL)
                  continue;
               if (String_eq(optarg, Process_fields[j].name)) {
                  flags->sortKey = j;
                  break;
               }
            }
            if (flags->sortKey == 0) {
               fprintf(stderr, "Error: invalid column \"%s\".\n", optarg);
               return STATUS_ERROR_EXIT;
            }
            break;
         case 'd':
            if (sscanf(optarg, "%16d", &(flags->delay)) == 1) {
               if (flags->delay < 1)
                  flags->delay = 1;
               if (flags->delay > 100)
                  flags->delay = 100;
            } else {
               fprintf(stderr, "Error: invalid delay value \"%s\".\n", optarg);
               return STATUS_ERROR_EXIT;
            }
            break;
         case 'n':
            if (sscanf(optarg, "%16d", &flags->iterationsRemaining) == 1) {
               if (flags->iterationsRemaining <= 0) {
                  fprintf(stderr, "Error: maximum iteration count must be positive.\n");
                  return STATUS_ERROR_EXIT;
               }
            } else {
               fprintf(stderr, "Error: invalid maximum iteration count \"%s\".\n", optarg);
               return STATUS_ERROR_EXIT;
            }
            break;
         case 'u': {
            const char* username = optarg;
            if (!username && optind < argc && argv[optind] != NULL &&
                (argv[optind][0] != '\0' && argv[optind][0] != '-')) {
               username = argv[optind++];
            }

            if (!username) {
               flags->userId = geteuid();
            } else if (!Action_setUserOnly(username, &(flags->userId))) {
               for (const char* itr = username; *itr; ++itr)
                  if (!isdigit((unsigned char)*itr)) {
                     fprintf(stderr, "Error: invalid user \"%s\".\n", username);
                     return STATUS_ERROR_EXIT;
                  }
               flags->userId = atol(username);
            }
            break;
         }
         case 'C':
            flags->useColors = false;
            break;
         case 'M':
#ifdef HAVE_GETMOUSE
            flags->enableMouse = false;
#endif
            break;
         case 'U':
            flags->allowUnicode = false;
            break;
         case 't':
            flags->treeView = true;
            break;
         case 'p': {
            assert(optarg); /* please clang analyzer, cause optarg can be NULL in the 'u' case */
            char* argCopy = xStrdup(optarg);
            char* saveptr;
            const char* pid = strtok_r(argCopy, ",", &saveptr);

            if (!flags->pidMatchList) {
               flags->pidMatchList = Hashtable_new(8, false);
            }

            while (pid) {
               unsigned int num_pid = atoi(pid);
               //  deepcode ignore CastIntegerToAddress: we just want a non-NULL pointer here
               Hashtable_put(flags->pidMatchList, num_pid, (void*) 1);
               pid = strtok_r(NULL, ",", &saveptr);
            }
            free(argCopy);

            break;
         }
         case 'F':
            assert(optarg);
            free_and_xStrdup(&flags->commFilter, optarg);
            break;
         case 'H': {
            const char* delay = optarg;
            if (!delay && optind < argc && argv[optind] != NULL &&
                (argv[optind][0] != '\0' && argv[optind][0] != '-')) {
               delay = argv[optind++];
            }
            if (delay) {
               if (sscanf(delay, "%16d", &(flags->highlightDelaySecs)) == 1) {
                  if (flags->highlightDelaySecs < 1)
                     flags->highlightDelaySecs = 1;
               } else {
                  fprintf(stderr, "Error: invalid highlight delay value \"%s\".\n", delay);
                  return STATUS_ERROR_EXIT;
               }
            }
            flags->highlightChanges = true;
            break;
         }
         case 128:
            flags->readonly = true;
            break;

         default: {
            CommandLineStatus status;
            if ((status = Platform_getLongOption(opt, argc, argv)) != STATUS_OK)
               return status;
            break;
         }
      }
   }

   if (optind < argc) {
      fprintf(stderr, "Error: unsupported non-option ARGV-elements:");
      while (optind < argc)
         fprintf(stderr, " %s", argv[optind++]);
      fprintf(stderr, "\n");
      return STATUS_ERROR_EXIT;
   }

   return STATUS_OK;
}

static void CommandLine_delay(Machine* host, unsigned long millisec) {
   struct timespec req = {
      .tv_sec = 0,
      .tv_nsec = millisec * 1000000L
   };
   while (nanosleep(&req, &req) == -1)
      continue;
   Platform_gettime_realtime(&host->realtime, &host->realtimeMs);
}

static void setCommFilter(State* state, char** commFilter) {
   Table* table = state->host->activeTable;
   IncSet* inc = state->mainPanel->inc;

   IncSet_setFilter(inc, *commFilter);
   table->incFilter = IncSet_filter(inc);

   free(*commFilter);
   *commFilter = NULL;
}

int CommandLine_run(int argc, char** argv) {

   /* initialize locale */
   const char* lc_ctype;
   if ((lc_ctype = getenv("LC_CTYPE")) || (lc_ctype = getenv("LC_ALL")))
      setlocale(LC_CTYPE, lc_ctype);
   else
      setlocale(LC_CTYPE, "");

   CommandLineStatus status = STATUS_OK;
   CommandLineSettings flags = { 0 };

   if ((status = parseArguments(argc, argv, &flags)) != STATUS_OK)
      return status != STATUS_OK_EXIT ? 1 : 0;

   if (flags.readonly)
      Settings_enableReadonly();

   if (!Platform_init())
      return 1;

   UsersTable* ut = UsersTable_new();
   Hashtable* dm = DynamicMeters_new();
   Hashtable* dc = DynamicColumns_new();
   Hashtable* ds = DynamicScreens_new();

   Machine* host = Machine_new(ut, flags.userId);
   ProcessTable* pt = ProcessTable_new(host, flags.pidMatchList);
   Settings* settings = Settings_new(host, dm, dc, ds);
   Machine_populateTablesFromSettings(host, settings, &pt->super);

   Header* header = Header_new(host, 2);
   Header_populateFromSettings(header);

   if (flags.delay != -1)
      settings->delay = flags.delay;
   if (!flags.useColors)
      settings->colorScheme = COLORSCHEME_MONOCHROME;
#ifdef HAVE_GETMOUSE
   if (!flags.enableMouse)
      settings->enableMouse = false;
#endif
   if (flags.treeView)
      settings->ss->treeView = true;
   if (flags.highlightChanges)
      settings->highlightChanges = true;
   if (flags.highlightDelaySecs != -1)
      settings->highlightDelaySecs = flags.highlightDelaySecs;
   if (flags.sortKey > 0) {
      // -t -s <key> means "tree sorted by key"
      // -s <key> means "list sorted by key" (previous existing behavior)
      if (!flags.treeView) {
         settings->ss->treeView = false;
      }
      ScreenSettings_setSortKey(settings->ss, flags.sortKey);
   }

   host->iterationsRemaining = flags.iterationsRemaining;
   CRT_init(settings, flags.allowUnicode, flags.iterationsRemaining != -1);

   MainPanel* panel = MainPanel_new();
   Machine_setTablesPanel(host, (Panel*) panel);

   MainPanel_updateLabels(panel, settings->ss->treeView, flags.commFilter);

   State state = {
      .host = host,
      .mainPanel = panel,
      .header = header,
      .pauseUpdate = false,
      .hideSelection = false,
      .hideMeters = false,
   };

   MainPanel_setState(panel, &state);
   if (flags.commFilter)
      setCommFilter(&state, &(flags.commFilter));

   ScreenManager* scr = ScreenManager_new(header, host, &state, true);
   ScreenManager_add(scr, (Panel*) panel, -1);

   Machine_scan(host);
   Machine_scanTables(host);
   CommandLine_delay(host, 75);
   Machine_scan(host);
   Machine_scanTables(host);

   if (settings->ss->allBranchesCollapsed)
      Table_collapseAllBranches(&pt->super);

   ScreenManager_run(scr, NULL, NULL, NULL);

   Platform_done();

   CRT_done();

   if (settings->changed) {
#ifndef NDEBUG
      if (!String_eq(settings->initialFilename, settings->filename))
         fprintf(stderr, "Configuration %s was resolved to %s\n", settings->initialFilename, settings->filename);
#endif /* NDEBUG */
      int r = Settings_write(settings, false);
      if (r < 0)
         fprintf(stderr, "Can not save configuration to %s: %s\n", settings->filename, strerror(-r));
   }

   Header_delete(header);
   Machine_delete(host);

   ScreenManager_delete(scr);
   MetersPanel_cleanup();

   UsersTable_delete(ut);

   if (flags.pidMatchList)
      Hashtable_delete(flags.pidMatchList);

   CRT_resetSignalHandlers();

   /* Delete these last, since they can get accessed in the crash handler */
   Settings_delete(settings);
   DynamicColumns_delete(dc);
   DynamicMeters_delete(dm);
   DynamicScreens_delete(ds);

   return 0;
}