WebServer.java

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */
package org.apache.xmlrpc.webserver;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.BindException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.xmlrpc.server.XmlRpcStreamServer;
import org.apache.xmlrpc.util.ThreadPool;


public class WebServer implements Runnable {
        private class AddressMatcher {
                private final int pattern[];
                
                AddressMatcher(String pAddress) {
                        try {
                                pattern = new int[4];
                                StringTokenizer st = new StringTokenizer(pAddress, ".");
                                if (st.countTokens() != 4) {
                                        throw new IllegalArgumentException();
                                }
                                for (int i = 0; i < 4; i++)     {
                                        String next = st.nextToken();
                                        if ("*".equals(next)) {
                                                pattern[i] = 256;
                                        } else {
                                            /* Note: *Not* pattern[i] = Integer.parseInt(next);
                                             * See XMLRPC-145
                                             */
                                                pattern[i] = (byte) Integer.parseInt(next);
                                        }
                                }
                        } catch (Exception e) {
                                throw new IllegalArgumentException("\"" + pAddress
                                                + "\" does not represent a valid IP address");
                        }
                }
                
                boolean matches(byte[] pAddress) {
                        for (int i = 0; i < 4; i++)     {
                                if (pattern[i] > 255) {
                                        continue; // Wildcard
                                }
                                if (pattern[i] != pAddress[i]) {
                                        return false;
                                }
                        }
                        return true;
                }
        }

        protected ServerSocket serverSocket;
        private Thread listener;
        private ThreadPool pool;
        protected final List accept = new ArrayList();
        protected final List deny = new ArrayList();
        protected final XmlRpcStreamServer server = newXmlRpcStreamServer();

        protected XmlRpcStreamServer newXmlRpcStreamServer(){
                return new ConnectionServer();
        }

        // Inputs to setupServerSocket()
        private InetAddress address;
        private int port;
        
        private boolean paranoid;
        
        static final String HTTP_11 = "HTTP/1.1";
        public WebServer(int pPort) {
                this(pPort, null);
        }
        
        public WebServer(int pPort, InetAddress pAddr) {
                address = pAddr;
                port = pPort;
        }
        
        protected ServerSocket createServerSocket(int pPort, int backlog, InetAddress addr)
                        throws IOException {
                return new ServerSocket(pPort, backlog, addr);
        }
        
        private synchronized void setupServerSocket(int backlog) throws IOException {
                // Since we can't reliably set SO_REUSEADDR until JDK 1.4 is
                // the standard, try to (re-)open the server socket several
                // times.  Some OSes (Linux and Solaris, for example), hold on
                // to listener sockets for a brief period of time for security
                // reasons before relinquishing their hold.
                for (int i = 1;  ;  i++) {
                        try {
                                serverSocket = createServerSocket(port, backlog, address);
                                // A socket timeout must be set.
                                if (serverSocket.getSoTimeout() <= 0) {
                                        serverSocket.setSoTimeout(4096);
                                }
                                return;
                        } catch (BindException e) {
                                if (i == 10) {
                                        throw e;
                                } else {
                                        long waitUntil = System.currentTimeMillis() + 1000;
                                        for (;;) {
                                                long l = waitUntil - System.currentTimeMillis();
                                                if (l > 0) {
                                                        try {
                                                                Thread.sleep(l);
                                                        } catch (InterruptedException ex) {
                                                        }
                                                } else {
                                                    break;
                        }
                                        }
                                }
                        }
                }
        }
        
        public void start() throws IOException {
                setupServerSocket(50);
                
                // The listener reference is released upon shutdown().
                if (listener == null) {
                        listener = new Thread(this, "XML-RPC Weblistener");
                        // Not marked as daemon thread since run directly via main().
                        listener.start();
                }
        }
        
        public void setParanoid(boolean pParanoid) {
                paranoid = pParanoid;
        }

        protected boolean isParanoid() {
                return paranoid;
        }
        
        public void acceptClient(String pAddress) {
                accept.add(new AddressMatcher(pAddress));
        }
        
        public void denyClient(String pAddress) {
                deny.add(new AddressMatcher(pAddress));
        }
        
        protected boolean allowConnection(Socket s) {
                if (!paranoid) {
                        return true;
                }
                
                int l = deny.size();
                byte addr[] = s.getInetAddress().getAddress();
                for (int i = 0; i < l; i++) {
                        AddressMatcher match = (AddressMatcher) deny.get(i);
                        if (match.matches(addr))
                        {
                                return false;
                        }
                }
                l = accept.size();
                for (int i = 0; i < l; i++) {
                        AddressMatcher match = (AddressMatcher) accept.get(i);
                        if (match.matches(addr)) {
                                return true;
                        }
                }
                return false;
        }

        protected ThreadPool.Task newTask(WebServer pServer, XmlRpcStreamServer pXmlRpcServer,
                                                                          Socket pSocket) throws IOException {
                return new Connection(pServer, pXmlRpcServer, pSocket);
        }

        public void run() {
                pool = newThreadPool();
                try {
                        while (listener != null) {
                                try {
                                        Socket socket = serverSocket.accept();
                                        try {
                                                socket.setTcpNoDelay(true);
                                        } catch (SocketException socketOptEx) {
                                                log(socketOptEx);
                                        }
                                        
                                        try {
                                                if (allowConnection(socket)) {
                                                // set read timeout to 30 seconds
                                                socket.setSoTimeout(30000);
                                                        final ThreadPool.Task task = newTask(this, server, socket);
                                                        if (pool.startTask(task)) {
                                                                socket = null;
                                                        } else {
                                                                log("Maximum load of " + pool.getMaxThreads()
                                                                        + " exceeded, rejecting client");
                                                        }
                                                }
                                        } finally {
                                                if (socket != null) { try { socket.close(); } catch (Throwable ignore) {} }
                                        }
                                } catch (InterruptedIOException checkState) {
                                        // Timeout while waiting for a client (from
                                        // SO_TIMEOUT)...try again if still listening.
                                } catch (Throwable t) {
                                        log(t);
                                }
                        }
                } finally {
                        if (serverSocket != null) {
                                try {
                                        serverSocket.close();
                                } catch (IOException e) {
                                        log(e);
                                }
                        }
                        
                        // Shutdown our Runner-based threads
                        pool.shutdown();
                }
        }

    protected ThreadPool newThreadPool() {
        return new ThreadPool(server.getMaxThreads(), "XML-RPC");
    }
        
        public synchronized void shutdown() {
                // Stop accepting client connections
                if (listener != null) {
                        Thread l = listener;
                        listener = null;
                        l.interrupt();
            if (pool != null) {
                pool.shutdown();
            }
                }
        }
        
        public int getPort() { return serverSocket.getLocalPort(); }

        public void log(Throwable pError) {
            final String msg = pError.getMessage() == null ? pError.getClass().getName() : pError.getMessage();
            server.getErrorLogger().log(msg, pError);
        }

        public void log(String pMessage) {
        server.getErrorLogger().log(pMessage);
        }

        public XmlRpcStreamServer getXmlRpcServer() {
                return server;
        }
}