plugins/OStatus/classes/FeedSub.php

   1 <?php
   2 /*
   3  * StatusNet - the distributed open-source microblogging tool
   4  * Copyright (C) 2009-2010, StatusNet, Inc.
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Affero General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 if (!defined('STATUSNET')) {
  21     exit(1);
  22 }
  23
  24 /**
  25  * @package OStatusPlugin
  26  * @maintainer Brion Vibber <brion@status.net>
  27  */
  28
  29 /*
  30 PuSH subscription flow:
  31
  32     $profile->subscribe()
  33         sends a sub request to the hub...
  34
  35     main/push/callback
  36         hub sends confirmation back to us via GET
  37         We verify the request, then echo back the challenge.
  38         On our end, we save the time we subscribed and the lease expiration
  39
  40     main/push/callback
  41         hub sends us updates via POST
  42
  43 */
  44 class FeedDBException extends FeedSubException
  45 {
  46     public $obj;
  47
  48     function __construct($obj)
  49     {
  50         parent::__construct('Database insert failure');
  51         $this->obj = $obj;
  52     }
  53 }
  54
  55 /**
  56  * FeedSub handles low-level PubHubSubbub (PuSH) subscriptions.
  57  * Higher-level behavior building OStatus stuff on top is handled
  58  * under Ostatus_profile.
  59  */
  60 class FeedSub extends Managed_DataObject
  61 {
  62     public $__table = 'feedsub';
  63
  64     public $id;
  65     public $uri;
  66
  67     // PuSH subscription data
  68     public $huburi;
  69     public $secret;
  70     public $sub_state; // subscribe, active, unsubscribe, inactive, nohub
  71     public $sub_start;
  72     public $sub_end;
  73     public $last_update;
  74
  75     public $created;
  76     public $modified;
  77
  78     public static function schemaDef()
  79     {
  80         return array(
  81             'fields' => array(
  82                 'id' => array('type' => 'serial', 'not null' => true, 'description' => 'FeedSub local unique id'),
  83                 'uri' => array('type' => 'varchar', 'not null' => true, 'length' => 255, 'description' => 'FeedSub uri'),
  84                 'huburi' => array('type' => 'text', 'description' => 'FeedSub hub-uri'),
  85                 'secret' => array('type' => 'text', 'description' => 'FeedSub stored secret'),
  86                 'sub_state' => array('type' => 'enum("subscribe","active","unsubscribe","inactive","nohub")', 'not null' => true, 'description' => 'subscription state'),
  87                 'sub_start' => array('type' => 'datetime', 'description' => 'subscription start'),
  88                 'sub_end' => array('type' => 'datetime', 'description' => 'subscription end'),
  89                 'last_update' => array('type' => 'datetime', 'not null' => true, 'description' => 'when this record was last updated'),
  90                 'created' => array('type' => 'datetime', 'not null' => true, 'description' => 'date this record was created'),
  91                 'modified' => array('type' => 'timestamp', 'not null' => true, 'description' => 'date this record was modified'),
  92             ),
  93             'primary key' => array('id'),
  94             'unique keys' => array(
  95                 'feedsub_uri_key' => array('uri'),
  96             ),
  97         );
  98     }
  99
 100     /**
 101      * Get the feed uri (http/https)
 102      */
 103     public function getUri()
 104     {
 105         if (empty($this->uri)) {
 106             throw new ServerException('No URI for FeedSub entry');
 107         }
 108         return $this->uri;
 109     }
 110
 111     /**
 112      * Do we have a hub? Then we are a PuSH feed.
 113      * https://en.wikipedia.org/wiki/PubSubHubbub
 114      *
 115      * If huburi is empty, then doublecheck that we are not using
 116      * a fallback hub. If there is a fallback hub, it is only if the
 117      * sub_state is "nohub" that we assume it's not a PuSH feed.
 118      */
 119     public function isPuSH()
 120     {
 121         if (empty($this->huburi)
 122                 && (!common_config('feedsub', 'fallback_hub')
 123                     || $this->sub_state === 'nohub')) {
 124                 // Here we have no huburi set. Also, either there is no
 125                 // fallback hub configured or sub_state is "nohub".
 126             return false;
 127         }
 128         return true;
 129     }
 130
 131     /**
 132      * Fetch the StatusNet-side profile for this feed
 133      * @return Profile
 134      */
 135     public function localProfile()
 136     {
 137         if ($this->profile_id) {
 138             return Profile::getKV('id', $this->profile_id);
 139         }
 140         return null;
 141     }
 142
 143     /**
 144      * Fetch the StatusNet-side profile for this feed
 145      * @return Profile
 146      */
 147     public function localGroup()
 148     {
 149         if ($this->group_id) {
 150             return User_group::getKV('id', $this->group_id);
 151         }
 152         return null;
 153     }
 154
 155     /**
 156      * @param string $feeduri
 157      * @return FeedSub
 158      * @throws FeedSubException if feed is invalid or lacks PuSH setup
 159      */
 160     public static function ensureFeed($feeduri)
 161     {
 162         $current = self::getKV('uri', $feeduri);
 163         if ($current instanceof FeedSub) {
 164             return $current;
 165         }
 166
 167         $discover = new FeedDiscovery();
 168         $discover->discoverFromFeedURL($feeduri);
 169
 170         $huburi = $discover->getHubLink();
 171         if (!$huburi && !common_config('feedsub', 'fallback_hub')) {
 172             throw new FeedSubNoHubException();
 173         }
 174
 175         $feedsub = new FeedSub();
 176         $feedsub->uri = $feeduri;
 177         $feedsub->huburi = $huburi;
 178         $feedsub->sub_state = 'inactive';
 179
 180         $feedsub->created = common_sql_now();
 181         $feedsub->modified = common_sql_now();
 182
 183         $result = $feedsub->insert();
 184         if ($result === false) {
 185             throw new FeedDBException($feedsub);
 186         }
 187
 188         return $feedsub;
 189     }
 190
 191     /**
 192      * Send a subscription request to the hub for this feed.
 193      * The hub will later send us a confirmation POST to /main/push/callback.
 194      *
 195      * @return void
 196      * @throws ServerException if feed state is not valid
 197      */
 198     public function subscribe()
 199     {
 200         if ($this->sub_state && $this->sub_state != 'inactive') {
 201             common_log(LOG_WARNING, sprintf('Attempting to (re)start PuSH subscription to %s in unexpected state %s', $this->getUri(), $this->sub_state));
 202         }
 203
 204         if (!Event::handle('FeedSubscribe', array($this))) {
 205             // A plugin handled it
 206             return;
 207         }
 208
 209         if (empty($this->huburi)) {
 210             if (common_config('feedsub', 'fallback_hub')) {
 211                 // No native hub on this feed?
 212                 // Use our fallback hub, which handles polling on our behalf.
 213             } else if (common_config('feedsub', 'nohub')) {
 214                 // Fake it! We're just testing remote feeds w/o hubs.
 215                 // We'll never actually get updates in this mode.
 216                 return;
 217             } else {
 218                 // TRANS: Server exception.
 219                 throw new ServerException(_m('Attempting to start PuSH subscription for feed with no hub.'));
 220             }
 221         }
 222
 223         $this->doSubscribe('subscribe');
 224     }
 225
 226     /**
 227      * Send a PuSH unsubscription request to the hub for this feed.
 228      * The hub will later send us a confirmation POST to /main/push/callback.
 229      * Warning: this will cancel the subscription even if someone else in
 230      * the system is using it. Most callers will want garbageCollect() instead,
 231      * which confirms there's no uses left.
 232      *
 233      * @throws ServerException if feed state is not valid
 234      */
 235     public function unsubscribe() {
 236         if ($this->sub_state != 'active') {
 237             common_log(LOG_WARNING, sprintf('Attempting to (re)end PuSH subscription to %s in unexpected state %s', $this->getUri(), $this->sub_state));
 238         }
 239
 240         if (!Event::handle('FeedUnsubscribe', array($this))) {
 241             // A plugin handled it
 242             return;
 243         }
 244
 245         if (empty($this->huburi)) {
 246             if (common_config('feedsub', 'fallback_hub')) {
 247                 // No native hub on this feed?
 248                 // Use our fallback hub, which handles polling on our behalf.
 249             } else if (common_config('feedsub', 'nohub')) {
 250                 // Fake it! We're just testing remote feeds w/o hubs.
 251                 // We'll never actually get updates in this mode.
 252                 return;
 253             } else {
 254                 // TRANS: Server exception.
 255                 throw new ServerException(_m('Attempting to end PuSH subscription for feed with no hub.'));
 256             }
 257         }
 258
 259         $this->doSubscribe('unsubscribe');
 260     }
 261
 262     /**
 263      * Check if there are any active local uses of this feed, and if not then
 264      * make sure it's inactive, unsubscribing if necessary.
 265      *
 266      * @return boolean true if the subscription is now inactive, false if still active.
 267      * @throws Exception if something goes wrong in unsubscribe() method
 268      */
 269     public function garbageCollect()
 270     {
 271         if ($this->sub_state == '' || $this->sub_state == 'inactive') {
 272             // No active PuSH subscription, we can just leave it be.
 273             return true;
 274         } else {
 275             // PuSH subscription is either active or in an indeterminate state.
 276             // Check if we're out of subscribers, and if so send an unsubscribe.
 277             $count = 0;
 278             Event::handle('FeedSubSubscriberCount', array($this, &$count));
 279
 280             if ($count > 0) {
 281                 common_log(LOG_INFO, __METHOD__ . ': ok, ' . $count . ' user(s) left for ' . $this->getUri());
 282                 return false;
 283             } else {
 284                 common_log(LOG_INFO, __METHOD__ . ': unsubscribing, no users left for ' . $this->getUri());
 285                 // Unsubscribe throws various Exceptions on failure
 286                 $this->unsubscribe();
 287                 return true;
 288             }
 289         }
 290     }
 291
 292     static public function renewalCheck()
 293     {
 294         $fs = new FeedSub();
 295         // the "" empty string check is because we historically haven't saved unsubscribed feeds as NULL
 296         $fs->whereAdd('sub_end IS NOT NULL AND sub_end!="" AND sub_end < NOW() - INTERVAL 1 day');
 297         if (!$fs->find()) { // find can be both false and 0, depending on why nothing was found
 298             throw new NoResultException($fs);
 299         }
 300         return $fs;
 301     }
 302
 303     public function renew()
 304     {
 305         $this->subscribe();
 306     }
 307
 308     /**
 309      * Setting to subscribe means it is _waiting_ to become active. This
 310      * cannot be done in a transaction because there is a chance that the
 311      * remote script we're calling (as in the case of PuSHpress) performs
 312      * the lookup _while_ we're POSTing data, which means the transaction
 313      * never completes (PushcallbackAction gets an 'inactive' state).
 314      *
 315      * @return boolean true when everything is ok (throws Exception on fail)
 316      * @throws Exception on failure, can be HTTPClient's or our own.
 317      */
 318     protected function doSubscribe($mode)
 319     {
 320         $orig = clone($this);
 321         if ($mode == 'subscribe') {
 322             $this->secret = common_random_hexstr(32);
 323         }
 324         $this->sub_state = $mode;
 325         $this->update($orig);
 326         unset($orig);
 327
 328         try {
 329             $callback = common_local_url('pushcallback', array('feed' => $this->id));
 330             $headers = array('Content-Type: application/x-www-form-urlencoded');
 331             $post = array('hub.mode' => $mode,
 332                           'hub.callback' => $callback,
 333                           'hub.verify' => 'async',  // TODO: deprecated, remove when noone uses PuSH <0.4 (only 'async' method used there)
 334                           'hub.verify_token' => 'Deprecated-since-PuSH-0.4', // TODO: rm!
 335
 336                           'hub.secret' => $this->secret,
 337                           'hub.topic' => $this->getUri());
 338             $client = new HTTPClient();
 339             if ($this->huburi) {
 340                 $hub = $this->huburi;
 341             } else {
 342                 if (common_config('feedsub', 'fallback_hub')) {
 343                     $hub = common_config('feedsub', 'fallback_hub');
 344                     if (common_config('feedsub', 'hub_user')) {
 345                         $u = common_config('feedsub', 'hub_user');
 346                         $p = common_config('feedsub', 'hub_pass');
 347                         $client->setAuth($u, $p);
 348                     }
 349                 } else {
 350                     throw new FeedSubException('Server could not find a usable PuSH hub.');
 351                 }
 352             }
 353             $response = $client->post($hub, $headers, $post);
 354             $status = $response->getStatus();
 355             // PuSH specificed response status code
 356             if ($status == 202) {
 357                 common_log(LOG_INFO, __METHOD__ . ': sub req ok, awaiting verification callback');
 358                 return;
 359             } else if ($status >= 200 && $status < 300) {
 360                 common_log(LOG_ERR, __METHOD__ . ": sub req returned unexpected HTTP $status: " . $response->getBody());
 361             } else {
 362                 common_log(LOG_ERR, __METHOD__ . ": sub req failed with HTTP $status: " . $response->getBody());
 363             }
 364         } catch (Exception $e) {
 365             common_log(LOG_ERR, __METHOD__ . ": error \"{$e->getMessage()}\" hitting hub {$this->huburi} subscribing to {$this->getUri()}");
 366
 367             // Reset the subscription state.
 368             $orig = clone($this);
 369             $this->sub_state = 'inactive';
 370             $this->update($orig);
 371
 372             // Throw the Exception again.
 373             throw $e;
 374         }
 375         throw ServerException("{$mode} request failed.");
 376     }
 377
 378     /**
 379      * Save PuSH subscription confirmation.
 380      * Sets approximate lease start and end times and finalizes state.
 381      *
 382      * @param int $lease_seconds provided hub.lease_seconds parameter, if given
 383      */
 384     public function confirmSubscribe($lease_seconds)
 385     {
 386         $original = clone($this);
 387
 388         $this->sub_state = 'active';
 389         $this->sub_start = common_sql_date(time());
 390         if ($lease_seconds > 0) {
 391             $this->sub_end = common_sql_date(time() + $lease_seconds);
 392         } else {
 393             $this->sub_end = null;  // Backwards compatibility to StatusNet (PuSH <0.4 supported permanent subs)
 394         }
 395         $this->modified = common_sql_now();
 396
 397         return $this->update($original);
 398     }
 399
 400     /**
 401      * Save PuSH unsubscription confirmation.
 402      * Wipes active PuSH sub info and resets state.
 403      */
 404     public function confirmUnsubscribe()
 405     {
 406         $original = clone($this);
 407
 408         // @fixme these should all be null, but DB_DataObject doesn't save null values...?????
 409         $this->secret = '';
 410         $this->sub_state = '';
 411         $this->sub_start = '';
 412         $this->sub_end = '';
 413         $this->modified = common_sql_now();
 414
 415         return $this->update($original);
 416     }
 417
 418     /**
 419      * Accept updates from a PuSH feed. If validated, this object and the
 420      * feed (as a DOMDocument) will be passed to the StartFeedSubHandleFeed
 421      * and EndFeedSubHandleFeed events for processing.
 422      *
 423      * Not guaranteed to be running in an immediate POST context; may be run
 424      * from a queue handler.
 425      *
 426      * Side effects: the feedsub record's lastupdate field will be updated
 427      * to the current time (not published time) if we got a legit update.
 428      *
 429      * @param string $post source of Atom or RSS feed
 430      * @param string $hmac X-Hub-Signature header, if present
 431      */
 432     public function receive($post, $hmac)
 433     {
 434         common_log(LOG_INFO, __METHOD__ . ": packet for \"" . $this->getUri() . "\"! $hmac $post");
 435
 436         if ($this->sub_state != 'active') {
 437             common_log(LOG_ERR, __METHOD__ . ": ignoring PuSH for inactive feed " . $this->getUri() . " (in state '$this->sub_state')");
 438             return;
 439         }
 440
 441         if ($post === '') {
 442             common_log(LOG_ERR, __METHOD__ . ": ignoring empty post");
 443             return;
 444         }
 445
 446         if (!$this->validatePushSig($post, $hmac)) {
 447             // Per spec we silently drop input with a bad sig,
 448             // while reporting receipt to the server.
 449             return;
 450         }
 451
 452         $feed = new DOMDocument();
 453         if (!$feed->loadXML($post)) {
 454             // @fixme might help to include the err message
 455             common_log(LOG_ERR, __METHOD__ . ": ignoring invalid XML");
 456             return;
 457         }
 458
 459         $orig = clone($this);
 460         $this->last_update = common_sql_now();
 461         $this->update($orig);
 462
 463         Event::handle('StartFeedSubReceive', array($this, $feed));
 464         Event::handle('EndFeedSubReceive', array($this, $feed));
 465     }
 466
 467     /**
 468      * Validate the given Atom chunk and HMAC signature against our
 469      * shared secret that was set up at subscription time.
 470      *
 471      * If we don't have a shared secret, there should be no signature.
 472      * If we we do, our the calculated HMAC should match theirs.
 473      *
 474      * @param string $post raw XML source as POSTed to us
 475      * @param string $hmac X-Hub-Signature HTTP header value, or empty
 476      * @return boolean true for a match
 477      */
 478     protected function validatePushSig($post, $hmac)
 479     {
 480         if ($this->secret) {
 481             if (preg_match('/^sha1=([0-9a-fA-F]{40})$/', $hmac, $matches)) {
 482                 $their_hmac = strtolower($matches[1]);
 483                 $our_hmac = hash_hmac('sha1', $post, $this->secret);
 484                 if ($their_hmac === $our_hmac) {
 485                     return true;
 486                 }
 487                 if (common_config('feedsub', 'debug')) {
 488                     $tempfile = tempnam(sys_get_temp_dir(), 'feedsub-receive');
 489                     if ($tempfile) {
 490                         file_put_contents($tempfile, $post);
 491                     }
 492                     common_log(LOG_ERR, __METHOD__ . ": ignoring PuSH with bad SHA-1 HMAC: got $their_hmac, expected $our_hmac for feed " . $this->getUri() . " on $this->huburi; saved to $tempfile");
 493                 } else {
 494                     common_log(LOG_ERR, __METHOD__ . ": ignoring PuSH with bad SHA-1 HMAC: got $their_hmac, expected $our_hmac for feed " . $this->getUri() . " on $this->huburi");
 495                 }
 496             } else {
 497                 common_log(LOG_ERR, __METHOD__ . ": ignoring PuSH with bogus HMAC '$hmac'");
 498             }
 499         } else {
 500             if (empty($hmac)) {
 501                 return true;
 502             } else {
 503                 common_log(LOG_ERR, __METHOD__ . ": ignoring PuSH with unexpected HMAC '$hmac'");
 504             }
 505         }
 506         return false;
 507     }
 508 }