core/rostermanager.lua

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