X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Fcmdline.cc;h=cbe8ff9a53ea70754cf7c8aa6f98c3a666c68576;hb=50532bea9eb770554e1e962d03b868987303acbe;hp=cad294671f22fca0310cf0f1dd507480fde9098c;hpb=675ac17fddca229e391d80eb610959d9c53db6e5;p=awesomized%2Flibmemcached diff --git a/libtest/cmdline.cc b/libtest/cmdline.cc index cad29467..cbe8ff9a 100644 --- a/libtest/cmdline.cc +++ b/libtest/cmdline.cc @@ -1,26 +1,42 @@ /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * libtest * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Data Differential YATL (i.e. libtest) library * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. + * Copyright (C) 2012-2013 Data Differential, http://datadifferential.com/ * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include -#include +#include "libtest/yatlcon.h" + +#include "libtest/common.h" using namespace libtest; @@ -30,73 +46,77 @@ using namespace libtest; #include #include #include -#include -#include +#ifdef HAVE_POLL_H +# include +#endif +#ifdef HAVE_SPAWN_H +# include +#endif #include #include #include #include +#include -extern "C" { - static int exited_successfully(int status) - { - if (status == 0) - { - return EXIT_SUCCESS; - } +#include +#include - if (WIFEXITED(status) == true) - { - return WEXITSTATUS(status); - } - else if (WIFSIGNALED(status) == true) - { - return WTERMSIG(status); - } +#ifndef __USE_GNU +static char **environ= NULL; +#endif - return EXIT_FAILURE; - } -} +#ifndef FD_CLOEXEC +# define FD_CLOEXEC 0 +#endif namespace { - std::string print_argv(char * * & built_argv, const size_t& argc) + std::string print_argv(libtest::vchar_ptr_t& built_argv) { std::stringstream arg_buffer; - for (size_t x= 0; x < argc; x++) + for (vchar_ptr_t::iterator iter= built_argv.begin(); + iter != built_argv.end(); + ++iter) { - arg_buffer << built_argv[x] << " "; + if (*iter) + { + arg_buffer << *iter << " "; + } } return arg_buffer.str(); } +#if 0 std::string print_argv(char** argv) { std::stringstream arg_buffer; - for (char** ptr= argv; *ptr; ptr++) + for (char** ptr= argv; *ptr; ++ptr) { arg_buffer << *ptr << " "; } return arg_buffer.str(); } +#endif static Application::error_t int_to_error_t(int arg) { switch (arg) { case 127: - return Application::INVALID; + return Application::INVALID_POSIX_SPAWN; case 0: return Application::SUCCESS; - default: case 1: return Application::FAILURE; + + default: + return Application::UNKNOWN; } } } @@ -107,16 +127,22 @@ Application::Application(const std::string& arg, const bool _use_libtool_arg) : _use_libtool(_use_libtool_arg), _use_valgrind(false), _use_gdb(false), + _use_ptrcheck(false), + _will_fail(false), _argc(0), _exectuble(arg), - built_argv(NULL), - _pid(-1) + stdin_fd(STDIN_FILENO), + stdout_fd(STDOUT_FILENO), + stderr_fd(STDERR_FILENO), + _pid(-1), + _status(0), + _app_exit_state(UNINITIALIZED) { if (_use_libtool) { if (libtool() == NULL) { - throw fatal_message("libtool requested, but know libtool was found"); + FATAL("libtool requested, but know libtool was found"); } } @@ -158,9 +184,32 @@ Application::error_t Application::run(const char *args[]) posix_spawn_file_actions_t file_actions; posix_spawn_file_actions_init(&file_actions); - stdin_fd.dup_for_spawn(Application::Pipe::READ, file_actions, STDIN_FILENO); - stdout_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions, STDOUT_FILENO); - stderr_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions, STDERR_FILENO); + stdin_fd.dup_for_spawn(file_actions); + stdout_fd.dup_for_spawn(file_actions); + stderr_fd.dup_for_spawn(file_actions); + + posix_spawnattr_t spawnattr; + posix_spawnattr_init(&spawnattr); + + short flags= 0; + + // Child should not block signals + flags |= POSIX_SPAWN_SETSIGMASK; + + sigset_t mask; + sigemptyset(&mask); + + fatal_assert(posix_spawnattr_setsigmask(&spawnattr, &mask) == 0); + +#if defined(POSIX_SPAWN_USEVFORK) || defined(__linux__) + // Use USEVFORK on linux + flags |= POSIX_SPAWN_USEVFORK; +#endif + + flags |= POSIX_SPAWN_SETPGROUP; + fatal_assert(posix_spawnattr_setpgroup(&spawnattr, 0) == 0); + + fatal_assert(posix_spawnattr_setflags(&spawnattr, flags) == 0); create_argv(args); @@ -199,7 +248,7 @@ Application::error_t Application::run(const char *args[]) const_cast(_exectuble_with_path.c_str()), 0}; - spawn_ret= posix_spawnp(&_pid, libtool(), &file_actions, NULL, argv, NULL); + spawn_ret= posix_spawnp(&_pid, libtool(), &file_actions, &spawnattr, argv, environ); } else { @@ -212,40 +261,53 @@ Application::error_t Application::run(const char *args[]) const_cast(gdb_run_file.c_str()), const_cast(_exectuble_with_path.c_str()), 0}; - spawn_ret= posix_spawnp(&_pid, "gdb", &file_actions, NULL, argv, NULL); + spawn_ret= posix_spawnp(&_pid, "gdb", &file_actions, &spawnattr, argv, environ); } } else { - if (_use_libtool) - { - spawn_ret= posix_spawn(&_pid, built_argv[0], &file_actions, NULL, built_argv, NULL); - } - else - { - spawn_ret= posix_spawnp(&_pid, built_argv[0], &file_actions, NULL, built_argv, NULL); - } + spawn_ret= posix_spawn(&_pid, built_argv[0], &file_actions, &spawnattr, &built_argv[0], NULL); } posix_spawn_file_actions_destroy(&file_actions); + posix_spawnattr_destroy(&spawnattr); stdin_fd.close(Application::Pipe::READ); stdout_fd.close(Application::Pipe::WRITE); stderr_fd.close(Application::Pipe::WRITE); - if (spawn_ret) + if (spawn_ret != 0) { + if (_will_fail == false) + { + Error << strerror(spawn_ret) << "(" << spawn_ret << ")"; + } _pid= -1; - return Application::INVALID; + return Application::INVALID_POSIX_SPAWN; } + assert(_pid != -1); + if (_pid == -1) + { + return Application::INVALID_POSIX_SPAWN; + } + +#if 0 + app_thread_st* _app_thread= new app_thread_st(_pid, _status, built_argv[0], _app_exit_state); + int error; + if ((error= pthread_create(&_thread, NULL, &app_thread, _app_thread)) != 0) + { + Error << "pthread_create() died during pthread_create(" << strerror(error) << ")"; + return Application::FAILURE; + } +#endif + return Application::SUCCESS; } bool Application::check() const { - Error << "Testing " << _exectuble; - if (kill(_pid, 0) == 0) + if (_pid > 1 and kill(_pid, 0) == 0) { return true; } @@ -255,28 +317,52 @@ bool Application::check() const void Application::murder() { + if (check()) + { + int count= 5; + while ((count--) > 0 and check()) + { + if (kill(_pid, SIGTERM) == 0) + { + join(); + } + else + { + Error << "kill(pid, SIGTERM) failed after kill with error of " << strerror(errno); + continue; + } + + break; + } + + // If for whatever reason it lives, kill it hard + if (check()) + { + Error << "using SIGKILL, things will likely go poorly from this point"; + (void)kill(_pid, SIGKILL); + } + } slurp(); - kill(_pid, SIGTERM); } // false means that no data was returned bool Application::slurp() { struct pollfd fds[2]; - fds[0].fd= stdout_fd.fd()[0]; - fds[0].events= POLLIN; + fds[0].fd= stdout_fd.fd(); + fds[0].events= POLLRDNORM; fds[0].revents= 0; - fds[1].fd= stderr_fd.fd()[0]; - fds[1].events= POLLIN; + fds[1].fd= stderr_fd.fd(); + fds[1].events= POLLRDNORM; fds[1].revents= 0; int active_fd; - if ((active_fd= poll(fds, 2, 400)) == -1) + if ((active_fd= poll(fds, 2, 0)) == -1) { int error; switch ((error= errno)) { -#ifdef TARGET_OS_LINUX +#ifdef __linux case ERESTART: #endif case EINTR: @@ -284,17 +370,19 @@ bool Application::slurp() case EFAULT: case ENOMEM: - fatal_message(strerror(error)); + FATAL(strerror(error)); break; case EINVAL: - fatal_message("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"); + FATAL("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"); break; default: - fatal_message(strerror(error)); + FATAL(strerror(error)); break; } + + return false; } if (active_fd == 0) @@ -303,120 +391,122 @@ bool Application::slurp() } bool data_was_read= false; - if (fds[0].revents & POLLIN) + if (fds[0].revents & POLLRDNORM) { - ssize_t read_length; - char buffer[1024]= { 0 }; - while ((read_length= ::read(stdout_fd.fd()[0], buffer, sizeof(buffer)))) + if (stdout_fd.read(_stdout_buffer) == true) { - if (read_length == -1) - { - switch(errno) - { - case EAGAIN: - continue; - - default: - Error << strerror(errno); - break; - } - - break; - } - data_was_read= true; - _stdout_buffer.reserve(read_length +1); - for (size_t x= 0; x < read_length; x++) - { - _stdout_buffer.push_back(buffer[x]); - } - // @todo Suck up all output code here } } - if (fds[1].revents & POLLIN) + if (fds[1].revents & POLLRDNORM) { - stderr_fd.nonblock(); - - ssize_t read_length; - char buffer[1024]= { 0 }; - while ((read_length= ::read(stderr_fd.fd()[0], buffer, sizeof(buffer)))) + if (stderr_fd.read(_stderr_buffer) == true) { - if (read_length == -1) - { - switch(errno) - { - case EAGAIN: - continue; - - default: - Error << strerror(errno); - break; - } - - break; - } - data_was_read= true; - _stderr_buffer.reserve(read_length +1); - for (size_t x= 0; x < read_length; x++) - { - _stderr_buffer.push_back(buffer[x]); - } - // @todo Suck up all errput code here } } return data_was_read; } -Application::error_t Application::wait(bool nohang) +Application::error_t Application::join() { - if (_pid == -1) - { - return Application::INVALID; - } - + pid_t waited_pid= waitpid(_pid, &_status, WUNTRACED); slurp(); - - error_t exit_code= FAILURE; + if (waited_pid == _pid and WIFEXITED(_status) == false) { - int status= 0; - pid_t waited_pid; - if ((waited_pid= waitpid(_pid, &status, nohang ? WNOHANG : 0)) == -1) + /* + What we are looking for here is how the exit status happened. + - 127 means that posix_spawn() itself had an error. + - If WEXITSTATUS is positive we need to see if it is a signal that we sent to kill the process. If not something bad happened in the process itself. + - Finally something has happened that we don't currently understand. + */ + if (WEXITSTATUS(_status) == 127) { - switch (errno) + _app_exit_state= Application::INVALID_POSIX_SPAWN; + std::string error_string("posix_spawn() failed pid:"); + error_string+= _pid; + error_string+= " name:"; + error_string+= print_argv(built_argv); + if (stderr_result_length()) { - case ECHILD: - exit_code= Application::SUCCESS; - break; - - default: - Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid); + error_string+= " stderr: "; + error_string+= stderr_c_str(); } + throw std::logic_error(error_string); } - else if (waited_pid == 0) + else if (WIFSIGNALED(_status)) { - exit_code= Application::SUCCESS; + if (WTERMSIG(_status) != SIGTERM and WTERMSIG(_status) != SIGHUP) + { + slurp(); + _app_exit_state= Application::INVALID_POSIX_SPAWN; + std::string error_string(print_argv(built_argv)); + error_string+= " was killed by signal "; + error_string+= strsignal(WTERMSIG(_status)); + + if (stdout_result_length()) + { + error_string+= " stdout: "; + error_string+= stdout_c_str(); + } + + if (stderr_result_length()) + { + error_string+= " stderr: "; + error_string+= stderr_c_str(); + } + + throw std::runtime_error(error_string); + } + + // If we terminted it on purpose then it counts as a success. +#if defined(DEBUG) + if (DEBUG) + { + Out << "waitpid() application terminated at request" + << " pid:" << _pid + << " name:" << built_argv[0]; + } +#endif } else { - if (waited_pid != _pid) - { - throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Pid mismatch, %d != %d", int(waited_pid), int(_pid)); - } - exit_code= int_to_error_t(exited_successfully(status)); + _app_exit_state= Application::UNKNOWN; + Error << "Unknown logic state at exit:" << WEXITSTATUS(_status) + << " pid:" << _pid + << " name:" << built_argv[0]; } } + else if (waited_pid == _pid and WIFEXITED(_status)) + { + _app_exit_state= int_to_error_t(WEXITSTATUS(_status)); + } + else if (waited_pid == -1) + { + std::string error_string; + if (stdout_result_length()) + { + error_string+= " stdout: "; + error_string+= stdout_c_str(); + } -#if 0 - if (exit_code == Application::INVALID) + if (stderr_result_length()) + { + error_string+= " stderr: "; + error_string+= stderr_c_str(); + } + Error << "waitpid() returned errno:" << strerror(errno) << " " << error_string; + _app_exit_state= Application::UNKNOWN; + } + else { - Error << print_argv(built_argv, _argc); + _app_exit_state= Application::UNKNOWN; + throw std::logic_error("waitpid() returned an unknown value"); } -#endif - return exit_code; + return _app_exit_state; } void Application::add_long_option(const std::string& name, const std::string& option_value) @@ -436,24 +526,89 @@ void Application::add_option(const std::string& name, const std::string& value) _options.push_back(std::make_pair(name, value)); } -Application::Pipe::Pipe() +Application::Pipe::Pipe(int arg) : + _std_fd(arg) { - _fd[0]= -1; - _fd[1]= -1; - _open[0]= false; - _open[1]= false; + _pipe_fd[READ]= -1; + _pipe_fd[WRITE]= -1; + _open[READ]= false; + _open[WRITE]= false; +} + +int Application::Pipe::Pipe::fd() +{ + if (_std_fd == STDOUT_FILENO) + { + return _pipe_fd[READ]; + } + else if (_std_fd == STDERR_FILENO) + { + return _pipe_fd[READ]; + } + + return _pipe_fd[WRITE]; // STDIN_FILENO +} + + +bool Application::Pipe::read(libtest::vchar_t& arg) +{ + fatal_assert(_std_fd == STDOUT_FILENO or _std_fd == STDERR_FILENO); + + bool data_was_read= false; + + libtest::vchar_t buffer; + buffer.resize(1024); + ssize_t read_length; + while ((read_length= ::read(_pipe_fd[READ], &buffer[0], buffer.size()))) + { + if (read_length == -1) + { + switch(errno) + { + case EAGAIN: + break; + + default: + Error << strerror(errno); + break; + } + + break; + } + + data_was_read= true; + arg.reserve(read_length +1); + for (size_t x= 0; x < size_t(read_length); ++x) + { + arg.push_back(buffer[x]); + } + // @todo Suck up all errput code here + } + + return data_was_read; } void Application::Pipe::nonblock() { - int ret; - if ((ret= fcntl(_fd[0], F_GETFL, 0)) == -1) + int flags; + do + { + flags= fcntl(_pipe_fd[READ], F_GETFL, 0); + } while (flags == -1 and (errno == EINTR or errno == EAGAIN)); + + if (flags == -1) { Error << "fcntl(F_GETFL) " << strerror(errno); throw strerror(errno); } - if ((ret= fcntl(_fd[0], F_SETFL, ret | O_NONBLOCK)) == -1) + int rval; + do + { + rval= fcntl(_pipe_fd[READ], F_SETFL, flags | O_NONBLOCK); + } while (rval == -1 and (errno == EINTR or errno == EAGAIN)); + + if (rval == -1) { Error << "fcntl(F_SETFL) " << strerror(errno); throw strerror(errno); @@ -465,40 +620,82 @@ void Application::Pipe::reset() close(READ); close(WRITE); - if (pipe(_fd) == -1) +#ifdef HAVE_PIPE2 + if (pipe2(_pipe_fd, O_NONBLOCK|O_CLOEXEC) == -1) +#endif { - throw fatal_message(strerror(errno)); + if (pipe(_pipe_fd) == -1) + { + FATAL(strerror(errno)); + } + + // Since either pipe2() was not found/called we set the pipe directly + nonblock(); + cloexec(); } _open[0]= true; _open[1]= true; +} - if (0) +void Application::Pipe::cloexec() +{ + //if (SOCK_CLOEXEC == 0) { - nonblock(); + if (FD_CLOEXEC) + { + int flags; + do + { + flags= fcntl(_pipe_fd[WRITE], F_GETFD, 0); + } while (flags == -1 and (errno == EINTR or errno == EAGAIN)); + + if (flags == -1) + { + Error << "fcntl(F_GETFD) " << strerror(errno); + throw strerror(errno); + } + + int rval; + do + { + rval= fcntl(_pipe_fd[WRITE], F_SETFD, flags | FD_CLOEXEC); + } while (rval == -1 && (errno == EINTR or errno == EAGAIN)); + + if (rval == -1) + { + Error << "fcntl(F_SETFD) " << strerror(errno); + throw strerror(errno); + } + } } } Application::Pipe::~Pipe() { - close(READ); - close(WRITE); + if (_pipe_fd[0] != -1) + { + ::close(_pipe_fd[0]); + } + + if (_pipe_fd[1] != -1) + { + ::close(_pipe_fd[1]); + } } -void Application::Pipe::dup_for_spawn(const close_t& arg, posix_spawn_file_actions_t& file_actions, const int newfildes) +void Application::Pipe::dup_for_spawn(posix_spawn_file_actions_t& file_actions) { - int type= int(arg); + int type= STDIN_FILENO == _std_fd ? 0 : 1; int ret; - if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _fd[type], newfildes )) < 0) + if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _pipe_fd[type], _std_fd )) < 0) { - Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")"; - throw fatal_message(strerror(ret)); + FATAL("posix_spawn_file_actions_adddup2(%s)", strerror(ret)); } - if ((ret= posix_spawn_file_actions_addclose(&file_actions, _fd[type])) < 0) + if ((ret= posix_spawn_file_actions_addclose(&file_actions, _pipe_fd[type])) < 0) { - Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")"; - throw fatal_message(strerror(ret)); + FATAL("posix_spawn_file_actions_addclose(%s)", strerror(ret)); } } @@ -508,91 +705,78 @@ void Application::Pipe::close(const close_t& arg) if (_open[type]) { - int ret; - if (::close(_fd[type]) == -1) + if (::close(_pipe_fd[type]) == -1) { Error << "close(" << strerror(errno) << ")"; } _open[type]= false; - _fd[type]= -1; + _pipe_fd[type]= -1; } } void Application::create_argv(const char *args[]) { - _argc= 2 +_use_libtool ? 2 : 0; // +1 for the command, +2 for libtool/mode=execute, +1 for the NULL - + delete_argv(); if (_use_libtool) { - _argc+= 2; // +2 for libtool --mode=execute + assert(libtool()); + vchar::append(built_argv, libtool()); + vchar::append(built_argv, "--mode=execute"); } - /* - valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE - */ if (_use_valgrind) { - _argc+= 7; - } - else if (_use_gdb) // gdb - { - _argc+= 1; - } - - for (Options::const_iterator iter= _options.begin(); iter != _options.end(); iter++) - { - _argc++; - if ((*iter).second.empty() == false) - { - _argc++; - } - } - - if (args) - { - for (const char **ptr= args; *ptr; ++ptr) - { - _argc++; - } - } - - delete_argv(); - built_argv= new char * [_argc]; + /* + valgrind --error-exitcode=1 --leak-check=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE + */ + vchar::append(built_argv, "valgrind"); + vchar::append(built_argv, "--error-exitcode=1"); + vchar::append(built_argv, "--leak-check=yes"); +#if 0 + vchar::append(built_argv, "--show-reachable=yes")); +#endif + vchar::append(built_argv, "--track-fds=yes"); +#if 0 + built_argv[x++]= strdup("--track-origin=yes"); +#endif + vchar::append(built_argv, "--malloc-fill=A5"); + vchar::append(built_argv, "--free-fill=DE"); - size_t x= 0; - if (_use_libtool) - { - assert(libtool()); - built_argv[x++]= strdup(libtool()); - built_argv[x++]= strdup("--mode=execute"); + std::string log_file= create_tmpfile("valgrind"); + libtest::vchar_t buffer; + buffer.resize(1024); + int length= snprintf(&buffer[0], buffer.size(), "--log-file=%s", log_file.c_str()); + fatal_assert(length > 0 and size_t(length) < buffer.size()); + vchar::append(built_argv, &buffer[0]); } - - if (_use_valgrind) + else if (_use_ptrcheck) { /* - valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE + valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file= */ - built_argv[x++]= strdup("valgrind"); - built_argv[x++]= strdup("--error-exitcode=1"); - built_argv[x++]= strdup("--leak-check=yes"); - built_argv[x++]= strdup("--show-reachable=yes"); - built_argv[x++]= strdup("--track-fds=yes"); - built_argv[x++]= strdup("--malloc-fill=A5"); - built_argv[x++]= strdup("--free-fill=DE"); + vchar::append(built_argv, "valgrind"); + vchar::append(built_argv, "--error-exitcode=1"); + vchar::append(built_argv, "--tool=exp-ptrcheck"); + std::string log_file= create_tmpfile("ptrcheck"); + libtest::vchar_t buffer; + buffer.resize(1024); + int length= snprintf(&buffer[0], buffer.size(), "--log-file=%s", log_file.c_str()); + fatal_assert(length > 0 and size_t(length) < buffer.size()); + vchar::append(built_argv, &buffer[0]); } else if (_use_gdb) { - built_argv[x++]= strdup("gdb"); + vchar::append(built_argv, "gdb"); } - built_argv[x++]= strdup(_exectuble_with_path.c_str()); + vchar::append(built_argv, _exectuble_with_path.c_str()); - for (Options::const_iterator iter= _options.begin(); iter != _options.end(); iter++) + for (Options::const_iterator iter= _options.begin(); iter != _options.end(); ++iter) { - built_argv[x++]= strdup((*iter).first.c_str()); + vchar::append(built_argv, (*iter).first.c_str()); if ((*iter).second.empty() == false) { - built_argv[x++]= strdup((*iter).second.c_str()); + vchar::append(built_argv, (*iter).second.c_str()); } } @@ -600,26 +784,28 @@ void Application::create_argv(const char *args[]) { for (const char **ptr= args; *ptr; ++ptr) { - built_argv[x++]= strdup(*ptr); + vchar::append(built_argv, *ptr); } } - built_argv[_argc -1]= NULL; + built_argv.push_back(nullptr); } std::string Application::print() { - return print_argv(built_argv, _argc); + return print_argv(built_argv); } std::string Application::arguments() { std::stringstream arg_buffer; - for (size_t x= 1 + _use_libtool ? 2 : 0; - x < _argc and built_argv[x]; - x++) + // Skip printing out the libtool reference + for (size_t x= _use_libtool ? 2 : 0; x < _argc; ++x) { - arg_buffer << built_argv[x] << " "; + if (built_argv[x]) + { + arg_buffer << built_argv[x] << " "; + } } return arg_buffer.str(); @@ -627,19 +813,10 @@ std::string Application::arguments() void Application::delete_argv() { - if (built_argv) - { - for (size_t x= 0; x < _argc; x++) - { - if (built_argv[x]) - { - ::free(built_argv[x]); - } - } - delete[] built_argv; - built_argv= NULL; - _argc= 0; - } + std::for_each(built_argv.begin(), built_argv.end(), FreeFromVector()); + + built_argv.clear(); + _argc= 0; } @@ -654,12 +831,7 @@ int exec_cmdline(const std::string& command, const char *args[], bool use_libtoo return int(ret); } - return int(app.wait(false)); -} - -const char *gearmand_binary() -{ - return GEARMAND_BINARY; + return int(app.join()); } } // namespace exec_cmdline