Updated chat/ejabberd to 2.0.2 (patch received from Fabrice Colliot)

* Bug fixes

* Patch #389 (https://support.process-one.net/browse/EJAB-389) applied
  instead of the old pkgsrc patch. You MUST modify your ejabberd.cfg!


(martti)

$NetBSD: patch-af,v 1.1 2008/11/12 13:13:59 martti Exp $

Modified to use IPv6/v4 patch (https://support.process-one.net/browse/EJAB-389)

--- src/ejabberd_config.erl.orig	2008-08-27 12:37:52.000000000 +0300
+++ src/ejabberd_config.erl
@@ -140,8 +140,16 @@ process_term(Term, State) ->
 	{host_config, Host, Terms} ->
 	    lists:foldl(fun(T, S) -> process_host_term(T, Host, S) end,
 			State, Terms);
-	{listen, Val} ->
-	    add_option(listen, Val, State);
+	{listen, Listeners} ->
+	    Listeners2 =
+		lists:map(
+		  fun({PortIP, Module, Opts}) ->
+			  {Port, IPT, _, _, OptsClean} =
+			      ejabberd_listener:parse_listener_portip(PortIP, Opts),
+			  {{Port, IPT}, Module, OptsClean}
+		  end,
+		  Listeners),
+	    add_option(listen, Listeners2, State);
 	{language, Val} ->
 	    add_option(language, Val, State);
 	{outgoing_s2s_port, Port} ->

$NetBSD: patch-ag,v 1.1 2008/11/12 13:13:59 martti Exp $

Modified to use IPv6/v4 patch (https://support.process-one.net/browse/EJAB-389)

--- src/ejabberd_listener.erl.orig	2008-08-27 12:37:52.000000000 +0300
+++ src/ejabberd_listener.erl
@@ -32,6 +32,7 @@
 	 init_ssl/4,
 	 start_listener/3,
 	 stop_listener/1,
+	 parse_listener_portip/2,
 	 add_listener/3,
 	 delete_listener/1
 	]).
@@ -47,8 +48,7 @@ init(_) ->
 	undefined ->
 	    ignore;
 	Ls ->
-	    {ok, {{one_for_one, 10, 1},
-		  lists:map(
+	    Ls2 = lists:map(
 		    fun({Port, Module, Opts}) ->
 			    {Port,
 			     {?MODULE, start, [Port, Module, Opts]},
@@ -56,7 +56,20 @@ init(_) ->
 			     brutal_kill,
 			     worker,
 			     [?MODULE]}
-		    end, Ls)}}
+		    end, Ls),
+	    report_duplicated_portips(Ls),
+	    {ok, {{one_for_one, 10, 1}, Ls2}}
+    end.
+
+report_duplicated_portips(L) ->
+    LKeys = [Port || {Port, _, _} <- L],
+    LNoDupsKeys = proplists:get_keys(L),
+    case LKeys -- LNoDupsKeys of
+	[] -> ok;
+	Dups ->
+	    ?CRITICAL_MSG("In the ejabberd configuration there are duplicated "
+			  "Port number + IP address:~n  ~p",
+			  [Dups])
     end.
 
 
@@ -81,13 +94,16 @@ start(Port, Module, Opts) ->
 	    end
     end.
 
-init(Port, Module, Opts) ->
+init(PortIP, Module, Opts1) ->
+    {Port, IPT, IPS, IPV, OptsClean} = parse_listener_portip(PortIP, Opts1),
+    %% The first inet|inet6 and the last {ip, _} work,
+    %% so overriding those in Opts
+    Opts = [IPV | OptsClean] ++ [{ip, IPT}],
     SockOpts = lists:filter(fun({ip, _}) -> true;
 			       (inet6) -> true;
 			       (inet) -> true;
 			       (_) -> false
 			    end, Opts),
-
     Res = gen_tcp:listen(Port, [binary,
 				{packet, 0}, 
 				{active, false},
@@ -99,11 +115,77 @@ init(Port, Module, Opts) ->
 	{ok, ListenSocket} ->
 	    accept(ListenSocket, Module, Opts);
 	{error, Reason} ->
-	    ?ERROR_MSG("Failed to open socket for ~p: ~p",
-		       [{Port, Module, Opts}, Reason]),
-	    error
+	    ReasonT = case Reason of
+			  eaddrnotavail -> "IP address not available: " ++ IPS;
+			  _ -> atom_to_list(Reason)
+		      end,
+	    ?ERROR_MSG("Failed to open socket:~n  ~p~nReason: ~s",
+		       [{Port, Module, SockOpts}, ReasonT]),
+	    {error, ReasonT}
+    end.
+
+%% @spec (PortIP, Opts) -> {Port, IPT, IPS, IPV, OptsClean}
+%% where
+%%      PortIP = Port | {Port, IPT | IPS}
+%%      Port = integer()
+%%      IPT = tuple()
+%%      IPS = string()
+%%      IPV = inet | inet6
+%%      Opts = [IPV | {ip, IPT} | atom() | tuple()]
+%%      OptsClean = [atom() | tuple()]
+%% @doc Parse any kind of ejabberd listener specification.
+%% The parsed options are returned in several formats.
+%% OptsClean does not include inet/inet6 or ip options.
+%% Opts can include the options inet6 and {ip, Tuple},
+%% but they are only used when no IP address was specified in the PortIP.
+%% The IP version (either IPv4 or IPv6) is inferred from the IP address type,
+%% so the option inet/inet6 is only used when no IP is specified at all.
+parse_listener_portip(PortIP, Opts) ->
+    {IPOpt, Opts2} = strip_ip_option(Opts),
+    {IPVOpt, OptsClean} = case lists:member(inet6, Opts2) of
+			      true -> {inet6, Opts2 -- [inet6]};
+			      false -> {inet, Opts2}
+			  end,
+    {Port, IPT, IPS} = case PortIP of
+			   P when is_integer(P) ->
+			       T = get_ip_tuple(IPOpt, IPVOpt),
+			       S = inet_parse:ntoa(T),
+			       {P, T, S};
+			   {P, T} when is_integer(P) and is_tuple(T) ->
+			       S = inet_parse:ntoa(T),
+			       {P, T, S};
+			   {P, S} when is_integer(P) and is_list(S) ->
+			       [S | _] = string:tokens(S, "/"),
+			       {ok, T} = inet_parse:address(S),
+			       {P, T, S}
+		       end,
+    IPV = case size(IPT) of
+	      4 -> inet;
+	      8 -> inet6
+	  end,
+    {Port, IPT, IPS, IPV, OptsClean}.
+
+strip_ip_option(Opts) ->
+    {IPL, OptsNoIP} = lists:partition(
+			fun({ip, _}) -> true;
+			   (_) -> false
+			end,
+			Opts),
+    case IPL of
+	%% Only the first ip option is considered
+	[{ip, T1} | _] when is_tuple(T1) ->
+	    {T1, OptsNoIP};
+	[] ->
+	    {no_ip_option, OptsNoIP}
     end.
 
+get_ip_tuple(no_ip_option, inet) ->
+    {0, 0, 0, 0};
+get_ip_tuple(no_ip_option, inet6) ->
+    {0, 0, 0, 0, 0, 0, 0, 0};
+get_ip_tuple(IPOpt, _IPVOpt) ->
+    IPOpt.
+
 accept(ListenSocket, Module, Opts) ->
     case gen_tcp:accept(ListenSocket) of
 	{ok, Socket} ->
@@ -178,6 +260,7 @@ accept_ssl(ListenSocket, Module, Opts) -
     end.
 
 
+%% @spec (Port, Module, Opts) -> {ok, Pid} | {error, Error}
 start_listener(Port, Module, Opts) ->
     ChildSpec = {Port,
 		 {?MODULE, start, [Port, Module, Opts]},
@@ -191,26 +274,49 @@ stop_listener(Port) ->
     supervisor:terminate_child(ejabberd_listeners, Port),
     supervisor:delete_child(ejabberd_listeners, Port).
 
-add_listener(Port, Module, Opts) ->
-    Ports = case ejabberd_config:get_local_option(listen) of
-		undefined ->
-		    [];
-		Ls ->
-		    Ls
-	    end,
-    Ports1 = lists:keydelete(Port, 1, Ports),
-    Ports2 = [{Port, Module, Opts} | Ports1],
-    ejabberd_config:add_local_option(listen, Ports2),
-    start_listener(Port, Module, Opts).
+%% @spec (PortIP, Module, Opts) -> {ok, Pid} | {error, Error}
+%% where
+%%      PortIP = {Port, IPT | IPS}
+%%      Port = integer()
+%%      IPT = tuple()
+%%      IPS = string()
+%%      IPV = inet | inet6
+%%      Module = atom()
+%%      Opts = [IPV | {ip, IPT} | atom() | tuple()]
+%% @doc Add a listener and store in config if success
+add_listener(PortIP, Module, Opts) ->
+    case start_listener(PortIP, Module, Opts) of
+	{ok, _Pid} ->
+	    Ports = case ejabberd_config:get_local_option(listen) of
+			undefined ->
+			    [];
+			Ls ->
+			    Ls
+		    end,
+	    Ports1 = lists:keydelete(PortIP, 1, Ports),
+	    Ports2 = [{PortIP, Module, Opts} | Ports1],
+	    ejabberd_config:add_local_option(listen, Ports2),
+		ok;
+	{error, {already_started, _Pid}} ->
+	    {error, {already_started, PortIP}};
+	{error, Error} ->
+	    {error, Error}
+    end.
 
-delete_listener(Port) ->
+%% @spec (PortIP) -> ok
+%% where
+%%      PortIP = {Port, IPT | IPS}
+%%      Port = integer()
+%%      IPT = tuple()
+%%      IPS = string()
+delete_listener(PortIP) ->
     Ports = case ejabberd_config:get_local_option(listen) of
 		undefined ->
 		    [];
 		Ls ->
 		    Ls
 	    end,
-    Ports1 = lists:keydelete(Port, 1, Ports),
+    Ports1 = lists:keydelete(PortIP, 1, Ports),
     ejabberd_config:add_local_option(listen, Ports1),
-    stop_listener(Port).
+    stop_listener(PortIP).
 

$NetBSD: patch-ah,v 1.1 2008/11/12 13:13:59 martti Exp $

Modified to use IPv6/v4 patch (https://support.process-one.net/browse/EJAB-389)

--- src/mod_proxy65/mod_proxy65_service.erl.orig	2008-08-27 12:37:52.000000000 +0300
+++ src/mod_proxy65/mod_proxy65_service.erl
@@ -52,6 +52,7 @@
 	  name,
 	  stream_addr,
 	  port,
+	  ip,
 	  acl
 	 }).
 
@@ -69,14 +70,14 @@ start_link(Host, Opts) ->
     gen_server:start_link({local, Proc}, ?MODULE, [Host, Opts], []).
 
 init([Host, Opts]) ->
-    {IP, State} = parse_options(Host, Opts),
-    NewOpts = [Host, {ip, IP} | Opts],
-    ejabberd_listener:add_listener(State#state.port, mod_proxy65_stream, NewOpts),
+    State = parse_options(Host, Opts),
+    NewOpts = [Host | Opts],
+    ejabberd_listener:add_listener({State#state.port, State#state.ip}, mod_proxy65_stream, NewOpts),
     ejabberd_router:register_route(State#state.myhost),
     {ok, State}.
 
-terminate(_Reason, #state{myhost=MyHost, port=Port}) ->
-    catch ejabberd_listener:delete_listener(Port),
+terminate(_Reason, #state{myhost=MyHost, port=Port, ip=IP}) ->
+    catch ejabberd_listener:delete_listener({Port, IP}),
     ejabberd_router:unregister_route(MyHost),
     ok.
 
@@ -203,12 +204,13 @@ parse_options(ServerHost, Opts) ->
 	     end,
     StrIP = inet_parse:ntoa(IP),
     StreamAddr = [{"jid", MyHost}, {"host", StrIP}, {"port", integer_to_list(Port)}],
-    {IP, #state{myhost      = MyHost,
+    #state{myhost      = MyHost,
 		serverhost  = ServerHost,
 		name        = Name,
 		port        = Port,
+		ip          = IP,
 		stream_addr = StreamAddr, 
-		acl         = ACL}}.
+		acl         = ACL}.
 
 %% Return the IP of the proxy host, or if not found, the ip of the xmpp domain
 get_proxy_or_domainip(ServerHost, MyHost) ->

$NetBSD: patch-ai,v 1.1 2008/11/12 13:13:59 martti Exp $

Modified to use IPv6/v4 patch (https://support.process-one.net/browse/EJAB-389)

--- src/web/ejabberd_web_admin.erl.orig	2008-08-27 12:37:52.000000000 +0300
+++ src/web/ejabberd_web_admin.erl
@@ -1806,15 +1806,21 @@ get_node(global, Node, ["ports"], Query,
 		  ok;
 	      {'EXIT', _Reason} ->
 		  error;
+	      {is_added, ok} ->
+		  ok;
+	      {is_added, {error, Reason}} ->
+		  {error, io_lib:format("~p", [Reason])};
 	      _ ->
 		  nothing
 	  end,
+    %% TODO: This sorting does not work when [{{Port, IP}, Module, Opts}]
     NewPorts = lists:sort(
 		 rpc:call(Node, ejabberd_config, get_local_option, [listen])),
     [?XC("h1", ?T("Listened Ports at ") ++ atom_to_list(Node))] ++
 	case Res of
 	    ok -> [?CT("Submitted"), ?P];
 	    error -> [?CT("Bad format"), ?P];
+	    {error, ReasonT} -> [?CT("Problem: "), ?C(ReasonT), ?P];
 	    nothing -> []
 	end ++
 	[?XAE("form", [{"action", ""}, {"method", "post"}],
@@ -2052,58 +2058,76 @@ node_ports_to_xhtml(Ports, Lang) ->
 	 [?XE("thead",
 	      [?XE("tr",
 		   [?XCT("td", "Port"),
+		    ?XCT("td", "IP"),
 		    ?XCT("td", "Module"),
 		    ?XCT("td", "Options")
 		   ])]),
 	  ?XE("tbody",
 	      lists:map(
-		fun({Port, Module, Opts} = _E) ->
-			SPort = integer_to_list(Port),
+		fun({PortIP, Module, Opts} = _E) ->
+			{_Port, SPort, _TIP, SIP, SSPort, OptsClean} =
+			    get_port_data(PortIP, Opts),
 			SModule = atom_to_list(Module),
 			%%ID = term_to_id(E),
 			?XE("tr",
-			    [?XC("td", SPort),
-			     ?XE("td", [?INPUT("text", "module" ++ SPort,
-					       SModule)]),
-			     ?XE("td", [?INPUTS("text", "opts" ++ SPort,
-						term_to_string(Opts), "40")]),
-			     ?XE("td", [?INPUTT("submit", "add" ++ SPort,
+			    [?XAE("td", [{"size", "6"}], [?C(SPort)]),
+			     ?XAE("td", [{"size", "15"}], [?C(SIP)]),
+			     ?XE("td", [?INPUTS("text", "module" ++ SSPort,
+						SModule, "15")]),
+			     ?XE("td", [?INPUTS("text", "opts" ++ SSPort,
+						term_to_string(OptsClean), "40")]),
+			     ?XE("td", [?INPUTT("submit", "add" ++ SSPort,
 						"Update")]),
-			     ?XE("td", [?INPUTT("submit", "delete" ++ SPort,
+			     ?XE("td", [?INPUTT("submit", "delete" ++ SSPort,
 						"Delete")])
 			    ]
 			   )
 		end, Ports) ++
 	      [?XE("tr",
 		   [?XE("td", [?INPUTS("text", "portnew", "", "6")]),
-		    ?XE("td", [?INPUT("text", "modulenew", "")]),
-		    ?XE("td", [?INPUTS("text", "optsnew", "", "40")]),
+		    ?XE("td", [?INPUTS("text", "ipnew", "0.0.0.0", "15")]),
+		    ?XE("td", [?INPUTS("text", "modulenew", "", "17")]),
+		    ?XE("td", [?INPUTS("text", "optsnew", "[]", "40")]),
 		    ?XAE("td", [{"colspan", "2"}],
 			 [?INPUTT("submit", "addnew", "Add New")])
 		   ]
 		  )]
 	     )]).
 
+get_port_data(PortIP, Opts) ->
+    {Port, IPT, IPS, _IPV, OptsClean} = ejabberd_listener:parse_listener_portip(PortIP, Opts),
+    SPort = io_lib:format("~p", [Port]),
+
+    SSPort = lists:flatten(
+	       lists:map(
+		 fun(N) -> io_lib:format("~.16b", [N]) end,
+		 binary_to_list(crypto:md5(SPort++IPS)))),
+    {Port, SPort, IPT, IPS, SSPort, OptsClean}.
 
 node_ports_parse_query(Node, Ports, Query) ->
     lists:foreach(
-      fun({Port, _Module1, _Opts1}) ->
-	      SPort = integer_to_list(Port),
-	      case lists:keysearch("add" ++ SPort, 1, Query) of
+      fun({PortIP, _Module1, Opts1}) ->
+	      {Port, _SPort, TIP, _SIP, SSPort, _OptsClean} =
+		  get_port_data(PortIP, Opts1),
+	      case lists:keysearch("add" ++ SSPort, 1, Query) of
 		  {value, _} ->
+		      PortIP2 = {Port, TIP},
 		      {{value, {_, SModule}}, {value, {_, SOpts}}} =
-			  {lists:keysearch("module" ++ SPort, 1, Query),
-			   lists:keysearch("opts" ++ SPort, 1, Query)},
+			  {lists:keysearch("module" ++ SSPort, 1, Query),
+			   lists:keysearch("opts" ++ SSPort, 1, Query)},
 		      Module = list_to_atom(SModule),
 		      {ok, Tokens, _} = erl_scan:string(SOpts ++ "."),
 		      {ok, Opts} = erl_parse:parse_term(Tokens),
-		      rpc:call(Node, ejabberd_listener, delete_listener, [Port]),
-		      rpc:call(Node, ejabberd_listener, add_listener, [Port, Module, Opts]),
-		      throw(submitted);
+		      rpc:call(Node, ejabberd_listener, delete_listener,
+			       [PortIP2]),
+		      R=rpc:call(Node, ejabberd_listener, add_listener,
+				 [PortIP2, Module, Opts]),
+		      throw({is_added, R});
 		  _ ->
-		      case lists:keysearch("delete" ++ SPort, 1, Query) of
+		      case lists:keysearch("delete" ++ SSPort, 1, Query) of
 			  {value, _} ->
-			      rpc:call(Node, ejabberd_listener, delete_listener, [Port]),
+			      rpc:call(Node, ejabberd_listener, delete_listener,
+				       [PortIP]),
 			      throw(submitted);
 			  _ ->
 			      ok
@@ -2113,17 +2137,28 @@ node_ports_parse_query(Node, Ports, Quer
     case lists:keysearch("addnew", 1, Query) of
 	{value, _} ->
 	    {{value, {_, SPort}},
+	     {value, {_, STIP}}, %% It is a string that may represent a tuple
 	     {value, {_, SModule}},
 	     {value, {_, SOpts}}} =
 		{lists:keysearch("portnew", 1, Query),
+		 lists:keysearch("ipnew", 1, Query),
 		 lists:keysearch("modulenew", 1, Query),
 		 lists:keysearch("optsnew", 1, Query)},
-	    Port = list_to_integer(SPort),
+	    {ok, Toks, _} = erl_scan:string(SPort ++ "."),
+	    {ok, Port2} = erl_parse:parse_term(Toks),
+	    {ok, ToksIP, _} = erl_scan:string(STIP ++ "."),
+	    STIP2 = case erl_parse:parse_term(ToksIP) of
+			{ok, IPTParsed} -> IPTParsed;
+			{error, _} -> STIP
+		    end,
 	    Module = list_to_atom(SModule),
 	    {ok, Tokens, _} = erl_scan:string(SOpts ++ "."),
 	    {ok, Opts} = erl_parse:parse_term(Tokens),
-	    rpc:call(Node, ejabberd_listener, add_listener, [Port, Module, Opts]),
-	    throw(submitted);
+	    {Port2, _SPort, IP2, _SIP, _SSPort, OptsClean} =
+		get_port_data({Port2, STIP2}, Opts),
+	    R=rpc:call(Node, ejabberd_listener, add_listener,
+		       [{Port2, IP2}, Module, OptsClean]),
+	    throw({is_added, R});
 	_ ->
 	    ok
     end.