Inside Bitcoin

751  // Lets call it parent even though
752  // technically a bit incorrect
753  Popen* parent_ = nullptr;
754  int err_wr_pipe_ = -1;
755};
756#endif
757
758// Fwd Decl.
759class Streams;
760
761/*!
762 * A helper class to Streams.
763 * This takes care of management of communicating
764 * with the child process with the means of the correct
765 * file descriptor.
766 */
767class Communication
768{
769public:
770  Communication(Streams* stream): stream_(stream)
771  {}
772  Communication(const Communication&) = delete;
773  Communication& operator=(const Communication&) = delete;
774  Communication(Communication&&) = default;
775  Communication& operator=(Communication&&) = default;
776public:
777  int send(const char* msg, size_t length);
778  int send(const std::vector<char>& msg);
779
780  std::pair<OutBuffer, ErrBuffer> communicate(const char* msg, size_t length);
781  std::pair<OutBuffer, ErrBuffer> communicate(const std::vector<char>& msg)
782  { return communicate(msg.data(), msg.size()); }
783
784  void set_out_buf_cap(size_t cap) { out_buf_cap_ = cap; }
785  void set_err_buf_cap(size_t cap) { err_buf_cap_ = cap; }
786
787private:
788  std::pair<OutBuffer, ErrBuffer> communicate_threaded(
789      const char* msg, size_t length);
790
791private:
792  Streams* stream_;
793  size_t out_buf_cap_ = DEFAULT_BUF_CAP_BYTES;
794  size_t err_buf_cap_ = DEFAULT_BUF_CAP_BYTES;
795};
796
797
798
799/*!
800 * This is a helper class to Popen.
801 * It takes care of management of all the file descriptors
802 * and file pointers.
803 * It dispatches of the communication aspects to the
804 * Communication class.
805 * Read through the data members to understand about the
806 * various file descriptors used.
807 */
808class Streams
809{
810public:
811  Streams():comm_(this) {}
812  Streams(const Streams&) = delete;
813  Streams& operator=(const Streams&) = delete;
814  Streams(Streams&&) = default;
815  Streams& operator=(Streams&&) = default;
816
817public:
818  void setup_comm_channels();
819
820  void cleanup_fds()
821  {
822    if (write_to_child_ != -1 && read_from_parent_ != -1) {
823      subprocess_close(write_to_child_);
824    }
825    if (write_to_parent_ != -1 && read_from_child_ != -1) {
826      subprocess_close(read_from_child_);
827    }
828    if (err_write_ != -1 && err_read_ != -1) {
829      subprocess_close(err_read_);
830    }
831  }
832
833  void close_parent_fds()
834  {
835    if (write_to_child_ != -1)  subprocess_close(write_to_child_);
836    if (read_from_child_ != -1) subprocess_close(read_from_child_);
837    if (err_read_ != -1)        subprocess_close(err_read_);
838  }
839
840  void close_child_fds()
841  {
842    if (write_to_parent_ != -1)  subprocess_close(write_to_parent_);
843    if (read_from_parent_ != -1) subprocess_close(read_from_parent_);
844    if (err_write_ != -1)        subprocess_close(err_write_);
845  }
846
847  FILE* input()  { return input_.get(); }
848  FILE* output() { return output_.get(); }
849  FILE* error()  { return error_.get(); }
850
851  void input(FILE* fp)  { input_.reset(fp, fclose); }
852  void output(FILE* fp) { output_.reset(fp, fclose); }
853  void error(FILE* fp)  { error_.reset(fp, fclose); }
854
855  void set_out_buf_cap(size_t cap) { comm_.set_out_buf_cap(cap); }
856  void set_err_buf_cap(size_t cap) { comm_.set_err_buf_cap(cap); }
857
858public: /* Communication forwarding API's */
859  int send(const char* msg, size_t length)
860  { return comm_.send(msg, length); }
861
862  int send(const std::vector<char>& msg)
863  { return comm_.send(msg); }
864
865  std::pair<OutBuffer, ErrBuffer> communicate(const char* msg, size_t length)
866  { return comm_.communicate(msg, length); }
867
868  std::pair<OutBuffer, ErrBuffer> communicate(const std::vector<char>& msg)
869  { return comm_.communicate(msg); }
870
871
872public:// Yes they are public
873
874  std::shared_ptr<FILE> input_  = nullptr;
875  std::shared_ptr<FILE> output_ = nullptr;
876  std::shared_ptr<FILE> error_  = nullptr;
877
878#ifdef WIN32
879  HANDLE g_hChildStd_IN_Rd = nullptr;
880  HANDLE g_hChildStd_IN_Wr = nullptr;
881  HANDLE g_hChildStd_OUT_Rd = nullptr;
882  HANDLE g_hChildStd_OUT_Wr = nullptr;
883  HANDLE g_hChildStd_ERR_Rd = nullptr;
884  HANDLE g_hChildStd_ERR_Wr = nullptr;
885#endif
886
887  // Pipes for communicating with child
888
889  // Emulates stdin
890  int write_to_child_   = -1; // Parent owned descriptor
891  int read_from_parent_ = -1; // Child owned descriptor
892
893  // Emulates stdout
894  int write_to_parent_ = -1; // Child owned descriptor
895  int read_from_child_ = -1; // Parent owned descriptor
896
897  // Emulates stderr
898  int err_write_ = -1; // Write error to parent (Child owned)
899  int err_read_  = -1; // Read error from child (Parent owned)
900
901private:
902  Communication comm_;
903};
904
905} // end namespace detail
906
907
908
909/*!
910 * class: Popen
911 * This is the single most important class in the whole library
912 * and glues together all the helper classes to provide a common
913 * interface to the client.
914 *
915 * API's provided by the class:
916 * Popen({"cmd"}, output{..}, error{..}, ....)
917 *    Command provided as a sequence.
918 * wait()             - Wait for the child to exit.
919 * retcode()          - The return code of the exited child.
920 * send(...)          - Send input to the input channel of the child.
921 * communicate(...)   - Get the output/error from the child and close the channels
922 *                      from the parent side.
923 */
924class Popen
925{
926public:
927  friend struct detail::ArgumentDeducer;
928#ifndef WIN32
929  friend class detail::Child;
930#endif
931
932  template <typename... Args>
933  Popen(std::initializer_list<const char*> cmd_args, Args&& ...args)
934  {
935    vargs_.insert(vargs_.end(), cmd_args.begin(), cmd_args.end());
936    init_args(std::forward<Args>(args)...);
937
938    // Setup the communication channels of the Popen class
939    stream_.setup_comm_channels();
940
941    execute_process();
942  }
943
944  template <typename... Args>
945  Popen(std::vector<std::string> vargs_, Args &&... args) : vargs_(vargs_)
946  {
947    init_args(std::forward<Args>(args)...);
948
949    // Setup the communication channels of the Popen class
950    stream_.setup_comm_channels();
951
952    execute_process();
953  }
954
955  int retcode() const noexcept { return retcode_; }
956
957  int wait() noexcept(false);
958
959  void set_out_buf_cap(size_t cap) { stream_.set_out_buf_cap(cap); }
960
961  void set_err_buf_cap(size_t cap) { stream_.set_err_buf_cap(cap); }
962
963  int send(const char* msg, size_t length)
964  { return stream_.send(msg, length); }
965
966  int send(const std::string& msg)
967  { return send(msg.c_str(), msg.size()); }
968
969  int send(const std::vector<char>& msg)
970  { return stream_.send(msg); }
971
972  std::pair<OutBuffer, ErrBuffer> communicate(const char* msg, size_t length)
973  {
974    auto res = stream_.communicate(msg, length);
975    retcode_ = wait();
976    return res;
977  }
978
979  std::pair<OutBuffer, ErrBuffer> communicate(const std::string& msg)
980  {
981    return communicate(msg.c_str(), msg.size());
982  }
983
984  std::pair<OutBuffer, ErrBuffer> communicate(const std::vector<char>& msg)
985  {
986    auto res = stream_.communicate(msg);
987    retcode_ = wait();
988    return res;
989  }
990
991  std::pair<OutBuffer, ErrBuffer> communicate()
992  {
993    return communicate(nullptr, 0);
994  }
995
996private:
997  template <typename F, typename... Args>
998  void init_args(F&& farg, Args&&... args);
999  void init_args();
1000  void populate_c_argv();