Пример #1
0
            public override void Run()
            {
                DomainSocket conn = null;

                try
                {
                    conn = preConnectedSockets != null ? preConnectedSockets[0] : serv.Accept();
                    byte[] in1 = new byte[clientMsg1.Length];
                    TestDomainSocket.ReadStrategy reader = System.Activator.CreateInstance(readStrategyClass
                                                                                           );
                    reader.Init(conn);
                    reader.ReadFully(in1, 0, in1.Length);
                    Assert.True(Arrays.Equals(clientMsg1, in1));
                    TestDomainSocket.WriteStrategy writer = System.Activator.CreateInstance(writeStrategyClass
                                                                                            );
                    writer.Init(conn);
                    writer.Write(serverMsg1);
                    InputStream connInputStream = conn.GetInputStream();
                    int         in2             = connInputStream.Read();
                    Assert.Equal((int)clientMsg2, in2);
                    conn.Close();
                }
                catch (Exception e)
                {
                    threadResults.AddItem(e);
                    NUnit.Framework.Assert.Fail(e.Message);
                }
                threadResults.AddItem(new TestDomainSocket.Success());
            }
Пример #2
0
        /// <summary>
        /// Test that we can create a socket and close it, even if it hasn't been
        /// opened.
        /// </summary>
        /// <exception cref="System.IO.IOException"/>
        public virtual void TestSocketCreateAndClose()
        {
            DomainSocket serv = DomainSocket.BindAndListen(new FilePath(sockDir.GetDir(), "test_sock_create_and_close"
                                                                        ).GetAbsolutePath());

            serv.Close();
        }
Пример #3
0
        /// <summary>
        /// Test that we get an AsynchronousCloseException when the DomainSocket
        /// we're using is closed during a read or write operation.
        /// </summary>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="System.Exception"/>
        private void TestAsyncCloseDuringIO(bool closeDuringWrite)
        {
            string TestPath = new FilePath(sockDir.GetDir(), "testAsyncCloseDuringIO(" + closeDuringWrite
                                           + ")").GetAbsolutePath();
            DomainSocket    serv           = DomainSocket.BindAndListen(TestPath);
            ExecutorService exeServ        = Executors.NewFixedThreadPool(2);
            Callable <Void> serverCallable = new _Callable_180(serv, closeDuringWrite);
            // The server just continues either writing or reading until someone
            // asynchronously closes the client's socket.  At that point, all our
            // reads return EOF, and writes get a socket error.
            Future <Void>   serverFuture   = exeServ.Submit(serverCallable);
            DomainSocket    clientConn     = DomainSocket.Connect(serv.GetPath());
            Callable <Void> clientCallable = new _Callable_213(closeDuringWrite, clientConn);
            // The client writes or reads until another thread
            // asynchronously closes the socket.  At that point, we should
            // get ClosedChannelException, or possibly its subclass
            // AsynchronousCloseException.
            Future <Void> clientFuture = exeServ.Submit(clientCallable);

            Thread.Sleep(500);
            clientConn.Close();
            serv.Close();
            clientFuture.Get(2, TimeUnit.Minutes);
            serverFuture.Get(2, TimeUnit.Minutes);
        }
Пример #4
0
 public override void Run()
 {
     try
     {
         DomainSocket client = preConnectedSockets != null ? preConnectedSockets[1] : DomainSocket
                               .Connect(TestPath);
         TestDomainSocket.WriteStrategy writer = System.Activator.CreateInstance(writeStrategyClass
                                                                                 );
         writer.Init(client);
         writer.Write(clientMsg1);
         TestDomainSocket.ReadStrategy reader = System.Activator.CreateInstance(readStrategyClass
                                                                                );
         reader.Init(client);
         byte[] in1 = new byte[serverMsg1.Length];
         reader.ReadFully(in1, 0, in1.Length);
         Assert.True(Arrays.Equals(serverMsg1, in1));
         OutputStream clientOutputStream = client.GetOutputStream();
         clientOutputStream.Write(clientMsg2);
         client.Close();
     }
     catch (Exception e)
     {
         threadResults.AddItem(e);
     }
     threadResults.AddItem(new TestDomainSocket.Success());
 }
Пример #5
0
 public override void Run()
 {
     try
     {
         DomainSocket client             = DomainSocket.Connect(TestPath);
         OutputStream clientOutputStream = client.GetOutputStream();
         InputStream  clientInputStream  = client.GetInputStream();
         clientOutputStream.Write(clientMsg1);
         DomainSocket      domainConn = (DomainSocket)client;
         byte[]            in1        = new byte[serverMsg1.Length];
         FileInputStream[] recvFis    = new FileInputStream[passedFds.Length];
         int r = domainConn.RecvFileInputStreams(recvFis, in1, 0, in1.Length - 1);
         Assert.True(r > 0);
         IOUtils.ReadFully(clientInputStream, in1, r, in1.Length - r);
         Assert.True(Arrays.Equals(serverMsg1, in1));
         for (int i = 0; i < passedFds.Length; i++)
         {
             NUnit.Framework.Assert.IsNotNull(recvFis[i]);
             passedFiles[i].CheckInputStream(recvFis[i]);
         }
         foreach (FileInputStream fis in recvFis)
         {
             fis.Close();
         }
         client.Close();
     }
     catch (System.Exception e)
     {
         threadResults.AddItem(e);
     }
     threadResults.AddItem(new TestDomainSocket.Success());
 }
Пример #6
0
        /// <summary>Test setting some server options.</summary>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="System.Exception"/>
        public virtual void TestServerOptions()
        {
            string TestPath = new FilePath(sockDir.GetDir(), "test_sock_server_options").GetAbsolutePath
                                  ();
            DomainSocket serv = DomainSocket.BindAndListen(TestPath);

            try
            {
                // Let's set a new receive buffer size
                int bufSize    = serv.GetAttribute(DomainSocket.ReceiveBufferSize);
                int newBufSize = bufSize / 2;
                serv.SetAttribute(DomainSocket.ReceiveBufferSize, newBufSize);
                int nextBufSize = serv.GetAttribute(DomainSocket.ReceiveBufferSize);
                Assert.Equal(newBufSize, nextBufSize);
                // Let's set a server timeout
                int newTimeout = 1000;
                serv.SetAttribute(DomainSocket.ReceiveTimeout, newTimeout);
                int nextTimeout = serv.GetAttribute(DomainSocket.ReceiveTimeout);
                Assert.Equal(newTimeout, nextTimeout);
                try
                {
                    serv.Accept();
                    NUnit.Framework.Assert.Fail("expected the accept() to time out and fail");
                }
                catch (SocketTimeoutException e)
                {
                    GenericTestUtils.AssertExceptionContains("accept(2) error: ", e);
                }
            }
            finally
            {
                serv.Close();
                NUnit.Framework.Assert.IsFalse(serv.IsOpen());
            }
        }
Пример #7
0
 public void Run()
 {
     try
     {
         for (int i = 0; i < SocketNum; i++)
         {
             DomainSocket[] pair = DomainSocket.Socketpair();
             watcher.Add(pair[1], new _Handler_128(handled));
             Lock.Lock();
             try
             {
                 pairs.AddItem(pair);
             }
             finally
             {
                 Lock.Unlock();
             }
         }
     }
     catch (Exception e)
     {
         TestDomainSocketWatcher.Log.Error(e);
         throw new RuntimeException(e);
     }
 }
Пример #8
0
 public _Thread_597(DomainSocket serv, byte[] clientMsg1, FileDescriptor[] passedFds
                    , byte[] serverMsg1, ArrayBlockingQueue <System.Exception> threadResults)
 {
     this.serv          = serv;
     this.clientMsg1    = clientMsg1;
     this.passedFds     = passedFds;
     this.serverMsg1    = serverMsg1;
     this.threadResults = threadResults;
 }
Пример #9
0
        /// <summary>Test that domain sockets are closed when the watcher is closed.</summary>
        /// <exception cref="System.Exception"/>
        public virtual void TestCloseSocketOnWatcherClose()
        {
            DomainSocketWatcher watcher = NewDomainSocketWatcher(10000000);

            DomainSocket[] pair = DomainSocket.Socketpair();
            watcher.Add(pair[1], new _Handler_103());
            watcher.Close();
            Uninterruptibles.JoinUninterruptibly(watcher.watcherThread);
            NUnit.Framework.Assert.IsFalse(pair[1].IsOpen());
        }
Пример #10
0
 /// <summary>Test that attempting to connect to an invalid path doesn't work.</summary>
 /// <exception cref="System.IO.IOException"/>
 public virtual void TestInvalidOperations()
 {
     try
     {
         DomainSocket.Connect(new FilePath(sockDir.GetDir(), "test_sock_invalid_operation"
                                           ).GetAbsolutePath());
     }
     catch (IOException e)
     {
         GenericTestUtils.AssertExceptionContains("connect(2) error: ", e);
     }
 }
Пример #11
0
        /// <summary>Test that we can get notifications out a DomainSocketWatcher.</summary>
        /// <exception cref="System.Exception"/>
        public virtual void TestDeliverNotifications()
        {
            DomainSocketWatcher watcher = NewDomainSocketWatcher(10000000);

            DomainSocket[] pair  = DomainSocket.Socketpair();
            CountDownLatch latch = new CountDownLatch(1);

            watcher.Add(pair[1], new _Handler_73(latch));
            pair[0].Close();
            latch.Await();
            watcher.Close();
        }
Пример #12
0
        /// <summary>
        /// Test that if one thread is blocking in a read or write operation, another
        /// thread can close the socket and stop the accept.
        /// </summary>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="System.Exception"/>
        public virtual void TestSocketAcceptAndClose()
        {
            string TestPath = new FilePath(sockDir.GetDir(), "test_sock_accept_and_close").GetAbsolutePath
                                  ();
            DomainSocket    serv     = DomainSocket.BindAndListen(TestPath);
            ExecutorService exeServ  = Executors.NewSingleThreadExecutor();
            Callable <Void> callable = new _Callable_149(serv);
            Future <Void>   future   = exeServ.Submit(callable);

            Thread.Sleep(500);
            serv.Close();
            future.Get(2, TimeUnit.Minutes);
        }
Пример #13
0
 public _Thread_435(DomainSocket[] preConnectedSockets, DomainSocket serv, byte[]
                    clientMsg1, Type readStrategyClass, Type writeStrategyClass, byte[] serverMsg1,
                    byte clientMsg2, ArrayBlockingQueue <Exception> threadResults)
 {
     this.preConnectedSockets = preConnectedSockets;
     this.serv               = serv;
     this.clientMsg1         = clientMsg1;
     this.readStrategyClass  = readStrategyClass;
     this.writeStrategyClass = writeStrategyClass;
     this.serverMsg1         = serverMsg1;
     this.clientMsg2         = clientMsg2;
     this.threadResults      = threadResults;
 }
Пример #14
0
        /// <summary>
        /// Send callback and return whether or not the domain socket was closed as a
        /// result of processing.
        /// </summary>
        /// <param name="caller">reason for call</param>
        /// <param name="entries">mapping of file descriptor to entry</param>
        /// <param name="fdSet">set of file descriptors</param>
        /// <param name="fd">file descriptor</param>
        /// <returns>true if the domain socket was closed as a result of processing</returns>
        private bool SendCallback(string caller, SortedDictionary <int, DomainSocketWatcher.Entry
                                                                   > entries, DomainSocketWatcher.FdSet fdSet, int fd)
        {
            if (Log.IsTraceEnabled())
            {
                Log.Trace(this + ": " + caller + " starting sendCallback for fd " + fd);
            }
            DomainSocketWatcher.Entry entry = entries[fd];
            Preconditions.CheckNotNull(entry, this + ": fdSet contained " + fd + ", which we were "
                                       + "not tracking.");
            DomainSocket sock = entry.GetDomainSocket();

            if (entry.GetHandler().Handle(sock))
            {
                if (Log.IsTraceEnabled())
                {
                    Log.Trace(this + ": " + caller + ": closing fd " + fd + " at the request of the handler."
                              );
                }
                if (Collections.Remove(toRemove, fd) != null)
                {
                    if (Log.IsTraceEnabled())
                    {
                        Log.Trace(this + ": " + caller + " : sendCallback processed fd " + fd + " in toRemove."
                                  );
                    }
                }
                try
                {
                    sock.refCount.UnreferenceCheckClosed();
                }
                catch (IOException)
                {
                    Preconditions.CheckArgument(false, this + ": file descriptor " + sock.fd + " was closed while "
                                                + "still in the poll(2) loop.");
                }
                IOUtils.Cleanup(Log, sock);
                fdSet.Remove(fd);
                return(true);
            }
            else
            {
                if (Log.IsTraceEnabled())
                {
                    Log.Trace(this + ": " + caller + ": sendCallback not " + "closing fd " + fd);
                }
                return(false);
            }
        }
Пример #15
0
 /// <exception cref="System.IO.IOException"/>
 public DomainSocketWatcher(int interruptCheckPeriodMs, string src)
 {
     watcherThread = new Thread(new _Runnable_451(this));
     if (loadingFailureReason != null)
     {
         throw new NotSupportedException(loadingFailureReason);
     }
     Preconditions.CheckArgument(interruptCheckPeriodMs > 0);
     this.interruptCheckPeriodMs = interruptCheckPeriodMs;
     notificationSockets         = DomainSocket.Socketpair();
     watcherThread.SetDaemon(true);
     watcherThread.SetName(src + " DomainSocketWatcher");
     watcherThread.SetUncaughtExceptionHandler(new _UncaughtExceptionHandler_252());
     watcherThread.Start();
 }
Пример #16
0
            /// <exception cref="System.IO.IOException"/>
            public override void Write(byte[] b, int off, int len)
            {
                this._enclosing.refCount.Reference();
                bool exc = true;

                try
                {
                    DomainSocket.WriteArray0(this._enclosing.fd, b, off, len);
                    exc = false;
                }
                finally
                {
                    this._enclosing.Unreference(exc);
                }
            }
Пример #17
0
        /// <summary>Test that we get a read result of -1 on EOF.</summary>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="System.Exception"/>
        public virtual void TestSocketReadEof()
        {
            string TestPath = new FilePath(sockDir.GetDir(), "testSocketReadEof").GetAbsolutePath
                                  ();
            DomainSocket    serv     = DomainSocket.BindAndListen(TestPath);
            ExecutorService exeServ  = Executors.NewSingleThreadExecutor();
            Callable <Void> callable = new _Callable_109(serv);
            Future <Void>   future   = exeServ.Submit(callable);
            DomainSocket    conn     = DomainSocket.Connect(serv.GetPath());

            Thread.Sleep(50);
            conn.Close();
            serv.Close();
            future.Get(2, TimeUnit.Minutes);
        }
Пример #18
0
            /// <exception cref="System.IO.IOException"/>
            public override int Read(byte[] b, int off, int len)
            {
                this._enclosing.refCount.Reference();
                bool exc = true;

                try
                {
                    int nRead = DomainSocket.ReadArray0(this._enclosing.fd, b, off, len);
                    exc = false;
                    return(nRead);
                }
                finally
                {
                    this._enclosing.Unreference(exc);
                }
            }
Пример #19
0
        /// <summary>Run validateSocketPathSecurity</summary>
        /// <param name="str">The path to validate</param>
        /// <param name="prefix">A prefix to skip validation for</param>
        /// <exception cref="System.IO.IOException"/>
        private static void TestValidateSocketPath(string str, string prefix)
        {
            int      skipComponents = 1;
            FilePath prefixFile     = new FilePath(prefix);

            while (true)
            {
                prefixFile = prefixFile.GetParentFile();
                if (prefixFile == null)
                {
                    break;
                }
                skipComponents++;
            }
            DomainSocket.ValidateSocketPathSecurity0(str, skipComponents);
        }
Пример #20
0
            /// <exception cref="System.IO.IOException"/>
            public override int Available()
            {
                this._enclosing.refCount.Reference();
                bool exc = true;

                try
                {
                    int nAvailable = DomainSocket.Available0(this._enclosing.fd);
                    exc = false;
                    return(nAvailable);
                }
                finally
                {
                    this._enclosing.Unreference(exc);
                }
            }
Пример #21
0
        /// <summary>Test file descriptor passing.</summary>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="System.Exception"/>
        public virtual void TestFdPassing()
        {
            string TestPath = new FilePath(sockDir.GetDir(), "test_sock").GetAbsolutePath();

            byte[] clientMsg1 = new byte[] { unchecked ((int)(0x11)), unchecked ((int)(0x22)),
                                             unchecked ((int)(0x33)), unchecked ((int)(0x44)), unchecked ((int)(0x55)), unchecked (
                                                 (int)(0x66)) };
            byte[] serverMsg1 = new byte[] { unchecked ((int)(0x31)), unchecked ((int)(0x30)),
                                             unchecked ((int)(0x32)), unchecked ((int)(0x34)), unchecked ((int)(0x31)), unchecked (
                                                 (int)(0x33)), unchecked ((int)(0x44)), unchecked ((int)(0x1)), unchecked ((int)(0x1
                                                                                                                                 )), unchecked ((int)(0x1)), unchecked ((int)(0x1)), unchecked ((int)(0x1)) };
            ArrayBlockingQueue <System.Exception> threadResults = new ArrayBlockingQueue <System.Exception
                                                                                          >(2);
            DomainSocket serv = DomainSocket.BindAndListen(TestPath);

            TestDomainSocket.PassedFile[] passedFiles = new TestDomainSocket.PassedFile[] { new
                                                                                            TestDomainSocket.PassedFile(1), new TestDomainSocket.PassedFile(2) };
            FileDescriptor[] passedFds = new FileDescriptor[passedFiles.Length];
            for (int i = 0; i < passedFiles.Length; i++)
            {
                passedFds[i] = passedFiles[i].GetInputStream().GetFD();
            }
            Thread serverThread = new _Thread_597(serv, clientMsg1, passedFds, serverMsg1
                                                  , threadResults);

            // Run server
            serverThread.Start();
            Thread clientThread = new _Thread_620(TestPath, clientMsg1, serverMsg1, passedFds
                                                  , passedFiles, threadResults);

            clientThread.Start();
            for (int i_1 = 0; i_1 < 2; i_1++)
            {
                System.Exception t = threadResults.Take();
                if (!(t is TestDomainSocket.Success))
                {
                    NUnit.Framework.Assert.Fail(t.Message + ExceptionUtils.GetStackTrace(t));
                }
            }
            serverThread.Join(120000);
            clientThread.Join(120000);
            serv.Close();
            foreach (TestDomainSocket.PassedFile pf in passedFiles)
            {
                pf.Cleanup();
            }
        }
Пример #22
0
            /// <exception cref="System.IO.IOException"/>
            public override int Read()
            {
                this._enclosing.refCount.Reference();
                bool exc = true;

                try
                {
                    byte[] b   = new byte[1];
                    int    ret = DomainSocket.ReadArray0(this._enclosing.fd, b, 0, 1);
                    exc = false;
                    return((ret >= 0) ? b[0] : -1);
                }
                finally
                {
                    this._enclosing.Unreference(exc);
                }
            }
Пример #23
0
 /// <summary>Add a socket.</summary>
 /// <param name="sock">
 /// The socket to add.  It is an error to re-add a socket that
 /// we are already watching.
 /// </param>
 /// <param name="handler">
 /// The handler to associate with this socket.  This may be
 /// called any time after this function is called.
 /// </param>
 public void Add(DomainSocket sock, DomainSocketWatcher.Handler handler)
 {
     Lock.Lock();
     try
     {
         if (closed)
         {
             handler.Handle(sock);
             IOUtils.Cleanup(Log, sock);
             return;
         }
         DomainSocketWatcher.Entry entry = new DomainSocketWatcher.Entry(sock, handler);
         try
         {
             sock.refCount.Reference();
         }
         catch (ClosedChannelException)
         {
             // If the socket is already closed before we add it, invoke the
             // handler immediately.  Then we're done.
             handler.Handle(sock);
             return;
         }
         toAdd.AddItem(entry);
         Kick();
         while (true)
         {
             try
             {
                 processedCond.Await();
             }
             catch (Exception)
             {
                 Thread.CurrentThread().Interrupt();
             }
             if (!toAdd.Contains(entry))
             {
                 break;
             }
         }
     }
     finally
     {
         Lock.Unlock();
     }
 }
Пример #24
0
            /// <exception cref="System.IO.IOException"/>
            public override void Write(int val)
            {
                this._enclosing.refCount.Reference();
                bool exc = true;

                try
                {
                    byte[] b = new byte[1];
                    b[0] = unchecked ((byte)val);
                    DomainSocket.WriteArray0(this._enclosing.fd, b, 0, 1);
                    exc = false;
                }
                finally
                {
                    this._enclosing.Unreference(exc);
                }
            }
Пример #25
0
            public Void Call()
            {
                DomainSocket serverConn = null;

                try
                {
                    serverConn = serv.Accept();
                    byte[] buf = new byte[100];
                    for (int i = 0; i < buf.Length; i++)
                    {
                        buf[i] = 0;
                    }
                    if (closeDuringWrite)
                    {
                        try
                        {
                            while (true)
                            {
                                serverConn.GetOutputStream().Write(buf);
                            }
                        }
                        catch (IOException)
                        {
                        }
                    }
                    else
                    {
                        do
                        {
                        }while (serverConn.GetInputStream().Read(buf, 0, buf.Length) != -1);
                    }
                }
                catch (IOException e)
                {
                    throw new RuntimeException("unexpected IOException", e);
                }
                finally
                {
                    IOUtils.Cleanup(DomainSocket.Log, serverConn);
                }
                return(null);
            }
Пример #26
0
        /// <exception cref="System.Exception"/>
        public virtual void TestShutdown()
        {
            AtomicInteger bytesRead = new AtomicInteger(0);
            AtomicBoolean failed    = new AtomicBoolean(false);

            DomainSocket[] socks        = DomainSocket.Socketpair();
            Runnable       reader       = new _Runnable_737(socks, bytesRead, failed);
            Thread         readerThread = new Thread(reader);

            readerThread.Start();
            socks[0].GetOutputStream().Write(1);
            socks[0].GetOutputStream().Write(2);
            socks[0].GetOutputStream().Write(3);
            Assert.True(readerThread.IsAlive());
            socks[0].Shutdown();
            readerThread.Join();
            NUnit.Framework.Assert.IsFalse(failed.Get());
            Assert.Equal(3, bytesRead.Get());
            IOUtils.Cleanup(null, socks);
        }
Пример #27
0
        /// <summary>Test file descriptor path security.</summary>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="System.Exception"/>
        public virtual void TestFdPassingPathSecurity()
        {
            TemporarySocketDirectory tmp = new TemporarySocketDirectory();

            try
            {
                string prefix = tmp.GetDir().GetAbsolutePath();
                Shell.ExecCommand(new string[] { "mkdir", "-p", prefix + "/foo/bar/baz" });
                Shell.ExecCommand(new string[] { "chmod", "0700", prefix + "/foo/bar/baz" });
                Shell.ExecCommand(new string[] { "chmod", "0700", prefix + "/foo/bar" });
                Shell.ExecCommand(new string[] { "chmod", "0707", prefix + "/foo" });
                Shell.ExecCommand(new string[] { "mkdir", "-p", prefix + "/q1/q2" });
                Shell.ExecCommand(new string[] { "chmod", "0700", prefix + "/q1" });
                Shell.ExecCommand(new string[] { "chmod", "0700", prefix + "/q1/q2" });
                TestValidateSocketPath(prefix + "/q1/q2", prefix);
                try
                {
                    TestValidateSocketPath(prefix + "/foo/bar/baz", prefix);
                }
                catch (IOException e)
                {
                    GenericTestUtils.AssertExceptionContains("/foo' is world-writable.  " + "Its permissions are 0707.  Please fix this or select a "
                                                             + "different socket path.", e);
                }
                try
                {
                    TestValidateSocketPath(prefix + "/nope", prefix);
                }
                catch (IOException e)
                {
                    GenericTestUtils.AssertExceptionContains("failed to stat a path " + "component: "
                                                             , e);
                }
                // Root should be secure
                DomainSocket.ValidateSocketPathSecurity0("/foo", 1);
            }
            finally
            {
                tmp.Close();
            }
        }
Пример #28
0
            public override void Run()
            {
                DomainSocket conn = null;

                try
                {
                    conn = serv.Accept();
                    byte[]      in1             = new byte[clientMsg1.Length];
                    InputStream connInputStream = conn.GetInputStream();
                    IOUtils.ReadFully(connInputStream, in1, 0, in1.Length);
                    Assert.True(Arrays.Equals(clientMsg1, in1));
                    DomainSocket domainConn = (DomainSocket)conn;
                    domainConn.SendFileDescriptors(passedFds, serverMsg1, 0, serverMsg1.Length);
                    conn.Close();
                }
                catch (System.Exception e)
                {
                    threadResults.AddItem(e);
                    NUnit.Framework.Assert.Fail(e.Message);
                }
                threadResults.AddItem(new TestDomainSocket.Success());
            }
Пример #29
0
        /// <summary>Test a simple client/server interaction.</summary>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="System.Exception"/>
        internal virtual void TestClientServer1(Type writeStrategyClass, Type readStrategyClass
                                                , DomainSocket[] preConnectedSockets)
        {
            string TestPath = new FilePath(sockDir.GetDir(), "test_sock_client_server1").GetAbsolutePath
                                  ();

            byte[] clientMsg1 = new byte[] { unchecked ((int)(0x1)), unchecked ((int)(0x2)), unchecked (
                                                 (int)(0x3)), unchecked ((int)(0x4)), unchecked ((int)(0x5)), unchecked ((int)(0x6)) };
            byte[] serverMsg1 = new byte[] { unchecked ((int)(0x9)), unchecked ((int)(0x8)), unchecked (
                                                 (int)(0x7)), unchecked ((int)(0x6)), unchecked ((int)(0x5)) };
            byte clientMsg2   = unchecked ((int)(0x45));
            ArrayBlockingQueue <Exception> threadResults = new ArrayBlockingQueue <Exception>(2
                                                                                              );
            DomainSocket serv = (preConnectedSockets != null) ? null : DomainSocket.BindAndListen
                                    (TestPath);
            Thread serverThread = new _Thread_435(preConnectedSockets, serv, clientMsg1
                                                  , readStrategyClass, writeStrategyClass, serverMsg1, clientMsg2, threadResults);

            // Run server
            serverThread.Start();
            Thread clientThread = new _Thread_463(preConnectedSockets, TestPath, writeStrategyClass
                                                  , clientMsg1, readStrategyClass, serverMsg1, clientMsg2, threadResults);

            clientThread.Start();
            for (int i = 0; i < 2; i++)
            {
                Exception t = threadResults.Take();
                if (!(t is TestDomainSocket.Success))
                {
                    NUnit.Framework.Assert.Fail(t.Message + ExceptionUtils.GetStackTrace(t));
                }
            }
            serverThread.Join(120000);
            clientThread.Join(120000);
            if (serv != null)
            {
                serv.Close();
            }
        }
Пример #30
0
            /// <exception cref="System.IO.IOException"/>
            public virtual int Read(ByteBuffer dst)
            {
                this._enclosing.refCount.Reference();
                bool exc = true;

                try
                {
                    int nread = 0;
                    if (dst.IsDirect())
                    {
                        nread = DomainSocket.ReadByteBufferDirect0(this._enclosing.fd, dst, dst.Position(
                                                                       ), dst.Remaining());
                    }
                    else
                    {
                        if (dst.HasArray())
                        {
                            nread = DomainSocket.ReadArray0(this._enclosing.fd, ((byte[])dst.Array()), dst.Position
                                                                () + dst.ArrayOffset(), dst.Remaining());
                        }
                        else
                        {
                            throw new Exception("we don't support " + "using ByteBuffers that aren't either direct or backed by "
                                                + "arrays");
                        }
                    }
                    if (nread > 0)
                    {
                        dst.Position(dst.Position() + nread);
                    }
                    exc = false;
                    return(nread);
                }
                finally
                {
                    this._enclosing.Unreference(exc);
                }
            }