Merge branch 'maint'

* maint:
  Bumped version nr
  ssl & public_key: Workaround that some certificates encode countryname as utf8 and close down gracefully if other ASN-1 errors occur.
  Add more cross reference links to ct docs
  Remove config option from common_test args
  Update user config to use nested tuple keys
  Allow mixed IPv4 and IPv6 addresses to sctp_bindx
  Add checks for in6addr_any and in6addr_loopback
  Fix SCTP multihoming
  observer: fix app file (Noticed-by: Motiejus Jakstys)
  Fix lib/src/test/ssh_basic_SUITE.erl to fix IPv6 option typos
  Prevent index from being corrupted if a nonexistent item is deleted
  Add tests showing that trying to delete non-existing object may corrupt the table index
  Fix Table Viewer search crash on new|changed|deleted rows
  Escape control characters in Table Viewer
  Fix Table Viewer crash after a 'Found' -> 'Not found' search sequence
  inet_drv.c: Set sockaddr lengths in inet_set_[f]address

Conflicts:
	erts/preloaded/ebin/prim_inet.beam

1 files changed, 129 insertions, 121 deletions

diff --git a/lib/common_test/src/ct_config.erl b/lib/common_test/src/ct_config.erl
index c585fe0995..463b7d180c 100644
--- a/lib/common_test/src/ct_config.erl
+++ b/lib/common_test/src/ct_config.erl
@@ -122,8 +122,8 @@ return({To,Ref},Result) ->
 
 loop(StartDir) ->
     receive
-	{{require,Name,Tag,SubTags},From} ->
-	    Result = do_require(Name,Tag,SubTags),
+	{{require,Name,Key},From} ->
+	    Result = do_require(Name,Key),
 	    return(From,Result),
 	    loop(StartDir);
 	{{set_default_config,{Config,Scope}},From} ->
@@ -168,16 +168,19 @@ reload_config(KeyOrName) ->
     call({reload_config, KeyOrName}).
 
 process_default_configs(Opts) ->
-    case lists:keysearch(config, 1, Opts) of
-	{value,{_,Files=[File|_]}} when is_list(File) ->
-	    Files;
-	{value,{_,File=[C|_]}} when is_integer(C) ->
-	    [File];
-	{value,{_,[]}} ->
-	    [];
-	false ->
-	    []
-    end.
+    lists:flatmap(fun({config,[_|_] = FileOrFiles}) ->
+			  case {io_lib:printable_list(FileOrFiles),
+				io_lib:printable_list(hd(FileOrFiles))} of
+			      {true,true} ->
+				  FileOrFiles;
+			      {true,false} ->
+				  [FileOrFiles];
+			      _ ->
+				  []
+			  end;
+		     (_) ->
+			  []
+		  end,Opts).
 
 process_user_configs(Opts, Acc) ->
     case lists:keytake(userconfig, 1, Opts) of
@@ -319,75 +322,58 @@ get_config(KeyOrName,Default) ->
     get_config(KeyOrName,Default,[]).
 
 get_config(KeyOrName,Default,Opts) when is_atom(KeyOrName) ->
-    case lookup_config(KeyOrName) of
-	[] ->
-	    Default;
-	[{_Ref,Val}|_] = Vals ->
-	    case {lists:member(all,Opts),lists:member(element,Opts)} of
-		{true,true} ->
-		    [{KeyOrName,V} || {_R,V} <- lists:sort(Vals)];
-		{true,false} ->
-		    [V || {_R,V} <- lists:sort(Vals)];
-		{false,true} ->
-		    {KeyOrName,Val};
-		{false,false} ->
-		    Val
-	    end
+    case get_config({KeyOrName}, Default, Opts) of
+	%% If only an atom is given, then we need to unwrap the
+	%% key if it is returned
+	{{KeyOrName}, Val} ->
+	    {KeyOrName, Val};
+	[{{KeyOrName}, _Val}|_] = Res ->
+	    [{K, Val} || {{K},Val} <- Res, K == KeyOrName];
+	Else ->
+	    Else
     end;
 
-get_config({KeyOrName,SubKey},Default,Opts) ->
-    case lookup_config(KeyOrName) of
+%% This useage of get_config is only used by internal ct functions
+%% and may change at any time
+get_config({DeepKey,SubKey}, Default, Opts) when is_tuple(DeepKey) ->
+    get_config(erlang:append_element(DeepKey, SubKey), Default, Opts);
+get_config(KeyOrName,Default,Opts) when is_tuple(KeyOrName) ->
+    case lookup_config(element(1,KeyOrName)) of
 	[] ->
-	    Default;
+	    format_value([Default],KeyOrName,Opts);
 	Vals ->
-	    Vals1 = case [Val || {_Ref,Val} <- lists:sort(Vals)] of
-			Result=[L|_] when is_list(L) ->
-			    case L of
-				[{_,_}|_] ->
-				    Result;
-				_ ->
-				    []
-			    end;
-			_ ->
-			    []
-		    end,
-	    case get_subconfig([SubKey],Vals1,[],Opts) of
-		{ok,[{_,SubVal}|_]=SubVals} ->
-		    case {lists:member(all,Opts),lists:member(element,Opts)} of
-			{true,true} ->
-			    [{{KeyOrName,SubKey},Val} || {_,Val} <- SubVals];
-			{true,false} ->
-			    [Val || {_SubKey,Val} <- SubVals];
-			{false,true} ->
-			    {{KeyOrName,SubKey},SubVal};
-			{false,false} ->
-			    SubVal
-		    end;
-		_ ->
-		    Default
-	    end
+	    NewVals =
+		lists:map(
+		  fun({Val}) ->
+			  get_config(tl(tuple_to_list(KeyOrName)),
+				     Val,Default,Opts)
+		  end,Vals),
+	    format_value(NewVals,KeyOrName,Opts)
     end.
 
-get_subconfig(SubKeys,Values) ->
-    get_subconfig(SubKeys,Values,[],[]).
-
-get_subconfig(SubKeys,[Value|Rest],Mapped,Opts) ->
-    case do_get_config(SubKeys,Value,[]) of
-	{ok,SubMapped} ->
-	    case lists:member(all,Opts) of
-		true ->
-		    get_subconfig(SubKeys,Rest,Mapped++SubMapped,Opts);
-		false ->
-		    {ok,SubMapped}
-	    end;
-	_Error ->
-	    get_subconfig(SubKeys,Rest,Mapped,Opts)
+get_config([],Vals,_Default,_Opts) ->
+    Vals;
+get_config([[]],Vals,Default,Opts) ->
+    get_config([],Vals,Default,Opts);
+%% This case is used by {require,{unix,[port,host]}} functionality
+get_config([SubKeys], Vals, Default, _Opts) when is_list(SubKeys) ->
+    case do_get_config(SubKeys, Vals, []) of
+	{ok, SubVals} ->
+	    [SubVal || {_,SubVal} <- SubVals];
+
+	_ ->
+	    Default
     end;
-get_subconfig(SubKeys,[],[],_) ->
-    {error,{not_available,SubKeys}};
-get_subconfig(_SubKeys,[],Mapped,_) ->
-    {ok,Mapped}.
+get_config([Key|Rest], Vals, Default, Opts) ->
+    case do_get_config([Key], Vals, []) of
+	{ok, [{Key,NewVals}]} ->
+	    get_config(Rest, NewVals, Default, Opts);
+	_ ->
+	    Default
+    end.
 
+do_get_config([Key|_], Available, _Mapped) when not is_list(Available) ->
+    {error,{not_available,Key}};
 do_get_config([Key|Required],Available,Mapped) ->
     case lists:keysearch(Key,1,Available) of
 	{value,{Key,Value}} ->
@@ -403,8 +389,7 @@ do_get_config([],_Available,Mapped) ->
 get_all_config() ->
     ets:select(?attr_table,[{#ct_conf{name='$1',key='$2',value='$3',
 				      default='$4',_='_'},
-			     [],
-			     [{{'$1','$2','$3','$4'}}]}]).
+			     [],[{{'$1','$2','$3','$4'}}]}]).
 
 lookup_config(KeyOrName) ->
     case lookup_name(KeyOrName) of
@@ -415,13 +400,23 @@ lookup_config(KeyOrName) ->
     end.
 
 lookup_name(Name) ->
-    ets:select(?attr_table,[{#ct_conf{ref='$1',value='$2',name=Name,_='_'},
-			     [],
-			     [{{'$1','$2'}}]}]).
+    ets:select(?attr_table,[{#ct_conf{value='$1',name=Name,_='_'},
+			     [],[{{'$1'}}]}]).
 lookup_key(Key) ->
-    ets:select(?attr_table,[{#ct_conf{key=Key,ref='$1',value='$2',name='_UNDEF',_='_'},
-			     [],
-			     [{{'$1','$2'}}]}]).
+    ets:select(?attr_table,[{#ct_conf{key=Key,value='$1',name='_UNDEF',_='_'},
+			     [],[{{'$1'}}]}]).
+
+format_value([SubVal|_] = SubVals, KeyOrName, Opts) ->
+    case {lists:member(all,Opts),lists:member(element,Opts)} of
+	{true,true} ->
+	    [{KeyOrName,Val} || Val <- SubVals];
+	{true,false} ->
+	    [Val || Val <- SubVals];
+	{false,true} ->
+	    {KeyOrName,SubVal};
+	{false,false} ->
+	    SubVal
+    end.
 
 lookup_handler_for_config({Key, _Subkey}) ->
     lookup_handler_for_config(Key);
@@ -475,65 +470,78 @@ release_allocated([H|T]) ->
 release_allocated([]) ->
     ok.
 
-allocate(Name,Key,SubKeys) ->
-    case ets:match_object(?attr_table,#ct_conf{key=Key,name='_UNDEF',_='_'}) of
-	[] ->
+allocate(Name,Key) ->
+    Ref = make_ref(),
+    case get_config(Key,Ref,[all,element]) of
+	[{_,Ref}] ->
 	    {error,{not_available,Key}};
-	Available ->
-	    case allocate_subconfig(Name,SubKeys,Available,false) of
-		ok ->
-		    ok;
-		Error ->
-		    Error
-	    end
+	Configs ->
+	    associate(Name,Key,Configs),
+	    ok
     end.
 
-allocate_subconfig(Name,SubKeys,[C=#ct_conf{value=Value}|Rest],Found) ->
-    case do_get_config(SubKeys,Value,[]) of
-	{ok,_SubMapped} ->
-	    ets:insert(?attr_table,C#ct_conf{name=Name}),
-	    allocate_subconfig(Name,SubKeys,Rest,true);
-	_Error ->
-	    allocate_subconfig(Name,SubKeys,Rest,Found)
-    end;
-allocate_subconfig(_Name,_SubKeys,[],true) ->
+
+associate('_UNDEF',_Key,_Configs) ->
     ok;
-allocate_subconfig(_Name,SubKeys,[],false) ->
-    {error,{not_available,SubKeys}}.
+associate(Name,{Key,SubKeys},Configs) when is_atom(Key), is_list(SubKeys) ->
+    associate_int(Name,Configs,"true");
+associate(Name,_Key,Configs) ->
+    associate_int(Name,Configs,os:getenv("COMMON_TEST_ALIAS_TOP")).
+
+associate_int(Name,Configs,"true") ->
+    lists:map(fun({K,_Config}) ->
+		      Cs = ets:match_object(
+			     ?attr_table,
+			     #ct_conf{key=element(1,K),
+				      name='_UNDEF',_='_'}),
+		      [ets:insert(?attr_table,C#ct_conf{name=Name})
+		       || C <- Cs]
+	      end,Configs);
+associate_int(Name,Configs,_) ->
+    lists:map(fun({K,Config}) ->
+		      Key = if is_tuple(K) -> element(1,K);
+			       is_atom(K) -> K
+			    end,
+
+		      Cs = ets:match_object(
+			     ?attr_table,
+			     #ct_conf{key=Key,
+				      name='_UNDEF',_='_'}),
+		      [ets:insert(?attr_table,C#ct_conf{name=Name,
+							value=Config})
+		       || C <- Cs]
+	      end,Configs).
+
+
 
 delete_config(Default) ->
     ets:match_delete(?attr_table,#ct_conf{default=Default,_='_'}),
     ok.
 
-require(Key) when is_atom(Key) ->
-    require({Key,[]});
-require({Key,SubKeys}) when is_atom(Key) ->
-    allocate('_UNDEF',Key,to_list(SubKeys));
+require(Key) when is_atom(Key); is_tuple(Key) ->
+    allocate('_UNDEF',Key);
 require(Key) ->
     {error,{invalid,Key}}.
 
-require(Name,Key) when is_atom(Key) ->
-    require(Name,{Key,[]});
-require(Name,{Key,SubKeys}) when is_atom(Name), is_atom(Key) ->
-    call({require,Name,Key,to_list(SubKeys)});
+require(Name,Key) when is_atom(Name),is_atom(Key) orelse is_tuple(Key) ->
+    call({require,Name,Key});
 require(Name,Keys) ->
     {error,{invalid,{Name,Keys}}}.
 
-to_list(X) when is_list(X) -> X;
-to_list(X) -> [X].
-
-do_require(Name,Key,SubKeys) when is_list(SubKeys) ->
+do_require(Name,Key) ->
     case get_key_from_name(Name) of
 	{error,_} ->
-	    allocate(Name,Key,SubKeys);
+	    allocate(Name,Key);
 	{ok,Key} ->
 	    %% already allocated - check that it has all required subkeys
-	    Vals = [Val || {_Ref,Val} <- lookup_name(Name)],
-	    case get_subconfig(SubKeys,Vals) of
-		{ok,_SubMapped} ->
-		    ok;
-		Error ->
-		    Error
+	    R = make_ref(),
+	    case get_config(Key,R,[]) of
+		R ->
+		    {error,{not_available,Key}};
+		{error,_} = Error ->
+		    Error;
+		_Error ->
+		    ok
 	    end;
 	{ok,OtherKey} ->
 	    {error,{name_in_use,Name,OtherKey}}