Merge pull request #2873 from ianhays/pipes

Unix NamedServerPipeStream disposal no longer deletes the FIFO

Author: Ian Hays

src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.Unix.cs

@@ -15,7 +15,6 @@ namespace System.IO.Pipes
     /// </summary>
     public sealed partial class NamedPipeServerStream : PipeStream
     {
-        private bool _createdFifo;
         private string _path;
         private PipeDirection _direction;
         private PipeOptions _options;
@@ -50,7 +49,9 @@ private void Create(string pipeName, PipeDirection direction, int maxNumberOfSer
                 int result = Interop.libc.mkfifo(_path, (int)Interop.libc.Permissions.S_IRWXU);
                 if (result == 0)
                 {
-                    _createdFifo = true;
+                    // The FIFO was successfully created - note that although we create the FIFO here, we don't
+                    // ever delete it. If we remove the FIFO we could invalidate other servers that also use it. 
+                    // See #2764 for further discussion.
                     break;
                 }
 
@@ -121,17 +122,6 @@ public void Disconnect()
             InitializeHandle(null, false, false);
         }
 
-        protected override void Dispose(bool disposing)
-        {
-            // If we created the FIFO object, be a good citizen and clean it up.
-            // If this doesn't happen, worst case is we leave a temp file around.
-            if (_createdFifo && _path != null)
-            {
-                Interop.libc.unlink(_path); // ignore any errors
-            }
-            base.Dispose(disposing);
-        }
-
         // Gets the username of the connected client.  Not that we will not have access to the client's 
         // username until it has written at least once to the pipe (and has set its impersonationLevel 
         // argument appropriately). 

src/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs

@@ -397,5 +397,40 @@ public void InvalidReadMode_Throws_ArgumentOutOfRangeException(PipeDirection ser
                 Assert.Throws<ArgumentOutOfRangeException>(() => client.ReadMode = (PipeTransmissionMode)999);
             }
         }
+
+        [Fact]
+        [PlatformSpecific(PlatformID.AnyUnix)]
+        public void Unix_MultipleServerDisposal_DoesntDeletePipe()
+        {
+            // Test for when multiple servers are created and linked to the same FIFO. The original ServerStream
+            // that created the FIFO is disposed. The other servers should still be valid and useable.
+            string serverName = GetUniquePipeName();
+
+            var server1 = new NamedPipeServerStream(serverName, PipeDirection.In); // Creates the FIFO
+            var server2 = new NamedPipeServerStream(serverName, PipeDirection.In);
+            var client1 = new NamedPipeClientStream(".", serverName, PipeDirection.Out);
+            var client2 = new NamedPipeClientStream(".", serverName, PipeDirection.Out);
+
+            Task server1Task = server1.WaitForConnectionAsync(); // Opens a handle to the FIFO
+            Task server2Task = server2.WaitForConnectionAsync(); // Opens a handle to the same FIFO as server1
+
+            Task client1Task = client1.ConnectAsync();
+            Task.WaitAll(server1Task, server2Task, client1Task); // client1 connects to server1 AND server2
+
+            Assert.True(server1.IsConnected);
+            Assert.True(server2.IsConnected);
+
+            // Get rid of client1/server1 and make sure server2 isn't connected (so that it can connect to client2)
+            server1.Dispose();
+            client1.Dispose();
+            server2.Disconnect();
+            Assert.False(server2.IsConnected);
+
+            server2Task = server2.WaitForConnectionAsync(); // Opens a handle to the same FIFO
+            Task client2Task = client2.ConnectAsync(); 
+            Task.WaitAll(server2Task, client2Task); // Should not block!
+            Assert.True(server2.IsConnected);
+        }
+
     }
 }