OTP-9094: [httpc] Add support for upload body streaming (PUT and POST).

	  Filipe David Manana

OTP-9114: [ftp] Added (type) spec for all exported functions.

OTP-9123: mod_esi:deliver/2 made to accept binary data.
	  Bernard Duggan

OTP-9124: [httpd] Prevent XSS in error pages.
	  Michael Santos

OTP-9131: [httpd] Wrong security property names used in documentation.
	  Garrett Smith

OTP-9157: [httpd] Improved error messages.
	  Ricardo Catalinas Jim�nez

OTP-9158: [httpd] Fix timeout message generated by mod_esi.
	  Bernard Duggan

OTP-9202: [httpd] Extended support for file descriptors.
	  Attila Rajmund Nohl

OTP-9230: The default ssl kind has now been changed to essl.

OTP-9246: [httpc] httpc manager crash because of a handler retry
	  race condition.

Merge branch 'bmk/inets/inet56_integration' into dev

16 files changed, 754 insertions, 741 deletions

diff --git a/lib/inets/src/ftp/ftp.erl b/lib/inets/src/ftp/ftp.erl
index 5ad74851c8..fe6cb0c191 100644
--- a/lib/inets/src/ftp/ftp.erl
+++ b/lib/inets/src/ftp/ftp.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2010. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -92,6 +92,12 @@
 	 }).
 
 
+-type shortage_reason()  :: 'etnospc' | 'epnospc'.
+-type restriction_reason() :: 'epath' | 'efnamena' | 'elogin' | 'enotbinary'.
+-type common_reason() ::  'econn' | 'eclosed' | term().
+-type file_write_error_reason() :: term(). % See file:write for more info
+
+
 %%%=========================================================================
 %%%  API - CLIENT FUNCTIONS
 %%%=========================================================================
@@ -106,6 +112,9 @@
 %% Description:  Start an ftp client and connect to a host.
 %%--------------------------------------------------------------------------
 
+-spec open(Host :: string() | inet:ip_address()) ->
+    {'ok', Pid :: pid()} | {'error', Reason :: 'ehost' | term()}.
+
 %% <BACKWARD-COMPATIBILLITY>
 open({option_list, Options}) when is_list(Options) ->
     try
@@ -126,6 +135,9 @@ open({option_list, Options}) when is_list(Options) ->
 open(Host) ->
     open(Host, []).
 
+-spec open(Host :: string() | inet:ip_address(), Opts :: list()) ->
+    {'ok', Pid :: pid()} | {'error', Reason :: 'ehost' | term()}.
+
 %% <BACKWARD-COMPATIBILLITY>
 open(Host, Port) when is_integer(Port) ->
     open(Host, [{port, Port}]);
@@ -161,12 +173,24 @@ open(Host, Opts) when is_list(Opts) ->
 %%
 %% Description:  Login with or without a supplied account name.
 %%--------------------------------------------------------------------------
+-spec user(Pid  :: pid(), 
+	   User :: string(), 
+	   Pass :: string()) ->
+    'ok' | {'error', Reason :: 'euser' | common_reason()}.
+
 user(Pid, User, Pass) ->
     call(Pid, {user, User, Pass}, atom).
 
+-spec user(Pid  :: pid(), 
+	   User :: string(), 
+	   Pass :: string(), 
+	   Acc  :: string()) ->
+    'ok' | {'error', Reason :: 'euser' | common_reason()}.
+
 user(Pid, User, Pass, Acc) ->
     call(Pid, {user, User, Pass, Acc}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% account(Pid, Acc)  -> ok | {error, eacct}
 %%	Pid = pid()
@@ -174,9 +198,14 @@ user(Pid, User, Pass, Acc) ->
 %%
 %% Description:  Set a user Account.
 %%--------------------------------------------------------------------------
+
+-spec account(Pid :: pid(), Acc :: string()) ->
+    'ok' | {'error', Reason :: 'eacct' | common_reason()}.
+
 account(Pid, Acc) ->
     call(Pid, {account, Acc}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% pwd(Pid) -> {ok, Dir} | {error, elogin} | {error, econn} 
 %%	Pid = pid()
@@ -184,19 +213,30 @@ account(Pid, Acc) ->
 %%
 %% Description:  Get the current working directory at remote server.
 %%--------------------------------------------------------------------------
+
+-spec pwd(Pid :: pid()) ->
+    {'ok', Dir :: string()} | 
+	{'error', Reason :: restriction_reason() | common_reason()}.
+
 pwd(Pid) ->
     call(Pid, pwd, ctrl).
 
+
 %%--------------------------------------------------------------------------
-%% lpwd(Pid) ->  {ok, Dir} | {error, elogin} 
+%% lpwd(Pid) ->  {ok, Dir} 
 %%	Pid = pid()
 %%      Dir = string()
 %%
 %% Description:  Get the current working directory at local server.
 %%--------------------------------------------------------------------------
+
+-spec lpwd(Pid :: pid()) ->
+    {'ok', Dir :: string()}.
+
 lpwd(Pid) ->
     call(Pid, lpwd, string).
 
+
 %%--------------------------------------------------------------------------
 %% cd(Pid, Dir) ->  ok | {error, epath} | {error, elogin} | {error, econn}
 %%	Pid = pid()
@@ -204,9 +244,14 @@ lpwd(Pid) ->
 %%
 %% Description:  Change current working directory at remote server.
 %%--------------------------------------------------------------------------
+
+-spec cd(Pid :: pid(), Dir :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | common_reason()}.
+
 cd(Pid, Dir) ->
     call(Pid, {cd, Dir}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% lcd(Pid, Dir) ->  ok | {error, epath}
 %%	Pid = pid()
@@ -214,9 +259,14 @@ cd(Pid, Dir) ->
 %%
 %% Description:  Change current working directory for the local client.
 %%--------------------------------------------------------------------------
+
+-spec lcd(Pid :: pid(), Dir :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason()}.
+
 lcd(Pid, Dir) ->
     call(Pid, {lcd, Dir}, string).
 
+
 %%--------------------------------------------------------------------------
 %% ls(Pid) -> Result
 %% ls(Pid, <Dir>) -> Result
@@ -229,11 +279,22 @@ lcd(Pid, Dir) ->
 %%
 %% Description: Returns a list of files in long format.
 %%--------------------------------------------------------------------------
+
+-spec ls(Pid :: pid()) ->
+    {'ok', Listing :: string()} | 
+	{'error', Reason :: restriction_reason() | common_reason()}.
+
 ls(Pid) ->
   ls(Pid, "").
+
+-spec ls(Pid :: pid(), Dir :: string()) ->
+    {'ok', Listing :: string()} | 
+	{'error', Reason ::  restriction_reason() | common_reason()}.
+
 ls(Pid, Dir) ->
     call(Pid, {dir, long, Dir}, string).
 
+
 %%--------------------------------------------------------------------------
 %% nlist(Pid) -> Result
 %% nlist(Pid, Pathname) -> Result
@@ -246,21 +307,37 @@ ls(Pid, Dir) ->
 %%
 %% Description:  Returns a list of files in short format
 %%--------------------------------------------------------------------------
+
+-spec nlist(Pid :: pid()) ->
+    {'ok', Listing :: string()} | 
+	{'error', Reason :: restriction_reason() | common_reason()}.
+
 nlist(Pid) ->
   nlist(Pid, "").
+
+-spec nlist(Pid :: pid(), Pathname :: string()) ->
+    {'ok', Listing :: string()} | 
+	{'error', Reason :: restriction_reason() | common_reason()}.
+
 nlist(Pid, Dir) ->
     call(Pid, {dir, short, Dir}, string).
 
+
 %%--------------------------------------------------------------------------
-%% rename(Pid, CurrFile, NewFile) ->  ok | {error, epath} | {error, elogin} 
-%%                                    | {error, econn}
+%% rename(Pid, Old, New) ->  ok | {error, epath} | {error, elogin} 
+%%                              | {error, econn}
 %%	Pid = pid()
 %%	CurrFile = NewFile = string()
 %%
 %% Description:  Rename a file at remote server.
 %%--------------------------------------------------------------------------
-rename(Pid, CurrFile, NewFile) ->
-    call(Pid, {rename, CurrFile, NewFile}, string).
+
+-spec rename(Pid :: pid(), Old :: string(), New :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | common_reason()}.
+
+rename(Pid, Old, New) ->
+    call(Pid, {rename, Old, New}, string).
+
 
 %%--------------------------------------------------------------------------
 %% delete(Pid, File) ->  ok | {error, epath} | {error, elogin} | 
@@ -270,9 +347,14 @@ rename(Pid, CurrFile, NewFile) ->
 %%
 %% Description:  Remove file at remote server.
 %%--------------------------------------------------------------------------
+
+-spec delete(Pid :: pid(), File :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | common_reason()}.
+
 delete(Pid, File) ->
     call(Pid, {delete, File}, string).
 
+
 %%--------------------------------------------------------------------------
 %% mkdir(Pid, Dir) -> ok | {error, epath} | {error, elogin} | {error, econn}
 %%	Pid = pid(), 
@@ -280,9 +362,14 @@ delete(Pid, File) ->
 %%
 %% Description:  Make directory at remote server.
 %%--------------------------------------------------------------------------
+
+-spec mkdir(Pid :: pid(), Dir :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | common_reason()}.
+
 mkdir(Pid, Dir) ->
     call(Pid, {mkdir, Dir}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% rmdir(Pid, Dir) -> ok | {error, epath} | {error, elogin} | {error, econn}
 %%	Pid = pid(), 
@@ -290,9 +377,14 @@ mkdir(Pid, Dir) ->
 %%
 %% Description:  Remove directory at remote server.
 %%--------------------------------------------------------------------------
+
+-spec rmdir(Pid :: pid(), Dir :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | common_reason()}.
+
 rmdir(Pid, Dir) ->
     call(Pid, {rmdir, Dir}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% type(Pid, Type) -> ok | {error, etype} | {error, elogin} | {error, econn}
 %%	Pid = pid() 
@@ -300,23 +392,41 @@ rmdir(Pid, Dir) ->
 %%
 %% Description:  Set transfer type.
 %%--------------------------------------------------------------------------
+
+-spec type(Pid :: pid(), Type :: ascii | binary) ->
+    'ok' | 
+	{'error', Reason :: 'etype' | restriction_reason() | common_reason()}.
+
 type(Pid, Type) ->
     call(Pid, {type, Type}, atom).
 
+
 %%--------------------------------------------------------------------------
-%% recv(Pid, RemoteFileName <LocalFileName>) -> ok | {error, epath} |
+%% recv(Pid, RemoteFileName [, LocalFileName]) -> ok | {error, epath} |
 %%                                          {error, elogin} | {error, econn}
 %%	Pid = pid()
 %%	RemoteFileName = LocalFileName = string()
 %%
 %% Description:  Transfer file from remote server.
 %%--------------------------------------------------------------------------
+
+-spec recv(Pid :: pid(), RemoteFileName :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | 
+                               common_reason() | 
+                               file_write_error_reason()}.
+
 recv(Pid, RemotFileName) ->
   recv(Pid, RemotFileName, RemotFileName).
 
+-spec recv(Pid            :: pid(), 
+	   RemoteFileName :: string(), 
+	   LocalFileName  :: string()) ->
+    'ok' | {'error', Reason :: term()}.
+
 recv(Pid, RemotFileName, LocalFileName) ->
     call(Pid, {recv, RemotFileName, LocalFileName}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% recv_bin(Pid, RemoteFile) -> {ok, Bin} | {error, epath} | {error, elogin} 
 %%			   | {error, econn}
@@ -326,9 +436,16 @@ recv(Pid, RemotFileName, LocalFileName) ->
 %%
 %% Description:  Transfer file from remote server into binary.
 %%--------------------------------------------------------------------------
+
+-spec recv_bin(Pid        :: pid(), 
+	       RemoteFile :: string()) ->
+    {'ok', Bin :: binary()} | 
+	{'error', Reason :: restriction_reason() | common_reason()}.
+
 recv_bin(Pid, RemoteFile) ->
     call(Pid, {recv_bin, RemoteFile}, bin).
 
+
 %%--------------------------------------------------------------------------
 %% recv_chunk_start(Pid, RemoteFile) -> ok | {error, elogin} | {error, epath} 
 %%                                 | {error, econn}
@@ -337,9 +454,15 @@ recv_bin(Pid, RemoteFile) ->
 %%
 %% Description:  Start receive of chunks of remote file.
 %%--------------------------------------------------------------------------
+
+-spec recv_chunk_start(Pid        :: pid(), 
+		       RemoteFile :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | common_reason()}.
+
 recv_chunk_start(Pid, RemoteFile) ->
     call(Pid, {recv_chunk_start, RemoteFile}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% recv_chunk(Pid, RemoteFile) ->  ok | {ok, Bin} | {error, Reason}
 %%	Pid = pid()
@@ -347,24 +470,47 @@ recv_chunk_start(Pid, RemoteFile) ->
 %%
 %% Description:  Transfer file from remote server into binary in chunks
 %%--------------------------------------------------------------------------
+
+-spec recv_chunk(Pid :: pid()) ->
+    'ok' | 
+	{'ok', Bin :: binary()} | 
+	{'error', Reason :: restriction_reason() | common_reason()}.
+
 recv_chunk(Pid) ->
     call(Pid, recv_chunk, atom).
 
+
 %%--------------------------------------------------------------------------
-%% send(Pid, LocalFileName <RemotFileName>) -> ok | {error, epath} 
-%%                                                | {error, elogin} 
-%%                             | {error, econn}
+%% send(Pid, LocalFileName [, RemotFileName]) -> ok | {error, epath} 
+%%                                                  | {error, elogin} 
+%%                                                  | {error, econn}
 %%	Pid = pid()
 %%	LocalFileName = RemotFileName = string()
 %%
 %% Description:  Transfer file to remote server.
 %%--------------------------------------------------------------------------
+
+-spec send(Pid :: pid(), LocalFileName :: string()) ->
+    'ok' | 
+	{'error', Reason :: restriction_reason() | 
+                            common_reason() | 
+                            shortage_reason()}.
+
 send(Pid, LocalFileName) ->
   send(Pid, LocalFileName, LocalFileName).
 
+-spec send(Pid            :: pid(), 
+	   LocalFileName  :: string(), 
+	   RemoteFileName :: string()) ->
+    'ok' | 
+	{'error', Reason :: restriction_reason() | 
+                            common_reason() | 
+                            shortage_reason()}.
+
 send(Pid, LocalFileName, RemotFileName) ->
     call(Pid, {send, LocalFileName, RemotFileName}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% send_bin(Pid, Bin, RemoteFile) -> ok | {error, epath} | {error, elogin} 
 %%                             | {error, enotbinary} | {error, econn}
@@ -374,11 +520,19 @@ send(Pid, LocalFileName, RemotFileName) ->
 %%
 %% Description:  Transfer a binary to a remote file.
 %%--------------------------------------------------------------------------
+
+-spec send_bin(Pid :: pid(), Bin :: binary(), RemoteFile :: string()) ->
+    'ok' | 
+	{'error', Reason :: restriction_reason() | 
+                            common_reason() | 
+                            shortage_reason()}.
+
 send_bin(Pid, Bin, RemoteFile) when is_binary(Bin) ->
     call(Pid, {send_bin, Bin, RemoteFile}, atom);
 send_bin(_Pid, _Bin, _RemoteFile) ->
   {error, enotbinary}.
 
+
 %%--------------------------------------------------------------------------
 %% send_chunk_start(Pid, RemoteFile) -> ok | {error, elogin} | {error, epath} 
 %%                                 | {error, econn}
@@ -387,9 +541,14 @@ send_bin(_Pid, _Bin, _RemoteFile) ->
 %%
 %% Description:  Start transfer of chunks to remote file.
 %%--------------------------------------------------------------------------
+
+-spec send_chunk_start(Pid :: pid(), RemoteFile :: string()) ->
+    'ok' | {'error', Reason :: restriction_reason() | common_reason()}.
+
 send_chunk_start(Pid, RemoteFile) ->
     call(Pid, {send_chunk_start, RemoteFile}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% append_chunk_start(Pid, RemoteFile) -> ok | {error, elogin} | 
 %%                                        {error, epath} | {error, econn}
@@ -398,9 +557,14 @@ send_chunk_start(Pid, RemoteFile) ->
 %%
 %% Description:  Start append chunks of data to remote file.
 %%--------------------------------------------------------------------------
+
+-spec append_chunk_start(Pid :: pid(), RemoteFile :: string()) ->
+    'ok' | {'error', Reason :: term()}.
+
 append_chunk_start(Pid, RemoteFile) ->
     call(Pid, {append_chunk_start, RemoteFile}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% send_chunk(Pid, Bin) -> ok | {error, elogin} | {error, enotbinary} 
 %%                       | {error, echunk} | {error, econn}
@@ -409,11 +573,19 @@ append_chunk_start(Pid, RemoteFile) ->
 %%
 %% Purpose:  Send chunk to remote file.
 %%--------------------------------------------------------------------------
+
+-spec send_chunk(Pid :: pid(), Bin :: binary()) ->
+    'ok' | 
+	{'error', Reason :: 'echunk' | 
+                            restriction_reason() | 
+                            common_reason()}.
+
 send_chunk(Pid, Bin) when is_binary(Bin) ->
     call(Pid, {transfer_chunk, Bin}, atom);
 send_chunk(_Pid, _Bin) ->
   {error, enotbinary}.
 
+
 %%--------------------------------------------------------------------------
 %% append_chunk(Pid, Bin) -> ok | {error, elogin} | {error, enotbinary} 
 %%			     | {error, echunk} | {error, econn}
@@ -422,11 +594,19 @@ send_chunk(_Pid, _Bin) ->
 %%
 %% Description:  Append chunk to remote file.
 %%--------------------------------------------------------------------------
+
+-spec append_chunk(Pid :: pid(), Bin :: binary()) ->
+    'ok' | 
+	{'error', Reason :: 'echunk' | 
+                            restriction_reason() | 
+                            common_reason()}.
+
 append_chunk(Pid, Bin) when is_binary(Bin) ->
     call(Pid, {transfer_chunk, Bin}, atom);
 append_chunk(_Pid, _Bin) ->
   {error, enotbinary}.
 
+
 %%--------------------------------------------------------------------------
 %% send_chunk_end(Pid) -> ok | {error, elogin} | {error, echunk} 
 %%			  | {error, econn}
@@ -434,9 +614,17 @@ append_chunk(_Pid, _Bin) ->
 %%
 %% Description:  End sending of chunks to remote file.
 %%--------------------------------------------------------------------------
+
+-spec send_chunk_end(Pid :: pid()) ->
+    'ok' | 
+	{'error', Reason :: restriction_reason() | 
+                            common_reason() | 
+                            shortage_reason()}.
+
 send_chunk_end(Pid) ->
     call(Pid, chunk_end, atom).
 
+
 %%--------------------------------------------------------------------------
 %% append_chunk_end(Pid) ->  ok | {error, elogin} | {error, echunk} 
 %%			     | {error, econn}
@@ -444,23 +632,47 @@ send_chunk_end(Pid) ->
 %%
 %% Description:  End appending of chunks to remote file.
 %%--------------------------------------------------------------------------
+
+-spec append_chunk_end(Pid :: pid()) ->
+    'ok' | 
+	{'error', Reason :: restriction_reason() | 
+                            common_reason() | 
+                            shortage_reason()}.
+
 append_chunk_end(Pid) ->
     call(Pid, chunk_end, atom).
 
+
 %%--------------------------------------------------------------------------
-%% append(Pid, LocalFileName, RemotFileName) -> ok | {error, epath} 
-%%                                          | {error, elogin} | {error, econn}
+%% append(Pid, LocalFileName [, RemotFileName]) -> ok | {error, epath} 
+%%                                                    | {error, elogin} 
+%%                                                    | {error, econn}
 %%	Pid = pid()
 %%	LocalFileName = RemotFileName = string()
 %%
 %% Description:  Append the local file to the remote file
 %%--------------------------------------------------------------------------
+
+-spec append(Pid :: pid(), LocalFileName :: string()) ->
+    'ok' | 
+	{'error', Reason :: 'epath'    | 
+                            'elogin'   | 
+                            'etnospc'  | 
+                            'epnospc'  | 
+                            'efnamena' | common_reason()}.
+
 append(Pid, LocalFileName) ->
     append(Pid, LocalFileName, LocalFileName).
 
+-spec append(Pid            :: pid(), 
+	     LocalFileName  :: string(), 
+	     RemoteFileName :: string()) ->
+    'ok' | {'error', Reason :: term()}.
+
 append(Pid, LocalFileName, RemotFileName) ->
     call(Pid, {append, LocalFileName, RemotFileName}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% append_bin(Pid, Bin, RemoteFile) -> ok | {error, epath} | {error, elogin} 
 %%				  | {error, enotbinary} | {error, econn}
@@ -470,27 +682,44 @@ append(Pid, LocalFileName, RemotFileName) ->
 %%
 %% Purpose:  Append a binary to a remote file.
 %%--------------------------------------------------------------------------
+
+-spec append_bin(Pid        :: pid(), 
+		 Bin        :: binary(), 
+		 RemoteFile :: string()) ->
+    'ok' | 
+	{'error', Reason :: restriction_reason() | 
+                            common_reason() | 
+                            shortage_reason()}.
+
 append_bin(Pid, Bin, RemoteFile) when is_binary(Bin) ->
     call(Pid, {append_bin, Bin, RemoteFile}, atom);
 append_bin(_Pid, _Bin, _RemoteFile) ->
     {error, enotbinary}.
 
+
 %%--------------------------------------------------------------------------
-%% quote(Pid, Cmd) -> ok
+%% quote(Pid, Cmd) -> list()
 %%	Pid = pid()
 %%	Cmd = string()
 %%
 %% Description: Send arbitrary ftp command.
 %%--------------------------------------------------------------------------
+
+-spec quote(Pid :: pid(), Cmd :: string()) -> list().
+
 quote(Pid, Cmd) when is_list(Cmd) ->
     call(Pid, {quote, Cmd}, atom).
 
+
 %%--------------------------------------------------------------------------
 %% close(Pid) -> ok
 %%	Pid = pid()
 %%
 %% Description:  End the ftp session.
 %%--------------------------------------------------------------------------
+
+-spec close(Pid :: pid()) -> 'ok'.
+
 close(Pid) ->
     cast(Pid, close),
     ok.
@@ -502,9 +731,13 @@ close(Pid) ->
 %%
 %% Description:  Return diagnostics.
 %%--------------------------------------------------------------------------
+
+-spec formaterror(Tag :: term()) -> string().
+
 formaterror(Tag) ->
   ftp_response:error_string(Tag).
 
+
 info(Pid) ->
     call(Pid, info, list).
 
diff --git a/lib/inets/src/http_client/httpc.erl b/lib/inets/src/http_client/httpc.erl
index 04fae13b20..b70b16f57f 100644
--- a/lib/inets/src/http_client/httpc.erl
+++ b/lib/inets/src/http_client/httpc.erl
@@ -126,7 +126,10 @@ request(Url, Profile) ->
 %%      Header = {Field, Value}
 %%	Field = string()
 %%	Value = string()
-%%	Body = string() | binary() - HTLM-code
+%%	Body = string() | binary() | {fun(SendAcc) -> SendFunResult, SendAcc} |
+%%              {chunkify, fun(SendAcc) -> SendFunResult, SendAcc} - HTLM-code
+%%      SendFunResult = eof | {ok, iolist(), NewSendAcc}
+%%      SendAcc = NewSendAcc = term()
 %%
 %% Description: Sends a HTTP-request. The function can be both
 %% syncronus and asynchronous in the later case the function will
@@ -426,26 +429,44 @@ service_info(Pid) ->
 
 handle_request(Method, Url, 
 	       {Scheme, UserInfo, Host, Port, Path, Query}, 
-	       Headers, ContentType, Body, 
+	       Headers0, ContentType, Body0,
 	       HTTPOptions0, Options0, Profile) ->
 
-    Started    = http_util:timestamp(), 
-    NewHeaders = [{http_util:to_lower(Key), Val} || {Key, Val} <- Headers],
+    Started     = http_util:timestamp(), 
+    NewHeaders0 = [{http_util:to_lower(Key), Val} || {Key, Val} <- Headers0],
 
     try
 	begin
+	    ?hcrt("begin processing", [{started,     Started}, 
+				       {new_headers, NewHeaders0}]),
+
+	    {NewHeaders, Body} = 
+		case Body0 of
+		    {chunkify, ProcessBody, Acc} 
+		      when is_function(ProcessBody, 1) ->
+			NewHeaders1 = ensure_chunked_encoding(NewHeaders0), 
+			Body1       = {mk_chunkify_fun(ProcessBody), Acc}, 
+			{NewHeaders1, Body1};
+		    {ProcessBody, _} 
+		      when is_function(ProcessBody, 1) ->
+			{NewHeaders0, Body0};
+		    _ when is_list(Body0) orelse is_binary(Body0) ->
+			{NewHeaders0, Body0};
+		    _ ->
+			throw({error, {bad_body, Body0}})
+		end,
+
 	    HTTPOptions   = http_options(HTTPOptions0),
 	    Options       = request_options(Options0), 
 	    Sync          = proplists:get_value(sync,   Options),
 	    Stream        = proplists:get_value(stream, Options),
 	    Host2         = header_host(Scheme, Host, Port), 
 	    HeadersRecord = header_record(NewHeaders, Host2, HTTPOptions),
-	    Receiver   = proplists:get_value(receiver, Options),
-	    SocketOpts = proplists:get_value(socket_opts, Options),
-	    UrlEncodeBool =  HTTPOptions#http_options.url_encode,
-	    MaybeEscPath = url_encode(Path, UrlEncodeBool),
-	    MaybeEscQuery = url_encode(Query, UrlEncodeBool),
-	    AbsUri  = url_encode(Url, UrlEncodeBool),
+	    Receiver      = proplists:get_value(receiver, Options),
+	    SocketOpts    = proplists:get_value(socket_opts, Options),
+	    MaybeEscPath  = maybe_encode_uri(HTTPOptions, Path),
+	    MaybeEscQuery = maybe_encode_uri(HTTPOptions, Query),
+	    AbsUri        = maybe_encode_uri(HTTPOptions, Url),
 
 	    Request = #request{from          = Receiver,
 			       scheme        = Scheme, 
@@ -458,38 +479,71 @@ handle_request(Method, Url,
 			       settings      = HTTPOptions, 
 			       abs_uri       = AbsUri,
 			       userinfo      = UserInfo, 
-			       stream        = Stream,
-			       headers_as_is = headers_as_is(Headers, Options),
+			       stream        = Stream, 
+			       headers_as_is = headers_as_is(Headers0, Options),
 			       socket_opts   = SocketOpts, 
 			       started       = Started},
+
 	    case httpc_manager:request(Request, profile_name(Profile)) of
 		{ok, RequestId} ->
 		    handle_answer(RequestId, Sync, Options);
 		{error, Reason} ->
+		    ?hcrd("request failed", [{reason, Reason}]),
 		    {error, Reason}
 	    end
 	end
     catch
 	error:{noproc, _} ->
+	    ?hcrv("noproc", [{profile, Profile}]),
 	    {error, {not_started, Profile}};
 	throw:Error ->
+	    ?hcrv("throw", [{error, Error}]),
 	    Error
     end.
 
-url_encode(URI, true) ->
+ensure_chunked_encoding(Hdrs) ->
+    Key = "transfer-encoding",
+    lists:keystore(Key, 1, Hdrs, {Key, "chunked"}).
+
+maybe_encode_uri(#http_options{url_encode = true}, URI) ->
     http_uri:encode(URI);
-url_encode(URI, false) ->
+maybe_encode_uri(_, URI) ->
     URI.
 
+mk_chunkify_fun(ProcessBody) ->
+    fun(eof_body) ->
+	    eof;
+       (Acc) ->
+	    case ProcessBody(Acc) of
+		eof ->
+		    {ok, <<"0\r\n\r\n">>, eof_body};
+		{ok, Data, NewAcc} ->
+		    {ok, mk_chunk_bin(Data), NewAcc}
+	    end
+    end.
+
+mk_chunk_bin(Data) ->
+    Bin = iolist_to_binary(Data),
+    iolist_to_binary([hex_size(Bin), "\r\n", Bin, "\r\n"]).
+
+hex_size(Bin) ->
+    hd(io_lib:format("~.16B", [size(Bin)])).
+
+
 handle_answer(RequestId, false, _) ->
     {ok, RequestId};
 handle_answer(RequestId, true, Options) ->
     receive
 	{http, {RequestId, saved_to_file}} ->
+	    ?hcrt("received saved-to-file", [{request_id, RequestId}]),
 	    {ok, saved_to_file};
 	{http, {RequestId, {_,_,_} = Result}} ->
+	    ?hcrt("received answer", [{request_id, RequestId}, 
+				      {result,     Result}]),
 	    return_answer(Options, Result);
 	{http, {RequestId, {error, Reason}}} ->
+	    ?hcrt("received error", [{request_id, RequestId}, 
+				     {reason,     Reason}]),
 	    {error, Reason}
     end.
 
diff --git a/lib/inets/src/http_client/httpc_handler.erl b/lib/inets/src/http_client/httpc_handler.erl
index cb6f3e2841..1f0e012e7e 100644
--- a/lib/inets/src/http_client/httpc_handler.erl
+++ b/lib/inets/src/http_client/httpc_handler.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2002-2010. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2011. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -29,10 +29,10 @@
 %%--------------------------------------------------------------------
 %% Internal Application API
 -export([
-	 start_link/2, 
-	 connect_and_send/2, 
+	 start_link/4,
+	 %% connect_and_send/2,
 	 send/2, 
-	 cancel/2, 
+	 cancel/3,
 	 stream/3, 
 	 stream_next/1,
 	 info/1
@@ -51,7 +51,7 @@
 -record(state, 
 	{
 	  request,                   % #request{}
-	  session,                   % #tcp_session{} 
+	  session,                   % #session{}
 	  status_line,               % {Version, StatusCode, ReasonPharse}
 	  headers,                   % #http_response_h{}
 	  body,                      % binary()
@@ -94,13 +94,9 @@
 %%--------------------------------------------------------------------
 %%--------------------------------------------------------------------
 
-start_link(Options, ProfileName) ->
-    Args = [Options, ProfileName], 
-    gen_server:start_link(?MODULE, Args, []).
-
-connect_and_send(Request, HandlerPid) ->
-    call({connect_and_send, Request}, HandlerPid).
-
+start_link(Parent, Request, Options, ProfileName) ->
+    {ok, proc_lib:start_link(?MODULE, init, [[Parent, Request, Options,
+					      ProfileName]])}.
 
 %%--------------------------------------------------------------------
 %% Function: send(Request, Pid) -> ok 
@@ -122,8 +118,8 @@ send(Request, Pid) ->
 %% Description: Cancels a request. Intended to be called by the httpc
 %% manager process.
 %%--------------------------------------------------------------------
-cancel(RequestId, Pid) ->
-    cast({cancel, RequestId}, Pid).
+cancel(RequestId, Pid, From) ->
+    cast({cancel, RequestId, From}, Pid).
 
 
 %%--------------------------------------------------------------------
@@ -229,16 +225,27 @@ stream(BodyPart, Request,_) -> % only 200 and 206 responses can be streamed
 %% but we do not want that so errors will be handled by the process
 %% sending an init_error message to itself.
 %%--------------------------------------------------------------------
-init([Options, ProfileName]) ->
-    ?hcrv("init - starting", [{options, Options}, {profile, ProfileName}]),
+init([Parent, Request, Options, ProfileName]) ->
     process_flag(trap_exit, true),
-    handle_verbose(Options#options.verbose),
-    State = #state{status       = undefined,
-		   options      = Options, 
-		   profile_name = ProfileName},
-    ?hcrd("init - started", []),
-    {ok, State}.
 
+    %% Do not let initial tcp-connection block the manager-process
+    proc_lib:init_ack(Parent, self()),
+    handle_verbose(Options#options.verbose),
+    Address = handle_proxy(Request#request.address, Options#options.proxy),
+    {ok, State} =
+	case {Address /= Request#request.address, Request#request.scheme} of
+	    {true, https} ->
+		Error = https_through_proxy_is_not_currently_supported,
+		self() ! {init_error,
+			  Error, httpc_response:error(Request, Error)},
+		{ok, #state{request = Request, options = Options,
+			    status = ssl_tunnel}};
+	    {_, _} ->
+		connect_and_send_first_request(Address, Request,
+				   #state{options = Options,
+					  profile_name = ProfileName})
+	end,
+    gen_server:enter_loop(?MODULE, [], State).
 
 %%--------------------------------------------------------------------
 %% Function: handle_call(Request, From, State) -> {reply, Reply, State} |
@@ -249,41 +256,6 @@ init([Options, ProfileName]) ->
 %%          {stop, Reason, State}            (terminate/2 is called)
 %% Description: Handling call messages
 %%--------------------------------------------------------------------
-
-
-%% This is the first request, the reason the proc was started
-handle_call({connect_and_send, #request{address = Address0,
-					scheme  = Scheme} = Request}, 
-	    _From, 
-	    #state{options = #options{proxy = Proxy}, 
-		   status  = undefined,
-		   session = undefined} = State) ->
-    ?hcrv("connect and send", [{address0, Address0}, {proxy, Proxy}]),
-    Address = handle_proxy(Address0, Proxy),
-    if
-	((Address =/= Address0) andalso (Scheme  =:= https)) ->
-	    %% This is what we should do if and when ssl supports 
-	    %% "socket upgrading"
-	    %%send_ssl_tunnel_request(Address, Request,
-	    %%		    #state{options = Options,
-	    %%		   status = ssl_tunnel});
-	    Reason = {failed_connecting, 
-		      https_through_proxy_is_not_currently_supported},
-	    %% Send a reply to the original caller
-	    ErrorResponse = httpc_response:error(Request, Reason), 
-	    httpc_response:send(Request#request.from, ErrorResponse),
-	    %% Reply to the manager
-	    ErrorReply    = {error, Reason},
-	    {stop, normal, ErrorReply, State};
-	true ->
-	    case connect_and_send_first_request(Address, Request, State) of
-		{ok, NewState} ->
-		    {reply, ok, NewState};
-		{stop, Error, NewState} ->
-		    {stop, normal, Error, NewState}
-	    end
-    end;
-	
 handle_call(#request{address = Addr} = Request, _, 
 	    #state{status  = Status,
 		   session = #session{type = pipeline} = Session,
@@ -445,25 +417,27 @@ handle_call(info, _, State) ->
 %% handle_keep_alive_queue/2 on the other hand will just skip the
 %% request as if it was never issued as in this case the request will
 %% not have been sent. 
-handle_cast({cancel, RequestId}, 
+handle_cast({cancel, RequestId, From},
 	    #state{request      = #request{id = RequestId} = Request,
 		   profile_name = ProfileName,
 		   canceled     = Canceled} = State) ->
     ?hcrv("cancel current request", [{request_id, RequestId}, 
 				     {profile,    ProfileName},
 				     {canceled,   Canceled}]),
-    httpc_manager:request_canceled(RequestId, ProfileName),
+    httpc_manager:request_canceled(RequestId, ProfileName, From),
     ?hcrv("canceled", []),
     {stop, normal, 
      State#state{canceled = [RequestId | Canceled],
 		 request  = Request#request{from = answer_sent}}};
-handle_cast({cancel, RequestId}, 
+handle_cast({cancel, RequestId, From},
 	    #state{profile_name = ProfileName,
+		   request      = #request{id = CurrId},
 		   canceled     = Canceled} = State) ->
-    ?hcrv("cancel", [{request_id, RequestId}, 
+    ?hcrv("cancel", [{request_id, RequestId},
+		     {curr_req_id, CurrId},
 		     {profile, ProfileName},
 		     {canceled,   Canceled}]),
-    httpc_manager:request_canceled(RequestId, ProfileName),
+    httpc_manager:request_canceled(RequestId, ProfileName, From),
     ?hcrv("canceled", []),
     {noreply, State#state{canceled = [RequestId | Canceled]}};
 
@@ -872,62 +846,55 @@ connect(SocketType, ToAddress,
 	    Opts3 = [IpFamily | Opts2], 
 	    http_transport:connect(SocketType, ToAddress, Opts3, Timeout)
     end.
-		
-connect_and_send_first_request(Address, 
-			       #request{settings    = Settings,
-					headers     = Headers,
-					address     = OrigAddress,
-					scheme      = Scheme} = Request, 
-			       #state{options = Options} = State) ->
-
-    ?hcrd("connect", 
-	  [{address, Address}, {request, Request}, {options, Options}]),
 
+connect_and_send_first_request(Address, Request, #state{options = Options} = State) ->
     SocketType  = socket_type(Request),
-    ConnTimeout = Settings#http_options.connect_timeout,
+    ConnTimeout = (Request#request.settings)#http_options.connect_timeout,
+    ?hcri("connect",
+	  [{address, Address}, {request, Request}, {options, Options}]),
     case connect(SocketType, Address, Options, ConnTimeout) of
 	{ok, Socket} ->
-	    Session = #session{id          = {OrigAddress, self()},
-			       scheme      = Scheme,
-			       socket      = Socket,
-			       socket_type = SocketType}, 
-	    ?hcrd("connected - now send first request", [{socket, Socket}]),
+	    ClientClose =
+			httpc_request:is_client_closing(
+			  Request#request.headers),
+	    SessionType = httpc_manager:session_type(Options),
+	    SocketType  = socket_type(Request),
+	    Session = #session{id = {Request#request.address, self()},
+			       scheme = Request#request.scheme,
+			       socket = Socket,
+			       socket_type = SocketType,
+			       client_close = ClientClose,
+			       type = SessionType},
+	    ?hcri("connected - now send first request", [{socket, Socket}]),
+
 	    case httpc_request:send(Address, Session, Request) of
 		ok ->
-		    ?hcrd("first request sent", []),
-		    ClientClose = 
-			httpc_request:is_client_closing(Headers),
-		    SessionType = httpc_manager:session_type(Options),
-		    Session2 =
-			Session#session{client_close = ClientClose,
-					type         = SessionType},
-		    TmpState = 
-			State#state{request     = Request, 
-				    session     = Session2, 
-				    mfa         = init_mfa(Request, State),
-				    status_line = init_status_line(Request),
-				    headers     = undefined,
-				    body        = undefined,
-				    status      = new},
-		    ?hcrt("activate socket", []),
-		    activate_once(Session),
+		    ?hcri("first request sent", []),
+		    TmpState = State#state{request = Request,
+					   session = Session,
+					   mfa = init_mfa(Request, State),
+					   status_line =
+					   init_status_line(Request),
+					   headers = undefined,
+					   body = undefined,
+					   status = new},
+		    http_transport:setopts(SocketType,
+					   Socket, [{active, once}]),
 		    NewState = activate_request_timeout(TmpState),
 		    {ok, NewState};
-
-		{error, Reason} = Error -> 
-		    ?hcrv("failed sending request", [{reason, Reason}]),
-		    {stop, Error, 
-		     State#state{session = {send_failed, Reason}, 
-				 request = Request}}
+		{error, Reason} ->
+		    self() ! {init_error, error_sending,
+			      httpc_response:error(Request, Reason)},
+		    {ok, State#state{request = Request,
+				     session =
+					 #session{socket = Socket}}}
 	    end;
-
-	{error, Reason} = Error -> 
-	    ?hcri("connect failed", [{reason, Reason}]),
-	    {stop, Error, State#state{session = {connect_failed, Reason},
-				       request = Request}}
+	{error, Reason} ->
+	    self() ! {init_error, error_connecting,
+		      httpc_response:error(Request, Reason)},
+	    {ok, State#state{request = Request}}
     end.
 
-
 handler_info(#state{request     = Request, 
 		    session     = Session, 
 		    status_line = _StatusLine, 
@@ -1167,12 +1134,12 @@ handle_response(#state{request      = Request,
 	{ok, Msg, Data} ->
 	    ?hcrd("handle response - ok", []),
 	    end_stream(StatusLine, Request),
-	    NewState = answer_request(Request, Msg, State),
+	    NewState = maybe_send_answer(Request, Msg, State),
 	    handle_queue(NewState, Data); 
 	{stop, Msg} ->
 	    ?hcrd("handle response - stop", [{msg, Msg}]),
 	    end_stream(StatusLine, Request),
-	    NewState = answer_request(Request, Msg, State),
+	    NewState = maybe_send_answer(Request, Msg, State),
 	    {stop, normal, NewState}
     end.
 
@@ -1242,7 +1209,8 @@ handle_pipeline(#state{status       = pipeline,
 		    %% See comment for handle_cast({cancel, RequestId})
 		    {stop, normal, 
 		     State#state{request = 
-				 NextRequest#request{from = answer_sent}}};
+				 NextRequest#request{from = answer_sent},
+				 pipeline = Pipeline}};
 		false ->
 		    ?hcrv("next request", [{request, NextRequest}]),
 		    NewSession = 
@@ -1443,6 +1411,7 @@ answer_request(#request{id = RequestId, from = From} = Request, Msg,
     Timer = {RequestId, TimerRef},
     cancel_timer(TimerRef, {timeout, Request#request.id}),
     httpc_manager:request_done(RequestId, ProfileName),
+
     State#state{request = Request#request{from = answer_sent},
 		timers = 
 		Timers#timers{request_timers =
@@ -1662,71 +1631,28 @@ handle_verbose(_) ->
     ok.    
 
 
-%%% Normaly I do not comment out code, I throw it away. But this might
-%%% actually be used one day if ssl is improved.
-%% send_ssl_tunnel_request(Address, Request = #request{address = {Host, Port}}, 
-%% 			State) ->
-%%     %% A ssl tunnel request is a special http request that looks like
-%%     %% CONNECT host:port HTTP/1.1
-%%     SslTunnelRequest = #request{method = connect, scheme = http,
-%% 				headers = 
-%% 				#http_request_h{
-%% 				  host = Host, 
-%% 				  address = Address, 
-%% 				  path = Host ++ ":",
-%% 				  pquery = integer_to_list(Port),
-%% 				  other = [{ "Proxy-Connection", "keep-alive"}]},
-%%     Ipv6 = (State#state.options)#options.ipv6,
-%%     SocketType = socket_type(SslTunnelRequest),
-%%     case http_transport:connect(SocketType, 
-%%                                 SslTunnelRequest#request.address, Ipv6) of
-%% 	{ok, Socket} ->
-%% 	    case httpc_request:send(Address, SslTunnelRequest, Socket) of
-%% 		ok ->
-%% 		    Session = #tcp_session{id = 
-%% 					   {SslTunnelRequest#request.address,
-%% 					    self()},
-%% 					   scheme = 
-%% 					   SslTunnelRequest#request.scheme,
-%% 					   socket = Socket},
-%% 		    NewState = State#state{mfa = 
-%% 					   {httpc_response, parse,
-%% 					    [State#state.max_header_size]},
-%% 					   request = Request,
-%% 					   session = Session},
-%% 		    http_transport:setopts(socket_type(
-%%                                           SslTunnelRequest#request.scheme), 
-%% 					   Socket, 
-%% 					   [{active, once}]),
-%% 		    {ok, NewState};
-%% 		{error, Reason} -> 
-%% 		    self() ! {init_error, error_sending, 
-%% 			      httpc_response:error(Request, Reason)},
-%% 		    {ok, State#state{request = Request,
-%% 				     session = #tcp_session{socket = 
-%% 							    Socket}}}
-%% 	    end;
-%% 	{error, Reason} ->
-%% 	    self() ! {init_error, error_connecting, 
-%% 		      httpc_response:error(Request, Reason)},
-%% 	    {ok, State#state{request = Request}}
-%%     end.
-
-%% d(F) ->
-%%    d(F, []).
-
-%% d(F, A) -> 
-%%     d(get(dbg), F, A).
-
-%% d(true, F, A) ->
-%%     io:format(user, "~w:~w:" ++ F ++ "~n", [self(), ?MODULE | A]);
-%% d(_, _, _) ->
-%%     ok.
-
 
+send_raw(#session{socket = Socket, socket_type = SocketType}, 
+	 {ProcessBody, Acc}) when is_function(ProcessBody, 1) ->
+    ?hcrt("send raw", [{acc, Acc}]),
+    send_raw(SocketType, Socket, ProcessBody, Acc);
 send_raw(#session{socket = Socket, socket_type = SocketType}, Body) ->
     http_transport:send(SocketType, Socket, Body).
 
+send_raw(SocketType, Socket, ProcessBody, Acc) ->
+    case ProcessBody(Acc) of
+        eof ->
+            ok;
+        {ok, Data, NewAcc} ->
+            DataBin = iolist_to_binary(Data),
+            ?hcrd("send", [{data, DataBin}]),
+            case http_transport:send(SocketType, Socket, DataBin) of
+                ok ->
+                    send_raw(SocketType, Socket, ProcessBody, NewAcc);
+                Error ->
+                    Error
+            end
+    end.
 
 
 call(Msg, Pid) ->
@@ -1738,11 +1664,5 @@ call(Msg, Pid, Timeout) ->
 cast(Msg, Pid) ->
     gen_server:cast(Pid, Msg).
 
-
-%% to(To, Start) when is_integer(Start) andalso (Start >= 0) ->
-%%     http_util:timeout(To, Start);
-%% to(To, _Start) ->
-%%     http_util:timeout(To, t()).
-
 t() ->
     http_util:timestamp().
diff --git a/lib/inets/src/http_client/httpc_handler_sup.erl b/lib/inets/src/http_client/httpc_handler_sup.erl
index 2a69fd15d0..f7a0b014b3 100644
--- a/lib/inets/src/http_client/httpc_handler_sup.erl
+++ b/lib/inets/src/http_client/httpc_handler_sup.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2007-2010. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2011. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -23,7 +23,7 @@
 
 %% API
 -export([start_link/0]).
--export([start_child/2]).
+-export([start_child/1]).
 
 %% Supervisor callback
 -export([init/1]).
@@ -34,11 +34,9 @@
 start_link() ->
     supervisor:start_link({local, ?MODULE}, ?MODULE, []).
 
-start_child(Options, Profile) ->
-    Args = [Options, Profile], 
+start_child(Args) ->
     supervisor:start_child(?MODULE, Args).
 
-
 %%%=========================================================================
 %%%  Supervisor callback
 %%%=========================================================================
diff --git a/lib/inets/src/http_client/httpc_manager.erl b/lib/inets/src/http_client/httpc_manager.erl
index 591cb78c29..7f66b477eb 100644
--- a/lib/inets/src/http_client/httpc_manager.erl
+++ b/lib/inets/src/http_client/httpc_manager.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2002-2010. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2011. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -29,7 +29,7 @@
 	 start_link/3, 
 	 request/2, 
 	 cancel_request/2,
-	 request_canceled/2, 
+	 request_canceled/3,
 	 request_done/2, 
 	 retry_request/2, 
 	 redirect_request/2,
@@ -66,6 +66,7 @@
 	  state    % State of the handler: initiating | started | operational | canceled
 	 }).
 
+-define(DELAY, 500).
 
 %%====================================================================
 %% Internal Application API
@@ -158,7 +159,8 @@ cancel_request(RequestId, ProfileName) ->
 %% be called by the httpc handler process.
 %%--------------------------------------------------------------------
 
-request_canceled(RequestId, ProfileName) ->
+request_canceled(RequestId, ProfileName, From) ->
+    gen_server:reply(From, ok),
     cast(ProfileName, {request_canceled, RequestId}).
 
 
@@ -355,44 +357,32 @@ do_init(ProfileName, CookiesDir) ->
 %%          {stop, Reason, State}            (terminate/2 is called)
 %% Description: Handling call messages
 %%--------------------------------------------------------------------
-handle_call({request, Request}, _From, State) ->
-    ?hcrv("request", [{request, Request}]),
+handle_call({request, Request}, _, State) ->
+    ?hcri("request", [{request, Request}]),
     case (catch handle_request(Request, State)) of
-	{ok, ReqId, NewState} ->
-	    {reply, {ok, ReqId}, NewState};
-	
+	{reply, Msg, NewState} ->
+	    {reply, Msg, NewState};
 	Error ->
-	    NewError = {error, {failed_process_request, Error}}, 
-	    {reply, NewError, State}
+	    {stop, Error, httpc_response:error(Request, Error), State}
     end;
-	
-handle_call({cancel_request, RequestId}, From, 
-	    #state{handler_db = HandlerDb} = State) ->
-    ?hcrv("cancel_request", [{request_id, RequestId}]),
+
+handle_call({cancel_request, RequestId}, From, State) ->
+    ?hcri("cancel_request", [{request_id, RequestId}]),
     case ets:lookup(State#state.handler_db, RequestId) of
 	[] ->
-	    ?hcrd("nothing to cancel", []),
-	    Reply = ok, %% Nothing to cancel
-	    {reply, Reply, State};
-
-	[#handler_info{handler = Pid}] when is_pid(Pid) ->
-	    ?hcrd("found operational handler for this request", 
-		  [{handler, Pid}]),
-	    httpc_handler:cancel(RequestId, Pid),
-	    {noreply, State#state{cancel = 
-				  [{RequestId, Pid, From} | 
-				   State#state.cancel]}};
-
-	[#handler_info{starter = Pid, state = HandlerState}] 
-	when is_pid(Pid) ->
-	    ?hcri("found *initiating* handler for this request", 
-		  [{starter, Pid}, {state, HandlerState}]),
-	    ets:update_element(HandlerDb, RequestId, 
-			       {#handler_info.state, canceled}),
+	    %% The request has allready compleated make sure
+	    %% it is deliverd to the client process queue so
+	    %% it can be thrown away by httpc:cancel_request
+	    %% This delay is hopfully a temporary workaround.
+	    %% Note that it will not not delay the manager,
+	    %% only the client that called httpc:cancel_request
+	    timer:apply_after(?DELAY, gen_server, reply, [From, ok]),
+	    {noreply, State};
+	[{_, Pid, _}] ->
+	    httpc_handler:cancel(RequestId, Pid, From),
 	    {noreply, State#state{cancel = 
-				  [{RequestId, Pid, From} | 
+				  [{RequestId, Pid, From} |
 				   State#state.cancel]}}
-
     end;
 
 handle_call(reset_cookies, _, #state{cookie_db = CookieDb} = State) ->
@@ -437,43 +427,16 @@ handle_call(Req, From, #state{profile_name = ProfileName} = State) ->
 %%--------------------------------------------------------------------
 handle_cast({retry_or_redirect_request, {Time, Request}}, 
 	    #state{profile_name = ProfileName} = State) ->
-    ?hcrv("retry or redirect request", [{time, Time}, {request, Request}]),
-    case timer:apply_after(Time, ?MODULE, retry_request, 
-			   [Request, ProfileName]) of
-	{ok, _} ->
-	    {noreply, State};
-	{error, Reason} ->
-	    error_report(ProfileName, 
-			 "failed scheduling retry/redirect request"
-			 "~n   Time:    ~p"
-			 "~n   Request: ~p"
-			 "~n   Reason:  ~p", [Time, Request, Reason]),
-	    {noreply, State}
-    end;
+    {ok, _} = timer:apply_after(Time, ?MODULE, retry_request, [Request, ProfileName]),
+    {noreply, State};
 
-handle_cast({retry_or_redirect_request, Request}, 
-	    #state{profile_name = Profile, 
-		   handler_db   = HandlerDb} = State) ->
-    ?hcrv("retry or redirect request", [{request, Request}]),
+handle_cast({retry_or_redirect_request, Request}, State) ->
     case (catch handle_request(Request, State)) of
-	{ok, _, NewState} ->
+	{reply, {ok, _}, NewState} ->
 	    {noreply, NewState};
-
 	Error  ->
-	    ReqId = Request#request.id, 
-	    error_report(Profile, 
-			 "failed to retry or redirect request ~p"
-			 "~n   Error: ~p", [ReqId, Error]),
-	    case ets:lookup(HandlerDb, ReqId) of
-		[#handler_info{from = From}] ->	
-		    Error2 = httpc_response:error(Request, Error), 
-		    httpc_response:send(From, Error2),
-		    ok;
-		
-		_ ->
-		    ok
-	    end,
-	    {noreply, State}
+	    httpc_response:error(Request, Error),
+	    {stop, Error, State}
     end;
 
 handle_cast({request_canceled, RequestId}, State) ->
@@ -482,7 +445,6 @@ handle_cast({request_canceled, RequestId}, State) ->
     case lists:keysearch(RequestId, 1, State#state.cancel) of
 	{value, Entry = {RequestId, _, From}} ->
 	    ?hcrt("found in cancel", [{from, From}]),
-	    gen_server:reply(From, ok),
 	    {noreply, 
 	     State#state{cancel = lists:delete(Entry, State#state.cancel)}};
 	Else ->
@@ -539,8 +501,6 @@ handle_cast(Msg, #state{profile_name = ProfileName} = State) ->
 		 "recived unknown message"
 		 "~n   Msg: ~p", [Msg]),
     {noreply, State}.
-
-
 	    
 %%--------------------------------------------------------------------
 %% Function: handle_info(Info, State) -> {noreply, State} |
@@ -548,39 +508,17 @@ handle_cast(Msg, #state{profile_name = ProfileName} = State) ->
 %%          {stop, Reason, State}            (terminate/2 is called)
 %% Description: Handling all non call/cast messages
 %%---------------------------------------------------------
-
-handle_info({started, StarterPid, ReqId, HandlerPid}, State) ->
-    handle_started(StarterPid, ReqId, HandlerPid, State),
-    {noreply, State};
-
-handle_info({connect_and_send, StarterPid, ReqId, HandlerPid, Res}, State) ->
-    handle_connect_and_send(StarterPid, ReqId, HandlerPid, Res, State),
-    {noreply, State};
-
-handle_info({failed_starting_handler, StarterPid, ReqId, Res}, State) ->
-    handle_failed_starting_handler(StarterPid, ReqId, Res, State),
-    {noreply, State};
-
-handle_info({'EXIT', Pid, Reason}, #state{handler_db = HandlerDb} = State) ->
-    maybe_handle_terminating_starter(Pid, Reason, HandlerDb), 
+handle_info({'EXIT', _, _}, State) ->
+    %% Handled in DOWN
     {noreply, State};
-
 handle_info({'DOWN', _, _, Pid, _}, State) ->
-    
-    %% 
-    %% Normally this should have been cleaned up already
-    %% (when receiving {request_done, PequestId}), but
-    %% just in case there is a glitch, cleanup anyway.
-    %% 
-
-    Pattern = #handler_info{handler = Pid, _ = '_'}, 
-    ets:match_delete(State#state.handler_db, Pattern),
+    ets:match_delete(State#state.handler_db, {'_', Pid, '_'}),
 
     %% If there where any canceled request, handled by the
     %% the process that now has terminated, the
     %% cancelation can be viewed as sucessfull!
-    NewCanceledList = 
-	lists:foldl(fun({_, HandlerPid, From} = Entry, Acc)  ->
+    NewCanceldList =
+	lists:foldl(fun(Entry = {_, HandlerPid, From}, Acc)  ->
 			    case HandlerPid of
 				Pid ->
 				    gen_server:reply(From, ok),
@@ -589,15 +527,13 @@ handle_info({'DOWN', _, _, Pid, _}, State) ->
 				    Acc
 			    end 
 		    end, State#state.cancel, State#state.cancel),
-    {noreply, State#state{cancel = NewCanceledList}};    
-
-handle_info(Info, #state{profile_name = ProfileName} = State) ->
-    error_report(ProfileName, 
-		 "received unknown info"
-		 "~n   Info: ~p", [Info]),
+    {noreply, State#state{cancel = NewCanceldList}};
+handle_info(Info, State) ->
+    Report = io_lib:format("Unknown message in "
+			   "httpc_manager:handle_info ~p~n", [Info]),
+    error_logger:error_report(Report),
     {noreply, State}. 
 
-
 %%--------------------------------------------------------------------
 %% Function: terminate(Reason, State) -> _  (ignored by gen_server)
 %% Description: Shutdown the httpc_handler
@@ -655,224 +591,79 @@ get_handler_info(Tab) ->
 		    {Pid, State} <- Handlers2],
     Handlers3.
 
-
-%% 
-%% The request handler process is started asynchronously by a 
-%% "starter process". When the handler has sucessfully been started,
-%% this message (started) is sent.
-%% 
-
-handle_started(StarterPid, ReqId, HandlerPid, 
-			#state{profile_name = Profile, 
-			       handler_db   = HandlerDb}) ->
-    case ets:lookup(HandlerDb, ReqId) of
-	[#handler_info{state = initiating} = HandlerInfo] ->
-	    ?hcri("received started ack for initiating handler", []),
-	    %% As a last resort, make sure we know when it exits,
-	    %% in case it forgets to notify us.
-	    %% We dont need to know the ref id?
-	    erlang:monitor(process, HandlerPid),
-	    HandlerInfo2 = HandlerInfo#handler_info{handler = HandlerPid,
-						    state   = started}, 
-	    ets:insert(HandlerDb, HandlerInfo2),
-	    ok;
-
-	[#handler_info{state = State}] ->
-	    error_report(Profile, 
-			 "unexpected (started) message for handler (~p) in state "
-			 "~p regarding request ~p - ignoring", [HandlerPid, State, ReqId]),
-	    ?hcri("received unexpected started message", [{state, State}]),
-	    ok;
-
-	[] ->
-	    error_report(Profile, 
-			 "unknown handler ~p (~p) started for request ~w - canceling",
-			 [HandlerPid, StarterPid, ReqId]),
-	    httpc_handler:cancel(ReqId, HandlerPid)
-    end.
-
-
-%% 
-%% The request handler process is started asynchronously by a 
-%% "starter process". When that process terminates it sends 
-%% one of two messages. These ara handled by the two functions
-%% below.
-%% 
-
-handle_connect_and_send(_StarterPid, ReqId, HandlerPid, Result, 
-			#state{profile_name = Profile, 
-			       handler_db   = HandlerDb}) ->
-    case ets:lookup(HandlerDb, ReqId) of
-	[#handler_info{state = started} = HandlerInfo] when Result =:= ok ->
-	    ?hcri("received connect-and-send ack for started handler", []),
-	    HandlerInfo2 = HandlerInfo#handler_info{starter = undefined, 
-						    handler = HandlerPid,
-						    state   = operational}, 
-	    ets:insert(HandlerDb, HandlerInfo2),
-	    ok;
-
-	[#handler_info{state = canceled} = HandlerInfo] when Result =:= ok ->
-	    ?hcri("received connect-and-send ack for canceled handler", []),
-	    httpc_handler:cancel(ReqId, HandlerPid),
-	    HandlerInfo2 = HandlerInfo#handler_info{starter = undefined, 
-						    handler = HandlerPid}, 
-	    ets:insert(HandlerDb, HandlerInfo2),
-	    ok;
-
-	[#handler_info{state = State}] when Result =/= ok ->
-	    error_report(Profile, 
-			 "handler (~p, ~w) failed to connect and/or "
-			 "send request ~p"
-			 "~n   Result: ~p", 
-			 [HandlerPid, State, ReqId, Result]),
-	    ?hcri("received connect-and-send error", 
-		  [{result, Result}, {state, State}]),
-	    %% We don't need to send a response to the original caller
-	    %% because the handler already sent one in its terminate
-	    %% function.
-	    ets:delete(HandlerDb, ReqId), 
-	    ok;
-
-	[] ->
-	    ?hcri("handler successfully started "
-		  "for unknown request => canceling",
-		  [{profile, Profile}, 
-		   {handler, HandlerPid}, 
-		   {request, ReqId}]),
-	    httpc_handler:cancel(ReqId, HandlerPid)
-    end.
-
-
-handle_failed_starting_handler(_StarterPid, ReqId, Error, 
-			       #state{profile_name = Profile, 
-				      handler_db = HandlerDb}) ->
-    case ets:lookup(HandlerDb, ReqId) of
-	[#handler_info{state = canceled}] ->
-	    error_report(Profile, 
-			 "failed starting handler for request ~p"
-			 "~n   Error: ~p", [ReqId, Error]),
-	    request_canceled(Profile, ReqId), % Fake signal from handler
-	    ets:delete(HandlerDb, ReqId), 
-	    ok;
-
-	[#handler_info{from = From}] ->
-	    error_report(Profile, 
-			 "failed starting handler for request ~p"
-			 "~n   Error: ~p", [ReqId, Error]),
-	    Reason2 = 
-		case Error of
-		    {error, Reason} ->
-			{failed_connecting, Reason};
-		    _ ->
-			{failed_connecting, Error}
-		end,
-	    DummyReq = #request{id = ReqId}, 
-	    httpc_response:send(From, httpc_response:error(DummyReq, Reason2)),
-	    ets:delete(HandlerDb, ReqId), 
-	    ok;
-
-	[] ->
-	    error_report(Profile, 
-			 "failed starting handler for unknown request ~p"
-			 "~n   Error: ~p", [ReqId, Error]),
-	    ok
-    end.
-
-
-maybe_handle_terminating_starter(MeybeStarterPid, Reason, HandlerDb) ->
-    Pattern = #handler_info{starter = MeybeStarterPid, _ = '_'}, 
-    case ets:match_object(HandlerDb, Pattern) of
-	[#handler_info{id = ReqId, from = From, state = initiating}] ->
-	    %% The starter process crashed before it could start the 
-	    %% the handler process, therefor we need to answer the 
-	    %% original caller.
-	    ?hcri("starter process crashed bfore starting handler", 
-		  [{starter, MeybeStarterPid}, {reason, Reason}]),
-	    Reason2 = 
-		case Reason of
-		    {error, Error} ->
-			{failed_connecting, Error};
-		    _ ->
-			{failed_connecting, Reason}
-		end,
-	    DummyReq = #request{id = ReqId}, 
-	    httpc_response:send(From, httpc_response:error(DummyReq, Reason2)),
-	    ets:delete(HandlerDb, ReqId),
-	    ok;
-
-	[#handler_info{state = State} = HandlerInfo] ->
-	    %% The starter process crashed after the handler was started. 
-	    %% The handler will answer to the original caller.
-	    ?hcri("starter process crashed after starting handler", 
-		  [{starter, MeybeStarterPid}, {reason, Reason}, {state, State}]),
-	    HandlerInfo2 = HandlerInfo#handler_info{starter = undefined}, 
-	    ets:insert(HandlerDb, HandlerInfo2),
-	    ok;
-
-	_ ->
-	    ok
-    end.
-
-
-%% -----
-%% Act as an HTTP/0.9 client that does not know anything
-%% about persistent connections
 handle_request(#request{settings = 
-			#http_options{version = "HTTP/0.9"}} = Request0, 
+			#http_options{version = "HTTP/0.9"}} = Request,
 	       State) ->
-    Request1 = handle_cookies(generate_request_id(Request0), State),
-    Hdrs0    = Request1#request.headers, 
-    Hdrs1    = Hdrs0#http_request_h{connection = undefined},
-    Request2 = Request1#request{headers = Hdrs1}, 
-    create_handler_starter(Request2, State),
-    {ok, Request2#request.id, State};
-
-%% -----
-%% Act as an HTTP/1.0 client that does not 
-%% use persistent connections
+    %% Act as an HTTP/0.9 client that does not know anything
+    %% about persistent connections
+
+    NewRequest = handle_cookies(generate_request_id(Request), State),
+    NewHeaders =
+	(NewRequest#request.headers)#http_request_h{connection
+						    = undefined},
+    start_handler(NewRequest#request{headers = NewHeaders}, State),
+    {reply, {ok, NewRequest#request.id}, State};
+
 handle_request(#request{settings = 
-			#http_options{version = "HTTP/1.0"}} = Request0, 
+			#http_options{version = "HTTP/1.0"}} = Request,
 	       State) ->
-    Request1 = handle_cookies(generate_request_id(Request0), State),
-    Hdrs0    = Request1#request.headers, 
-    Hdrs1    = Hdrs0#http_request_h{connection = "close"},
-    Request2 = Request1#request{headers = Hdrs1}, 
-    create_handler_starter(Request2, State),
-    {ok, Request2#request.id, State};
-
-
-%% -----
-handle_request(#request{method  = Method,
-			address = Address,
-			scheme  = Scheme} = Request0, 
-	       #state{options = Opts} = State) ->
-    Request1    = handle_cookies(generate_request_id(Request0), State),
-    SessionType = session_type(Opts),
-    case select_session(Method, Address, Scheme, SessionType, State) of
+    %% Act as an HTTP/1.0 client that does not
+    %% use persistent connections
+
+    NewRequest = handle_cookies(generate_request_id(Request), State),
+    NewHeaders =
+	(NewRequest#request.headers)#http_request_h{connection
+						    = "close"},
+    start_handler(NewRequest#request{headers = NewHeaders}, State),
+    {reply, {ok, NewRequest#request.id}, State};
+
+handle_request(Request, State = #state{options = Options}) ->
+
+    NewRequest = handle_cookies(generate_request_id(Request), State),
+    SessionType = session_type(Options),
+    case select_session(Request#request.method,
+			Request#request.address,
+			Request#request.scheme, SessionType, State) of
 	{ok, HandlerPid} ->
-	    pipeline_or_keep_alive(Request1, HandlerPid, State);
+	    pipeline_or_keep_alive(NewRequest, HandlerPid, State);
 	no_connection ->
-	    create_handler_starter(Request1, State);
-	{no_session, OpenSessions} 
-	when OpenSessions < Opts#options.max_sessions ->
-	    create_handler_starter(Request1, State);
+	    start_handler(NewRequest, State);
+	{no_session,  OpenSessions} when OpenSessions
+	< Options#options.max_sessions ->
+	    start_handler(NewRequest, State);
 	{no_session, _} ->
 	    %% Do not start any more persistent connections
 	    %% towards this server.
-	    Hdrs0    = Request1#request.headers, 
-	    Hdrs1    = Hdrs0#http_request_h{connection = "close"},
-	    Request2 = Request1#request{headers = Hdrs1}, 
-	    create_handler_starter(Request2, State)
+	    NewHeaders =
+		(NewRequest#request.headers)#http_request_h{connection
+							    = "close"},
+	    start_handler(NewRequest#request{headers = NewHeaders}, State)
     end,
-    {ok, Request1#request.id, State}.
+    {reply, {ok, NewRequest#request.id}, State}.
+
+
+start_handler(Request, State) ->
+    {ok, Pid} =
+	case is_inets_manager() of
+	    true ->
+		httpc_handler_sup:start_child([whereis(httpc_handler_sup),
+					       Request, State#state.options,
+					       State#state.profile_name]);
+	    false ->
+		httpc_handler:start_link(self(), Request, State#state.options,
+					 State#state.profile_name)
+	end,
+    ets:insert(State#state.handler_db, {Request#request.id,
+					Pid, Request#request.from}),
+    erlang:monitor(process, Pid).
 
 
 select_session(Method, HostPort, Scheme, SessionType, 
 	       #state{options = #options{max_pipeline_length   = MaxPipe,
 					 max_keep_alive_length = MaxKeepAlive},
 		      session_db = SessionDb}) ->
-    ?hcrd("select session", [{session_type,          SessionType}, 
-			     {max_pipeline_length,   MaxPipe}, 
+    ?hcrd("select session", [{session_type,          SessionType},
+			     {max_pipeline_length,   MaxPipe},
 			     {max_keep_alive_length, MaxKeepAlive}]),
     case httpc_request:is_idempotent(Method) orelse 
 	(SessionType =:= keep_alive) of
@@ -918,92 +709,17 @@ select_session(Candidates, Max) ->
 	    ?hcrd("select session - found one", [{handler, HandlerPid}]),
 	    {ok, HandlerPid}
     end.
-	    
-pipeline_or_keep_alive(#request{id = Id} = Request, HandlerPid, State) ->
-    ?hcrd("pipeline of keep-alive", [{id, Id}, {handler, HandlerPid}]),
+
+pipeline_or_keep_alive(Request, HandlerPid, State) ->
     case (catch httpc_handler:send(Request, HandlerPid)) of
 	ok ->
-	    ?hcrd("pipeline or keep-alive - successfully sent", []),
-	    Entry = #handler_info{id      = Id,
-				  handler = HandlerPid,
-				  state   = operational},
-	    ets:insert(State#state.handler_db, Entry); 
-		
-	_  -> %% timeout pipelining failed 
-	    ?hcrd("pipeline or keep-alive - failed sending -> "
-		  "start a new handler", []),
-	    create_handler_starter(Request, State)
+	    ets:insert(State#state.handler_db, {Request#request.id,
+						HandlerPid,
+						Request#request.from});
+	_  -> %timeout pipelining failed
+	    start_handler(Request, State)
     end.
 
-
-create_handler_starter(#request{socket_opts = SocketOpts} = Request, 
-		       #state{options = Options} = State) 
-  when is_list(SocketOpts) ->
-    %% The user provided us with (override) socket options
-    ?hcrt("create handler starter", [{socket_opts, SocketOpts}, {options, Options}]),
-    Options2 = Options#options{socket_opts = SocketOpts}, 
-    create_handler_starter(Request#request{socket_opts = undefined}, 
-			   State#state{options = Options2});
-
-create_handler_starter(#request{id          = Id, 
-				from        = From} = Request, 
-		       #state{profile_name = ProfileName,
-			      options      = Options,
-			      handler_db   = HandlerDb} = _State) ->
-    ?hcrv("create handler starter", [{id, Id}, {profile, ProfileName}]),
-    IsInetsManager = is_inets_manager(), 
-    ManagerPid = self(), 
-    StarterFun = 
-	fun() ->
-		?hcrd("handler starter - start", 
-		      [{id,            Id}, 
-		       {profile,       ProfileName}, 
-		       {inets_manager, IsInetsManager}]),
-		Result1 = 
-		    case IsInetsManager of
-			true ->
-			    httpc_handler_sup:start_child(Options, 
-							  ProfileName);
-			false ->
-			    httpc_handler:start_link(Options, 
-						     ProfileName)
-		    end,
-		?hcrd("handler starter - maybe connect and send", 
-		      [{id, Id}, {profile, ProfileName}, {result, Result1}]),
-		case Result1 of
-		    {ok, HandlerPid} ->
-			StartedMessage = 
-			    {started, self(), Id, HandlerPid}, 
-			ManagerPid ! StartedMessage, 
-			Result2 = httpc_handler:connect_and_send(Request, 
-								 HandlerPid),
-			?hcrd("handler starter - connected and sent", 
-			      [{id, Id}, {profile, ProfileName}, 
-			       {handler, HandlerPid}, {result, Result2}]),
-			ConnAndSendMessage = 
-			    {connect_and_send, 
-			     self(), Id, HandlerPid, Result2}, 
-			ManagerPid ! ConnAndSendMessage;
-		     {error, Reason} ->
-			StartFailureMessage = 
-			    {failed_starting_handler, self(), Id, Reason}, 
-			ManagerPid ! StartFailureMessage;
-		     _ ->
-			StartFailureMessage = 
-			    {failed_starting_handler, self(), Id, Result1}, 
-			ManagerPid ! StartFailureMessage
-		end
-	end,
-    Starter = erlang:spawn_link(StarterFun),
-    ?hcrd("create handler starter - started", [{id, Id}, {starter, Starter}]),
-    Entry = #handler_info{id      = Id,
-			  starter = Starter, 
-			  from    = From, 
-			  state   = initiating},
-    ets:insert(HandlerDb, Entry),
-    ok.
-		
-	
 is_inets_manager() ->
     case get('$ancestors') of
 	[httpc_profile_sup | _] ->
@@ -1045,8 +761,6 @@ do_store_cookies([Cookie | Cookies], #state{cookie_db = CookieDb} = State) ->
     ok = httpc_cookie:insert(CookieDb, Cookie),
     do_store_cookies(Cookies, State).
 
-
-
 session_db_name(ProfileName) ->
     make_db_name(ProfileName, "__session_db").
 
@@ -1074,7 +788,6 @@ cast(ProfileName, Msg) ->
    gen_server:cast(ProfileName, Msg).
 
 
-
 get_proxy(Opts, #options{proxy = Default}) ->
     proplists:get_value(proxy, Opts, Default).
 
@@ -1133,20 +846,6 @@ handle_verbose(trace) ->
 handle_verbose(_) ->
     ok.  
 
-
 error_report(Profile, F, A) ->
     Report = io_lib:format("HTTPC-MANAGER<~p> " ++ F ++ "~n", [Profile | A]), 
     error_logger:error_report(Report).
-
-
-%% d(F) ->
-%%    d(F, []).
-
-%% d(F, A) -> 
-%%     d(get(dbg), F, A).
-
-%% d(true, F, A) ->
-%%     io:format(user, "~w:~w:" ++ F ++ "~n", [self(), ?MODULE | A]);
-%% d(_, _, _) ->
-%%     ok.
-
diff --git a/lib/inets/src/http_client/httpc_request.erl b/lib/inets/src/http_client/httpc_request.erl
index d4df97ad40..879053f0f2 100644
--- a/lib/inets/src/http_client/httpc_request.erl
+++ b/lib/inets/src/http_client/httpc_request.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2004-2010. All Rights Reserved.
+%% Copyright Ericsson AB 2004-2011. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -79,36 +79,62 @@ send(SendAddr, Socket, SocketType,
 	   {settings,      HttpOptions}, 
 	   {userinfo,      UserInfo}]),
 
-    TmpHeaders = handle_user_info(UserInfo, Headers),
+    TmpHdrs = handle_user_info(UserInfo, Headers),
 
-    {TmpHeaders2, Body} = 
-	post_data(Method, TmpHeaders, Content, HeadersAsIs),
+    {TmpHdrs2, Body} = post_data(Method, TmpHdrs, Content, HeadersAsIs),
     
-    {NewHeaders, Uri} = case Address of
-			    SendAddr ->
-				{TmpHeaders2, Path ++ Query};
-			    _Proxy ->
-				TmpHeaders3 =
-				    handle_proxy(HttpOptions, TmpHeaders2),
-				{TmpHeaders3, AbsUri}
-			end,
-
-    FinalHeaders = case NewHeaders of
-		       HeaderList when is_list(HeaderList) ->
-			   http_headers(HeaderList, []);
-		       _  ->
-			   http_request:http_headers(NewHeaders)
-		   end,
+    {NewHeaders, Uri} = 
+	case Address of
+	    SendAddr ->
+		{TmpHdrs2, Path ++ Query};
+	    _Proxy ->
+		TmpHdrs3 = handle_proxy(HttpOptions, TmpHdrs2), 
+		{TmpHdrs3, AbsUri}
+	end,
+    
+    FinalHeaders = 
+	case NewHeaders of
+	    HeaderList when is_list(HeaderList) ->
+		http_headers(HeaderList, []);
+	    _  ->
+		http_request:http_headers(NewHeaders)
+	end,
     Version = HttpOptions#http_options.version,
 
-    Message = [method(Method), " ", Uri, " ", 
-	       version(Version), ?CRLF, 
-	       headers(FinalHeaders, Version), ?CRLF, Body],
+    do_send_body(SocketType, Socket, Method, Uri, Version, FinalHeaders, Body).
+
+
+do_send_body(SocketType, Socket, Method, Uri, Version, Headers, 
+	     {ProcessBody, Acc}) when is_function(ProcessBody, 1) ->
+    ?hcrt("send", [{acc, Acc}]),
+    case do_send_body(SocketType, Socket, Method, Uri, Version, Headers, []) of
+        ok ->
+            do_send_body(SocketType, Socket, ProcessBody, Acc);
+        Error ->
+            Error
+    end;
 
+do_send_body(SocketType, Socket, Method, Uri, Version, Headers, Body) ->
+    ?hcrt("create message", [{body, Body}]),
+    Message = [method(Method), " ", Uri, " ",
+	       version(Version), ?CRLF,
+	       headers(Headers, Version), ?CRLF, Body],
     ?hcrd("send", [{message, Message}]),
-    
-    http_transport:send(SocketType, Socket, lists:append(Message)).
+    http_transport:send(SocketType, Socket, Message).
+
 
+do_send_body(SocketType, Socket, ProcessBody, Acc) ->
+    case ProcessBody(Acc) of
+        eof ->
+            ok;
+        {ok, Data, NewAcc} ->
+            case http_transport:send(SocketType, Socket, Data) of
+                ok ->
+                    do_send_body(SocketType, Socket, ProcessBody, NewAcc);
+                Error ->
+                    Error
+            end
+    end.
 
 
 %%-------------------------------------------------------------------------
@@ -161,7 +187,6 @@ is_client_closing(Headers) ->
 %%%========================================================================
 post_data(Method, Headers, {ContentType, Body}, HeadersAsIs) 
   when (Method =:= post) orelse (Method =:= put) ->
-    ContentLength = body_length(Body),	      
     NewBody = case Headers#http_request_h.expect of
 		  "100-continue" ->
 		      "";
@@ -170,14 +195,22 @@ post_data(Method, Headers, {ContentType, Body}, HeadersAsIs)
 	      end,
     
     NewHeaders = case HeadersAsIs of
-		     [] ->
-			 Headers#http_request_h{'content-type' = 
-						ContentType, 
-						'content-length' = 
-						ContentLength};
-		     _ ->
-			 HeadersAsIs
-		 end,
+        [] ->
+            Headers#http_request_h{
+                'content-type' = ContentType,
+                'content-length' = case body_length(Body) of
+                    undefined ->
+                        % on upload streaming the caller must give a
+                        % value to the Content-Length header
+                        % (or use chunked Transfer-Encoding)
+                        Headers#http_request_h.'content-length';
+                    Len when is_list(Len) ->
+                        Len
+                    end
+            };
+        _ ->
+            HeadersAsIs
+    end,
     
     {NewHeaders, NewBody};
 
@@ -190,7 +223,10 @@ body_length(Body) when is_binary(Body) ->
    integer_to_list(size(Body));
 
 body_length(Body) when is_list(Body) ->
-  integer_to_list(length(Body)).
+  integer_to_list(length(Body));
+
+body_length({DataFun, _Acc}) when is_function(DataFun, 1) ->
+  undefined.
 
 method(Method) ->
     http_util:to_upper(atom_to_list(Method)).
diff --git a/lib/inets/src/http_lib/http_internal.hrl b/lib/inets/src/http_lib/http_internal.hrl
index 5440f214b5..2e924667c6 100644
--- a/lib/inets/src/http_lib/http_internal.hrl
+++ b/lib/inets/src/http_lib/http_internal.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2002-2010. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2011. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -28,8 +28,8 @@
 -define(HTTP_MAX_URI_SIZE,    nolimit).
 
 -ifndef(HTTP_DEFAULT_SSL_KIND).
--define(HTTP_DEFAULT_SSL_KIND, ossl).
-%% -define(HTTP_DEFAULT_SSL_KIND, essl).
+%% -define(HTTP_DEFAULT_SSL_KIND, ossl).
+-define(HTTP_DEFAULT_SSL_KIND, essl).
 -endif. % -ifdef(HTTP_DEFAULT_SSL_KIND).
 
 
diff --git a/lib/inets/src/http_lib/http_transport.erl b/lib/inets/src/http_lib/http_transport.erl
index 0024d19fc1..8cabfe3c71 100644
--- a/lib/inets/src/http_lib/http_transport.erl
+++ b/lib/inets/src/http_lib/http_transport.erl
@@ -23,7 +23,7 @@
 -export([
 	 start/1, 
 	 connect/3, connect/4, 
-	 listen/2, listen/3, 
+	 listen/2, listen/3, listen/4, 
 	 accept/2, accept/3, 
 	 close/2,
 	 send/3, 
@@ -110,7 +110,17 @@ connect(ip_comm = _SocketType, {Host, Port}, Opts0, Timeout)
     Opts = [binary, {packet, 0}, {active, false}, {reuseaddr, true} | Opts0],
     ?hlrt("connect using gen_tcp", 
 	  [{host, Host}, {port, Port}, {opts, Opts}, {timeout, Timeout}]),
-    gen_tcp:connect(Host, Port, Opts, Timeout);
+    try gen_tcp:connect(Host, Port, Opts, Timeout) of
+	{ok, _} = OK ->
+	    OK;
+	{error, _} = ERROR ->
+	    ERROR
+    catch 
+	exit:{badarg, _} ->
+	    {error, {eoptions, Opts}};
+	exit:badarg ->
+	    {error, {eoptions, Opts}}
+    end;
 
 %% Wrapper for backaward compatibillity
 connect({ssl, SslConfig}, Address, Opts, Timeout) ->
@@ -123,7 +133,14 @@ connect({ossl, SslConfig}, {Host, Port}, _, Timeout) ->
 	   {port,       Port}, 
 	   {ssl_config, SslConfig}, 
 	   {timeout,    Timeout}]),
-    ssl:connect(Host, Port, Opts, Timeout);
+    case (catch ssl:connect(Host, Port, Opts, Timeout)) of
+	{'EXIT', Reason} ->
+	    {error, {eoptions, Reason}};
+	{ok, _} = OK ->
+	    OK;
+	{error, _} = ERROR ->
+	    ERROR
+    end;
 
 connect({essl, SslConfig}, {Host, Port}, _, Timeout) ->
     Opts = [binary, {active, false}, {ssl_imp, new}] ++ SslConfig,
@@ -132,14 +149,22 @@ connect({essl, SslConfig}, {Host, Port}, _, Timeout) ->
 	   {port,       Port}, 
 	   {ssl_config, SslConfig}, 
 	   {timeout,    Timeout}]),
-    ssl:connect(Host, Port, Opts, Timeout).
+    case (catch ssl:connect(Host, Port, Opts, Timeout)) of
+	{'EXIT', Reason} ->
+	    {error, {eoptions, Reason}};
+	{ok, _} = OK ->
+	    OK;
+	{error, _} = ERROR ->
+	    ERROR
+    end.
 
 
 %%-------------------------------------------------------------------------
-%% listen(SocketType, Port) -> {ok, Socket} | {error, Reason}
+%% listen(SocketType, Addr, Port, Fd) -> {ok, Socket} | {error, Reason}
 %%      SocketType = ip_comm | {ssl, SSLConfig}  
 %%      Port = integer() 
-%%      Socket = socket()                            
+%%      Socket = socket()
+%%      Fd = undefined | fd()
 %%
 %% Description: Sets up socket to listen on the port Port on the local
 %% host using either gen_tcp or ssl. In the gen_tcp case the port
@@ -151,13 +176,8 @@ connect({essl, SslConfig}, {Host, Port}, _, Timeout) ->
 listen(SocketType, Port) ->
     listen(SocketType, undefined, Port).
 
-listen(ip_comm, Addr, Port) ->
-    case (catch listen_ip_comm(Addr, Port)) of
-	{'EXIT', Reason} ->
-	    {error, {exit, Reason}};
-	Else ->
-	    Else
-    end;
+listen(ip_comm = SocketType, Addr, Port) ->
+    listen(SocketType, Addr, Port, undefined);
 
 %% Wrapper for backaward compatibillity
 listen({ssl, SSLConfig}, Addr, Port) ->
@@ -186,9 +206,17 @@ listen({essl, SSLConfig} = Ssl, Addr, Port) ->
     Opt2 = [{ssl_imp, new}, {reuseaddr, true} | Opt], 
     ssl:listen(Port, Opt2).
 
+listen(ip_comm, Addr, Port, Fd) ->
+    case (catch listen_ip_comm(Addr, Port, Fd)) of
+	{'EXIT', Reason} ->
+	    {error, {exit, Reason}};
+	Else ->
+	    Else
+    end.
+
 
-listen_ip_comm(Addr, Port) ->
-    {NewPort, Opts, IpFamily} = get_socket_info(Addr, Port),
+listen_ip_comm(Addr, Port, Fd) ->
+    {NewPort, Opts, IpFamily} = get_socket_info(Addr, Port, Fd),
     case IpFamily of
 	inet6fb4 -> 
 	    Opts2 = [inet6 | Opts], 
@@ -223,29 +251,36 @@ listen_ip_comm(Addr, Port) ->
 ipfamily_default(Addr, Port) ->
     httpd_conf:lookup(Addr, Port, ipfamily, inet6fb4).
 
-get_socket_info(Addr, Port) ->
-    Key  = list_to_atom("httpd_" ++ integer_to_list(Port)),
-    BaseOpts =  [{backlog, 128}, {reuseaddr, true}], 
+get_socket_info(Addr, Port, Fd0) ->
+    BaseOpts        = [{backlog, 128}, {reuseaddr, true}], 
     IpFamilyDefault = ipfamily_default(Addr, Port), 
-    case init:get_argument(Key) of
-	{ok, [[Value]]} ->
-	    {Fd, IpFamily} = 
-		case string:tokens(Value, [$|]) of
-		    [FdStr, IpFamilyStr] ->
-			Fd0       = fd_of(FdStr),
-			IpFamily0 = ip_family_of(IpFamilyStr),
-			{Fd0, IpFamily0};
-		    [FdStr] ->
-			{fd_of(FdStr), IpFamilyDefault};
-		    _ ->
-			throw({error, {bad_descriptor, Value}})
-		end,
+    %% The presence of a file descriptor takes precedence
+    case get_fd(Port, Fd0, IpFamilyDefault) of
+	{Fd, IpFamily} -> 
 	    {0, sock_opt(ip_comm, Addr, [{fd, Fd} | BaseOpts]), IpFamily};
-	error ->
+	undefined ->
 	    {Port, sock_opt(ip_comm, Addr, BaseOpts), IpFamilyDefault}
     end.
 	    
+get_fd(Port, undefined = _Fd, IpFamilyDefault) ->
+    FdKey = list_to_atom("httpd_" ++ integer_to_list(Port)),
+    case init:get_argument(FdKey) of
+	{ok, [[Value]]} ->
+	    case string:tokens(Value, [$|]) of
+		[FdStr, IpFamilyStr] ->
+		    {fd_of(FdStr), ip_family_of(IpFamilyStr)};
+		[FdStr] ->
+		    {fd_of(FdStr), IpFamilyDefault};
+		_ ->
+		    throw({error, {bad_descriptor, Value}})
+	    end;
+	error ->
+	    undefined
+    end;
+get_fd(_Port, Fd, IpFamilyDefault) ->
+    {Fd, IpFamilyDefault}.
 
+    
 fd_of(FdStr) ->
     case (catch list_to_integer(FdStr)) of
 	Fd when is_integer(Fd) ->
diff --git a/lib/inets/src/http_lib/http_util.erl b/lib/inets/src/http_lib/http_util.erl
index 4f1147176c..5e6b69ac5e 100644
--- a/lib/inets/src/http_lib/http_util.erl
+++ b/lib/inets/src/http_lib/http_util.erl
@@ -25,7 +25,8 @@
 	 hexlist_to_integer/1, integer_to_hexlist/1, 
 	 convert_month/1, 
 	 is_hostname/1,
-	 timestamp/0, timeout/2
+	 timestamp/0, timeout/2,
+	 html_encode/1
 	]).
 
 
@@ -187,6 +188,13 @@ timeout(Timeout, Started) ->
     end.
     
 
+html_encode(Chars) ->
+    Reserved = sets:from_list([$&, $<, $>, $\", $', $/]),
+    lists:append(lists:map(fun(Char) ->
+	               char_to_html_entity(Char, Reserved)
+	           end, Chars)).
+
+
 %%%========================================================================
 %%% Internal functions
 %%%========================================================================
@@ -235,3 +243,11 @@ convert_to_ascii([Num | Reversed], Number)
 convert_to_ascii([Num | Reversed], Number) 
   when (Num > 9) andalso (Num < 16) ->
     convert_to_ascii(Reversed, [Num + 55 | Number]).
+
+char_to_html_entity(Char, Reserved) ->
+    case sets:is_element(Char, Reserved) of
+	true ->
+	    "&#" ++ integer_to_list(Char) ++ ";";
+	false ->
+	    [Char]
+    end.
diff --git a/lib/inets/src/http_server/httpd_file.erl b/lib/inets/src/http_server/httpd_file.erl
index 7e21d9e158..ccc1f7874a 100644
--- a/lib/inets/src/http_server/httpd_file.erl
+++ b/lib/inets/src/http_server/httpd_file.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2006-2010. All Rights Reserved.
+%% Copyright Ericsson AB 2006-2011. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -26,22 +26,21 @@
 
 
 handle_error(eacces, Op, ModData, Path) ->
-    handle_error(403, Op, ModData, Path,"Forbidden");
+    handle_error(403, Op, ModData, Path, ": Forbidden");
 handle_error(enoent, Op, ModData, Path) ->
-    handle_error(404, Op, ModData, Path,"File not found");
+    handle_error(404, Op, ModData, Path, ": File not found");
 handle_error(enotdir, Op, ModData, Path) ->
     handle_error(404, Op, ModData, Path,
-	       ": A component of the file name is not a directory");
+	         ": A component of the file name is not a directory");
 handle_error(emfile, Op, _ModData, Path) ->
     handle_error(500, Op, none, Path, ": To many open files");
 handle_error({enfile,_}, Op, _ModData, Path) ->
     handle_error(500, Op, none, Path, ": File table overflow");
 handle_error(_Reason, Op, ModData, Path) ->
-    handle_error(404, Op, ModData, Path, "File not found").
-	    
-handle_error(StatusCode, Op, none, Path, Reason) ->
-    {StatusCode, none, ?NICE("Can't " ++ Op ++ Path ++ Reason)};
+    handle_error(404, Op, ModData, Path, ": File not found").
 
+handle_error(StatusCode, Op, none, Path, Reason) ->
+    {StatusCode, none, ?NICE("Can't " ++ Op ++ " " ++ Path ++ Reason)};
 handle_error(StatusCode, Op, ModData, Path, Reason) ->
     {StatusCode, ModData#mod.request_uri,
-     ?NICE("Can't " ++ Op ++ Path ++ Reason)}.
+     ?NICE("Can't " ++ Op ++ " " ++ Path ++ Reason)}.
diff --git a/lib/inets/src/http_server/httpd_log.erl b/lib/inets/src/http_server/httpd_log.erl
index f3ea3aa0e2..db1e2c627a 100644
--- a/lib/inets/src/http_server/httpd_log.erl
+++ b/lib/inets/src/http_server/httpd_log.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2008-2009. All Rights Reserved.
+%% Copyright Ericsson AB 2008-2011. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -113,7 +113,7 @@ do_error_entry(ConfigDB, RemoteHost, undefined, Date, Reason) ->
 do_error_entry(ConfigDB, RemoteHost, URI, Date, Reason) ->
     case httpd_util:lookup(ConfigDB, error_log_format, pretty) of
 	pretty ->
-	   io_lib:format("[~s] access to ~s failed for ~s reason: ~n~p~n",
+	   io_lib:format("[~s] access to ~s failed for ~s, reason: ~n~p~n",
 			 [Date, URI, RemoteHost, Reason]);
 	compact ->
 	   io_lib:format( "[~s] access to ~s failed for ~s, reason: ~w~n", 
diff --git a/lib/inets/src/http_server/httpd_request_handler.erl b/lib/inets/src/http_server/httpd_request_handler.erl
index a9db6e2058..c3b47ce390 100644
--- a/lib/inets/src/http_server/httpd_request_handler.erl
+++ b/lib/inets/src/http_server/httpd_request_handler.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2010. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -240,13 +240,13 @@ handle_info({ssl_error, _, _} = Reason, State) ->
 
 %% Timeouts
 handle_info(timeout, #state{mod = ModData, mfa = {_, parse, _}} = State) ->
-    error_log("No request received on keep-alive connection" 
+    error_log("No request received on keep-alive connection "
 	      "before server side timeout", ModData),
     %% No response should be sent!
     {stop, normal, State#state{response_sent = true}}; 
 handle_info(timeout, #state{mod = ModData} = State) ->
     httpd_response:send_status(ModData, 408, "Request timeout"),
-    error_log("The client did not send the whole request before the"
+    error_log("The client did not send the whole request before the "
 	      "server side timeout", ModData),
     {stop, normal, State#state{response_sent = true}};
 
diff --git a/lib/inets/src/http_server/httpd_sup.erl b/lib/inets/src/http_server/httpd_sup.erl
index f94e5459c1..d028a19bf0 100644
--- a/lib/inets/src/http_server/httpd_sup.erl
+++ b/lib/inets/src/http_server/httpd_sup.erl
@@ -90,7 +90,7 @@ id(Address, Port) ->
 %%%  Supervisor callback
 %%%=========================================================================
 init([HttpdServices]) ->
-    ?hdrd("starting", []),
+    ?hdrd("starting", [{httpd_service, HttpdServices}]),
     RestartStrategy = one_for_one,
     MaxR = 10,
     MaxT = 3600,
@@ -182,24 +182,32 @@ httpd_child_spec(ConfigFile, AcceptTimeout, Debug) ->
 	    Error
     end.
 
-httpd_child_spec(Config, AcceptTimeout, Debug, Addr, 0) ->
-	case start_listen(Addr, 0, Config) of
-	    {Pid, {NewPort, NewConfig, ListenSocket}} ->
-		Name      = {httpd_instance_sup, Addr, NewPort},
-		StartFunc = {httpd_instance_sup, start_link,
-			     [NewConfig, AcceptTimeout, 
-			      {Pid, ListenSocket}, Debug]},
-		Restart   = permanent, 
-		Shutdown  = infinity,
-		Modules   = [httpd_instance_sup],
-		Type      = supervisor,
-		{Name, StartFunc, Restart, Shutdown, Type, Modules};
-	    {Pid, {error, Reason}}  ->
-		exit(Pid, normal),
-		{error, Reason}
-	end;
-		    
 httpd_child_spec(Config, AcceptTimeout, Debug, Addr, Port) ->
+    case Port == 0 orelse proplists:is_defined(fd, Config) of
+	true ->
+	    httpd_child_spec_listen(Config, AcceptTimeout, Debug, Addr, Port);
+	false ->
+	    httpd_child_spec_nolisten(Config, AcceptTimeout, Debug, Addr, Port)
+    end.
+
+httpd_child_spec_listen(Config, AcceptTimeout, Debug, Addr, Port) ->
+    case start_listen(Addr, Port, Config) of
+	{Pid, {NewPort, NewConfig, ListenSocket}} ->
+	    Name      = {httpd_instance_sup, Addr, NewPort},
+	    StartFunc = {httpd_instance_sup, start_link,
+			 [NewConfig, AcceptTimeout, 
+			  {Pid, ListenSocket}, Debug]},
+	    Restart   = permanent, 
+	    Shutdown  = infinity,
+	    Modules   = [httpd_instance_sup],
+	    Type      = supervisor,
+	    {Name, StartFunc, Restart, Shutdown, Type, Modules};
+	{Pid, {error, Reason}}  ->
+	    exit(Pid, normal),
+	    {error, Reason}
+    end.
+		    
+httpd_child_spec_nolisten(Config, AcceptTimeout, Debug, Addr, Port) ->
     Name = {httpd_instance_sup, Addr, Port},
     StartFunc = {httpd_instance_sup, start_link,
 		 [Config, AcceptTimeout, Debug]},
@@ -224,7 +232,8 @@ listen(Address, Port, Config)  ->
     SocketType = proplists:get_value(socket_type, Config, ip_comm), 
     case http_transport:start(SocketType) of
 	ok ->
-	    case http_transport:listen(SocketType, Address, Port) of
+	    Fd = proplists:get_value(fd, Config), 
+	    case http_transport:listen(SocketType, Address, Port, Fd) of
 		{ok, ListenSocket} ->
 		    NewConfig = proplists:delete(port, Config),
 		    {ok, NewPort} = inet:port(ListenSocket),
diff --git a/lib/inets/src/http_server/httpd_util.erl b/lib/inets/src/http_server/httpd_util.erl
index 789f12652b..c1aff65d5e 100644
--- a/lib/inets/src/http_server/httpd_util.erl
+++ b/lib/inets/src/http_server/httpd_util.erl
@@ -181,7 +181,7 @@ message(304, _URL,_) ->
 message(400,none,_) ->
     "Your browser sent a query that this server could not understand.";
 message(400,Msg,_) ->
-    "Your browser sent a query that this server could not understand. "++ maybe_encode(Msg);
+    "Your browser sent a query that this server could not understand. "++ http_util:html_encode(Msg);
 message(401,none,_) ->
     "This server could not verify that you
 are authorized to access the document you
@@ -190,48 +190,48 @@ credentials (e.g., bad password), or your
 browser doesn't understand how to supply
 the credentials required.";
 message(403,RequestURI,_) ->
-    "You don't have permission to access "++ maybe_encode(RequestURI) ++" on this server.";
+    "You don't have permission to access "++ http_util:html_encode(RequestURI) ++" on this server.";
 message(404,RequestURI,_) ->
-    "The requested URL " ++ maybe_encode(RequestURI) ++ " was not found on this server.";
+    "The requested URL " ++ http_util:html_encode(RequestURI) ++ " was not found on this server.";
 message(408, Timeout, _) ->
     Timeout;
 message(412,none,_) ->
-    "The requested preconditions where false";
+    "The requested preconditions were false";
 message(413, Reason,_) ->
-    "Entity: " ++ Reason;
+    "Entity: " ++ http_util:html_encode(Reason);
 message(414,ReasonPhrase,_) ->
-    "Message "++ ReasonPhrase ++".";
+    "Message "++ http_util:html_encode(ReasonPhrase) ++".";
 message(416,ReasonPhrase,_) ->
-    ReasonPhrase;
+    http_util:html_encode(ReasonPhrase);
 
 message(500,_,ConfigDB) ->
     ServerAdmin=lookup(ConfigDB,server_admin,"unknown@unknown"),
     "The server encountered an internal error or "
 	"misconfiguration and was unable to complete "
 	"your request.<P>Please contact the server administrator "
-	++ ServerAdmin ++ ", and inform them of the time the error occurred "
+	++ http_util:html_encode(ServerAdmin) ++ ", and inform them of the time the error occurred "
 	"and anything you might have done that may have caused the error.";
 
 message(501,{Method, RequestURI, HTTPVersion}, _ConfigDB) ->
     if
 	is_atom(Method) ->
-	    atom_to_list(Method)++
-		" to "++ maybe_encode(RequestURI)++" ("++HTTPVersion++") not supported.";
+        http_util:html_encode(atom_to_list(Method))++
+		" to "++ http_util:html_encode(RequestURI)++" ("++ http_util:html_encode(HTTPVersion)++") not supported.";
 	is_list(Method) ->
-	    Method++
-		" to "++ maybe_encode(RequestURI)++" ("++HTTPVersion++") not supported."
+	    http_util:html_encode(Method)++
+		" to "++ http_util:html_encode(RequestURI)++" ("++ http_util:html_encode(HTTPVersion)++") not supported."
     end;
 
 message(503, String, _ConfigDB) ->
-    "This service in unavailable due to: "++String.
+    "This service in unavailable due to: "++ http_util:html_encode(String).
 
 maybe_encode(URI) ->
-    case lists:member($%, URI) of
-	true ->
-	    URI;
-	false ->
-	    http_uri:encode(URI)
-    end.
+    Decoded = try http_uri:decode(URI) of
+	N -> N
+    catch
+	error:_ -> URI
+    end,
+    http_uri:encode(Decoded).
 
 %%convert_rfc_date(Date)->{{YYYY,MM,DD},{HH,MIN,SEC}}
 
diff --git a/lib/inets/src/http_server/mod_esi.erl b/lib/inets/src/http_server/mod_esi.erl
index 929185a67a..e36c33b282 100644
--- a/lib/inets/src/http_server/mod_esi.erl
+++ b/lib/inets/src/http_server/mod_esi.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2010. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -415,7 +415,7 @@ deliver_webpage_chunk(#mod{config_db = Db} = ModData, Pid, Timeout) ->
 	    end;
 	timeout ->
 	    ?hdrv("deliver_webpage_chunk - timeout", []),
-	    send_headers(ModData, {504, "Timeout"},[{"connection", "close"}]),
+	    send_headers(ModData, 504, [{"connection", "close"}]),
 	    httpd_socket:close(ModData#mod.socket_type, ModData#mod.socket),
 	    process_flag(trap_exit,false),
 	    {proceed,[{response, {already_sent, 200, 0}} | ModData#mod.data]}
@@ -452,6 +452,10 @@ handle_body(Pid, ModData, Body, Timeout, Size, IsDisableChunkedSend) ->
     ?hdrt("handle_body - send chunk", [{timeout, Timeout}, {size, Size}]),
     httpd_response:send_chunk(ModData, Body, IsDisableChunkedSend),
     receive 
+	{esi_data, Data} when is_binary(Data) ->
+	    ?hdrt("handle_body - received binary data (esi)", []),
+	    handle_body(Pid, ModData, Data, Timeout, Size + byte_size(Data),
+			IsDisableChunkedSend);
 	{esi_data, Data} ->
 	    ?hdrt("handle_body - received data (esi)", []),
 	    handle_body(Pid, ModData, Data, Timeout, Size + length(Data),
diff --git a/lib/inets/src/inets_app/inets.appup.src b/lib/inets/src/inets_app/inets.appup.src
index 07da8ca961..47f3fbba58 100644
--- a/lib/inets/src/inets_app/inets.appup.src
+++ b/lib/inets/src/inets_app/inets.appup.src
@@ -18,9 +18,14 @@
 
 {"%VSN%",
  [
+  {"5.5.2", 
+   [
+    {restart_application, inets}
+   ]
+  }, 
   {"5.5.1", 
    [
-    {load_module, http_chunk, soft_purge, soft_purge, []}
+    {restart_application, inets}
    ]
   }, 
   {"5.5",
@@ -34,10 +39,15 @@
    ]
   } 
  ],
- [	
+ [
+  {"5.5.2",
+   [
+    {restart_application, inets}
+   ]
+  },
   {"5.5.1", 
    [
-    {load_module, http_chunk, soft_purge, soft_purge, []}
+    {restart_application, inets}
    ]
   }, 
   {"5.5",