Merge branch 'bmk/snmp/handling_corrupt_atl_when_converting/r16/OTP-11453' into bmk/snmp/snmp425_integration

Conflicts:
	lib/snmp/src/misc/snmp_log.erl

1 files changed, 47 insertions, 81 deletions

diff --git a/lib/inets/src/http_client/httpc_manager.erl b/lib/inets/src/http_client/httpc_manager.erl
index c45dcab802..a3ed371e61 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-2012. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2013. 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,6 @@
 	 start_link/3, 
 	 request/2, 
 	 cancel_request/2,
-	 request_canceled/3,
 	 request_done/2, 
 	 retry_request/2, 
 	 redirect_request/2,
@@ -144,22 +143,7 @@ redirect_request(Request, ProfileName) ->
 %%--------------------------------------------------------------------
 
 cancel_request(RequestId, ProfileName) ->
-    call(ProfileName, {cancel_request, RequestId}).
-
-
-%%--------------------------------------------------------------------
-%% Function: request_canceled(RequestId, ProfileName) -> ok
-%%	RequestId - ref()
-%%      ProfileName = atom()
-%%
-%% Description: Confirms that a request has been canceld. Intended to
-%% be called by the httpc handler process.
-%%--------------------------------------------------------------------
-
-request_canceled(RequestId, ProfileName, From) ->
-    gen_server:reply(From, ok),
-    cast(ProfileName, {request_canceled, RequestId}).
-
+    cast(ProfileName, {cancel_request, RequestId}).
 
 %%--------------------------------------------------------------------
 %% Function: request_done(RequestId, ProfileName) -> ok
@@ -467,33 +451,13 @@ do_init(ProfileName, CookiesDir) ->
 %%--------------------------------------------------------------------
 handle_call({request, Request}, _, State) ->
     ?hcri("request", [{request, Request}]),
-    case (catch handle_request(Request, State)) of
+    case (catch handle_request(Request, State, false)) of
 	{reply, Msg, NewState} ->
 	    {reply, Msg, NewState};
 	Error ->
 	    {stop, Error, httpc_response:error(Request, Error), State}
     end;
 
-handle_call({cancel_request, RequestId}, From, 
-	    #state{handler_db = HandlerDb} = State) ->
-    ?hcri("cancel_request", [{request_id, RequestId}]),
-    case ets:lookup(HandlerDb, RequestId) of
-	[] ->
-	    %% 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} | State#state.cancel]}}
-    end;
-
 handle_call(reset_cookies, _, #state{cookie_db = CookieDb} = State) ->
     ?hcrv("reset cookies", []),
     httpc_cookie:reset_db(CookieDb),
@@ -547,7 +511,7 @@ handle_cast({retry_or_redirect_request, {Time, Request}},
     {noreply, State};
 
 handle_cast({retry_or_redirect_request, Request}, State) ->
-    case (catch handle_request(Request, State)) of
+    case (catch handle_request(Request, State, true)) of
 	{reply, {ok, _}, NewState} ->
 	    {noreply, NewState};
 	Error  ->
@@ -555,19 +519,19 @@ handle_cast({retry_or_redirect_request, Request}, State) ->
 	    {stop, Error, State}
     end;
 
-handle_cast({request_canceled, RequestId}, State) ->
-    ?hcrv("request canceled", [{request_id, RequestId}]),
-    ets:delete(State#state.handler_db, RequestId),
-    case lists:keysearch(RequestId, 1, State#state.cancel) of
-	{value, Entry = {RequestId, _, From}} ->
-	    ?hcrt("found in cancel", [{from, From}]),
-	    {noreply, 
-	     State#state{cancel = lists:delete(Entry, State#state.cancel)}};
-	Else ->
-	    ?hcrt("not found in cancel", [{else, Else}]),
-	   {noreply, State}
+handle_cast({cancel_request, RequestId}, 
+	    #state{handler_db = HandlerDb} = State) ->
+    case ets:lookup(HandlerDb, RequestId) of
+	[] ->
+	    %% Request already compleated nothing to 
+	    %% cancel
+	    {noreply, State};
+	[{_, Pid, _}] ->
+	    httpc_handler:cancel(RequestId, Pid),
+	    ets:delete(State#state.handler_db, RequestId),
+	    {noreply, State}
     end;
-
+  
 handle_cast({request_done, RequestId}, State) ->
     ?hcrv("request done", [{request_id, RequestId}]),
     ets:delete(State#state.handler_db, RequestId),
@@ -629,22 +593,8 @@ handle_info({'EXIT', _, _}, State) ->
     %% Handled in DOWN
     {noreply, State};
 handle_info({'DOWN', _, _, Pid, _}, State) ->
-    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!
-    NewCanceldList =
-	lists:foldl(fun(Entry = {_, HandlerPid, From}, Acc)  ->
-			    case HandlerPid of
-				Pid ->
-				    gen_server:reply(From, ok),
-				    lists:delete(Entry, Acc);
-				_ ->
-				    Acc
-			    end 
-		    end, State#state.cancel, State#state.cancel),
-    {noreply, State#state{cancel = NewCanceldList}};
+    ets:match_delete(State#state.handler_db, {'_', Pid, '_'}),  
+    {noreply, State};
 handle_info(Info, State) ->
     Report = io_lib:format("Unknown message in "
 			   "httpc_manager:handle_info ~p~n", [Info]),
@@ -774,7 +724,7 @@ get_handler_info(Tab) ->
 
 handle_request(#request{settings = 
 			#http_options{version = "HTTP/0.9"}} = Request,
-	       State) ->
+	       State, _) ->
     %% Act as an HTTP/0.9 client that does not know anything
     %% about persistent connections
 
@@ -787,7 +737,7 @@ handle_request(#request{settings =
 
 handle_request(#request{settings = 
 			#http_options{version = "HTTP/1.0"}} = Request,
-	       State) ->
+	       State, _) ->
     %% Act as an HTTP/1.0 client that does not
     %% use persistent connections
 
@@ -798,13 +748,13 @@ handle_request(#request{settings =
     start_handler(NewRequest#request{headers = NewHeaders}, State),
     {reply, {ok, NewRequest#request.id}, State};
 
-handle_request(Request, State = #state{options = Options}) ->
+handle_request(Request, State = #state{options = Options}, Retry) ->
 
     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
+			Request#request.scheme, SessionType, State, Retry) of
 	{ok, HandlerPid} ->
 	    pipeline_or_keep_alive(NewRequest, HandlerPid, State);
 	no_connection ->
@@ -828,6 +778,7 @@ start_handler(#request{id   = Id,
 	      #state{profile_name = ProfileName, 
 		     handler_db   = HandlerDb, 
 		     options      = Options}) ->
+    ClientClose = httpc_request:is_client_closing(Request#request.headers),
     {ok, Pid} =
 	case is_inets_manager() of
 	    true ->
@@ -838,13 +789,18 @@ start_handler(#request{id   = Id,
 	end,
     HandlerInfo = {Id, Pid, From}, 
     ets:insert(HandlerDb, HandlerInfo), 
+    insert_session(#session{id = {Request#request.address, Pid},
+			    scheme = Request#request.scheme,
+			    client_close = ClientClose,
+			    type = session_type(Options)
+			   }, ProfileName),
     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}) ->
+		      session_db = SessionDb}, Retry) ->
     ?hcrd("select session", [{session_type,          SessionType},
 			     {max_pipeline_length,   MaxPipe},
 			     {max_keep_alive_length, MaxKeepAlive}]),
@@ -857,19 +813,29 @@ select_session(Method, HostPort, Scheme, SessionType,
 	    %% client_close, scheme and type specified. 
 	    %% The fields id (part of: HandlerPid) and queue_length
 	    %% specified.
-	    Pattern = #session{id           = {HostPort, '$1'},
-			       client_close = false,
-			       scheme       = Scheme,
-			       queue_length = '$2',
-			       type         = SessionType,
-			       available    = true, 
-			       _            = '_'},
+	    Pattern = case (Retry andalso SessionType == pipeline) of
+			  true ->
+			      #session{id           = {HostPort, '$1'},
+				       client_close = false,
+				       scheme       = Scheme,
+				       queue_length = '$2',
+				       type         = SessionType,
+				       persistent   = true,
+				       _            = '_'};
+			  false ->
+			      #session{id           = {HostPort, '$1'},
+				       client_close = false,
+				       scheme       = Scheme,
+				       queue_length = '$2',
+				       type         = SessionType,
+				       _            = '_'}
+		      end,
 	    %% {'_', {HostPort, '$1'}, false, Scheme, '_', '$2', SessionTyp}, 
 	    Candidates = ets:match(SessionDb, Pattern), 
 	    ?hcrd("select session", [{host_port,  HostPort}, 
 				     {scheme,     Scheme}, 
 				     {type,       SessionType}, 
-				     {candidates, Candidates}]),
+				     {candidates, Candidates}]),	    
 	    select_session(Candidates, MaxKeepAlive, MaxPipe, SessionType);
 	false ->
 	    no_connection