com.cazoodle.crawl.DummySSLProtocolSocketFactory.java Source code

Introduction

Here is the source code for com.cazoodle.crawl.DummySSLProtocolSocketFactory.java

Source

/*
* 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.
*/
/*
 * Based on EasySSLProtocolSocketFactory from commons-httpclient:
 * 
 * $Header:
 * /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/contrib/org/apache/commons/httpclient/contrib/ssl/DummySSLProtocolSocketFactory.java,v
 * 1.7 2004/06/11 19:26:27 olegk Exp $ $Revision$ $Date: 2005-02-26 05:01:52
 * -0800 (Sat, 26 Feb 2005) $
 */

package com.cazoodle.crawl;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;

import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.HttpClientError;
import org.apache.commons.httpclient.params.HttpConnectionParams;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.cazoodle.lib.CounterCache;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;

/**
 * Socket Factory for SSL Protocol
 *
 */
public class DummySSLProtocolSocketFactory implements ProtocolSocketFactory {
    private static final Log LOG = LogFactory.getLog(DummySSLProtocolSocketFactory.class);
    private static DummySSLProtocolSocketFactory instance = null;

    public static DummySSLProtocolSocketFactory getInstance() {
        if (instance == null) {
            instance = new DummySSLProtocolSocketFactory();
        }
        return instance;
    }

    private SSLContext sslcontext = null;
    private CounterCache<String, byte[]> dnsCache;

    public DummySSLProtocolSocketFactory() {
        dnsCache = new CounterCache<String, byte[]>();
    }

    public void addDNS(String host, byte[] ip) {
        dnsCache.addValue(host, ip);
    }

    private InetAddress getInetAddress(String host) throws UnknownHostException {
        byte[] ip = dnsCache.getValue(host);
        if (ip == null) {
            LOG.debug(host + ": No IP cached, DNS resolving");
            return InetAddress.getByName(host);
        } else {
            LOG.debug(host + ": IP cached, skip DNS");
            return InetAddress.getByAddress(host, ip);
        }
    }

    private static SSLContext createEasySSLContext() {
        try {
            SSLContext context = SSLContext.getInstance("SSL");
            context.init(null, new TrustManager[] { new DummyX509TrustManager(null) }, null);
            return context;
        } catch (Exception e) {
            if (LOG.isErrorEnabled()) {
                LOG.error(e.getMessage(), e);
            }
            throw new HttpClientError(e.toString());
        }
    }

    private SSLContext getSSLContext() {
        if (this.sslcontext == null) {
            this.sslcontext = createEasySSLContext();
        }
        return this.sslcontext;
    }

    public Socket createSocket(final String host, final int port, final InetAddress localAddress,
            final int localPort, final HttpConnectionParams params)
            throws IOException, UnknownHostException, ConnectTimeoutException {
        if (params == null) {
            throw new IllegalArgumentException("Parameters may not be null");
        }
        int timeout = params.getConnectionTimeout();
        if (timeout > 0) {
            Socket socket = getSSLContext().getSocketFactory().createSocket();
            socket.bind(new InetSocketAddress(localAddress, localPort));
            socket.setSoTimeout(timeout);
            socket.connect(new InetSocketAddress(getInetAddress(host), port), timeout);
            return socket;
        } else {
            return createSocket(host, port, localAddress, localPort);
        }
    }

    /**
     * @see org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory#createSocket(String,int)
     */
    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(getInetAddress(host), port);
    }

    public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort)
            throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(getInetAddress(host), port, clientHost, clientPort);
    }

    @Override
    public boolean equals(Object obj) {
        return ((obj != null) && obj.getClass().equals(DummySSLProtocolSocketFactory.class));
    }

    @Override
    public int hashCode() {
        return DummySSLProtocolSocketFactory.class.hashCode();
    }
}