Drqs 184194259 balb pipecontrolchannel configure permissions (#5932)

* balb_pipecontrolchannel: add 'permissions' to c'tor

Author: cppguru

groups/bal/balb/balb_pipecontrolchannel.cpp

@@ -5,6 +5,7 @@
 BSLS_IDENT_RCSID(balb_pipecontrolchannel_cpp,"$Id$ $CSID$")
 
 #include <bdlf_bind.h>
+#include <bdls_filepermissions.h>
 #include <bdls_filesystemutil.h>
 #include <bdls_pathutil.h>
 #include <bdls_pipeutil.h>
@@ -45,6 +46,9 @@ BSLS_IDENT_RCSID(balb_pipecontrolchannel_cpp,"$Id$ $CSID$")
 #endif
 
 namespace {
+namespace u {
+
+using namespace BloombergLP;
 
 #ifdef BSLS_PLATFORM_OS_WINDOWS
 bsl::string describeWin32Error(DWORD lastError)
@@ -63,6 +67,7 @@ bsl::string describeWin32Error(DWORD lastError)
 }
 #endif
 
+}  // close namespace u
 }  // close unnamed namespace
 
 namespace BloombergLP {
@@ -150,7 +155,7 @@ int PipeControlChannel::readNamedPipe()
     if (!ConnectNamedPipe(d_impl.d_windows.d_handle, NULL)) {
         BSLS_LOG_TRACE("Connecting to named pipe '%s': %s",
                        d_pipeName.c_str(),
-                       describeWin32Error(GetLastError()).c_str());
+                       u::describeWin32Error(GetLastError()).c_str());
 
         DWORD lastError = GetLastError();
         if (lastError != ERROR_PIPE_CONNECTED && lastError != ERROR_NO_DATA) {
@@ -204,7 +209,7 @@ int PipeControlChannel::readNamedPipe()
             if (ERROR_BROKEN_PIPE != err) {
                 BSLS_LOG_TRACE("Failed read from named pipe '%s': %s",
                                d_pipeName.c_str(),
-                               describeWin32Error(err).c_str());
+                               u::describeWin32Error(err).c_str());
             } else {
                 // The 'ERROR_BROKEN_PIPE' case simply means that the client
                 // closed the connection but did not tell us to shut down; we
@@ -254,7 +259,7 @@ PipeControlChannel::createNamedPipe(const char *pipeName)
         }
         BSLS_LOG_TRACE("Failed to create named pipe '%s': %s",
                        d_pipeName.c_str(),
-                       describeWin32Error(GetLastError()).c_str());
+                       u::describeWin32Error(GetLastError()).c_str());
         return -1;                                                    // RETURN
     }
 
@@ -469,7 +474,7 @@ PipeControlChannel::createNamedPipe(const char *pipeName)
         }
     }
 
-    int rc = mkfifo(pipeName, 0666);
+    int rc = mkfifo(pipeName, d_permissions);
     if (0 != rc) {
         int savedErrno = errno;
         BSLS_LOG_ERROR("Unable to create pipe '%s'. errno = %d (%s)",
@@ -538,6 +543,9 @@ PipeControlChannel::createNamedPipe(const char *pipeName)
 
 namespace balb {
 
+// CONSTANTS
+const int PipeControlChannel::k_DEFAULT_PERMISSIONS;
+
 // CREATORS
 PipeControlChannel::PipeControlChannel(const ControlCallback&  callback,
                                        bslma::Allocator       *basicAllocator)
@@ -548,8 +556,32 @@ PipeControlChannel::PipeControlChannel(const ControlCallback&  callback,
 , d_buffer(bslma::Default::allocator(basicAllocator))
 , d_thread(bslmt::ThreadUtil::invalidHandle())
 , d_backgroundState(e_STOPPED)
+, d_permissions(k_DEFAULT_PERMISSIONS)
+, d_isPipeOpen(false)
+{
+#ifdef BSLS_PLATFORM_OS_WINDOWS
+    d_impl.d_windows.d_handle = INVALID_HANDLE_VALUE;
+#else
+    d_impl.d_unix.d_readFd    = -1;
+    d_impl.d_unix.d_writeFd   = -1;
+#endif
+}
+
+PipeControlChannel::PipeControlChannel(const ControlCallback&  callback,
+                                       int                     permissions,
+                                       bslma::Allocator       *basicAllocator)
+: d_callback(bsl::allocator_arg_t(),
+             bsl::allocator<ControlCallback>(basicAllocator),
+             callback)
+, d_pipeName(bslma::Default::allocator(basicAllocator))
+, d_buffer(bslma::Default::allocator(basicAllocator))
+, d_thread(bslmt::ThreadUtil::invalidHandle())
+, d_backgroundState(e_STOPPED)
+, d_permissions(permissions)
 , d_isPipeOpen(false)
 {
+    BSLS_ASSERT(bdls::FilePermissions::isValidBaseBits(permissions));
+
 #ifdef BSLS_PLATFORM_OS_WINDOWS
     d_impl.d_windows.d_handle = INVALID_HANDLE_VALUE;
 #else
@@ -565,6 +597,14 @@ PipeControlChannel::~PipeControlChannel()
 }
 
 // MANIPULATORS
+void PipeControlChannel::setPermissions(int permissions)
+{
+    BSLS_ASSERT(e_STOPPED == d_backgroundState);
+    BSLS_ASSERT(bdls::FilePermissions::isValidBaseBits(permissions));
+
+    d_permissions = permissions;
+}
+
 void PipeControlChannel::backgroundProcessor()
 {
     while (d_backgroundState == e_RUNNING) {

groups/bal/balb/balb_pipecontrolchannel.h

@@ -65,6 +65,27 @@ BSLS_IDENT("$Id: $")
 // each message.  This trailing newline is stripped from the message before
 // the message is passed to the control callback.
 //
+///Pipe Permissions
+///----------------
+// This component creates its underlying named pipe with a permission bit
+// mask that defaults to `k_DEFAULT_PERMISSIONS` (`0666`, i.e., read and write
+// for owner, group, and others).  A different permission bit mask may be
+// supplied at construction time via the constructor overload taking an
+// `int permissions` argument, or may be changed after construction (but before
+// `start`) by calling `setPermissions`.  The bit-mask semantics follow the
+// conventional Unix mode-bit layout enumerated by `bdls::FilePermissions`;
+// callers may express the desired permissions either as an octal literal
+// (e.g., `0640`) or by OR-ing together `bdls::FilePermissions` enumerators
+// (e.g., `bdls::FilePermissions::k_OWNER_READ | ...`).  Only the nine
+// owner/group/others read/write/execute bits are accepted (see
+// `bdls::FilePermissions::isValidBaseBits`); `k_SET_UID`, `k_SET_GID`, and
+// `k_STICKY_BIT` are not meaningful for a control pipe and result in
+// undefined behavior.
+//
+// On operating systems that do not support Unix-style permission bits
+// (notably Windows) the requested permission bit mask is silently ignored
+// and the pipe is created with the operating-system default permissions.
+//
 ///Platform-Specific Pipe Name Encoding Caveats
 ///--------------------------------------------
 // Pipe-name encodings have the following caveats for the following operating
@@ -209,6 +230,8 @@ BSLS_IDENT("$Id: $")
 
 #include <balscm_version.h>
 
+#include <bdls_filepermissions.h>
+
 #include <bslmt_threadattributes.h>
 #include <bslmt_threadutil.h>
 
@@ -247,6 +270,17 @@ class PipeControlChannel {
     typedef bsl::function<void(const bslstl::StringRef& message)>
                                                                ControlCallback;
 
+    // CONSTANTS
+
+    /// The default permission bit mask for the underlying named pipe
+    /// (read/write for owner, group, and others).
+    static const int k_DEFAULT_PERMISSIONS =
+                                         bdls::FilePermissions::k_OWNER_READ  |
+                                         bdls::FilePermissions::k_OWNER_WRITE |
+                                         bdls::FilePermissions::k_GROUP_READ  |
+                                         bdls::FilePermissions::k_GROUP_WRITE |
+                                         bdls::FilePermissions::k_OTHERS_READ |
+                                         bdls::FilePermissions::k_OTHERS_WRITE;
   private:
     // TYPES
     enum BackgroundThreadState {
@@ -261,6 +295,10 @@ class PipeControlChannel {
     bsl::vector<char>         d_buffer;       // message buffer
     bslmt::ThreadUtil::Handle d_thread;       // background processing thread
     bsls::AtomicInt           d_backgroundState; // the background thread state
+    int                       d_permissions;  // permission bit mask for the
+                                              // created named pipe (see
+                                              // `bdls_filepermissions`);
+                                              // ignored on Windows
     bool                      d_isPipeOpen;   // true if the pipe is still open
 
     union {
@@ -320,19 +358,50 @@ class PipeControlChannel {
 
     /// Create a pipe control mechanism that dispatches messages to the
     /// specified `callback`.  Optionally specify `basicAllocator` to supply
-    /// memory.  If `basicAllocator` is zero, the currently installed
-    /// default allocator is used.
+    /// memory.  If `basicAllocator` is zero, the currently installed default
+    /// allocator is used.  The permission bit mask of the underlying named
+    /// pipe defaults to `k_DEFAULT_PERMISSIONS` (0666, i.e., read/write for
+    /// everyone) and may be changed by calling `setPermissions` before
+    /// `start`.
     explicit
     PipeControlChannel(const ControlCallback&  callback,
                        bslma::Allocator       *basicAllocator = 0);
 
+    /// Create a pipe control mechanism that dispatches messages to the
+    /// specified `callback` and creates its underlying named pipe with the
+    /// specified `permissions` bit mask.  Optionally specify
+    /// `basicAllocator` to supply memory.  If `basicAllocator` is zero, the
+    /// currently installed default allocator is used.  The behavior is
+    /// undefined unless `bdls::FilePermissions::isValidBaseBits(permissions)`
+    /// (i.e., unless `permissions` is a combination of the nine
+    /// owner/group/others read/write/execute bits defined by
+    /// `bdls::FilePermissions`; note that `k_SET_UID`, `k_SET_GID`, and
+    /// `k_STICKY_BIT` are not accepted).  On operating systems that do not
+    /// support Unix-style permission bits (notably Windows) the value is
+    /// ignored and falls back to the operating-system default (see the
+    /// component-level documentation for details).
+    PipeControlChannel(const ControlCallback&  callback,
+                       int                     permissions,
+                       bslma::Allocator       *basicAllocator = 0);
+
     /// Destroy this object.  Shut down the processing thread if it is still
     /// running and block until it terminates.  Close the named pipe and
     /// clean up any associated system resources.
     ~PipeControlChannel();
 
     // MANIPULATORS
 
+    /// Set the permission bit mask for the underlying named pipe to the
+    /// specified `permissions` value.  The behavior is undefined unless
+    /// `bdls::FilePermissions::isValidBaseBits(permissions)`.  This setting
+    /// only takes effect on the next call to `start`; calling this method
+    /// has no effect on a pipe that has already been opened.  See the
+    /// class-level documentation for a description of the cross-platform
+    /// semantics.  The behavior is undefined if this method is called while
+    /// the background thread is running (i.e., after `start` and before
+    /// `shutdown`), or if the `permissions` value is not valid.
+    void setPermissions(int permissions);
+
     /// Open a named pipe having the specified `pipeName`, and start a
     /// thread to read messages and dispatch them to the callback specified
     /// at construction.  Optionally specify `attributes` of the background
@@ -363,6 +432,10 @@ class PipeControlChannel {
 
     // ACCESSORS
 
+    /// Return the permission bit mask that will be applied to the named
+    /// pipe on the next call to `start`.
+    int permissions() const;
+
     /// Return the fully qualified system name of the pipe.
     const bsl::string& pipeName() const;
 
@@ -458,6 +531,12 @@ int PipeControlChannel::start(const STRING_TYPE&             pipeName,
 }
 
 // ACCESSORS
+inline
+int PipeControlChannel::permissions() const
+{
+    return d_permissions;
+}
+
 inline
 const bsl::string& PipeControlChannel::pipeName() const
 {