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 = 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 jid ~= "pending" 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 function load_roster(username, host)
  83         local jid = username.."@"..host;
  84         log("debug", "load_roster: asked for: %s", jid);
  85         local user = bare_sessions[jid];
  86         local roster;
  87         if user then
  88                 roster = user.roster;
  89                 if roster then return roster; end
  90                 log("debug", "load_roster: loading for new user: %s@%s", username, host);
  91         else -- Attempt to load roster for non-loaded user
  92                 log("debug", "load_roster: loading for offline user: %s@%s", username, host);
  93         end
  94         local data, err = datamanager.load(username, host, "roster");
  95         roster = data or {};
  96         if user then user.roster = roster; end
  97         if not roster[false] then roster[false] = { broken = err or nil }; end
  98         if roster[jid] then
  99                 roster[jid] = nil;
 100                 log("warn", "roster for %s has a self-contact", jid);
 101         end
 102         if not err then
 103                 hosts[host].events.fire_event("roster-load", username, host, roster);
 104         end
 105         return roster, err;
 106 end
 107
 108 function save_roster(username, host, roster)
 109         if not um_user_exists(username, host) then
 110                 log("debug", "not saving roster for %s@%s: the user doesn't exist", username, host);
 111                 return nil;
 112         end
 113
 114         log("debug", "save_roster: saving roster for %s@%s", username, host);
 115         if not roster then
 116                 roster = hosts[host] and hosts[host].sessions[username] and hosts[host].sessions[username].roster;
 117                 --if not roster then
 118                 --      --roster = load_roster(username, host);
 119                 --      return true; -- roster unchanged, no reason to save
 120                 --end
 121         end
 122         if roster then
 123                 local metadata = roster[false];
 124                 if not metadata then
 125                         metadata = {};
 126                         roster[false] = metadata;
 127                 end
 128                 if metadata.version ~= true then
 129                         metadata.version = (metadata.version or 0) + 1;
 130                 end
 131                 if roster[false].broken then return nil, "Not saving broken roster" end
 132                 return datamanager.store(username, host, "roster", roster);
 133         end
 134         log("warn", "save_roster: user had no roster to save");
 135         return nil;
 136 end
 137
 138 function process_inbound_subscription_approval(username, host, jid)
 139         local roster = load_roster(username, host);
 140         local item = roster[jid];
 141         if item and item.ask then
 142                 if item.subscription == "none" then
 143                         item.subscription = "to";
 144                 else -- subscription == from
 145                         item.subscription = "both";
 146                 end
 147                 item.ask = nil;
 148                 return save_roster(username, host, roster);
 149         end
 150 end
 151
 152 function process_inbound_subscription_cancellation(username, host, jid)
 153         local roster = load_roster(username, host);
 154         local item = roster[jid];
 155         local changed = nil;
 156         if is_contact_pending_out(username, host, jid) then
 157                 item.ask = nil;
 158                 changed = true;
 159         end
 160         if item then
 161                 if item.subscription == "to" then
 162                         item.subscription = "none";
 163                         changed = true;
 164                 elseif item.subscription == "both" then
 165                         item.subscription = "from";
 166                         changed = true;
 167                 end
 168         end
 169         if changed then
 170                 return save_roster(username, host, roster);
 171         end
 172 end
 173
 174 function process_inbound_unsubscribe(username, host, jid)
 175         local roster = load_roster(username, host);
 176         local item = roster[jid];
 177         local changed = nil;
 178         if is_contact_pending_in(username, host, jid) then
 179                 roster.pending[jid] = nil; -- TODO maybe delete roster.pending if empty?
 180                 changed = true;
 181         end
 182         if item then
 183                 if item.subscription == "from" then
 184                         item.subscription = "none";
 185                         changed = true;
 186                 elseif item.subscription == "both" then
 187                         item.subscription = "to";
 188                         changed = true;
 189                 end
 190         end
 191         if changed then
 192                 return save_roster(username, host, roster);
 193         end
 194 end
 195
 196 local function _get_online_roster_subscription(jidA, jidB)
 197         local user = bare_sessions[jidA];
 198         local item = user and (user.roster[jidB] or { subscription = "none" });
 199         return item and item.subscription;
 200 end
 201 function is_contact_subscribed(username, host, jid)
 202         do
 203                 local selfjid = username.."@"..host;
 204                 local subscription = _get_online_roster_subscription(selfjid, jid);
 205                 if subscription then return (subscription == "both" or subscription == "from"); end
 206                 local subscription = _get_online_roster_subscription(jid, selfjid);
 207                 if subscription then return (subscription == "both" or subscription == "to"); end
 208         end
 209         local roster, err = load_roster(username, host);
 210         local item = roster[jid];
 211         return item and (item.subscription == "from" or item.subscription == "both"), err;
 212 end
 213
 214 function is_contact_pending_in(username, host, jid)
 215         local roster = load_roster(username, host);
 216         return roster.pending and roster.pending[jid];
 217 end
 218 function set_contact_pending_in(username, host, jid, pending)
 219         local roster = load_roster(username, host);
 220         local item = roster[jid];
 221         if item and (item.subscription == "from" or item.subscription == "both") then
 222                 return; -- false
 223         end
 224         if not roster.pending then roster.pending = {}; end
 225         roster.pending[jid] = true;
 226         return save_roster(username, host, roster);
 227 end
 228 function is_contact_pending_out(username, host, jid)
 229         local roster = load_roster(username, host);
 230         local item = roster[jid];
 231         return item and item.ask;
 232 end
 233 function set_contact_pending_out(username, host, jid) -- subscribe
 234         local roster = load_roster(username, host);
 235         local item = roster[jid];
 236         if item and (item.ask or item.subscription == "to" or item.subscription == "both") then
 237                 return true;
 238         end
 239         if not item then
 240                 item = {subscription = "none", groups = {}};
 241                 roster[jid] = item;
 242         end
 243         item.ask = "subscribe";
 244         log("debug", "set_contact_pending_out: saving roster; set %s@%s.roster[%q].ask=subscribe", username, host, jid);
 245         return save_roster(username, host, roster);
 246 end
 247 function unsubscribe(username, host, jid)
 248         local roster = load_roster(username, host);
 249         local item = roster[jid];
 250         if not item then return false; end
 251         if (item.subscription == "from" or item.subscription == "none") and not item.ask then
 252                 return true;
 253         end
 254         item.ask = nil;
 255         if item.subscription == "both" then
 256                 item.subscription = "from";
 257         elseif item.subscription == "to" then
 258                 item.subscription = "none";
 259         end
 260         return save_roster(username, host, roster);
 261 end
 262 function subscribed(username, host, jid)
 263         if is_contact_pending_in(username, host, jid) then
 264                 local roster = load_roster(username, host);
 265                 local item = roster[jid];
 266                 if not item then -- FIXME should roster item be auto-created?
 267                         item = {subscription = "none", groups = {}};
 268                         roster[jid] = item;
 269                 end
 270                 if item.subscription == "none" then
 271                         item.subscription = "from";
 272                 else -- subscription == to
 273                         item.subscription = "both";
 274                 end
 275                 roster.pending[jid] = nil;
 276                 -- TODO maybe remove roster.pending if empty
 277                 return save_roster(username, host, roster);
 278         end -- TODO else implement optional feature pre-approval (ask = subscribed)
 279 end
 280 function unsubscribed(username, host, jid)
 281         local roster = load_roster(username, host);
 282         local item = roster[jid];
 283         local pending = is_contact_pending_in(username, host, jid);
 284         if pending then
 285                 roster.pending[jid] = nil; -- TODO maybe delete roster.pending if empty?
 286         end
 287         local subscribed;
 288         if item then
 289                 if item.subscription == "from" then
 290                         item.subscription = "none";
 291                         subscribed = true;
 292                 elseif item.subscription == "both" then
 293                         item.subscription = "to";
 294                         subscribed = true;
 295                 end
 296         end
 297         local success = (pending or subscribed) and save_roster(username, host, roster);
 298         return success, pending, subscribed;
 299 end
 300
 301 function process_outbound_subscription_request(username, host, jid)
 302         local roster = load_roster(username, host);
 303         local item = roster[jid];
 304         if item and (item.subscription == "none" or item.subscription == "from") then
 305                 item.ask = "subscribe";
 306                 return save_roster(username, host, roster);
 307         end
 308 end
 309
 310 --[[function process_outbound_subscription_approval(username, host, jid)
 311         local roster = load_roster(username, host);
 312         local item = roster[jid];
 313         if item and (item.subscription == "none" or item.subscription == "from" then
 314                 item.ask = "subscribe";
 315                 return save_roster(username, host, roster);
 316         end
 317 end]]
 318
 319
 320
 321 return _M;