diff -r 027aca7ae47b OpenSim/Framework/Servers/BaseHttpServer.cs
--- a/OpenSim/Framework/Servers/BaseHttpServer.cs	Thu May 15 13:11:36 2008 -0400
+++ b/OpenSim/Framework/Servers/BaseHttpServer.cs	Fri May 16 11:35:32 2008 -0400
@@ -49,8 +49,9 @@ namespace OpenSim.Framework.Servers
         protected HttpListener m_httpListener;
         protected Dictionary<string, XmlRpcMethod> m_rpcHandlers = new Dictionary<string, XmlRpcMethod>();
         protected LLSDMethod m_llsdHandler = null;
-        protected Dictionary<string, IRequestHandler> m_streamHandlers = new Dictionary<string, IRequestHandler>();
-        protected Dictionary<string, GenericHTTPMethod> m_HTTPHandlers = new Dictionary<string, GenericHTTPMethod>();
+        protected Dictionary<string, IRequestHandler> m_streamHandlers  = new Dictionary<string, IRequestHandler>();
+        protected Dictionary<string, GenericHTTPMethod> m_HTTPHandlers  = new Dictionary<string, GenericHTTPMethod>();
+        protected Dictionary<string, IUserAgentHandler> m_agentHandlers = new Dictionary<string, IUserAgentHandler>();
 
         protected uint m_port;
         protected bool m_ssl = false;
@@ -119,6 +120,18 @@ namespace OpenSim.Framework.Servers
             return false;
         }
 
+        public bool AddAgentHandler(string agent, IUserAgentHandler handler)
+        {
+            if (!m_agentHandlers.ContainsKey(agent))
+            {
+                m_agentHandlers.Add(agent, handler);
+                return true;
+            }
+
+            //must already have a handler for that path so return false
+            return false;
+        }
+
         public bool SetLLSDHandler(LLSDMethod handler)
         {
             m_llsdHandler = handler;
@@ -136,88 +149,128 @@ namespace OpenSim.Framework.Servers
             {
                 HttpListenerContext context = (HttpListenerContext) stateinfo;
     
-                HttpListenerRequest request = context.Request;
-                HttpListenerResponse response = context.Response;
+				HttpListenerRequest request   = context.Request;
+				HttpListenerResponse response = context.Response;
     
-                response.KeepAlive = false;
-                response.SendChunked = false;
-    
-                string path = request.RawUrl;
-                string handlerKey = GetHandlerKey(request.HttpMethod, path);
-                
-                //m_log.DebugFormat("[BASE HTTP SERVER]: Handling {0} request for {1}", request.HttpMethod, path);
-    
-                IRequestHandler requestHandler;
-    
-                if (TryGetStreamHandler(handlerKey, out requestHandler))
+				for(int i=0;i<request.Headers.Count;i++)
                 {
-                    // Okay, so this is bad, but should be considered temporary until everything is IStreamHandler.
-                    byte[] buffer;
-                    if (requestHandler is IStreamedRequestHandler)
+                    m_log.DebugFormat("[HTTP] Header[{0}]: {1} : {2}",i,request.Headers.GetKey(i), request.Headers.Get(i));
+				}
+
+                if(request.UserAgent != null)
+                {
+					IUserAgentHandler agentHandler;
+					if(TryGetAgentHandler(request.UserAgent, out agentHandler))
                     {
-                        IStreamedRequestHandler streamedRequestHandler = requestHandler as IStreamedRequestHandler;
-                                          
-                        buffer = streamedRequestHandler.Handle(path, request.InputStream);
-                    }
-                    else
-                    {
-                        IStreamHandler streamHandler = (IStreamHandler) requestHandler;
-    
-                        using (MemoryStream memoryStream = new MemoryStream())
-                        {
-                            streamHandler.Handle(path, request.InputStream, memoryStream);
-                            memoryStream.Flush();
-                            buffer = memoryStream.ToArray();
-                        }
-                    }
-    
-                    request.InputStream.Close();
-                    response.ContentType = requestHandler.ContentType;
-                    response.ContentLength64 = buffer.LongLength;
-    
-                    try
-                    {
-                        response.OutputStream.Write(buffer, 0, buffer.Length);
-                        response.OutputStream.Close();
-                    }
-                    catch (HttpListenerException)
-                    {
-                        m_log.WarnFormat("[BASE HTTP SERVER]: HTTP request abnormally terminated.");
+						m_log.DebugFormat("[HTTP-AGENT] Handler located for {0}",request.UserAgent);
+						HandleAgentRequest(agentHandler, request, response);
                     }
                 }
-                else
+	            else
+                {	
+
+					IRequestHandler  requestHandler;
+
+					string path = request.RawUrl;
+					string handlerKey = GetHandlerKey(request.HttpMethod, path);
+                
+					response.KeepAlive   = false;
+					response.SendChunked = false;
+    
+					if (TryGetStreamHandler(handlerKey, out requestHandler))
+					{
+
+						m_log.DebugFormat("[HTTP-STREAM] Handler matched for {0}",handlerKey);
+
+						// Okay, so this is bad, but should be considered temporary until everything is IStreamHandler.
+						byte[] buffer;
+						if (requestHandler is IStreamedRequestHandler)
+						{
+							IStreamedRequestHandler streamedRequestHandler = requestHandler as IStreamedRequestHandler;
+											  
+							buffer = streamedRequestHandler.Handle(path, request.InputStream);
+						}
+						else
+						{
+							IStreamHandler streamHandler = (IStreamHandler) requestHandler;
+		
+							using (MemoryStream memoryStream = new MemoryStream())
+							{
+								streamHandler.Handle(path, request.InputStream, memoryStream);
+								memoryStream.Flush();
+								buffer = memoryStream.ToArray();
+							}
+						}
+		
+						request.InputStream.Close();
+						response.ContentType = requestHandler.ContentType;
+						response.ContentLength64 = buffer.LongLength;
+		
+						try
+						{
+							response.OutputStream.Write(buffer, 0, buffer.Length);
+							response.OutputStream.Close();
+						}
+						catch (HttpListenerException)
+						{
+							m_log.WarnFormat("[BASE HTTP SERVER]: HTTP request abnormally terminated.");
+						}
+					}
+					else
+					{
+						m_log.DebugFormat("[HTTP] Default handling based on content type");
+						switch (request.ContentType)
+						{
+							case null:
+							case "text/html":
+								HandleHTTPRequest(request, response);
+								break;
+							case "application/xml+llsd":
+								HandleLLSDRequests(request, response);
+								break;
+							case "text/xml":
+							case "application/xml":
+							default:
+								HandleXmlRpcRequests(request, response);
+								break;
+						}
+					}
+				}	// switch(headers)
+			}
+			catch (SocketException)
+			{
+				// At least on linux, it appears that if the client makes a request without requiring the response,
+				// an unconnected socket exception is thrown when we close the response output stream.  There's no
+				// obvious way to tell if the client didn't require the response, so instead we'll catch and ignore
+				// the exception instead.
+				//
+				// An alternative may be to turn off all response write exceptions on the HttpListener, but let's go
+				// with the minimum first
+			}
+			catch (Exception e)
+			{
+				m_log.ErrorFormat("[BASE HTTP SERVER]: HandleRequest() threw {0}", e);
+			}
+        }
+
+        private bool TryGetAgentHandler(string agent, out IUserAgentHandler agentHandler)
+        {
+            agentHandler = null;
+            try
+            {
+                foreach(IUserAgentHandler handler in m_agentHandlers.Values)
                 {
-                    switch (request.ContentType)
+                    if(handler.Match(agent))
                     {
-                        case null:
-                        case "text/html":
-                            HandleHTTPRequest(request, response);
-                            break;
-                        case "application/xml+llsd":
-                            HandleLLSDRequests(request, response);
-                            break;
-                        case "text/xml":
-                        case "application/xml":
-                        default:
-                            HandleXmlRpcRequests(request, response);
-                            break;
+                        agentHandler = handler;
+						return true;
                     }
                 }
             }
-            catch (SocketException)
-            {
-                // At least on linux, it appears that if the client makes a request without requiring the response,
-                // an unconnected socket exception is thrown when we close the response output stream.  There's no
-                // obvious way to tell if the client didn't require the response, so instead we'll catch and ignore
-                // the exception instead.
-                //
-                // An alternative may be to turn off all response write exceptions on the HttpListener, but let's go
-                // with the minimum first
-            }
-            catch (Exception e)
-            {
-                m_log.ErrorFormat("[BASE HTTP SERVER]: HandleRequest() threw {0}", e);
-            }
+            catch(KeyNotFoundException) {}
+
+            return false;
+
         }
 
         private bool TryGetStreamHandler(string handlerKey, out IRequestHandler streamHandler)
@@ -274,6 +327,36 @@ namespace OpenSim.Framework.Servers
             }
         }
         
+        /// <summary>
+        /// A specific agent handler was provided. Such a handler is expecetd to have an
+        /// intimate, and highly specific relationship with the client. Consequently,
+        /// nothing is done here.
+        /// </summary>
+        /// <param name="handler"></param>
+        /// <param name="request"></param>
+        /// <param name="response"></param>
+
+        private void HandleAgentRequest(IUserAgentHandler handler, HttpListenerRequest request, HttpListenerResponse response)
+        {
+
+            // In the case of REST, then handler is responsible for ALL aspects of 
+            // the request/response handling. Nothing is done here, not even encoding.
+
+            try
+            {
+				handler.Handle(request, response);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn("[HTTP-AGENT]: Error - " + e.Message);
+				response.SendChunked   = false;
+				response.KeepAlive     = false;
+                response.StatusCode    = 500;
+                response.OutputStream.Close();
+            }
+
+		}
+
         /// <summary>
         /// Try all the registered xmlrpc handlers when an xmlrpc request is received.
         /// Sends back an XMLRPC unknown request response if no handler is registered for the requested method.