Author: mhabersack
Date: 2007-03-30 08:28:55 -0500 (Fri, 30 Mar 2007)
New Revision: 75192

Modified:
   trunk/xsp/ChangeLog
   trunk/xsp/src/Mono.WebServer/BaseRequestBroker.cs
Log:
2007-03-30  Marek Habersack  <[EMAIL PROTECTED]>

        * src/Mono.WebServer/BaseRequestBroker.cs: protect access to the
        buffer in Read at least a bit. It can still be released by some
        other thread after or during Read.


Modified: trunk/xsp/ChangeLog
===================================================================
--- trunk/xsp/ChangeLog 2007-03-30 13:27:25 UTC (rev 75191)
+++ trunk/xsp/ChangeLog 2007-03-30 13:28:55 UTC (rev 75192)
@@ -1,5 +1,9 @@
 2007-03-30  Marek Habersack  <[EMAIL PROTECTED]>
 
+       * src/Mono.WebServer/BaseRequestBroker.cs: protect access to the
+       buffer in Read at least a bit. It can still be released by some
+       other thread after or during Read.
+
        * src/Mono.WebServer/Tracing.cs: added a utility class to help in
        tracing.
 

Modified: trunk/xsp/src/Mono.WebServer/BaseRequestBroker.cs
===================================================================
--- trunk/xsp/src/Mono.WebServer/BaseRequestBroker.cs   2007-03-30 13:27:25 UTC 
(rev 75191)
+++ trunk/xsp/src/Mono.WebServer/BaseRequestBroker.cs   2007-03-30 13:28:55 UTC 
(rev 75192)
@@ -35,6 +35,8 @@
 {
        public class BaseRequestBroker: MarshalByRefObject, IRequestBroker
        {
+               const int BufferAllocSize = 16384;
+               
                Hashtable requests = new Hashtable ();
                Hashtable buffers = new Hashtable ();
 
@@ -43,8 +45,8 @@
                {
                        if (stk.Count > 0)
                                return (byte []) stk.Pop ();
-
-                       return new byte [16384];
+                       
+                       return new byte [BufferAllocSize];;
                }
 
                static void ReleaseBuffer (byte [] buffer)
@@ -55,7 +57,7 @@
                public int RegisterRequest (Worker worker)
                {
                        int result = worker.GetHashCode ();
-                       lock (requests) {
+                       lock (requests) {                                       
            
                                requests [result] = worker;
                                buffers [result] = Allocate16k ();
                        }
@@ -74,18 +76,22 @@
 
                public int Read (int requestId, int size, out byte[] buffer)
                {
-                       if (size == 16384) {
-                               buffer = (byte []) buffers [requestId];
-                       } else {
+                       buffer = null;
+                       if (size != BufferAllocSize)
                                buffer = new byte[size];
-                       }
                        Worker w;
                        lock (requests) {
+                               if (buffer == null)
+                                       buffer = (byte []) buffers [requestId];
                                w = (Worker) requests [requestId];
                        }
 
                        int nread = 0;
-                       if (w != null)
+                       // NOTE: Maybe we should NOT return cached buffers but
+                       // always allocate a new one? That would eliminate the
+                       // need to lock buffers[] access and a possible race
+                       // condition below.
+                       if (w != null && buffer != null)
                                nread = w.Read (buffer, 0, size);
 
                        return nread;

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to