core/rostermanager.lua

   1 -- Prosody IM
   2 -- Copyright (C) 2008-2009 Matthew Wild
   3 -- Copyright (C) 2008-2009 Waqas Hussain
   4 --
   5 -- This project is MIT/X11 licensed. Please see the
   6 -- COPYING file in the source package for more information.
   7 --
   8
   9
  10
  11
  12 local log = require "util.logger".init("rostermanager");
  13
  14 local setmetatable = setmetatable;
  15 local format = string.format;
  16 local loadfile, setfenv, pcall = loadfile, setfenv, pcall;
  17 local pairs, ipairs = pairs, ipairs;
  18 local tostring = tostring;
  19
  20 local hosts = hosts;
  21
  22 local datamanager = require "util.datamanager"
  23 local st = require "util.stanza";
  24
  25 module "rostermanager"
  26
  27 function add_to_roster(session, jid, item)
  28         if session.roster then
  29                 local old_item = session.roster[jid];
  30                 session.roster[jid] = item;
  31                 if save_roster(session.username, session.host) then
  32                         return true;
  33                 else
  34                         session.roster[jid] = old_item;
  35                         return nil, "wait", "internal-server-error", "Unable to save roster";
  36                 end
  37         else
  38                 return nil, "auth", "not-authorized", "Session's roster not loaded";
  39         end
  40 end
  41
  42 function remove_from_roster(session, jid)
  43         if session.roster then
  44                 local old_item = session.roster[jid];
  45                 session.roster[jid] = nil;
  46                 if save_roster(session.username, session.host) then
  47                         return true;
  48                 else
  49                         session.roster[jid] = old_item;
  50                         return nil, "wait", "internal-server-error", "Unable to save roster";
  51                 end
  52         else
  53                 return nil, "auth", "not-authorized", "Session's roster not loaded";
  54         end
  55 end
  56
  57 function roster_push(username, host, jid)
  58         local roster = jid and jid ~= "pending" and hosts[host] and hosts[host].sessions[username] and hosts[host].sessions[username].roster;
  59         if roster then
  60                 local item = hosts[host].sessions[username].roster[jid];
  61                 local stanza = st.iq({type="set"});
  62                 stanza:tag("query", {xmlns = "jabber:iq:roster", ver = tostring(roster[false].version or "1")  });
  63                 if item then
  64                         stanza:tag("item", {jid = jid, subscription = item.subscription, name = item.name, ask = item.ask});
  65                         for group in pairs(item.groups) do
  66                                 stanza:tag("group"):text(group):up();
  67                         end
  68                 else
  69                         stanza:tag("item", {jid = jid, subscription = "remove"});
  70                 end
  71                 stanza:up(); -- move out from item
  72                 stanza:up(); -- move out from stanza
  73                 -- stanza ready
  74                 for _, session in pairs(hosts[host].sessions[username].sessions) do
  75                         if session.interested then
  76                                 -- FIXME do we need to set stanza.attr.to?
  77                                 session.send(stanza);
  78                         end
  79                 end
  80         end
  81 end
  82
  83 function load_roster(username, host)
  84         local jid = username.."@"..host;
  85         log("debug", "load_roster: asked for: "..jid);
  86         local user = bare_sessions[jid];
  87         local roster;
  88         if user then
  89                 roster = user.roster;
  90                 if roster then return roster; end
  91                 log("debug", "load_roster: loading for new user: "..username.."@"..host);
  92         else -- Attempt to load roster for non-loaded user
  93                 log("debug", "load_roster: loading for offline user: "..username.."@"..host);
  94         end
  95         roster = datamanager.load(username, host, "roster") or {};
  96         if user then user.roster = roster; end
  97         if not roster[false] then roster[false] = { }; end
  98         if roster[jid] then
  99                 roster[jid] = nil;
 100                 log("warn", "roster for "..jid.." has a self-contact");
 101         end
 102         hosts[host].events.fire_event("roster-load", username, host, roster);
 103         return roster;
 104 end
 105
 106 function save_roster(username, host, roster)
 107         log("debug", "save_roster: saving roster for "..username.."@"..host);
 108         if not roster then
 109                 roster = hosts[host] and hosts[host].sessions[username] and hosts[host].sessions[username].roster;
 110                 --if not roster then
 111                 --      --roster = load_roster(username, host);
 112                 --      return true; -- roster unchanged, no reason to save
 113                 --end
 114         end
 115         if roster then
 116                 if not roster[false] then roster[false] = {}; end
 117                 roster[false].version = (roster[false].version or 0) + 1;
 118                 return datamanager.store(username, host, "roster", roster);
 119         end
 120         log("warn", "save_roster: user had no roster to save");
 121         return nil;
 122 end
 123
 124 function process_inbound_subscription_approval(username, host, jid)
 125         local roster = load_roster(username, host);
 126         local item = roster[jid];
 127         if item and item.ask then
 128                 if item.subscription == "none" then
 129                         item.subscription = "to";
 130                 else -- subscription == from
 131                         item.subscription = "both";
 132                 end
 133                 item.ask = nil;
 134                 return save_roster(username, host, roster);
 135         end
 136 end
 137
 138 function process_inbound_subscription_cancellation(username, host, jid)
 139         local roster = load_roster(username, host);
 140         local item = roster[jid];
 141         local changed = nil;
 142         if is_contact_pending_out(username, host, jid) then
 143                 item.ask = nil;
 144                 changed = true;
 145         end
 146         if item then
 147                 if item.subscription == "to" then
 148                         item.subscription = "none";
 149                         changed = true;
 150                 elseif item.subscription == "both" then
 151                         item.subscription = "from";
 152                         changed = true;
 153                 end
 154         end
 155         if changed then
 156                 return save_roster(username, host, roster);
 157         end
 158 end
 159
 160 function process_inbound_unsubscribe(username, host, jid)
 161         local roster = load_roster(username, host);
 162         local item = roster[jid];
 163         local changed = nil;
 164         if is_contact_pending_in(username, host, jid) then
 165                 roster.pending[jid] = nil; -- TODO maybe delete roster.pending if empty?
 166                 changed = true;
 167         end
 168         if item then
 169                 if item.subscription == "from" then
 170                         item.subscription = "none";
 171                         changed = true;
 172                 elseif item.subscription == "both" then
 173                         item.subscription = "to";
 174                         changed = true;
 175                 end
 176         end
 177         if changed then
 178                 return save_roster(username, host, roster);
 179         end
 180 end
 181
 182 function is_contact_subscribed(username, host, jid)
 183         local roster = load_roster(username, host);
 184         local item = roster[jid];
 185         return item and (item.subscription == "from" or item.subscription == "both");
 186 end
 187
 188 function is_contact_pending_in(username, host, jid)
 189         local roster = load_roster(username, host);
 190         return roster.pending and roster.pending[jid];
 191 end
 192 function set_contact_pending_in(username, host, jid, pending)
 193         local roster = load_roster(username, host);
 194         local item = roster[jid];
 195         if item and (item.subscription == "from" or item.subscription == "both") then
 196                 return; -- false
 197         end
 198         if not roster.pending then roster.pending = {}; end
 199         roster.pending[jid] = true;
 200         return save_roster(username, host, roster);
 201 end
 202 function is_contact_pending_out(username, host, jid)
 203         local roster = load_roster(username, host);
 204         local item = roster[jid];
 205         return item and item.ask;
 206 end
 207 function set_contact_pending_out(username, host, jid) -- subscribe
 208         local roster = load_roster(username, host);
 209         local item = roster[jid];
 210         if item and (item.ask or item.subscription == "to" or item.subscription == "both") then
 211                 return true;
 212         end
 213         if not item then
 214                 item = {subscription = "none", groups = {}};
 215                 roster[jid] = item;
 216         end
 217         item.ask = "subscribe";
 218         log("debug", "set_contact_pending_out: saving roster; set "..username.."@"..host..".roster["..jid.."].ask=subscribe");
 219         return save_roster(username, host, roster);
 220 end
 221 function unsubscribe(username, host, jid)
 222         local roster = load_roster(username, host);
 223         local item = roster[jid];
 224         if not item then return false; end
 225         if (item.subscription == "from" or item.subscription == "none") and not item.ask then
 226                 return true;
 227         end
 228         item.ask = nil;
 229         if item.subscription == "both" then
 230                 item.subscription = "from";
 231         elseif item.subscription == "to" then
 232                 item.subscription = "none";
 233         end
 234         return save_roster(username, host, roster);
 235 end
 236 function subscribed(username, host, jid)
 237         if is_contact_pending_in(username, host, jid) then
 238                 local roster = load_roster(username, host);
 239                 local item = roster[jid];
 240                 if not item then -- FIXME should roster item be auto-created?
 241                         item = {subscription = "none", groups = {}};
 242                         roster[jid] = item;
 243                 end
 244                 if item.subscription == "none" then
 245                         item.subscription = "from";
 246                 else -- subscription == to
 247                         item.subscription = "both";
 248                 end
 249                 roster.pending[jid] = nil;
 250                 -- TODO maybe remove roster.pending if empty
 251                 return save_roster(username, host, roster);
 252         end -- TODO else implement optional feature pre-approval (ask = subscribed)
 253 end
 254 function unsubscribed(username, host, jid)
 255         local roster = load_roster(username, host);
 256         local item = roster[jid];
 257         local pending = is_contact_pending_in(username, host, jid);
 258         local changed = nil;
 259         if is_contact_pending_in(username, host, jid) then
 260                 roster.pending[jid] = nil; -- TODO maybe delete roster.pending if empty?
 261                 changed = true;
 262         end
 263         if item then
 264                 if item.subscription == "from" then
 265                         item.subscription = "none";
 266                         changed = true;
 267                 elseif item.subscription == "both" then
 268                         item.subscription = "to";
 269                         changed = true;
 270                 end
 271         end
 272         if changed then
 273                 return save_roster(username, host, roster);
 274         end
 275 end
 276
 277 function process_outbound_subscription_request(username, host, jid)
 278         local roster = load_roster(username, host);
 279         local item = roster[jid];
 280         if item and (item.subscription == "none" or item.subscription == "from") then
 281                 item.ask = "subscribe";
 282                 return save_roster(username, host, roster);
 283         end
 284 end
 285
 286 --[[function process_outbound_subscription_approval(username, host, jid)
 287         local roster = load_roster(username, host);
 288         local item = roster[jid];
 289         if item and (item.subscription == "none" or item.subscription == "from" then
 290                 item.ask = "subscribe";
 291                 return save_roster(username, host, roster);
 292         end
 293 end]]
 294
 295
 296
 297 return _M;