pipe.h

Go to the documentation of this file.

#ifndef CVMFS_UTIL_PIPE_H_
#define CVMFS_UTIL_PIPE_H_

#include <sys/types.h>
#include <unistd.h>

#include <cerrno>

#include "exception.h"
#include "gtest/gtest_prod.h"
#include "util/export.h"
#include "util/single_copy.h"

#ifdef CVMFS_NAMESPACE_GUARD
namespace CVMFS_NAMESPACE_GUARD {
#endif

enum PipeType {
  kPipeThreadTerminator = 0,  // pipe only used to signal a thread to stop
  kPipeWatchdog,
  kPipeWatchdogSupervisor,
  kPipeWatchdogPid,
  kPipeDetachedChild,
  kPipeTest,
  kPipeDownloadJobs,
  kPipeDownloadJobsResults
};

enum PipeSignals {
  kPipeTerminateSignal = 1
};

template <PipeType pipeType>
class CVMFS_EXPORT Pipe : public SingleCopy {
  FRIEND_TEST(T_Util, ManagedExecRunShell);
  FRIEND_TEST(T_Util, ManagedExecExecuteBinaryDoubleFork);
  FRIEND_TEST(T_Util, ManagedExecExecuteBinaryAsChild);

 public:
  Pipe() {
    int pipe_fd[2];
    MakePipe(pipe_fd);
    fd_read_ = pipe_fd[0];
    fd_write_ = pipe_fd[1];
  }

  ~Pipe() {
    Close();
  }

  void Close() {
    CloseReadFd();
    CloseWriteFd();
  }

  void CloseReadFd() {
    if (fd_read_ >= 0) {
      close(fd_read_);
      fd_read_ = -1;
    }
  }

  void CloseWriteFd() {
    if (fd_write_  >= 0) {
      close(fd_write_);
      fd_write_ = -1;
    }
  }

  template<typename T>
  bool TryWrite(const T &data) {
    const int num_bytes = write(fd_write_, &data, sizeof(T));
    return (num_bytes >= 0) && (static_cast<size_t>(num_bytes) == sizeof(T));
  }

  template<typename T>
  bool Write(const T &data) {
    WritePipe(fd_write_, &data, sizeof(T));
    return true;
  }

  bool Write(const void *buf, size_t nbyte) {
    WritePipe(fd_write_, buf, nbyte);
    return true;
  }

  template<typename T>
  bool TryRead(T *data) {
    ssize_t num_bytes;
    do {
      num_bytes = read(fd_read_, data, sizeof(T));
    } while ((num_bytes < 0) && (errno == EINTR));
    return (num_bytes >= 0) && (static_cast<size_t>(num_bytes) == sizeof(T));
  }

  template<typename T>
  bool Read(T *data) {
    ReadPipe(fd_read_, data, sizeof(T));
    return true;
  }

  bool Read(void *buf, size_t nbyte) {
    ReadPipe(fd_read_, buf, nbyte);
    return true;
  }

  int GetReadFd() const {
    return fd_read_;
  }

  int GetWriteFd() const {
    return fd_write_;
  }


 private:
  int fd_read_;
  int fd_write_;

  Pipe(const int fd_read, const int fd_write) : fd_read_(fd_read),
                                                fd_write_(fd_write) {}

  void MakePipe(int pipe_fd[2]) {
    int retval = pipe(pipe_fd);
    if (retval != 0) {
      PANIC(kLogSyslogErr | kLogDebug, "MakePipe failed with errno %d", errno);
    }
  }


  void WritePipe(int fd, const void *buf, size_t nbyte) {
    ssize_t num_bytes;
    do {
      num_bytes = write(fd, buf, nbyte);
    } while ((num_bytes < 0) && (errno == EINTR));
    if (!((num_bytes >= 0) && (static_cast<size_t>(num_bytes) == nbyte))) {
      PANIC(kLogSyslogErr | kLogDebug,
                                   "WritePipe failed: expected write size %lu, "
                                   "actually written %lu, errno %d, fd %d",
                                   nbyte, num_bytes, errno, fd);
    }
  }


  void ReadPipe(int fd, void *buf, size_t nbyte) {
    ssize_t num_bytes;
    do {
      num_bytes = read(fd, buf, nbyte);
    } while ((num_bytes < 0) && (errno == EINTR));
    if (!((num_bytes >= 0) && (static_cast<size_t>(num_bytes) == nbyte))) {
      PANIC(kLogSyslogErr | kLogDebug,
                                     "ReadPipe failed: expected read size %lu, "
                                     "actually read %lu, errno %d, fd %d",
                                     nbyte, num_bytes, errno, fd);
    }
  }
};

#ifdef CVMFS_NAMESPACE_GUARD
}  // namespace CVMFS_NAMESPACE_GUARD
#endif

#endif  // CVMFS_UTIL_PIPE_H_