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

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  libtest
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *
   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.
  11  *
  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.
  16  *
  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
  20  */
  21
  22 #include <libtest/common.h>
  23
  24 using namespace libtest;
  25
  26 #include <cstdlib>
  27 #include <cstring>
  28 #include <fcntl.h>
  29 #include <fstream>
  30 #include <memory>
  31 #include <spawn.h>
  32 #include <sstream>
  33 #include <string>
  34 #include <sys/stat.h>
  35 #include <sys/types.h>
  36
  37 extern "C" {
  38   static int exited_successfully(int status)
  39   {
  40     if (status == 0)
  41     {
  42       return EXIT_SUCCESS;
  43     }
  44
  45     if (WIFEXITED(status) == true)
  46     {
  47       return WEXITSTATUS(status);
  48     }
  49     else if (WIFSIGNALED(status) == true)
  50     {
  51       return WTERMSIG(status);
  52     }
  53
  54     return EXIT_FAILURE;
  55   }
  56 }
  57
  58 namespace {
  59
  60   std::string print_argv(char * * & built_argv, const size_t& argc)
  61   {
  62     std::stringstream arg_buffer;
  63
  64     for (size_t x= 0; x < argc; x++)
  65     {
  66       arg_buffer << built_argv[x] << " ";
  67     }
  68
  69     return arg_buffer.str();
  70   }
  71
  72   std::string print_argv(char** argv)
  73   {
  74     std::stringstream arg_buffer;
  75
  76     for (char** ptr= argv; *ptr; ptr++)
  77     {
  78       arg_buffer << *ptr << " ";
  79     }
  80
  81     return arg_buffer.str();
  82   }
  83
  84   static Application::error_t int_to_error_t(int arg)
  85   {
  86     switch (arg)
  87     {
  88     case 127:
  89       return Application::INVALID;
  90
  91     case 0:
  92       return Application::SUCCESS;
  93
  94     default:
  95     case 1:
  96       return Application::FAILURE;
  97     }
  98   }
  99 }
 100
 101 namespace libtest {
 102
 103 Application::Application(const std::string& arg, const bool _use_libtool_arg) :
 104   _use_libtool(_use_libtool_arg),
 105   _use_valgrind(false),
 106   _use_gdb(false),
 107   _argc(0),
 108   _exectuble(arg),
 109   built_argv(NULL),
 110   _pid(-1)
 111   {
 112     if (_use_libtool)
 113     {
 114       if (libtool() == NULL)
 115       {
 116         throw "libtool requested, but know libtool was found";
 117       }
 118     }
 119
 120     // Find just the name of the application with no path
 121     {
 122       size_t found= arg.find_last_of("/\\");
 123       if (found)
 124       {
 125         _exectuble_name= arg.substr(found +1);
 126       }
 127       else
 128       {
 129         _exectuble_name= arg;
 130       }
 131     }
 132
 133     if (_use_libtool and getenv("PWD"))
 134     {
 135       _exectuble_with_path+= getenv("PWD");
 136       _exectuble_with_path+= "/";
 137     }
 138     _exectuble_with_path+= _exectuble;
 139   }
 140
 141 Application::~Application()
 142 {
 143   delete_argv();
 144 }
 145
 146 Application::error_t Application::run(const char *args[])
 147 {
 148   stdin_fd.reset();
 149   stdout_fd.reset();
 150   stderr_fd.reset();
 151   _stdout_buffer.clear();
 152   _stderr_buffer.clear();
 153
 154   posix_spawn_file_actions_t file_actions;
 155   posix_spawn_file_actions_init(&file_actions);
 156
 157   stdin_fd.dup_for_spawn(Application::Pipe::READ, file_actions, STDIN_FILENO);
 158   stdout_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions, STDOUT_FILENO);
 159   stderr_fd.dup_for_spawn(Application::Pipe::WRITE, file_actions, STDERR_FILENO);
 160
 161   create_argv(args);
 162
 163   int spawn_ret;
 164   if (_use_gdb)
 165   {
 166     std::string gdb_run_file= create_tmpfile(_exectuble_name);
 167     std::fstream file_stream;
 168     file_stream.open(gdb_run_file.c_str(), std::fstream::out | std::fstream::trunc);
 169
 170     _gdb_filename= create_tmpfile(_exectuble_name);
 171     file_stream
 172       << "set logging redirect on" << std::endl
 173       << "set logging file " << _gdb_filename << std::endl
 174       << "set logging overwrite on" << std::endl
 175       << "set logging on" << std::endl
 176       << "set environment LIBTEST_IN_GDB=1" << std::endl
 177       << "run " << arguments() << std::endl
 178       << "thread apply all bt" << std::endl
 179       << "quit" << std::endl;
 180
 181     fatal_assert(file_stream.good());
 182     file_stream.close();
 183
 184     if (_use_libtool)
 185     {
 186       // libtool --mode=execute gdb -f -x binary
 187       char *argv[]= {
 188         const_cast<char *>(libtool()),
 189         const_cast<char *>("--mode=execute"),
 190         const_cast<char *>("gdb"),
 191         const_cast<char *>("-batch"),
 192         const_cast<char *>("-f"),
 193         const_cast<char *>("-x"),
 194         const_cast<char *>(gdb_run_file.c_str()),
 195         const_cast<char *>(_exectuble_with_path.c_str()),
 196         0};
 197
 198       spawn_ret= posix_spawnp(&_pid, libtool(), &file_actions, NULL, argv, NULL);
 199     }
 200     else
 201     {
 202       // gdb binary
 203       char *argv[]= {
 204         const_cast<char *>("gdb"),
 205         const_cast<char *>("-batch"),
 206         const_cast<char *>("-f"),
 207         const_cast<char *>("-x"),
 208         const_cast<char *>(gdb_run_file.c_str()),
 209         const_cast<char *>(_exectuble_with_path.c_str()),
 210         0};
 211       spawn_ret= posix_spawnp(&_pid, "gdb", &file_actions, NULL, argv, NULL);
 212     }
 213   }
 214   else
 215   {
 216     if (_use_libtool)
 217     {
 218       spawn_ret= posix_spawn(&_pid, built_argv[0], &file_actions, NULL, built_argv, NULL);
 219     }
 220     else
 221     {
 222       spawn_ret= posix_spawnp(&_pid, built_argv[0], &file_actions, NULL, built_argv, NULL);
 223     }
 224   }
 225
 226   posix_spawn_file_actions_destroy(&file_actions);
 227
 228   stdin_fd.close(Application::Pipe::READ);
 229   stdout_fd.close(Application::Pipe::WRITE);
 230   stderr_fd.close(Application::Pipe::WRITE);
 231
 232   if (spawn_ret)
 233   {
 234     Error << print();
 235     return Application::INVALID;
 236   }
 237
 238   return Application::SUCCESS;
 239 }
 240
 241 Application::error_t Application::wait()
 242 {
 243   if (_pid == -1)
 244   {
 245     Error << "wait() got an invalid pid_t";
 246     return Application::INVALID;
 247   }
 248
 249   {
 250     ssize_t read_length;
 251     char buffer[1024]= { 0 };
 252     bool bail= false;
 253     while (((read_length= ::read(stdout_fd.fd()[0], buffer, sizeof(buffer))) != 0) or bail)
 254     {
 255       if (read_length == -1)
 256       {
 257         switch(errno)
 258         {
 259         case EAGAIN:
 260           continue;
 261
 262         default:
 263           Error << strerror(errno);
 264           bail= true;
 265         }
 266       }
 267       _stdout_buffer.reserve(read_length +1);
 268       for (size_t x= 0; x < read_length; x++)
 269       {
 270         _stdout_buffer.push_back(buffer[x]);
 271       }
 272       // @todo Suck up all output code here
 273     }
 274   }
 275
 276   {
 277     ssize_t read_length;
 278     char buffer[1024]= { 0 };
 279     bool bail= false;
 280     while (((read_length= ::read(stderr_fd.fd()[0], buffer, sizeof(buffer))) != 0) or bail)
 281     {
 282       if (read_length == -1)
 283       {
 284         switch(errno)
 285         {
 286         case EAGAIN:
 287           continue;
 288
 289         default:
 290           Error << strerror(errno);
 291           bail= true;
 292         }
 293       }
 294       _stderr_buffer.reserve(read_length +1);
 295       for (size_t x= 0; x < read_length; x++)
 296       {
 297         _stderr_buffer.push_back(buffer[x]);
 298       }
 299       // @todo Suck up all errput code here
 300     }
 301   }
 302
 303   error_t exit_code= FAILURE;
 304   {
 305     int status= 0;
 306     pid_t waited_pid;
 307     if ((waited_pid= waitpid(_pid, &status, 0)) == -1)
 308     {
 309       Error << "Error occured while waitpid(" << strerror(errno) << ") on pid " << int(_pid);
 310     }
 311     else
 312     {
 313       if (waited_pid != _pid)
 314       {
 315         throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "Pid mismatch, %d != %d", int(waited_pid), int(_pid));
 316       }
 317       exit_code= int_to_error_t(exited_successfully(status));
 318     }
 319   }
 320
 321 #if 0
 322   if (exit_code == Application::INVALID)
 323   {
 324     Error << print_argv(built_argv, _argc);
 325   }
 326 #endif
 327
 328   return exit_code;
 329 }
 330
 331 void Application::add_option(const std::string& arg)
 332 {
 333   _options.push_back(std::make_pair(arg, std::string()));
 334 }
 335
 336 void Application::add_option(const std::string& name, const std::string& value)
 337 {
 338   _options.push_back(std::make_pair(name, value));
 339 }
 340
 341 Application::Pipe::Pipe()
 342 {
 343   _fd[0]= -1;
 344   _fd[1]= -1;
 345   _open[0]= false;
 346   _open[1]= false;
 347 }
 348
 349 void Application::Pipe::reset()
 350 {
 351   close(READ);
 352   close(WRITE);
 353
 354   int ret;
 355   if ((ret= pipe(_fd)) < 0)
 356   {
 357     throw strerror(ret);
 358   }
 359   _open[0]= true;
 360   _open[1]= true;
 361
 362   {
 363     ret= fcntl(_fd[0], F_GETFL, 0);
 364     if (ret == -1)
 365     {
 366       Error << "fcntl(F_GETFL) " << strerror(ret);
 367       throw strerror(ret);
 368     }
 369
 370     ret= fcntl(_fd[0], F_SETFL, ret | O_NONBLOCK);
 371     if (ret == -1)
 372     {
 373       Error << "fcntl(F_SETFL) " << strerror(ret);
 374       throw strerror(ret);
 375     }
 376   }
 377 }
 378
 379 Application::Pipe::~Pipe()
 380 {
 381   close(READ);
 382   close(WRITE);
 383 }
 384
 385 void Application::Pipe::dup_for_spawn(const close_t& arg, posix_spawn_file_actions_t& file_actions, const int newfildes)
 386 {
 387   int type= int(arg);
 388
 389   int ret;
 390   if ((ret= posix_spawn_file_actions_adddup2(&file_actions, _fd[type], newfildes )) < 0)
 391   {
 392     Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
 393     throw strerror(ret);
 394   }
 395
 396   if ((ret= posix_spawn_file_actions_addclose(&file_actions, _fd[type])) < 0)
 397   {
 398     Error << "posix_spawn_file_actions_adddup2(" << strerror(ret) << ")";
 399     throw strerror(ret);
 400   }
 401 }
 402
 403 void Application::Pipe::close(const close_t& arg)
 404 {
 405   int type= int(arg);
 406
 407   if (_open[type])
 408   {
 409     int ret;
 410     if ((ret= ::close(_fd[type])) < 0)
 411     {
 412       Error << "close(" << strerror(ret) << ")";
 413     }
 414     _open[type]= false;
 415   }
 416 }
 417
 418 void Application::create_argv(const char *args[])
 419 {
 420   _argc= 2 +_use_libtool ? 2 : 0; // +1 for the command, +2 for libtool/mode=execute, +1 for the NULL
 421
 422   if (_use_libtool)
 423   {
 424     _argc+= 2; // +2 for libtool --mode=execute
 425   }
 426
 427   /*
 428     valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
 429   */
 430   if (_use_valgrind)
 431   {
 432     _argc+= 7;
 433   }
 434   else if (_use_gdb) // gdb
 435   {
 436     _argc+= 1;
 437   }
 438
 439   for (Options::const_iterator iter= _options.begin(); iter != _options.end(); iter++)
 440   {
 441     _argc++;
 442     if ((*iter).second.empty() == false)
 443     {
 444       _argc++;
 445     }
 446   }
 447
 448   if (args)
 449   {
 450     for (const char **ptr= args; *ptr; ++ptr)
 451     {
 452       _argc++;
 453     }
 454   }
 455
 456   delete_argv();
 457   built_argv= new char * [_argc];
 458
 459   size_t x= 0;
 460   if (_use_libtool)
 461   {
 462     assert(libtool());
 463     built_argv[x++]= strdup(libtool());
 464     built_argv[x++]= strdup("--mode=execute");
 465   }
 466
 467   if (_use_valgrind)
 468   {
 469     /*
 470       valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
 471     */
 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");
 479   }
 480   else if (_use_gdb)
 481   {
 482     built_argv[x++]= strdup("gdb");
 483   }
 484
 485   built_argv[x++]= strdup(_exectuble_with_path.c_str());
 486
 487   for (Options::const_iterator iter= _options.begin(); iter != _options.end(); iter++)
 488   {
 489     built_argv[x++]= strdup((*iter).first.c_str());
 490     if ((*iter).second.empty() == false)
 491     {
 492       built_argv[x++]= strdup((*iter).second.c_str());
 493     }
 494   }
 495
 496   if (args)
 497   {
 498     for (const char **ptr= args; *ptr; ++ptr)
 499     {
 500       built_argv[x++]= strdup(*ptr);
 501     }
 502   }
 503   built_argv[_argc -1]= NULL;
 504 }
 505
 506 std::string Application::print()
 507 {
 508   return print_argv(built_argv, _argc);
 509 }
 510
 511 std::string Application::arguments()
 512 {
 513   std::stringstream arg_buffer;
 514
 515   for (size_t x= 1 + _use_libtool ? 2 : 0;
 516        x < _argc and built_argv[x];
 517        x++)
 518   {
 519     arg_buffer << built_argv[x] << " ";
 520   }
 521
 522   return arg_buffer.str();
 523 }
 524
 525 void Application::delete_argv()
 526 {
 527   if (built_argv == NULL)
 528   {
 529     return;
 530   }
 531
 532   for (size_t x= 0; x < _argc; x++)
 533   {
 534     if (built_argv[x])
 535     {
 536       ::free(built_argv[x]);
 537     }
 538   }
 539   delete[] built_argv;
 540   built_argv= NULL;
 541   _argc= 0;
 542 }
 543
 544
 545 int exec_cmdline(const std::string& command, const char *args[], bool use_libtool)
 546 {
 547   Application app(command, use_libtool);
 548
 549   Application::error_t ret= app.run(args);
 550
 551   if (ret != Application::SUCCESS)
 552   {
 553     return int(ret);
 554   }
 555
 556   return int(app.wait());
 557 }
 558
 559 const char *gearmand_binary()
 560 {
 561   return GEARMAND_BINARY;
 562 }
 563
 564 } // namespace exec_cmdline