v1.5.1RC3/modules/transport/http/src/org/apache/axis2/transport/http/server/AxisHttpConnectionImpl.java

/*
 * 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.axis2.transport.http.server;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HeaderIterator;
import org.apache.http.HttpConnectionMetrics;
import org.apache.http.HttpEntity;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpException;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.ProtocolVersion;
import org.apache.http.entity.ContentLengthStrategy;
import org.apache.http.impl.DefaultHttpRequestFactory;
import org.apache.http.impl.entity.StrictContentLengthStrategy;
import org.apache.http.impl.io.ChunkedInputStream;
import org.apache.http.impl.io.ChunkedOutputStream;
import org.apache.http.impl.io.ContentLengthInputStream;
import org.apache.http.impl.io.ContentLengthOutputStream;
import org.apache.http.impl.io.HttpRequestParser;
import org.apache.http.impl.io.HttpResponseWriter;
import org.apache.http.impl.io.IdentityInputStream;
import org.apache.http.impl.io.IdentityOutputStream;
import org.apache.http.impl.io.SocketInputBuffer;
import org.apache.http.impl.io.SocketOutputBuffer;
import org.apache.http.io.HttpMessageParser;
import org.apache.http.io.HttpMessageWriter;
import org.apache.http.io.SessionInputBuffer;
import org.apache.http.io.SessionOutputBuffer;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;

public class AxisHttpConnectionImpl implements AxisHttpConnection {

    private static final Log HEADERLOG =
        LogFactory.getLog("org.apache.axis2.transport.http.server.wire");

    private final Socket socket;
    private final SessionOutputBuffer outbuffer;
    private final SessionInputBuffer inbuffer;
    private final HttpMessageParser requestParser;
    private final HttpMessageWriter responseWriter;
    private final ContentLengthStrategy contentLenStrategy;

    private OutputStream out = null;
    private InputStream in = null;
    
    public AxisHttpConnectionImpl(final Socket socket, final HttpParams params) 
            throws IOException {
        super();
        if (socket == null) {
            throw new IllegalArgumentException("Socket may not be null"); 
        }
        if (params == null) {
            throw new IllegalArgumentException("HTTP parameters may not be null"); 
        }
        socket.setTcpNoDelay(HttpConnectionParams.getTcpNoDelay(params));
        socket.setSoTimeout(HttpConnectionParams.getSoTimeout(params));
        
        int linger = HttpConnectionParams.getLinger(params);
        if (linger >= 0) {
            socket.setSoLinger(linger > 0, linger);
        }
        
        int buffersize = HttpConnectionParams.getSocketBufferSize(params);
        this.socket = socket;
        this.outbuffer = new SocketOutputBuffer(socket, buffersize, params); 
        this.inbuffer = new SocketInputBuffer(socket, buffersize, params); 
        this.contentLenStrategy = new StrictContentLengthStrategy();
        this.requestParser = new HttpRequestParser(
                this.inbuffer, null, new DefaultHttpRequestFactory(), params);
        this.responseWriter = new HttpResponseWriter(
                this.outbuffer, null, params);
    }

    public void close() throws IOException {
        this.outbuffer.flush();
        try {
            this.socket.shutdownOutput();
        } catch (IOException ignore) {
        }
        try {
            this.socket.shutdownInput();
        } catch (IOException ignore) {
        }
        this.socket.close();
    }

    public boolean isOpen() {
        return !this.socket.isClosed();
    }

    public boolean isStale() {
        try {
            this.inbuffer.isDataAvailable(1);
            return false;
        } catch (IOException ex) {
            return true;
        }
    }

    public void shutdown() throws IOException {
        Socket tmpsocket = this.socket;
        if (tmpsocket != null) {
            tmpsocket.close();
        }
    }

    public HttpRequest receiveRequest() throws HttpException, IOException {
        HttpRequest request = (HttpRequest) this.requestParser.parse();
        if (HEADERLOG.isDebugEnabled()) {
            HEADERLOG.debug(">> " + request.getRequestLine().toString());
            for (HeaderIterator it = request.headerIterator(); it.hasNext(); ) {
                HEADERLOG.debug(">> " + it.nextHeader().toString());
            }
        }
        
        // Prepare input stream
        this.in = null;
        if (request instanceof HttpEntityEnclosingRequest) {
            long len = this.contentLenStrategy.determineLength(request);
            if (len == ContentLengthStrategy.CHUNKED) {
                this.in = new ChunkedInputStream(this.inbuffer);
            } else if (len == ContentLengthStrategy.IDENTITY) {
                this.in = new IdentityInputStream(this.inbuffer);                            
            } else {
                this.in = new ContentLengthInputStream(inbuffer, len);
            }
        }
        return request;
    }
    
    public void sendResponse(final HttpResponse response) 
            throws HttpException, IOException {
        if (response == null) {
            throw new IllegalArgumentException("HTTP response may not be null");
        }

        if (HEADERLOG.isDebugEnabled()) {
            HEADERLOG.debug("<< " + response.getStatusLine().toString());
            for (HeaderIterator it = response.headerIterator(); it.hasNext(); ) {
                HEADERLOG.debug("<< " + it.nextHeader().toString());
            }
        }
        
        this.responseWriter.write(response);

        // Prepare output stream
        this.out = null;
        ProtocolVersion ver = response.getStatusLine().getProtocolVersion();
        HttpEntity entity = response.getEntity();
        if (entity != null) {
            long len = entity.getContentLength();
            if (entity.isChunked() && ver.greaterEquals(HttpVersion.HTTP_1_1)) {
                this.out = new ChunkedOutputStream(this.outbuffer);
            } else if (len >= 0) {
                this.out = new ContentLengthOutputStream(this.outbuffer, len);
            } else {
                this.out = new IdentityOutputStream(this.outbuffer); 
            }
        } else {
            this.outbuffer.flush();
        }
    }
    
    public InputStream getInputStream() {
        return this.in;
    }

    public OutputStream getOutputStream() {
        return this.out;
    }
    
    public void flush() throws IOException {
        if (this.out != null) {
            this.out.flush();
        } else {
            this.outbuffer.flush();
        }
    }

    public void reset() throws IOException {
        if (this.in != null) {
            this.in.close();
            this.in = null;
        }
        if (this.out != null) {
            this.out.flush();
            this.out.close();
            this.out = null;
        }
    }
    
    public int getSocketTimeout() {
        try {
            return this.socket.getSoTimeout();
        } catch (SocketException ex) {
            return -1;
        }
    }

    public void setSocketTimeout(int timeout) {
        try {
            this.socket.setSoTimeout(timeout);
        } catch (SocketException ex) {
        }
    }

    public InetAddress getLocalAddress() {
        if (this.socket != null) {
            return this.socket.getLocalAddress();
        } else {
            return null;
        }
    }

    public int getLocalPort() {
        if (this.socket != null) {
            return this.socket.getLocalPort();
        } else {
            return -1;
        }
    }

    public InetAddress getRemoteAddress() {
        if (this.socket != null) {
            return this.socket.getInetAddress();
        } else {
            return null;
        }
    }

    public int getRemotePort() {
        if (this.socket != null) {
            return this.socket.getPort();
        } else {
            return -1;
        }
    }

    public HttpConnectionMetrics getMetrics() {
        return null;
    }

    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("[");
        if (isOpen()) {
            buffer.append(this.socket.getInetAddress());
        } else {
            buffer.append("closed");
        }
        buffer.append("]");
        return buffer.toString();
    }

}