/* 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 <config.h>
-#include <libtest/common.h>
+#include "libtest/yatlcon.h"
+
+#include "libtest/common.h"
using namespace libtest;
#include <fcntl.h>
#include <fstream>
#include <memory>
-#include <spawn.h>
+#ifdef HAVE_POLL_H
+# include <poll.h>
+#endif
+#ifdef HAVE_SPAWN_H
+# include <spawn.h>
+#endif
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
+#include <unistd.h>
-extern "C" {
- static int exited_successfully(int status)
- {
- if (status == 0)
- {
- return EXIT_SUCCESS;
- }
+#include <algorithm>
+#include <stdexcept>
- 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] << " ";
+ 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;
}
}
}
_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 "libtool requested, but know libtool was found";
+ FATAL("libtool requested, but know libtool was found");
}
}
Application::~Application()
{
+ murder();
delete_argv();
}
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);
const_cast<char *>(_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
{
const_cast<char *>(gdb_run_file.c_str()),
const_cast<char *>(_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_POSIX_SPAWN;
+ }
+
+ assert(_pid != -1);
+ if (_pid == -1)
{
- return Application::INVALID;
+ 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;
}
-Application::error_t Application::wait()
+bool Application::check() const
{
- if (_pid == -1)
+ if (_pid > 1 and kill(_pid, 0) == 0)
{
- Error << "wait() got an invalid pid_t";
- return Application::INVALID;
+ return true;
}
+ return false;
+}
+
+void Application::murder()
+{
+ if (check())
{
- ssize_t read_length;
- char buffer[1024]= { 0 };
- bool bail= false;
- while (((read_length= ::read(stdout_fd.fd()[0], buffer, sizeof(buffer))) != 0) or bail)
+ int count= 5;
+ while ((count--) > 0 and check())
{
- if (read_length == -1)
+ if (kill(_pid, SIGTERM) == 0)
{
- switch(errno)
- {
- case EAGAIN:
- continue;
-
- default:
- Error << strerror(errno);
- bail= true;
- }
+ join();
}
- _stdout_buffer.reserve(read_length +1);
- for (size_t x= 0; x < read_length; x++)
+ else
{
- _stdout_buffer.push_back(buffer[x]);
+ Error << "kill(pid, SIGTERM) failed after kill with error of " << strerror(errno);
+ continue;
}
- // @todo Suck up all output code here
+
+ 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();
+}
+
+// false means that no data was returned
+bool Application::slurp()
+{
+ struct pollfd fds[2];
+ fds[0].fd= stdout_fd.fd();
+ fds[0].events= POLLRDNORM;
+ fds[0].revents= 0;
+ fds[1].fd= stderr_fd.fd();
+ fds[1].events= POLLRDNORM;
+ fds[1].revents= 0;
+
+ int active_fd;
+ if ((active_fd= poll(fds, 2, 0)) == -1)
+ {
+ int error;
+ switch ((error= errno))
+ {
+#ifdef TARGET_OS_LINUX
+ case ERESTART:
+#endif
+ case EINTR:
+ break;
+
+ case EFAULT:
+ case ENOMEM:
+ FATAL(strerror(error));
+ break;
+
+ case EINVAL:
+ FATAL("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid");
+ break;
+
+ default:
+ FATAL(strerror(error));
+ break;
+ }
+
+ return false;
+ }
+
+ if (active_fd == 0)
+ {
+ return false;
+ }
+
+ bool data_was_read= false;
+ if (fds[0].revents & POLLRDNORM)
+ {
+ if (stdout_fd.read(_stdout_buffer) == true)
+ {
+ data_was_read= true;
+ }
+ }
+
+ if (fds[1].revents & POLLRDNORM)
+ {
+ if (stderr_fd.read(_stderr_buffer) == true)
+ {
+ data_was_read= true;
}
}
+ return data_was_read;
+}
+
+Application::error_t Application::join()
+{
+ pid_t waited_pid= waitpid(_pid, &_status, 0);
+ slurp();
+ if (waited_pid == _pid and WIFEXITED(_status) == false)
{
- ssize_t read_length;
- char buffer[1024]= { 0 };
- bool bail= false;
- while (((read_length= ::read(stderr_fd.fd()[0], buffer, sizeof(buffer))) != 0) or bail)
+ /*
+ 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)
{
- if (read_length == -1)
+ _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())
{
- switch(errno)
+ error_string+= " stderr: ";
+ error_string+= stderr_c_str();
+ }
+ throw std::logic_error(error_string);
+ }
+ else if (WIFSIGNALED(_status))
+ {
+ 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())
{
- case EAGAIN:
- continue;
+ error_string+= " stdout: ";
+ error_string+= stdout_c_str();
+ }
- default:
- Error << strerror(errno);
- bail= true;
+ if (stderr_result_length())
+ {
+ error_string+= " stderr: ";
+ error_string+= stderr_c_str();
}
+
+ throw std::runtime_error(error_string);
}
- _stderr_buffer.reserve(read_length +1);
- for (size_t x= 0; x < read_length; x++)
+
+ // If we terminted it on purpose then it counts as a success.
+#if defined(DEBUG)
+ if (DEBUG)
{
- _stderr_buffer.push_back(buffer[x]);
+ Out << "waitpid() application terminated at request"
+ << " pid:" << _pid
+ << " name:" << built_argv[0];
}
- // @todo Suck up all errput code here
+#endif
+ }
+ else
+ {
+ _app_exit_state= Application::UNKNOWN;
+ Error << "Unknown logic state at exit:" << WEXITSTATUS(_status)
+ << " pid:" << _pid
+ << " name:" << built_argv[0];
}
}
-
- error_t exit_code= FAILURE;
+ else if (waited_pid == _pid and WIFEXITED(_status))
+ {
+ _app_exit_state= int_to_error_t(WEXITSTATUS(_status));
+ }
+ else if (waited_pid == -1)
{
- int status= 0;
- pid_t waited_pid;
- if ((waited_pid= waitpid(_pid, &status, 0)) == -1)
+ std::string error_string;
+ if (stdout_result_length())
{
- Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid);
+ error_string+= " stdout: ";
+ error_string+= stdout_c_str();
}
- else
+
+ if (stderr_result_length())
{
- 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));
+ error_string+= " stderr: ";
+ error_string+= stderr_c_str();
}
+ Error << "waitpid() returned errno:" << strerror(errno) << " " << error_string;
+ _app_exit_state= Application::UNKNOWN;
}
-
-#if 0
- if (exit_code == Application::INVALID)
+ 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)
+{
+ std::string arg(name);
+ arg+= option_value;
+ _options.push_back(std::make_pair(arg, std::string()));
}
void Application::add_option(const std::string& arg)
_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;
}
-void Application::Pipe::reset()
+int Application::Pipe::Pipe::fd()
{
- close(READ);
- close(WRITE);
-
- int ret;
- if (pipe(_fd) == -1)
+ if (_std_fd == STDOUT_FILENO)
{
- throw strerror(errno);
+ return _pipe_fd[READ];
}
- _open[0]= true;
- _open[1]= true;
+ 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 ((ret= fcntl(_fd[0], F_GETFL, 0)) == -1)
+ if (read_length == -1)
{
- Error << "fcntl(F_GETFL) " << strerror(errno);
- throw strerror(errno);
+ switch(errno)
+ {
+ case EAGAIN:
+ break;
+
+ default:
+ Error << strerror(errno);
+ break;
+ }
+
+ break;
}
- if ((ret= fcntl(_fd[0], F_SETFL, ret | O_NONBLOCK)) == -1)
+ data_was_read= true;
+ arg.reserve(read_length +1);
+ for (size_t x= 0; x < size_t(read_length); ++x)
{
- Error << "fcntl(F_SETFL) " << strerror(errno);
- throw strerror(errno);
+ arg.push_back(buffer[x]);
}
+ // @todo Suck up all errput code here
}
-}
-Application::Pipe::~Pipe()
-{
- close(READ);
- close(WRITE);
+ return data_was_read;
}
-void Application::Pipe::dup_for_spawn(const close_t& arg, posix_spawn_file_actions_t& file_actions, const int newfildes)
+void Application::Pipe::nonblock()
{
- int type= int(arg);
+ int flags;
+ do
+ {
+ flags= fcntl(_pipe_fd[READ], F_GETFL, 0);
+ } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
- int ret;
- if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _fd[type], newfildes )) < 0)
+ if (flags == -1)
{
- Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
- throw strerror(ret);
+ Error << "fcntl(F_GETFL) " << strerror(errno);
+ throw strerror(errno);
}
- if ((ret= posix_spawn_file_actions_addclose(&file_actions, _fd[type])) < 0)
+ 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 << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
- throw strerror(ret);
+ Error << "fcntl(F_SETFL) " << strerror(errno);
+ throw strerror(errno);
}
}
-void Application::Pipe::close(const close_t& arg)
+void Application::Pipe::reset()
{
- int type= int(arg);
+ close(READ);
+ close(WRITE);
- if (_open[type])
+#ifdef HAVE_PIPE2
+ if (pipe2(_pipe_fd, O_NONBLOCK|O_CLOEXEC) == -1)
+#endif
{
- int ret;
- if (::close(_fd[type]) == -1)
+ if (pipe(_pipe_fd) == -1)
{
- Error << "close(" << strerror(errno) << ")";
+ FATAL(strerror(errno));
}
- _open[type]= false;
- _fd[type]= -1;
+
+ // Since either pipe2() was not found/called we set the pipe directly
+ nonblock();
+ cloexec();
}
+ _open[0]= true;
+ _open[1]= true;
}
-void Application::create_argv(const char *args[])
+void Application::Pipe::cloexec()
{
- _argc= 2 +_use_libtool ? 2 : 0; // +1 for the command, +2 for libtool/mode=execute, +1 for the NULL
+ //if (SOCK_CLOEXEC == 0)
+ {
+ if (FD_CLOEXEC)
+ {
+ int flags;
+ do
+ {
+ flags= fcntl(_pipe_fd[WRITE], F_GETFD, 0);
+ } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
- if (_use_libtool)
+ 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()
+{
+ if (_pipe_fd[0] != -1)
{
- _argc+= 2; // +2 for libtool --mode=execute
+ ::close(_pipe_fd[0]);
}
- /*
- valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
- */
- if (_use_valgrind)
+ if (_pipe_fd[1] != -1)
{
- _argc+= 7;
+ ::close(_pipe_fd[1]);
}
- else if (_use_gdb) // gdb
+}
+
+void Application::Pipe::dup_for_spawn(posix_spawn_file_actions_t& file_actions)
+{
+ int type= STDIN_FILENO == _std_fd ? 0 : 1;
+
+ int ret;
+ if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _pipe_fd[type], _std_fd )) < 0)
{
- _argc+= 1;
+ FATAL("posix_spawn_file_actions_adddup2(%s)", strerror(ret));
}
- for (Options::const_iterator iter= _options.begin(); iter != _options.end(); iter++)
+ if ((ret= posix_spawn_file_actions_addclose(&file_actions, _pipe_fd[type])) < 0)
{
- _argc++;
- if ((*iter).second.empty() == false)
- {
- _argc++;
- }
+ FATAL("posix_spawn_file_actions_addclose(%s)", strerror(ret));
}
+}
- if (args)
+void Application::Pipe::close(const close_t& arg)
+{
+ int type= int(arg);
+
+ if (_open[type])
{
- for (const char **ptr= args; *ptr; ++ptr)
+ if (::close(_pipe_fd[type]) == -1)
{
- _argc++;
+ Error << "close(" << strerror(errno) << ")";
}
+ _open[type]= false;
+ _pipe_fd[type]= -1;
}
+}
+void Application::create_argv(const char *args[])
+{
delete_argv();
- built_argv= new char * [_argc];
-
- size_t x= 0;
if (_use_libtool)
{
assert(libtool());
- built_argv[x++]= strdup(libtool());
- built_argv[x++]= strdup("--mode=execute");
+ vchar::append(built_argv, libtool());
+ vchar::append(built_argv, "--mode=execute");
}
if (_use_valgrind)
{
/*
- valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
+ 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");
+
+ 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]);
+ }
+ else if (_use_ptrcheck)
+ {
+ /*
+ 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());
}
}
{
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(NULL);
}
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();
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;
}
return int(ret);
}
- return int(app.wait());
-}
-
-const char *gearmand_binary()
-{
- return GEARMAND_BINARY;
+ return int(app.join());
}
} // namespace exec_cmdline