Merge branch 'dev' of super:otp into dev

* 'dev' of super:otp: (166 commits)
  Corrected documentation error and added examples to Users Guide
  In TLS 1.1, failure to properly close a connection no longer requires that a session not be resumed.  This is a change from TLS 1.0 to conform with widespread implementation practice.  Erlang ssl will now in TLS 1.0 conform to the widespread implementation practice instead of the specification to avoid performance issues.
  Add escript to bootstrap/bin
  Remove unused variable warning in inet_res
  Remove unused variable in epmd_port
  Remove compiler warnings in inet_drv
  Add SASL test suite
  Allow same module name in multiple applications if explicitely excluded
  Fix bugs concerning the option report_missing_types
  Fix default encoding in SAX parser.
  re: remove gratuitous "it " in manpage
  Spelling in (backward *compatibility*) comment.
  Improve erl_docgen's support for Dialyzer specs and types
  dialyzer warning on mnesia_tm
  Add documentation text about majority checking
  add mnesia_majority_test suite
  where_to_wlock optimization + change_table_majority/2
  bug in mnesia_tm:needs_majority/2
  optimize sticky_lock maj. check
  check majority for sticky locks
  ...

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",