plugins/OStatus/classes/Ostatus_profile.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 /**
  21  * @package OStatusPlugin
  22  * @maintainer Brion Vibber <brion@status.net>
  23  */
  24
  25 class Ostatus_profile extends Memcached_DataObject
  26 {
  27     public $__table = 'ostatus_profile';
  28
  29     public $uri;
  30
  31     public $profile_id;
  32     public $group_id;
  33
  34     public $feeduri;
  35     public $salmonuri;
  36     public $avatar; // remote URL of the last avatar we saved
  37
  38     public $created;
  39     public $modified;
  40
  41     public /*static*/ function staticGet($k, $v=null)
  42     {
  43         return parent::staticGet(__CLASS__, $k, $v);
  44     }
  45
  46     /**
  47      * return table definition for DB_DataObject
  48      *
  49      * DB_DataObject needs to know something about the table to manipulate
  50      * instances. This method provides all the DB_DataObject needs to know.
  51      *
  52      * @return array array of column definitions
  53      */
  54
  55     function table()
  56     {
  57         return array('uri' => DB_DATAOBJECT_STR + DB_DATAOBJECT_NOTNULL,
  58                      'profile_id' => DB_DATAOBJECT_INT,
  59                      'group_id' => DB_DATAOBJECT_INT,
  60                      'feeduri' => DB_DATAOBJECT_STR,
  61                      'salmonuri' =>  DB_DATAOBJECT_STR,
  62                      'avatar' =>  DB_DATAOBJECT_STR,
  63                      'created' => DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME + DB_DATAOBJECT_NOTNULL,
  64                      'modified' => DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME + DB_DATAOBJECT_NOTNULL);
  65     }
  66
  67     static function schemaDef()
  68     {
  69         return array(new ColumnDef('uri', 'varchar',
  70                                    255, false, 'PRI'),
  71                      new ColumnDef('profile_id', 'integer',
  72                                    null, true, 'UNI'),
  73                      new ColumnDef('group_id', 'integer',
  74                                    null, true, 'UNI'),
  75                      new ColumnDef('feeduri', 'varchar',
  76                                    255, true, 'UNI'),
  77                      new ColumnDef('salmonuri', 'text',
  78                                    null, true),
  79                      new ColumnDef('avatar', 'text',
  80                                    null, true),
  81                      new ColumnDef('created', 'datetime',
  82                                    null, false),
  83                      new ColumnDef('modified', 'datetime',
  84                                    null, false));
  85     }
  86
  87     /**
  88      * return key definitions for DB_DataObject
  89      *
  90      * DB_DataObject needs to know about keys that the table has; this function
  91      * defines them.
  92      *
  93      * @return array key definitions
  94      */
  95
  96     function keys()
  97     {
  98         return array_keys($this->keyTypes());
  99     }
 100
 101     /**
 102      * return key definitions for Memcached_DataObject
 103      *
 104      * Our caching system uses the same key definitions, but uses a different
 105      * method to get them.
 106      *
 107      * @return array key definitions
 108      */
 109
 110     function keyTypes()
 111     {
 112         return array('uri' => 'K', 'profile_id' => 'U', 'group_id' => 'U', 'feeduri' => 'U');
 113     }
 114
 115     function sequenceKey()
 116     {
 117         return array(false, false, false);
 118     }
 119
 120     /**
 121      * Fetch the StatusNet-side profile for this feed
 122      * @return Profile
 123      */
 124     public function localProfile()
 125     {
 126         if ($this->profile_id) {
 127             return Profile::staticGet('id', $this->profile_id);
 128         }
 129         return null;
 130     }
 131
 132     /**
 133      * Fetch the StatusNet-side profile for this feed
 134      * @return Profile
 135      */
 136     public function localGroup()
 137     {
 138         if ($this->group_id) {
 139             return User_group::staticGet('id', $this->group_id);
 140         }
 141         return null;
 142     }
 143
 144     /**
 145      * Returns an ActivityObject describing this remote user or group profile.
 146      * Can then be used to generate Atom chunks.
 147      *
 148      * @return ActivityObject
 149      */
 150     function asActivityObject()
 151     {
 152         if ($this->isGroup()) {
 153             $object = new ActivityObject();
 154             $object->type = 'http://activitystrea.ms/schema/1.0/group';
 155             $object->id = $this->uri;
 156             $self = $this->localGroup();
 157
 158             // @fixme put a standard getAvatar() interface on groups too
 159             if ($self->homepage_logo) {
 160                 $object->avatar = $self->homepage_logo;
 161                 $map = array('png' => 'image/png',
 162                              'jpg' => 'image/jpeg',
 163                              'jpeg' => 'image/jpeg',
 164                              'gif' => 'image/gif');
 165                 $extension = pathinfo(parse_url($avatarHref, PHP_URL_PATH), PATHINFO_EXTENSION);
 166                 if (isset($map[$extension])) {
 167                     // @fixme this ain't used/saved yet
 168                     $object->avatarType = $map[$extension];
 169                 }
 170             }
 171
 172             $object->link = $this->uri; // @fixme accurate?
 173             return $object;
 174         } else {
 175             return ActivityObject::fromProfile($this->localProfile());
 176         }
 177     }
 178
 179     /**
 180      * Returns an XML string fragment with profile information as an
 181      * Activity Streams noun object with the given element type.
 182      *
 183      * Assumes that 'activity' namespace has been previously defined.
 184      *
 185      * @fixme replace with wrappers on asActivityObject when it's got everything.
 186      *
 187      * @param string $element one of 'actor', 'subject', 'object', 'target'
 188      * @return string
 189      */
 190     function asActivityNoun($element)
 191     {
 192         $xs = new XMLStringer(true);
 193         $avatarHref = Avatar::defaultImage(AVATAR_PROFILE_SIZE);
 194         $avatarType = 'image/png';
 195         if ($this->isGroup()) {
 196             $type = 'http://activitystrea.ms/schema/1.0/group';
 197             $self = $this->localGroup();
 198
 199             // @fixme put a standard getAvatar() interface on groups too
 200             if ($self->homepage_logo) {
 201                 $avatarHref = $self->homepage_logo;
 202                 $map = array('png' => 'image/png',
 203                              'jpg' => 'image/jpeg',
 204                              'jpeg' => 'image/jpeg',
 205                              'gif' => 'image/gif');
 206                 $extension = pathinfo(parse_url($avatarHref, PHP_URL_PATH), PATHINFO_EXTENSION);
 207                 if (isset($map[$extension])) {
 208                     $avatarType = $map[$extension];
 209                 }
 210             }
 211         } else {
 212             $type = 'http://activitystrea.ms/schema/1.0/person';
 213             $self = $this->localProfile();
 214             $avatar = $self->getAvatar(AVATAR_PROFILE_SIZE);
 215             if ($avatar) {
 216                   $avatarHref = $avatar->url;
 217                   $avatarType = $avatar->mediatype;
 218             }
 219         }
 220         $xs->elementStart('activity:' . $element);
 221         $xs->element(
 222             'activity:object-type',
 223             null,
 224             $type
 225         );
 226         $xs->element(
 227             'id',
 228             null,
 229             $this->uri); // ?
 230         $xs->element('title', null, $self->getBestName());
 231
 232         $xs->element(
 233             'link', array(
 234                 'type' => $avatarType,
 235                 'href' => $avatarHref
 236             ),
 237             ''
 238         );
 239
 240         $xs->elementEnd('activity:' . $element);
 241
 242         return $xs->getString();
 243     }
 244
 245     /**
 246      * @return boolean true if this is a remote group
 247      */
 248     function isGroup()
 249     {
 250         if ($this->profile_id && !$this->group_id) {
 251             return false;
 252         } else if ($this->group_id && !$this->profile_id) {
 253             return true;
 254         } else if ($this->group_id && $this->profile_id) {
 255             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs set for $this->uri");
 256         } else {
 257             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs empty for $this->uri");
 258         }
 259     }
 260
 261     /**
 262      * Subscribe a local user to this remote user.
 263      * PuSH subscription will be started if necessary, and we'll
 264      * send a Salmon notification to the remote server if available
 265      * notifying them of the sub.
 266      *
 267      * @param User $user
 268      * @return boolean success
 269      * @throws FeedException
 270      */
 271     public function subscribeLocalToRemote(User $user)
 272     {
 273         if ($this->isGroup()) {
 274             throw new ServerException("Can't subscribe to a remote group");
 275         }
 276
 277         if ($this->subscribe()) {
 278             if ($user->subscribeTo($this->localProfile())) {
 279                 $this->notify($user->getProfile(), ActivityVerb::FOLLOW, $this);
 280                 return true;
 281             }
 282         }
 283         return false;
 284     }
 285
 286     /**
 287      * Mark this remote profile as subscribing to the given local user,
 288      * and send appropriate notifications to the user.
 289      *
 290      * This will generally be in response to a subscription notification
 291      * from a foreign site to our local Salmon response channel.
 292      *
 293      * @param User $user
 294      * @return boolean success
 295      */
 296     public function subscribeRemoteToLocal(User $user)
 297     {
 298         if ($this->isGroup()) {
 299             throw new ServerException("Remote groups can't subscribe to local users");
 300         }
 301
 302         Subscription::start($this->localProfile(), $user->getProfile());
 303
 304         return true;
 305     }
 306
 307     /**
 308      * Send a subscription request to the hub for this feed.
 309      * The hub will later send us a confirmation POST to /main/push/callback.
 310      *
 311      * @return bool true on success, false on failure
 312      * @throws ServerException if feed state is not valid
 313      */
 314     public function subscribe()
 315     {
 316         $feedsub = FeedSub::ensureFeed($this->feeduri);
 317         if ($feedsub->sub_state == 'active' || $feedsub->sub_state == 'subscribe') {
 318             return true;
 319         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive') {
 320             return $feedsub->subscribe();
 321         } else if ('unsubscribe') {
 322             throw new FeedSubException("Unsub is pending, can't subscribe...");
 323         }
 324     }
 325
 326     /**
 327      * Send a PuSH unsubscription request to the hub for this feed.
 328      * The hub will later send us a confirmation POST to /main/push/callback.
 329      *
 330      * @return bool true on success, false on failure
 331      * @throws ServerException if feed state is not valid
 332      */
 333     public function unsubscribe() {
 334         $feedsub = FeedSub::staticGet('uri', $this->feeduri);
 335         if ($feedsub->sub_state == 'active') {
 336             return $feedsub->unsubscribe();
 337         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive' || $feedsub->sub_state == 'unsubscribe') {
 338             return true;
 339         } else if ($feedsub->sub_state == 'subscribe') {
 340             throw new FeedSubException("Feed is awaiting subscription, can't unsub...");
 341         }
 342     }
 343
 344     /**
 345      * Check if this remote profile has any active local subscriptions, and
 346      * if not drop the PuSH subscription feed.
 347      *
 348      * @return boolean
 349      */
 350     public function garbageCollect()
 351     {
 352         if ($this->isGroup()) {
 353             $members = $this->localGroup()->getMembers(0, 1);
 354             $count = $members->N;
 355         } else {
 356             $count = $this->localProfile()->subscriberCount();
 357         }
 358         if ($count == 0) {
 359             common_log(LOG_INFO, "Unsubscribing from now-unused remote feed $oprofile->feeduri");
 360             $this->unsubscribe();
 361             return true;
 362         } else {
 363             return false;
 364         }
 365     }
 366
 367     /**
 368      * Send an Activity Streams notification to the remote Salmon endpoint,
 369      * if so configured.
 370      *
 371      * @param Profile $actor  Actor who did the activity
 372      * @param string  $verb   Activity::SUBSCRIBE or Activity::JOIN
 373      * @param Object  $object object of the action; must define asActivityNoun($tag)
 374      */
 375     public function notify($actor, $verb, $object=null)
 376     {
 377         if (!($actor instanceof Profile)) {
 378             $type = gettype($actor);
 379             if ($type == 'object') {
 380                 $type = get_class($actor);
 381             }
 382             throw new ServerException("Invalid actor passed to " . __METHOD__ . ": " . $type);
 383         }
 384         if ($object == null) {
 385             $object = $this;
 386         }
 387         if ($this->salmonuri) {
 388
 389             $text = 'update';
 390             $id = TagURI::mint('%s:%s:%s',
 391                                $verb,
 392                                $actor->getURI(),
 393                                common_date_iso8601(time()));
 394
 395             // @fixme consolidate all these NS settings somewhere
 396             $attributes = array('xmlns' => Activity::ATOM,
 397                                 'xmlns:activity' => 'http://activitystrea.ms/spec/1.0/',
 398                                 'xmlns:thr' => 'http://purl.org/syndication/thread/1.0',
 399                                 'xmlns:georss' => 'http://www.georss.org/georss',
 400                                 'xmlns:ostatus' => 'http://ostatus.org/schema/1.0',
 401                                 'xmlns:poco' => 'http://portablecontacts.net/spec/1.0');
 402
 403             $entry = new XMLStringer();
 404             $entry->elementStart('entry', $attributes);
 405             $entry->element('id', null, $id);
 406             $entry->element('title', null, $text);
 407             $entry->element('summary', null, $text);
 408             $entry->element('published', null, common_date_w3dtf(common_sql_now()));
 409
 410             $entry->element('activity:verb', null, $verb);
 411             $entry->raw($actor->asAtomAuthor());
 412             $entry->raw($actor->asActivityActor());
 413             $entry->raw($object->asActivityNoun('object'));
 414             $entry->elementEnd('entry');
 415
 416             $xml = $entry->getString();
 417             common_log(LOG_INFO, "Posting to Salmon endpoint $this->salmonuri: $xml");
 418
 419             $salmon = new Salmon(); // ?
 420             return $salmon->post($this->salmonuri, $xml);
 421         }
 422         return false;
 423     }
 424
 425     /**
 426      * Send a Salmon notification ping immediately, and confirm that we got
 427      * an acceptable response from the remote site.
 428      *
 429      * @param mixed $entry XML string, Notice, or Activity
 430      * @return boolean success
 431      */
 432     public function notifyActivity($entry)
 433     {
 434         if ($this->salmonuri) {
 435             $salmon = new Salmon();
 436             return $salmon->post($this->salmonuri, $this->notifyPrepXml($entry));
 437         }
 438
 439         return false;
 440     }
 441
 442     /**
 443      * Queue a Salmon notification for later. If queues are disabled we'll
 444      * send immediately but won't get the return value.
 445      *
 446      * @param mixed $entry XML string, Notice, or Activity
 447      * @return boolean success
 448      */
 449     public function notifyDeferred($entry)
 450     {
 451         if ($this->salmonuri) {
 452             $data = array('salmonuri' => $this->salmonuri,
 453                           'entry' => $this->notifyPrepXml($entry));
 454
 455             $qm = QueueManager::get();
 456             return $qm->enqueue($data, 'salmon');
 457         }
 458
 459         return false;
 460     }
 461
 462     protected function notifyPrepXml($entry)
 463     {
 464         $preamble = '<?xml version="1.0" encoding="UTF-8" ?' . '>';
 465         if (is_string($entry)) {
 466             return $entry;
 467         } else if ($entry instanceof Activity) {
 468             return $preamble . $entry->asString(true);
 469         } else if ($entry instanceof Notice) {
 470             return $preamble . $entry->asAtomEntry(true, true);
 471         } else {
 472             throw new ServerException("Invalid type passed to Ostatus_profile::notify; must be XML string or Activity entry");
 473         }
 474     }
 475
 476     function getBestName()
 477     {
 478         if ($this->isGroup()) {
 479             return $this->localGroup()->getBestName();
 480         } else {
 481             return $this->localProfile()->getBestName();
 482         }
 483     }
 484
 485     function atomFeed($actor)
 486     {
 487         $feed = new Atom10Feed();
 488         // @fixme should these be set up somewhere else?
 489         $feed->addNamespace('activity', 'http://activitystrea.ms/spec/1.0/');
 490         $feed->addNamespace('thr', 'http://purl.org/syndication/thread/1.0');
 491         $feed->addNamespace('georss', 'http://www.georss.org/georss');
 492         $feed->addNamespace('ostatus', 'http://ostatus.org/schema/1.0');
 493
 494         $taguribase = common_config('integration', 'taguri');
 495         $feed->setId("tag:{$taguribase}:UserTimeline:{$actor->id}"); // ???
 496
 497         $feed->setTitle($actor->getBestName() . ' timeline'); // @fixme
 498         $feed->setUpdated(time());
 499         $feed->setPublished(time());
 500
 501         $feed->addLink(common_local_url('ApiTimelineUser',
 502                                         array('id' => $actor->id,
 503                                               'type' => 'atom')),
 504                        array('rel' => 'self',
 505                              'type' => 'application/atom+xml'));
 506
 507         $feed->addLink(common_local_url('userbyid',
 508                                         array('id' => $actor->id)),
 509                        array('rel' => 'alternate',
 510                              'type' => 'text/html'));
 511
 512         return $feed;
 513     }
 514
 515     /**
 516      * Read and post notices for updates from the feed.
 517      * Currently assumes that all items in the feed are new,
 518      * coming from a PuSH hub.
 519      *
 520      * @param DOMDocument $feed
 521      */
 522     public function processFeed($feed, $source)
 523     {
 524         $entries = $feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 525         if ($entries->length == 0) {
 526             common_log(LOG_ERR, __METHOD__ . ": no entries in feed update, ignoring");
 527             return;
 528         }
 529
 530         for ($i = 0; $i < $entries->length; $i++) {
 531             $entry = $entries->item($i);
 532             $this->processEntry($entry, $feed, $source);
 533         }
 534     }
 535
 536     /**
 537      * Process a posted entry from this feed source.
 538      *
 539      * @param DOMElement $entry
 540      * @param DOMElement $feed for context
 541      */
 542     public function processEntry($entry, $feed, $source)
 543     {
 544         $activity = new Activity($entry, $feed);
 545
 546         if ($activity->verb == ActivityVerb::POST) {
 547             $this->processPost($activity, $source);
 548         } else {
 549             common_log(LOG_INFO, "Ignoring activity with unrecognized verb $activity->verb");
 550         }
 551     }
 552
 553     /**
 554      * Process an incoming post activity from this remote feed.
 555      * @param Activity $activity
 556      * @param string $method 'push' or 'salmon'
 557      * @return mixed saved Notice or false
 558      * @fixme break up this function, it's getting nasty long
 559      */
 560     public function processPost($activity, $method)
 561     {
 562         if ($this->isGroup()) {
 563             // A group feed will contain posts from multiple authors.
 564             // @fixme validate these profiles in some way!
 565             $oprofile = self::ensureActorProfile($activity);
 566             if ($oprofile->isGroup()) {
 567                 // Groups can't post notices in StatusNet.
 568                 common_log(LOG_WARNING, "OStatus: skipping post with group listed as author: $oprofile->uri in feed from $this->uri");
 569                 return false;
 570             }
 571         } else {
 572             // Individual user feeds may contain only posts from themselves.
 573             // Authorship is validated against the profile URI on upper layers,
 574             // through PuSH setup or Salmon signature checks.
 575             $actorUri = self::getActorProfileURI($activity);
 576             if ($actorUri == $this->uri) {
 577                 // Check if profile info has changed and update it
 578                 $this->updateFromActivityObject($activity->actor);
 579             } else {
 580                 common_log(LOG_WARNING, "OStatus: skipping post with bad author: got $actorUri expected $this->uri");
 581                 return false;
 582             }
 583             $oprofile = $this;
 584         }
 585
 586         // The id URI will be used as a unique identifier for for the notice,
 587         // protecting against duplicate saves. It isn't required to be a URL;
 588         // tag: URIs for instance are found in Google Buzz feeds.
 589         $sourceUri = $activity->object->id;
 590         $dupe = Notice::staticGet('uri', $sourceUri);
 591         if ($dupe) {
 592             common_log(LOG_INFO, "OStatus: ignoring duplicate post: $sourceUri");
 593             return false;
 594         }
 595
 596         // We'll also want to save a web link to the original notice, if provided.
 597         $sourceUrl = null;
 598         if ($activity->object->link) {
 599             $sourceUrl = $activity->object->link;
 600         } else if ($activity->link) {
 601             $sourceUrl = $activity->link;
 602         } else if (preg_match('!^https?://!', $activity->object->id)) {
 603             $sourceUrl = $activity->object->id;
 604         }
 605
 606         // Get (safe!) HTML and text versions of the content
 607         $rendered = $this->purify($activity->object->content);
 608         $content = html_entity_decode(strip_tags($rendered));
 609
 610         $options = array('is_local' => Notice::REMOTE_OMB,
 611                         'url' => $sourceUrl,
 612                         'uri' => $sourceUri,
 613                         'rendered' => $rendered,
 614                         'replies' => array(),
 615                         'groups' => array());
 616
 617         // Check for optional attributes...
 618
 619         if (!empty($activity->time)) {
 620             $options['created'] = common_sql_date($activity->time);
 621         }
 622
 623         if ($activity->context) {
 624             // Any individual or group attn: targets?
 625             $replies = $activity->context->attention;
 626             $options['groups'] = $this->filterReplies($oprofile, $replies);
 627             $options['replies'] = $replies;
 628
 629             // Maintain direct reply associations
 630             // @fixme what about conversation ID?
 631             if (!empty($activity->context->replyToID)) {
 632                 $orig = Notice::staticGet('uri',
 633                                           $activity->context->replyToID);
 634                 if (!empty($orig)) {
 635                     $options['reply_to'] = $orig->id;
 636                 }
 637             }
 638
 639             $location = $activity->context->location;
 640             if ($location) {
 641                 $options['lat'] = $location->lat;
 642                 $options['lon'] = $location->lon;
 643                 if ($location->location_id) {
 644                     $options['location_ns'] = $location->location_ns;
 645                     $options['location_id'] = $location->location_id;
 646                 }
 647             }
 648         }
 649
 650         try {
 651             $saved = Notice::saveNew($oprofile->profile_id,
 652                                      $content,
 653                                      'ostatus',
 654                                      $options);
 655             if ($saved) {
 656                 Ostatus_source::saveNew($saved, $this, $method);
 657             }
 658         } catch (Exception $e) {
 659             common_log(LOG_ERR, "OStatus save of remote message $sourceUri failed: " . $e->getMessage());
 660             throw $e;
 661         }
 662         common_log(LOG_INFO, "OStatus saved remote message $sourceUri as notice id $saved->id");
 663         return $saved;
 664     }
 665
 666     /**
 667      * Clean up HTML
 668      */
 669     protected function purify($html)
 670     {
 671         require_once(INSTALLDIR.'/extlib/HTMLPurifier/HTMLPurifier.auto.php');
 672
 673         // By default Purifier wants to cache data to its own code directories,
 674         // and spews error messages if they're not writable.
 675         $config = HTMLPurifier_Config::createDefault();
 676         if (common_config('ostatus', 'purify_cache')) {
 677             $config->set('Cache.SerializerPath', common_config('ostatus', 'purify_cache'));
 678         } else {
 679             // Although recommended in the documentation, this produces a notice:
 680             //    "Core.DefinitionCache is an alias, preferred directive name is Cache.DefinitionImpl"
 681             // If I then follow *those* directions, I get a warning and it doesn't work:
 682             //    "Cannot set undefined directive Core.DefinitionImpl"
 683             // So... lesser of two evils. Suppressing the notice from output,
 684             // though it'll still be seen and logged by StatusNet's error handler.
 685             $old = error_reporting();
 686             error_reporting($old & ~E_NOTICE);
 687             $config->set('Core.DefinitionCache', null);
 688             error_reporting($old);
 689         }
 690
 691         $purifier = new HTMLPurifier($config);
 692         return $purifier->purify($html);
 693     }
 694
 695     /**
 696      * Filters a list of recipient ID URIs to just those for local delivery.
 697      * @param Ostatus_profile local profile of sender
 698      * @param array in/out &$attention_uris set of URIs, will be pruned on output
 699      * @return array of group IDs
 700      */
 701     protected function filterReplies($sender, &$attention_uris)
 702     {
 703         common_log(LOG_DEBUG, "Original reply recipients: " . implode(', ', $attention_uris));
 704         $groups = array();
 705         $replies = array();
 706         foreach ($attention_uris as $recipient) {
 707             // Is the recipient a local user?
 708             $user = User::staticGet('uri', $recipient);
 709             if ($user) {
 710                 // @fixme sender verification, spam etc?
 711                 $replies[] = $recipient;
 712                 continue;
 713             }
 714
 715             // Is the recipient a remote group?
 716             $oprofile = Ostatus_profile::staticGet('uri', $recipient);
 717             if ($oprofile) {
 718                 if ($oprofile->isGroup()) {
 719                     // Deliver to local members of this remote group.
 720                     // @fixme sender verification?
 721                     $groups[] = $oprofile->group_id;
 722                 } else {
 723                     common_log(LOG_DEBUG, "Skipping reply to remote profile $recipient");
 724                 }
 725                 continue;
 726             }
 727
 728             // Is the recipient a local group?
 729             // @fixme we need a uri on user_group
 730             // $group = User_group::staticGet('uri', $recipient);
 731             $template = common_local_url('groupbyid', array('id' => '31337'));
 732             $template = preg_quote($template, '/');
 733             $template = str_replace('31337', '(\d+)', $template);
 734             if (preg_match("/$template/", $recipient, $matches)) {
 735                 $id = $matches[1];
 736                 $group = User_group::staticGet('id', $id);
 737                 if ($group) {
 738                     // Deliver to all members of this local group if allowed.
 739                     $profile = $sender->localProfile();
 740                     if ($profile->isMember($group)) {
 741                         $groups[] = $group->id;
 742                     } else {
 743                         common_log(LOG_DEBUG, "Skipping reply to local group $group->nickname as sender $profile->id is not a member");
 744                     }
 745                     continue;
 746                 } else {
 747                     common_log(LOG_DEBUG, "Skipping reply to bogus group $recipient");
 748                 }
 749             }
 750
 751             common_log(LOG_DEBUG, "Skipping reply to unrecognized profile $recipient");
 752
 753         }
 754         $attention_uris = $replies;
 755         common_log(LOG_DEBUG, "Local reply recipients: " . implode(', ', $replies));
 756         common_log(LOG_DEBUG, "Local group recipients: " . implode(', ', $groups));
 757         return $groups;
 758     }
 759
 760     /**
 761      * @param string $profile_url
 762      * @return Ostatus_profile
 763      * @throws FeedSubException
 764      */
 765     public static function ensureProfile($profile_uri, $hints=array())
 766     {
 767         // Get the canonical feed URI and check it
 768         $discover = new FeedDiscovery();
 769         $feeduri = $discover->discoverFromURL($profile_uri);
 770
 771         //$feedsub = FeedSub::ensureFeed($feeduri, $discover->feed);
 772         $huburi = $discover->getAtomLink('hub');
 773         $salmonuri = $discover->getAtomLink('salmon');
 774
 775         if (!$huburi) {
 776             // We can only deal with folks with a PuSH hub
 777             throw new FeedSubNoHubException();
 778         }
 779
 780         // Try to get a profile from the feed activity:subject
 781
 782         $feedEl = $discover->feed->documentElement;
 783
 784         $subject = ActivityUtils::child($feedEl, Activity::SUBJECT, Activity::SPEC);
 785
 786         if (!empty($subject)) {
 787             $subjObject = new ActivityObject($subject);
 788             return self::ensureActivityObjectProfile($subjObject, $feeduri, $salmonuri, $hints);
 789         }
 790
 791         // Otherwise, try the feed author
 792
 793         $author = ActivityUtils::child($feedEl, Activity::AUTHOR, Activity::ATOM);
 794
 795         if (!empty($author)) {
 796             $authorObject = new ActivityObject($author);
 797             return self::ensureActivityObjectProfile($authorObject, $feeduri, $salmonuri, $hints);
 798         }
 799
 800         // Sheesh. Not a very nice feed! Let's try fingerpoken in the
 801         // entries.
 802
 803         $entries = $discover->feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 804
 805         if (!empty($entries) && $entries->length > 0) {
 806
 807             $entry = $entries->item(0);
 808
 809             $actor = ActivityUtils::child($entry, Activity::ACTOR, Activity::SPEC);
 810
 811             if (!empty($actor)) {
 812                 $actorObject = new ActivityObject($actor);
 813                 return self::ensureActivityObjectProfile($actorObject, $feeduri, $salmonuri, $hints);
 814
 815             }
 816
 817             $author = ActivityUtils::child($entry, Activity::AUTHOR, Activity::ATOM);
 818
 819             if (!empty($author)) {
 820                 $authorObject = new ActivityObject($author);
 821                 return self::ensureActivityObjectProfile($authorObject, $feeduri, $salmonuri, $hints);
 822             }
 823         }
 824
 825         // XXX: make some educated guesses here
 826
 827         throw new FeedSubException("Can't find enough profile information to make a feed.");
 828     }
 829
 830     /**
 831      *
 832      * Download and update given avatar image
 833      * @param string $url
 834      * @throws Exception in various failure cases
 835      */
 836     protected function updateAvatar($url)
 837     {
 838         if ($url == $this->avatar) {
 839             // We've already got this one.
 840             return;
 841         }
 842
 843         if ($this->isGroup()) {
 844             $self = $this->localGroup();
 845         } else {
 846             $self = $this->localProfile();
 847         }
 848         if (!$self) {
 849             throw new ServerException(sprintf(
 850                 _m("Tried to update avatar for unsaved remote profile %s"),
 851                 $this->uri));
 852         }
 853
 854         // @fixme this should be better encapsulated
 855         // ripped from oauthstore.php (for old OMB client)
 856         $temp_filename = tempnam(sys_get_temp_dir(), 'listener_avatar');
 857         if (!copy($url, $temp_filename)) {
 858             throw new ServerException(sprintf(_m("Unable to fetch avatar from %s"), $url));
 859         }
 860
 861         if ($this->isGroup()) {
 862             $id = $this->group_id;
 863         } else {
 864             $id = $this->profile_id;
 865         }
 866         // @fixme should we be using different ids?
 867         $imagefile = new ImageFile($id, $temp_filename);
 868         $filename = Avatar::filename($id,
 869                                      image_type_to_extension($imagefile->type),
 870                                      null,
 871                                      common_timestamp());
 872         rename($temp_filename, Avatar::path($filename));
 873         $self->setOriginal($filename);
 874
 875         $orig = clone($this);
 876         $this->avatar = $url;
 877         $this->update($orig);
 878     }
 879
 880     /**
 881      * Pull avatar URL from ActivityObject or profile hints
 882      *
 883      * @param ActivityObject $object
 884      * @param array $hints
 885      * @return mixed URL string or false
 886      */
 887
 888     protected static function getActivityObjectAvatar($object, $hints=array())
 889     {
 890         if ($object->avatar) {
 891             return $object->avatar;
 892         } else if (array_key_exists('avatar', $hints)) {
 893             return $hints['avatar'];
 894         }
 895         return false;
 896     }
 897
 898     /**
 899      * Get an appropriate avatar image source URL, if available.
 900      *
 901      * @param ActivityObject $actor
 902      * @param DOMElement $feed
 903      * @return string
 904      */
 905
 906     protected static function getAvatar($actor, $feed)
 907     {
 908         $url = '';
 909         $icon = '';
 910         if ($actor->avatar) {
 911             $url = trim($actor->avatar);
 912         }
 913         if (!$url) {
 914             // Check <atom:logo> and <atom:icon> on the feed
 915             $els = $feed->childNodes();
 916             if ($els && $els->length) {
 917                 for ($i = 0; $i < $els->length; $i++) {
 918                     $el = $els->item($i);
 919                     if ($el->namespaceURI == Activity::ATOM) {
 920                         if (empty($url) && $el->localName == 'logo') {
 921                             $url = trim($el->textContent);
 922                             break;
 923                         }
 924                         if (empty($icon) && $el->localName == 'icon') {
 925                             // Use as a fallback
 926                             $icon = trim($el->textContent);
 927                         }
 928                     }
 929                 }
 930             }
 931             if ($icon && !$url) {
 932                 $url = $icon;
 933             }
 934         }
 935         if ($url) {
 936             $opts = array('allowed_schemes' => array('http', 'https'));
 937             if (Validate::uri($url, $opts)) {
 938                 return $url;
 939             }
 940         }
 941         return common_path('plugins/OStatus/images/96px-Feed-icon.svg.png');
 942     }
 943
 944     /**
 945      * Fetch, or build if necessary, an Ostatus_profile for the actor
 946      * in a given Activity Streams activity.
 947      *
 948      * @param Activity $activity
 949      * @param string $feeduri if we already know the canonical feed URI!
 950      * @param string $salmonuri if we already know the salmon return channel URI
 951      * @return Ostatus_profile
 952      */
 953
 954     public static function ensureActorProfile($activity, $feeduri=null, $salmonuri=null)
 955     {
 956         return self::ensureActivityObjectProfile($activity->actor, $feeduri, $salmonuri);
 957     }
 958
 959     public static function ensureActivityObjectProfile($object, $feeduri=null, $salmonuri=null, $hints=array())
 960     {
 961         $profile = self::getActivityObjectProfile($object);
 962         if ($profile) {
 963             $profile->updateFromActivityObject($object, $hints);
 964         } else {
 965             $profile = self::createActivityObjectProfile($object, $feeduri, $salmonuri, $hints);
 966         }
 967         return $profile;
 968     }
 969
 970     /**
 971      * @param Activity $activity
 972      * @return mixed matching Ostatus_profile or false if none known
 973      */
 974     protected static function getActorProfile($activity)
 975     {
 976         return self::getActivityObjectProfile($activity->actor);
 977     }
 978
 979     protected static function getActivityObjectProfile($object)
 980     {
 981         $uri = self::getActivityObjectProfileURI($object);
 982         return Ostatus_profile::staticGet('uri', $uri);
 983     }
 984
 985     protected static function getActorProfileURI($activity)
 986     {
 987         return self::getActivityObjectProfileURI($activity->actor);
 988     }
 989
 990     /**
 991      * @param Activity $activity
 992      * @return string
 993      * @throws ServerException
 994      */
 995     protected static function getActivityObjectProfileURI($object)
 996     {
 997         $opts = array('allowed_schemes' => array('http', 'https'));
 998         if ($object->id && Validate::uri($object->id, $opts)) {
 999             return $object->id;
1000         }
1001         if ($object->link && Validate::uri($object->link, $opts)) {
1002             return $object->link;
1003         }
1004         throw new ServerException("No author ID URI found");
1005     }
1006
1007     /**
1008      * @fixme validate stuff somewhere
1009      */
1010
1011     protected static function createActorProfile($activity, $feeduri=null, $salmonuri=null)
1012     {
1013         $actor = $activity->actor;
1014
1015         self::createActivityObjectProfile($actor, $feeduri, $salmonuri);
1016     }
1017
1018     /**
1019      * Create local ostatus_profile and profile/user_group entries for
1020      * the provided remote user or group.
1021      *
1022      * @param ActivityObject $object
1023      * @param string $feeduri
1024      * @param string $salmonuri
1025      * @param array $hints
1026      *
1027      * @fixme fold $feeduri/$salmonuri into $hints
1028      * @return Ostatus_profile
1029      */
1030     protected static function createActivityObjectProfile($object, $feeduri=null, $salmonuri=null, $hints=array())
1031     {
1032         $homeuri  = $object->id;
1033
1034         if (!$homeuri) {
1035             common_log(LOG_DEBUG, __METHOD__ . " empty actor profile URI: " . var_export($activity, true));
1036             throw new ServerException("No profile URI");
1037         }
1038
1039         if (empty($feeduri)) {
1040             if (array_key_exists('feedurl', $hints)) {
1041                 $feeduri = $hints['feedurl'];
1042             }
1043         }
1044
1045         if (empty($salmonuri)) {
1046             if (array_key_exists('salmon', $hints)) {
1047                 $salmonuri = $hints['salmon'];
1048             }
1049         }
1050
1051         if (!$feeduri || !$salmonuri) {
1052             // Get the canonical feed URI and check it
1053             $discover = new FeedDiscovery();
1054             $feeduri = $discover->discoverFromURL($homeuri);
1055
1056             $huburi = $discover->getAtomLink('hub');
1057             $salmonuri = $discover->getAtomLink('salmon');
1058
1059             if (!$huburi) {
1060                 // We can only deal with folks with a PuSH hub
1061                 throw new FeedSubNoHubException();
1062             }
1063         }
1064
1065         $oprofile = new Ostatus_profile();
1066
1067         $oprofile->uri        = $homeuri;
1068         $oprofile->feeduri    = $feeduri;
1069         $oprofile->salmonuri  = $salmonuri;
1070
1071         $oprofile->created    = common_sql_now();
1072         $oprofile->modified   = common_sql_now();
1073
1074         if ($object->type == ActivityObject::PERSON) {
1075             $profile = new Profile();
1076             self::updateProfile($profile, $object, $hints);
1077             $profile->created  = common_sql_now();
1078
1079             $oprofile->profile_id = $profile->insert();
1080             if (!$oprofile->profile_id) {
1081                 throw new ServerException("Can't save local profile");
1082             }
1083         } else {
1084             $group = new User_group();
1085             $group->created = common_sql_now();
1086             self::updateGroup($group, $object, $hints);
1087
1088             $oprofile->group_id = $group->insert();
1089             if (!$oprofile->group_id) {
1090                 throw new ServerException("Can't save local profile");
1091             }
1092         }
1093
1094         $ok = $oprofile->insert();
1095
1096         if ($ok) {
1097             $avatar = self::getActivityObjectAvatar($object, $hints);
1098             if ($avatar) {
1099                 $oprofile->updateAvatar($avatar);
1100             }
1101             return $oprofile;
1102         } else {
1103             throw new ServerException("Can't save OStatus profile");
1104         }
1105     }
1106
1107     /**
1108      * Save any updated profile information to our local copy.
1109      * @param ActivityObject $object
1110      * @param array $hints
1111      */
1112     protected function updateFromActivityObject($object, $hints=array())
1113     {
1114         if ($this->isGroup()) {
1115             $group = $this->localGroup();
1116             self::updateGroup($group, $object, $hints);
1117         } else {
1118             $profile = $this->localProfile();
1119             self::updateProfile($profile, $object, $hints);
1120         }
1121         $avatar = self::getActivityObjectAvatar($object, $hints);
1122         if ($avatar) {
1123             $this->updateAvatar($avatar);
1124         }
1125     }
1126
1127     protected static function updateProfile($profile, $object, $hints=array())
1128     {
1129         $orig = clone($profile);
1130
1131         $profile->nickname = self::getActivityObjectNickname($object, $hints);
1132         $profile->fullname = $object->title;
1133         if (!empty($object->link)) {
1134             $profile->profileurl = $object->link;
1135         } else if (array_key_exists('profileurl', $hints)) {
1136             $profile->profileurl = $hints['profileurl'];
1137         }
1138
1139         // @fixme bio
1140         // @fixme tags/categories
1141         // @fixme location?
1142         // @todo tags from categories
1143         // @todo lat/lon/location?
1144
1145         if ($profile->id) {
1146             common_log(LOG_DEBUG, "Updating OStatus profile $profile->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1147             $profile->update($orig);
1148         }
1149     }
1150
1151     protected static function updateGroup($group, $object, $hints=array())
1152     {
1153         $orig = clone($group);
1154
1155         // @fixme need to make nick unique etc *hack hack*
1156         $group->nickname = self::getActivityObjectNickname($object, $hints);
1157         $group->fullname = $object->title;
1158
1159         // @fixme no canonical profileurl; using homepage instead for now
1160         $group->homepage = $object->id;
1161
1162         // @fixme homepage
1163         // @fixme bio
1164         // @fixme tags/categories
1165         // @fixme location?
1166         // @todo tags from categories
1167         // @todo lat/lon/location?
1168
1169         if ($group->id) {
1170             common_log(LOG_DEBUG, "Updating OStatus group $group->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1171             $group->update($orig);
1172         }
1173     }
1174
1175     protected static function getActivityObjectNickname($object, $hints=array())
1176     {
1177         if ($object->poco) {
1178             if (!empty($object->poco->preferredUsername)) {
1179                 return common_nicknamize($object->poco->preferredUsername);
1180             }
1181         }
1182         if (!empty($object->nickname)) {
1183             return common_nicknamize($object->nickname);
1184         }
1185
1186         // Try the definitive ID
1187
1188         $nickname = self::nicknameFromURI($object->id);
1189
1190         // Try a Webfinger if one was passed (way) down
1191
1192         if (empty($nickname)) {
1193             if (array_key_exists('webfinger', $hints)) {
1194                 $nickname = self::nicknameFromURI($hints['webfinger']);
1195             }
1196         }
1197
1198         // Try the name
1199
1200         if (empty($nickname)) {
1201             $nickname = common_nicknamize($object->title);
1202         }
1203
1204         return $nickname;
1205     }
1206
1207     protected static function nicknameFromURI($uri)
1208     {
1209         preg_match('/(\w+):/', $uri, $matches);
1210
1211         $protocol = $matches[1];
1212
1213         switch ($protocol) {
1214         case 'acct':
1215         case 'mailto':
1216             if (preg_match("/^$protocol:(.*)?@.*\$/", $uri, $matches)) {
1217                 return common_canonical_nickname($matches[1]);
1218             }
1219             return null;
1220         case 'http':
1221             return common_url_to_nickname($uri);
1222             break;
1223         default:
1224             return null;
1225         }
1226     }
1227
1228     public static function ensureWebfinger($addr)
1229     {
1230         // First, look it up
1231
1232         $oprofile = Ostatus_profile::staticGet('uri', 'acct:'.$addr);
1233
1234         if (!empty($oprofile)) {
1235             return $oprofile;
1236         }
1237
1238         // Now, try some discovery
1239
1240         $wf = new Webfinger();
1241
1242         $result = $wf->lookup($addr);
1243
1244         if (!$result) {
1245             return null;
1246         }
1247
1248         foreach ($result->links as $link) {
1249             switch ($link['rel']) {
1250             case Webfinger::PROFILEPAGE:
1251                 $profileUrl = $link['href'];
1252                 break;
1253             case 'salmon':
1254                 $salmonEndpoint = $link['href'];
1255                 break;
1256             case Webfinger::UPDATESFROM:
1257                 $feedUrl = $link['href'];
1258                 break;
1259             default:
1260                 common_log(LOG_NOTICE, "Don't know what to do with rel = '{$link['rel']}'");
1261                 break;
1262             }
1263         }
1264
1265         $hints = array('webfinger' => $addr,
1266                        'profileurl' => $profileUrl,
1267                        'feedurl' => $feedUrl,
1268                        'salmon' => $salmonEndpoint);
1269
1270         // If we got a feed URL, try that
1271
1272         if (isset($feedUrl)) {
1273             try {
1274                 $oprofile = self::ensureProfile($feedUrl, $hints);
1275                 return $oprofile;
1276             } catch (Exception $e) {
1277                 common_log(LOG_WARNING, "Failed creating profile from feed URL '$feedUrl': " . $e->getMessage());
1278                 // keep looking
1279             }
1280         }
1281
1282         // If we got a profile page, try that!
1283
1284         if (isset($profileUrl)) {
1285             try {
1286                 $oprofile = self::ensureProfile($profileUrl, $hints);
1287                 return $oprofile;
1288             } catch (Exception $e) {
1289                 common_log(LOG_WARNING, "Failed creating profile from profile URL '$profileUrl': " . $e->getMessage());
1290                 // keep looking
1291             }
1292         }
1293
1294         // XXX: try hcard
1295         // XXX: try FOAF
1296
1297         if (isset($salmonEndpoint)) {
1298
1299             // An account URL, a salmon endpoint, and a dream? Not much to go
1300             // on, but let's give it a try
1301
1302             $uri = 'acct:'.$addr;
1303
1304             $profile = new Profile();
1305
1306             $profile->nickname = self::nicknameFromUri($uri);
1307             $profile->created  = common_sql_now();
1308
1309             if (isset($profileUrl)) {
1310                 $profile->profileurl = $profileUrl;
1311             }
1312
1313             $profile_id = $profile->insert();
1314
1315             if (!$profile_id) {
1316                 common_log_db_error($profile, 'INSERT', __FILE__);
1317                 throw new Exception("Couldn't save profile for '$addr'");
1318             }
1319
1320             $oprofile = new Ostatus_profile();
1321
1322             $oprofile->uri        = $uri;
1323             $oprofile->salmonuri  = $salmonEndpoint;
1324             $oprofile->profile_id = $profile_id;
1325             $oprofile->created    = common_sql_now();
1326
1327             if (isset($feedUrl)) {
1328                 $profile->feeduri = $feedUrl;
1329             }
1330
1331             $result = $oprofile->insert();
1332
1333             if (!$result) {
1334                 common_log_db_error($oprofile, 'INSERT', __FILE__);
1335                 throw new Exception("Couldn't save ostatus_profile for '$addr'");
1336             }
1337
1338             return $oprofile;
1339         }
1340
1341         return null;
1342     }
1343 }