-- README

-- Squish verse into this dir, then squish them into one, which you move

-- and rename to mod_ircd.lua in your prosody modules/plugins dir.

--

-- IRC spec:

-- http://tools.ietf.org/html/rfc2812

local _module = module

module = _G.module

local module = _module

local client_xmlns = "jabber:client"

local component_jid, component_secret, muc_server, port_number =

      module.host, nil, module:get_option_string("conference_server"), module:get_option_number("listener_port", 7000);

if not muc_server then

        module:log ("error", "You need to set the MUC server in the configuration (conference_server)!")

	module:log ("error", "Be a good boy or girl and go read the wiki at: http://code.google.com/p/prosody-modules/wiki/mod_ircd")

        return false;

end

package.loaded["util.sha1"] = require "util.encodings";

local verse = require "verse"

require "verse.component"

require "socket"

c = verse.new(); -- something interferes with prosody's console logging

c:add_plugin("groupchat");

local function verse2prosody(e)

        return c:event("stanza", e.stanza) or true;

end

module:hook("message/bare", verse2prosody);

module:hook("message/full", verse2prosody);

module:hook("presence/bare", verse2prosody);

module:hook("presence/full", verse2prosody);

c.type = "component";

c.send = core_post_stanza;

local jid = require "util.jid";

local nodeprep = require "util.encodings".stringprep.nodeprep;

local function utf8_clean (s)

        local push, join = table.insert, table.concat;

        local r, i = {}, 1;

        if not(s and #s > 0) then

                return ""

        end

        while true do

                local c = s:sub(i,i)

                local b = c:byte();

                local w = (

                        (b >= 9   and b <= 10  and 0) or

                        (b >= 32  and b <= 126 and 0) or

                        (b >= 192 and b <= 223 and 1) or

                        (b >= 224 and b <= 239 and 2) or

                        (b >= 240 and b <= 247 and 3) or

                        (b >= 248 and b <= 251 and 4) or

                        (b >= 251 and b <= 252 and 5) or nil

                )

                if not w then

                        push(r, "?")

                else

                        local n = i + w;

                        if w == 0 then

                                push(r, c);

                        elseif n > #s then

                                push(r, ("?"):format(b));

                        else

                                local e = s:sub(i+1,n);

                                if e:match('^[\128-\191]*$') then

                                        push(r, c);

                                        push(r, e);

                                        i = n;

                                else

                                        push(r, ("?"):format(b));

                                end

                        end

                end

                i = i + 1;

                if i > #s then

                        break

                end

        end

        return join(r);

end

local function parse_line(line)

        local ret = {};

        if line:sub(1,1) == ":" then

                ret.from, line = line:match("^:(%w+)%s+(.*)$");

        end

        for part in line:gmatch("%S+") do

                if part:sub(1,1) == ":" then

                        ret[#ret+1] = line:match(":(.*)$");

                        break

                end

                ret[#ret+1]=part;

        end

        return ret;

end

local function build_line(parts)

        if #parts > 1 then

                parts[#parts] = ":" ..  parts[#parts];

        end

        return (parts.from and ":"..parts.from.." " or "")..table.concat(parts, " ");

end

local function irc2muc(channel, nick)

        local room = channel and nodeprep(channel:match("^#(%w+)")) or nil;

        if not nick then

                return jid.join(room, muc_server);

        else

                return jid.join(room, muc_server, nick);

        end

end

local function muc2irc(room)

        local channel, _, nick = jid.split(room);

        return "#"..channel, nick;

end

local role_map = {

        moderator = "@",

        participant = "",

        visitor = "",

        none = ""

}

local aff_map = {

        owner = "~",

        administrator = "&",

        member = "+",

        none = ""

}

local role_modemap = {

        moderator = "o",

        participant = "",

        visitor = "",

        none = ""

}

local aff_modemap = {

        owner = "q",

        administrator = "a",

        member = "v",

        none = ""

}

local irc_listener = { default_port = port_number, default_mode = "*l" };

local sessions = {};

local jids = {};

local commands = {};

local nicks = {};

local usernames = {};

local st = require "util.stanza";

local conference_server = muc_server;

local function irc_close_session(session)

        session.conn:close();

end

function irc_listener.onincoming(conn, data)

        local session = sessions[conn];

        if not session then

                session = { conn = conn, host = component_jid, reset_stream = function () end,

                        close = irc_close_session, log = logger.init("irc"..(conn.id or "1")),

                        rooms = {}, roster = {}, has_un = false };

                sessions[conn] = session;

                function session.data(data)

                        local parts = parse_line(data);

                        module:log("debug", require"util.serialization".serialize(parts));

                        local command = table.remove(parts, 1);

                        if not command then

                                return;

                        end

                        command = command:upper();

                        if not session.username and not session.nick then

                                if not (command == "USER" or command == "NICK") then

                                        module:log("debug", "Client tried to send command %s before registering", command);

                                        return session.send{from=muc_server, "451", command, "You have not completed the registration."}

                                end

                        end

                        if commands[command] then

                                local ret = commands[command](session, parts);

                                if ret then

                                        return session.send(ret);

                                end

                        else

                                session.send{from=muc_server, "421", session.nick, command, "Unknown command"};

                                return module:log("debug", "Unknown command: %s", command);

                        end

                end

                function session.send(data)

                        if type(data) == "string" then

                                return conn:write(data.."\r\n");

                        elseif type(data) == "table" then

                                local line = build_line(data);

                                module:log("debug", line);

                                conn:write(line.."\r\n");

                        end

                end

        end

        if data then

                session.data(data);

        end

end

function irc_listener.ondisconnect(conn, error)

        local session = sessions[conn];

        if session then

                for _, room in pairs(session.rooms) do

                        room:leave("Disconnected");

                end

                if session.nick then

                        nicks[session.nick] = nil;

                end

                if session.full_jid then

                        jids[session.full_jid] = nil;

                end

                if session.username then

                        usernames[session.username] = nil;

                end

        end

        sessions[conn] = nil;

end

local function nick_inuse(nick)

        if nicks[nick] then return true else return false end

end

local function check_username(un)

        local count = 0;

        local result;

        for name, given in pairs(usernames) do

                if un == given then count = count + 1; end

        end

        result = count + 1;

        if count > 0 then return tostring(un)..tostring(result); else return tostring(un); end

end

local function set_t_data(session, full_jid)

        session.full_jid = full_jid;

        jids[full_jid] = session;

        jids[full_jid]["ar_last"] = {};

        jids[full_jid]["nicks_changing"] = {};

        if session.nick then nicks[session.nick] = session; end

end

local function send_motd(session)

        local nick = session.nick;

        if session.username and session.nick then -- send MOTD only if username and nick are set

                session.send{from = muc_server, "001", nick, "Welcome in the IRC to MUC XMPP Gateway, "..nick};

                session.send{from = muc_server, "002", nick, "Your host is "..muc_server.." running Prosody "..prosody.version};

                session.send{from = muc_server, "003", nick, "This server was created the "..os.date(nil, prosody.start_time)}

                session.send{from = muc_server, "004", nick, table.concat({muc_server, "mod_ircd(alpha-0.8)", "i", "aoqv"}, " ")};

                session.send((":%s %s %s %s :%s"):format(muc_server, "005", nick, "CHANTYPES=# PREFIX=(qaov)~&@+", "are supported by this server"));

                session.send((":%s %s %s %s :%s"):format(muc_server, "005", nick, "STATUSMSG=~&@+", "are supported by this server"));

                session.send{from = muc_server, "375", nick, "- "..muc_server.." Message of the day -"};

                session.send{from = muc_server, "372", nick, "-"};

                session.send{from = muc_server, "372", nick, "- Please be warned that this is only a partial irc implementation,"};

                session.send{from = muc_server, "372", nick, "- it's made to facilitate users transiting away from irc to XMPP."};

                session.send{from = muc_server, "372", nick, "-"};

                session.send{from = muc_server, "372", nick, "- Prosody is _NOT_ an IRC Server and it never will."};

                session.send{from = muc_server, "372", nick, "- We also would like to remind you that this plugin is provided as is,"};

                session.send{from = muc_server, "372", nick, "- it's still an Alpha and it's still a work in progress, use it at your sole"};

                session.send{from = muc_server, "372", nick, "- risk as there's a not so little chance something will break."};

                session.send{from = nick, "MODE", nick, "+i"};  -- why -> Invisible mode setting,

        end                                                     --        enforce by default on most servers (since the source host doesn't show it's sensible to have it "set")

end

function commands.NICK(session, args)

        local nick = args[1];

        nick = nick:gsub("[^%w_]","");

        if session.nick and not nick_inuse(nick) then -- changing nick

                local oldnick = session.nick;

                -- update and replace session data

                session.nick = nick;

                nicks[oldnick] = nil;

                nicks[nick] = session;

                session.send{from=oldnick.."!"..nicks[nick].username, "NICK", nick};

                -- broadcast changes if required

                if session.rooms then

                        session.nicks_changing[nick] = { oldnick, session.username };

                        for id, room in pairs(session.rooms) do room:change_nick(nick); end

                        session.nicks_changing[nick] = nil;

                end

                return;

        elseif nick_inuse(nick) then

                session.send{from=muc_server, "433", nick, "The nickname "..nick.." is already in use"}; return;

        end

        session.nick = nick;

        session.type = "c2s";

        nicks[nick] = session;

        -- Some choppy clients send in NICK before USER, that needs to be handled

        if session.username then

                set_t_data(session, jid.join(session.username, component_jid, "ircd"));

        end

        send_motd(session);

end

function commands.USER(session, params)

        local username = params[1];

        if not session.has_un then

                local un_checked = check_username(username);

                usernames[un_checked] = username;

                session.username = un_checked;

                session.has_un = true;

                if not session.full_jid then

                        set_t_data(session, jid.join(session.username, component_jid, "ircd"));

                end

        else

                return session.send{from=muc_server, "462", "USER", "You may not re-register."}

        end

        send_motd(session);

end

function commands.USERHOST(session, params) -- can show only users on the gateway. Needed for some clients to determinate self hostmask.

        local nick = params[1];

        if not nick then session.send{from=muc_server, "461", "USERHOST", "Not enough parameters"}; return; end

        if nicks[nick] and nicks[nick].nick and nicks[nick].username then

                session.send{from=muc_server, "302", session.nick, nick.."=+"..nicks[nick].username}; return;

        else

                return;

        end

end

local function mode_map(am, rm, nicks)

        local rnick;

        local c_modes;

        c_modes = aff_modemap[am]..role_modemap[rm]

        rnick = string.rep(nicks.." ", c_modes:len())

        if c_modes == "" then return nil, nil end

        return c_modes, rnick

end

function commands.JOIN(session, args)

        local channel = args[1];