xmpp.chapril.org-ejabberd/src/mod_irc_connection.erl

%%%----------------------------------------------------------------------
%%% File    : mod_irc_connection.erl
%%% Author  : Alexey Shchepin <alexey@process-one.net>
%%% Purpose :
%%% Created : 15 Feb 2003 by Alexey Shchepin <alexey@process-one.net>
%%%
%%%
%%% ejabberd, Copyright (C) 2002-2016   ProcessOne
%%%
%%% This program is free software; you can redistribute it and/or
%%% modify it under the terms of the GNU General Public License as
%%% published by the Free Software Foundation; either version 2 of the
%%% License, or (at your option) any later version.
%%%
%%% This program is distributed in the hope that it will be useful,
%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
%%% General Public License for more details.
%%%
%%% You should have received a copy of the GNU General Public License along
%%% with this program; if not, write to the Free Software Foundation, Inc.,
%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
%%%
%%%----------------------------------------------------------------------

-module(mod_irc_connection).

-author('alexey@process-one.net').

-behaviour(gen_fsm).

%% External exports
-export([start_link/12, start/13, route_chan/4,
	 route_nick/3]).

%% gen_fsm callbacks
-export([init/1, open_socket/2, wait_for_registration/2,
	 stream_established/2, handle_event/3,
	 handle_sync_event/4, handle_info/3, terminate/3,
	 code_change/4]).

-include("ejabberd.hrl").
-include("logger.hrl").

-include("jlib.hrl").

-define(SETS, gb_sets).

-record(state,
	{socket                :: inet:socket(),
         encoding = <<"">>     :: binary(),
         port = 0              :: inet:port_number(),
         password = <<"">>     :: binary(),
         queue = queue:new()   :: ?TQUEUE,
         user = #jid{}         :: jid(),
         host = <<"">>         :: binary(),
	 server = <<"">>       :: binary(),
	 remoteAddr = <<"">>   :: binary(),
	 ident = <<"">>        :: binary(),
	 realname = <<"">>        :: binary(),
         nick = <<"">>         :: binary(),
         channels = dict:new() :: ?TDICT,
         nickchannel           :: binary(),
	 webirc_password       :: binary(),
         mod = mod_irc         :: atom(),
	 inbuf = <<"">>        :: binary(),
         outbuf = <<"">>       :: binary()}).

%-define(DBGFSM, true).

-ifdef(DBGFSM).

-define(FSMOPTS, [{debug, [trace]}]).

-else.

-define(FSMOPTS, []).

%%%----------------------------------------------------------------------
%%% API
%%%----------------------------------------------------------------------
-endif.

start(From, Host, ServerHost, Server, Username,
      Encoding, Port, Password, Ident, RemoteAddr, RealName, WebircPassword, Mod) ->
    Supervisor = gen_mod:get_module_proc(ServerHost,
					 ejabberd_mod_irc_sup),
    supervisor:start_child(Supervisor,
			   [From, Host, Server, Username, Encoding, Port,
			    Password, Ident, RemoteAddr, RealName, WebircPassword, Mod]).

start_link(From, Host, Server, Username, Encoding, Port,
	   Password, Ident, RemoteAddr, RealName, WebircPassword, Mod) ->
    gen_fsm:start_link(?MODULE,
		       [From, Host, Server, Username, Encoding, Port, Password,
			Ident, RemoteAddr, RealName, WebircPassword, Mod],
		       ?FSMOPTS).

%%%----------------------------------------------------------------------
%%% Callback functions from gen_fsm
%%%----------------------------------------------------------------------

%%----------------------------------------------------------------------
%% Func: init/1
%% Returns: {ok, StateName, StateData}          |
%%          {ok, StateName, StateData, Timeout} |
%%          ignore                              |
%%          {stop, StopReason}
%%----------------------------------------------------------------------
init([From, Host, Server, Username, Encoding, Port,
      Password, Ident, RemoteAddr, RealName, WebircPassword, Mod]) ->
    gen_fsm:send_event(self(), init),
    {ok, open_socket,
     #state{queue = queue:new(), mod = Mod,
	    encoding = Encoding, port = Port, password = Password,
	    user = From, nick = Username, host = Host,
	    server = Server, ident = Ident, realname = RealName,
		remoteAddr = RemoteAddr, webirc_password = WebircPassword }}.

%%----------------------------------------------------------------------
%% Func: StateName/2
%% Returns: {next_state, NextStateName, NextStateData}          |
%%          {next_state, NextStateName, NextStateData, Timeout} |
%%          {stop, Reason, NewStateData}
%%----------------------------------------------------------------------
open_socket(init, StateData) ->
    Addr = StateData#state.server,
    Port = StateData#state.port,
    ?DEBUG("Connecting with IPv6 to ~s:~p", [Addr, Port]),
    From = StateData#state.user,
    #jid{user = JidUser, server = JidServer, resource = JidResource} = From,
    UserIP = ejabberd_sm:get_user_ip(JidUser, JidServer, JidResource),
    UserIPStr = inet_parse:ntoa(element(1, UserIP)),
    Connect6 = gen_tcp:connect(binary_to_list(Addr), Port,
			       [inet6, binary, {packet, 0}]),
    Connect = case Connect6 of
		{error, _} ->
		    ?DEBUG("Connection with IPv6 to ~s:~p failed. "
			   "Now using IPv4.",
			   [Addr, Port]),
		    gen_tcp:connect(binary_to_list(Addr), Port,
				    [inet, binary, {packet, 0}]);
		_ -> Connect6
	      end,
    case Connect of
      {ok, Socket} ->
	  NewStateData = StateData#state{socket = Socket},
	  send_text(NewStateData,
	  io_lib:format("WEBIRC ~s ~s ~s ~s\r\n", [StateData#state.webirc_password, JidResource, UserIPStr, UserIPStr])),
	  if StateData#state.password /= <<"">> ->
		 send_text(NewStateData,
			   io_lib:format("PASS ~s\r\n",
					 [StateData#state.password]));
	     true -> true
	  end,
	  send_text(NewStateData,
		    io_lib:format("NICK ~s\r\n", [StateData#state.nick])),
	  send_text(NewStateData,
		    io_lib:format("USER ~s ~s ~s :~s\r\n",
				  [StateData#state.ident,
				   StateData#state.nick,
				   StateData#state.host,
				   StateData#state.realname])),
	  {next_state, wait_for_registration, NewStateData};
      {error, Reason} ->
	  ?DEBUG("connect return ~p~n", [Reason]),
	  Text = case Reason of
		   timeout -> <<"Server Connect Timeout">>;
		   _ -> <<"Server Connect Failed">>
		 end,
	  bounce_messages(Text),
	  {stop, normal, StateData}
    end.

wait_for_registration(closed, StateData) ->
    {stop, normal, StateData}.

stream_established({xmlstreamend, _Name}, StateData) ->
    {stop, normal, StateData};
stream_established(timeout, StateData) ->
    {stop, normal, StateData};
stream_established(closed, StateData) ->
    {stop, normal, StateData}.

%%----------------------------------------------------------------------
%% Func: StateName/3
%% Returns: {next_state, NextStateName, NextStateData}            |
%%          {next_state, NextStateName, NextStateData, Timeout}   |
%%          {reply, Reply, NextStateName, NextStateData}          |
%%          {reply, Reply, NextStateName, NextStateData, Timeout} |
%%          {stop, Reason, NewStateData}                          |
%%          {stop, Reason, Reply, NewStateData}
%%----------------------------------------------------------------------
%state_name(Event, From, StateData) ->
%    Reply = ok,
%    {reply, Reply, state_name, StateData}.

%%----------------------------------------------------------------------
%% Func: handle_event/3
%% Returns: {next_state, NextStateName, NextStateData}          |
%%          {next_state, NextStateName, NextStateData, Timeout} |
%%          {stop, Reason, NewStateData}
%%----------------------------------------------------------------------
handle_event(_Event, StateName, StateData) ->
    {next_state, StateName, StateData}.

%%----------------------------------------------------------------------
%% Func: handle_sync_event/4
%% Returns: {next_state, NextStateName, NextStateData}            |
%%          {next_state, NextStateName, NextStateData, Timeout}   |
%%          {reply, Reply, NextStateName, NextStateData}          |
%%          {reply, Reply, NextStateName, NextStateData, Timeout} |
%%          {stop, Reason, NewStateData}                          |
%%          {stop, Reason, Reply, NewStateData}
%%----------------------------------------------------------------------
handle_sync_event(_Event, _From, StateName,
		  StateData) ->
    Reply = ok, {reply, Reply, StateName, StateData}.

code_change(_OldVsn, StateName, StateData, _Extra) ->
    {ok, StateName, StateData}.

-define(SEND(S),
	if StateName == stream_established ->
	       send_text(StateData, S), StateData;
	   true ->
	       StateData#state{outbuf = <<(StateData#state.outbuf)/binary,
                                          (iolist_to_binary(S))/binary>>}
	end).

get_password_from_presence(#xmlel{name = <<"presence">>,
				  children = Els}) ->
    case lists:filter(fun (El) ->
			      case El of
				#xmlel{name = <<"x">>, attrs = Attrs} ->
				    case fxml:get_attr_s(<<"xmlns">>, Attrs) of
				      ?NS_MUC -> true;
				      _ -> false
				    end;
				_ -> false
			      end
		      end,
		      Els)
	of
      [ElXMUC | _] ->
	  case fxml:get_subtag(ElXMUC, <<"password">>) of
	    #xmlel{name = <<"password">>} = PasswordTag ->
		{true, fxml:get_tag_cdata(PasswordTag)};
	    _ -> false
	  end;
      _ -> false
    end.

%%----------------------------------------------------------------------
%% Func: handle_info/3
%% Returns: {next_state, NextStateName, NextStateData}          |
%%          {next_state, NextStateName, NextStateData, Timeout} |
%%          {stop, Reason, NewStateData}
%%----------------------------------------------------------------------
handle_info({route_chan, Channel, Resource,
	     #xmlel{name = <<"presence">>, attrs = Attrs} =
		 Presence},
	    StateName, StateData) ->
    NewStateData = case fxml:get_attr_s(<<"type">>, Attrs) of
		     <<"unavailable">> ->
			 send_stanza_unavailable(Channel, StateData),
			 S1 = (?SEND((io_lib:format("PART #~s\r\n",
						    [Channel])))),
			 S1#state{channels =
				      dict:erase(Channel, S1#state.channels)};
		     <<"subscribe">> -> StateData;
		     <<"subscribed">> -> StateData;
		     <<"unsubscribe">> -> StateData;
		     <<"unsubscribed">> -> StateData;
		     <<"error">> -> stop;
		     _ ->
			 Nick = case Resource of
				  <<"">> -> StateData#state.nick;
				  _ -> Resource
				end,
			 S1 = if Nick /= StateData#state.nick ->
				     S11 = (?SEND((io_lib:format("NICK ~s\r\n",
								 [Nick])))),
				     S11#state{nickchannel = Channel};
				 true -> StateData
			      end,
			 case dict:is_key(Channel, S1#state.channels) of
			   true -> S1;
			   _ ->
			       case get_password_from_presence(Presence) of
				 {true, Password} ->
				     S2 =
					 (?SEND((io_lib:format("JOIN #~s ~s\r\n",
							       [Channel,
								Password]))));
				 _ ->
				     S2 = (?SEND((io_lib:format("JOIN #~s\r\n",
								[Channel]))))
			       end,
			       S2#state{channels =
					    dict:store(Channel, (?SETS):new(),
						       S1#state.channels)}
			 end
		   end,
    if NewStateData == stop -> {stop, normal, StateData};
       true ->
	   case dict:fetch_keys(NewStateData#state.channels) of
	     [] -> {stop, normal, NewStateData};
	     _ -> {next_state, StateName, NewStateData}
	   end
    end;
handle_info({route_chan, Channel, Resource,
	     #xmlel{name = <<"message">>, attrs = Attrs} = El},
	    StateName, StateData) ->
    NewStateData = case fxml:get_attr_s(<<"type">>, Attrs) of
		     <<"groupchat">> ->
			 case fxml:get_path_s(El, [{elem, <<"subject">>}, cdata])
			     of
			   <<"">> ->
			       ejabberd_router:route(
                                 jid:make(
                                   iolist_to_binary([Channel,
                                                     <<"%">>,
                                                     StateData#state.server]),
                                   StateData#state.host,
                                   StateData#state.nick),
                                 StateData#state.user, El),
			       Body = fxml:get_path_s(El,
						     [{elem, <<"body">>},
						      cdata]),
			       case Body of
				 <<"/quote ", Rest/binary>> ->
				     ?SEND(<<Rest/binary, "\r\n">>);
				 <<"/msg ", Rest/binary>> ->
				     ?SEND(<<"PRIVMSG ", Rest/binary, "\r\n">>);
				 <<"/me ", Rest/binary>> ->
				     Strings = str:tokens(Rest, <<"\n">>),
				     Res = iolist_to_binary(
                                             lists:map(
                                               fun (S) ->
                                                       io_lib:format(
                                                         "PRIVMSG #~s :\001ACTION ~s\001\r\n",
                                                         [Channel, S])
                                               end,
                                               Strings)),
				     ?SEND(Res);
				 <<"/ctcp ", Rest/binary>> ->
				     Words = str:tokens(Rest, <<" ">>),
				     case Words of
				       [CtcpDest | _] ->
					   CtcpCmd = str:to_upper(
                                                       str:substr(Rest,
                                                                  str:str(Rest,
                                                                          <<" ">>)
                                                                  + 1)),
					   Res =
					       io_lib:format("PRIVMSG ~s :\001~s\001\r\n",
							     [CtcpDest,
							      CtcpCmd]),
					   ?SEND(Res);
				       _ -> ok
				     end;
				 _ ->
				     Strings = str:tokens(Body, <<"\n">>),
				     Res = iolist_to_binary(
                                             lists:map(
                                               fun (S) ->
                                                       io_lib:format("PRIVMSG #~s :~s\r\n",
                                                                     [Channel, S])
                                               end,
                                               Strings)),
				     ?SEND(Res)
			       end;
			   Subject ->
			       Strings = str:tokens(Subject, <<"\n">>),
			       Res = iolist_to_binary(
                                       lists:map(
                                         fun (S) ->
                                                 io_lib:format("TOPIC #~s :~s\r\n",
                                                               [Channel, S])
                                         end,
                                         Strings)),
			       ?SEND(Res)
			 end;
		     Type
			 when Type == <<"chat">>;
			      Type == <<"">>;
			      Type == <<"normal">> ->
			 Body = fxml:get_path_s(El, [{elem, <<"body">>}, cdata]),
			 case Body of
			   <<"/quote ", Rest/binary>> ->
			       ?SEND(<<Rest/binary, "\r\n">>);
			   <<"/msg ", Rest/binary>> ->
			       ?SEND(<<"PRIVMSG ", Rest/binary, "\r\n">>);
			   <<"/me ", Rest/binary>> ->
			       Strings = str:tokens(Rest, <<"\n">>),
			       Res = iolist_to_binary(
                                       lists:map(
                                         fun (S) ->
                                                 io_lib:format(
                                                   "PRIVMSG ~s :\001ACTION ~s\001\r\n",
                                                   [Resource, S])
                                         end,
                                         Strings)),
			       ?SEND(Res);
			   <<"/ctcp ", Rest/binary>> ->
			       Words = str:tokens(Rest, <<" ">>),
			       case Words of
				 [CtcpDest | _] ->
				     CtcpCmd = str:to_upper(
                                                 str:substr(Rest,
                                                            str:str(Rest,
                                                                    <<" ">>)
                                                            + 1)),
				     Res = io_lib:format("PRIVMSG ~s :~s\r\n",
							 [CtcpDest,
							  <<"\001",
							    CtcpCmd/binary,
							    "\001">>]),
				     ?SEND(Res);
				 _ -> ok
			       end;
			   _ ->
			       Strings = str:tokens(Body, <<"\n">>),
			       Res = iolist_to_binary(
                                       lists:map(
                                         fun (S) ->
                                                 io_lib:format(
                                                   "PRIVMSG ~s :~s\r\n",
                                                   [Resource, S])
                                         end,
                                         Strings)),
			       ?SEND(Res)
			 end;
		     <<"error">> -> stop;
		     _ -> StateData
		   end,
    if NewStateData == stop -> {stop, normal, StateData};
       true -> {next_state, StateName, NewStateData}
    end;
handle_info({route_chan, Channel, Resource,
	     #xmlel{name = <<"iq">>} = El},
	    StateName, StateData) ->
    From = StateData#state.user,
    To = jid:make(iolist_to_binary([Channel, <<"%">>,
                                         StateData#state.server]),
		       StateData#state.host, StateData#state.nick),
    _ = case jlib:iq_query_info(El) of
	  #iq{xmlns = ?NS_MUC_ADMIN} = IQ ->
	      iq_admin(StateData, Channel, From, To, IQ);
	  #iq{xmlns = ?NS_VERSION} ->
	      Res = io_lib:format("PRIVMSG ~s :\001VERSION\001\r\n",
				  [Resource]),
	      _ = (?SEND(Res)),
	      Err = jlib:make_error_reply(El,
					  ?ERR_FEATURE_NOT_IMPLEMENTED),
	      ejabberd_router:route(To, From, Err);
	  #iq{xmlns = ?NS_TIME} ->
	      Res = io_lib:format("PRIVMSG ~s :\001TIME\001\r\n",
				  [Resource]),
	      _ = (?SEND(Res)),
	      Err = jlib:make_error_reply(El,
					  ?ERR_FEATURE_NOT_IMPLEMENTED),
	      ejabberd_router:route(To, From, Err);
	  #iq{xmlns = ?NS_VCARD} ->
	      Res = io_lib:format("WHOIS ~s \r\n", [Resource]),
	      _ = (?SEND(Res)),
	      Err = jlib:make_error_reply(El,
					  ?ERR_FEATURE_NOT_IMPLEMENTED),
	      ejabberd_router:route(To, From, Err);
	  #iq{} ->
	      Err = jlib:make_error_reply(El,
					  ?ERR_FEATURE_NOT_IMPLEMENTED),
	      ejabberd_router:route(To, From, Err);
	  _ -> ok
	end,
    {next_state, StateName, StateData};
handle_info({route_chan, _Channel, _Resource, _Packet},
	    StateName, StateData) ->
    {next_state, StateName, StateData};
handle_info({route_nick, Nick,
	     #xmlel{name = <<"message">>, attrs = Attrs} = El},
	    StateName, StateData) ->
    NewStateData = case fxml:get_attr_s(<<"type">>, Attrs) of
		     <<"chat">> ->
			 Body = fxml:get_path_s(El, [{elem, <<"body">>}, cdata]),
			 case Body of
			   <<"/quote ", Rest/binary>> ->
			       ?SEND(<<Rest/binary, "\r\n">>);
			   <<"/msg ", Rest/binary>> ->
			       ?SEND(<<"PRIVMSG ", Rest/binary, "\r\n">>);
			   <<"/me ", Rest/binary>> ->
			       Strings = str:tokens(Rest, <<"\n">>),
			       Res = iolist_to_binary(
                                       lists:map(
                                         fun (S) ->
                                                 io_lib:format(
                                                   "PRIVMSG ~s :\001ACTION ~s\001\r\n",
                                                   [Nick, S])
                                         end,
                                         Strings)),
			       ?SEND(Res);
			   <<"/ctcp ", Rest/binary>> ->
			       Words = str:tokens(Rest, <<" ">>),
			       case Words of
				 [CtcpDest | _] ->
				     CtcpCmd = str:to_upper(
                                                 str:substr(Rest,
                                                            str:str(Rest,
                                                                    <<" ">>)
                                                            + 1)),
				     Res = io_lib:format("PRIVMSG ~s :~s\r\n",
							 [CtcpDest,
							  <<"\001",
							    CtcpCmd/binary,
							    "\001">>]),
				     ?SEND(Res);
				 _ -> ok
			       end;
			   _ ->
			       Strings = str:tokens(Body, <<"\n">>),
			       Res = iolist_to_binary(
                                       lists:map(
                                         fun (S) ->
                                                 io_lib:format(
                                                   "PRIVMSG ~s :~s\r\n",
                                                   [Nick, S])
                                         end,
                                         Strings)),
			       ?SEND(Res)
			 end;
		     <<"error">> -> stop;
		     _ -> StateData
		   end,
    if NewStateData == stop -> {stop, normal, StateData};
       true -> {next_state, StateName, NewStateData}
    end;
handle_info({route_nick, _Nick, _Packet}, StateName,
	    StateData) ->
    {next_state, StateName, StateData};
handle_info({ircstring,
	     <<$P, $I, $N, $G, $\s, ID/binary>>},
	    StateName, StateData) ->
    send_text(StateData, <<"PONG ", ID/binary, "\r\n">>),
    {next_state, StateName, StateData};
handle_info({ircstring, <<$:, String/binary>>},
	    wait_for_registration, StateData) ->
    Words = str:tokens(String, <<" ">>),
    {NewState, NewStateData} = case Words of
				 [_, <<"001">> | _] ->
				     send_text(StateData,
					       io_lib:format("CODEPAGE ~s\r\n",
							     [StateData#state.encoding])),
				     {stream_established, StateData};
				 [_, <<"433">> | _] ->
				     {error,
				      {error,
				       error_nick_in_use(StateData, String),
				       StateData}};
				 [_, <<$4, _, _>> | _] ->
				     {error,
				      {error,
				       error_unknown_num(StateData, String,
							 <<"cancel">>),
				       StateData}};
				 [_, <<$5, _, _>> | _] ->
				     {error,
				      {error,
				       error_unknown_num(StateData, String,
							 <<"cancel">>),
				       StateData}};
				 _ ->
				     ?DEBUG("unknown irc command '~s'~n",
					    [String]),
				     {wait_for_registration, StateData}
			       end,
    if NewState == error -> {stop, normal, NewStateData};
       true -> {next_state, NewState, NewStateData}
    end;
handle_info({ircstring, <<$:, String/binary>>},
	    _StateName, StateData) ->
    Words = str:tokens(String, <<" ">>),
    NewStateData = case Words of
		     [_, <<"353">> | Items] ->
			 process_channel_list(StateData, Items);
		     [_, <<"332">>, _Nick, <<$#, Chan/binary>> | _] ->
			 process_channel_topic(StateData, Chan, String),
			 StateData;
		     [_, <<"333">>, _Nick, <<$#, Chan/binary>> | _] ->
			 process_channel_topic_who(StateData, Chan, String),
			 StateData;
		     [_, <<"318">>, _, Nick | _] ->
			 process_endofwhois(StateData, String, Nick), StateData;
		     [_, <<"311">>, _, Nick, Ident, Irchost | _] ->
			 process_whois311(StateData, String, Nick, Ident,
					  Irchost),
			 StateData;
		     [_, <<"312">>, _, Nick, Ircserver | _] ->
			 process_whois312(StateData, String, Nick, Ircserver),
			 StateData;
		     [_, <<"319">>, _, Nick | _] ->
			 process_whois319(StateData, String, Nick), StateData;
		     [_, <<"433">> | _] ->
			 process_nick_in_use(StateData, String);
		     % CODEPAGE isn't standard, so don't complain if it's not there.
		     [_, <<"421">>, _, <<"CODEPAGE">> | _] -> StateData;
		     [_, <<$4, _, _>> | _] ->
			 process_num_error(StateData, String);
		     [_, <<$5, _, _>> | _] ->
			 process_num_error(StateData, String);
		     [From, <<"PRIVMSG">>, <<$#, Chan/binary>> | _] ->
			 process_chanprivmsg(StateData, Chan, From, String),
			 StateData;
		     [From, <<"NOTICE">>, <<$#, Chan/binary>> | _] ->
			 process_channotice(StateData, Chan, From, String),
			 StateData;
		     [From, <<"PRIVMSG">>, Nick, <<":\001VERSION\001">>
		      | _] ->
			 process_version(StateData, Nick, From), StateData;
		     [From, <<"PRIVMSG">>, Nick, <<":\001USERINFO\001">>
		      | _] ->
			 process_userinfo(StateData, Nick, From), StateData;
		     [From, <<"PRIVMSG">>, Nick | _] ->
			 process_privmsg(StateData, Nick, From, String),
			 StateData;
		     [From, <<"NOTICE">>, Nick | _] ->
			 process_notice(StateData, Nick, From, String),
			 StateData;
		     [From, <<"TOPIC">>, <<$#, Chan/binary>> | _] ->
			 process_topic(StateData, Chan, From, String),
			 StateData;
		     [From, <<"PART">>, <<$#, Chan/binary>> | _] ->
			 process_part(StateData, Chan, From, String);
		     [From, <<"QUIT">> | _] ->
			 process_quit(StateData, From, String);
		     [From, <<"JOIN">>, Chan | _] ->
			 process_join(StateData, Chan, From, String);
		     [From, <<"MODE">>, <<$#, Chan/binary>>, <<"+o">>, Nick
		      | _] ->
			 process_mode_o(StateData, Chan, From, Nick,
					<<"admin">>, <<"moderator">>),
			 StateData;
		     [From, <<"MODE">>, <<$#, Chan/binary>>, <<"-o">>, Nick
		      | _] ->
			 process_mode_o(StateData, Chan, From, Nick,
					<<"member">>, <<"participant">>),
			 StateData;
		     [From, <<"KICK">>, <<$#, Chan/binary>>, Nick | _] ->
			 process_kick(StateData, Chan, From, Nick, String),
			 StateData;
		     [From, <<"NICK">>, Nick | _] ->
			 process_nick(StateData, From, Nick);
		     _ ->
			 ?DEBUG("unknown irc command '~s'~n", [String]),
			 StateData
		   end,
    NewStateData1 = case StateData#state.outbuf of
		      <<"">> -> NewStateData;
		      Data ->
			  send_text(NewStateData, Data),
			  NewStateData#state{outbuf = <<"">>}
		    end,
    {next_state, stream_established, NewStateData1};
handle_info({ircstring,
	     <<$E, $R, $R, $O, $R, _/binary>> = String},
	    StateName, StateData) ->
    process_error(StateData, String),
    {next_state, StateName, StateData};
handle_info({ircstring, String}, StateName,
	    StateData) ->
    ?DEBUG("unknown irc command '~s'~n", [String]),
    {next_state, StateName, StateData};
handle_info({send_text, Text}, StateName, StateData) ->
    send_text(StateData, Text),
    {next_state, StateName, StateData};
handle_info({tcp, _Socket, Data}, StateName,
	    StateData) ->
    Buf = <<(StateData#state.inbuf)/binary, Data/binary>>,
    Strings = ejabberd_regexp:split(<< <<C>>
                                       || <<C>> <= Buf, C /= $\r >>,
				    <<"\n">>),
    ?DEBUG("strings=~p~n", [Strings]),
    NewBuf = process_lines(StateData#state.encoding,
			   Strings),
    {next_state, StateName,
     StateData#state{inbuf = NewBuf}};
handle_info({tcp_closed, _Socket}, StateName,
	    StateData) ->
    gen_fsm:send_event(self(), closed),
    {next_state, StateName, StateData};
handle_info({tcp_error, _Socket, _Reason}, StateName,
	    StateData) ->
    gen_fsm:send_event(self(), closed),
    {next_state, StateName, StateData}.

%%----------------------------------------------------------------------
%% Func: terminate/3
%% Purpose: Shutdown the fsm
%% Returns: any
%%----------------------------------------------------------------------
terminate(_Reason, _StateName, FullStateData) ->
    {Error, StateData} = case FullStateData of
			   {error, SError, SStateData} -> {SError, SStateData};
			   _ ->
			       {#xmlel{name = <<"error">>,
				       attrs = [{<<"code">>, <<"502">>}],
				       children =
					   [{xmlcdata,
					     <<"Server Connect Failed">>}]},
				FullStateData}
			 end,
    (StateData#state.mod):closed_connection(StateData#state.host,
                                            StateData#state.user,
                                            StateData#state.server),
    bounce_messages(<<"Server Connect Failed">>),
    lists:foreach(fun (Chan) ->
			  Stanza = #xmlel{name = <<"presence">>,
					  attrs = [{<<"type">>, <<"error">>}],
					  children = [Error]},
			  send_stanza(Chan, StateData, Stanza)
		  end,
		  dict:fetch_keys(StateData#state.channels)),
    case StateData#state.socket of
      undefined -> ok;
      Socket -> gen_tcp:close(Socket)
    end,
    ok.

send_stanza(Chan, StateData, Stanza) ->
    ejabberd_router:route(
      jid:make(
        iolist_to_binary([Chan,
                          <<"%">>,
                          StateData#state.server]),
        StateData#state.host,
        StateData#state.nick),
      StateData#state.user, Stanza).

send_stanza_unavailable(Chan, StateData) ->
    Affiliation = <<"member">>,
    Role = <<"none">>,
    Stanza = #xmlel{name = <<"presence">>,
		    attrs = [{<<"type">>, <<"unavailable">>}],
		    children =
			[#xmlel{name = <<"x">>,
				attrs = [{<<"xmlns">>, ?NS_MUC_USER}],
				children =
				    [#xmlel{name = <<"item">>,
					    attrs =
						[{<<"affiliation">>,
						  Affiliation},
						 {<<"role">>, Role}],
					    children = []},
				     #xmlel{name = <<"status">>,
					    attrs = [{<<"code">>, <<"110">>}],
					    children = []}]}]},
    send_stanza(Chan, StateData, Stanza).

%%%----------------------------------------------------------------------
%%% Internal functions
%%%----------------------------------------------------------------------

send_text(#state{socket = Socket, encoding = Encoding},
	  Text) ->
    CText = iconv:convert(<<"utf-8">>, Encoding, iolist_to_binary(Text)),
    gen_tcp:send(Socket, CText).

%send_queue(Socket, Q) ->
%    case queue:out(Q) of
%	{{value, El}, Q1} ->
%	    send_element(Socket, El),
%	    send_queue(Socket, Q1);
%	{empty, Q1} ->
%	    ok
%    end.

bounce_messages(Reason) ->
    receive
      {send_element, El} ->
	  #xmlel{attrs = Attrs} = El,
	  case fxml:get_attr_s(<<"type">>, Attrs) of
	    <<"error">> -> ok;
	    _ ->
		Err = jlib:make_error_reply(El, <<"502">>, Reason),
		From = jid:from_string(fxml:get_attr_s(<<"from">>,
							 Attrs)),
		To = jid:from_string(fxml:get_attr_s(<<"to">>,
						       Attrs)),
		ejabberd_router:route(To, From, Err)
	  end,
	  bounce_messages(Reason)
      after 0 -> ok
    end.

route_chan(Pid, Channel, Resource, Packet) ->
    Pid ! {route_chan, Channel, Resource, Packet}.

route_nick(Pid, Nick, Packet) ->
    Pid ! {route_nick, Nick, Packet}.

process_lines(_Encoding, [S]) -> S;
process_lines(Encoding, [S | Ss]) ->
    self() !
      {ircstring, iconv:convert(Encoding, <<"utf-8">>, S)},
    process_lines(Encoding, Ss).

process_channel_list(StateData, Items) ->
    process_channel_list_find_chan(StateData, Items).

process_channel_list_find_chan(StateData, []) ->
    StateData;
process_channel_list_find_chan(StateData,
			       [<<$#, Chan/binary>> | Items]) ->
    process_channel_list_users(StateData, Chan, Items);
process_channel_list_find_chan(StateData,
			       [_ | Items]) ->
    process_channel_list_find_chan(StateData, Items).

process_channel_list_users(StateData, _Chan, []) ->
    StateData;
process_channel_list_users(StateData, Chan,
			   [User | Items]) ->
    NewStateData = process_channel_list_user(StateData,
					     Chan, User),
    process_channel_list_users(NewStateData, Chan, Items).

process_channel_list_user(StateData, Chan, User) ->
    User1 = case User of
	      <<$:, U1/binary>> -> U1;
	      _ -> User
	    end,
    {User2, Affiliation, Role} = case User1 of
				   <<$@, U2/binary>> ->
				       {U2, <<"admin">>, <<"moderator">>};
				   <<$+, U2/binary>> ->
				       {U2, <<"member">>, <<"participant">>};
				   <<$%, U2/binary>> ->
				       {U2, <<"admin">>, <<"moderator">>};
				   <<$&, U2/binary>> ->
				       {U2, <<"admin">>, <<"moderator">>};
				   <<$~, U2/binary>> ->
				       {U2, <<"admin">>, <<"moderator">>};
				   _ -> {User1, <<"member">>, <<"participant">>}
				 end,
    ejabberd_router:route(jid:make(iolist_to_binary([Chan,
                                                          <<"%">>,
                                                          StateData#state.server]),
					StateData#state.host, User2),
			  StateData#state.user,
			  #xmlel{name = <<"presence">>, attrs = [],
				 children =
				     [#xmlel{name = <<"x">>,
					     attrs =
						 [{<<"xmlns">>, ?NS_MUC_USER}],
					     children =
						 [#xmlel{name = <<"item">>,
							 attrs =
							     [{<<"affiliation">>,
							       Affiliation},
							      {<<"role">>,
							       Role}],
							 children = []}]}]}),
    case catch dict:update(Chan,
			   fun (Ps) -> (?SETS):add_element(User2, Ps) end,
			   StateData#state.channels)
	of
      {'EXIT', _} -> StateData;
      NS -> StateData#state{channels = NS}
    end.

process_channel_topic(StateData, Chan, String) ->
    Msg = ejabberd_regexp:replace(String, <<".*332[^:]*:">>,
				  <<"">>),
    Msg1 = filter_message(Msg),
    ejabberd_router:route(jid:make(iolist_to_binary([Chan,
                                                          <<"%">>,
                                                          StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"groupchat">>}],
				 children =
				     [#xmlel{name = <<"subject">>, attrs = [],
					     children = [{xmlcdata, Msg1}]},
				      #xmlel{name = <<"body">>, attrs = [],
					     children =
						 [{xmlcdata,
						   <<"Topic for #", Chan/binary,
						     ": ", Msg1/binary>>}]}]}).

process_channel_topic_who(StateData, Chan, String) ->
    Words = str:tokens(String, <<" ">>),
    Msg1 = case Words of
	     [_, <<"333">>, _, _Chan, Whoset, Timeset] ->
		 {Unixtimeset, _Rest} = str:to_integer(Timeset),
		 <<"Topic for #", Chan/binary, " set by ", Whoset/binary,
		   " at ", (unixtime2string(Unixtimeset))/binary>>;
	     [_, <<"333">>, _, _Chan, Whoset | _] ->
		 <<"Topic for #", Chan/binary, " set by ",
		   Whoset/binary>>;
	     _ -> String
	   end,
    Msg2 = filter_message(Msg1),
    ejabberd_router:route(jid:make(iolist_to_binary([Chan,
                                                          <<"%">>,
                                                          StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"groupchat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children = [{xmlcdata, Msg2}]}]}).

error_nick_in_use(_StateData, String) ->
    Msg = ejabberd_regexp:replace(String,
				  <<".*433 +[^ ]* +">>, <<"">>),
    Msg1 = filter_message(Msg),
    #xmlel{name = <<"error">>,
	   attrs =
	       [{<<"code">>, <<"409">>}, {<<"type">>, <<"cancel">>}],
	   children =
	       [#xmlel{name = <<"conflict">>,
		       attrs = [{<<"xmlns">>, ?NS_STANZAS}], children = []},
		#xmlel{name = <<"text">>,
		       attrs = [{<<"xmlns">>, ?NS_STANZAS}],
		       children = [{xmlcdata, Msg1}]}]}.

process_nick_in_use(StateData, String) ->
    Error = error_nick_in_use(StateData, String),
    case StateData#state.nickchannel of
      undefined ->
	  % Shouldn't happen with a well behaved server
	  StateData;
      Chan ->
	  ejabberd_router:route(jid:make(iolist_to_binary([Chan,
                                                                <<"%">>,
                                                                StateData#state.server]),
					      StateData#state.host,
					      StateData#state.nick),
				StateData#state.user,
				#xmlel{name = <<"presence">>,
				       attrs = [{<<"type">>, <<"error">>}],
				       children = [Error]}),
	  StateData#state{nickchannel = undefined}
    end.

process_num_error(StateData, String) ->
    Error = error_unknown_num(StateData, String,
			      <<"continue">>),
    lists:foreach(fun (Chan) ->
			  ejabberd_router:route(
                            jid:make(
                              iolist_to_binary(
                                [Chan,
                                 <<"%">>,
                                 StateData#state.server]),
                              StateData#state.host,
                              StateData#state.nick),
                            StateData#state.user,
                            #xmlel{name = <<"message">>,
                                   attrs =
                                       [{<<"type">>,
                                         <<"error">>}],
                                   children = [Error]})
		  end,
		  dict:fetch_keys(StateData#state.channels)),
    StateData.

process_endofwhois(StateData, _String, Nick) ->
    ejabberd_router:route(jid:make(iolist_to_binary([Nick,
                                                          <<"!">>,
                                                          StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"chat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children =
						 [{xmlcdata,
						   <<"End of WHOIS">>}]}]}).

process_whois311(StateData, String, Nick, Ident,
		 Irchost) ->
    Fullname = ejabberd_regexp:replace(String,
				       <<".*311[^:]*:">>, <<"">>),
    ejabberd_router:route(jid:make(iolist_to_binary([Nick,
                                                          <<"!">>,
                                                          StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"chat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children =
						 [{xmlcdata,
						   iolist_to_binary(
                                                     [<<"WHOIS: ">>,
                                                      Nick,
                                                      <<" is ">>,
                                                      Ident,
                                                      <<"@">>,
                                                      Irchost,
                                                      <<" : ">>,
                                                      Fullname])}]}]}).

process_whois312(StateData, String, Nick, Ircserver) ->
    Ircserverdesc = ejabberd_regexp:replace(String,
					    <<".*312[^:]*:">>, <<"">>),
    ejabberd_router:route(jid:make(iolist_to_binary([Nick,
                                                          <<"!">>,
                                                          StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"chat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children =
						 [{xmlcdata,
						   iolist_to_binary(
                                                     [<<"WHOIS: ">>,
                                                      Nick,
                                                      <<" use ">>,
                                                      Ircserver,
                                                      <<" : ">>,
                                                      Ircserverdesc])}]}]}).

process_whois319(StateData, String, Nick) ->
    Chanlist = ejabberd_regexp:replace(String,
				       <<".*319[^:]*:">>, <<"">>),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Nick,
                                           <<"!">>,
                                           StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"chat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children =
						 [{xmlcdata,
						   iolist_to_binary(
                                                     [<<"WHOIS: ">>,
                                                      Nick,
                                                      <<" is on ">>,
                                                      Chanlist])}]}]}).

process_chanprivmsg(StateData, Chan, From, String) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    Msg = ejabberd_regexp:replace(String,
				  <<".*PRIVMSG[^:]*:">>, <<"">>),
    Msg1 = case Msg of
	     <<1, $A, $C, $T, $I, $O, $N, $\s, Rest/binary>> ->
		 <<"/me ", Rest/binary>>;
	     _ -> Msg
	   end,
    Msg2 = filter_message(Msg1),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, FromUser),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"groupchat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children = [{xmlcdata, Msg2}]}]}).

process_channotice(StateData, Chan, From, String) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    Msg = ejabberd_regexp:replace(String,
				  <<".*NOTICE[^:]*:">>, <<"">>),
    Msg1 = case Msg of
	     <<1, $A, $C, $T, $I, $O, $N, $\s, Rest/binary>> ->
		 <<"/me ", Rest/binary>>;
	     _ -> <<"/me NOTICE: ", Msg/binary>>
	   end,
    Msg2 = filter_message(Msg1),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, FromUser),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"groupchat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children = [{xmlcdata, Msg2}]}]}).

process_privmsg(StateData, _Nick, From, String) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    Msg = ejabberd_regexp:replace(String,
				  <<".*PRIVMSG[^:]*:">>, <<"">>),
    Msg1 = case Msg of
	     <<1, $A, $C, $T, $I, $O, $N, $\s, Rest/binary>> ->
		 <<"/me ", Rest/binary>>;
	     _ -> Msg
	   end,
    Msg2 = filter_message(Msg1),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [FromUser,
                                           <<"!">>,
                                           StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"chat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children = [{xmlcdata, Msg2}]}]}).

process_notice(StateData, _Nick, From, String) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    Msg = ejabberd_regexp:replace(String,
				  <<".*NOTICE[^:]*:">>, <<"">>),
    Msg1 = case Msg of
	     <<1, $A, $C, $T, $I, $O, $N, $\s, Rest/binary>> ->
		 <<"/me ", Rest/binary>>;
	     _ -> <<"/me NOTICE: ", Msg/binary>>
	   end,
    Msg2 = filter_message(Msg1),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [FromUser,
                                           <<"!">>,
                                           StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"chat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children = [{xmlcdata, Msg2}]}]}).

process_version(StateData, _Nick, From) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    send_text(StateData,
	      io_lib:format("NOTICE ~s :\001VERSION ejabberd IRC "
			    "transport ~s (c) Alexey Shchepin\001\r\n",
			    [FromUser, ?VERSION])
		++
		io_lib:format("NOTICE ~s :\001VERSION http://ejabberd.jabber"
			      "studio.org/\001\r\n",
			      [FromUser])).

process_userinfo(StateData, _Nick, From) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    send_text(StateData,
	      io_lib:format("NOTICE ~s :\001USERINFO xmpp:~s\001\r\n",
			    [FromUser,
			     jid:to_string(StateData#state.user)])).

process_topic(StateData, Chan, From, String) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    Msg = ejabberd_regexp:replace(String,
				  <<".*TOPIC[^:]*:">>, <<"">>),
    Msg1 = filter_message(Msg),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, FromUser),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"groupchat">>}],
				 children =
				     [#xmlel{name = <<"subject">>, attrs = [],
					     children = [{xmlcdata, Msg1}]},
				      #xmlel{name = <<"body">>, attrs = [],
					     children =
						 [{xmlcdata,
						   <<"/me has changed the subject to: ",
						     Msg1/binary>>}]}]}).

process_part(StateData, Chan, From, String) ->
    [FromUser | FromIdent] = str:tokens(From, <<"!">>),
    Msg = ejabberd_regexp:replace(String,
				  <<".*PART[^:]*:">>, <<"">>),
    Msg1 = filter_message(Msg),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, FromUser),
			  StateData#state.user,
			  #xmlel{name = <<"presence">>,
				 attrs = [{<<"type">>, <<"unavailable">>}],
				 children =
				     [#xmlel{name = <<"x">>,
					     attrs =
						 [{<<"xmlns">>, ?NS_MUC_USER}],
					     children =
						 [#xmlel{name = <<"item">>,
							 attrs =
							     [{<<"affiliation">>,
							       <<"member">>},
							      {<<"role">>,
							       <<"none">>}],
							 children = []}]},
				      #xmlel{name = <<"status">>, attrs = [],
					     children =
						 [{xmlcdata,
                                                   list_to_binary(
                                                     [Msg1, " (",
                                                      FromIdent, ")"])}]}]}),
    case catch dict:update(Chan,
			   fun (Ps) -> remove_element(FromUser, Ps) end,
			   StateData#state.channels)
	of
      {'EXIT', _} -> StateData;
      NS -> StateData#state{channels = NS}
    end.

process_quit(StateData, From, String) ->
    [FromUser | FromIdent] = str:tokens(From, <<"!">>),
    Msg = ejabberd_regexp:replace(String,
				  <<".*QUIT[^:]*:">>, <<"">>),
    Msg1 = filter_message(Msg),
    dict:map(fun (Chan, Ps) ->
		     case (?SETS):is_member(FromUser, Ps) of
		       true ->
			   ejabberd_router:route(jid:make(iolist_to_binary(
                                                                 [Chan,
                                                                  <<"%">>,
                                                                  StateData#state.server]),
							       StateData#state.host,
							       FromUser),
						 StateData#state.user,
						 #xmlel{name = <<"presence">>,
							attrs =
							    [{<<"type">>,
							      <<"unavailable">>}],
							children =
							    [#xmlel{name =
									<<"x">>,
								    attrs =
									[{<<"xmlns">>,
									  ?NS_MUC_USER}],
								    children =
									[#xmlel{name
										    =
										    <<"item">>,
										attrs
										    =
										    [{<<"affiliation">>,
										      <<"member">>},
										     {<<"role">>,
										      <<"none">>}],
										children
										    =
										    []}]},
							     #xmlel{name =
									<<"status">>,
								    attrs = [],
								    children =
									[{xmlcdata,
                                                                          list_to_binary(
                                                                            [Msg1, " (",
                                                                             FromIdent,
                                                                             ")"])}]}]}),
			   remove_element(FromUser, Ps);
		       _ -> Ps
		     end
	     end,
	     StateData#state.channels),
    StateData.

process_join(StateData, Channel, From, _String) ->
    [FromUser | FromIdent] = str:tokens(From, <<"!">>),
    [Chan | _] = binary:split(Channel, <<":#">>),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, FromUser),
			  StateData#state.user,
			  #xmlel{name = <<"presence">>, attrs = [],
				 children =
				     [#xmlel{name = <<"x">>,
					     attrs =
						 [{<<"xmlns">>, ?NS_MUC_USER}],
					     children =
						 [#xmlel{name = <<"item">>,
							 attrs =
							     [{<<"affiliation">>,
							       <<"member">>},
							      {<<"role">>,
							       <<"participant">>}],
							 children = []}]},
				      #xmlel{name = <<"status">>, attrs = [],
					     children =
						 [{xmlcdata,
                                                   list_to_binary(FromIdent)}]}]}),
    case catch dict:update(Chan,
			   fun (Ps) -> (?SETS):add_element(FromUser, Ps) end,
			   StateData#state.channels)
	of
      {'EXIT', _} -> StateData;
      NS -> StateData#state{channels = NS}
    end.

process_mode_o(StateData, Chan, _From, Nick,
	       Affiliation, Role) ->
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, Nick),
			  StateData#state.user,
			  #xmlel{name = <<"presence">>, attrs = [],
				 children =
				     [#xmlel{name = <<"x">>,
					     attrs =
						 [{<<"xmlns">>, ?NS_MUC_USER}],
					     children =
						 [#xmlel{name = <<"item">>,
							 attrs =
							     [{<<"affiliation">>,
							       Affiliation},
							      {<<"role">>,
							       Role}],
							 children = []}]}]}).

process_kick(StateData, Chan, From, Nick, String) ->
    Msg = lists:last(str:tokens(String, <<":">>)),
    Msg2 = <<Nick/binary, " kicked by ", From/binary, " (",
	     (filter_message(Msg))/binary, ")">>,
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, <<"">>),
			  StateData#state.user,
			  #xmlel{name = <<"message">>,
				 attrs = [{<<"type">>, <<"groupchat">>}],
				 children =
				     [#xmlel{name = <<"body">>, attrs = [],
					     children = [{xmlcdata, Msg2}]}]}),
    ejabberd_router:route(jid:make(iolist_to_binary(
                                          [Chan,
                                           <<"%">>,
                                           StateData#state.server]),
					StateData#state.host, Nick),
			  StateData#state.user,
			  #xmlel{name = <<"presence">>,
				 attrs = [{<<"type">>, <<"unavailable">>}],
				 children =
				     [#xmlel{name = <<"x">>,
					     attrs =
						 [{<<"xmlns">>, ?NS_MUC_USER}],
					     children =
						 [#xmlel{name = <<"item">>,
							 attrs =
							     [{<<"affiliation">>,
							       <<"none">>},
							      {<<"role">>,
							       <<"none">>}],
							 children = []},
						  #xmlel{name = <<"status">>,
							 attrs =
							     [{<<"code">>,
							       <<"307">>}],
							 children = []}]}]}).

process_nick(StateData, From, NewNick) ->
    [FromUser | _] = str:tokens(From, <<"!">>),
    [Nick | _] = binary:split(NewNick, <<":">>),
    NewChans = dict:map(fun (Chan, Ps) ->
				case (?SETS):is_member(FromUser, Ps) of
				  true ->
				      ejabberd_router:route(jid:make(
                                                              iolist_to_binary(
                                                                [Chan,
                                                                 <<"%">>,
                                                                 StateData#state.server]),
                                                              StateData#state.host,
                                                              FromUser),
							    StateData#state.user,
							    #xmlel{name =
								       <<"presence">>,
								   attrs =
								       [{<<"type">>,
									 <<"unavailable">>}],
								   children =
								       [#xmlel{name
										   =
										   <<"x">>,
									       attrs
										   =
										   [{<<"xmlns">>,
										     ?NS_MUC_USER}],
									       children
										   =
										   [#xmlel{name
											       =
											       <<"item">>,
											   attrs
											       =
											       [{<<"affiliation">>,
												 <<"member">>},
												{<<"role">>,
												 <<"participant">>},
												{<<"nick">>,
												 Nick}],
											   children
											       =
											       []},
										    #xmlel{name
											       =
											       <<"status">>,
											   attrs
											       =
											       [{<<"code">>,
												 <<"303">>}],
											   children
											       =
											       []}]}]}),
				      ejabberd_router:route(jid:make(
                                                              iolist_to_binary(
                                                                [Chan,
                                                                 <<"%">>,
                                                                 StateData#state.server]),
                                                              StateData#state.host,
                                                              Nick),
							    StateData#state.user,
							    #xmlel{name =
								       <<"presence">>,
								   attrs = [],
								   children =
								       [#xmlel{name
										   =
										   <<"x">>,
									       attrs
										   =
										   [{<<"xmlns">>,
										     ?NS_MUC_USER}],
									       children
										   =
										   [#xmlel{name
											       =
											       <<"item">>,
											   attrs
											       =
											       [{<<"affiliation">>,
												 <<"member">>},
												{<<"role">>,
												 <<"participant">>}],
											   children
											       =
											       []}]}]}),
				      (?SETS):add_element(Nick,
							  remove_element(FromUser,
									 Ps));
				  _ -> Ps
				end
			end,
			StateData#state.channels),
    if FromUser == StateData#state.nick ->
	   StateData#state{nick = Nick, nickchannel = undefined,
			   channels = NewChans};
       true -> StateData#state{channels = NewChans}
    end.

process_error(StateData, String) ->
    lists:foreach(fun (Chan) ->
			  ejabberd_router:route(jid:make(
                                                  iolist_to_binary(
                                                    [Chan,
                                                     <<"%">>,
                                                     StateData#state.server]),
                                                  StateData#state.host,
                                                  StateData#state.nick),
						StateData#state.user,
						#xmlel{name = <<"presence">>,
						       attrs =
							   [{<<"type">>,
							     <<"error">>}],
						       children =
							   [#xmlel{name =
								       <<"error">>,
								   attrs =
								       [{<<"code">>,
									 <<"502">>}],
								   children =
								       [{xmlcdata,
									 String}]}]})
		  end,
		  dict:fetch_keys(StateData#state.channels)).

error_unknown_num(_StateData, String, Type) ->
    Msg = ejabberd_regexp:replace(String,
				  <<".*[45][0-9][0-9] +[^ ]* +">>, <<"">>),
    Msg1 = filter_message(Msg),
    #xmlel{name = <<"error">>,
	   attrs = [{<<"code">>, <<"500">>}, {<<"type">>, Type}],
	   children =
	       [#xmlel{name = <<"undefined-condition">>,
		       attrs = [{<<"xmlns">>, ?NS_STANZAS}], children = []},
		#xmlel{name = <<"text">>,
		       attrs = [{<<"xmlns">>, ?NS_STANZAS}],
		       children = [{xmlcdata, Msg1}]}]}.

remove_element(E, Set) ->
    case (?SETS):is_element(E, Set) of
      true -> (?SETS):del_element(E, Set);
      _ -> Set
    end.

iq_admin(StateData, Channel, From, To,
	 #iq{type = Type, xmlns = XMLNS, sub_el = SubEl} = IQ) ->
    case catch process_iq_admin(StateData, Channel, Type,
				SubEl)
	of
      {'EXIT', Reason} -> ?ERROR_MSG("~p", [Reason]);
      Res ->
	  if Res /= ignore ->
		 ResIQ = case Res of
			   {result, ResEls} ->
			       IQ#iq{type = result,
				     sub_el =
					 [#xmlel{name = <<"query">>,
						 attrs = [{<<"xmlns">>, XMLNS}],
						 children = ResEls}]};
			   {error, Error} ->
			       IQ#iq{type = error, sub_el = [SubEl, Error]}
			 end,
		 ejabberd_router:route(To, From, jlib:iq_to_xml(ResIQ));
	     true -> ok
	  end
    end.

process_iq_admin(StateData, Channel, set, SubEl) ->
    case fxml:get_subtag(SubEl, <<"item">>) of
      false -> {error, ?ERR_BAD_REQUEST};
      ItemEl ->
	  Nick = fxml:get_tag_attr_s(<<"nick">>, ItemEl),
	  Affiliation = fxml:get_tag_attr_s(<<"affiliation">>,
					   ItemEl),
	  Role = fxml:get_tag_attr_s(<<"role">>, ItemEl),
	  Reason = fxml:get_path_s(ItemEl,
				  [{elem, <<"reason">>}, cdata]),
	  process_admin(StateData, Channel, Nick, Affiliation,
			Role, Reason)
    end;
process_iq_admin(_StateData, _Channel, get, _SubEl) ->
    {error, ?ERR_FEATURE_NOT_IMPLEMENTED}.

process_admin(_StateData, _Channel, <<"">>,
	      _Affiliation, _Role, _Reason) ->
    {error, ?ERR_FEATURE_NOT_IMPLEMENTED};
process_admin(StateData, Channel, Nick, _Affiliation,
	      <<"none">>, Reason) ->
    case Reason of
      <<"">> ->
	  send_text(StateData,
		    io_lib:format("KICK #~s ~s\r\n", [Channel, Nick]));
      _ ->
	  send_text(StateData,
		    io_lib:format("KICK #~s ~s :~s\r\n",
				  [Channel, Nick, Reason]))
    end,
    {result, []};
process_admin(_StateData, _Channel, _Nick, _Affiliation,
	      _Role, _Reason) ->
    {error, ?ERR_FEATURE_NOT_IMPLEMENTED}.

filter_message(Msg) ->
    list_to_binary(
      lists:filter(fun (C) ->
                           if (C < 32) and (C /= 9) and (C /= 10) and (C /= 13) ->
                                   false;
                              true -> true
                           end
                   end,
                   binary_to_list(filter_mirc_colors(Msg)))).

filter_mirc_colors(Msg) ->
    ejabberd_regexp:greplace(Msg,
			     <<"(\\003[0-9]+)(,[0-9]+)?">>, <<"">>).

unixtime2string(Unixtime) ->
    Secs = Unixtime +
	     calendar:datetime_to_gregorian_seconds({{1970, 1, 1},
						     {0, 0, 0}}),
    {{Year, Month, Day}, {Hour, Minute, Second}} =
	calendar:universal_time_to_local_time(calendar:gregorian_seconds_to_datetime(Secs)),
    iolist_to_binary(io_lib:format("~4..0w-~2..0w-~2..0w ~2..0w:~2..0w:~2..0w",
				   [Year, Month, Day, Hour, Minute, Second])).