git.m6w6.name Git - m6w6/libmemcached/blob - libtest/cmdline.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Data Differential YATL (i.e. libtest)  library
   4  *
   5  *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
   6  *
   7  *  Redistribution and use in source and binary forms, with or without
   8  *  modification, are permitted provided that the following conditions are
   9  *  met:
  10  *
  11  *      * Redistributions of source code must retain the above copyright
  12  *  notice, this list of conditions and the following disclaimer.
  13  *
  14  *      * Redistributions in binary form must reproduce the above
  15  *  copyright notice, this list of conditions and the following disclaimer
  16  *  in the documentation and/or other materials provided with the
  17  *  distribution.
  18  *
  19  *      * The names of its contributors may not be used to endorse or
  20  *  promote products derived from this software without specific prior
  21  *  written permission.
  22  *
  23  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  29  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  33  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  */
  36
  37 #include "mem_config.h"
  38 #include "libtest/common.h"
  39
  40 using namespace libtest;
  41
  42 #include <cstdlib>
  43 #include <cstring>
  44 #include <cerrno>
  45 #include <fcntl.h>
  46 #include <fstream>
  47 #include <memory>
  48 #ifdef HAVE_POLL_H
  49 # include <poll.h>
  50 #endif
  51 #ifdef HAVE_SPAWN_H
  52 # include <spawn.h>
  53 #endif
  54 #include <sstream>
  55 #include <string>
  56 #include <sys/stat.h>
  57 #include <sys/types.h>
  58 #include <unistd.h>
  59
  60 #include <algorithm>
  61
  62 #ifndef __USE_GNU
  63 static char **environ= NULL;
  64 #endif
  65
  66 #ifndef FD_CLOEXEC
  67 # define FD_CLOEXEC 0
  68 #endif
  69
  70 namespace {
  71
  72   std::string print_argv(libtest::vchar_ptr_t& built_argv)
  73   {
  74     std::stringstream arg_buffer;
  75
  76     for (vchar_ptr_t::iterator iter= built_argv.begin();
  77          iter == built_argv.end();
  78          iter++)
  79     {
  80       arg_buffer << *iter << " ";
  81     }
  82
  83     return arg_buffer.str();
  84   }
  85
  86 #if 0
  87   std::string print_argv(char** argv)
  88   {
  89     std::stringstream arg_buffer;
  90
  91     for (char** ptr= argv; *ptr; ++ptr)
  92     {
  93       arg_buffer << *ptr << " ";
  94     }
  95
  96     return arg_buffer.str();
  97   }
  98 #endif
  99
 100   static Application::error_t int_to_error_t(int arg)
 101   {
 102     switch (arg)
 103     {
 104     case 127:
 105       return Application::INVALID_POSIX_SPAWN;
 106
 107     case 0:
 108       return Application::SUCCESS;
 109
 110     case 1:
 111       return Application::FAILURE;
 112
 113     default:
 114       return Application::UNKNOWN;
 115     }
 116   }
 117 }
 118
 119 namespace libtest {
 120
 121 Application::Application(const std::string& arg, const bool _use_libtool_arg) :
 122   _use_libtool(_use_libtool_arg),
 123   _use_valgrind(false),
 124   _use_gdb(false),
 125   _use_ptrcheck(false),
 126   _will_fail(false),
 127   _argc(0),
 128   _exectuble(arg),
 129   stdin_fd(STDIN_FILENO),
 130   stdout_fd(STDOUT_FILENO),
 131   stderr_fd(STDERR_FILENO),
 132   _pid(-1),
 133   _status(0),
 134   _app_exit_state(UNINITIALIZED)
 135   {
 136     if (_use_libtool)
 137     {
 138       if (libtool() == NULL)
 139       {
 140         fatal_message("libtool requested, but know libtool was found");
 141       }
 142     }
 143
 144     // Find just the name of the application with no path
 145     {
 146       size_t found= arg.find_last_of("/\\");
 147       if (found)
 148       {
 149         _exectuble_name= arg.substr(found +1);
 150       }
 151       else
 152       {
 153         _exectuble_name= arg;
 154       }
 155     }
 156
 157     if (_use_libtool and getenv("PWD"))
 158     {
 159       _exectuble_with_path+= getenv("PWD");
 160       _exectuble_with_path+= "/";
 161     }
 162     _exectuble_with_path+= _exectuble;
 163   }
 164
 165 Application::~Application()
 166 {
 167   murder();
 168   delete_argv();
 169 }
 170
 171 Application::error_t Application::run(const char *args[])
 172 {
 173   stdin_fd.reset();
 174   stdout_fd.reset();
 175   stderr_fd.reset();
 176   _stdout_buffer.clear();
 177   _stderr_buffer.clear();
 178
 179   posix_spawn_file_actions_t file_actions;
 180   posix_spawn_file_actions_init(&file_actions);
 181
 182   stdin_fd.dup_for_spawn(file_actions);
 183   stdout_fd.dup_for_spawn(file_actions);
 184   stderr_fd.dup_for_spawn(file_actions);
 185
 186   posix_spawnattr_t spawnattr;
 187   posix_spawnattr_init(&spawnattr);
 188
 189   short flags= 0;
 190
 191   // Child should not block signals
 192   flags |= POSIX_SPAWN_SETSIGMASK;
 193
 194   sigset_t mask;
 195   sigemptyset(&mask);
 196
 197   fatal_assert(posix_spawnattr_setsigmask(&spawnattr, &mask) == 0);
 198
 199 #if defined(POSIX_SPAWN_USEVFORK) || defined(__linux__)
 200   // Use USEVFORK on linux
 201   flags |= POSIX_SPAWN_USEVFORK;
 202 #endif
 203
 204   flags |= POSIX_SPAWN_SETPGROUP;
 205   fatal_assert(posix_spawnattr_setpgroup(&spawnattr, 0) == 0);
 206
 207   fatal_assert(posix_spawnattr_setflags(&spawnattr, flags) == 0);
 208
 209   create_argv(args);
 210
 211   int spawn_ret;
 212   if (_use_gdb)
 213   {
 214     std::string gdb_run_file= create_tmpfile(_exectuble_name);
 215     std::fstream file_stream;
 216     file_stream.open(gdb_run_file.c_str(), std::fstream::out | std::fstream::trunc);
 217
 218     _gdb_filename= create_tmpfile(_exectuble_name);
 219     file_stream
 220       << "set logging redirect on" << std::endl
 221       << "set logging file " << _gdb_filename << std::endl
 222       << "set logging overwrite on" << std::endl
 223       << "set logging on" << std::endl
 224       << "set environment LIBTEST_IN_GDB=1" << std::endl
 225       << "run " << arguments() << std::endl
 226       << "thread apply all bt" << std::endl
 227       << "quit" << std::endl;
 228
 229     fatal_assert(file_stream.good());
 230     file_stream.close();
 231
 232     if (_use_libtool)
 233     {
 234       // libtool --mode=execute gdb -f -x binary
 235       char *argv[]= {
 236         const_cast<char *>(libtool()),
 237         const_cast<char *>("--mode=execute"),
 238         const_cast<char *>("gdb"),
 239         const_cast<char *>("-batch"),
 240         const_cast<char *>("-f"),
 241         const_cast<char *>("-x"),
 242         const_cast<char *>(gdb_run_file.c_str()),
 243         const_cast<char *>(_exectuble_with_path.c_str()),
 244         0};
 245
 246       spawn_ret= posix_spawnp(&_pid, libtool(), &file_actions, &spawnattr, argv, environ);
 247     }
 248     else
 249     {
 250       // gdb binary
 251       char *argv[]= {
 252         const_cast<char *>("gdb"),
 253         const_cast<char *>("-batch"),
 254         const_cast<char *>("-f"),
 255         const_cast<char *>("-x"),
 256         const_cast<char *>(gdb_run_file.c_str()),
 257         const_cast<char *>(_exectuble_with_path.c_str()),
 258         0};
 259       spawn_ret= posix_spawnp(&_pid, "gdb", &file_actions, &spawnattr, argv, environ);
 260     }
 261   }
 262   else
 263   {
 264     spawn_ret= posix_spawn(&_pid, built_argv[0], &file_actions, &spawnattr, &built_argv[0], NULL);
 265   }
 266
 267   posix_spawn_file_actions_destroy(&file_actions);
 268   posix_spawnattr_destroy(&spawnattr);
 269
 270   stdin_fd.close(Application::Pipe::READ);
 271   stdout_fd.close(Application::Pipe::WRITE);
 272   stderr_fd.close(Application::Pipe::WRITE);
 273
 274   if (spawn_ret != 0)
 275   {
 276     if (_will_fail == false)
 277     {
 278       Error << strerror(spawn_ret) << "(" << spawn_ret << ")";
 279     }
 280     _pid= -1;
 281     return Application::INVALID_POSIX_SPAWN;
 282   }
 283
 284   assert(_pid != -1);
 285   if (_pid == -1)
 286   {
 287     return Application::INVALID_POSIX_SPAWN;
 288   }
 289
 290 #if 0
 291   app_thread_st* _app_thread= new app_thread_st(_pid, _status, built_argv[0], _app_exit_state);
 292   int error;
 293   if ((error= pthread_create(&_thread, NULL, &app_thread, _app_thread)) != 0)
 294   {
 295     Error << "pthread_create() died during pthread_create(" << strerror(error) << ")";
 296     return Application::FAILURE;
 297   }
 298 #endif
 299
 300   return Application::SUCCESS;
 301 }
 302
 303 bool Application::check() const
 304 {
 305   if (_pid > 1 and kill(_pid, 0) == 0)
 306   {
 307     return true;
 308   }
 309
 310   return false;
 311 }
 312
 313 void Application::murder()
 314 {
 315   if (check())
 316   {
 317     int count= 5;
 318     while ((count--) > 0 and check())
 319     {
 320       if (kill(_pid, SIGTERM) == 0)
 321       {
 322         join();
 323       }
 324       else
 325       {
 326         Error << "kill(pid, SIGTERM) failed after kill with error of " << strerror(errno);
 327         continue;
 328       }
 329
 330       break;
 331     }
 332
 333     // If for whatever reason it lives, kill it hard
 334     if (check())
 335     {
 336       Error << "using SIGKILL, things will likely go poorly from this point";
 337       (void)kill(_pid, SIGKILL);
 338     }
 339   }
 340   slurp();
 341 }
 342
 343 // false means that no data was returned
 344 bool Application::slurp()
 345 {
 346   struct pollfd fds[2];
 347   fds[0].fd= stdout_fd.fd();
 348   fds[0].events= POLLRDNORM;
 349   fds[0].revents= 0;
 350   fds[1].fd= stderr_fd.fd();
 351   fds[1].events= POLLRDNORM;
 352   fds[1].revents= 0;
 353
 354   int active_fd;
 355   if ((active_fd= poll(fds, 2, 0)) == -1)
 356   {
 357     int error;
 358     switch ((error= errno))
 359     {
 360 #ifdef TARGET_OS_LINUX
 361     case ERESTART:
 362 #endif
 363     case EINTR:
 364       break;
 365
 366     case EFAULT:
 367     case ENOMEM:
 368       fatal_message(strerror(error));
 369       break;
 370
 371     case EINVAL:
 372       fatal_message("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid");
 373       break;
 374
 375     default:
 376       fatal_message(strerror(error));
 377       break;
 378     }
 379
 380     return false;
 381   }
 382
 383   if (active_fd == 0)
 384   {
 385     return false;
 386   }
 387
 388   bool data_was_read= false;
 389   if (fds[0].revents & POLLRDNORM)
 390   {
 391     if (stdout_fd.read(_stdout_buffer) == true)
 392     {
 393       data_was_read= true;
 394     }
 395   }
 396
 397   if (fds[1].revents & POLLRDNORM)
 398   {
 399     if (stderr_fd.read(_stderr_buffer) == true)
 400     {
 401       data_was_read= true;
 402     }
 403   }
 404
 405   return data_was_read;
 406 }
 407
 408 Application::error_t Application::join()
 409 {
 410   pid_t waited_pid= waitpid(_pid, &_status, 0);
 411
 412   if (waited_pid == _pid and WIFEXITED(_status) == false)
 413   {
 414     /*
 415       What we are looking for here is how the exit status happened.
 416       - 127 means that posix_spawn() itself had an error.
 417       - 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.
 418       - Finally something has happened that we don't currently understand.
 419     */
 420     if (WEXITSTATUS(_status) == 127)
 421     {
 422       _app_exit_state= Application::INVALID_POSIX_SPAWN;
 423       std::string error_string("posix_spawn() failed pid:");
 424       error_string+= _pid;
 425       error_string+= " name:";
 426       error_string+= built_argv[0];
 427       throw std::logic_error(error_string);
 428     }
 429     else if WIFSIGNALED(_status)
 430     {
 431       if (WTERMSIG(_status) != SIGTERM and WTERMSIG(_status) != SIGHUP)
 432       {
 433         _app_exit_state= Application::INVALID_POSIX_SPAWN;
 434         std::string error_string(built_argv[0]);
 435         error_string+= " was killed by signal ";
 436         error_string+= strsignal(WTERMSIG(_status));
 437         throw std::runtime_error(error_string);
 438       }
 439
 440       // If we terminted it on purpose then it counts as a success.
 441       Out << "waitpid() application terminated at request"
 442         << " pid:" << _pid
 443         << " name:" << built_argv[0];
 444     }
 445     else
 446     {
 447       _app_exit_state= Application::UNKNOWN;
 448       Error << "Unknown logic state at exit:" << WEXITSTATUS(_status)
 449         << " pid:" << _pid
 450         << " name:" << built_argv[0];
 451     }
 452   }
 453   else if (waited_pid == _pid and WIFEXITED(_status))
 454   {
 455     _app_exit_state= int_to_error_t(WEXITSTATUS(_status));
 456   }
 457   else if (waited_pid == -1)
 458   {
 459     _app_exit_state= Application::UNKNOWN;
 460     Error << "waitpid() returned errno:" << strerror(errno);
 461   }
 462   else
 463   {
 464     _app_exit_state= Application::UNKNOWN;
 465     throw std::logic_error("waitpid() returned an unknown value");
 466   }
 467
 468   return _app_exit_state;
 469 }
 470
 471 void Application::add_long_option(const std::string& name, const std::string& option_value)
 472 {
 473   std::string arg(name);
 474   arg+= option_value;
 475   _options.push_back(std::make_pair(arg, std::string()));
 476 }
 477
 478 void Application::add_option(const std::string& arg)
 479 {
 480   _options.push_back(std::make_pair(arg, std::string()));
 481 }
 482
 483 void Application::add_option(const std::string& name, const std::string& value)
 484 {
 485   _options.push_back(std::make_pair(name, value));
 486 }
 487
 488 Application::Pipe::Pipe(int arg) :
 489   _std_fd(arg)
 490 {
 491   _pipe_fd[READ]= -1;
 492   _pipe_fd[WRITE]= -1;
 493   _open[READ]= false;
 494   _open[WRITE]= false;
 495 }
 496
 497 int Application::Pipe::Pipe::fd()
 498 {
 499   if (_std_fd == STDOUT_FILENO)
 500   {
 501     return _pipe_fd[READ];
 502   }
 503   else if (_std_fd == STDERR_FILENO)
 504   {
 505     return _pipe_fd[READ];
 506   }
 507
 508   return _pipe_fd[WRITE]; // STDIN_FILENO
 509 }
 510
 511
 512 bool Application::Pipe::read(libtest::vchar_t& arg)
 513 {
 514   fatal_assert(_std_fd == STDOUT_FILENO or _std_fd == STDERR_FILENO);
 515
 516   bool data_was_read= false;
 517
 518   ssize_t read_length;
 519   char buffer[1024]= { 0 };
 520   while ((read_length= ::read(_pipe_fd[READ], buffer, sizeof(buffer))))
 521   {
 522     if (read_length == -1)
 523     {
 524       switch(errno)
 525       {
 526       case EAGAIN:
 527         break;
 528
 529       default:
 530         Error << strerror(errno);
 531         break;
 532       }
 533
 534       break;
 535     }
 536
 537     data_was_read= true;
 538     arg.reserve(read_length +1);
 539     for (size_t x= 0; x < size_t(read_length); ++x)
 540     {
 541       arg.push_back(buffer[x]);
 542     }
 543     // @todo Suck up all errput code here
 544   }
 545
 546   return data_was_read;
 547 }
 548
 549 void Application::Pipe::nonblock()
 550 {
 551   int flags;
 552   {
 553     flags= fcntl(_pipe_fd[READ], F_GETFL, 0);
 554   } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
 555
 556   if (flags == -1)
 557   {
 558     Error << "fcntl(F_GETFL) " << strerror(errno);
 559     throw strerror(errno);
 560   }
 561
 562   int rval;
 563   do
 564   {
 565     rval= fcntl(_pipe_fd[READ], F_SETFL, flags | O_NONBLOCK);
 566   } while (rval == -1 and (errno == EINTR or errno == EAGAIN));
 567
 568   if (rval == -1)
 569   {
 570     Error << "fcntl(F_SETFL) " << strerror(errno);
 571     throw strerror(errno);
 572   }
 573 }
 574
 575 void Application::Pipe::reset()
 576 {
 577   close(READ);
 578   close(WRITE);
 579
 580 #if defined(HAVE_PIPE2) && HAVE_PIPE2
 581   if (pipe2(_pipe_fd, O_NONBLOCK|O_CLOEXEC) == -1)
 582 #else
 583   if (pipe(_pipe_fd) == -1)
 584 #endif
 585   {
 586     fatal_message(strerror(errno));
 587   }
 588   _open[0]= true;
 589   _open[1]= true;
 590
 591 #if defined(HAVE_PIPE2) && HAVE_PIPE2
 592   {
 593     nonblock();
 594     cloexec();
 595   }
 596 #endif
 597 }
 598
 599 void Application::Pipe::cloexec()
 600 {
 601   //if (SOCK_CLOEXEC == 0)
 602   {
 603     if (FD_CLOEXEC)
 604     {
 605       int flags;
 606       do
 607       {
 608         flags= fcntl(_pipe_fd[WRITE], F_GETFD, 0);
 609       } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
 610
 611       if (flags == -1)
 612       {
 613         Error << "fcntl(F_GETFD) " << strerror(errno);
 614         throw strerror(errno);
 615       }
 616
 617       int rval;
 618       do
 619       {
 620         rval= fcntl(_pipe_fd[WRITE], F_SETFD, flags | FD_CLOEXEC);
 621       } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
 622
 623       if (rval == -1)
 624       {
 625         Error << "fcntl(F_SETFD) " << strerror(errno);
 626         throw strerror(errno);
 627       }
 628     }
 629   }
 630 }
 631
 632 Application::Pipe::~Pipe()
 633 {
 634   if (_pipe_fd[0] != -1)
 635   {
 636     ::close(_pipe_fd[0]);
 637   }
 638
 639   if (_pipe_fd[1] != -1)
 640   {
 641     ::close(_pipe_fd[1]);
 642   }
 643 }
 644
 645 void Application::Pipe::dup_for_spawn(posix_spawn_file_actions_t& file_actions)
 646 {
 647   int type= STDIN_FILENO == _std_fd ? 0 : 1;
 648
 649   int ret;
 650   if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _pipe_fd[type], _std_fd )) < 0)
 651   {
 652     Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
 653     fatal_message(strerror(ret));
 654   }
 655
 656   if ((ret= posix_spawn_file_actions_addclose(&file_actions, _pipe_fd[type])) < 0)
 657   {
 658     Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
 659     fatal_message(strerror(ret));
 660   }
 661 }
 662
 663 void Application::Pipe::close(const close_t& arg)
 664 {
 665   int type= int(arg);
 666
 667   if (_open[type])
 668   {
 669     if (::close(_pipe_fd[type]) == -1)
 670     {
 671       Error << "close(" << strerror(errno) << ")";
 672     }
 673     _open[type]= false;
 674     _pipe_fd[type]= -1;
 675   }
 676 }
 677
 678 void Application::create_argv(const char *args[])
 679 {
 680   delete_argv();
 681   if (_use_libtool)
 682   {
 683     assert(libtool());
 684     built_argv.push_back(strdup(libtool()));
 685     built_argv.push_back(strdup("--mode=execute"));
 686   }
 687
 688   if (_use_valgrind)
 689   {
 690     /*
 691       valgrind --error-exitcode=1 --leak-check=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
 692     */
 693     built_argv.push_back(strdup("valgrind"));
 694     built_argv.push_back(strdup("--error-exitcode=1"));
 695     built_argv.push_back(strdup("--leak-check=yes"));
 696 #if 0
 697     built_argv.push_back(strdup("--show-reachable=yes"));
 698 #endif
 699     built_argv.push_back(strdup("--track-fds=yes"));
 700 #if 0
 701     built_argv[x++]= strdup("--track-origin=yes");
 702 #endif
 703     built_argv.push_back(strdup("--malloc-fill=A5"));
 704     built_argv.push_back(strdup("--free-fill=DE"));
 705
 706     std::string log_file= create_tmpfile("valgrind");
 707     char buffer[1024];
 708     int length= snprintf(buffer, sizeof(buffer), "--log-file=%s", log_file.c_str());
 709     fatal_assert(length > 0 and size_t(length) < sizeof(buffer));
 710     built_argv.push_back(strdup(buffer));
 711   }
 712   else if (_use_ptrcheck)
 713   {
 714     /*
 715       valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file=
 716     */
 717     built_argv.push_back(strdup("valgrind"));
 718     built_argv.push_back(strdup("--error-exitcode=1"));
 719     built_argv.push_back(strdup("--tool=exp-ptrcheck"));
 720     std::string log_file= create_tmpfile("ptrcheck");
 721     char buffer[1024];
 722     int length= snprintf(buffer, sizeof(buffer), "--log-file=%s", log_file.c_str());
 723     fatal_assert(length > 0 and size_t(length) < sizeof(buffer));
 724     built_argv.push_back(strdup(buffer));
 725   }
 726   else if (_use_gdb)
 727   {
 728     built_argv.push_back(strdup("gdb"));
 729   }
 730
 731   built_argv.push_back(strdup(_exectuble_with_path.c_str()));
 732
 733   for (Options::const_iterator iter= _options.begin(); iter != _options.end(); ++iter)
 734   {
 735     built_argv.push_back(strdup((*iter).first.c_str()));
 736     if ((*iter).second.empty() == false)
 737     {
 738       built_argv.push_back(strdup((*iter).second.c_str()));
 739     }
 740   }
 741
 742   if (args)
 743   {
 744     for (const char **ptr= args; *ptr; ++ptr)
 745     {
 746       built_argv.push_back(strdup(*ptr));
 747     }
 748   }
 749   built_argv.push_back(NULL);
 750 }
 751
 752 std::string Application::print()
 753 {
 754   return print_argv(built_argv);
 755 }
 756
 757 std::string Application::arguments()
 758 {
 759   std::stringstream arg_buffer;
 760
 761   for (size_t x= (1 +_use_libtool) ? 2 : 0;
 762        x < _argc and built_argv[x];
 763        ++x)
 764   {
 765     arg_buffer << built_argv[x] << " ";
 766   }
 767
 768   return arg_buffer.str();
 769 }
 770
 771 struct DeleteFromVector
 772 {
 773   template <class T>
 774     void operator() ( T* ptr) const
 775     {
 776       free(ptr);
 777     }
 778 };
 779
 780 void Application::delete_argv()
 781 {
 782   std::for_each(built_argv.begin(), built_argv.end(), DeleteFromVector());
 783
 784   built_argv.clear();
 785   _argc= 0;
 786 }
 787
 788
 789 int exec_cmdline(const std::string& command, const char *args[], bool use_libtool)
 790 {
 791   Application app(command, use_libtool);
 792
 793   Application::error_t ret= app.run(args);
 794
 795   if (ret != Application::SUCCESS)
 796   {
 797     return int(ret);
 798   }
 799
 800   return int(app.join());
 801 }
 802
 803 const char *gearmand_binary()
 804 {
 805   return GEARMAND_BINARY;
 806 }
 807
 808 const char *drizzled_binary()
 809 {
 810   return DRIZZLED_BINARY;
 811 }
 812
 813 } // namespace exec_cmdline