Inside Bitcoin

501   *    pair.first : Return code of the waitpid call.
502   *    pair.second : Exit status of the process.
503   *
504   *  NOTE: This is a blocking call as in, it will loop
505   *  till the child is exited.
506   */
507  static inline
508  std::pair<int, int> wait_for_child_exit(int pid)
509  {
510    int status = 0;
511    int ret = -1;
512    while (1) {
513      ret = waitpid(pid, &status, 0);
514      if (ret == -1) break;
515      if (ret == 0) continue;
516      return std::make_pair(ret, status);
517    }
518
519    return std::make_pair(ret, status);
520  }
521#endif
522
523} // end namespace util
524
525
526
527/* -------------------------------
528 *     Popen Arguments
529 * -------------------------------
530 */
531
532/*!
533 * Base class for all arguments involving string value.
534 */
535struct string_arg
536{
537  string_arg(const char* arg): arg_value(arg) {}
538  string_arg(std::string&& arg): arg_value(std::move(arg)) {}
539  string_arg(const std::string& arg): arg_value(arg) {}
540  std::string arg_value;
541};
542
543/*!
544 * Option to specify the executable name separately
545 * from the args sequence.
546 * In this case the cmd args must only contain the
547 * options required for this executable.
548 *
549 * Eg: executable{"ls"}
550 */
551struct executable: string_arg
552{
553  template <typename T>
554  executable(T&& arg): string_arg(std::forward<T>(arg)) {}
555};
556
557/*!
558 * Used for redirecting input/output/error
559 */
560enum IOTYPE {
561  STDOUT = 1,
562  STDERR,
563  PIPE,
564};
565
566//TODO: A common base/interface for below stream structures ??
567
568/*!
569 * Option to specify the input channel for the child
570 * process. It can be:
571 * 1. An already open file descriptor.
572 * 2. A file name.
573 * 3. IOTYPE. Usual a PIPE
574 *
575 * Eg: input{PIPE}
576 * OR in case of redirection, output of another Popen
577 * input{popen.output()}
578 */
579struct input
580{
581  // For an already existing file descriptor.
582  explicit input(int fd): rd_ch_(fd) {}
583
584  // FILE pointer.
585  explicit input (FILE* fp):input(subprocess_fileno(fp)) { assert(fp); }
586
587  explicit input(const char* filename) {
588    int fd = subprocess_open(filename, O_RDONLY);
589    if (fd == -1) throw OSError("File not found: ", errno);
590    rd_ch_ = fd;
591  }
592  explicit input(IOTYPE typ) {
593    assert (typ == PIPE && "STDOUT/STDERR not allowed");
594#ifndef WIN32
595    std::tie(rd_ch_, wr_ch_) = util::pipe_cloexec();
596#endif
597  }
598
599  int rd_ch_ = -1;
600  int wr_ch_ = -1;
601};
602
603
604/*!
605 * Option to specify the output channel for the child
606 * process. It can be:
607 * 1. An already open file descriptor.
608 * 2. A file name.
609 * 3. IOTYPE. Usually a PIPE.
610 *
611 * Eg: output{PIPE}
612 * OR output{"output.txt"}
613 */
614struct output
615{
616  explicit output(int fd): wr_ch_(fd) {}
617
618  explicit output (FILE* fp):output(subprocess_fileno(fp)) { assert(fp); }
619
620  explicit output(const char* filename) {
621    int fd = subprocess_open(filename, O_APPEND | O_CREAT | O_RDWR, 0640);
622    if (fd == -1) throw OSError("File not found: ", errno);
623    wr_ch_ = fd;
624  }
625  explicit output(IOTYPE typ) {
626    assert (typ == PIPE && "STDOUT/STDERR not allowed");
627#ifndef WIN32
628    std::tie(rd_ch_, wr_ch_) = util::pipe_cloexec();
629#endif
630  }
631
632  int rd_ch_ = -1;
633  int wr_ch_ = -1;
634};
635
636
637/*!
638 * Option to specify the error channel for the child
639 * process. It can be:
640 * 1. An already open file descriptor.
641 * 2. A file name.
642 * 3. IOTYPE. Usually a PIPE or STDOUT
643 *
644 */
645struct error
646{
647  explicit error(int fd): wr_ch_(fd) {}
648
649  explicit error(FILE* fp):error(subprocess_fileno(fp)) { assert(fp); }
650
651  explicit error(const char* filename) {
652    int fd = subprocess_open(filename, O_APPEND | O_CREAT | O_RDWR, 0640);
653    if (fd == -1) throw OSError("File not found: ", errno);
654    wr_ch_ = fd;
655  }
656  explicit error(IOTYPE typ) {
657    assert ((typ == PIPE || typ == STDOUT) && "STDERR not allowed");
658    if (typ == PIPE) {
659#ifndef WIN32
660      std::tie(rd_ch_, wr_ch_) = util::pipe_cloexec();
661#endif
662    } else {
663      // Need to defer it till we have checked all arguments
664      deferred_ = true;
665    }
666  }
667
668  bool deferred_ = false;
669  int rd_ch_ = -1;
670  int wr_ch_ = -1;
671};
672
673// ~~~~ End Popen Args ~~~~
674
675
676/*!
677 * class: Buffer
678 * This class is a very thin wrapper around std::vector<char>
679 * This is basically used to determine the length of the actual
680 * data stored inside the dynamically resized vector.
681 *
682 * This is what is returned as the output to the communicate
683 * function, so, users must know about this class.
684 *
685 * OutBuffer and ErrBuffer are just different typedefs to this class.
686 */
687class Buffer
688{
689public:
690  Buffer() = default;
691  explicit Buffer(size_t cap) { buf.resize(cap); }
692  void add_cap(size_t cap) { buf.resize(cap); }
693
694public:
695  std::vector<char> buf;
696  size_t length = 0;
697};
698
699// Buffer for storing output written to output fd
700using OutBuffer = Buffer;
701// Buffer for storing output written to error fd
702using ErrBuffer = Buffer;
703
704
705// Fwd Decl.
706class Popen;
707
708/*---------------------------------------------------
709 *      DETAIL NAMESPACE
710 *---------------------------------------------------
711 */
712
713namespace detail {
714/*!
715 * A helper class to Popen class for setting
716 * options as provided in the Popen constructor.
717 * This design allows us to _not_ have any fixed position
718 * to any arguments and specify them in a way similar to what
719 * can be done in python.
720 */
721struct ArgumentDeducer
722{
723  ArgumentDeducer(Popen* p): popen_(p) {}
724
725  void set_option(executable&& exe);
726  void set_option(input&& inp);
727  void set_option(output&& out);
728  void set_option(error&& err);
729
730private:
731  Popen* popen_ = nullptr;
732};
733
734#ifndef WIN32
735/*!
736 * A helper class to Popen.
737 * This takes care of all the fork-exec logic
738 * in the execute_child API.
739 */
740class Child
741{
742public:
743  Child(Popen* p, int err_wr_pipe):
744    parent_(p),
745    err_wr_pipe_(err_wr_pipe)
746  {}
747
748  void execute_child();
749
750private: