//
// $Id: FileUploadThreadHTTP.java 488 2008-07-06 20:21:43Z etienne_sf $
//
// jupload - A file upload applet.
// Copyright 2007 The JUpload Team
//
// Created: 2007-03-07
// Creator: etienne_sf
// Last modified: $Date: 2008-07-06 22:21:43 +0200 (dim., 06 juil. 2008) $
//
// This program is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation; either version 2 of the License, or (at your option) any later
// version. This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details. You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software Foundation, Inc.,
// 675 Mass Ave, Cambridge, MA 02139, USA.

package wjhk.jupload2.upload.helper;

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PushbackInputStream;
import java.net.Proxy;
import java.net.ProxySelector;
import java.net.Socket;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

import wjhk.jupload2.exception.JUploadException;
import wjhk.jupload2.exception.JUploadIOException;
import wjhk.jupload2.policies.UploadPolicy;

/**
 * This class contains utilities to delegate network manipulation. It hides the
 * management for the current upload policy connection parameters.<BR>
 * This class goes through the following states, stored in the private
 * connectionStatus attribute: <DIR> <LI>STATUS_NOT_INITIALIZED: default status
 * when the instance in created. Only available action:
 * {@link #initRequest(URL, String, boolean, boolean)} <LI>
 * STATUS_BEFORE_SERVER_CONNECTION: the instance is initialized, and the caller
 * may begin writing the request to this HttpConnectionHelper. All data written
 * to it, will be stored in a {@link ByteArrayEncoderHTTP}. The connection
 * switches to this status when the
 * {@link #initRequest(URL, String, boolean, boolean)} is called. <LI>
 * STATUS_WRITING_REQUEST: The network connection to the server is now opened.
 * The content of the ByteArrayEncoderHTTP has been sent to the server. All
 * subsequent calls to write methods will directly write on the socket to the
 * server. The {@link #sendRequest()} method changes the connection to this
 * status. <LI>STATUS_READING_RESPONSE: The request to the server has been
 * totally written. No more calls to the write methods are allowed. The
 * {@link #readHttpResponse()} is responsible to put the HttpConnectionHelper to
 * this status. <LI>STATUS_CONNECTION_CLOSED: The response has been read. All
 * getters can be called, to get information about the server response. The only
 * other method allowed is the
 * {@link #initRequest(URL, String, boolean, boolean)}, to start a new request
 * to the server. Using the same HttpConnectionHelper allows to use the same
 * network connection, when the allowHttpPersistent applet parameter is used.
 * </DIR>
 * 
 * @author etienne_sf
 */
public class HTTPConnectionHelper extends OutputStream {

	// FIXME Does HTTPConnectionHelper really need to be an OutputStream? (Find
	// Bug generate not closed exception)

	// ////////////////////////////////////////////////////////////////////////////////////
	// /////////////////// PRIVATE CONSTANTS
	// ////////////////////////////////////////////////////////////////////////////////////
	/**
	 * Indicates that the connection has not been initialized. The only
	 * authorized action in this state is a call to
	 * {@link #initRequest(URL, String, boolean, boolean)}.
	 */
	final static private int STATUS_NOT_INITIALIZED = 0;

	/**
	 * Indicates that the network connection to the server has not been opened.
	 * All data sent to the HttpConnectionHelper with write methods are sent to
	 * the current ByteArrayEncoder.
	 */
	final static private int STATUS_BEFORE_SERVER_CONNECTION = 1;

	/**
	 * Indicates that the network connection to the server is opened, but the
	 * request has not been totally sent to the server. All data sent to the
	 * HttpConnectionHelper with write methods is sent to the network
	 * connection, that is: to the current OutputStream. <BR>
	 * That is: the ByteArrayEncoder is now read only (closed).
	 */
	final static private int STATUS_WRITING_REQUEST = 2;

	/**
	 * Indicates that the network connection to the server is opened, but the
	 * request has not been totally sent to the server. All data sent to the
	 * HttpConnectionHelper with write methods is sent to the network
	 * connection, that is: to the current OutputStream. <BR>
	 * That is: the ByteArrayEncoder is now read only (closed).
	 */
	final static private int STATUS_READING_RESPONSE = 3;

	/**
	 * Indicates that the network connection to the server is now closed, that
	 * is: we've written the request, read the response, and free the server
	 * connection. If the keepAlive parameter is used, the connection may remain
	 * opened for the next request. <BR>
	 * No more action may be done on this connection helper, out of reading
	 * data, until the application do a call to
	 * {@link #initRequest(URL, String, boolean, boolean)}.
	 */
	final static private int STATUS_CONNECTION_CLOSED = 4;

	// ////////////////////////////////////////////////////////////////////////////////////
	// /////////////////// ATTRIBUTE USED TO CONTROL THE OUTPUT TO THE SERVER
	// ////////////////////////////////////////////////////////////////////////////////////
	/**
	 * http boundary, for the posting multipart post.
	 */
	private String boundary = calculateRandomBoundary();

	/**
	 * Is chunk upload on for this request ?
	 */
	private boolean bChunkEnabled;

	/**
	 * Is it the last chunk ? If yes, we'll try to keep the connection open,
	 * according to the current applet configuration.
	 */
	private boolean bLastChunk;

	/**
	 * The encoder that will contain the HTTP request.
	 */
	private ByteArrayEncoder byteArrayEncoder = null;

	/**
	 * Indicates where data sent to appendXxx method should be added. It must be
	 * one of the SENDING_XXX private strings.
	 */
	private int connectionStatus = STATUS_NOT_INITIALIZED;

	/**
	 * Contains the HTTP reader. All data coming from the server response are
	 * read from it. If this attribute is null, it means that the server
	 * response has not been read.
	 */
	private HTTPInputStreamReader httpInputStreamReader = null;

	/**
	 * This stream allows the applet to get the server response. It is opened
	 * and closed as the {@link #outputStream}.
	 */
	private PushbackInputStream inputStream = null;

	/**
	 * The HTTP method: POST, GET, HEAD...
	 */
	private String method = null;

	/**
	 * This stream is open by {@link #sendRequest()}. It is closed by the
	 * {@link #readHttpResponse()} method.
	 * 
	 * @see #sendRequest()
	 * @see #readHttpResponse()
	 * @see #getOutputStream()
	 */
	private DataOutputStream outputStream = null;

	/**
	 * The current proxy, if any
	 */
	private Proxy proxy = null;

	/**
	 * The network socket where the bytes should be written.
	 */
	private Socket socket = null;

	/**
	 * The current upload policy
	 */
	private UploadPolicy uploadPolicy = null;

	/**
	 * The current URL
	 */
	private URL url = null;

	/**
	 * Should we use a proxy
	 */
	private boolean useProxy;

	/**
	 * Is SSL mode on ?
	 */
	private boolean useSSL;

	// ////////////////////////////////////////////////////////////////////////////////////
	// /////////////////////// PUBLIC METHODS
	// ////////////////////////////////////////////////////////////////////////////////////

	/**
	 * The standard constructor for this class.
	 * 
	 * @param uploadPolicy
	 *            The current upload policy.
	 */
	public HTTPConnectionHelper(UploadPolicy uploadPolicy) {
		this.uploadPolicy = uploadPolicy;
	}

	/**
	 * The standard constructor for this class.
	 * 
	 * @param url
	 *            The target URL
	 * @param method
	 *            The HTTP method (POST, GET, HEAD...)
	 * @param bChunkEnabled
	 *            Indicates if chunkUpload is enabled for this query. Put false,
	 *            if non chunked request or if it is not relevant.
	 * @param bLastChunk
	 *            Indicates whether this chunk is the last one. Put true, if non
	 *            chunked request or if it is not relevant.
	 * @param uploadPolicy
	 *            The current upload policy.
	 * @throws JUploadIOException
	 */
	public HTTPConnectionHelper(URL url, String method, boolean bChunkEnabled,
			boolean bLastChunk, UploadPolicy uploadPolicy)
			throws JUploadIOException {
		this.uploadPolicy = uploadPolicy;
		initRequest(url, method, bChunkEnabled, bLastChunk);
	}

	/**
	 * The standard constructor for this class.
	 * 
	 * @param url
	 *            The target URL
	 * @param bChunkEnabled
	 *            Indicates if chunkUpload is enabled for this query. Put false,
	 *            if non chunked request or if it is not relevant.
	 * @param method
	 *            The HTTP method (POST, GET, HEAD...)
	 * @param bLastChunk
	 *            Indicates whether this chunk is the last one. Put true, if non
	 *            chunked request or if it is not relevant.
	 * @throws JUploadIOException
	 */
	public synchronized void initRequest(URL url, String method,
			boolean bChunkEnabled, boolean bLastChunk)
			throws JUploadIOException {
		// This method expects that the connection has not been initialized yet,
		// or that the previous request is finished.
		if (this.connectionStatus != STATUS_NOT_INITIALIZED
				&& this.connectionStatus != STATUS_CONNECTION_CLOSED) {
			throw new JUploadIOException(
					"Bad status of the HttpConnectionHelper in initRequest: "
							+ getStatusLabel());
		}

		// Clean any current request.
		if (isKeepAlive()) {
			dispose();
		}

		// Load the new parameters.
		this.url = url;
		this.method = method;
		this.bChunkEnabled = bChunkEnabled;
		this.bLastChunk = bLastChunk;
		// We will write to the local ByteArrayEncoder, until a connection to
		// the server is opened.
		initByteArrayEncoder();

		// Ok, the HttpConnectionHelper is now ready to get write commands.
		this.connectionStatus = STATUS_BEFORE_SERVER_CONNECTION;
	}

	/**
	 * Return the current {@link ByteArrayEncoder}. If it was not created, it is
	 * initialized.
	 * 
	 * @return The current {@link ByteArrayEncoder}, null if called before the
	 *         first initialization.
	 * @throws JUploadIOException
	 * @see #initRequest(URL, String, boolean, boolean)
	 */
	public ByteArrayEncoder getByteArrayEncoder() throws JUploadIOException {
		return this.byteArrayEncoder;
	}

	/**
	 * @return Returns the boundary for this HTTP request.
	 */
	public String getBoundary() {
		return this.boundary;
	}

	/**
	 * Closes the byteArrayEncoder, create the socket (or not, depending on the
	 * current uploadPolicy, and upload history), send the request, and create
	 * the InputStream to read the server response.
	 * 
	 * @throws JUploadIOException
	 */
	public synchronized void sendRequest() throws JUploadIOException {
		// This method expects that the connection is writing data to the
		// server.
		if (this.connectionStatus != STATUS_BEFORE_SERVER_CONNECTION) {
			throw new JUploadIOException(
					"Bad status of the HttpConnectionHelper in sendRequest: "
							+ getStatusLabel());
		}

		try {
			// We've finished with the current encoder.
			if (!this.byteArrayEncoder.isClosed()) {
				this.byteArrayEncoder.close();
			}

			// Let's clear any field that could have been read in a previous
			// step:
			this.httpInputStreamReader = null;

			// Only connect, if sock is null!!
			// ... or if we don't persist HTTP connections (patch for IIS, based
			// on Marc Reidy's patch)
			if (this.socket == null
					|| !this.uploadPolicy.getAllowHttpPersistent()) {
				this.socket = new HttpConnect(this.uploadPolicy).connect(
						this.url, this.proxy);
				this.outputStream = new DataOutputStream(
						new BufferedOutputStream(this.socket.getOutputStream()));
				this.inputStream = new PushbackInputStream(this.socket
						.getInputStream(), 1);
			}

			// Send http request to server
			this.outputStream
					.write(this.byteArrayEncoder.getEncodedByteArray());

			// The request has been sent. The current ByteArrayEncoder is now
			// useless. A new one is to be created for the next request.
			this.connectionStatus = STATUS_WRITING_REQUEST;

		} catch (IOException e) {
			throw new JUploadIOException("Unable to open socket", e);
		} catch (KeyManagementException e) {
			throw new JUploadIOException("Unable to open socket", e);
		} catch (UnrecoverableKeyException e) {
			throw new JUploadIOException("Unable to open socket", e);
		} catch (NoSuchAlgorithmException e) {
			throw new JUploadIOException("Unable to open socket", e);
		} catch (KeyStoreException e) {
			throw new JUploadIOException("Unable to open socket", e);
		} catch (CertificateException e) {
			throw new JUploadIOException("Unable to open socket", e);
		} catch (IllegalArgumentException e) {
			throw new JUploadIOException("Unable to open socket", e);
		}

	}

	/**
	 * Releases all reserved resources.
	 * 
	 * @throws JUploadIOException
	 */
	public synchronized void dispose() throws JUploadIOException {
		// A try to properly clean the connection to the server.
		try {
			// Let's shutdown the output, to free the server connection. Only
			// valid for non https connections.
			if (this.socket != null && !this.useSSL
					&& !this.socket.isOutputShutdown()) {
				this.socket.shutdownOutput();
			}
		} catch (IOException e) {
			throw new JUploadIOException(e);
		}
		try {
			if (this.socket != null && !this.useSSL
					&& !this.socket.isInputShutdown()) {
				this.socket.shutdownInput();
			}
		} catch (IOException e) {
			throw new JUploadIOException(e);
		}

		try {
			if (this.outputStream != null) {
				this.outputStream.close();
			}
		} catch (IOException e) {
			throw new JUploadIOException(e);
		} finally {
			this.outputStream = null;
		}

		try {
			if (this.inputStream != null) {
				this.inputStream.close();
			}
		} catch (IOException e) {
			throw new JUploadIOException(e);
		} finally {
			this.inputStream = null;
		}

		try {
			if (this.socket != null) {
				if (!this.socket.isClosed()) {
					this.socket.close();
				}
			}
		} catch (IOException e) {
			throw new JUploadIOException(e);
		} finally {
			this.socket = null;
		}
	}

	/**
	 * Return the current socket. If the byteArrayEncoder is not closed: close
	 * it, and send the request to the server.
	 * 
	 * @return public Socket getSocket() { }
	 */

	/**
	 * get the output stream, where HTTP data can be written.
	 * 
	 * @return The current output stream to the server, where things can be
	 *         written, event after the socket is open, if the byteArrayEncoder
	 *         did not contain the full request.
	 */
	public OutputStream getOutputStream() {
		return this;
	}

	/**
	 * get the input stream, where HTTP server response can be read.
	 * 
	 * @return The current input stream of the socket.
	 */
	public PushbackInputStream getInputStream() {
		return this.inputStream;
	}

	/**
	 * Get the HTTP method (HEAD, POST, GET...)
	 * 
	 * @return The HTTP method
	 */
	public String getMethod() {
		return this.method;
	}

	/**
	 * Get the last response body.
	 * 
	 * @return The full response body, that is: the HTTP body of the server
	 *         response.
	 */
	public String getResponseBody() {
		return this.httpInputStreamReader.getResponseBody();
	}

	/**
	 * Get the headers of the HTTP response.
	 * 
	 * @return The HTTP headers.
	 */
	public String getResponseHeaders() {
		return this.httpInputStreamReader.getResponseHeaders();
	}

	/**
	 * Get the last response message.
	 * 
	 * @return the response message, like "200 OK"
	 */
	public String getResponseMsg() {
		return this.httpInputStreamReader.getResponseMsg();
	}

	/**
	 * Get the label describing the current state of this connection helper.
	 * 
	 * @return A text describing briefly the current connection status.
	 */
	public synchronized String getStatusLabel() {
		switch (this.connectionStatus) {
		case STATUS_NOT_INITIALIZED:
			return "Not initialized";
		case STATUS_BEFORE_SERVER_CONNECTION:
			return "Before server connection";
		case STATUS_WRITING_REQUEST:
			return "Writing request to the network";
		case STATUS_READING_RESPONSE:
			return "Reading server response";
		case STATUS_CONNECTION_CLOSED:
			return "Connection closed";
		}
		return "Unknown status in HTTPConnectionHelper.getStatusLabel()";
	}

	/**
	 * Get the current socket.
	 * 
	 * @return return the current Socket, opened toward the server.
	 */
	Socket getSocket() {
		return this.socket;
	}

	/**
	 * Append bytes to the current query. The bytes will be written to the
	 * current ByteArrayEncoder if the the connection to the server is not open,
	 * or directly to the server if the connection is opened.
	 * 
	 * @param b
	 *            The byte to send to the server.
	 * @return Returns the current HttpConnectionHelper, to allow coding like
	 *         StringBuffers: a.append(b).append(c);
	 * @throws JUploadIOException
	 */
	public synchronized HTTPConnectionHelper append(int b)
			throws JUploadIOException {
		if (this.connectionStatus == STATUS_BEFORE_SERVER_CONNECTION) {
			this.byteArrayEncoder.append(b);
		} else if (this.connectionStatus == STATUS_WRITING_REQUEST) {
			try {
				this.outputStream.write(b);
			} catch (IOException e) {
				throw new JUploadIOException(e.getClass().getName()
						+ " while writing to httpDataOut", e);
			}
		} else {
			throw new JUploadIOException(
					"Wrong status in HTTPConnectionHelper.write() ["
							+ getStatusLabel() + "]");
		}
		return this;
	}

	/**
	 * Append bytes to the current query. The bytes will be written to the
	 * current ByteArrayEncoder if the the connection to the server is not open,
	 * or directly to the server if the connection is opened.
	 * 
	 * @param bytes
	 *            The bytes to send to the server.
	 * @return Returns the current HttpConnectionHelper, to allow coding like
	 *         StringBuffers: a.append(b).append(c);
	 * @throws JUploadIOException
	 */
	public synchronized HTTPConnectionHelper append(byte[] bytes)
			throws JUploadIOException {
		return this.append(bytes, 0, bytes.length);
	}

	/**
	 * Append bytes to the current query. The bytes will be written to the
	 * current ByteArrayEncoder if the the connection to the server is not open,
	 * or directly to the server if the connection is opened.
	 * 
	 * @param bytes
	 *            The bytes to send to the server.
	 * @param off
	 *            The first byte to send
	 * @param len
	 *            Number of bytes to send.
	 * @return Returns the current HttpConnectionHelper, to allow coding like
	 *         StringBuffers: a.append(b).append(c);
	 * @throws JUploadIOException
	 */
	public synchronized HTTPConnectionHelper append(byte[] bytes, int off,
			int len) throws JUploadIOException {

		if (this.connectionStatus == STATUS_BEFORE_SERVER_CONNECTION) {
			this.byteArrayEncoder.append(bytes);
		} else if (this.connectionStatus == STATUS_WRITING_REQUEST) {
			try {
				this.outputStream.write(bytes, off, len);
			} catch (IOException e) {
				throw new JUploadIOException(e.getClass().getName()
						+ " while writing to httpDataOut", e);
			}
		} else {
			throw new JUploadIOException(
					"Wrong status in HTTPConnectionHelper.write() ["
							+ getStatusLabel() + "]");
		}

		if (this.uploadPolicy.getDebugLevel() > 100) {
			this.uploadPolicy
					.displayDebug(
							"[HTTPConnectionHelper append(byte[],int,int)] ("
									+ len
									+ " bytes appended to "
									+ (this.connectionStatus == STATUS_BEFORE_SERVER_CONNECTION ? " current ByteArrayEncoder"
											: " socket") + ")", 101);
		}

		return this;
	}

	/**
	 * write a string to the current HTTP request.
	 * 
	 * @param str
	 *            The string to write
	 * @return The current HTTPConnectionHelper
	 * @throws JUploadIOException
	 *             If any problem occurs during the writing operation.
	 * @see #append(byte[])
	 */
	public synchronized HTTPConnectionHelper append(String str)
			throws JUploadIOException {
		this.uploadPolicy.displayDebug("[HTTPConnectionHelper append] " + str,
				70);
		if (this.connectionStatus == STATUS_BEFORE_SERVER_CONNECTION) {
			this.byteArrayEncoder.append(str);
		} else if (this.connectionStatus == STATUS_WRITING_REQUEST) {
			ByteArrayEncoder bae = new ByteArrayEncoderHTTP(this.uploadPolicy,
					this.byteArrayEncoder.getBoundary(), this.byteArrayEncoder
							.getEncoding());
			bae.append(str);
			bae.close();
			this.append(bae);
		}
		return this;
	}

	/**
	 * Appends a string to the current HTTP request.
	 * 
	 * @param bae
	 *            The ByteArrayEncoder to write. It is expected to be correctly
	 *            encoded. That is: it is up to the caller to check that its
	 *            encoding is the same as the current HTTP request encoding.
	 * @return The current HTTPConnectionHelper
	 * @throws JUploadIOException
	 *             If any problem occurs during the writing operation.
	 * @see #append(byte[])
	 */
	public synchronized HTTPConnectionHelper append(ByteArrayEncoder bae)
			throws JUploadIOException {
		this.uploadPolicy.displayDebug("[HTTPConnectionHelper append] "
				+ bae.getString(), 70);
		return this.append(bae.getEncodedByteArray());
	}

	/**
	 * Read the response of the server. This method delegates the work to the
	 * HTTPInputStreamReader. handles the chunk HTTP response.
	 * 
	 * @return The HTTP status. Should be 200, when everything is right.
	 * @throws JUploadException
	 */
	public synchronized int readHttpResponse() throws JUploadException {
		// This method expects that the connection is writing data to the
		// server.
		if (this.connectionStatus != STATUS_WRITING_REQUEST) {
			throw new JUploadIOException(
					"Bad status of the HttpConnectionHelper in readHttpResponse: "
							+ getStatusLabel());
		}
		this.connectionStatus = STATUS_READING_RESPONSE;

		// Let's connect in InputStream to read this server response.
		if (this.httpInputStreamReader == null) {
			this.httpInputStreamReader = new HTTPInputStreamReader(this,
					this.uploadPolicy);
		}

		// Let's do the job
		try {
			this.outputStream.flush();
		} catch (IOException ioe) {
			throw new JUploadIOException("flushing outputStream, in "
					+ getClass().getName() + ".readHttpResponse()");
		}
		this.httpInputStreamReader.readHttpResponse();

		if (this.httpInputStreamReader.gotClose) {
			// RFC 2868, section 8.1.2.1
			dispose();
		}

		// We got the response
		this.connectionStatus = STATUS_CONNECTION_CLOSED;

		// FIXME Should close the connection, from time to time...

		//
		return this.httpInputStreamReader.gethttpStatusCode();
	}

	// ////////////////////////////////////////////////////////////////////////////////////
	// /////////////////////// PRIVATE METHODS
	// ////////////////////////////////////////////////////////////////////////////////////

	/**
	 * creating of a new {@link ByteArrayEncoderHTTP}, and initializing of the
	 * following header items: First line (POST currentProtocol URI), Host,
	 * Connection, Keep-Alive, Proxy-Connection.
	 * 
	 * @throws JUploadIOException
	 */
	private synchronized void initByteArrayEncoder() throws JUploadIOException {
		if (this.byteArrayEncoder != null && !this.byteArrayEncoder.isClosed()) {
			this.byteArrayEncoder.close();
			this.byteArrayEncoder = null;
		}
		this.byteArrayEncoder = new ByteArrayEncoderHTTP(this.uploadPolicy,
				this.boundary);
		this.connectionStatus = STATUS_BEFORE_SERVER_CONNECTION;
		this.proxy = null;
		try {
			this.proxy = ProxySelector.getDefault().select(this.url.toURI())
					.get(0);
		} catch (URISyntaxException e) {
			throw new JUploadIOException("Error while managing url "
					+ this.url.toExternalForm(), e);
		}
		this.useProxy = ((this.proxy != null) && (this.proxy.type() != Proxy.Type.DIRECT));
		this.useSSL = this.url.getProtocol().equals("https");

		// Header: Request line
		// Let's clear it. Useful only for chunked uploads.
		this.byteArrayEncoder.append(this.method);
		this.byteArrayEncoder.append(" ");
		this.uploadPolicy.displayDebug("[initByteArrayEncoder] proxy=" + proxy
				+ ", proxy.type=" + this.proxy.type() + ", useProxy="
				+ useProxy + ", url.host=" + this.url.getHost() + ", url.port="
				+ this.url.getPort(), 80);
		if (this.useProxy && (!this.useSSL)) {
			// with a proxy we need the absolute URL, but only if not
			// using SSL. (with SSL, we first use the proxy CONNECT method,
			// and then a plain request.)
			this.byteArrayEncoder.append(this.url.getProtocol()).append("://")
					.append(this.url.getHost());
			// TODO port in proxy mode: to be tested !
			if (this.url.getPort() > 0) {
				this.byteArrayEncoder.append(":").append(
						Integer.toString(this.url.getPort()));
			}
		}
		this.byteArrayEncoder.append(this.url.getPath());

		// Append the query params.
		// TODO: This probably can be removed as we now have everything in POST
		// data. However in order to be
		// backwards-compatible, it stays here for now. So we now provide
		// *both* GET and POST params.
		if (null != this.url.getQuery() && !"".equals(this.url.getQuery()))
			this.byteArrayEncoder.append("?").append(this.url.getQuery());

		this.byteArrayEncoder.append(" ").append(
				this.uploadPolicy.getServerProtocol()).append("\r\n");

		// Header: General
		this.byteArrayEncoder.append("Host: ").append(this.url.getHost())
				.append("\r\nAccept: */*\r\n");
		// We do not want gzipped or compressed responses, so we must
		// specify that here (RFC 2616, Section 14.3)
		this.byteArrayEncoder.append("Accept-Encoding: identity\r\n");

		// Seems like the Keep-alive doesn't work properly, at least on my
		// local dev (Etienne).
		if (!this.uploadPolicy.getAllowHttpPersistent()) {
			this.byteArrayEncoder.append("Connection: close\r\n");
		} else {
			if (!this.bChunkEnabled
					|| this.bLastChunk
					|| this.useProxy
					|| !this.uploadPolicy.getServerProtocol()
							.equals("HTTP/1.1")) { // RFC 2086, section 19.7.1
				this.byteArrayEncoder.append("Connection: close\r\n");
			} else {
				this.byteArrayEncoder.append("Keep-Alive: 300\r\n");
				if (this.useProxy)
					this.byteArrayEncoder
							.append("Proxy-Connection: keep-alive\r\n");
				else
					this.byteArrayEncoder.append("Connection: keep-alive\r\n");
			}
		}

		// Get specific headers for this upload.
		this.uploadPolicy.onAppendHeader(this.byteArrayEncoder);
	}

	/**
	 * Indicates whether the current socket should be reused ... if any.
	 */
	private boolean isKeepAlive() {
		if (this.socket == null) {
			return false;
		} else if (!this.uploadPolicy.getAllowHttpPersistent()) {
			return false;
		} else {
			if (!this.bChunkEnabled
					|| this.bLastChunk
					|| this.useProxy
					|| !this.uploadPolicy.getServerProtocol()
							.equals("HTTP/1.1")) { // RFC 2086, section 19.7.1
				return false;
			} else {
				return true;
			}
		}
	}

	/**
	 * Construction of a random boundary, to separate the uploaded files, in the
	 * HTTP upload request.
	 * 
	 * @return The calculated boundary.
	 */
	private final String calculateRandomBoundary() {
		StringBuffer sbRan = new StringBuffer(11);
		sbRan.append("-----------------------------");
		String alphaNum = "1234567890abcdefghijklmnopqrstuvwxyz";
		int num;
		for (int i = 0; i < 11; i++) {
			num = (int) (Math.random() * (alphaNum.length() - 1));
			sbRan.append(alphaNum.charAt(num));
		}
		return sbRan.toString();
	}

	// ////////////////////////////////////////////////////////////////////////////////////
	// /////////////////// OVERRIDE OF OutputStream METHODS
	// ////////////////////////////////////////////////////////////////////////////////////
	/** {@inheritDoc} */
	@Override
	public void write(int b) throws IOException {
		try {
			append(b);
		} catch (JUploadIOException e) {
			// Hum, HTTPConnectionHelper catch IOException, and throws a
			// JUploadIOException. Now we get the cause, that is the original
			// IOException. Not optimized.
			if (e.getCause() == null) {
				// This should not happen
				throw new IOException();
			} else if (e.getCause() instanceof IOException) {
				throw (IOException) e.getCause();
			} else {
				// Hum, can something like an OutOfMemory. We must throw it.
				throw new IOException(e.getCause().getClass().getName() + ": "
						+ e.getCause().getMessage());
			}
		}
	}

	/** {@inheritDoc} */
	@Override
	public void write(byte[] b, int off, int len) throws IOException {
		try {
			append(b, off, len);
		} catch (JUploadIOException e) {
			// Hum, HTTPConnectionHelper catch IOException, and throws a
			// JUploadIOException. Now we get the cause, that is the original
			// IOException. Not optimized.
			if (e.getCause() == null) {
				// This should not happen
				throw new IOException();
			} else if (e.getCause() instanceof IOException) {
				throw (IOException) e.getCause();
			} else {
				// Hum, can something like an OutOfMemory. We must throw it.
				throw new IOException(e.getCause().getClass().getName() + ": "
						+ e.getCause().getMessage());
			}
		}
	}

	/** {@inheritDoc} */
	@Override
	public void write(byte[] b) throws IOException {
		write(b, 0, b.length);
	}

	/**
	 * This method is the override of {@link OutputStream#close()} one. It may
	 * not been called. You must use the {@link #sendRequest()} or
	 * {@link #readHttpResponse()} methods instead.
	 * 
	 * @see java.io.OutputStream#close()
	 */
	@Override
	public void close() throws IOException {
		throw new IOException(
				"Forbidden action (HTTPConnectionHelper.close()). Please use the "
						+ getClass().getName() + ".sendRequest() method");
	}

	/**
	 * Flushes the output stream. Useful only when the HTTPConnectionHelper is
	 * writing to the socket toward the server, that is when the status is:
	 * STATUS_WRITING_REQUEST.
	 * 
	 * @see java.io.OutputStream#flush()
	 */
	@Override
	public void flush() throws IOException {
		if (this.connectionStatus == STATUS_WRITING_REQUEST) {
			this.outputStream.flush();
		} else {
			throw new IOException("Wrong status in " + getClass().getName()
					+ ".flush method: " + getStatusLabel());
		}
	}
}