1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 3 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include <libtest/common.h>
25 using namespace libtest
;
37 #include <sys/types.h>
40 static int exited_successfully(int status
)
47 if (WIFEXITED(status
) == true)
49 return WEXITSTATUS(status
);
51 else if (WIFSIGNALED(status
) == true)
53 return WTERMSIG(status
);
62 std::string
print_argv(char * * & built_argv
, const size_t& argc
)
64 std::stringstream arg_buffer
;
66 for (size_t x
= 0; x
< argc
; x
++)
68 arg_buffer
<< built_argv
[x
] << " ";
71 return arg_buffer
.str();
74 std::string
print_argv(char** argv
)
76 std::stringstream arg_buffer
;
78 for (char** ptr
= argv
; *ptr
; ptr
++)
80 arg_buffer
<< *ptr
<< " ";
83 return arg_buffer
.str();
86 static Application::error_t
int_to_error_t(int arg
)
91 return Application::INVALID
;
94 return Application::SUCCESS
;
98 return Application::FAILURE
;
105 Application::Application(const std::string
& arg
, const bool _use_libtool_arg
) :
106 _use_libtool(_use_libtool_arg
),
107 _use_valgrind(false),
116 if (libtool() == NULL
)
118 throw "libtool requested, but know libtool was found";
122 // Find just the name of the application with no path
124 size_t found
= arg
.find_last_of("/\\");
127 _exectuble_name
= arg
.substr(found
+1);
131 _exectuble_name
= arg
;
135 if (_use_libtool
and getenv("PWD"))
137 _exectuble_with_path
+= getenv("PWD");
138 _exectuble_with_path
+= "/";
140 _exectuble_with_path
+= _exectuble
;
143 Application::~Application()
148 Application::error_t
Application::run(const char *args
[])
153 _stdout_buffer
.clear();
154 _stderr_buffer
.clear();
156 posix_spawn_file_actions_t file_actions
;
157 posix_spawn_file_actions_init(&file_actions
);
159 stdin_fd
.dup_for_spawn(Application::Pipe::READ
, file_actions
, STDIN_FILENO
);
160 stdout_fd
.dup_for_spawn(Application::Pipe::WRITE
, file_actions
, STDOUT_FILENO
);
161 stderr_fd
.dup_for_spawn(Application::Pipe::WRITE
, file_actions
, STDERR_FILENO
);
168 std::string gdb_run_file
= create_tmpfile(_exectuble_name
);
169 std::fstream file_stream
;
170 file_stream
.open(gdb_run_file
.c_str(), std::fstream::out
| std::fstream::trunc
);
172 _gdb_filename
= create_tmpfile(_exectuble_name
);
174 << "set logging redirect on" << std::endl
175 << "set logging file " << _gdb_filename
<< std::endl
176 << "set logging overwrite on" << std::endl
177 << "set logging on" << std::endl
178 << "set environment LIBTEST_IN_GDB=1" << std::endl
179 << "run " << arguments() << std::endl
180 << "thread apply all bt" << std::endl
181 << "quit" << std::endl
;
183 fatal_assert(file_stream
.good());
188 // libtool --mode=execute gdb -f -x binary
190 const_cast<char *>(libtool()),
191 const_cast<char *>("--mode=execute"),
192 const_cast<char *>("gdb"),
193 const_cast<char *>("-batch"),
194 const_cast<char *>("-f"),
195 const_cast<char *>("-x"),
196 const_cast<char *>(gdb_run_file
.c_str()),
197 const_cast<char *>(_exectuble_with_path
.c_str()),
200 spawn_ret
= posix_spawnp(&_pid
, libtool(), &file_actions
, NULL
, argv
, NULL
);
206 const_cast<char *>("gdb"),
207 const_cast<char *>("-batch"),
208 const_cast<char *>("-f"),
209 const_cast<char *>("-x"),
210 const_cast<char *>(gdb_run_file
.c_str()),
211 const_cast<char *>(_exectuble_with_path
.c_str()),
213 spawn_ret
= posix_spawnp(&_pid
, "gdb", &file_actions
, NULL
, argv
, NULL
);
220 spawn_ret
= posix_spawn(&_pid
, built_argv
[0], &file_actions
, NULL
, built_argv
, NULL
);
224 spawn_ret
= posix_spawnp(&_pid
, built_argv
[0], &file_actions
, NULL
, built_argv
, NULL
);
228 posix_spawn_file_actions_destroy(&file_actions
);
230 stdin_fd
.close(Application::Pipe::READ
);
231 stdout_fd
.close(Application::Pipe::WRITE
);
232 stderr_fd
.close(Application::Pipe::WRITE
);
236 return Application::INVALID
;
239 return Application::SUCCESS
;
242 Application::error_t
Application::wait()
246 Error
<< "wait() got an invalid pid_t";
247 return Application::INVALID
;
252 char buffer
[1024]= { 0 };
254 while (((read_length
= ::read(stdout_fd
.fd()[0], buffer
, sizeof(buffer
))) != 0) or bail
)
256 if (read_length
== -1)
264 Error
<< strerror(errno
);
268 _stdout_buffer
.reserve(read_length
+1);
269 for (size_t x
= 0; x
< read_length
; x
++)
271 _stdout_buffer
.push_back(buffer
[x
]);
273 // @todo Suck up all output code here
279 char buffer
[1024]= { 0 };
281 while (((read_length
= ::read(stderr_fd
.fd()[0], buffer
, sizeof(buffer
))) != 0) or bail
)
283 if (read_length
== -1)
291 Error
<< strerror(errno
);
295 _stderr_buffer
.reserve(read_length
+1);
296 for (size_t x
= 0; x
< read_length
; x
++)
298 _stderr_buffer
.push_back(buffer
[x
]);
300 // @todo Suck up all errput code here
304 error_t exit_code
= FAILURE
;
308 if ((waited_pid
= waitpid(_pid
, &status
, 0)) == -1)
310 Error
<< "Error occured while waitpid(" << strerror(errno
) << ") on pid " << int(_pid
);
314 if (waited_pid
!= _pid
)
316 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "Pid mismatch, %d != %d", int(waited_pid
), int(_pid
));
318 exit_code
= int_to_error_t(exited_successfully(status
));
323 if (exit_code
== Application::INVALID
)
325 Error
<< print_argv(built_argv
, _argc
);
332 void Application::add_option(const std::string
& arg
)
334 _options
.push_back(std::make_pair(arg
, std::string()));
337 void Application::add_option(const std::string
& name
, const std::string
& value
)
339 _options
.push_back(std::make_pair(name
, value
));
342 Application::Pipe::Pipe()
350 void Application::Pipe::reset()
358 throw strerror(errno
);
364 if ((ret
= fcntl(_fd
[0], F_GETFL
, 0)) == -1)
366 Error
<< "fcntl(F_GETFL) " << strerror(errno
);
367 throw strerror(errno
);
370 if ((ret
= fcntl(_fd
[0], F_SETFL
, ret
| O_NONBLOCK
)) == -1)
372 Error
<< "fcntl(F_SETFL) " << strerror(errno
);
373 throw strerror(errno
);
378 Application::Pipe::~Pipe()
384 void Application::Pipe::dup_for_spawn(const close_t
& arg
, posix_spawn_file_actions_t
& file_actions
, const int newfildes
)
389 if ((ret
= posix_spawn_file_actions_adddup2(&file_actions
, _fd
[type
], newfildes
)) < 0)
391 Error
<< "posix_spawn_file_actions_adddup2(" << strerror(ret
) << ")";
395 if ((ret
= posix_spawn_file_actions_addclose(&file_actions
, _fd
[type
])) < 0)
397 Error
<< "posix_spawn_file_actions_adddup2(" << strerror(ret
) << ")";
402 void Application::Pipe::close(const close_t
& arg
)
409 if (::close(_fd
[type
]) == -1)
411 Error
<< "close(" << strerror(errno
) << ")";
418 void Application::create_argv(const char *args
[])
420 _argc
= 2 +_use_libtool
? 2 : 0; // +1 for the command, +2 for libtool/mode=execute, +1 for the NULL
424 _argc
+= 2; // +2 for libtool --mode=execute
428 valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
434 else if (_use_gdb
) // gdb
439 for (Options::const_iterator iter
= _options
.begin(); iter
!= _options
.end(); iter
++)
442 if ((*iter
).second
.empty() == false)
450 for (const char **ptr
= args
; *ptr
; ++ptr
)
457 built_argv
= new char * [_argc
];
463 built_argv
[x
++]= strdup(libtool());
464 built_argv
[x
++]= strdup("--mode=execute");
470 valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
472 built_argv
[x
++]= strdup("valgrind");
473 built_argv
[x
++]= strdup("--error-exitcode=1");
474 built_argv
[x
++]= strdup("--leak-check=yes");
475 built_argv
[x
++]= strdup("--show-reachable=yes");
476 built_argv
[x
++]= strdup("--track-fds=yes");
477 built_argv
[x
++]= strdup("--malloc-fill=A5");
478 built_argv
[x
++]= strdup("--free-fill=DE");
482 built_argv
[x
++]= strdup("gdb");
485 built_argv
[x
++]= strdup(_exectuble_with_path
.c_str());
487 for (Options::const_iterator iter
= _options
.begin(); iter
!= _options
.end(); iter
++)
489 built_argv
[x
++]= strdup((*iter
).first
.c_str());
490 if ((*iter
).second
.empty() == false)
492 built_argv
[x
++]= strdup((*iter
).second
.c_str());
498 for (const char **ptr
= args
; *ptr
; ++ptr
)
500 built_argv
[x
++]= strdup(*ptr
);
503 built_argv
[_argc
-1]= NULL
;
506 std::string
Application::print()
508 return print_argv(built_argv
, _argc
);
511 std::string
Application::arguments()
513 std::stringstream arg_buffer
;
515 for (size_t x
= 1 + _use_libtool
? 2 : 0;
516 x
< _argc
and built_argv
[x
];
519 arg_buffer
<< built_argv
[x
] << " ";
522 return arg_buffer
.str();
525 void Application::delete_argv()
529 for (size_t x
= 0; x
< _argc
; x
++)
533 ::free(built_argv
[x
]);
543 int exec_cmdline(const std::string
& command
, const char *args
[], bool use_libtool
)
545 Application
app(command
, use_libtool
);
547 Application::error_t ret
= app
.run(args
);
549 if (ret
!= Application::SUCCESS
)
554 return int(app
.wait());
557 const char *gearmand_binary()
559 return GEARMAND_BINARY
;
562 } // namespace exec_cmdline