1// Copyright (c) 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/command_line.h"
6#include "base/files/file_util.h"
7#include "base/logging.h"
8#include "base/process/kill.h"
9#include "base/process/launch.h"
10#include "base/strings/string_number_conversions.h"
11#include "base/strings/utf_string_conversions.h"
12#include "base/time/time.h"
13#include "build/build_config.h"
14#include "tools/gn/err.h"
15#include "tools/gn/filesystem_utils.h"
16#include "tools/gn/functions.h"
17#include "tools/gn/input_conversion.h"
18#include "tools/gn/input_file.h"
19#include "tools/gn/parse_tree.h"
20#include "tools/gn/scheduler.h"
21#include "tools/gn/trace.h"
22#include "tools/gn/value.h"
23
24#if defined(OS_WIN)
25#include <windows.h>
26
27#include "base/win/scoped_handle.h"
28#include "base/win/scoped_process_information.h"
29#endif
30
31#if defined(OS_POSIX)
32#include <fcntl.h>
33#include <unistd.h>
34
35#include "base/posix/file_descriptor_shuffle.h"
36#endif
37
38namespace functions {
39
40namespace {
41
42const char kNoExecSwitch[] = "no-exec";
43
44#if defined(OS_WIN)
45bool ExecProcess(const CommandLine& cmdline,
46                 const base::FilePath& startup_dir,
47                 std::string* std_out,
48                 std::string* std_err,
49                 int* exit_code) {
50  SECURITY_ATTRIBUTES sa_attr;
51  // Set the bInheritHandle flag so pipe handles are inherited.
52  sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
53  sa_attr.bInheritHandle = TRUE;
54  sa_attr.lpSecurityDescriptor = NULL;
55
56  // Create the pipe for the child process's STDOUT.
57  HANDLE out_read = NULL;
58  HANDLE out_write = NULL;
59  if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
60    NOTREACHED() << "Failed to create pipe";
61    return false;
62  }
63  base::win::ScopedHandle scoped_out_read(out_read);
64  base::win::ScopedHandle scoped_out_write(out_write);
65
66  // Create the pipe for the child process's STDERR.
67  HANDLE err_read = NULL;
68  HANDLE err_write = NULL;
69  if (!CreatePipe(&err_read, &err_write, &sa_attr, 0)) {
70    NOTREACHED() << "Failed to create pipe";
71    return false;
72  }
73  base::win::ScopedHandle scoped_err_read(err_read);
74  base::win::ScopedHandle scoped_err_write(err_write);
75
76  // Ensure the read handle to the pipe for STDOUT/STDERR is not inherited.
77  if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
78    NOTREACHED() << "Failed to disabled pipe inheritance";
79    return false;
80  }
81  if (!SetHandleInformation(err_read, HANDLE_FLAG_INHERIT, 0)) {
82    NOTREACHED() << "Failed to disabled pipe inheritance";
83    return false;
84  }
85
86  base::FilePath::StringType cmdline_str(cmdline.GetCommandLineString());
87
88  STARTUPINFO start_info = {};
89
90  start_info.cb = sizeof(STARTUPINFO);
91  start_info.hStdOutput = out_write;
92  // Keep the normal stdin.
93  start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
94  // FIXME(brettw) set stderr here when we actually read it below.
95  //start_info.hStdError = err_write;
96  start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
97  start_info.dwFlags |= STARTF_USESTDHANDLES;
98
99  // Create the child process.
100  PROCESS_INFORMATION temp_process_info = {};
101  if (!CreateProcess(NULL,
102                     &cmdline_str[0],
103                     NULL, NULL,
104                     TRUE,  // Handles are inherited.
105                     0, NULL,
106                     startup_dir.value().c_str(),
107                     &start_info, &temp_process_info)) {
108    return false;
109  }
110  base::win::ScopedProcessInformation proc_info(temp_process_info);
111
112  // Close our writing end of pipes now. Otherwise later read would not be able
113  // to detect end of child's output.
114  scoped_out_write.Close();
115  scoped_err_write.Close();
116
117  // Read output from the child process's pipe for STDOUT
118  const int kBufferSize = 1024;
119  char buffer[kBufferSize];
120
121  // FIXME(brettw) read from stderr here! This is complicated because we want
122  // to read both of them at the same time, probably need overlapped I/O.
123  // Also uncomment start_info code above.
124  for (;;) {
125    DWORD bytes_read = 0;
126    BOOL success = ReadFile(out_read, buffer, kBufferSize, &bytes_read, NULL);
127    if (!success || bytes_read == 0)
128      break;
129    std_out->append(buffer, bytes_read);
130  }
131
132  // Let's wait for the process to finish.
133  WaitForSingleObject(proc_info.process_handle(), INFINITE);
134
135  DWORD dw_exit_code;
136  GetExitCodeProcess(proc_info.process_handle(), &dw_exit_code);
137  *exit_code = static_cast<int>(dw_exit_code);
138
139  return true;
140}
141#else
142bool ExecProcess(const CommandLine& cmdline,
143                 const base::FilePath& startup_dir,
144                 std::string* std_out,
145                 std::string* std_err,
146                 int* exit_code) {
147  *exit_code = EXIT_FAILURE;
148
149  std::vector<std::string> argv = cmdline.argv();
150
151  int pipe_fd[2];
152  pid_t pid;
153  base::InjectiveMultimap fd_shuffle1, fd_shuffle2;
154  scoped_ptr<char*[]> argv_cstr(new char*[argv.size() + 1]);
155
156  fd_shuffle1.reserve(3);
157  fd_shuffle2.reserve(3);
158
159  if (pipe(pipe_fd) < 0)
160    return false;
161
162  switch (pid = fork()) {
163    case -1:  // error
164      close(pipe_fd[0]);
165      close(pipe_fd[1]);
166      return false;
167    case 0:  // child
168      {
169        // DANGER: no calls to malloc are allowed from now on:
170        // http://crbug.com/36678
171
172        // Obscure fork() rule: in the child, if you don't end up doing exec*(),
173        // you call _exit() instead of exit(). This is because _exit() does not
174        // call any previously-registered (in the parent) exit handlers, which
175        // might do things like block waiting for threads that don't even exist
176        // in the child.
177        int dev_null = open("/dev/null", O_WRONLY);
178        if (dev_null < 0)
179          _exit(127);
180
181        fd_shuffle1.push_back(
182            base::InjectionArc(pipe_fd[1], STDOUT_FILENO, true));
183        fd_shuffle1.push_back(
184            base::InjectionArc(dev_null, STDERR_FILENO, true));
185        fd_shuffle1.push_back(
186            base::InjectionArc(dev_null, STDIN_FILENO, true));
187        // Adding another element here? Remeber to increase the argument to
188        // reserve(), above.
189
190        for (size_t i = 0; i < fd_shuffle1.size(); ++i)
191          fd_shuffle2.push_back(fd_shuffle1[i]);
192
193        if (!ShuffleFileDescriptors(&fd_shuffle1))
194          _exit(127);
195
196        base::SetCurrentDirectory(startup_dir);
197
198        // TODO(brettw) the base version GetAppOutput does a
199        // CloseSuperfluousFds call here. Do we need this?
200
201        for (size_t i = 0; i < argv.size(); i++)
202          argv_cstr[i] = const_cast<char*>(argv[i].c_str());
203        argv_cstr[argv.size()] = NULL;
204        execvp(argv_cstr[0], argv_cstr.get());
205        _exit(127);
206      }
207    default:  // parent
208      {
209        // Close our writing end of pipe now. Otherwise later read would not
210        // be able to detect end of child's output (in theory we could still
211        // write to the pipe).
212        close(pipe_fd[1]);
213
214        char buffer[256];
215        ssize_t bytes_read = 0;
216
217        while (true) {
218          bytes_read = HANDLE_EINTR(read(pipe_fd[0], buffer, sizeof(buffer)));
219          if (bytes_read <= 0)
220            break;
221          std_out->append(buffer, bytes_read);
222        }
223        close(pipe_fd[0]);
224
225        return base::WaitForExitCode(pid, exit_code);
226      }
227  }
228
229  return false;
230}
231#endif
232
233}  // namespace
234
235const char kExecScript[] = "exec_script";
236const char kExecScript_HelpShort[] =
237    "exec_script: Synchronously run a script and return the output.";
238const char kExecScript_Help[] =
239    "exec_script: Synchronously run a script and return the output.\n"
240    "\n"
241    "  exec_script(filename,\n"
242    "              arguments = [],\n"
243    "              input_conversion = \"\",\n"
244    "              file_dependencies = [])\n"
245    "\n"
246    "  Runs the given script, returning the stdout of the script. The build\n"
247    "  generation will fail if the script does not exist or returns a nonzero\n"
248    "  exit code.\n"
249    "\n"
250    "  The current directory when executing the script will be the root\n"
251    "  build directory. If you are passing file names, you will want to use\n"
252    "  the rebase_path() function to make file names relative to this\n"
253    "  path (see \"gn help rebase_path\").\n"
254    "\n"
255    "Arguments:\n"
256    "\n"
257    "  filename:\n"
258    "      File name of python script to execute. Non-absolute names will\n"
259    "      be treated as relative to the current build file.\n"
260    "\n"
261    "  arguments:\n"
262    "      A list of strings to be passed to the script as arguments.\n"
263    "      May be unspecified or the empty list which means no arguments.\n"
264    "\n"
265    "  input_conversion:\n"
266    "      Controls how the file is read and parsed.\n"
267    "      See \"gn help input_conversion\".\n"
268    "\n"
269    "      If unspecified, defaults to the empty string which causes the\n"
270    "      script result to be discarded. exec script will return None.\n"
271    "\n"
272    "  dependencies:\n"
273    "      (Optional) A list of files that this script reads or otherwise\n"
274    "      depends on. These dependencies will be added to the build result\n"
275    "      such that if any of them change, the build will be regenerated and\n"
276    "      the script will be re-run.\n"
277    "\n"
278    "      The script itself will be an implicit dependency so you do not\n"
279    "      need to list it.\n"
280    "\n"
281    "Example:\n"
282    "\n"
283    "  all_lines = exec_script(\n"
284    "      \"myscript.py\", [some_input], \"list lines\",\n"
285    "      [ rebase_path(\"data_file.txt\", root_build_dir) ])\n"
286    "\n"
287    "  # This example just calls the script with no arguments and discards\n"
288    "  # the result.\n"
289    "  exec_script(\"//foo/bar/myscript.py\")\n";
290
291Value RunExecScript(Scope* scope,
292                    const FunctionCallNode* function,
293                    const std::vector<Value>& args,
294                    Err* err) {
295  if (args.size() < 1 || args.size() > 4) {
296    *err = Err(function->function(), "Wrong number of arguments to exec_script",
297               "I expected between one and four arguments.");
298    return Value();
299  }
300
301  const Settings* settings = scope->settings();
302  const BuildSettings* build_settings = settings->build_settings();
303  const SourceDir& cur_dir = scope->GetSourceDir();
304
305  // Find the python script to run.
306  if (!args[0].VerifyTypeIs(Value::STRING, err))
307    return Value();
308  SourceFile script_source =
309      cur_dir.ResolveRelativeFile(args[0].string_value());
310  base::FilePath script_path = build_settings->GetFullPath(script_source);
311  if (!build_settings->secondary_source_path().empty() &&
312      !base::PathExists(script_path)) {
313    // Fall back to secondary source root when the file doesn't exist.
314    script_path = build_settings->GetFullPathSecondary(script_source);
315  }
316
317  ScopedTrace trace(TraceItem::TRACE_SCRIPT_EXECUTE, script_source.value());
318  trace.SetToolchain(settings->toolchain_label());
319
320  // Add all dependencies of this script, including the script itself, to the
321  // build deps.
322  g_scheduler->AddGenDependency(script_path);
323  if (args.size() == 4) {
324    const Value& deps_value = args[3];
325    if (!deps_value.VerifyTypeIs(Value::LIST, err))
326      return Value();
327
328    for (size_t i = 0; i < deps_value.list_value().size(); i++) {
329      if (!deps_value.list_value()[0].VerifyTypeIs(Value::STRING, err))
330        return Value();
331      g_scheduler->AddGenDependency(
332          build_settings->GetFullPath(cur_dir.ResolveRelativeFile(
333              deps_value.list_value()[0].string_value())));
334    }
335  }
336
337  // Make the command line.
338  const base::FilePath& python_path = build_settings->python_path();
339  CommandLine cmdline(python_path);
340  cmdline.AppendArgPath(script_path);
341
342  if (args.size() >= 2) {
343    // Optional command-line arguments to the script.
344    const Value& script_args = args[1];
345    if (!script_args.VerifyTypeIs(Value::LIST, err))
346      return Value();
347    for (size_t i = 0; i < script_args.list_value().size(); i++) {
348      if (!script_args.list_value()[i].VerifyTypeIs(Value::STRING, err))
349        return Value();
350      cmdline.AppendArg(script_args.list_value()[i].string_value());
351    }
352  }
353
354  // Log command line for debugging help.
355  trace.SetCommandLine(cmdline);
356  base::TimeTicks begin_exec;
357  if (g_scheduler->verbose_logging()) {
358#if defined(OS_WIN)
359    g_scheduler->Log("Pythoning",
360                     base::UTF16ToUTF8(cmdline.GetCommandLineString()));
361#else
362    g_scheduler->Log("Pythoning", cmdline.GetCommandLineString());
363#endif
364    begin_exec = base::TimeTicks::Now();
365  }
366
367  base::FilePath startup_dir =
368      build_settings->GetFullPath(build_settings->build_dir());
369  // The first time a build is run, no targets will have been written so the
370  // build output directory won't exist. We need to make sure it does before
371  // running any scripts with this as its startup directory, although it will
372  // be relatively rare that the directory won't exist by the time we get here.
373  //
374  // If this shows up on benchmarks, we can cache whether we've done this
375  // or not and skip creating the directory.
376  base::CreateDirectory(startup_dir);
377
378  // Execute the process.
379  // TODO(brettw) set the environment block.
380  std::string output;
381  std::string stderr_output;  // TODO(brettw) not hooked up, see above.
382  int exit_code = 0;
383  if (!CommandLine::ForCurrentProcess()->HasSwitch(kNoExecSwitch)) {
384    if (!ExecProcess(cmdline, startup_dir,
385                     &output, &stderr_output, &exit_code)) {
386      *err = Err(function->function(), "Could not execute python.",
387          "I was trying to execute \"" + FilePathToUTF8(python_path) + "\".");
388      return Value();
389    }
390  }
391  if (g_scheduler->verbose_logging()) {
392    g_scheduler->Log("Pythoning", script_source.value() + " took " +
393        base::Int64ToString(
394            (base::TimeTicks::Now() - begin_exec).InMilliseconds()) +
395        "ms");
396  }
397
398  // TODO(brettw) maybe we need stderr also for reasonable stack dumps.
399  if (exit_code != 0) {
400    std::string msg = "Current dir: " + FilePathToUTF8(startup_dir) +
401        "\nCommand: " + FilePathToUTF8(cmdline.GetCommandLineString()) +
402        "\nReturned " + base::IntToString(exit_code);
403    if (!output.empty())
404      msg += " and printed out:\n\n" + output;
405    else
406      msg += ".";
407    *err = Err(function->function(), "Script returned non-zero exit code.",
408               msg);
409    return Value();
410  }
411
412  // Default to None value for the input conversion if unspecified.
413  return ConvertInputToValue(scope->settings(), output, function,
414                             args.size() >= 3 ? args[2] : Value(), err);
415}
416
417}  // namespace functions
418