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             return ActivityObject::fromGroup($this->localGroup());
 154         } else {
 155             return ActivityObject::fromProfile($this->localProfile());
 156         }
 157     }
 158
 159     /**
 160      * Returns an XML string fragment with profile information as an
 161      * Activity Streams noun object with the given element type.
 162      *
 163      * Assumes that 'activity' namespace has been previously defined.
 164      *
 165      * @fixme replace with wrappers on asActivityObject when it's got everything.
 166      *
 167      * @param string $element one of 'actor', 'subject', 'object', 'target'
 168      * @return string
 169      */
 170     function asActivityNoun($element)
 171     {
 172         if ($this->isGroup()) {
 173             $noun = ActivityObject::fromGroup($this->localGroup());
 174             return $noun->asString('activity:' . $element);
 175         } else {
 176             $noun = ActivityObject::fromProfile($this->localProfile());
 177             return $noun->asString('activity:' . $element);
 178         }
 179     }
 180
 181     /**
 182      * @return boolean true if this is a remote group
 183      */
 184     function isGroup()
 185     {
 186         if ($this->profile_id && !$this->group_id) {
 187             return false;
 188         } else if ($this->group_id && !$this->profile_id) {
 189             return true;
 190         } else if ($this->group_id && $this->profile_id) {
 191             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs set for $this->uri");
 192         } else {
 193             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs empty for $this->uri");
 194         }
 195     }
 196
 197     /**
 198      * Subscribe a local user to this remote user.
 199      * PuSH subscription will be started if necessary, and we'll
 200      * send a Salmon notification to the remote server if available
 201      * notifying them of the sub.
 202      *
 203      * @param User $user
 204      * @return boolean success
 205      * @throws FeedException
 206      */
 207     public function subscribeLocalToRemote(User $user)
 208     {
 209         if ($this->isGroup()) {
 210             throw new ServerException("Can't subscribe to a remote group");
 211         }
 212
 213         if ($this->subscribe()) {
 214             if ($user->subscribeTo($this->localProfile())) {
 215                 $this->notify($user->getProfile(), ActivityVerb::FOLLOW, $this);
 216                 return true;
 217             }
 218         }
 219         return false;
 220     }
 221
 222     /**
 223      * Mark this remote profile as subscribing to the given local user,
 224      * and send appropriate notifications to the user.
 225      *
 226      * This will generally be in response to a subscription notification
 227      * from a foreign site to our local Salmon response channel.
 228      *
 229      * @param User $user
 230      * @return boolean success
 231      */
 232     public function subscribeRemoteToLocal(User $user)
 233     {
 234         if ($this->isGroup()) {
 235             throw new ServerException("Remote groups can't subscribe to local users");
 236         }
 237
 238         Subscription::start($this->localProfile(), $user->getProfile());
 239
 240         return true;
 241     }
 242
 243     /**
 244      * Send a subscription request to the hub for this feed.
 245      * The hub will later send us a confirmation POST to /main/push/callback.
 246      *
 247      * @return bool true on success, false on failure
 248      * @throws ServerException if feed state is not valid
 249      */
 250     public function subscribe()
 251     {
 252         $feedsub = FeedSub::ensureFeed($this->feeduri);
 253         if ($feedsub->sub_state == 'active' || $feedsub->sub_state == 'subscribe') {
 254             return true;
 255         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive') {
 256             return $feedsub->subscribe();
 257         } else if ('unsubscribe') {
 258             throw new FeedSubException("Unsub is pending, can't subscribe...");
 259         }
 260     }
 261
 262     /**
 263      * Send a PuSH unsubscription request to the hub for this feed.
 264      * The hub will later send us a confirmation POST to /main/push/callback.
 265      *
 266      * @return bool true on success, false on failure
 267      * @throws ServerException if feed state is not valid
 268      */
 269     public function unsubscribe() {
 270         $feedsub = FeedSub::staticGet('uri', $this->feeduri);
 271         if (!$feedsub) {
 272             return true;
 273         }
 274         if ($feedsub->sub_state == 'active') {
 275             return $feedsub->unsubscribe();
 276         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive' || $feedsub->sub_state == 'unsubscribe') {
 277             return true;
 278         } else if ($feedsub->sub_state == 'subscribe') {
 279             throw new FeedSubException("Feed is awaiting subscription, can't unsub...");
 280         }
 281     }
 282
 283     /**
 284      * Check if this remote profile has any active local subscriptions, and
 285      * if not drop the PuSH subscription feed.
 286      *
 287      * @return boolean
 288      */
 289     public function garbageCollect()
 290     {
 291         if ($this->isGroup()) {
 292             $members = $this->localGroup()->getMembers(0, 1);
 293             $count = $members->N;
 294         } else {
 295             $count = $this->localProfile()->subscriberCount();
 296         }
 297         if ($count == 0) {
 298             common_log(LOG_INFO, "Unsubscribing from now-unused remote feed $this->feeduri");
 299             $this->unsubscribe();
 300             return true;
 301         } else {
 302             return false;
 303         }
 304     }
 305
 306     /**
 307      * Send an Activity Streams notification to the remote Salmon endpoint,
 308      * if so configured.
 309      *
 310      * @param Profile $actor  Actor who did the activity
 311      * @param string  $verb   Activity::SUBSCRIBE or Activity::JOIN
 312      * @param Object  $object object of the action; must define asActivityNoun($tag)
 313      */
 314     public function notify($actor, $verb, $object=null)
 315     {
 316         if (!($actor instanceof Profile)) {
 317             $type = gettype($actor);
 318             if ($type == 'object') {
 319                 $type = get_class($actor);
 320             }
 321             throw new ServerException("Invalid actor passed to " . __METHOD__ . ": " . $type);
 322         }
 323         if ($object == null) {
 324             $object = $this;
 325         }
 326         if ($this->salmonuri) {
 327
 328             $text = 'update';
 329             $id = TagURI::mint('%s:%s:%s',
 330                                $verb,
 331                                $actor->getURI(),
 332                                common_date_iso8601(time()));
 333
 334             // @fixme consolidate all these NS settings somewhere
 335             $attributes = array('xmlns' => Activity::ATOM,
 336                                 'xmlns:activity' => 'http://activitystrea.ms/spec/1.0/',
 337                                 'xmlns:thr' => 'http://purl.org/syndication/thread/1.0',
 338                                 'xmlns:georss' => 'http://www.georss.org/georss',
 339                                 'xmlns:ostatus' => 'http://ostatus.org/schema/1.0',
 340                                 'xmlns:poco' => 'http://portablecontacts.net/spec/1.0',
 341                                 'xmlns:media' => 'http://purl.org/syndication/atommedia');
 342
 343             $entry = new XMLStringer();
 344             $entry->elementStart('entry', $attributes);
 345             $entry->element('id', null, $id);
 346             $entry->element('title', null, $text);
 347             $entry->element('summary', null, $text);
 348             $entry->element('published', null, common_date_w3dtf(common_sql_now()));
 349
 350             $entry->element('activity:verb', null, $verb);
 351             $entry->raw($actor->asAtomAuthor());
 352             $entry->raw($actor->asActivityActor());
 353             $entry->raw($object->asActivityNoun('object'));
 354             $entry->elementEnd('entry');
 355
 356             $xml = $entry->getString();
 357             common_log(LOG_INFO, "Posting to Salmon endpoint $this->salmonuri: $xml");
 358
 359             $salmon = new Salmon(); // ?
 360             return $salmon->post($this->salmonuri, $xml, $actor);
 361         }
 362         return false;
 363     }
 364
 365     /**
 366      * Send a Salmon notification ping immediately, and confirm that we got
 367      * an acceptable response from the remote site.
 368      *
 369      * @param mixed $entry XML string, Notice, or Activity
 370      * @return boolean success
 371      */
 372     public function notifyActivity($entry, $actor)
 373     {
 374         if ($this->salmonuri) {
 375             $salmon = new Salmon();
 376             return $salmon->post($this->salmonuri, $this->notifyPrepXml($entry), $actor);
 377         }
 378
 379         return false;
 380     }
 381
 382     /**
 383      * Queue a Salmon notification for later. If queues are disabled we'll
 384      * send immediately but won't get the return value.
 385      *
 386      * @param mixed $entry XML string, Notice, or Activity
 387      * @return boolean success
 388      */
 389     public function notifyDeferred($entry, $actor)
 390     {
 391         if ($this->salmonuri) {
 392             $data = array('salmonuri' => $this->salmonuri,
 393                           'entry' => $this->notifyPrepXml($entry),
 394                           'actor' => $actor->id);
 395
 396             $qm = QueueManager::get();
 397             return $qm->enqueue($data, 'salmon');
 398         }
 399
 400         return false;
 401     }
 402
 403     protected function notifyPrepXml($entry)
 404     {
 405         $preamble = '<?xml version="1.0" encoding="UTF-8" ?' . '>';
 406         if (is_string($entry)) {
 407             return $entry;
 408         } else if ($entry instanceof Activity) {
 409             return $preamble . $entry->asString(true);
 410         } else if ($entry instanceof Notice) {
 411             return $preamble . $entry->asAtomEntry(true, true);
 412         } else {
 413             throw new ServerException("Invalid type passed to Ostatus_profile::notify; must be XML string or Activity entry");
 414         }
 415     }
 416
 417     function getBestName()
 418     {
 419         if ($this->isGroup()) {
 420             return $this->localGroup()->getBestName();
 421         } else {
 422             return $this->localProfile()->getBestName();
 423         }
 424     }
 425
 426     /**
 427      * Read and post notices for updates from the feed.
 428      * Currently assumes that all items in the feed are new,
 429      * coming from a PuSH hub.
 430      *
 431      * @param DOMDocument $doc
 432      * @param string $source identifier ("push")
 433      */
 434     public function processFeed(DOMDocument $doc, $source)
 435     {
 436         $feed = $doc->documentElement;
 437
 438         if ($feed->localName != 'feed' || $feed->namespaceURI != Activity::ATOM) {
 439             common_log(LOG_ERR, __METHOD__ . ": not an Atom feed, ignoring");
 440             return;
 441         }
 442
 443         $entries = $feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 444         if ($entries->length == 0) {
 445             common_log(LOG_ERR, __METHOD__ . ": no entries in feed update, ignoring");
 446             return;
 447         }
 448
 449         for ($i = 0; $i < $entries->length; $i++) {
 450             $entry = $entries->item($i);
 451             $this->processEntry($entry, $feed, $source);
 452         }
 453     }
 454
 455     /**
 456      * Process a posted entry from this feed source.
 457      *
 458      * @param DOMElement $entry
 459      * @param DOMElement $feed for context
 460      * @param string $source identifier ("push" or "salmon")
 461      */
 462     public function processEntry($entry, $feed, $source)
 463     {
 464         $activity = new Activity($entry, $feed);
 465
 466         if ($activity->verb == ActivityVerb::POST) {
 467             $this->processPost($activity, $source);
 468         } else {
 469             common_log(LOG_INFO, "Ignoring activity with unrecognized verb $activity->verb");
 470         }
 471     }
 472
 473     /**
 474      * Process an incoming post activity from this remote feed.
 475      * @param Activity $activity
 476      * @param string $method 'push' or 'salmon'
 477      * @return mixed saved Notice or false
 478      * @fixme break up this function, it's getting nasty long
 479      */
 480     public function processPost($activity, $method)
 481     {
 482         if ($this->isGroup()) {
 483             // A group feed will contain posts from multiple authors.
 484             // @fixme validate these profiles in some way!
 485             $oprofile = self::ensureActorProfile($activity);
 486             if ($oprofile->isGroup()) {
 487                 // Groups can't post notices in StatusNet.
 488                 common_log(LOG_WARNING, "OStatus: skipping post with group listed as author: $oprofile->uri in feed from $this->uri");
 489                 return false;
 490             }
 491         } else {
 492             // Individual user feeds may contain only posts from themselves.
 493             // Authorship is validated against the profile URI on upper layers,
 494             // through PuSH setup or Salmon signature checks.
 495             $actorUri = self::getActorProfileURI($activity);
 496             if ($actorUri == $this->uri) {
 497                 // Check if profile info has changed and update it
 498                 $this->updateFromActivityObject($activity->actor);
 499             } else {
 500                 common_log(LOG_WARNING, "OStatus: skipping post with bad author: got $actorUri expected $this->uri");
 501                 return false;
 502             }
 503             $oprofile = $this;
 504         }
 505
 506         // The id URI will be used as a unique identifier for for the notice,
 507         // protecting against duplicate saves. It isn't required to be a URL;
 508         // tag: URIs for instance are found in Google Buzz feeds.
 509         $sourceUri = $activity->object->id;
 510         $dupe = Notice::staticGet('uri', $sourceUri);
 511         if ($dupe) {
 512             common_log(LOG_INFO, "OStatus: ignoring duplicate post: $sourceUri");
 513             return false;
 514         }
 515
 516         // We'll also want to save a web link to the original notice, if provided.
 517         $sourceUrl = null;
 518         if ($activity->object->link) {
 519             $sourceUrl = $activity->object->link;
 520         } else if ($activity->link) {
 521             $sourceUrl = $activity->link;
 522         } else if (preg_match('!^https?://!', $activity->object->id)) {
 523             $sourceUrl = $activity->object->id;
 524         }
 525
 526         // Get (safe!) HTML and text versions of the content
 527         $rendered = $this->purify($activity->object->content);
 528         $content = html_entity_decode(strip_tags($rendered));
 529
 530         $shortened = common_shorten_links($content);
 531
 532         // If it's too long, try using the summary, and make the
 533         // HTML an attachment.
 534
 535         $attachment = null;
 536
 537         if (Notice::contentTooLong($shortened)) {
 538             $attachment = $this->saveHTMLFile($activity->object->title, $rendered);
 539             $summary = $activity->object->summary;
 540             if (empty($summary)) {
 541                 $summary = $content;
 542             }
 543             $shortSummary = common_shorten_links($summary);
 544             if (Notice::contentTooLong($shortSummary)) {
 545                 $url = common_shorten_url(common_local_url('attachment',
 546                                                            array('attachment' => $attachment->id)));
 547                 $shortSummary = substr($shortSummary,
 548                                        0,
 549                                        Notice::maxContent() - (mb_strlen($url) + 2));
 550                 $shortSummary .= '… ' . $url;
 551                 $content = $shortSummary;
 552                 $rendered = common_render_text($content);
 553             }
 554         }
 555
 556         $options = array('is_local' => Notice::REMOTE_OMB,
 557                         'url' => $sourceUrl,
 558                         'uri' => $sourceUri,
 559                         'rendered' => $rendered,
 560                         'replies' => array(),
 561                         'groups' => array(),
 562                         'tags' => array(),
 563                         'urls' => array());
 564
 565         // Check for optional attributes...
 566
 567         if (!empty($activity->time)) {
 568             $options['created'] = common_sql_date($activity->time);
 569         }
 570
 571         if ($activity->context) {
 572             // Any individual or group attn: targets?
 573             $replies = $activity->context->attention;
 574             $options['groups'] = $this->filterReplies($oprofile, $replies);
 575             $options['replies'] = $replies;
 576
 577             // Maintain direct reply associations
 578             // @fixme what about conversation ID?
 579             if (!empty($activity->context->replyToID)) {
 580                 $orig = Notice::staticGet('uri',
 581                                           $activity->context->replyToID);
 582                 if (!empty($orig)) {
 583                     $options['reply_to'] = $orig->id;
 584                 }
 585             }
 586
 587             $location = $activity->context->location;
 588             if ($location) {
 589                 $options['lat'] = $location->lat;
 590                 $options['lon'] = $location->lon;
 591                 if ($location->location_id) {
 592                     $options['location_ns'] = $location->location_ns;
 593                     $options['location_id'] = $location->location_id;
 594                 }
 595             }
 596         }
 597
 598         // Atom categories <-> hashtags
 599         foreach ($activity->categories as $cat) {
 600             if ($cat->term) {
 601                 $term = common_canonical_tag($cat->term);
 602                 if ($term) {
 603                     $options['tags'][] = $term;
 604                 }
 605             }
 606         }
 607
 608         // Atom enclosures -> attachment URLs
 609         foreach ($activity->enclosures as $href) {
 610             // @fixme save these locally or....?
 611             $options['urls'][] = $href;
 612         }
 613
 614         try {
 615             $saved = Notice::saveNew($oprofile->profile_id,
 616                                      $content,
 617                                      'ostatus',
 618                                      $options);
 619             if ($saved) {
 620                 Ostatus_source::saveNew($saved, $this, $method);
 621                 if (!empty($attachment)) {
 622                     File_to_post::processNew($attachment->id, $saved->id);
 623                 }
 624             }
 625         } catch (Exception $e) {
 626             common_log(LOG_ERR, "OStatus save of remote message $sourceUri failed: " . $e->getMessage());
 627             throw $e;
 628         }
 629         common_log(LOG_INFO, "OStatus saved remote message $sourceUri as notice id $saved->id");
 630         return $saved;
 631     }
 632
 633     /**
 634      * Clean up HTML
 635      */
 636     protected function purify($html)
 637     {
 638         require_once INSTALLDIR.'/extlib/htmLawed/htmLawed.php';
 639         $config = array('safe' => 1,
 640                         'deny_attribute' => 'id,style,on*');
 641         return htmLawed($html, $config);
 642     }
 643
 644     /**
 645      * Filters a list of recipient ID URIs to just those for local delivery.
 646      * @param Ostatus_profile local profile of sender
 647      * @param array in/out &$attention_uris set of URIs, will be pruned on output
 648      * @return array of group IDs
 649      */
 650     protected function filterReplies($sender, &$attention_uris)
 651     {
 652         common_log(LOG_DEBUG, "Original reply recipients: " . implode(', ', $attention_uris));
 653         $groups = array();
 654         $replies = array();
 655         foreach ($attention_uris as $recipient) {
 656             // Is the recipient a local user?
 657             $user = User::staticGet('uri', $recipient);
 658             if ($user) {
 659                 // @fixme sender verification, spam etc?
 660                 $replies[] = $recipient;
 661                 continue;
 662             }
 663
 664             // Is the recipient a remote group?
 665             $oprofile = Ostatus_profile::staticGet('uri', $recipient);
 666             if ($oprofile) {
 667                 if ($oprofile->isGroup()) {
 668                     // Deliver to local members of this remote group.
 669                     // @fixme sender verification?
 670                     $groups[] = $oprofile->group_id;
 671                 } else {
 672                     common_log(LOG_DEBUG, "Skipping reply to remote profile $recipient");
 673                 }
 674                 continue;
 675             }
 676
 677             // Is the recipient a local group?
 678             // @fixme uri on user_group isn't reliable yet
 679             // $group = User_group::staticGet('uri', $recipient);
 680             $id = OStatusPlugin::localGroupFromUrl($recipient);
 681             if ($id) {
 682                 $group = User_group::staticGet('id', $id);
 683                 if ($group) {
 684                     // Deliver to all members of this local group if allowed.
 685                     $profile = $sender->localProfile();
 686                     if ($profile->isMember($group)) {
 687                         $groups[] = $group->id;
 688                     } else {
 689                         common_log(LOG_DEBUG, "Skipping reply to local group $group->nickname as sender $profile->id is not a member");
 690                     }
 691                     continue;
 692                 } else {
 693                     common_log(LOG_DEBUG, "Skipping reply to bogus group $recipient");
 694                 }
 695             }
 696
 697             common_log(LOG_DEBUG, "Skipping reply to unrecognized profile $recipient");
 698
 699         }
 700         $attention_uris = $replies;
 701         common_log(LOG_DEBUG, "Local reply recipients: " . implode(', ', $replies));
 702         common_log(LOG_DEBUG, "Local group recipients: " . implode(', ', $groups));
 703         return $groups;
 704     }
 705
 706     /**
 707      * @param string $profile_url
 708      * @return Ostatus_profile
 709      * @throws FeedSubException
 710      */
 711     public static function ensureProfile($profile_uri, $hints=array())
 712     {
 713         // Get the canonical feed URI and check it
 714         $discover = new FeedDiscovery();
 715         if (isset($hints['feedurl'])) {
 716             $feeduri = $hints['feedurl'];
 717             $feeduri = $discover->discoverFromFeedURL($feeduri);
 718         } else {
 719             $feeduri = $discover->discoverFromURL($profile_uri);
 720             $hints['feedurl'] = $feeduri;
 721         }
 722
 723         $huburi = $discover->getAtomLink('hub');
 724         $hints['hub'] = $huburi;
 725         $salmonuri = $discover->getAtomLink(Salmon::NS_REPLIES);
 726         $hints['salmon'] = $salmonuri;
 727
 728         if (!$huburi) {
 729             // We can only deal with folks with a PuSH hub
 730             throw new FeedSubNoHubException();
 731         }
 732
 733         // Try to get a profile from the feed activity:subject
 734
 735         $feedEl = $discover->feed->documentElement;
 736
 737         $subject = ActivityUtils::child($feedEl, Activity::SUBJECT, Activity::SPEC);
 738
 739         if (!empty($subject)) {
 740             $subjObject = new ActivityObject($subject);
 741             return self::ensureActivityObjectProfile($subjObject, $hints);
 742         }
 743
 744         // Otherwise, try the feed author
 745
 746         $author = ActivityUtils::child($feedEl, Activity::AUTHOR, Activity::ATOM);
 747
 748         if (!empty($author)) {
 749             $authorObject = new ActivityObject($author);
 750             return self::ensureActivityObjectProfile($authorObject, $hints);
 751         }
 752
 753         // Sheesh. Not a very nice feed! Let's try fingerpoken in the
 754         // entries.
 755
 756         $entries = $discover->feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 757
 758         if (!empty($entries) && $entries->length > 0) {
 759
 760             $entry = $entries->item(0);
 761
 762             $actor = ActivityUtils::child($entry, Activity::ACTOR, Activity::SPEC);
 763
 764             if (!empty($actor)) {
 765                 $actorObject = new ActivityObject($actor);
 766                 return self::ensureActivityObjectProfile($actorObject, $hints);
 767
 768             }
 769
 770             $author = ActivityUtils::child($entry, Activity::AUTHOR, Activity::ATOM);
 771
 772             if (!empty($author)) {
 773                 $authorObject = new ActivityObject($author);
 774                 return self::ensureActivityObjectProfile($authorObject, $hints);
 775             }
 776         }
 777
 778         // XXX: make some educated guesses here
 779
 780         throw new FeedSubException("Can't find enough profile information to make a feed.");
 781     }
 782
 783     /**
 784      * Download and update given avatar image
 785      *
 786      * @param string $url
 787      * @throws Exception in various failure cases
 788      */
 789     protected function updateAvatar($url)
 790     {
 791         if ($url == $this->avatar) {
 792             // We've already got this one.
 793             return;
 794         }
 795         if (!common_valid_http_url($url)) {
 796             throw new ServerException(_m("Invalid avatar URL %s"), $url);
 797         }
 798
 799         if ($this->isGroup()) {
 800             $self = $this->localGroup();
 801         } else {
 802             $self = $this->localProfile();
 803         }
 804         if (!$self) {
 805             throw new ServerException(sprintf(
 806                 _m("Tried to update avatar for unsaved remote profile %s"),
 807                 $this->uri));
 808         }
 809
 810         // @fixme this should be better encapsulated
 811         // ripped from oauthstore.php (for old OMB client)
 812         $temp_filename = tempnam(sys_get_temp_dir(), 'listener_avatar');
 813         if (!copy($url, $temp_filename)) {
 814             throw new ServerException(sprintf(_m("Unable to fetch avatar from %s"), $url));
 815         }
 816
 817         if ($this->isGroup()) {
 818             $id = $this->group_id;
 819         } else {
 820             $id = $this->profile_id;
 821         }
 822         // @fixme should we be using different ids?
 823         $imagefile = new ImageFile($id, $temp_filename);
 824         $filename = Avatar::filename($id,
 825                                      image_type_to_extension($imagefile->type),
 826                                      null,
 827                                      common_timestamp());
 828         rename($temp_filename, Avatar::path($filename));
 829         $self->setOriginal($filename);
 830
 831         $orig = clone($this);
 832         $this->avatar = $url;
 833         $this->update($orig);
 834     }
 835
 836     /**
 837      * Pull avatar URL from ActivityObject or profile hints
 838      *
 839      * @param ActivityObject $object
 840      * @param array $hints
 841      * @return mixed URL string or false
 842      */
 843
 844     protected static function getActivityObjectAvatar($object, $hints=array())
 845     {
 846         if ($object->avatarLinks) {
 847             $best = false;
 848             // Take the exact-size avatar, or the largest avatar, or the first avatar if all sizeless
 849             foreach ($object->avatarLinks as $avatar) {
 850                 if ($avatar->width == AVATAR_PROFILE_SIZE && $avatar->height = AVATAR_PROFILE_SIZE) {
 851                     // Exact match!
 852                     $best = $avatar;
 853                     break;
 854                 }
 855                 if (!$best || $avatar->width > $best->width) {
 856                     $best = $avatar;
 857                 }
 858             }
 859             return $best->url;
 860         } else if (array_key_exists('avatar', $hints)) {
 861             return $hints['avatar'];
 862         }
 863         return false;
 864     }
 865
 866     /**
 867      * Get an appropriate avatar image source URL, if available.
 868      *
 869      * @param ActivityObject $actor
 870      * @param DOMElement $feed
 871      * @return string
 872      */
 873
 874     protected static function getAvatar($actor, $feed)
 875     {
 876         $url = '';
 877         $icon = '';
 878         if ($actor->avatar) {
 879             $url = trim($actor->avatar);
 880         }
 881         if (!$url) {
 882             // Check <atom:logo> and <atom:icon> on the feed
 883             $els = $feed->childNodes();
 884             if ($els && $els->length) {
 885                 for ($i = 0; $i < $els->length; $i++) {
 886                     $el = $els->item($i);
 887                     if ($el->namespaceURI == Activity::ATOM) {
 888                         if (empty($url) && $el->localName == 'logo') {
 889                             $url = trim($el->textContent);
 890                             break;
 891                         }
 892                         if (empty($icon) && $el->localName == 'icon') {
 893                             // Use as a fallback
 894                             $icon = trim($el->textContent);
 895                         }
 896                     }
 897                 }
 898             }
 899             if ($icon && !$url) {
 900                 $url = $icon;
 901             }
 902         }
 903         if ($url) {
 904             $opts = array('allowed_schemes' => array('http', 'https'));
 905             if (Validate::uri($url, $opts)) {
 906                 return $url;
 907             }
 908         }
 909         return common_path('plugins/OStatus/images/96px-Feed-icon.svg.png');
 910     }
 911
 912     /**
 913      * Fetch, or build if necessary, an Ostatus_profile for the actor
 914      * in a given Activity Streams activity.
 915      *
 916      * @param Activity $activity
 917      * @param string $feeduri if we already know the canonical feed URI!
 918      * @param string $salmonuri if we already know the salmon return channel URI
 919      * @return Ostatus_profile
 920      */
 921
 922     public static function ensureActorProfile($activity, $hints=array())
 923     {
 924         return self::ensureActivityObjectProfile($activity->actor, $hints);
 925     }
 926
 927     public static function ensureActivityObjectProfile($object, $hints=array())
 928     {
 929         $profile = self::getActivityObjectProfile($object);
 930         if ($profile) {
 931             $profile->updateFromActivityObject($object, $hints);
 932         } else {
 933             $profile = self::createActivityObjectProfile($object, $hints);
 934         }
 935         return $profile;
 936     }
 937
 938     /**
 939      * @param Activity $activity
 940      * @return mixed matching Ostatus_profile or false if none known
 941      */
 942     public static function getActorProfile($activity)
 943     {
 944         return self::getActivityObjectProfile($activity->actor);
 945     }
 946
 947     protected static function getActivityObjectProfile($object)
 948     {
 949         $uri = self::getActivityObjectProfileURI($object);
 950         return Ostatus_profile::staticGet('uri', $uri);
 951     }
 952
 953     protected static function getActorProfileURI($activity)
 954     {
 955         return self::getActivityObjectProfileURI($activity->actor);
 956     }
 957
 958     /**
 959      * @param Activity $activity
 960      * @return string
 961      * @throws ServerException
 962      */
 963     protected static function getActivityObjectProfileURI($object)
 964     {
 965         $opts = array('allowed_schemes' => array('http', 'https'));
 966         if ($object->id && Validate::uri($object->id, $opts)) {
 967             return $object->id;
 968         }
 969         if ($object->link && Validate::uri($object->link, $opts)) {
 970             return $object->link;
 971         }
 972         throw new ServerException("No author ID URI found");
 973     }
 974
 975     /**
 976      * @fixme validate stuff somewhere
 977      */
 978
 979     /**
 980      * Create local ostatus_profile and profile/user_group entries for
 981      * the provided remote user or group.
 982      *
 983      * @param ActivityObject $object
 984      * @param array $hints
 985      *
 986      * @return Ostatus_profile
 987      */
 988     protected static function createActivityObjectProfile($object, $hints=array())
 989     {
 990         $homeuri = $object->id;
 991         $discover = false;
 992
 993         if (!$homeuri) {
 994             common_log(LOG_DEBUG, __METHOD__ . " empty actor profile URI: " . var_export($activity, true));
 995             throw new Exception("No profile URI");
 996         }
 997
 998         if (OStatusPlugin::localProfileFromUrl($homeuri)) {
 999             throw new Exception("Local user can't be referenced as remote.");
1000         }
1001
1002         if (OStatusPlugin::localGroupFromUrl($homeuri)) {
1003             throw new Exception("Local group can't be referenced as remote.");
1004         }
1005
1006         if (array_key_exists('feedurl', $hints)) {
1007             $feeduri = $hints['feedurl'];
1008         } else {
1009             $discover = new FeedDiscovery();
1010             $feeduri = $discover->discoverFromURL($homeuri);
1011         }
1012
1013         if (array_key_exists('salmon', $hints)) {
1014             $salmonuri = $hints['salmon'];
1015         } else {
1016             if (!$discover) {
1017                 $discover = new FeedDiscovery();
1018                 $discover->discoverFromFeedURL($hints['feedurl']);
1019             }
1020             $salmonuri = $discover->getAtomLink(Salmon::NS_REPLIES);
1021         }
1022
1023         if (array_key_exists('hub', $hints)) {
1024             $huburi = $hints['hub'];
1025         } else {
1026             if (!$discover) {
1027                 $discover = new FeedDiscovery();
1028                 $discover->discoverFromFeedURL($hints['feedurl']);
1029             }
1030             $huburi = $discover->getAtomLink('hub');
1031         }
1032
1033         if (!$huburi) {
1034             // We can only deal with folks with a PuSH hub
1035             throw new FeedSubNoHubException();
1036         }
1037
1038         $oprofile = new Ostatus_profile();
1039
1040         $oprofile->uri        = $homeuri;
1041         $oprofile->feeduri    = $feeduri;
1042         $oprofile->salmonuri  = $salmonuri;
1043
1044         $oprofile->created    = common_sql_now();
1045         $oprofile->modified   = common_sql_now();
1046
1047         if ($object->type == ActivityObject::PERSON) {
1048             $profile = new Profile();
1049             $profile->created = common_sql_now();
1050             self::updateProfile($profile, $object, $hints);
1051
1052             $oprofile->profile_id = $profile->insert();
1053             if (!$oprofile->profile_id) {
1054                 throw new ServerException("Can't save local profile");
1055             }
1056         } else {
1057             $group = new User_group();
1058             $group->uri = $homeuri;
1059             $group->created = common_sql_now();
1060             self::updateGroup($group, $object, $hints);
1061
1062             $oprofile->group_id = $group->insert();
1063             if (!$oprofile->group_id) {
1064                 throw new ServerException("Can't save local profile");
1065             }
1066         }
1067
1068         $ok = $oprofile->insert();
1069
1070         if ($ok) {
1071             $avatar = self::getActivityObjectAvatar($object, $hints);
1072             if ($avatar) {
1073                 $oprofile->updateAvatar($avatar);
1074             }
1075             return $oprofile;
1076         } else {
1077             throw new ServerException("Can't save OStatus profile");
1078         }
1079     }
1080
1081     /**
1082      * Save any updated profile information to our local copy.
1083      * @param ActivityObject $object
1084      * @param array $hints
1085      */
1086     public function updateFromActivityObject($object, $hints=array())
1087     {
1088         if ($this->isGroup()) {
1089             $group = $this->localGroup();
1090             self::updateGroup($group, $object, $hints);
1091         } else {
1092             $profile = $this->localProfile();
1093             self::updateProfile($profile, $object, $hints);
1094         }
1095         $avatar = self::getActivityObjectAvatar($object, $hints);
1096         if ($avatar) {
1097             $this->updateAvatar($avatar);
1098         }
1099     }
1100
1101     protected static function updateProfile($profile, $object, $hints=array())
1102     {
1103         $orig = clone($profile);
1104
1105         $profile->nickname = self::getActivityObjectNickname($object, $hints);
1106
1107         if (!empty($object->title)) {
1108             $profile->fullname = $object->title;
1109         } else if (array_key_exists('fullname', $hints)) {
1110             $profile->fullname = $hints['fullname'];
1111         }
1112
1113         if (!empty($object->link)) {
1114             $profile->profileurl = $object->link;
1115         } else if (array_key_exists('profileurl', $hints)) {
1116             $profile->profileurl = $hints['profileurl'];
1117         } else if (Validate::uri($object->id, array('allowed_schemes' => array('http', 'https')))) {
1118             $profile->profileurl = $object->id;
1119         }
1120
1121         $profile->bio      = self::getActivityObjectBio($object, $hints);
1122         $profile->location = self::getActivityObjectLocation($object, $hints);
1123         $profile->homepage = self::getActivityObjectHomepage($object, $hints);
1124
1125         if (!empty($object->geopoint)) {
1126             $location = ActivityContext::locationFromPoint($object->geopoint);
1127             if (!empty($location)) {
1128                 $profile->lat = $location->lat;
1129                 $profile->lon = $location->lon;
1130             }
1131         }
1132
1133         // @fixme tags/categories
1134         // @todo tags from categories
1135
1136         if ($profile->id) {
1137             common_log(LOG_DEBUG, "Updating OStatus profile $profile->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1138             $profile->update($orig);
1139         }
1140     }
1141
1142     protected static function updateGroup($group, $object, $hints=array())
1143     {
1144         $orig = clone($group);
1145
1146         $group->nickname = self::getActivityObjectNickname($object, $hints);
1147         $group->fullname = $object->title;
1148
1149         if (!empty($object->link)) {
1150             $group->mainpage = $object->link;
1151         } else if (array_key_exists('profileurl', $hints)) {
1152             $group->mainpage = $hints['profileurl'];
1153         }
1154
1155         // @todo tags from categories
1156         $group->description = self::getActivityObjectBio($object, $hints);
1157         $group->location = self::getActivityObjectLocation($object, $hints);
1158         $group->homepage = self::getActivityObjectHomepage($object, $hints);
1159
1160         if ($group->id) {
1161             common_log(LOG_DEBUG, "Updating OStatus group $group->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1162             $group->update($orig);
1163         }
1164     }
1165
1166     protected static function getActivityObjectHomepage($object, $hints=array())
1167     {
1168         $homepage = null;
1169         $poco     = $object->poco;
1170
1171         if (!empty($poco)) {
1172             $url = $poco->getPrimaryURL();
1173             if ($url && $url->type == 'homepage') {
1174                 $homepage = $url->value;
1175             }
1176         }
1177
1178         // @todo Try for a another PoCo URL?
1179
1180         return $homepage;
1181     }
1182
1183     protected static function getActivityObjectLocation($object, $hints=array())
1184     {
1185         $location = null;
1186
1187         if (!empty($object->poco) &&
1188             isset($object->poco->address->formatted)) {
1189             $location = $object->poco->address->formatted;
1190         } else if (array_key_exists('location', $hints)) {
1191             $location = $hints['location'];
1192         }
1193
1194         if (!empty($location)) {
1195             if (mb_strlen($location) > 255) {
1196                 $location = mb_substr($note, 0, 255 - 3) . ' … ';
1197             }
1198         }
1199
1200         // @todo Try to find location some othe way? Via goerss point?
1201
1202         return $location;
1203     }
1204
1205     protected static function getActivityObjectBio($object, $hints=array())
1206     {
1207         $bio  = null;
1208
1209         if (!empty($object->poco)) {
1210             $note = $object->poco->note;
1211         } else if (array_key_exists('bio', $hints)) {
1212             $note = $hints['bio'];
1213         }
1214
1215         if (!empty($note)) {
1216             if (Profile::bioTooLong($note)) {
1217                 // XXX: truncate ok?
1218                 $bio = mb_substr($note, 0, Profile::maxBio() - 3) . ' … ';
1219             } else {
1220                 $bio = $note;
1221             }
1222         }
1223
1224         // @todo Try to get bio info some other way?
1225
1226         return $bio;
1227     }
1228
1229     protected static function getActivityObjectNickname($object, $hints=array())
1230     {
1231         if ($object->poco) {
1232             if (!empty($object->poco->preferredUsername)) {
1233                 return common_nicknamize($object->poco->preferredUsername);
1234             }
1235         }
1236
1237         if (!empty($object->nickname)) {
1238             return common_nicknamize($object->nickname);
1239         }
1240
1241         if (array_key_exists('nickname', $hints)) {
1242             return $hints['nickname'];
1243         }
1244
1245         // Try the definitive ID
1246
1247         $nickname = self::nicknameFromURI($object->id);
1248
1249         // Try a Webfinger if one was passed (way) down
1250
1251         if (empty($nickname)) {
1252             if (array_key_exists('webfinger', $hints)) {
1253                 $nickname = self::nicknameFromURI($hints['webfinger']);
1254             }
1255         }
1256
1257         // Try the name
1258
1259         if (empty($nickname)) {
1260             $nickname = common_nicknamize($object->title);
1261         }
1262
1263         return $nickname;
1264     }
1265
1266     protected static function nicknameFromURI($uri)
1267     {
1268         preg_match('/(\w+):/', $uri, $matches);
1269
1270         $protocol = $matches[1];
1271
1272         switch ($protocol) {
1273         case 'acct':
1274         case 'mailto':
1275             if (preg_match("/^$protocol:(.*)?@.*\$/", $uri, $matches)) {
1276                 return common_canonical_nickname($matches[1]);
1277             }
1278             return null;
1279         case 'http':
1280             return common_url_to_nickname($uri);
1281             break;
1282         default:
1283             return null;
1284         }
1285     }
1286
1287     /**
1288      * @param string $addr webfinger address
1289      * @return Ostatus_profile
1290      * @throws Exception on error conditions
1291      */
1292     public static function ensureWebfinger($addr)
1293     {
1294         // First, try the cache
1295
1296         $uri = self::cacheGet(sprintf('ostatus_profile:webfinger:%s', $addr));
1297
1298         if ($uri !== false) {
1299             if (is_null($uri)) {
1300                 // Negative cache entry
1301                 throw new Exception('Not a valid webfinger address.');
1302             }
1303             $oprofile = Ostatus_profile::staticGet('uri', $uri);
1304             if (!empty($oprofile)) {
1305                 return $oprofile;
1306             }
1307         }
1308
1309         // First, look it up
1310
1311         $oprofile = Ostatus_profile::staticGet('uri', 'acct:'.$addr);
1312
1313         if (!empty($oprofile)) {
1314             self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1315             return $oprofile;
1316         }
1317
1318         // Now, try some discovery
1319
1320         $disco = new Discovery();
1321
1322         try {
1323             $result = $disco->lookup($addr);
1324         } catch (Exception $e) {
1325             // Save negative cache entry so we don't waste time looking it up again.
1326             // @fixme distinguish temporary failures?
1327             self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), null);
1328             throw new Exception('Not a valid webfinger address.');
1329         }
1330
1331         $hints = array('webfinger' => $addr);
1332
1333         foreach ($result->links as $link) {
1334             switch ($link['rel']) {
1335             case Discovery::PROFILEPAGE:
1336                 $hints['profileurl'] = $profileUrl = $link['href'];
1337                 break;
1338             case Salmon::NS_REPLIES:
1339                 $hints['salmon'] = $salmonEndpoint = $link['href'];
1340                 break;
1341             case Discovery::UPDATESFROM:
1342                 $hints['feedurl'] = $feedUrl = $link['href'];
1343                 break;
1344             case Discovery::HCARD:
1345                 $hcardUrl = $link['href'];
1346                 break;
1347             default:
1348                 common_log(LOG_NOTICE, "Don't know what to do with rel = '{$link['rel']}'");
1349                 break;
1350             }
1351         }
1352
1353         if (isset($hcardUrl)) {
1354             $hcardHints = self::slurpHcard($hcardUrl);
1355             // Note: Webfinger > hcard
1356             $hints = array_merge($hcardHints, $hints);
1357         }
1358
1359         // If we got a feed URL, try that
1360
1361         if (isset($feedUrl)) {
1362             try {
1363                 common_log(LOG_INFO, "Discovery on acct:$addr with feed URL $feedUrl");
1364                 $oprofile = self::ensureProfile($feedUrl, $hints);
1365                 self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1366                 return $oprofile;
1367             } catch (Exception $e) {
1368                 common_log(LOG_WARNING, "Failed creating profile from feed URL '$feedUrl': " . $e->getMessage());
1369                 // keep looking
1370             }
1371         }
1372
1373         // If we got a profile page, try that!
1374
1375         if (isset($profileUrl)) {
1376             try {
1377                 common_log(LOG_INFO, "Discovery on acct:$addr with profile URL $profileUrl");
1378                 $oprofile = self::ensureProfile($profileUrl, $hints);
1379                 self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1380                 return $oprofile;
1381             } catch (Exception $e) {
1382                 common_log(LOG_WARNING, "Failed creating profile from profile URL '$profileUrl': " . $e->getMessage());
1383                 // keep looking
1384             }
1385         }
1386
1387         // XXX: try hcard
1388         // XXX: try FOAF
1389
1390         if (isset($salmonEndpoint)) {
1391
1392             // An account URL, a salmon endpoint, and a dream? Not much to go
1393             // on, but let's give it a try
1394
1395             $uri = 'acct:'.$addr;
1396
1397             $profile = new Profile();
1398
1399             $profile->nickname = self::nicknameFromUri($uri);
1400             $profile->created  = common_sql_now();
1401
1402             if (isset($profileUrl)) {
1403                 $profile->profileurl = $profileUrl;
1404             }
1405
1406             $profile_id = $profile->insert();
1407
1408             if (!$profile_id) {
1409                 common_log_db_error($profile, 'INSERT', __FILE__);
1410                 throw new Exception("Couldn't save profile for '$addr'");
1411             }
1412
1413             $oprofile = new Ostatus_profile();
1414
1415             $oprofile->uri        = $uri;
1416             $oprofile->salmonuri  = $salmonEndpoint;
1417             $oprofile->profile_id = $profile_id;
1418             $oprofile->created    = common_sql_now();
1419
1420             if (isset($feedUrl)) {
1421                 $profile->feeduri = $feedUrl;
1422             }
1423
1424             $result = $oprofile->insert();
1425
1426             if (!$result) {
1427                 common_log_db_error($oprofile, 'INSERT', __FILE__);
1428                 throw new Exception("Couldn't save ostatus_profile for '$addr'");
1429             }
1430
1431             self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1432             return $oprofile;
1433         }
1434
1435         throw new Exception("Couldn't find a valid profile for '$addr'");
1436     }
1437
1438     function saveHTMLFile($title, $rendered)
1439     {
1440         $final = sprintf("<!DOCTYPE html>\n<html><head><title>%s</title></head>".
1441                          '<body><div>%s</div></body></html>',
1442                          htmlspecialchars($title),
1443                          $rendered);
1444
1445         $filename = File::filename($this->localProfile(),
1446                                    'ostatus', // ignored?
1447                                    'text/html');
1448
1449         $filepath = File::path($filename);
1450
1451         file_put_contents($filepath, $final);
1452
1453         $file = new File;
1454
1455         $file->filename = $filename;
1456         $file->url      = File::url($filename);
1457         $file->size     = filesize($filepath);
1458         $file->date     = time();
1459         $file->mimetype = 'text/html';
1460
1461         $file_id = $file->insert();
1462
1463         if ($file_id === false) {
1464             common_log_db_error($file, "INSERT", __FILE__);
1465             throw new ServerException(_('Could not store HTML content of long post as file.'));
1466         }
1467
1468         return $file;
1469     }
1470
1471     protected static function slurpHcard($url)
1472     {
1473         set_include_path(get_include_path() . PATH_SEPARATOR . INSTALLDIR . '/plugins/OStatus/extlib/hkit/');
1474         require_once('hkit.class.php');
1475
1476         $h      = new hKit;
1477
1478         // Google Buzz hcards need to be tidied. Probably others too.
1479
1480         $h->tidy_mode = 'proxy'; // 'proxy', 'exec', 'php' or 'none'
1481
1482         // Get by URL
1483         $hcards = $h->getByURL('hcard', $url);
1484
1485         if (empty($hcards)) {
1486             return array();
1487         }
1488
1489         // @fixme more intelligent guess on multi-hcard pages
1490         $hcard = $hcards[0];
1491
1492         $hints = array();
1493
1494         $hints['profileurl'] = $url;
1495
1496         if (array_key_exists('nickname', $hcard)) {
1497             $hints['nickname'] = $hcard['nickname'];
1498         }
1499
1500         if (array_key_exists('fn', $hcard)) {
1501             $hints['fullname'] = $hcard['fn'];
1502         } else if (array_key_exists('n', $hcard)) {
1503             $hints['fullname'] = implode(' ', $hcard['n']);
1504         }
1505
1506         if (array_key_exists('photo', $hcard)) {
1507             $hints['avatar'] = $hcard['photo'];
1508         }
1509
1510         if (array_key_exists('note', $hcard)) {
1511             $hints['bio'] = $hcard['note'];
1512         }
1513
1514         if (array_key_exists('adr', $hcard)) {
1515             if (is_string($hcard['adr'])) {
1516                 $hints['location'] = $hcard['adr'];
1517             } else if (is_array($hcard['adr'])) {
1518                 $hints['location'] = implode(' ', $hcard['adr']);
1519             }
1520         }
1521
1522         if (array_key_exists('url', $hcard)) {
1523             if (is_string($hcard['url'])) {
1524                 $hints['homepage'] = $hcard['url'];
1525             } else if (is_array($hcard['url'])) {
1526                 // HACK get the last one; that's how our hcards look
1527                 $hints['homepage'] = $hcard['url'][count($hcard['url'])-1];
1528             }
1529         }
1530
1531         return $hints;
1532     }
1533 }