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 <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 #include <poll.h>
  49 #include <spawn.h>
  50 #include <sstream>
  51 #include <string>
  52 #include <sys/stat.h>
  53 #include <sys/types.h>
  54 #include <unistd.h>
  55
  56 #include <algorithm>
  57
  58 #ifndef __USE_GNU
  59 static char **environ= NULL;
  60 #endif
  61
  62 extern "C" {
  63   static int exited_successfully(int status)
  64   {
  65     if (status == 0)
  66     {
  67       return EXIT_SUCCESS;
  68     }
  69
  70     if (WIFEXITED(status) == true)
  71     {
  72       return WEXITSTATUS(status);
  73     }
  74     else if (WIFSIGNALED(status) == true)
  75     {
  76       return WTERMSIG(status);
  77     }
  78
  79     return EXIT_FAILURE;
  80   }
  81 }
  82
  83 namespace {
  84
  85   std::string print_argv(libtest::vchar_ptr_t& built_argv)
  86   {
  87     std::stringstream arg_buffer;
  88
  89     for (vchar_ptr_t::iterator iter= built_argv.begin();
  90          iter == built_argv.end();
  91          iter++)
  92     {
  93       arg_buffer << *iter << " ";
  94     }
  95
  96     return arg_buffer.str();
  97   }
  98
  99 #if 0
 100   std::string print_argv(char** argv)
 101   {
 102     std::stringstream arg_buffer;
 103
 104     for (char** ptr= argv; *ptr; ++ptr)
 105     {
 106       arg_buffer << *ptr << " ";
 107     }
 108
 109     return arg_buffer.str();
 110   }
 111 #endif
 112
 113
 114   static Application::error_t int_to_error_t(int arg)
 115   {
 116     switch (arg)
 117     {
 118     case 127:
 119       return Application::INVALID;
 120
 121     case 0:
 122       return Application::SUCCESS;
 123
 124     default:
 125     case 1:
 126       return Application::FAILURE;
 127     }
 128   }
 129 }
 130
 131 namespace libtest {
 132
 133 Application::Application(const std::string& arg, const bool _use_libtool_arg) :
 134   _use_libtool(_use_libtool_arg),
 135   _use_valgrind(false),
 136   _use_gdb(false),
 137   _use_ptrcheck(false),
 138   _will_fail(false),
 139   _argc(0),
 140   _exectuble(arg),
 141   stdin_fd(STDIN_FILENO),
 142   stdout_fd(STDOUT_FILENO),
 143   stderr_fd(STDERR_FILENO),
 144   _pid(-1)
 145   {
 146     if (_use_libtool)
 147     {
 148       if (libtool() == NULL)
 149       {
 150         fatal_message("libtool requested, but know libtool was found");
 151       }
 152     }
 153
 154     // Find just the name of the application with no path
 155     {
 156       size_t found= arg.find_last_of("/\\");
 157       if (found)
 158       {
 159         _exectuble_name= arg.substr(found +1);
 160       }
 161       else
 162       {
 163         _exectuble_name= arg;
 164       }
 165     }
 166
 167     if (_use_libtool and getenv("PWD"))
 168     {
 169       _exectuble_with_path+= getenv("PWD");
 170       _exectuble_with_path+= "/";
 171     }
 172     _exectuble_with_path+= _exectuble;
 173   }
 174
 175 Application::~Application()
 176 {
 177   murder();
 178   delete_argv();
 179 }
 180
 181 Application::error_t Application::run(const char *args[])
 182 {
 183   stdin_fd.reset();
 184   stdout_fd.reset();
 185   stderr_fd.reset();
 186   _stdout_buffer.clear();
 187   _stderr_buffer.clear();
 188
 189   posix_spawn_file_actions_t file_actions;
 190   posix_spawn_file_actions_init(&file_actions);
 191
 192   stdin_fd.dup_for_spawn(file_actions);
 193   stdout_fd.dup_for_spawn(file_actions);
 194   stderr_fd.dup_for_spawn(file_actions);
 195
 196   posix_spawnattr_t spawnattr;
 197   posix_spawnattr_init(&spawnattr);
 198
 199   sigset_t set;
 200   sigemptyset(&set);
 201   fatal_assert(posix_spawnattr_setsigmask(&spawnattr, &set) == 0);
 202
 203   create_argv(args);
 204
 205   int spawn_ret;
 206   if (_use_gdb)
 207   {
 208     std::string gdb_run_file= create_tmpfile(_exectuble_name);
 209     std::fstream file_stream;
 210     file_stream.open(gdb_run_file.c_str(), std::fstream::out | std::fstream::trunc);
 211
 212     _gdb_filename= create_tmpfile(_exectuble_name);
 213     file_stream
 214       << "set logging redirect on" << std::endl
 215       << "set logging file " << _gdb_filename << std::endl
 216       << "set logging overwrite on" << std::endl
 217       << "set logging on" << std::endl
 218       << "set environment LIBTEST_IN_GDB=1" << std::endl
 219       << "run " << arguments() << std::endl
 220       << "thread apply all bt" << std::endl
 221       << "quit" << std::endl;
 222
 223     fatal_assert(file_stream.good());
 224     file_stream.close();
 225
 226     if (_use_libtool)
 227     {
 228       // libtool --mode=execute gdb -f -x binary
 229       char *argv[]= {
 230         const_cast<char *>(libtool()),
 231         const_cast<char *>("--mode=execute"),
 232         const_cast<char *>("gdb"),
 233         const_cast<char *>("-batch"),
 234         const_cast<char *>("-f"),
 235         const_cast<char *>("-x"),
 236         const_cast<char *>(gdb_run_file.c_str()),
 237         const_cast<char *>(_exectuble_with_path.c_str()),
 238         0};
 239
 240       spawn_ret= posix_spawnp(&_pid, libtool(), &file_actions, &spawnattr, argv, environ);
 241     }
 242     else
 243     {
 244       // gdb binary
 245       char *argv[]= {
 246         const_cast<char *>("gdb"),
 247         const_cast<char *>("-batch"),
 248         const_cast<char *>("-f"),
 249         const_cast<char *>("-x"),
 250         const_cast<char *>(gdb_run_file.c_str()),
 251         const_cast<char *>(_exectuble_with_path.c_str()),
 252         0};
 253       spawn_ret= posix_spawnp(&_pid, "gdb", &file_actions, &spawnattr, argv, environ);
 254     }
 255   }
 256   else
 257   {
 258
 259     if (_use_libtool)
 260     {
 261       spawn_ret= posix_spawn(&_pid, built_argv[0], &file_actions, &spawnattr, &built_argv[0], NULL);
 262     }
 263     else
 264     {
 265       spawn_ret= posix_spawnp(&_pid, built_argv[0], &file_actions, &spawnattr, &built_argv[0], NULL);
 266     }
 267   }
 268
 269   posix_spawn_file_actions_destroy(&file_actions);
 270   posix_spawnattr_destroy(&spawnattr);
 271
 272   stdin_fd.close(Application::Pipe::READ);
 273   stdout_fd.close(Application::Pipe::WRITE);
 274   stderr_fd.close(Application::Pipe::WRITE);
 275
 276   if (spawn_ret != 0)
 277   {
 278     if (_will_fail == false)
 279     {
 280       Error << strerror(spawn_ret) << "(" << spawn_ret << ")";
 281     }
 282     _pid= -1;
 283     return Application::INVALID;
 284   }
 285
 286   return Application::SUCCESS;
 287 }
 288
 289 bool Application::check() const
 290 {
 291   if (_pid > 1 and kill(_pid, 0) == 0)
 292   {
 293     return true;
 294   }
 295
 296   return false;
 297 }
 298
 299 void Application::murder()
 300 {
 301   if (check())
 302   {
 303     int count= 5;
 304     while ((count--) > 0 and check())
 305     {
 306       int kill_ret= kill(_pid, SIGTERM);
 307       if (kill_ret == 0)
 308       {
 309         int status= 0;
 310         pid_t waitpid_ret;
 311         if ((waitpid_ret= waitpid(_pid, &status, WNOHANG)) == -1)
 312         {
 313           switch (errno)
 314           {
 315           case ECHILD:
 316           case EINTR:
 317             break;
 318
 319           default:
 320             Error << "waitpid() failed after kill with error of " << strerror(errno);
 321             break;
 322           }
 323         }
 324
 325         if (waitpid_ret == 0)
 326         {
 327           libtest::dream(1, 0);
 328         }
 329       }
 330       else
 331       {
 332         Error << "kill(pid, SIGTERM) failed after kill with error of " << strerror(errno);
 333         continue;
 334       }
 335
 336       break;
 337     }
 338
 339     // If for whatever reason it lives, kill it hard
 340     if (check())
 341     {
 342       (void)kill(_pid, SIGKILL);
 343     }
 344   }
 345   slurp();
 346 }
 347
 348 // false means that no data was returned
 349 bool Application::slurp()
 350 {
 351   struct pollfd fds[2];
 352   fds[0].fd= stdout_fd.fd();
 353   fds[0].events= POLLRDNORM;
 354   fds[0].revents= 0;
 355   fds[1].fd= stderr_fd.fd();
 356   fds[1].events= POLLRDNORM;
 357   fds[1].revents= 0;
 358
 359   int active_fd;
 360   if ((active_fd= poll(fds, 2, 0)) == -1)
 361   {
 362     int error;
 363     switch ((error= errno))
 364     {
 365 #ifdef TARGET_OS_LINUX
 366     case ERESTART:
 367 #endif
 368     case EINTR:
 369       break;
 370
 371     case EFAULT:
 372     case ENOMEM:
 373       fatal_message(strerror(error));
 374       break;
 375
 376     case EINVAL:
 377       fatal_message("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid");
 378       break;
 379
 380     default:
 381       fatal_message(strerror(error));
 382       break;
 383     }
 384
 385     return false;
 386   }
 387
 388   if (active_fd == 0)
 389   {
 390     return false;
 391   }
 392
 393   bool data_was_read= false;
 394   if (fds[0].revents & POLLRDNORM)
 395   {
 396     if (stdout_fd.read(_stdout_buffer) == true)
 397     {
 398       data_was_read= true;
 399     }
 400   }
 401
 402   if (fds[1].revents & POLLRDNORM)
 403   {
 404     if (stderr_fd.read(_stderr_buffer) == true)
 405     {
 406       data_was_read= true;
 407     }
 408   }
 409
 410   return data_was_read;
 411 }
 412
 413 Application::error_t Application::wait(bool nohang)
 414 {
 415   if (_pid == -1)
 416   {
 417     return Application::INVALID;
 418   }
 419
 420   slurp();
 421
 422   error_t exit_code= FAILURE;
 423   {
 424     int status= 0;
 425     pid_t waited_pid;
 426     if ((waited_pid= waitpid(_pid, &status, nohang ? WNOHANG : 0)) == -1)
 427     {
 428       switch (errno)
 429       {
 430       case ECHILD:
 431         exit_code= Application::SUCCESS;
 432         break;
 433
 434       case EINTR:
 435         break;
 436
 437       default:
 438         Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid);
 439         break;
 440       }
 441     }
 442     else if (waited_pid == 0)
 443     {
 444       exit_code= Application::SUCCESS;
 445     }
 446     else
 447     {
 448       if (waited_pid != _pid)
 449       {
 450         throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Pid mismatch, %d != %d", int(waited_pid), int(_pid));
 451       }
 452       exit_code= int_to_error_t(exited_successfully(status));
 453     }
 454   }
 455
 456   slurp();
 457
 458 #if 0
 459   if (exit_code == Application::INVALID)
 460   {
 461     Error << print_argv(built_argv, _argc);
 462     /
 463   }
 464 #endif
 465
 466   return exit_code;
 467 }
 468
 469 Application::error_t Application::join()
 470 {
 471   if (_pid == -1)
 472   {
 473     return Application::INVALID;
 474   }
 475
 476   slurp();
 477
 478   error_t exit_code= FAILURE;
 479   {
 480     int status= 0;
 481     pid_t waited_pid;
 482     do {
 483       waited_pid= waitpid(_pid, &status, 0);
 484     } while (waited_pid == -1 and (errno == EINTR or errno == EAGAIN));
 485
 486     if (waited_pid == -1)
 487     {
 488       switch (errno)
 489       {
 490       case ECHILD:
 491         exit_code= Application::SUCCESS;
 492         break;
 493
 494       case EINTR:
 495         break;
 496
 497       default:
 498         Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid);
 499         break;
 500       }
 501     }
 502     else if (waited_pid == 0)
 503     {
 504       exit_code= Application::SUCCESS;
 505     }
 506     else
 507     {
 508       if (waited_pid != _pid)
 509       {
 510         throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Pid mismatch, %d != %d", int(waited_pid), int(_pid));
 511       }
 512
 513       exit_code= int_to_error_t(exited_successfully(status));
 514     }
 515   }
 516
 517   slurp();
 518
 519   if (exit_code == Application::INVALID)
 520   {
 521     Error << print_argv(built_argv);
 522   }
 523 ;
 524   return exit_code;
 525 }
 526
 527 void Application::add_long_option(const std::string& name, const std::string& option_value)
 528 {
 529   std::string arg(name);
 530   arg+= option_value;
 531   _options.push_back(std::make_pair(arg, std::string()));
 532 }
 533
 534 void Application::add_option(const std::string& arg)
 535 {
 536   _options.push_back(std::make_pair(arg, std::string()));
 537 }
 538
 539 void Application::add_option(const std::string& name, const std::string& value)
 540 {
 541   _options.push_back(std::make_pair(name, value));
 542 }
 543
 544 Application::Pipe::Pipe(int arg) :
 545   _std_fd(arg)
 546 {
 547   _pipe_fd[READ]= -1;
 548   _pipe_fd[WRITE]= -1;
 549   _open[READ]= false;
 550   _open[WRITE]= false;
 551 }
 552
 553 int Application::Pipe::Pipe::fd()
 554 {
 555   if (_std_fd == STDOUT_FILENO)
 556   {
 557     return _pipe_fd[READ];
 558   }
 559   else if (_std_fd == STDERR_FILENO)
 560   {
 561     return _pipe_fd[READ];
 562   }
 563
 564   return _pipe_fd[WRITE]; // STDIN_FILENO
 565 }
 566
 567
 568 bool Application::Pipe::read(libtest::vchar_t& arg)
 569 {
 570   fatal_assert(_std_fd == STDOUT_FILENO or _std_fd == STDERR_FILENO);
 571
 572   bool data_was_read= false;
 573
 574   ssize_t read_length;
 575   char buffer[1024]= { 0 };
 576   while ((read_length= ::read(_pipe_fd[READ], buffer, sizeof(buffer))))
 577   {
 578     if (read_length == -1)
 579     {
 580       switch(errno)
 581       {
 582       case EAGAIN:
 583         break;
 584
 585       default:
 586         Error << strerror(errno);
 587         break;
 588       }
 589
 590       break;
 591     }
 592
 593     data_was_read= true;
 594     arg.reserve(read_length +1);
 595     for (size_t x= 0; x < size_t(read_length); ++x)
 596     {
 597       arg.push_back(buffer[x]);
 598     }
 599     // @todo Suck up all errput code here
 600   }
 601
 602   return data_was_read;
 603 }
 604
 605 void Application::Pipe::nonblock()
 606 {
 607   int ret;
 608   if ((ret= fcntl(_pipe_fd[READ], F_GETFL, 0)) == -1)
 609   {
 610     Error << "fcntl(F_GETFL) " << strerror(errno);
 611     throw strerror(errno);
 612   }
 613
 614   if ((ret= fcntl(_pipe_fd[READ], F_SETFL, ret | O_NONBLOCK)) == -1)
 615   {
 616     Error << "fcntl(F_SETFL) " << strerror(errno);
 617     throw strerror(errno);
 618   }
 619 }
 620
 621 void Application::Pipe::reset()
 622 {
 623   close(READ);
 624   close(WRITE);
 625
 626 #if HAVE_PIPE2
 627   if (pipe2(_pipe_fd, O_NONBLOCK) == -1)
 628 #else
 629   if (pipe(_pipe_fd) == -1)
 630 #endif
 631   {
 632     fatal_message(strerror(errno));
 633   }
 634   _open[0]= true;
 635   _open[1]= true;
 636
 637   if (true)
 638   {
 639     nonblock();
 640     cloexec();
 641   }
 642 }
 643
 644 void Application::Pipe::cloexec()
 645 {
 646   int ret;
 647   if ((ret= fcntl(_pipe_fd[WRITE], F_GETFD, 0)) == -1)
 648   {
 649     Error << "fcntl(F_GETFD) " << strerror(errno);
 650     throw strerror(errno);
 651   }
 652
 653   if ((ret= fcntl(_pipe_fd[WRITE], F_SETFD, ret | FD_CLOEXEC)) == -1)
 654   {
 655     Error << "fcntl(F_SETFD) " << strerror(errno);
 656     throw strerror(errno);
 657   }
 658 }
 659
 660 Application::Pipe::~Pipe()
 661 {
 662   if (_pipe_fd[0] != -1)
 663   {
 664     ::close(_pipe_fd[0]);
 665   }
 666
 667   if (_pipe_fd[1] != -1)
 668   {
 669     ::close(_pipe_fd[1]);
 670   }
 671 }
 672
 673 void Application::Pipe::dup_for_spawn(posix_spawn_file_actions_t& file_actions)
 674 {
 675   int type= STDIN_FILENO == _std_fd ? 0 : 1;
 676
 677   int ret;
 678   if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _pipe_fd[type], _std_fd )) < 0)
 679   {
 680     Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
 681     fatal_message(strerror(ret));
 682   }
 683
 684   if ((ret= posix_spawn_file_actions_addclose(&file_actions, _pipe_fd[type])) < 0)
 685   {
 686     Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
 687     fatal_message(strerror(ret));
 688   }
 689 }
 690
 691 void Application::Pipe::close(const close_t& arg)
 692 {
 693   int type= int(arg);
 694
 695   if (_open[type])
 696   {
 697     if (::close(_pipe_fd[type]) == -1)
 698     {
 699       Error << "close(" << strerror(errno) << ")";
 700     }
 701     _open[type]= false;
 702     _pipe_fd[type]= -1;
 703   }
 704 }
 705
 706 void Application::create_argv(const char *args[])
 707 {
 708   delete_argv();
 709   if (_use_libtool)
 710   {
 711     assert(libtool());
 712     built_argv.push_back(strdup(libtool()));
 713     built_argv.push_back(strdup("--mode=execute"));
 714   }
 715
 716   if (_use_valgrind)
 717   {
 718     /*
 719       valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
 720     */
 721     built_argv.push_back(strdup("valgrind"));
 722     built_argv.push_back(strdup("--error-exitcode=1"));
 723     built_argv.push_back(strdup("--leak-check=yes"));
 724     built_argv.push_back(strdup("--show-reachable=yes"));
 725     built_argv.push_back(strdup("--track-fds=yes"));
 726 #if 0
 727     built_argv[x++]= strdup("--track-origin=yes");
 728 #endif
 729     built_argv.push_back(strdup("--malloc-fill=A5"));
 730     built_argv.push_back(strdup("--free-fill=DE"));
 731
 732     std::string log_file= create_tmpfile("valgrind");
 733     char buffer[1024];
 734     int length= snprintf(buffer, sizeof(buffer), "--log-file=%s", log_file.c_str());
 735     fatal_assert(length > 0 and size_t(length) < sizeof(buffer));
 736     built_argv.push_back(strdup(buffer));
 737   }
 738   else if (_use_ptrcheck)
 739   {
 740     /*
 741       valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file=
 742     */
 743     built_argv.push_back(strdup("valgrind"));
 744     built_argv.push_back(strdup("--error-exitcode=1"));
 745     built_argv.push_back(strdup("--tool=exp-ptrcheck"));
 746     std::string log_file= create_tmpfile("ptrcheck");
 747     char buffer[1024];
 748     int length= snprintf(buffer, sizeof(buffer), "--log-file=%s", log_file.c_str());
 749     fatal_assert(length > 0 and size_t(length) < sizeof(buffer));
 750     built_argv.push_back(strdup(buffer));
 751   }
 752   else if (_use_gdb)
 753   {
 754     built_argv.push_back(strdup("gdb"));
 755   }
 756
 757   built_argv.push_back(strdup(_exectuble_with_path.c_str()));
 758
 759   for (Options::const_iterator iter= _options.begin(); iter != _options.end(); ++iter)
 760   {
 761     built_argv.push_back(strdup((*iter).first.c_str()));
 762     if ((*iter).second.empty() == false)
 763     {
 764       built_argv.push_back(strdup((*iter).second.c_str()));
 765     }
 766   }
 767
 768   if (args)
 769   {
 770     for (const char **ptr= args; *ptr; ++ptr)
 771     {
 772       built_argv.push_back(strdup(*ptr));
 773     }
 774   }
 775   built_argv.push_back(NULL);
 776 }
 777
 778 std::string Application::print()
 779 {
 780   return print_argv(built_argv);
 781 }
 782
 783 std::string Application::arguments()
 784 {
 785   std::stringstream arg_buffer;
 786
 787   for (size_t x= (1 +_use_libtool) ? 2 : 0;
 788        x < _argc and built_argv[x];
 789        ++x)
 790   {
 791     arg_buffer << built_argv[x] << " ";
 792   }
 793
 794   return arg_buffer.str();
 795 }
 796
 797 struct DeleteFromVector
 798 {
 799   template <class T>
 800     void operator() ( T* ptr) const
 801     {
 802       free(ptr);
 803     }
 804 };
 805
 806 void Application::delete_argv()
 807 {
 808   std::for_each(built_argv.begin(), built_argv.end(), DeleteFromVector());
 809
 810   built_argv.clear();
 811   _argc= 0;
 812 }
 813
 814
 815 int exec_cmdline(const std::string& command, const char *args[], bool use_libtool)
 816 {
 817   Application app(command, use_libtool);
 818
 819   Application::error_t ret= app.run(args);
 820
 821   if (ret != Application::SUCCESS)
 822   {
 823     return int(ret);
 824   }
 825
 826   return int(app.join());
 827 }
 828
 829 const char *gearmand_binary()
 830 {
 831   return GEARMAND_BINARY;
 832 }
 833
 834 const char *drizzled_binary()
 835 {
 836   return DRIZZLED_BINARY;
 837 }
 838
 839 } // namespace exec_cmdline