Add proper licensing

8 files changed, 1360 insertions, 0 deletions

diff --git a/java/src/com/memberwebs/httpauth/BaseHttpAuthenticator.java b/java/src/com/memberwebs/httpauth/BaseHttpAuthenticator.java
new file mode 100644
index 0000000..8dd15f1
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/BaseHttpAuthenticator.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth;
+
+import java.io.IOException;
+import java.net.SocketException;
+import java.util.Enumeration;
+
+/**
+ * Base class for HttpAuth authenticators. This class in not generally used
+ * outside of the HttpAuth code.
+ *
+ * @author Nate Nielsen
+ */
+public abstract class BaseHttpAuthenticator
+{
+    protected HttpAuthConnectionSource m_source;
+
+    protected BaseHttpAuthenticator(HttpAuthConnectionSource source)
+    {
+        m_source = source;
+    }
+
+    protected abstract void addResponseHeader(Object response, String name, String value);
+    protected abstract void setResponseResult(Object response, int code)
+        throws IOException;
+    protected abstract Enumeration getHeaderValues(Object request, String name);
+    protected abstract Enumeration getHeaderNames(Object request);
+
+    protected String authenticateRequest(Object request, Object response,
+                                         String connid, String method,
+                                         String uri, String[] authtypes)
+        throws HttpAuthException
+    {
+        // Prepare and send the request line
+        String args = connid + " " + method + " " + uri;
+        HttpAuthConnection conn = null;
+        HttpAuthConnection.Response rsp = null;
+
+        try
+        {
+            // Retry loop
+            for(;;)
+            {
+                conn = m_source.getOpenConnection();
+
+                try
+                {
+                    conn.sendLine("AUTH " + args);
+                    sendHeaders(conn, request, authtypes);
+
+                    // If above was successful get out of this retry loop
+                    break;
+                }
+                catch(SocketException e)
+                {
+                    // Always close connections that have errors on them
+                    conn.close();
+
+                    // Stupid hack but java doesn't let us do any better just now
+                    if(!e.getMessage().startsWith("Broken pipe"))
+                        throw new HttpAuthException("error communicating with httpauthd", e);
+                }
+
+                // The following code only gets executed when our sockets
+                // have been disconnected. We loop up and try again. We're
+                // pretty safe in doing this because the act of opening a
+                // HttpAuthConnection sends some data through it, so only
+                // stale connections should end up here.
+                m_source.doneWithConnection(conn);
+            }
+
+            rsp = conn.readResponse(200);
+            copyHeaders(conn, response, authtypes);
+
+            if(rsp.ccode != 200)
+            {
+                setResponseResult(response, rsp.ccode);
+                return null;
+            }
+            else
+            {
+                return rsp.details;
+            }
+        }
+        catch(IOException e)
+        {
+            try
+            {
+                // Always close connections that have errors on them
+                conn.close();
+            }
+            catch(IOException ex)
+            { }
+
+            throw new HttpAuthException("error communicating with httpauthd", e);
+        }
+        finally
+        {
+            if(conn != null)
+                m_source.doneWithConnection(conn);
+        }
+    }
+
+    protected void copyHeaders(HttpAuthConnection conn, Object response,
+                               String[] authtypes)
+        throws IOException
+    {
+        for(;;)
+        {
+            String line = conn.readLine();
+            if(line != null)
+            {
+                line.trim();
+                if(line.length() == 0)
+                    line = null;
+            }
+
+            if(line == null)
+                break;
+
+            int pos = line.indexOf(":");
+
+            // Skip invalid lines
+            if(pos == -1)
+                continue;
+
+            String name = line.substring(0, pos).trim();
+            String value = line.substring(pos + 1).trim();
+
+            // Drop junk that's not allowed
+            if(authtypes != null && authtypes.length > 0)
+            {
+                if(name.equalsIgnoreCase("WWW-Authenticate"))
+                {
+                    boolean ok = false;
+
+                    for(int i = 0; i < authtypes.length; i++)
+                    {
+                        if(value.startsWith(authtypes[i]))
+                        {
+                            ok = true;
+                            break;
+                        }
+                    }
+
+                    if(!ok)
+                        continue;
+                }
+            }
+
+            addResponseHeader(response, name, value);
+        }
+    }
+
+    /**
+     * @param req
+     */
+    protected void sendHeaders(HttpAuthConnection conn, Object request,
+                               String[] authtypes)
+        throws IOException
+    {
+        Enumeration e = getHeaderNames(request);
+
+        while(e.hasMoreElements())
+        {
+            String name = (String)e.nextElement();
+            if(!name.equalsIgnoreCase("Authorization"))
+                continue;
+
+            Enumeration e2 = getHeaderValues(request, name);
+            while(e2.hasMoreElements())
+            {
+                String value = (String)e2.nextElement();
+
+                if(authtypes == null || authtypes.length == 0)
+                {
+                    conn.sendLine(name + ": " + value);
+                }
+                else
+                {
+                    for(int i = 0; i < authtypes.length; i++)
+                    {
+                        if(value.startsWith(authtypes[i]))
+                        {
+                            conn.sendLine(name + ": " + value);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Headers always end in a blank line
+        conn.sendLine("");
+    }
+}
diff --git a/java/src/com/memberwebs/httpauth/HttpAuthConnection.java b/java/src/com/memberwebs/httpauth/HttpAuthConnection.java
new file mode 100644
index 0000000..7604d31
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/HttpAuthConnection.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * A connection to the HttpAuth daemon.
+ *
+ * @author Nate Nielsen
+ */
+public class HttpAuthConnection
+    implements HttpAuthConnectionSource
+{
+    /**
+     * The option to set the authenticaton handler.
+     */
+    public static final String OPT_HANDLER = "Handler";
+
+    /**
+     * The option to set the digest domains.
+     */
+    public static final String OPT_DOMAIN = "Domain";
+
+    private Writer m_output;
+    private BufferedReader m_input;
+    private Socket m_socket;
+    private boolean m_checkedout;
+
+    /**
+     * Connects to the HttpAuth daemon at the given address and port. The
+     * appropriate handler is set.
+     *
+     * @param hostname The address where the HttpAuth daemon is running.
+     * @param port The TCP port for the HttpAuth daemon.
+     * @param handler The HttpAuth handler to use.
+     */
+    public void open(String hostname, int port, String handler)
+        throws IOException, HttpAuthException
+    {
+        HashMap options = new HashMap();
+        options.put(OPT_HANDLER, handler);
+        open(hostname, port, options);
+    }
+
+    /**
+     * Connects to the HttpAuth daemon at the given address and port. Various
+     * options (including the handler) can be set.
+     *
+     * @param hostname The address where the HttpAuth daemon is running.
+     * @param port The TCP port for the HttpAuth daemon.
+     * @param options The HttpAuth options to use. This must include {@link #OPT_HANDLER}.
+     */
+    public void open(String hostname, int port, Map options)
+        throws IOException, HttpAuthException
+    {
+        synchronized(this)
+        {
+            close();
+
+            m_socket = new Socket();
+            m_socket.connect(new InetSocketAddress(hostname, port), 60000);
+
+            m_input = new BufferedReader(new InputStreamReader(m_socket.getInputStream()));
+            m_output = new OutputStreamWriter(m_socket.getOutputStream());
+
+            // Okay now read the version number
+            Response ver = readResponse(100);
+            if(!ver.details.trim().equals("HTTPAUTH/1.0"))
+                throw new HttpAuthException("httpauthd speaking wrong version of protocol: " + ver.details);
+
+            // Set any options as necessary
+            Iterator it = options.keySet().iterator();
+            while(it.hasNext())
+            {
+                String name = (String)it.next();
+                String value = (String)options.get(name);
+
+                // Set the options request
+                sendLine("SET " + name + " " + value);
+
+                // This throws an exception if we don't get the right response
+                readResponse(202);
+            }
+        }
+    }
+
+    /**
+     * Closes the connection to the HttpAuth daemon.
+     */
+    public void close()
+        throws IOException
+    {
+        synchronized(this)
+        {
+            if(m_socket != null && m_output != null)
+            {
+                try
+                {
+                    sendLine("QUIT");
+                }
+                catch(IOException e)
+                {
+                }
+            }
+
+            if(m_output != null)
+            {
+                m_output.close();
+                m_output = null;
+            }
+
+            if(m_input != null)
+            {
+                m_input.close();
+                m_input = null;
+            }
+
+            if(m_socket != null)
+            {
+                m_socket.close();
+                m_socket = null;
+            }
+        }
+    }
+
+    /**
+     * Checks whether we're connected to the HttpAuth daemon.
+     */
+    public boolean isConnected()
+    {
+        return m_socket != null && m_socket.isConnected()
+                && m_input != null && m_output != null;
+    }
+
+    /**
+     * Sends a command string to the HttpAuth daemon.
+     *
+     * @param string The command to send.
+     */
+    public void sendLine(String string)
+        throws IOException
+    {
+        synchronized(this)
+        {
+            m_output.write(string + "\n");
+            m_output.flush();
+        }
+    }
+
+    /**
+     * Reads a response line from the HttpAuth daemon.
+     *
+     * @return The response line.
+     */
+    public String readLine()
+        throws IOException
+    {
+        synchronized(this)
+        {
+            return m_input.readLine();
+        }
+    }
+
+    /* ---------------------------------------------------------------------------
+     * HttpAuthConnectionSource
+     *
+     * This is a simple implementation which allows a single connection
+     * to be used in leu of a connection pool.
+     */
+
+    /**
+     * Treats this single connection as a pool. Checks out the current
+     * connection. Use {@link HttpAuthConnectionPool} instead.
+     * @return The connection.
+     */
+    public HttpAuthConnection getOpenConnection()
+        throws HttpAuthException
+    {
+        synchronized(this)
+        {
+            if(isConnected() && !m_checkedout)
+                return null;
+
+            m_checkedout = true;
+            return this;
+        }
+    }
+
+    /**
+     * Treats this single connection as a pool. Checks in the current
+     * connection. Use {@link HttpAuthConnectionPool} instead.
+     * @param conn The connection.
+     */
+    public void doneWithConnection(HttpAuthConnection conn)
+        throws HttpAuthException
+    {
+        synchronized(this)
+        {
+            m_checkedout = false;
+        }
+    }
+
+    // -----------------------------------------------------------------------------
+    // Helper functions
+
+    protected Response readResponse(int expected)
+        throws HttpAuthException, IOException
+    {
+        Response resp = new Response();
+        String line = readLine();
+
+        if(line == null)
+            throw new IOException("unexpected end of data from httpauthd");
+
+        String word = parseWord(line);
+        line = line.substring(word.length());
+        word = word.trim();
+
+        try
+        {
+            int code = Integer.parseInt(word, 10);
+            if(code < 100 || code > 599)
+                throw new NumberFormatException();
+
+            resp.code = code;
+        }
+        catch(NumberFormatException e)
+        {
+            throw new HttpAuthException("httpauth protocol error. invalid code received: " + word);
+        }
+
+        if(expected != 0 && resp.code != expected)
+            throw new HttpAuthException("httpauth protocol error. expected code '" + expected + "' and got: " + resp.code);
+
+        if(resp.code == 200)
+        {
+            word = parseWord(line);
+            line = line.substring(word.length()).trim();
+            word = word.trim();
+
+            try
+            {
+                int code = Integer.parseInt(word, 10);
+                if(code < 100 || code > 599)
+                    throw new NumberFormatException();
+
+                resp.ccode = code;
+            }
+            catch(NumberFormatException e)
+            {
+                throw new HttpAuthException("httpauth protocol error. invalid code received: " + word);
+            }
+        }
+
+        if(line.length() > 0)
+            resp.details = line;
+
+        return resp;
+    }
+
+    protected String parseWord(String line)
+    {
+        int start = -1;
+        int end;
+        char ch;
+
+        while(true)
+        {
+            if(++start >= line.length())
+                return "";
+
+            ch = line.charAt(start);
+            if(ch != ' ' && ch != '\t')
+                break;
+        }
+
+        end = start - 1;
+
+        while(true)
+        {
+            if(++end >= line.length())
+                break;
+
+            ch = line.charAt(end);
+            if(ch == ' ' || ch == '\t')
+                break;
+        }
+
+        if(end == -1)
+            return "";
+
+        return line.substring(0, end);
+    }
+
+    class Response
+    {
+        int code;
+        int ccode;
+        String details;
+    };
+}
diff --git a/java/src/com/memberwebs/httpauth/HttpAuthConnectionPool.java b/java/src/com/memberwebs/httpauth/HttpAuthConnectionPool.java
new file mode 100644
index 0000000..089402b
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/HttpAuthConnectionPool.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+/**
+ * A pool of connections to the HttpAuth daemon.
+ *
+ * @author Nate Nielsen
+ */
+public class HttpAuthConnectionPool
+    implements HttpAuthConnectionSource
+{
+    private Stack m_connections;
+    private short m_checkedout;
+    private short m_max;
+
+    private String m_hostname;
+    private int m_port;
+    private Map m_options;
+
+    /**
+     * Creates a new pool of connections to the HttpAuth daemon at the given
+     * address. The connections will be setup to use the given handler.
+     *
+     * @param hostname The address at which the HttpAuth daemon is running.
+     * @param port The TCP port at which the HttpAuth daemon is listening on.
+     * @param handler The HttpAuth handler to use.
+     */
+    public HttpAuthConnectionPool(String hostname, int port, String handler)
+    {
+        m_hostname = hostname;
+        m_port = port;
+        m_checkedout = 0;
+        m_max = 16;
+        m_connections = new Stack();
+        m_options = new HashMap();
+        m_options.put(HttpAuthConnection.OPT_HANDLER, handler);
+    }
+
+    /**
+     * Creates a new pool of connections to the HttpAuth daemon at the given
+     * address. The connections will be setup with the various options.
+     *
+     * @param hostname The address at which the HttpAuth daemon is running.
+     * @param port The TCP port at which the HttpAuth daemon is listening on.
+     * @param options The HttpAuth options to use. This must include {@link #HttpAuthConnection.OPT_HANDLER}.
+     */
+    public HttpAuthConnectionPool(String hostname, int port, Map options)
+    {
+        m_hostname = hostname;
+        m_port = port;
+        m_checkedout = 0;
+        m_max = 16;
+        m_connections = new Stack();
+        m_options = options;
+    }
+
+    /**
+     * Set the maximum number of connections available in this pool.
+     * @param max The maximum number of connections.
+     */
+    public void setMax(short max)
+    {
+        m_max = max;
+    }
+
+    /* ---------------------------------------------------------------------------
+     * HttpAuthConnectionSource
+     */
+
+    /**
+     * Retrieves a connection from the pool.
+     * @return The connection.
+     */
+    public HttpAuthConnection getOpenConnection()
+        throws HttpAuthException
+    {
+        synchronized(this)
+        {
+            HttpAuthConnection conn = null;
+
+            while(!m_connections.empty())
+            {
+                conn = (HttpAuthConnection)m_connections.pop();
+                if(conn != null && conn.isConnected())
+                {
+                    m_checkedout++;
+                    return conn;
+                }
+            }
+
+            if(m_checkedout >= m_max)
+                throw new HttpAuthException("too many connections to httpauthd: " + m_checkedout);
+
+            try
+            {
+                // Otherwise we make a new connection
+                conn = new HttpAuthConnection();
+                conn.open(m_hostname, m_port, m_options);
+                m_checkedout++;
+                return conn;
+            }
+            catch(IOException e)
+            {
+                throw new HttpAuthException("couldn't connect to httpauthd: " + e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * Puts a connection back in the pool.
+     * @param conn The connection.
+     */
+    public void doneWithConnection(HttpAuthConnection conn)
+        throws HttpAuthException
+    {
+        synchronized(this)
+        {
+            if(m_checkedout > 0)
+                m_checkedout--;
+
+            if(conn.isConnected())
+            {
+                // TODO: I don't know of any way to drain the remaining
+                // junk out of a socket here without blocking. :(
+
+                m_connections.push(conn);
+            }
+        }
+    }
+}
diff --git a/java/src/com/memberwebs/httpauth/HttpAuthConnectionSource.java b/java/src/com/memberwebs/httpauth/HttpAuthConnectionSource.java
new file mode 100644
index 0000000..eab8eb5
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/HttpAuthConnectionSource.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth;
+
+/**
+ * An interface for a pool of HttpAuth connections.
+ *
+ * @author Nate Nielsen
+ */
+public interface HttpAuthConnectionSource
+{
+    /**
+     * Retrieves a connection from the pool.
+     * @return The connection.
+     */
+    public HttpAuthConnection getOpenConnection()
+        throws HttpAuthException;
+
+    /**
+     * Puts a connection back in the pool.
+     * @param conn The connection.
+     */
+    public void doneWithConnection(HttpAuthConnection conn)
+        throws HttpAuthException;
+}
diff --git a/java/src/com/memberwebs/httpauth/HttpAuthException.java b/java/src/com/memberwebs/httpauth/HttpAuthException.java
new file mode 100644
index 0000000..c342302
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/HttpAuthException.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth;
+
+
+/**
+ * A general utility exception which can wrap another exception or
+ * hold it's own message
+ *
+ * @author Nate Nielsen
+ */
+public class HttpAuthException
+    extends Exception
+{
+    // The internal exception
+    private Exception m_exception;
+
+    /**
+     * Creates a new HttpAuthException with a message
+     *
+     * @param message The message to include.
+     */
+    public HttpAuthException(String message)
+    {
+        this(message, null);
+    }
+
+    /**
+     * Creates a new HttpAuthException with an exception
+     * held internally.
+     *
+     * @param e The internal exception.
+     */
+    public HttpAuthException(Exception e)
+    {
+        this(null, e);
+    }
+
+    /**
+     * Creates a new HttpAuthException with a message and an
+     * exception exception held internally.
+     *
+     * @param message The message to include.
+     * @param e The internal exception.
+     */
+    public HttpAuthException(String message, Exception e)
+    {
+        super(message);
+        if(e != null)
+            m_exception = e;
+    }
+
+    /**
+     * Returns the error message of this exception if present, or
+     * the internal exception.
+     *
+     * @return The message.
+     */
+    public String getMessage()
+    {
+        String message = super.getMessage();
+
+        if(message == null && m_exception != null)
+            message = m_exception.getMessage();
+
+        return message;
+    }
+
+    /**
+     * Returns the internal exception, or this if not present.
+     *
+     * @return The exception.
+     */
+    public Exception getException()
+    {
+        if(m_exception == null)
+            return this;
+        else
+            return m_exception;
+    }
+
+    /**
+     * Converts this object to a string.
+     *
+     * @return The string value.
+     */
+    public String toString ()
+    {
+        if(m_exception != null)
+            return m_exception.toString();
+        else
+            return super.toString();
+    }
+
+    public StackTraceElement[] getStackTrace()
+    {
+        return getStackTrace();
+    }
+
+    // A dumb id to suppress compiler warnings
+    private static final long serialVersionUID = 9117749574169057520L;
+
+}
diff --git a/java/src/com/memberwebs/httpauth/HttpAuthFilter.java b/java/src/com/memberwebs/httpauth/HttpAuthFilter.java
new file mode 100644
index 0000000..1c7367d
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/HttpAuthFilter.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth;
+
+/**
+ * Implement this interface if you want to limit the type of
+ * authentication available for each request. This could allow
+ * more insecure authentication over SSL for example.
+ *
+ * @author Nate Nielsen
+ */
+public interface HttpAuthFilter
+{
+    /**
+     * Return the types of authentication allowed.
+     * @param address The address for the request.
+     * @param secure Whether the request came over a secure channel or not.
+     * @return The types of authentication allowed.
+     */
+    String[] getAuthTypes(String address, boolean secure);
+}
diff --git a/java/src/com/memberwebs/httpauth/jetty/JettyHttpAuthenticator.java b/java/src/com/memberwebs/httpauth/jetty/JettyHttpAuthenticator.java
new file mode 100644
index 0000000..bcca142
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/jetty/JettyHttpAuthenticator.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth.jetty;
+
+import java.io.IOException;
+import java.util.Enumeration;
+
+import org.mortbay.http.HttpRequest;
+import org.mortbay.http.HttpResponse;
+import org.mortbay.http.UserPrincipal;
+import org.mortbay.http.UserRealm;
+import org.mortbay.http.SecurityConstraint.Authenticator;
+
+import com.memberwebs.httpauth.BaseHttpAuthenticator;
+import com.memberwebs.httpauth.HttpAuthConnectionSource;
+import com.memberwebs.httpauth.HttpAuthException;
+import com.memberwebs.httpauth.HttpAuthFilter;
+
+/**
+ * An authenticator for the Jetty web server. An instance of this object
+ * is used by a Jetty HttpContext to perform authentication.
+ *
+ * @author Nate Nielsen
+ */
+public class JettyHttpAuthenticator
+    extends BaseHttpAuthenticator
+    implements Authenticator
+{
+    protected HttpAuthFilter m_filter;
+
+    /**
+     * Creates a new JettyHttpAuthenticator.
+     *
+     * @param source A source of HttpAuth connections
+     *               (such as {@link #HttpAuthConnectionPool})
+     * @param filter An optional filter which determines
+     *               which types of authentication may be performed.
+     */
+    public JettyHttpAuthenticator(HttpAuthConnectionSource source,
+                                  HttpAuthFilter filter)
+    {
+        super(source);
+        m_filter = filter;
+    }
+
+    /**
+     * Called by Jetty's HttpContext to perform authentication.
+     * @param realm
+     * @param pathInContext
+     * @param request
+     * @param response
+     * @return Used by Jetty to identify the user.
+     */
+    public UserPrincipal authenticated(UserRealm realm, String pathInContext,
+                                       HttpRequest request, HttpResponse response)
+        throws IOException
+    {
+        // We ignore the realm
+
+        String[] authtypes = null;
+
+        if(m_filter != null)
+            authtypes = m_filter.getAuthTypes(request.getRemoteAddr(), request.isConfidential());
+
+        String user = null;
+
+        try
+        {
+            user = authenticateRequest(request, response, "XXX", request.getMethod(),
+                                       request.getURI().toString(), authtypes);
+        }
+        catch(HttpAuthException e)
+        {
+            throw new IOException(e.getMessage());
+        }
+
+        if(user == null)
+            return null;
+
+        HttpAuthPrincipal principal = new HttpAuthPrincipal(user);
+
+        request.setAuthType("HTTPAUTH");
+        request.setAuthUser(user);
+        request.setUserPrincipal(principal);
+
+        return principal;
+    }
+
+    /**
+     * Called by Jetty's HttpContext to get authentication method.
+     * @return Used by Jetty to identify the method.
+     */
+    public String getAuthMethod()
+    {
+        return "HTTPAUTH";
+    }
+
+    /* -------------------------------------------------------------------------
+     * OVERRIDES
+     */
+
+    protected void addResponseHeader(Object response, String name, String value)
+    {
+        HttpResponse resp = (HttpResponse)response;
+        resp.addField(name, value);
+    }
+
+    protected void setResponseResult(Object response, int code)
+        throws IOException
+    {
+        HttpResponse resp = (HttpResponse)response;
+
+        if(code >= 300)
+            resp.sendError(code);
+        else
+            resp.setStatus(code);
+    }
+
+    protected Enumeration getHeaderValues(Object request, String name)
+    {
+        HttpRequest req = (HttpRequest)request;
+        return req.getFieldValues(name);
+    }
+
+    protected Enumeration getHeaderNames(Object request)
+    {
+        HttpRequest req = (HttpRequest)request;
+        return req.getFieldNames();
+    }
+
+    protected class HttpAuthPrincipal
+        implements UserPrincipal
+    {
+        private String m_name;
+
+        public HttpAuthPrincipal(String name)
+        {
+            m_name = name;
+        }
+
+        public boolean isAuthenticated()
+        {
+            return true;
+        }
+
+        public boolean isUserInRole(String role)
+        {
+            return false;
+        }
+
+        public String getName()
+        {
+            return m_name;
+        }
+    }
+
+    // A dumb ID to suppress compiler warnings
+    private static final long serialVersionUID = -1266258707017895782L;
+}
diff --git a/java/src/com/memberwebs/httpauth/servlet/ServletHttpAuthenticator.java b/java/src/com/memberwebs/httpauth/servlet/ServletHttpAuthenticator.java
new file mode 100644
index 0000000..4e2d025
--- /dev/null
+++ b/java/src/com/memberwebs/httpauth/servlet/ServletHttpAuthenticator.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2004, Nate Nielsen
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ *
+ * CONTRIBUTORS
+ *  Nate Nielsen <nielsen@memberwebs.com>
+ *
+ */
+
+package com.memberwebs.httpauth.servlet;
+
+import java.io.IOException;
+import java.util.Enumeration;
+
+import javax.servlet.ServletException;
+import javax.servlet.UnavailableException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.memberwebs.httpauth.BaseHttpAuthenticator;
+import com.memberwebs.httpauth.HttpAuthConnectionSource;
+import com.memberwebs.httpauth.HttpAuthException;
+
+/**
+ * A class which can be used by servlets to authenticate the user for
+ * a given request.
+ *
+ * Note that the user will not be set on the request and will not be
+ * available via req.getRemoteUser().
+ *
+ * @author Nate Nielsen
+ */
+
+public class ServletHttpAuthenticator
+    extends BaseHttpAuthenticator
+{
+    /**
+     * Creates a new ServletHttpAuthenticator.
+     *
+     * @param source A source of HttpAuth connections
+     *               (such as {@link #HttpAuthConnectionPool})
+     */
+    public ServletHttpAuthenticator(HttpAuthConnectionSource source)
+    {
+        super(source);
+    }
+
+    /**
+     * Authenticate a request. If the authentication fails, headers and
+     * a response will be sent.
+     *
+     * @param req The HTTP request.
+     * @param resp The HTTP response used when authentication fails.
+     * @return The authenticated user name, or null if unsuccessful.
+     */
+    public String authenticate(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException
+    {
+        return authenticate(req, resp, null);
+    }
+
+    /**
+     * Authenticate a request. If the authentication fails, headers and
+     * a response will be sent. The caller can limit the types of
+     * authentication allowed.
+     *
+     * @param req The HTTP request.
+     * @param resp The HTTP response used when authentication fails.
+     * @param authtypes The types of authentication allowed.
+     * @return The authenticated user name, or null if unsuccessful.
+     */
+    public String authenticate(HttpServletRequest req, HttpServletResponse resp,
+                               String[] authtypes)
+        throws ServletException
+    {
+        String method = req.getMethod();
+        String uri = req.getRequestURI();
+
+        String qs = req.getQueryString();
+        if(qs != null)
+            uri += qs;
+
+        // NOTE: We can't set the remote user on the request. That's just
+        // the way the interfaces are designed
+
+        try
+        {
+            return authenticateRequest(req, resp, "XXX", method, uri, authtypes);
+        }
+        catch(HttpAuthException e)
+        {
+            throw new UnavailableException(e.getMessage(), 30);
+        }
+    }
+
+    /* -------------------------------------------------------------------------
+     * OVERRIDES
+     */
+
+    protected void addResponseHeader(Object response, String name, String value)
+    {
+        HttpServletResponse resp = (HttpServletResponse)response;
+        resp.addHeader(name, value);
+    }
+
+    protected void setResponseResult(Object response, int code)
+        throws IOException
+    {
+        HttpServletResponse resp = (HttpServletResponse)response;
+        if(code >= 200 && code < 300)
+            resp.setStatus(code);
+        else
+            resp.sendError(code);
+    }
+
+    protected Enumeration getHeaderValues(Object request, String name)
+    {
+        HttpServletRequest req = (HttpServletRequest)request;
+        return req.getHeaders(name);
+    }
+
+    protected Enumeration getHeaderNames(Object request)
+    {
+        HttpServletRequest req = (HttpServletRequest)request;
+        return req.getHeaderNames();
+    }
+}