pintos-os.org Git - pspp/blob - src/language/utilities/host.c

   1 /* pspp - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2009, 2010, 2011 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include <ctype.h>
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <signal.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <sys/time.h>
  26 #include <unistd.h>
  27 #if HAVE_SYS_WAIT_H
  28 #include <sys/wait.h>
  29 #endif
  30
  31 #include "data/settings.h"
  32 #include "language/command.h"
  33 #include "language/lexer/lexer.h"
  34 #include "libpspp/assertion.h"
  35 #include "libpspp/compiler.h"
  36 #include "libpspp/i18n.h"
  37 #include "libpspp/message.h"
  38 #include "libpspp/str.h"
  39 #include "libpspp/string-array.h"
  40 #include "libpspp/temp-file.h"
  41 #include "output/text-item.h"
  42
  43 #include "gl/error.h"
  44 #include "gl/intprops.h"
  45 #include "gl/localcharset.h"
  46 #include "gl/read-file.h"
  47 #include "gl/timespec.h"
  48 #include "gl/xalloc.h"
  49 #include "gl/xmalloca.h"
  50
  51 #include "gettext.h"
  52 #define _(msgid) gettext (msgid)
  53 #define N_(msgid) msgid
  54 \f
  55 #if !HAVE_FORK
  56 static bool
  57 run_commands (const struct string_array *commands, double time_limit)
  58 {
  59   if (time_limit != DBL_MAX)
  60     {
  61       msg (SE, _("Time limit not supported on this platform."));
  62       return false;
  63     }
  64
  65   for (size_t i = 0; i < commands->n; i++)
  66     {
  67       /* XXX No way to capture command output */
  68       char *s = recode_string (locale_charset (), "UTF-8",
  69                                commands->strings[i], -1);
  70       int retval = system (s);
  71       free (s);
  72
  73       if (retval)
  74         {
  75           msg (SE, _("%s: Command exited with status %d."),
  76                commands->strings[i], retval);
  77           return false;
  78         }
  79     }
  80   return true;
  81 }
  82 #else
  83 static bool
  84 run_command (const char *command, struct timespec timeout)
  85 {
  86   /* Same exit codes used by 'sh'. */
  87   enum {
  88     EXIT_CANNOT_INVOKE = 126,
  89     EXIT_ENOENT = 127,
  90   };
  91
  92   /* Create a temporary file to capture command output. */
  93   FILE *output_file = create_temp_file ();
  94   if (!output_file)
  95     {
  96       msg (SE, _("Failed to create temporary file (%s)."), strerror (errno));
  97       return false;
  98     }
  99
 100   int dev_null_fd = open ("/dev/null", O_RDONLY);
 101   if (dev_null_fd < 0)
 102     {
 103       msg (SE, _("/dev/null: Failed to open (%s)."), strerror (errno));
 104       fclose (output_file);
 105       return false;
 106     }
 107
 108   char *locale_command = recode_string (locale_charset (), "UTF-8",
 109                                         command, -1);
 110
 111   pid_t pid = fork ();
 112   if (pid < 0)
 113     {
 114       close (dev_null_fd);
 115       fclose (output_file);
 116       free (locale_command);
 117
 118       msg (SE, _("Couldn't fork: %s."), strerror (errno));
 119       return false;
 120     }
 121   else if (!pid)
 122     {
 123       /* Running in the child. */
 124
 125       /* Set up timeout. */
 126       if (timeout.tv_sec < TYPE_MAXIMUM (time_t))
 127         {
 128           signal (SIGALRM, SIG_DFL);
 129
 130           struct timespec left = timespec_sub (timeout, current_timespec ());
 131           if (timespec_sign (left) <= 0)
 132             raise (SIGALRM);
 133
 134           struct itimerval it = {
 135             .it_value = {
 136               .tv_sec = left.tv_sec,
 137               .tv_usec = left.tv_nsec / 1000
 138             }
 139           };
 140           if (setitimer (ITIMER_REAL, &it, NULL) < 0)
 141             error (1, errno, _("Failed to set timeout."));
 142         }
 143
 144       /* Set up file descriptors:
 145          - /dev/null for stdin
 146          - Temporary file to capture stdout and stderr.
 147          - Close everything else.
 148       */
 149       dup2 (dev_null_fd, 0);
 150       dup2 (fileno (output_file), 1);
 151       dup2 (fileno (output_file), 2);
 152       close (dev_null_fd);
 153       for (int fd = 3; fd < 256; fd++)
 154         close (fd);
 155
 156       /* Choose the shell. */
 157       const char *shell = getenv ("SHELL");
 158       if (shell == NULL)
 159         shell = "/bin/sh";
 160
 161       /* Run subprocess. */
 162       execl (shell, shell, "-c", locale_command, NULL);
 163
 164       /* Failed to start the shell. */
 165       _exit (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 166     }
 167
 168   /* Running in the parent. */
 169   close (dev_null_fd);
 170   free (locale_command);
 171
 172   /* Wait for child to exit. */
 173   int status = 0;
 174   int error = 0;
 175   for (;;)
 176     {
 177       pid_t retval = waitpid (pid, &status, 0);
 178       if (retval == pid)
 179         break;
 180       else if (retval < 0)
 181         {
 182           if (errno != EINTR)
 183             {
 184               error = errno;
 185               break;
 186             }
 187         }
 188       else
 189         NOT_REACHED ();
 190     }
 191
 192   bool ok = true;
 193   if (error)
 194     {
 195       msg (SW, _("While running \"%s\", waiting for child process "
 196                  "failed (%s)."),
 197            command, strerror (errno));
 198       ok = false;
 199     }
 200
 201   if (WIFSIGNALED (status))
 202     {
 203       int signum = WTERMSIG (status);
 204       if (signum == SIGALRM)
 205         msg (SW, _("Command \"%s\" timed out."), command);
 206       else
 207         msg (SW, _("Command \"%s\" terminated by signal %d."), command, signum);
 208       ok = false;
 209     }
 210   else if (WIFEXITED (status) && WEXITSTATUS (status))
 211     {
 212       int exit_code = WEXITSTATUS (status);
 213       const char *detail = (exit_code == EXIT_ENOENT
 214                             ? _("Command or shell not found")
 215                             : exit_code == EXIT_CANNOT_INVOKE
 216                             ? _("Could not invoke command or shell")
 217                             : NULL);
 218       if (detail)
 219         msg (SW, _("Command \"%s\" exited with status %d (%s)."),
 220              command, exit_code, detail);
 221       else
 222         msg (SW, _("Command \"%s\" exited with status %d."),
 223              command, exit_code);
 224       ok = false;
 225     }
 226
 227   rewind (output_file);
 228   size_t length;
 229   char *locale_output = fread_file (output_file, 0, &length);
 230   if (!locale_output)
 231     {
 232       msg (SW, _("Command \"%s\" output could not be read (%s)."),
 233            command, strerror (errno));
 234       ok = false;
 235     }
 236   else if (length > 0)
 237     {
 238       char *output = recode_string ("UTF-8", locale_charset (),
 239                                     locale_output, -1);
 240
 241       /* Drop final new-line, if any. */
 242       char *end = strchr (output, '\0');
 243       if (end > output && end[-1] == '\n')
 244         end[-1] = '\0';
 245
 246       text_item_submit (text_item_create_nocopy (TEXT_ITEM_LOG, output));
 247     }
 248   free (locale_output);
 249
 250   return ok;
 251 }
 252
 253 static bool
 254 run_commands (const struct string_array *commands, double time_limit)
 255 {
 256   struct timespec timeout = timespec_add (dtotimespec (time_limit),
 257                                           current_timespec ());
 258
 259   for (size_t i = 0; i < commands->n; i++)
 260     {
 261       if (!run_command (commands->strings[i], timeout))
 262         return false;
 263     }
 264
 265   return true;
 266 }
 267 #endif
 268
 269 int
 270 cmd_host (struct lexer *lexer, struct dataset *ds UNUSED)
 271 {
 272   if (settings_get_safer_mode ())
 273     {
 274       msg (SE, _("This command not allowed when the %s option is set."), "SAFER");
 275       return CMD_FAILURE;
 276     }
 277
 278   if (!lex_force_match_id (lexer, "COMMAND")
 279       || !lex_force_match (lexer, T_EQUALS)
 280       || !lex_force_match (lexer, T_LBRACK)
 281       || !lex_force_string (lexer))
 282     return CMD_FAILURE;
 283
 284   struct string_array commands = STRING_ARRAY_INITIALIZER;
 285   while (lex_token (lexer) == T_STRING)
 286     {
 287       string_array_append (&commands, lex_tokcstr (lexer));
 288       lex_get (lexer);
 289     }
 290   if (!lex_force_match (lexer, T_RBRACK))
 291     {
 292       string_array_destroy (&commands);
 293       return CMD_FAILURE;
 294     }
 295
 296   double time_limit = DBL_MAX;
 297   if (lex_match_id (lexer, "TIMELIMIT"))
 298     {
 299       if (!lex_force_match (lexer, T_EQUALS)
 300           || !lex_force_num (lexer))
 301         {
 302           string_array_destroy (&commands);
 303           return CMD_FAILURE;
 304         }
 305
 306       double num = lex_number (lexer);
 307       lex_get (lexer);
 308       time_limit = num < 0.0 ? 0.0 : num;
 309     }
 310
 311   enum cmd_result result = lex_end_of_command (lexer);
 312   if (result == CMD_SUCCESS && !run_commands (&commands, time_limit))
 313     result = CMD_FAILURE;
 314   string_array_destroy (&commands);
 315   return result;
 316 }