diff --git a/include/Contact.php b/include/Contact.php index a7a22671fe..c75de6afc8 100644 --- a/include/Contact.php +++ b/include/Contact.php @@ -5,6 +5,8 @@ use Friendica\Core\PConfig; use Friendica\Core\System; use Friendica\Core\Worker; use Friendica\Network\Probe; +use Friendica\Protocol\Diaspora; +use Friendica\Protocol\Dfrn; // Included here for completeness, but this is a very dangerous operation. // It is the caller's responsibility to confirm the requestor's intent and @@ -90,11 +92,9 @@ function terminate_friendship($user,$self,$contact) { slapper($user,$contact['notify'],$slap); } } elseif ($contact['network'] === NETWORK_DIASPORA) { - require_once 'include/diaspora.php'; Diaspora::send_unshare($user,$contact); } elseif ($contact['network'] === NETWORK_DFRN) { - require_once 'include/dfrn.php'; - dfrn::deliver($user,$contact,'placeholder', 1); + Dfrn::deliver($user,$contact,'placeholder', 1); } } diff --git a/include/api.php b/include/api.php index d677206b47..09ce9d6b26 100644 --- a/include/api.php +++ b/include/api.php @@ -9,6 +9,7 @@ use Friendica\App; use Friendica\Core\System; use Friendica\Core\Config; +use Friendica\Core\NotificationsManager; use Friendica\Core\Worker; require_once 'include/HTTPExceptions.php'; @@ -28,7 +29,6 @@ require_once 'mod/proxy.php'; require_once 'include/message.php'; require_once 'include/group.php'; require_once 'include/like.php'; -require_once 'include/NotificationsManager.php'; require_once 'include/plaintext.php'; require_once 'include/xml.php'; diff --git a/include/contact_selectors.php b/include/contact_selectors.php index 48f2fb005e..4109f38cd1 100644 --- a/include/contact_selectors.php +++ b/include/contact_selectors.php @@ -1,5 +1,6 @@ '); - $deliver_status = dfrn::deliver($owner, $contact, $data); + $deliver_status = Dfrn::deliver($owner, $contact, $data); if ($deliver_status == (-1)) { update_queue_time($q_item['id']); diff --git a/mod/dfrn_confirm.php b/mod/dfrn_confirm.php index e53abd2206..f0d5d76305 100644 --- a/mod/dfrn_confirm.php +++ b/mod/dfrn_confirm.php @@ -24,6 +24,7 @@ use Friendica\Core\PConfig; use Friendica\Core\System; use Friendica\Core\Worker; use Friendica\Network\Probe; +use Friendica\Protocol\Diaspora; require_once 'include/enotify.php'; require_once 'include/group.php'; @@ -438,7 +439,6 @@ function dfrn_confirm_post(App $a, $handsfree = null) { if ((isset($new_relation) && $new_relation == CONTACT_IS_FRIEND)) { if (($contact) && ($contact['network'] === NETWORK_DIASPORA)) { - require_once 'include/diaspora.php'; $ret = Diaspora::send_share($user[0],$r[0]); logger('share returns: ' . $ret); } diff --git a/mod/dfrn_notify.php b/mod/dfrn_notify.php index 5ff90d4851..65e9535c6a 100644 --- a/mod/dfrn_notify.php +++ b/mod/dfrn_notify.php @@ -8,9 +8,9 @@ use Friendica\App; use Friendica\Core\Config; +use Friendica\Protocol\Dfrn; require_once('include/items.php'); -require_once('include/dfrn.php'); require_once('include/event.php'); require_once('library/defuse/php-encryption-1.2.1/Crypto.php'); @@ -180,7 +180,7 @@ function dfrn_notify_post(App $a) { *we got a key. old code send only the key, without RINO version. * we assume RINO 1 if key and no RINO version */ - $data = dfrn::aes_decrypt(hex2bin($data), $final_key); + $data = Dfrn::aes_decrypt(hex2bin($data), $final_key); break; case 2: try { @@ -212,7 +212,7 @@ function dfrn_notify_post(App $a) { logger('rino: decrypted data: ' . $data, LOGGER_DATA); } - $ret = dfrn::import($data, $importer); + $ret = Dfrn::import($data, $importer); xml_status($ret, 'Processed'); // NOTREACHED diff --git a/mod/dfrn_poll.php b/mod/dfrn_poll.php index 2a5eff5667..6f3d843810 100644 --- a/mod/dfrn_poll.php +++ b/mod/dfrn_poll.php @@ -3,10 +3,10 @@ use Friendica\App; use Friendica\Core\Config; use Friendica\Core\System; +use Friendica\Protocol\Dfrn; require_once('include/items.php'); require_once('include/auth.php'); -require_once('include/dfrn.php'); require_once('include/ostatus.php'); function dfrn_poll_init(App $a) { @@ -58,7 +58,7 @@ function dfrn_poll_init(App $a) { logger('dfrn_poll: public feed request from ' . $_SERVER['REMOTE_ADDR'] . ' for ' . $user); header("Content-type: application/atom+xml"); - echo dfrn::feed('', $user,$last_update, 0, $hidewall); + echo Dfrn::feed('', $user,$last_update, 0, $hidewall); killme(); } @@ -387,7 +387,7 @@ function dfrn_poll_post(App $a) { } header("Content-type: application/atom+xml"); - $o = dfrn::feed($dfrn_id, $a->argv[1], $last_update, $direction); + $o = Dfrn::feed($dfrn_id, $a->argv[1], $last_update, $direction); echo $o; killme(); diff --git a/mod/display.php b/mod/display.php index d2ee12c570..62cb0445fe 100644 --- a/mod/display.php +++ b/mod/display.php @@ -3,8 +3,7 @@ use Friendica\App; use Friendica\Core\Config; use Friendica\Core\System; - -require_once('include/dfrn.php'); +use Friendica\Protocol\Dfrn; function display_init(App $a) { @@ -492,7 +491,7 @@ function display_content(App $a, $update = 0) { } function displayShowFeed($item_id, $conversation) { - $xml = dfrn::itemFeed($item_id, $conversation); + $xml = Dfrn::itemFeed($item_id, $conversation); if ($xml == '') { http_status_exit(500); } diff --git a/mod/fetch.php b/mod/fetch.php index 30c38bf543..9587afbf0e 100644 --- a/mod/fetch.php +++ b/mod/fetch.php @@ -5,9 +5,9 @@ This file is part of the Diaspora protocol. It is used for fetching single publi use Friendica\App; use Friendica\Core\System; +use Friendica\Protocol\Diaspora; require_once("include/crypto.php"); -require_once("include/diaspora.php"); require_once("include/xml.php"); function fetch_init(App $a) { diff --git a/mod/item.php b/mod/item.php index 51488fa728..61259df74a 100644 --- a/mod/item.php +++ b/mod/item.php @@ -20,6 +20,7 @@ use Friendica\Core\Config; use Friendica\Core\System; use Friendica\Core\Worker; use Friendica\Network\Probe; +use Friendica\Protocol\Diaspora; require_once 'include/crypto.php'; require_once 'include/enotify.php'; @@ -29,7 +30,6 @@ require_once 'include/files.php'; require_once 'include/threads.php'; require_once 'include/text.php'; require_once 'include/items.php'; -require_once 'include/diaspora.php'; require_once 'include/Contact.php'; function item_post(App $a) { diff --git a/mod/notifications.php b/mod/notifications.php index 95467a584f..271e400df5 100644 --- a/mod/notifications.php +++ b/mod/notifications.php @@ -6,9 +6,9 @@ */ use Friendica\App; +use Friendica\Core\NotificationsManager; use Friendica\Core\System; -require_once("include/NotificationsManager.php"); require_once("include/contact_selectors.php"); require_once("include/network.php"); diff --git a/mod/notify.php b/mod/notify.php index 867ead9fa7..6f7d222d8b 100644 --- a/mod/notify.php +++ b/mod/notify.php @@ -1,10 +1,9 @@ argc != 2) { diff --git a/mod/receive.php b/mod/receive.php index 68d304ae70..73382794dd 100644 --- a/mod/receive.php +++ b/mod/receive.php @@ -6,10 +6,10 @@ use Friendica\App; use Friendica\Core\Config; +use Friendica\Protocol\Diaspora; require_once('include/salmon.php'); require_once('include/crypto.php'); -require_once('include/diaspora.php'); function receive_post(App $a) { $enabled = intval(Config::get('system', 'diaspora_enabled')); diff --git a/object/Item.php b/object/Item.php index 6d2d35f345..fa8c893c7f 100644 --- a/object/Item.php +++ b/object/Item.php @@ -4,10 +4,10 @@ if(class_exists('Item')) use Friendica\Core\Config; use Friendica\Core\PConfig; +use Friendica\Protocol\Diaspora; require_once('object/BaseObject.php'); require_once('include/text.php'); -require_once('include/diaspora.php'); require_once('boot.php'); /** diff --git a/src/App.php b/src/App.php index 5c1c2bb9c1..7ff56cee3a 100644 --- a/src/App.php +++ b/src/App.php @@ -5,10 +5,10 @@ namespace Friendica; use Friendica\Core\System; use Friendica\Core\Config; use Friendica\Core\PConfig; +use Friendica\Database\Dbm; use Cache; use dba; -use dbm; use Detection\MobileDetect; @@ -706,7 +706,7 @@ class App { dba::transaction(); $r = q('SELECT `pid` FROM `process` WHERE `pid` = %d', intval(getmypid())); - if (!dbm::is_result($r)) { + if (!Dbm::is_result($r)) { dba::insert('process', array('pid' => getmypid(), 'command' => $command, 'created' => datetime_convert())); } dba::commit(); @@ -719,7 +719,7 @@ class App { dba::transaction(); $r = q('SELECT `pid` FROM `process`'); - if (dbm::is_result($r)) { + if (Dbm::is_result($r)) { foreach ($r AS $process) { if (!posix_kill($process['pid'], 0)) { q('DELETE FROM `process` WHERE `pid` = %d', intval($process['pid'])); @@ -806,7 +806,7 @@ class App { } } - $processlist = dbm::processlist(); + $processlist = Dbm::processlist(); if ($processlist['list'] != '') { logger('Processcheck: Processes: ' . $processlist['amount'] . ' - Processlist: ' . $processlist['list'], LOGGER_DEBUG); diff --git a/src/Core/Config.php b/src/Core/Config.php index be0d0def16..546177ff78 100644 --- a/src/Core/Config.php +++ b/src/Core/Config.php @@ -1,8 +1,8 @@ $family, 'k' => $key), array('limit' => 1)); - if (dbm::is_result($ret)) { + if (Dbm::is_result($ret)) { // manage array value $val = (preg_match("|^a:[0-9]+:{.*}$|s", $ret['v']) ? unserialize($ret['v']) : $ret['v']); diff --git a/src/Core/NotificationsManager.php b/src/Core/NotificationsManager.php new file mode 100644 index 0000000000..113091d7ec --- /dev/null +++ b/src/Core/NotificationsManager.php @@ -0,0 +1,868 @@ +a = get_app(); + } + + /** + * @brief set some extra note properties + * + * @param array $notes array of note arrays from db + * @return array Copy of input array with added properties + * + * Set some extra properties to note array from db: + * - timestamp as int in default TZ + * - date_rel : relative date string + * - msg_html: message as html string + * - msg_plain: message as plain text string + */ + private function _set_extra($notes) { + $rets = array(); + foreach($notes as $n) { + $local_time = datetime_convert('UTC',date_default_timezone_get(),$n['date']); + $n['timestamp'] = strtotime($local_time); + $n['date_rel'] = relative_date($n['date']); + $n['msg_html'] = bbcode($n['msg'], false, false, false, false); + $n['msg_plain'] = explode("\n",trim(html2plain($n['msg_html'], 0)))[0]; + + $rets[] = $n; + } + return $rets; + } + + + /** + * @brief Get all notifications for local_user() + * + * @param array $filter optional Array "column name"=>value: filter query by columns values + * @param string $order optional Space separated list of column to sort by. prepend name with "+" to sort ASC, "-" to sort DESC. Default to "-date" + * @param string $limit optional Query limits + * + * @return array of results or false on errors + */ + public function getAll($filter = array(), $order="-date", $limit="") { + $filter_str = array(); + $filter_sql = ""; + foreach($filter as $column => $value) { + $filter_str[] = sprintf("`%s` = '%s'", $column, dbesc($value)); + } + if (count($filter_str)>0) { + $filter_sql = "AND ".implode(" AND ", $filter_str); + } + + $aOrder = explode(" ", $order); + $asOrder = array(); + foreach($aOrder as $o) { + $dir = "asc"; + if ($o[0]==="-") { + $dir = "desc"; + $o = substr($o,1); + } + if ($o[0]==="+") { + $dir = "asc"; + $o = substr($o,1); + } + $asOrder[] = "$o $dir"; + } + $order_sql = implode(", ", $asOrder); + + if($limit!="") + $limit = " LIMIT ".$limit; + + $r = q("SELECT * FROM `notify` WHERE `uid` = %d $filter_sql ORDER BY $order_sql $limit", + intval(local_user()) + ); + + if (Dbm::is_result($r)) + return $this->_set_extra($r); + + return false; + } + + /** + * @brief Get one note for local_user() by $id value + * + * @param int $id + * @return array note values or null if not found + */ + public function getByID($id) { + $r = q("SELECT * FROM `notify` WHERE `id` = %d AND `uid` = %d LIMIT 1", + intval($id), + intval(local_user()) + ); + if (Dbm::is_result($r)) { + return $this->_set_extra($r)[0]; + } + return null; + } + + /** + * @brief set seen state of $note of local_user() + * + * @param array $note + * @param bool $seen optional true or false, default true + * @return bool true on success, false on errors + */ + public function setSeen($note, $seen = true) { + return q("UPDATE `notify` SET `seen` = %d WHERE ( `link` = '%s' OR ( `parent` != 0 AND `parent` = %d AND `otype` = '%s' )) AND `uid` = %d", + intval($seen), + dbesc($note['link']), + intval($note['parent']), + dbesc($note['otype']), + intval(local_user()) + ); + } + + /** + * @brief set seen state of all notifications of local_user() + * + * @param bool $seen optional true or false. default true + * @return bool true on success, false on error + */ + public function setAllSeen($seen = true) { + return q("UPDATE `notify` SET `seen` = %d WHERE `uid` = %d", + intval($seen), + intval(local_user()) + ); + } + + /** + * @brief List of pages for the Notifications TabBar + * + * @return array with with notifications TabBar data + */ + public function getTabs() { + $tabs = array( + array( + 'label' => t('System'), + 'url'=>'notifications/system', + 'sel'=> (($this->a->argv[1] == 'system') ? 'active' : ''), + 'id' => 'system-tab', + 'accesskey' => 'y', + ), + array( + 'label' => t('Network'), + 'url'=>'notifications/network', + 'sel'=> (($this->a->argv[1] == 'network') ? 'active' : ''), + 'id' => 'network-tab', + 'accesskey' => 'w', + ), + array( + 'label' => t('Personal'), + 'url'=>'notifications/personal', + 'sel'=> (($this->a->argv[1] == 'personal') ? 'active' : ''), + 'id' => 'personal-tab', + 'accesskey' => 'r', + ), + array( + 'label' => t('Home'), + 'url' => 'notifications/home', + 'sel'=> (($this->a->argv[1] == 'home') ? 'active' : ''), + 'id' => 'home-tab', + 'accesskey' => 'h', + ), + array( + 'label' => t('Introductions'), + 'url' => 'notifications/intros', + 'sel'=> (($this->a->argv[1] == 'intros') ? 'active' : ''), + 'id' => 'intro-tab', + 'accesskey' => 'i', + ), + ); + + return $tabs; + } + + /** + * @brief Format the notification query in an usable array + * + * @param array $notifs The array from the db query + * @param string $ident The notifications identifier (e.g. network) + * @return array + * string 'label' => The type of the notification + * string 'link' => URL to the source + * string 'image' => The avatar image + * string 'url' => The profile url of the contact + * string 'text' => The notification text + * string 'when' => The date of the notification + * string 'ago' => T relative date of the notification + * bool 'seen' => Is the notification marked as "seen" + */ + private function formatNotifs($notifs, $ident = "") { + + $notif = array(); + $arr = array(); + + if (Dbm::is_result($notifs)) { + + foreach ($notifs as $it) { + // Because we use different db tables for the notification query + // we have sometimes $it['unseen'] and sometimes $it['seen]. + // So we will have to transform $it['unseen'] + if (array_key_exists('unseen', $it)) { + $it['seen'] = ($it['unseen'] > 0 ? false : true); + } + + // Depending on the identifier of the notification we need to use different defaults + switch ($ident) { + case 'system': + $default_item_label = 'notify'; + $default_item_link = System::baseUrl(true).'/notify/view/'. $it['id']; + $default_item_image = proxy_url($it['photo'], false, PROXY_SIZE_MICRO); + $default_item_url = $it['url']; + $default_item_text = strip_tags(bbcode($it['msg'])); + $default_item_when = datetime_convert('UTC', date_default_timezone_get(), $it['date'], 'r'); + $default_item_ago = relative_date($it['date']); + break; + + case 'home': + $default_item_label = 'comment'; + $default_item_link = System::baseUrl(true).'/display/'.$it['pguid']; + $default_item_image = proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO); + $default_item_url = $it['author-link']; + $default_item_text = sprintf(t("%s commented on %s's post"), $it['author-name'], $it['pname']); + $default_item_when = datetime_convert('UTC', date_default_timezone_get(), $it['created'], 'r'); + $default_item_ago = relative_date($it['created']); + break; + + default: + $default_item_label = (($it['id'] == $it['parent']) ? 'post' : 'comment'); + $default_item_link = System::baseUrl(true).'/display/'.$it['pguid']; + $default_item_image = proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO); + $default_item_url = $it['author-link']; + $default_item_text = (($it['id'] == $it['parent']) + ? sprintf(t("%s created a new post"), $it['author-name']) + : sprintf(t("%s commented on %s's post"), $it['author-name'], $it['pname'])); + $default_item_when = datetime_convert('UTC', date_default_timezone_get(), $it['created'], 'r'); + $default_item_ago = relative_date($it['created']); + + } + + // Transform the different types of notification in an usable array + switch ($it['verb']){ + case ACTIVITY_LIKE: + $notif = array( + 'label' => 'like', + 'link' => System::baseUrl(true).'/display/'.$it['pguid'], + 'image' => proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO), + 'url' => $it['author-link'], + 'text' => sprintf(t("%s liked %s's post"), $it['author-name'], $it['pname']), + 'when' => $default_item_when, + 'ago' => $default_item_ago, + 'seen' => $it['seen'] + ); + break; + + case ACTIVITY_DISLIKE: + $notif = array( + 'label' => 'dislike', + 'link' => System::baseUrl(true).'/display/'.$it['pguid'], + 'image' => proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO), + 'url' => $it['author-link'], + 'text' => sprintf(t("%s disliked %s's post"), $it['author-name'], $it['pname']), + 'when' => $default_item_when, + 'ago' => $default_item_ago, + 'seen' => $it['seen'] + ); + break; + + case ACTIVITY_ATTEND: + $notif = array( + 'label' => 'attend', + 'link' => System::baseUrl(true).'/display/'.$it['pguid'], + 'image' => proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO), + 'url' => $it['author-link'], + 'text' => sprintf(t("%s is attending %s's event"), $it['author-name'], $it['pname']), + 'when' => $default_item_when, + 'ago' => $default_item_ago, + 'seen' => $it['seen'] + ); + break; + + case ACTIVITY_ATTENDNO: + $notif = array( + 'label' => 'attendno', + 'link' => System::baseUrl(true).'/display/'.$it['pguid'], + 'image' => proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO), + 'url' => $it['author-link'], + 'text' => sprintf( t("%s is not attending %s's event"), $it['author-name'], $it['pname']), + 'when' => $default_item_when, + 'ago' => $default_item_ago, + 'seen' => $it['seen'] + ); + break; + + case ACTIVITY_ATTENDMAYBE: + $notif = array( + 'label' => 'attendmaybe', + 'link' => System::baseUrl(true).'/display/'.$it['pguid'], + 'image' => proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO), + 'url' => $it['author-link'], + 'text' => sprintf(t("%s may attend %s's event"), $it['author-name'], $it['pname']), + 'when' => $default_item_when, + 'ago' => $default_item_ago, + 'seen' => $it['seen'] + ); + break; + + case ACTIVITY_FRIEND: + $xmlhead="<"."?xml version='1.0' encoding='UTF-8' ?".">"; + $obj = parse_xml_string($xmlhead.$it['object']); + $it['fname'] = $obj->title; + + $notif = array( + 'label' => 'friend', + 'link' => System::baseUrl(true).'/display/'.$it['pguid'], + 'image' => proxy_url($it['author-avatar'], false, PROXY_SIZE_MICRO), + 'url' => $it['author-link'], + 'text' => sprintf(t("%s is now friends with %s"), $it['author-name'], $it['fname']), + 'when' => $default_item_when, + 'ago' => $default_item_ago, + 'seen' => $it['seen'] + ); + break; + + default: + $notif = array( + 'label' => $default_item_label, + 'link' => $default_item_link, + 'image' => $default_item_image, + 'url' => $default_item_url, + 'text' => $default_item_text, + 'when' => $default_item_when, + 'ago' => $default_item_ago, + 'seen' => $it['seen'] + ); + } + + $arr[] = $notif; + } + } + + return $arr; + + } + + /** + * @brief Total number of network notifications + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @return int Number of network notifications + */ + private function networkTotal($seen = 0) { + $sql_seen = ""; + + if($seen === 0) + $sql_seen = " AND `item`.`unseen` = 1 "; + + $r = q("SELECT COUNT(*) AS `total` + FROM `item` INNER JOIN `item` AS `pitem` ON `pitem`.`id`=`item`.`parent` + WHERE `item`.`visible` = 1 AND `pitem`.`parent` != 0 AND + `item`.`deleted` = 0 AND `item`.`uid` = %d AND `item`.`wall` = 0 + $sql_seen", + intval(local_user()) + ); + + if (Dbm::is_result($r)) + return $r[0]['total']; + + return 0; + } + + /** + * @brief Get network notifications + * + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @param int $start Start the query at this point + * @param int $limit Maximum number of query results + * + * @return array with + * string 'ident' => Notification identifier + * int 'total' => Total number of available network notifications + * array 'notifications' => Network notifications + */ + public function networkNotifs($seen = 0, $start = 0, $limit = 80) { + $ident = 'network'; + $total = $this->networkTotal($seen); + $notifs = array(); + $sql_seen = ""; + + if($seen === 0) + $sql_seen = " AND `item`.`unseen` = 1 "; + + + $r = q("SELECT `item`.`id`,`item`.`parent`, `item`.`verb`, `item`.`author-name`, `item`.`unseen`, + `item`.`author-link`, `item`.`author-avatar`, `item`.`created`, `item`.`object` AS `object`, + `pitem`.`author-name` AS `pname`, `pitem`.`author-link` AS `plink`, `pitem`.`guid` AS `pguid` + FROM `item` INNER JOIN `item` AS `pitem` ON `pitem`.`id`=`item`.`parent` + WHERE `item`.`visible` = 1 AND `pitem`.`parent` != 0 AND + `item`.`deleted` = 0 AND `item`.`uid` = %d AND `item`.`wall` = 0 + $sql_seen + ORDER BY `item`.`created` DESC LIMIT %d, %d ", + intval(local_user()), + intval($start), + intval($limit) + ); + + if (Dbm::is_result($r)) + $notifs = $this->formatNotifs($r, $ident); + + $arr = array ( + 'notifications' => $notifs, + 'ident' => $ident, + 'total' => $total, + ); + + return $arr; + } + + /** + * @brief Total number of system notifications + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @return int Number of system notifications + */ + private function systemTotal($seen = 0) { + $sql_seen = ""; + + if($seen === 0) + $sql_seen = " AND `seen` = 0 "; + + $r = q("SELECT COUNT(*) AS `total` FROM `notify` WHERE `uid` = %d $sql_seen", + intval(local_user()) + ); + + if (Dbm::is_result($r)) + return $r[0]['total']; + + return 0; + } + + /** + * @brief Get system notifications + * + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @param int $start Start the query at this point + * @param int $limit Maximum number of query results + * + * @return array with + * string 'ident' => Notification identifier + * int 'total' => Total number of available system notifications + * array 'notifications' => System notifications + */ + public function systemNotifs($seen = 0, $start = 0, $limit = 80) { + $ident = 'system'; + $total = $this->systemTotal($seen); + $notifs = array(); + $sql_seen = ""; + + if($seen === 0) + $sql_seen = " AND `seen` = 0 "; + + $r = q("SELECT `id`, `url`, `photo`, `msg`, `date`, `seen` FROM `notify` + WHERE `uid` = %d $sql_seen ORDER BY `date` DESC LIMIT %d, %d ", + intval(local_user()), + intval($start), + intval($limit) + ); + + if (Dbm::is_result($r)) + $notifs = $this->formatNotifs($r, $ident); + + $arr = array ( + 'notifications' => $notifs, + 'ident' => $ident, + 'total' => $total, + ); + + return $arr; + } + + /** + * @brief Addional SQL query string for the personal notifications + * + * @return string The additional sql query + */ + private function _personal_sql_extra() { + $myurl = System::baseUrl(true) . '/profile/'. $this->a->user['nickname']; + $myurl = substr($myurl,strpos($myurl,'://')+3); + $myurl = str_replace(array('www.','.'),array('','\\.'),$myurl); + $diasp_url = str_replace('/profile/','/u/',$myurl); + $sql_extra = sprintf(" AND ( `item`.`author-link` regexp '%s' OR `item`.`tag` regexp '%s' OR `item`.`tag` regexp '%s' ) ", + dbesc($myurl . '$'), + dbesc($myurl . '\\]'), + dbesc($diasp_url . '\\]') + ); + + return $sql_extra; + } + + /** + * @brief Total number of personal notifications + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @return int Number of personal notifications + */ + private function personalTotal($seen = 0) { + $sql_seen = ""; + $sql_extra = $this->_personal_sql_extra(); + + if($seen === 0) + $sql_seen = " AND `item`.`unseen` = 1 "; + + $r = q("SELECT COUNT(*) AS `total` + FROM `item` INNER JOIN `item` AS `pitem` ON `pitem`.`id`=`item`.`parent` + WHERE `item`.`visible` = 1 + $sql_extra + $sql_seen + AND `item`.`deleted` = 0 AND `item`.`uid` = %d AND `item`.`wall` = 0 " , + intval(local_user()) + ); + + if (Dbm::is_result($r)) + return $r[0]['total']; + + return 0; + } + + /** + * @brief Get personal notifications + * + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @param int $start Start the query at this point + * @param int $limit Maximum number of query results + * + * @return array with + * string 'ident' => Notification identifier + * int 'total' => Total number of available personal notifications + * array 'notifications' => Personal notifications + */ + public function personalNotifs($seen = 0, $start = 0, $limit = 80) { + $ident = 'personal'; + $total = $this->personalTotal($seen); + $sql_extra = $this->_personal_sql_extra(); + $notifs = array(); + $sql_seen = ""; + + if($seen === 0) + $sql_seen = " AND `item`.`unseen` = 1 "; + + $r = q("SELECT `item`.`id`,`item`.`parent`, `item`.`verb`, `item`.`author-name`, `item`.`unseen`, + `item`.`author-link`, `item`.`author-avatar`, `item`.`created`, `item`.`object` AS `object`, + `pitem`.`author-name` AS `pname`, `pitem`.`author-link` AS `plink`, `pitem`.`guid` AS `pguid` + FROM `item` INNER JOIN `item` AS `pitem` ON `pitem`.`id`=`item`.`parent` + WHERE `item`.`visible` = 1 + $sql_extra + $sql_seen + AND `item`.`deleted` = 0 AND `item`.`uid` = %d AND `item`.`wall` = 0 + ORDER BY `item`.`created` DESC LIMIT %d, %d " , + intval(local_user()), + intval($start), + intval($limit) + ); + + if (Dbm::is_result($r)) + $notifs = $this->formatNotifs($r, $ident); + + $arr = array ( + 'notifications' => $notifs, + 'ident' => $ident, + 'total' => $total, + ); + + return $arr; + } + + /** + * @brief Total number of home notifications + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @return int Number of home notifications + */ + private function homeTotal($seen = 0) { + $sql_seen = ""; + + if($seen === 0) + $sql_seen = " AND `item`.`unseen` = 1 "; + + $r = q("SELECT COUNT(*) AS `total` FROM `item` + WHERE `item`.`visible` = 1 AND + `item`.`deleted` = 0 AND `item`.`uid` = %d AND `item`.`wall` = 1 + $sql_seen", + intval(local_user()) + ); + + if (Dbm::is_result($r)) + return $r[0]['total']; + + return 0; + } + + /** + * @brief Get home notifications + * + * @param int|string $seen + * If 0 only include notifications into the query + * which aren't marked as "seen" + * @param int $start Start the query at this point + * @param int $limit Maximum number of query results + * + * @return array with + * string 'ident' => Notification identifier + * int 'total' => Total number of available home notifications + * array 'notifications' => Home notifications + */ + public function homeNotifs($seen = 0, $start = 0, $limit = 80) { + $ident = 'home'; + $total = $this->homeTotal($seen); + $notifs = array(); + $sql_seen = ""; + + if($seen === 0) + $sql_seen = " AND `item`.`unseen` = 1 "; + + $r = q("SELECT `item`.`id`,`item`.`parent`, `item`.`verb`, `item`.`author-name`, `item`.`unseen`, + `item`.`author-link`, `item`.`author-avatar`, `item`.`created`, `item`.`object` AS `object`, + `pitem`.`author-name` AS `pname`, `pitem`.`author-link` AS `plink`, `pitem`.`guid` AS `pguid` + FROM `item` INNER JOIN `item` AS `pitem` ON `pitem`.`id`=`item`.`parent` + WHERE `item`.`visible` = 1 AND + `item`.`deleted` = 0 AND `item`.`uid` = %d AND `item`.`wall` = 1 + $sql_seen + ORDER BY `item`.`created` DESC LIMIT %d, %d ", + intval(local_user()), + intval($start), + intval($limit) + ); + + if (Dbm::is_result($r)) + $notifs = $this->formatNotifs($r, $ident); + + $arr = array ( + 'notifications' => $notifs, + 'ident' => $ident, + 'total' => $total, + ); + + return $arr; + } + + /** + * @brief Total number of introductions + * @param bool $all + * If false only include introductions into the query + * which aren't marked as ignored + * @return int Number of introductions + */ + private function introTotal($all = false) { + $sql_extra = ""; + + if(!$all) + $sql_extra = " AND `ignore` = 0 "; + + $r = q("SELECT COUNT(*) AS `total` FROM `intro` + WHERE `intro`.`uid` = %d $sql_extra AND `intro`.`blocked` = 0 ", + intval($_SESSION['uid']) + ); + + if (Dbm::is_result($r)) + return $r[0]['total']; + + return 0; + } + + /** + * @brief Get introductions + * + * @param bool $all + * If false only include introductions into the query + * which aren't marked as ignored + * @param int $start Start the query at this point + * @param int $limit Maximum number of query results + * + * @return array with + * string 'ident' => Notification identifier + * int 'total' => Total number of available introductions + * array 'notifications' => Introductions + */ + public function introNotifs($all = false, $start = 0, $limit = 80) { + $ident = 'introductions'; + $total = $this->introTotal($seen); + $notifs = array(); + $sql_extra = ""; + + if(!$all) + $sql_extra = " AND `ignore` = 0 "; + + /// @todo Fetch contact details by "get_contact_details_by_url" instead of queries to contact, fcontact and gcontact + $r = q("SELECT `intro`.`id` AS `intro_id`, `intro`.*, `contact`.*, + `fcontact`.`name` AS `fname`, `fcontact`.`url` AS `furl`, + `fcontact`.`photo` AS `fphoto`, `fcontact`.`request` AS `frequest`, + `gcontact`.`location` AS `glocation`, `gcontact`.`about` AS `gabout`, + `gcontact`.`keywords` AS `gkeywords`, `gcontact`.`gender` AS `ggender`, + `gcontact`.`network` AS `gnetwork`, `gcontact`.`addr` AS `gaddr` + FROM `intro` + LEFT JOIN `contact` ON `contact`.`id` = `intro`.`contact-id` + LEFT JOIN `gcontact` ON `gcontact`.`nurl` = `contact`.`nurl` + LEFT JOIN `fcontact` ON `intro`.`fid` = `fcontact`.`id` + WHERE `intro`.`uid` = %d $sql_extra AND `intro`.`blocked` = 0 + LIMIT %d, %d", + intval($_SESSION['uid']), + intval($start), + intval($limit) + ); + + if (Dbm::is_result($r)) + $notifs = $this->formatIntros($r); + + $arr = array ( + 'ident' => $ident, + 'total' => $total, + 'notifications' => $notifs, + ); + + return $arr; + } + + /** + * @brief Format the notification query in an usable array + * + * @param array $intros The array from the db query + * @return array with the introductions + */ + private function formatIntros($intros) { + $knowyou = ''; + + foreach($intros as $it) { + // There are two kind of introduction. Contacts suggested by other contacts and normal connection requests. + // We have to distinguish between these two because they use different data. + + // Contact suggestions + if($it['fid']) { + + $return_addr = bin2hex($this->a->user['nickname'] . '@' . $this->a->get_hostname() . (($this->a->path) ? '/' . $this->a->path : '')); + + $intro = array( + 'label' => 'friend_suggestion', + 'notify_type' => t('Friend Suggestion'), + 'intro_id' => $it['intro_id'], + 'madeby' => $it['name'], + 'contact_id' => $it['contact-id'], + 'photo' => ((x($it,'fphoto')) ? proxy_url($it['fphoto'], false, PROXY_SIZE_SMALL) : "images/person-175.jpg"), + 'name' => $it['fname'], + 'url' => zrl($it['furl']), + 'hidden' => $it['hidden'] == 1, + 'post_newfriend' => (intval(PConfig::get(local_user(),'system','post_newfriend')) ? '1' : 0), + + 'knowyou' => $knowyou, + 'note' => $it['note'], + 'request' => $it['frequest'] . '?addr=' . $return_addr, + + ); + + // Normal connection requests + } else { + + $it = $this->getMissingIntroData($it); + + // Don't show these data until you are connected. Diaspora is doing the same. + if($it['gnetwork'] === NETWORK_DIASPORA) { + $it['glocation'] = ""; + $it['gabout'] = ""; + $it['ggender'] = ""; + } + $intro = array( + 'label' => (($it['network'] !== NETWORK_OSTATUS) ? 'friend_request' : 'follower'), + 'notify_type' => (($it['network'] !== NETWORK_OSTATUS) ? t('Friend/Connect Request') : t('New Follower')), + 'dfrn_id' => $it['issued-id'], + 'uid' => $_SESSION['uid'], + 'intro_id' => $it['intro_id'], + 'contact_id' => $it['contact-id'], + 'photo' => ((x($it,'photo')) ? proxy_url($it['photo'], false, PROXY_SIZE_SMALL) : "images/person-175.jpg"), + 'name' => $it['name'], + 'location' => bbcode($it['glocation'], false, false), + 'about' => bbcode($it['gabout'], false, false), + 'keywords' => $it['gkeywords'], + 'gender' => $it['ggender'], + 'hidden' => $it['hidden'] == 1, + 'post_newfriend' => (intval(PConfig::get(local_user(),'system','post_newfriend')) ? '1' : 0), + 'url' => $it['url'], + 'zrl' => zrl($it['url']), + 'addr' => $it['gaddr'], + 'network' => $it['gnetwork'], + 'knowyou' => $it['knowyou'], + 'note' => $it['note'], + ); + } + + $arr[] = $intro; + } + + return $arr; + } + + /** + * @brief Check for missing contact data and try to fetch the data from + * from other sources + * + * @param array $arr The input array with the intro data + * + * @return array The array with the intro data + */ + private function getMissingIntroData($arr) { + // If the network and the addr isn't available from the gcontact + // table entry, take the one of the contact table entry + if ($arr['gnetwork'] == "") { + $arr['gnetwork'] = $arr['network']; + } + if ($arr['gaddr'] == "") { + $arr['gaddr'] = $arr['addr']; + } + + // If the network and addr is still not available + // get the missing data data from other sources + if ($arr['gnetwork'] == "" || $arr['gaddr'] == "") { + $ret = get_contact_details_by_url($arr['url']); + + if ($arr['gnetwork'] == "" && $ret['network'] != "") { + $arr['gnetwork'] = $ret['network']; + } + if ($arr['gaddr'] == "" && $ret['addr'] != "") { + $arr['gaddr'] = $ret['addr']; + } + } + + return $arr; + } +} diff --git a/src/Core/PConfig.php b/src/Core/PConfig.php index 1c64888247..9f6c49bb41 100644 --- a/src/Core/PConfig.php +++ b/src/Core/PConfig.php @@ -1,8 +1,8 @@ $family, 'uid' => $uid)); - if (dbm::is_result($r)) { + if (Dbm::is_result($r)) { while ($rr = dba::fetch($r)) { $k = $rr['k']; $a->config[$uid][$family][$k] = $rr['v']; @@ -90,7 +90,7 @@ class PConfig { } $ret = dba::select('pconfig', array('v'), array('uid' => $uid, 'cat' => $family, 'k' => $key), array('limit' => 1)); - if (dbm::is_result($ret)) { + if (Dbm::is_result($ret)) { $val = (preg_match("|^a:[0-9]+:{.*}$|s", $ret['v']) ? unserialize($ret['v']) : $ret['v']); $a->config[$uid][$family][$key] = $val; self::$in_db[$uid][$family][$key] = true; diff --git a/src/Core/Worker.php b/src/Core/Worker.php index e1787071cb..148b707d14 100644 --- a/src/Core/Worker.php +++ b/src/Core/Worker.php @@ -5,10 +5,10 @@ use Friendica\App; use Friendica\Core\System; use Friendica\Core\Config; use Friendica\Core\Worker; +use Friendica\Database\Dbm; use Friendica\Util\Lock; use dba; -use dbm; /** * @file src/Core/Worker.php @@ -142,7 +142,7 @@ class Worker { */ private static function totalEntries() { $s = dba::fetch_first("SELECT COUNT(*) AS `total` FROM `workerqueue` WHERE `executed` <= ? AND NOT `done`", NULL_DATE); - if (dbm::is_result($s)) { + if (Dbm::is_result($s)) { return $s["total"]; } else { return 0; @@ -157,7 +157,7 @@ class Worker { private static function highestPriority() { $condition = array("`executed` <= ? AND NOT `done`", NULL_DATE); $s = dba::select('workerqueue', array('priority'), $condition, array('limit' => 1, 'order' => array('priority'))); - if (dbm::is_result($s)) { + if (Dbm::is_result($s)) { return $s["priority"]; } else { return 0; @@ -405,7 +405,7 @@ class Worker { if ($max == 0) { // the maximum number of possible user connections can be a system variable $r = dba::fetch_first("SHOW VARIABLES WHERE `variable_name` = 'max_user_connections'"); - if (dbm::is_result($r)) { + if (Dbm::is_result($r)) { $max = $r["Value"]; } // Or it can be granted. This overrides the system variable @@ -441,7 +441,7 @@ class Worker { // We will now check for the system values. // This limit could be reached although the user limits are fine. $r = dba::fetch_first("SHOW VARIABLES WHERE `variable_name` = 'max_connections'"); - if (!dbm::is_result($r)) { + if (!Dbm::is_result($r)) { return false; } $max = intval($r["Value"]); @@ -449,7 +449,7 @@ class Worker { return false; } $r = dba::fetch_first("SHOW STATUS WHERE `variable_name` = 'Threads_connected'"); - if (!dbm::is_result($r)) { + if (!Dbm::is_result($r)) { return false; } $used = intval($r["Value"]); @@ -631,7 +631,7 @@ class Worker { INNER JOIN `workerqueue` ON `workerqueue`.`pid` = `process`.`pid` AND NOT `done`"); // No active processes at all? Fine - if (!dbm::is_result($r)) { + if (!Dbm::is_result($r)) { return false; } $priorities = array(); @@ -754,7 +754,7 @@ class Worker { // There can already be jobs for us in the queue. $r = dba::select('workerqueue', array(), array('pid' => getmypid(), 'done' => false)); - if (dbm::is_result($r)) { + if (Dbm::is_result($r)) { self::$db_duration += (microtime(true) - $stamp); return dba::inArray($r); } diff --git a/src/Database/Dbm.php b/src/Database/Dbm.php new file mode 100644 index 0000000000..c5db97f0ee --- /dev/null +++ b/src/Database/Dbm.php @@ -0,0 +1,115 @@ + List of processes, separated in their different states + * 'amount' => Number of concurrent database processes + */ + public static function processlist() { + $r = q("SHOW PROCESSLIST"); + $s = array(); + + $processes = 0; + $states = array(); + foreach ($r AS $process) { + $state = trim($process["State"]); + + // Filter out all non blocking processes + if (!in_array($state, array("", "init", "statistics", "updating"))) { + ++$states[$state]; + ++$processes; + } + } + + $statelist = ""; + foreach ($states AS $state => $usage) { + if ($statelist != "") + $statelist .= ", "; + $statelist .= $state.": ".$usage; + } + return(array("list" => $statelist, "amount" => $processes)); + } + + /** + * Checks if $array is a filled array with at least one entry. + * + * @param $array mixed A filled array with at least one entry + * @return Whether $array is a filled array or an object with rows + */ + public static function is_result($array) { + // It could be a return value from an update statement + if (is_bool($array)) { + return $array; + } + + if (is_object($array)) { + return dba::num_rows($array) > 0; + } + + return (is_array($array) && (count($array) > 0)); + } + + /** + * @brief Callback function for "esc_array" + * + * @param mixed $value Array value + * @param string $key Array key + * @param boolean $add_quotation add quotation marks for string values + */ + private static function esc_array_callback(&$value, $key, $add_quotation) { + + if (!$add_quotation) { + if (is_bool($value)) { + $value = ($value ? '1' : '0'); + } else { + $value = dbesc($value); + } + return; + } + + if (is_bool($value)) { + $value = ($value ? 'true' : 'false'); + } elseif (is_float($value) || is_integer($value)) { + $value = (string)$value; + } else { + $value = "'".dbesc($value)."'"; + } + } + + /** + * @brief Escapes a whole array + * + * @param mixed $arr Array with values to be escaped + * @param boolean $add_quotation add quotation marks for string values + */ + public static function esc_array(&$arr, $add_quotation = false) { + array_walk($arr, 'self::esc_array_callback', $add_quotation); + } + + /** + * Checks Converts any date string into a SQL compatible date string + * + * @param string $date a date string in any format + * @return string SQL style date string + */ + public static function date($date = 'now') { + $timestamp = strtotime($date); + + // Don't allow lower date strings as '0001-01-01 00:00:00' + if ($timestamp < -62135596800) { + $timestamp = -62135596800; + } + + return date('Y-m-d H:i:s', (int)$timestamp); + } +} diff --git a/src/Network/Probe.php b/src/Network/Probe.php index 2f79fe80e1..7e1d28ef8a 100644 --- a/src/Network/Probe.php +++ b/src/Network/Probe.php @@ -11,9 +11,9 @@ namespace Friendica\Network; use Friendica\App; use Friendica\Core\System; use Friendica\Core\Config; +use Friendica\Database\Dbm; use dba; -use dbm; use Cache; use xml; @@ -397,7 +397,7 @@ class Probe { } } - $fields['updated'] = dbm::date(); + $fields['updated'] = Dbm::date(); $condition = array('nurl' => normalise_link($data["url"])); @@ -420,7 +420,7 @@ class Probe { 'confirm' => $data['confirm'], 'poco' => $data['poco'], 'network' => $data['network'], - 'success_update' => dbm::date()); + 'success_update' => Dbm::date()); $fieldnames = array(); @@ -1501,7 +1501,7 @@ class Probe { $r = q("SELECT * FROM `mailacct` WHERE `uid` = %d AND `server` != '' LIMIT 1", intval($uid)); - if (dbm::is_result($x) && dbm::is_result($r)) { + if (Dbm::is_result($x) && Dbm::is_result($r)) { $mailbox = construct_mailbox_name($r[0]); $password = ''; openssl_private_decrypt(hex2bin($r[0]['pass']), $password, $x[0]['prvkey']); diff --git a/src/Protocol/Dfrn.php b/src/Protocol/Dfrn.php new file mode 100644 index 0000000000..d0597603a2 --- /dev/null +++ b/src/Protocol/Dfrn.php @@ -0,0 +1,2970 @@ +formatOutput = true; + + $root = self::add_header($doc, $owner, "dfrn:owner", "", false); + + if (! count($items)) { + return trim($doc->saveXML()); + } + + foreach ($items as $item) { + $entry = self::entry($doc, "text", $item, $owner, $item["entry:comment-allow"], $item["entry:cid"]); + $root->appendChild($entry); + } + + return(trim($doc->saveXML())); + } + + /** + * @brief Generate an atom feed for the given user + * + * This function is called when another server is pulling data from the user feed. + * + * @param string $dfrn_id DFRN ID from the requesting party + * @param string $owner_nick Owner nick name + * @param string $last_update Date of the last update + * @param int $direction Can be -1, 0 or 1. + * @param boolean $onlyheader Output only the header without content? (Default is "no") + * + * @return string DFRN feed entries + */ + public static function feed($dfrn_id, $owner_nick, $last_update, $direction = 0, $onlyheader = false) { + + $a = get_app(); + + $sitefeed = ((strlen($owner_nick)) ? false : true); // not yet implemented, need to rewrite huge chunks of following logic + $public_feed = (($dfrn_id) ? false : true); + $starred = false; // not yet implemented, possible security issues + $converse = false; + + if ($public_feed && $a->argc > 2) { + for ($x = 2; $x < $a->argc; $x++) { + if ($a->argv[$x] == 'converse') { + $converse = true; + } + if ($a->argv[$x] == 'starred') { + $starred = true; + } + if ($a->argv[$x] == 'category' && $a->argc > ($x + 1) && strlen($a->argv[$x+1])) { + $category = $a->argv[$x+1]; + } + } + } + + + + // default permissions - anonymous user + + $sql_extra = " AND `item`.`allow_cid` = '' AND `item`.`allow_gid` = '' AND `item`.`deny_cid` = '' AND `item`.`deny_gid` = '' "; + + $r = q("SELECT `contact`.*, `user`.`nickname`, `user`.`timezone`, `user`.`page-flags`, `user`.`account-type` + FROM `contact` INNER JOIN `user` ON `user`.`uid` = `contact`.`uid` + WHERE `contact`.`self` AND `user`.`nickname` = '%s' LIMIT 1", + dbesc($owner_nick) + ); + + if (! Dbm::is_result($r)) { + killme(); + } + + $owner = $r[0]; + $owner_id = $owner['uid']; + $owner_nick = $owner['nickname']; + + $sql_post_table = ""; + + if (! $public_feed) { + + $sql_extra = ''; + switch($direction) { + case (-1): + $sql_extra = sprintf(" AND `issued-id` = '%s' ", dbesc($dfrn_id)); + $my_id = $dfrn_id; + break; + case 0: + $sql_extra = sprintf(" AND `issued-id` = '%s' AND `duplex` = 1 ", dbesc($dfrn_id)); + $my_id = '1:' . $dfrn_id; + break; + case 1: + $sql_extra = sprintf(" AND `dfrn-id` = '%s' AND `duplex` = 1 ", dbesc($dfrn_id)); + $my_id = '0:' . $dfrn_id; + break; + default: + return false; + break; // NOTREACHED + } + + $r = q("SELECT * FROM `contact` WHERE NOT `blocked` AND `contact`.`uid` = %d $sql_extra LIMIT 1", + intval($owner_id) + ); + + if (! Dbm::is_result($r)) { + killme(); + } + + $contact = $r[0]; + require_once('include/security.php'); + $groups = init_groups_visitor($contact['id']); + + if (count($groups)) { + for ($x = 0; $x < count($groups); $x ++) + $groups[$x] = '<' . intval($groups[$x]) . '>' ; + $gs = implode('|', $groups); + } else { + $gs = '<<>>' ; // Impossible to match + } + + $sql_extra = sprintf(" + AND ( `allow_cid` = '' OR `allow_cid` REGEXP '<%d>' ) + AND ( `deny_cid` = '' OR NOT `deny_cid` REGEXP '<%d>' ) + AND ( `allow_gid` = '' OR `allow_gid` REGEXP '%s' ) + AND ( `deny_gid` = '' OR NOT `deny_gid` REGEXP '%s') + ", + intval($contact['id']), + intval($contact['id']), + dbesc($gs), + dbesc($gs) + ); + } + + if ($public_feed) { + $sort = 'DESC'; + } else { + $sort = 'ASC'; + } + + if (! strlen($last_update)) { + $last_update = 'now -30 days'; + } + + if (isset($category)) { + $sql_post_table = sprintf("INNER JOIN (SELECT `oid` FROM `term` WHERE `term` = '%s' AND `otype` = %d AND `type` = %d AND `uid` = %d ORDER BY `tid` DESC) AS `term` ON `item`.`id` = `term`.`oid` ", + dbesc(protect_sprintf($category)), intval(TERM_OBJ_POST), intval(TERM_CATEGORY), intval($owner_id)); + //$sql_extra .= file_tag_file_query('item',$category,'category'); + } + + if ($public_feed) { + if (! $converse) { + $sql_extra .= " AND `contact`.`self` = 1 "; + } + } + + $check_date = datetime_convert('UTC','UTC',$last_update,'Y-m-d H:i:s'); + + $r = q("SELECT `item`.*, `item`.`id` AS `item_id`, + `contact`.`name`, `contact`.`network`, `contact`.`photo`, `contact`.`url`, + `contact`.`name-date`, `contact`.`uri-date`, `contact`.`avatar-date`, + `contact`.`thumb`, `contact`.`dfrn-id`, `contact`.`self`, + `sign`.`signed_text`, `sign`.`signature`, `sign`.`signer` + FROM `item` USE INDEX (`uid_wall_changed`) $sql_post_table + STRAIGHT_JOIN `contact` ON `contact`.`id` = `item`.`contact-id` + AND (NOT `contact`.`blocked` OR `contact`.`pending`) + LEFT JOIN `sign` ON `sign`.`iid` = `item`.`id` + WHERE `item`.`uid` = %d AND `item`.`visible` AND NOT `item`.`moderated` AND `item`.`parent` != 0 + AND `item`.`wall` AND `item`.`changed` > '%s' + $sql_extra + ORDER BY `item`.`parent` ".$sort.", `item`.`created` ASC LIMIT 0, 300", + intval($owner_id), + dbesc($check_date), + dbesc($sort) + ); + + /* + * Will check further below if this actually returned results. + * We will provide an empty feed if that is the case. + */ + + $items = $r; + + $doc = new DOMDocument('1.0', 'utf-8'); + $doc->formatOutput = true; + + $alternatelink = $owner['url']; + + if (isset($category)) { + $alternatelink .= "/category/".$category; + } + + if ($public_feed) { + $author = "dfrn:owner"; + } else { + $author = "author"; + } + + $root = self::add_header($doc, $owner, $author, $alternatelink, true); + + /// @TODO This hook can't work anymore + // call_hooks('atom_feed', $atom); + + if (!Dbm::is_result($items) || $onlyheader) { + $atom = trim($doc->saveXML()); + + call_hooks('atom_feed_end', $atom); + + return $atom; + } + + foreach ($items as $item) { + + // prevent private email from leaking. + if ($item['network'] == NETWORK_MAIL) { + continue; + } + + // public feeds get html, our own nodes use bbcode + + if ($public_feed) { + $type = 'html'; + // catch any email that's in a public conversation and make sure it doesn't leak + if ($item['private']) { + continue; + } + } else { + $type = 'text'; + } + + $entry = self::entry($doc, $type, $item, $owner, true); + $root->appendChild($entry); + + } + + $atom = trim($doc->saveXML()); + + call_hooks('atom_feed_end', $atom); + + return $atom; + } + + /** + * @brief Generate an atom entry for a given item id + * + * @param int $item_id The item id + * @param boolean $conversation Show the conversation. If false show the single post. + * + * @return string DFRN feed entry + */ + public static function itemFeed($item_id, $conversation = false) { + if ($conversation) { + $condition = '`item`.`parent`'; + } else { + $condition = '`item`.`id`'; + } + + $r = q("SELECT `item`.*, `item`.`id` AS `item_id`, + `contact`.`name`, `contact`.`network`, `contact`.`photo`, `contact`.`url`, + `contact`.`name-date`, `contact`.`uri-date`, `contact`.`avatar-date`, + `contact`.`thumb`, `contact`.`dfrn-id`, `contact`.`self`, + `sign`.`signed_text`, `sign`.`signature`, `sign`.`signer` + FROM `item` + STRAIGHT_JOIN `contact` ON `contact`.`id` = `item`.`contact-id` + AND (NOT `contact`.`blocked` OR `contact`.`pending`) + LEFT JOIN `sign` ON `sign`.`iid` = `item`.`id` + WHERE %s = %d AND `item`.`visible` AND NOT `item`.`moderated` AND `item`.`parent` != 0 + AND NOT `item`.`private`", + $condition, + intval($item_id) + ); + + if (!Dbm::is_result($r)) { + killme(); + } + + $items = $r; + $item = $r[0]; + + $r = q("SELECT `contact`.*, `user`.`nickname`, `user`.`timezone`, `user`.`page-flags`, `user`.`account-type` + FROM `contact` INNER JOIN `user` ON `user`.`uid` = `contact`.`uid` + WHERE `contact`.`self` AND `user`.`uid` = %d LIMIT 1", + intval($item['uid']) + ); + + if (!Dbm::is_result($r)) { + killme(); + } + + $owner = $r[0]; + + $doc = new DOMDocument('1.0', 'utf-8'); + $doc->formatOutput = true; + $type = 'html'; + + if ($conversation) { + $root = $doc->createElementNS(NAMESPACE_ATOM1, 'feed'); + $doc->appendChild($root); + + $root->setAttribute("xmlns:thr", NAMESPACE_THREAD); + $root->setAttribute("xmlns:at", NAMESPACE_TOMB); + $root->setAttribute("xmlns:media", NAMESPACE_MEDIA); + $root->setAttribute("xmlns:dfrn", NAMESPACE_DFRN); + $root->setAttribute("xmlns:activity", NAMESPACE_ACTIVITY); + $root->setAttribute("xmlns:georss", NAMESPACE_GEORSS); + $root->setAttribute("xmlns:poco", NAMESPACE_POCO); + $root->setAttribute("xmlns:ostatus", NAMESPACE_OSTATUS); + $root->setAttribute("xmlns:statusnet", NAMESPACE_STATUSNET); + + //$root = self::add_header($doc, $owner, "dfrn:owner", "", false); + + foreach ($items as $item) { + $entry = self::entry($doc, $type, $item, $owner, true, 0); + $root->appendChild($entry); + } + } else { + $root = self::entry($doc, $type, $item, $owner, true, 0, true); + } + + $atom = trim($doc->saveXML()); + return $atom; + } + + /** + * @brief Create XML text for DFRN mails + * + * @param array $item message elements + * @param array $owner Owner record + * + * @return string DFRN mail + * @todo Add type-hints + */ + public static function mail($item, $owner) { + $doc = new DOMDocument('1.0', 'utf-8'); + $doc->formatOutput = true; + + $root = self::add_header($doc, $owner, "dfrn:owner", "", false); + + $mail = $doc->createElement("dfrn:mail"); + $sender = $doc->createElement("dfrn:sender"); + + xml::add_element($doc, $sender, "dfrn:name", $owner['name']); + xml::add_element($doc, $sender, "dfrn:uri", $owner['url']); + xml::add_element($doc, $sender, "dfrn:avatar", $owner['thumb']); + + $mail->appendChild($sender); + + xml::add_element($doc, $mail, "dfrn:id", $item['uri']); + xml::add_element($doc, $mail, "dfrn:in-reply-to", $item['parent-uri']); + xml::add_element($doc, $mail, "dfrn:sentdate", datetime_convert('UTC', 'UTC', $item['created'] . '+00:00' , ATOM_TIME)); + xml::add_element($doc, $mail, "dfrn:subject", $item['title']); + xml::add_element($doc, $mail, "dfrn:content", $item['body']); + + $root->appendChild($mail); + + return(trim($doc->saveXML())); + } + + /** + * @brief Create XML text for DFRN friend suggestions + * + * @param array $item suggestion elements + * @param array $owner Owner record + * + * @return string DFRN suggestions + * @todo Add type-hints + */ + public static function fsuggest($item, $owner) { + $doc = new DOMDocument('1.0', 'utf-8'); + $doc->formatOutput = true; + + $root = self::add_header($doc, $owner, "dfrn:owner", "", false); + + $suggest = $doc->createElement("dfrn:suggest"); + + xml::add_element($doc, $suggest, "dfrn:url", $item['url']); + xml::add_element($doc, $suggest, "dfrn:name", $item['name']); + xml::add_element($doc, $suggest, "dfrn:photo", $item['photo']); + xml::add_element($doc, $suggest, "dfrn:request", $item['request']); + xml::add_element($doc, $suggest, "dfrn:note", $item['note']); + + $root->appendChild($suggest); + + return(trim($doc->saveXML())); + } + + /** + * @brief Create XML text for DFRN relocations + * + * @param array $owner Owner record + * @param int $uid User ID + * + * @return string DFRN relocations + * @todo Add type-hints + */ + public static function relocate($owner, $uid) { + + /* get site pubkey. this could be a new installation with no site keys*/ + $pubkey = Config::get('system','site_pubkey'); + if (! $pubkey) { + $res = new_keypair(1024); + Config::set('system','site_prvkey', $res['prvkey']); + Config::set('system','site_pubkey', $res['pubkey']); + } + + $rp = q("SELECT `resource-id` , `scale`, type FROM `photo` + WHERE `profile` = 1 AND `uid` = %d ORDER BY scale;", $uid); + $photos = array(); + $ext = Photo::supportedTypes(); + + foreach ($rp as $p) { + $photos[$p['scale']] = System::baseUrl().'/photo/'.$p['resource-id'].'-'.$p['scale'].'.'.$ext[$p['type']]; + } + + unset($rp, $ext); + + $doc = new DOMDocument('1.0', 'utf-8'); + $doc->formatOutput = true; + + $root = self::add_header($doc, $owner, "dfrn:owner", "", false); + + $relocate = $doc->createElement("dfrn:relocate"); + + xml::add_element($doc, $relocate, "dfrn:url", $owner['url']); + xml::add_element($doc, $relocate, "dfrn:name", $owner['name']); + xml::add_element($doc, $relocate, "dfrn:addr", $owner['addr']); + xml::add_element($doc, $relocate, "dfrn:avatar", $owner['avatar']); + xml::add_element($doc, $relocate, "dfrn:photo", $photos[4]); + xml::add_element($doc, $relocate, "dfrn:thumb", $photos[5]); + xml::add_element($doc, $relocate, "dfrn:micro", $photos[6]); + xml::add_element($doc, $relocate, "dfrn:request", $owner['request']); + xml::add_element($doc, $relocate, "dfrn:confirm", $owner['confirm']); + xml::add_element($doc, $relocate, "dfrn:notify", $owner['notify']); + xml::add_element($doc, $relocate, "dfrn:poll", $owner['poll']); + xml::add_element($doc, $relocate, "dfrn:sitepubkey", Config::get('system','site_pubkey')); + + $root->appendChild($relocate); + + return(trim($doc->saveXML())); + } + + /** + * @brief Adds the header elements for the DFRN protocol + * + * @param object $doc XML document + * @param array $owner Owner record + * @param string $authorelement Element name for the author + * @param string $alternatelink link to profile or category + * @param bool $public Is it a header for public posts? + * + * @return object XML root object + * @todo Add type-hints + */ + private static function add_header($doc, $owner, $authorelement, $alternatelink = "", $public = false) { + + if ($alternatelink == "") { + $alternatelink = $owner['url']; + } + + $root = $doc->createElementNS(NAMESPACE_ATOM1, 'feed'); + $doc->appendChild($root); + + $root->setAttribute("xmlns:thr", NAMESPACE_THREAD); + $root->setAttribute("xmlns:at", NAMESPACE_TOMB); + $root->setAttribute("xmlns:media", NAMESPACE_MEDIA); + $root->setAttribute("xmlns:dfrn", NAMESPACE_DFRN); + $root->setAttribute("xmlns:activity", NAMESPACE_ACTIVITY); + $root->setAttribute("xmlns:georss", NAMESPACE_GEORSS); + $root->setAttribute("xmlns:poco", NAMESPACE_POCO); + $root->setAttribute("xmlns:ostatus", NAMESPACE_OSTATUS); + $root->setAttribute("xmlns:statusnet", NAMESPACE_STATUSNET); + + xml::add_element($doc, $root, "id", System::baseUrl()."/profile/".$owner["nick"]); + xml::add_element($doc, $root, "title", $owner["name"]); + + $attributes = array("uri" => "https://friendi.ca", "version" => FRIENDICA_VERSION."-".DB_UPDATE_VERSION); + xml::add_element($doc, $root, "generator", FRIENDICA_PLATFORM, $attributes); + + $attributes = array("rel" => "license", "href" => "http://creativecommons.org/licenses/by/3.0/"); + xml::add_element($doc, $root, "link", "", $attributes); + + $attributes = array("rel" => "alternate", "type" => "text/html", "href" => $alternatelink); + xml::add_element($doc, $root, "link", "", $attributes); + + + if ($public) { + // DFRN itself doesn't uses this. But maybe someone else wants to subscribe to the public feed. + ostatus::hublinks($doc, $root, $owner["nick"]); + + $attributes = array("rel" => "salmon", "href" => System::baseUrl()."/salmon/".$owner["nick"]); + xml::add_element($doc, $root, "link", "", $attributes); + + $attributes = array("rel" => "http://salmon-protocol.org/ns/salmon-replies", "href" => System::baseUrl()."/salmon/".$owner["nick"]); + xml::add_element($doc, $root, "link", "", $attributes); + + $attributes = array("rel" => "http://salmon-protocol.org/ns/salmon-mention", "href" => System::baseUrl()."/salmon/".$owner["nick"]); + xml::add_element($doc, $root, "link", "", $attributes); + } + + // For backward compatibility we keep this element + if ($owner['page-flags'] == PAGE_COMMUNITY) { + xml::add_element($doc, $root, "dfrn:community", 1); + } + + // The former element is replaced by this one + xml::add_element($doc, $root, "dfrn:account_type", $owner["account-type"]); + + /// @todo We need a way to transmit the different page flags like "PAGE_PRVGROUP" + + xml::add_element($doc, $root, "updated", datetime_convert("UTC", "UTC", "now", ATOM_TIME)); + + $author = self::add_author($doc, $owner, $authorelement, $public); + $root->appendChild($author); + + return $root; + } + + /** + * @brief Adds the author element in the header for the DFRN protocol + * + * @param object $doc XML document + * @param array $owner Owner record + * @param string $authorelement Element name for the author + * + * @return object XML author object + * @todo Add type-hints + */ + private static function add_author($doc, $owner, $authorelement, $public) { + + // Is the profile hidden or shouldn't be published in the net? Then add the "hide" element + $r = q("SELECT `id` FROM `profile` INNER JOIN `user` ON `user`.`uid` = `profile`.`uid` + WHERE (`hidewall` OR NOT `net-publish`) AND `user`.`uid` = %d", + intval($owner['uid'])); + if (Dbm::is_result($r)) { + $hidewall = true; + } else { + $hidewall = false; + } + + $author = $doc->createElement($authorelement); + + $namdate = datetime_convert('UTC', 'UTC', $owner['name-date'].'+00:00', ATOM_TIME); + $uridate = datetime_convert('UTC', 'UTC', $owner['uri-date'].'+00:00', ATOM_TIME); + $picdate = datetime_convert('UTC', 'UTC', $owner['avatar-date'].'+00:00', ATOM_TIME); + + $attributes = array(); + + if (!$public || !$hidewall) { + $attributes = array("dfrn:updated" => $namdate); + } + + xml::add_element($doc, $author, "name", $owner["name"], $attributes); + xml::add_element($doc, $author, "uri", System::baseUrl().'/profile/'.$owner["nickname"], $attributes); + xml::add_element($doc, $author, "dfrn:handle", $owner["addr"], $attributes); + + $attributes = array("rel" => "photo", "type" => "image/jpeg", + "media:width" => 175, "media:height" => 175, "href" => $owner['photo']); + + if (!$public || !$hidewall) { + $attributes["dfrn:updated"] = $picdate; + } + + xml::add_element($doc, $author, "link", "", $attributes); + + $attributes["rel"] = "avatar"; + xml::add_element($doc, $author, "link", "", $attributes); + + if ($hidewall) { + xml::add_element($doc, $author, "dfrn:hide", "true"); + } + + // The following fields will only be generated if the data isn't meant for a public feed + if ($public) { + return $author; + } + + $birthday = feed_birthday($owner['uid'], $owner['timezone']); + + if ($birthday) + xml::add_element($doc, $author, "dfrn:birthday", $birthday); + + // Only show contact details when we are allowed to + $r = q("SELECT `profile`.`about`, `profile`.`name`, `profile`.`homepage`, `user`.`nickname`, + `user`.`timezone`, `profile`.`locality`, `profile`.`region`, `profile`.`country-name`, + `profile`.`pub_keywords`, `profile`.`xmpp`, `profile`.`dob` + FROM `profile` + INNER JOIN `user` ON `user`.`uid` = `profile`.`uid` + WHERE `profile`.`is-default` AND NOT `user`.`hidewall` AND `user`.`uid` = %d", + intval($owner['uid'])); + if (Dbm::is_result($r)) { + $profile = $r[0]; + + xml::add_element($doc, $author, "poco:displayName", $profile["name"]); + xml::add_element($doc, $author, "poco:updated", $namdate); + + if (trim($profile["dob"]) > '0001-01-01') { + xml::add_element($doc, $author, "poco:birthday", "0000-".date("m-d", strtotime($profile["dob"]))); + } + + xml::add_element($doc, $author, "poco:note", $profile["about"]); + xml::add_element($doc, $author, "poco:preferredUsername", $profile["nickname"]); + + $savetz = date_default_timezone_get(); + date_default_timezone_set($profile["timezone"]); + xml::add_element($doc, $author, "poco:utcOffset", date("P")); + date_default_timezone_set($savetz); + + if (trim($profile["homepage"]) != "") { + $urls = $doc->createElement("poco:urls"); + xml::add_element($doc, $urls, "poco:type", "homepage"); + xml::add_element($doc, $urls, "poco:value", $profile["homepage"]); + xml::add_element($doc, $urls, "poco:primary", "true"); + $author->appendChild($urls); + } + + if (trim($profile["pub_keywords"]) != "") { + $keywords = explode(",", $profile["pub_keywords"]); + + foreach ($keywords AS $keyword) { + xml::add_element($doc, $author, "poco:tags", trim($keyword)); + } + + } + + if (trim($profile["xmpp"]) != "") { + $ims = $doc->createElement("poco:ims"); + xml::add_element($doc, $ims, "poco:type", "xmpp"); + xml::add_element($doc, $ims, "poco:value", $profile["xmpp"]); + xml::add_element($doc, $ims, "poco:primary", "true"); + $author->appendChild($ims); + } + + if (trim($profile["locality"].$profile["region"].$profile["country-name"]) != "") { + $element = $doc->createElement("poco:address"); + + xml::add_element($doc, $element, "poco:formatted", formatted_location($profile)); + + if (trim($profile["locality"]) != "") { + xml::add_element($doc, $element, "poco:locality", $profile["locality"]); + } + + if (trim($profile["region"]) != "") { + xml::add_element($doc, $element, "poco:region", $profile["region"]); + } + + if (trim($profile["country-name"]) != "") { + xml::add_element($doc, $element, "poco:country", $profile["country-name"]); + } + + $author->appendChild($element); + } + } + + return $author; + } + + /** + * @brief Adds the author elements in the "entry" elements of the DFRN protocol + * + * @param object $doc XML document + * @param string $element Element name for the author + * @param string $contact_url Link of the contact + * @param array $items Item elements + * + * @return object XML author object + * @todo Add type-hints + */ + private static function add_entry_author($doc, $element, $contact_url, $item) { + + $contact = get_contact_details_by_url($contact_url, $item["uid"]); + + $author = $doc->createElement($element); + xml::add_element($doc, $author, "name", $contact["name"]); + xml::add_element($doc, $author, "uri", $contact["url"]); + xml::add_element($doc, $author, "dfrn:handle", $contact["addr"]); + + /// @Todo + /// - Check real image type and image size + /// - Check which of these boths elements we should use + $attributes = array( + "rel" => "photo", + "type" => "image/jpeg", + "media:width" => 80, + "media:height" => 80, + "href" => $contact["photo"]); + xml::add_element($doc, $author, "link", "", $attributes); + + $attributes = array( + "rel" => "avatar", + "type" => "image/jpeg", + "media:width" => 80, + "media:height" => 80, + "href" => $contact["photo"]); + xml::add_element($doc, $author, "link", "", $attributes); + + return $author; + } + + /** + * @brief Adds the activity elements + * + * @param object $doc XML document + * @param string $element Element name for the activity + * @param string $activity activity value + * + * @return object XML activity object + * @todo Add type-hints + */ + private static function create_activity($doc, $element, $activity) { + + if ($activity) { + $entry = $doc->createElement($element); + + $r = parse_xml_string($activity, false); + if (!$r) { + return false; + } + if ($r->type) { + xml::add_element($doc, $entry, "activity:object-type", $r->type); + } + if ($r->id) { + xml::add_element($doc, $entry, "id", $r->id); + } + if ($r->title) { + xml::add_element($doc, $entry, "title", $r->title); + } + + if ($r->link) { + if (substr($r->link, 0, 1) == '<') { + if (strstr($r->link, '&') && (! strstr($r->link, '&'))) { + $r->link = str_replace('&', '&', $r->link); + } + + $r->link = preg_replace('/\/', '', $r->link); + + // XML does need a single element as root element so we add a dummy element here + $data = parse_xml_string("" . $r->link . "", false); + if (is_object($data)) { + foreach ($data->link AS $link) { + $attributes = array(); + foreach ($link->attributes() AS $parameter => $value) { + $attributes[$parameter] = $value; + } + xml::add_element($doc, $entry, "link", "", $attributes); + } + } + } else { + $attributes = array("rel" => "alternate", "type" => "text/html", "href" => $r->link); + xml::add_element($doc, $entry, "link", "", $attributes); + } + } + if ($r->content) { + xml::add_element($doc, $entry, "content", bbcode($r->content), array("type" => "html")); + } + + return $entry; + } + + return false; + } + + /** + * @brief Adds the elements for attachments + * + * @param object $doc XML document + * @param object $root XML root + * @param array $item Item element + * + * @return object XML attachment object + * @todo Add type-hints + */ + private static function get_attachment($doc, $root, $item) { + $arr = explode('[/attach],',$item['attach']); + if (count($arr)) { + foreach ($arr as $r) { + $matches = false; + $cnt = preg_match('|\[attach\]href=\"(.*?)\" length=\"(.*?)\" type=\"(.*?)\" title=\"(.*?)\"|',$r,$matches); + if ($cnt) { + $attributes = array("rel" => "enclosure", + "href" => $matches[1], + "type" => $matches[3]); + + if (intval($matches[2])) { + $attributes["length"] = intval($matches[2]); + } + + if (trim($matches[4]) != "") { + $attributes["title"] = trim($matches[4]); + } + + xml::add_element($doc, $root, "link", "", $attributes); + } + } + } + } + + /** + * @brief Adds the "entry" elements for the DFRN protocol + * + * @param object $doc XML document + * @param string $type "text" or "html" + * @param array $item Item element + * @param array $owner Owner record + * @param bool $comment Trigger the sending of the "comment" element + * @param int $cid Contact ID of the recipient + * @param bool $single If set, the entry is created as an XML document with a single "entry" element + * + * @return object XML entry object + * @todo Add type-hints + */ + private static function entry($doc, $type, $item, $owner, $comment = false, $cid = 0, $single = false) { + + $mentioned = array(); + + if (!$item['parent']) { + return; + } + + if ($item['deleted']) { + $attributes = array("ref" => $item['uri'], "when" => datetime_convert('UTC','UTC',$item['edited'] . '+00:00',ATOM_TIME)); + return xml::create_element($doc, "at:deleted-entry", "", $attributes); + } + + if (!$single) { + $entry = $doc->createElement("entry"); + } else { + $entry = $doc->createElementNS(NAMESPACE_ATOM1, 'entry'); + $doc->appendChild($entry); + + $entry->setAttribute("xmlns:thr", NAMESPACE_THREAD); + $entry->setAttribute("xmlns:at", NAMESPACE_TOMB); + $entry->setAttribute("xmlns:media", NAMESPACE_MEDIA); + $entry->setAttribute("xmlns:dfrn", NAMESPACE_DFRN); + $entry->setAttribute("xmlns:activity", NAMESPACE_ACTIVITY); + $entry->setAttribute("xmlns:georss", NAMESPACE_GEORSS); + $entry->setAttribute("xmlns:poco", NAMESPACE_POCO); + $entry->setAttribute("xmlns:ostatus", NAMESPACE_OSTATUS); + $entry->setAttribute("xmlns:statusnet", NAMESPACE_STATUSNET); + } + + if ($item['allow_cid'] || $item['allow_gid'] || $item['deny_cid'] || $item['deny_gid']) { + $body = fix_private_photos($item['body'],$owner['uid'],$item,$cid); + } else { + $body = $item['body']; + } + + // Remove the abstract element. It is only locally important. + $body = remove_abstract($body); + + if ($type == 'html') { + $htmlbody = $body; + + if ($item['title'] != "") { + $htmlbody = "[b]".$item['title']."[/b]\n\n".$htmlbody; + } + + $htmlbody = bbcode($htmlbody, false, false, 7); + } + + $author = self::add_entry_author($doc, "author", $item["author-link"], $item); + $entry->appendChild($author); + + $dfrnowner = self::add_entry_author($doc, "dfrn:owner", $item["owner-link"], $item); + $entry->appendChild($dfrnowner); + + if (($item['parent'] != $item['id']) || ($item['parent-uri'] !== $item['uri']) || (($item['thr-parent'] !== '') && ($item['thr-parent'] !== $item['uri']))) { + $parent_item = (($item['thr-parent']) ? $item['thr-parent'] : $item['parent-uri']); + $parent = q("SELECT `guid`,`plink` FROM `item` WHERE `uri` = '%s' AND `uid` = %d", dbesc($parent_item), intval($item['uid'])); + $attributes = array("ref" => $parent_item, "type" => "text/html", + "href" => $parent[0]['plink'], + "dfrn:diaspora_guid" => $parent[0]['guid']); + xml::add_element($doc, $entry, "thr:in-reply-to", "", $attributes); + } + + // Add conversation data. This is used for OStatus + $conversation_href = System::baseUrl()."/display/".$owner["nick"]."/".$item["parent"]; + $conversation_uri = $conversation_href; + + if (isset($parent_item)) { + $r = dba::fetch_first("SELECT `conversation-uri`, `conversation-href` FROM `conversation` WHERE `item-uri` = ?", $item['parent-uri']); + if (Dbm::is_result($r)) { + if ($r['conversation-uri'] != '') { + $conversation_uri = $r['conversation-uri']; + } + if ($r['conversation-href'] != '') { + $conversation_href = $r['conversation-href']; + } + } + } + + $attributes = array( + "href" => $conversation_href, + "ref" => $conversation_uri); + + xml::add_element($doc, $entry, "ostatus:conversation", $conversation_uri, $attributes); + + xml::add_element($doc, $entry, "id", $item["uri"]); + xml::add_element($doc, $entry, "title", $item["title"]); + + xml::add_element($doc, $entry, "published", datetime_convert("UTC","UTC",$item["created"]."+00:00",ATOM_TIME)); + xml::add_element($doc, $entry, "updated", datetime_convert("UTC","UTC",$item["edited"]."+00:00",ATOM_TIME)); + + // "dfrn:env" is used to read the content + xml::add_element($doc, $entry, "dfrn:env", base64url_encode($body, true)); + + // The "content" field is not read by the receiver. We could remove it when the type is "text" + // We keep it at the moment, maybe there is some old version that doesn't read "dfrn:env" + xml::add_element($doc, $entry, "content", (($type == 'html') ? $htmlbody : $body), array("type" => $type)); + + // We save this value in "plink". Maybe we should read it from there as well? + xml::add_element($doc, $entry, "link", "", array("rel" => "alternate", "type" => "text/html", + "href" => System::baseUrl()."/display/".$item["guid"])); + + // "comment-allow" is some old fashioned stuff for old Friendica versions. + // It is included in the rewritten code for completeness + if ($comment) { + xml::add_element($doc, $entry, "dfrn:comment-allow", intval($item['last-child'])); + } + + if ($item['location']) { + xml::add_element($doc, $entry, "dfrn:location", $item['location']); + } + + if ($item['coord']) { + xml::add_element($doc, $entry, "georss:point", $item['coord']); + } + + if (($item['private']) || strlen($item['allow_cid']) || strlen($item['allow_gid']) || strlen($item['deny_cid']) || strlen($item['deny_gid'])) { + xml::add_element($doc, $entry, "dfrn:private", (($item['private']) ? $item['private'] : 1)); + } + + if ($item['extid']) { + xml::add_element($doc, $entry, "dfrn:extid", $item['extid']); + } + + if ($item['bookmark']) { + xml::add_element($doc, $entry, "dfrn:bookmark", "true"); + } + + if ($item['app']) { + xml::add_element($doc, $entry, "statusnet:notice_info", "", array("local_id" => $item['id'], "source" => $item['app'])); + } + + xml::add_element($doc, $entry, "dfrn:diaspora_guid", $item["guid"]); + + // The signed text contains the content in Markdown, the sender handle and the signatur for the content + // It is needed for relayed comments to Diaspora. + if ($item['signed_text']) { + $sign = base64_encode(json_encode(array('signed_text' => $item['signed_text'],'signature' => $item['signature'],'signer' => $item['signer']))); + xml::add_element($doc, $entry, "dfrn:diaspora_signature", $sign); + } + + xml::add_element($doc, $entry, "activity:verb", construct_verb($item)); + + if ($item['object-type'] != "") { + xml::add_element($doc, $entry, "activity:object-type", $item['object-type']); + } elseif ($item['id'] == $item['parent']) { + xml::add_element($doc, $entry, "activity:object-type", ACTIVITY_OBJ_NOTE); + } else { + xml::add_element($doc, $entry, "activity:object-type", ACTIVITY_OBJ_COMMENT); + } + + $actobj = self::create_activity($doc, "activity:object", $item['object']); + if ($actobj) { + $entry->appendChild($actobj); + } + + $actarg = self::create_activity($doc, "activity:target", $item['target']); + if ($actarg) { + $entry->appendChild($actarg); + } + + $tags = item_getfeedtags($item); + + if (count($tags)) { + foreach ($tags as $t) { + if (($type != 'html') || ($t[0] != "@")) { + xml::add_element($doc, $entry, "category", "", array("scheme" => "X-DFRN:".$t[0].":".$t[1], "term" => $t[2])); + } + } + } + + if (count($tags)) { + foreach ($tags as $t) { + if ($t[0] == "@") { + $mentioned[$t[1]] = $t[1]; + } + } + } + + foreach ($mentioned AS $mention) { + $r = q("SELECT `forum`, `prv` FROM `contact` WHERE `uid` = %d AND `nurl` = '%s'", + intval($owner["uid"]), + dbesc(normalise_link($mention))); + + if (Dbm::is_result($r) && ($r[0]["forum"] || $r[0]["prv"])) { + xml::add_element($doc, $entry, "link", "", array("rel" => "mentioned", + "ostatus:object-type" => ACTIVITY_OBJ_GROUP, + "href" => $mention)); + } else { + xml::add_element($doc, $entry, "link", "", array("rel" => "mentioned", + "ostatus:object-type" => ACTIVITY_OBJ_PERSON, + "href" => $mention)); + } + } + + self::get_attachment($doc, $entry, $item); + + return $entry; + } + + /** + * @brief encrypts data via AES + * + * @param string $data The data that is to be encrypted + * @param string $key The AES key + * + * @return string encrypted data + */ + private static function aes_encrypt($data, $key) { + return openssl_encrypt($data, 'aes-128-ecb', $key, OPENSSL_RAW_DATA); + } + + /** + * @brief decrypts data via AES + * + * @param string $encrypted The encrypted data + * @param string $key The AES key + * + * @return string decrypted data + */ + public static function aes_decrypt($encrypted, $key) { + return openssl_decrypt($encrypted, 'aes-128-ecb', $key, OPENSSL_RAW_DATA); + } + + /** + * @brief Delivers the atom content to the contacts + * + * @param array $owner Owner record + * @param array $contactr Contact record of the receiver + * @param string $atom Content that will be transmitted + * @param bool $dissolve (to be documented) + * + * @return int Deliver status. -1 means an error. + * @todo Add array type-hint for $owner, $contact + */ + public static function deliver($owner,$contact,$atom, $dissolve = false) { + + $a = get_app(); + + $idtosend = $orig_id = (($contact['dfrn-id']) ? $contact['dfrn-id'] : $contact['issued-id']); + + if ($contact['duplex'] && $contact['dfrn-id']) { + $idtosend = '0:' . $orig_id; + } + if ($contact['duplex'] && $contact['issued-id']) { + $idtosend = '1:' . $orig_id; + } + + $rino = Config::get('system', 'rino_encrypt'); + $rino = intval($rino); + + logger("Local rino version: ". $rino, LOGGER_DEBUG); + + $ssl_val = intval(Config::get('system','ssl_policy')); + $ssl_policy = ''; + + switch ($ssl_val) { + case SSL_POLICY_FULL: + $ssl_policy = 'full'; + break; + case SSL_POLICY_SELFSIGN: + $ssl_policy = 'self'; + break; + case SSL_POLICY_NONE: + default: + $ssl_policy = 'none'; + break; + } + + $url = $contact['notify'] . '&dfrn_id=' . $idtosend . '&dfrn_version=' . DFRN_PROTOCOL_VERSION . (($rino) ? '&rino='.$rino : ''); + + logger('dfrn_deliver: ' . $url); + + $ret = z_fetch_url($url); + + if ($ret['errno'] == CURLE_OPERATION_TIMEDOUT) { + return -2; // timed out + } + + $xml = $ret['body']; + + $curl_stat = $a->get_curl_code(); + if (!$curl_stat) { + return -3; // timed out + } + + logger('dfrn_deliver: ' . $xml, LOGGER_DATA); + + if (! $xml) { + return 3; + } + + if (strpos($xml,'status) != 0) || (! strlen($res->challenge)) || (! strlen($res->dfrn_id))) { + return (($res->status) ? $res->status : 3); + } + + $postvars = array(); + $sent_dfrn_id = hex2bin((string) $res->dfrn_id); + $challenge = hex2bin((string) $res->challenge); + $perm = (($res->perm) ? $res->perm : null); + $dfrn_version = (float) (($res->dfrn_version) ? $res->dfrn_version : 2.0); + $rino_remote_version = intval($res->rino); + $page = (($owner['page-flags'] == PAGE_COMMUNITY) ? 1 : 0); + + logger("Remote rino version: ".$rino_remote_version." for ".$contact["url"], LOGGER_DEBUG); + + if ($owner['page-flags'] == PAGE_PRVGROUP) { + $page = 2; + } + + $final_dfrn_id = ''; + + if ($perm) { + if ((($perm == 'rw') && (! intval($contact['writable']))) + || (($perm == 'r') && (intval($contact['writable'])))) { + q("update contact set writable = %d where id = %d", + intval(($perm == 'rw') ? 1 : 0), + intval($contact['id']) + ); + $contact['writable'] = (string) 1 - intval($contact['writable']); + } + } + + if (($contact['duplex'] && strlen($contact['pubkey'])) + || ($owner['page-flags'] == PAGE_COMMUNITY && strlen($contact['pubkey'])) + || ($contact['rel'] == CONTACT_IS_SHARING && strlen($contact['pubkey']))) { + openssl_public_decrypt($sent_dfrn_id,$final_dfrn_id,$contact['pubkey']); + openssl_public_decrypt($challenge,$postvars['challenge'],$contact['pubkey']); + } else { + openssl_private_decrypt($sent_dfrn_id,$final_dfrn_id,$contact['prvkey']); + openssl_private_decrypt($challenge,$postvars['challenge'],$contact['prvkey']); + } + + $final_dfrn_id = substr($final_dfrn_id, 0, strpos($final_dfrn_id, '.')); + + if (strpos($final_dfrn_id,':') == 1) { + $final_dfrn_id = substr($final_dfrn_id,2); + } + + if ($final_dfrn_id != $orig_id) { + logger('dfrn_deliver: wrong dfrn_id.'); + // did not decode properly - cannot trust this site + return 3; + } + + $postvars['dfrn_id'] = $idtosend; + $postvars['dfrn_version'] = DFRN_PROTOCOL_VERSION; + if ($dissolve) { + $postvars['dissolve'] = '1'; + } + + + if ((($contact['rel']) && ($contact['rel'] != CONTACT_IS_SHARING) && (! $contact['blocked'])) || ($owner['page-flags'] == PAGE_COMMUNITY)) { + $postvars['data'] = $atom; + $postvars['perm'] = 'rw'; + } else { + $postvars['data'] = str_replace('1','0',$atom); + $postvars['perm'] = 'r'; + } + + $postvars['ssl_policy'] = $ssl_policy; + + if ($page) { + $postvars['page'] = $page; + } + + + if ($rino > 0 && $rino_remote_version > 0 && (! $dissolve)) { + logger('rino version: '. $rino_remote_version); + + switch ($rino_remote_version) { + case 1: + // Deprecated rino version! + $key = openssl_random_pseudo_bytes(16); + $data = self::aes_encrypt($postvars['data'], $key); + break; + case 2: + // RINO 2 based on php-encryption + try { + $key = Crypto::createNewRandomKey(); + } catch (CryptoTestFailed $ex) { + logger('Cannot safely create a key'); + return -4; + } catch (CannotPerformOperation $ex) { + logger('Cannot safely create a key'); + return -5; + } + try { + $data = Crypto::encrypt($postvars['data'], $key); + } catch (CryptoTestFailed $ex) { + logger('Cannot safely perform encryption'); + return -6; + } catch (CannotPerformOperation $ex) { + logger('Cannot safely perform encryption'); + return -7; + } + break; + default: + logger("rino: invalid requested verision '$rino_remote_version'"); + return -8; + } + + $postvars['rino'] = $rino_remote_version; + $postvars['data'] = bin2hex($data); + + //logger('rino: sent key = ' . $key, LOGGER_DEBUG); + + + if ($dfrn_version >= 2.1) { + if (($contact['duplex'] && strlen($contact['pubkey'])) + || ($owner['page-flags'] == PAGE_COMMUNITY && strlen($contact['pubkey'])) + || ($contact['rel'] == CONTACT_IS_SHARING && strlen($contact['pubkey']))) { + openssl_public_encrypt($key,$postvars['key'],$contact['pubkey']); + } else { + openssl_private_encrypt($key,$postvars['key'],$contact['prvkey']); + } + + } else { + if (($contact['duplex'] && strlen($contact['prvkey'])) || ($owner['page-flags'] == PAGE_COMMUNITY)) { + openssl_private_encrypt($key,$postvars['key'],$contact['prvkey']); + } else { + openssl_public_encrypt($key,$postvars['key'],$contact['pubkey']); + } + + } + + logger('md5 rawkey ' . md5($postvars['key'])); + + $postvars['key'] = bin2hex($postvars['key']); + } + + + logger('dfrn_deliver: ' . "SENDING: " . print_r($postvars,true), LOGGER_DATA); + + $xml = post_url($contact['notify'], $postvars); + + logger('dfrn_deliver: ' . "RECEIVED: " . $xml, LOGGER_DATA); + + $curl_stat = $a->get_curl_code(); + if ((!$curl_stat) || (!strlen($xml))) { + return -9; // timed out + } + + if (($curl_stat == 503) && (stristr($a->get_curl_headers(),'retry-after'))) { + return -10; + } + + if (strpos($xml,' NULL_DATE) { + logger("dfrn_deliver: $url back from the dead - removing mark for death"); + require_once('include/Contact.php'); + unmark_for_death($contact); + } + + $res = parse_xml_string($xml); + + if (!isset($res->status)) { + return -11; + } + + if (!empty($res->message)) { + logger('Delivery returned status '.$res->status.' - '.$res->message, LOGGER_DEBUG); + } + + return intval($res->status); + } + + /** + * @brief Add new birthday event for this person + * + * @param array $contact Contact record + * @param string $birthday Birthday of the contact + * @todo Add array type-hint for $contact + */ + private static function birthday_event($contact, $birthday) { + + // Check for duplicates + $r = q("SELECT `id` FROM `event` WHERE `uid` = %d AND `cid` = %d AND `start` = '%s' AND `type` = '%s' LIMIT 1", + intval($contact["uid"]), + intval($contact["id"]), + dbesc(datetime_convert("UTC","UTC", $birthday)), + dbesc("birthday")); + + if (Dbm::is_result($r)) { + return; + } + + logger("updating birthday: ".$birthday." for contact ".$contact["id"]); + + $bdtext = sprintf(t("%s\'s birthday"), $contact["name"]); + $bdtext2 = sprintf(t("Happy Birthday %s"), " [url=".$contact["url"]."]".$contact["name"]."[/url]") ; + + $r = q("INSERT INTO `event` (`uid`,`cid`,`created`,`edited`,`start`,`finish`,`summary`,`desc`,`type`) + VALUES ( %d, %d, '%s', '%s', '%s', '%s', '%s', '%s', '%s') ", + intval($contact["uid"]), + intval($contact["id"]), + dbesc(datetime_convert()), + dbesc(datetime_convert()), + dbesc(datetime_convert("UTC","UTC", $birthday)), + dbesc(datetime_convert("UTC","UTC", $birthday." + 1 day ")), + dbesc($bdtext), + dbesc($bdtext2), + dbesc("birthday") + ); + } + + /** + * @brief Fetch the author data from head or entry items + * + * @param object $xpath XPath object + * @param object $context In which context should the data be searched + * @param array $importer Record of the importer user mixed with contact of the content + * @param string $element Element name from which the data is fetched + * @param bool $onlyfetch Should the data only be fetched or should it update the contact record as well + * + * @return Returns an array with relevant data of the author + * @todo Find good type-hints for all parameter + */ + private static function fetchauthor($xpath, $context, $importer, $element, $onlyfetch, $xml = "") { + + $author = array(); + $author["name"] = $xpath->evaluate($element."/atom:name/text()", $context)->item(0)->nodeValue; + $author["link"] = $xpath->evaluate($element."/atom:uri/text()", $context)->item(0)->nodeValue; + + $r = q("SELECT `id`, `uid`, `url`, `network`, `avatar-date`, `name-date`, `uri-date`, `addr`, + `name`, `nick`, `about`, `location`, `keywords`, `xmpp`, `bdyear`, `bd`, `hidden`, `contact-type` + FROM `contact` WHERE `uid` = %d AND `nurl` = '%s' AND `network` != '%s'", + intval($importer["uid"]), dbesc(normalise_link($author["link"])), dbesc(NETWORK_STATUSNET)); + + if (Dbm::is_result($r)) { + $contact = $r[0]; + $author["contact-id"] = $r[0]["id"]; + $author["network"] = $r[0]["network"]; + } else { + if (!$onlyfetch) { + logger("Contact ".$author["link"]." wasn't found for user ".$importer["uid"]." XML: ".$xml, LOGGER_DEBUG); + } + + $author["contact-id"] = $importer["id"]; + $author["network"] = $importer["network"]; + $onlyfetch = true; + } + + // Until now we aren't serving different sizes - but maybe later + $avatarlist = array(); + /// @todo check if "avatar" or "photo" would be the best field in the specification + $avatars = $xpath->query($element."/atom:link[@rel='avatar']", $context); + foreach ($avatars AS $avatar) { + $href = ""; + $width = 0; + foreach ($avatar->attributes AS $attributes) { + /// @TODO Rewrite these similar if () to one switch + if ($attributes->name == "href") { + $href = $attributes->textContent; + } + if ($attributes->name == "width") { + $width = $attributes->textContent; + } + if ($attributes->name == "updated") { + $contact["avatar-date"] = $attributes->textContent; + } + } + if (($width > 0) && ($href != "")) { + $avatarlist[$width] = $href; + } + } + if (count($avatarlist) > 0) { + krsort($avatarlist); + $author["avatar"] = current($avatarlist); + } + + if (Dbm::is_result($r) && !$onlyfetch) { + logger("Check if contact details for contact " . $r[0]["id"] . " (" . $r[0]["nick"] . ") have to be updated.", LOGGER_DEBUG); + + $poco = array("url" => $contact["url"]); + + // When was the last change to name or uri? + $name_element = $xpath->query($element . "/atom:name", $context)->item(0); + foreach ($name_element->attributes AS $attributes) { + if ($attributes->name == "updated") { + $poco["name-date"] = $attributes->textContent; + } + } + + $link_element = $xpath->query($element . "/atom:link", $context)->item(0); + foreach ($link_element->attributes AS $attributes) { + if ($attributes->name == "updated") { + $poco["uri-date"] = $attributes->textContent; + } + } + + // Update contact data + $value = $xpath->evaluate($element . "/dfrn:handle/text()", $context)->item(0)->nodeValue; + if ($value != "") { + $poco["addr"] = $value; + } + + $value = $xpath->evaluate($element . "/poco:displayName/text()", $context)->item(0)->nodeValue; + if ($value != "") { + $poco["name"] = $value; + } + + $value = $xpath->evaluate($element . "/poco:preferredUsername/text()", $context)->item(0)->nodeValue; + if ($value != "") { + $poco["nick"] = $value; + } + + $value = $xpath->evaluate($element . "/poco:note/text()", $context)->item(0)->nodeValue; + if ($value != "") { + $poco["about"] = $value; + } + + $value = $xpath->evaluate($element . "/poco:address/poco:formatted/text()", $context)->item(0)->nodeValue; + if ($value != "") { + $poco["location"] = $value; + } + + /// @todo Only search for elements with "poco:type" = "xmpp" + $value = $xpath->evaluate($element . "/poco:ims/poco:value/text()", $context)->item(0)->nodeValue; + if ($value != "") { + $poco["xmpp"] = $value; + } + + /// @todo Add support for the following fields that we don't support by now in the contact table: + /// - poco:utcOffset + /// - poco:urls + /// - poco:locality + /// - poco:region + /// - poco:country + + // If the "hide" element is present then the profile isn't searchable. + $hide = intval($xpath->evaluate($element . "/dfrn:hide/text()", $context)->item(0)->nodeValue == "true"); + + logger("Hidden status for contact " . $contact["url"] . ": " . $hide, LOGGER_DEBUG); + + // If the contact isn't searchable then set the contact to "hidden". + // Problem: This can be manually overridden by the user. + if ($hide) { + $contact["hidden"] = true; + } + + // Save the keywords into the contact table + $tags = array(); + $tagelements = $xpath->evaluate($element . "/poco:tags/text()", $context); + foreach ($tagelements AS $tag) { + $tags[$tag->nodeValue] = $tag->nodeValue; + } + + if (count($tags)) { + $poco["keywords"] = implode(", ", $tags); + } + + // "dfrn:birthday" contains the birthday converted to UTC + $old_bdyear = $contact["bdyear"]; + + $birthday = $xpath->evaluate($element . "/dfrn:birthday/text()", $context)->item(0)->nodeValue; + + if (strtotime($birthday) > time()) { + $bd_timestamp = strtotime($birthday); + + $poco["bdyear"] = date("Y", $bd_timestamp); + } + + // "poco:birthday" is the birthday in the format "yyyy-mm-dd" + $value = $xpath->evaluate($element . "/poco:birthday/text()", $context)->item(0)->nodeValue; + + if (!in_array($value, array("", "0000-00-00", "0001-01-01"))) { + $bdyear = date("Y"); + $value = str_replace("0000", $bdyear, $value); + + if (strtotime($value) < time()) { + $value = str_replace($bdyear, $bdyear + 1, $value); + $bdyear = $bdyear + 1; + } + + $poco["bd"] = $value; + } + + $contact = array_merge($contact, $poco); + + if ($old_bdyear != $contact["bdyear"]) { + self::birthday_event($contact, $birthday); + } + + // Get all field names + $fields = array(); + foreach ($r[0] AS $field => $data) { + $fields[$field] = $data; + } + + unset($fields["id"]); + unset($fields["uid"]); + unset($fields["url"]); + unset($fields["avatar-date"]); + unset($fields["name-date"]); + unset($fields["uri-date"]); + + // Update check for this field has to be done differently + $datefields = array("name-date", "uri-date"); + foreach ($datefields AS $field) { + if (strtotime($contact[$field]) > strtotime($r[0][$field])) { + logger("Difference for contact " . $contact["id"] . " in field '" . $field . "'. New value: '" . $contact[$field] . "', old value '" . $r[0][$field] . "'", LOGGER_DEBUG); + $update = true; + } + } + + foreach ($fields AS $field => $data) { + if ($contact[$field] != $r[0][$field]) { + logger("Difference for contact " . $contact["id"] . " in field '" . $field . "'. New value: '" . $contact[$field] . "', old value '" . $r[0][$field] . "'", LOGGER_DEBUG); + $update = true; + } + } + + if ($update) { + logger("Update contact data for contact " . $contact["id"] . " (" . $contact["nick"] . ")", LOGGER_DEBUG); + + q("UPDATE `contact` SET `name` = '%s', `nick` = '%s', `about` = '%s', `location` = '%s', + `addr` = '%s', `keywords` = '%s', `bdyear` = '%s', `bd` = '%s', `hidden` = %d, + `xmpp` = '%s', `name-date` = '%s', `uri-date` = '%s' + WHERE `id` = %d AND `network` = '%s'", + dbesc($contact["name"]), dbesc($contact["nick"]), dbesc($contact["about"]), dbesc($contact["location"]), + dbesc($contact["addr"]), dbesc($contact["keywords"]), dbesc($contact["bdyear"]), + dbesc($contact["bd"]), intval($contact["hidden"]), dbesc($contact["xmpp"]), + dbesc(Dbm::date($contact["name-date"])), dbesc(Dbm::date($contact["uri-date"])), + intval($contact["id"]), dbesc($contact["network"])); + } + + update_contact_avatar($author["avatar"], $importer["uid"], $contact["id"], + (strtotime($contact["avatar-date"]) > strtotime($r[0]["avatar-date"]))); + + /* + * The generation is a sign for the reliability of the provided data. + * It is used in the socgraph.php to prevent that old contact data + * that was relayed over several servers can overwrite contact + * data that we received directly. + */ + + $poco["generation"] = 2; + $poco["photo"] = $author["avatar"]; + $poco["hide"] = $hide; + $poco["contact-type"] = $contact["contact-type"]; + $gcid = update_gcontact($poco); + + link_gcontact($gcid, $importer["uid"], $contact["id"]); + } + + return($author); + } + + /** + * @brief Transforms activity objects into an XML string + * + * @param object $xpath XPath object + * @param object $activity Activity object + * @param text $element element name + * + * @return string XML string + * @todo Find good type-hints for all parameter + */ + private static function transform_activity($xpath, $activity, $element) { + if (!is_object($activity)) { + return ""; + } + + $obj_doc = new DOMDocument("1.0", "utf-8"); + $obj_doc->formatOutput = true; + + $obj_element = $obj_doc->createElementNS(NAMESPACE_ATOM1, $element); + + $activity_type = $xpath->query("activity:object-type/text()", $activity)->item(0)->nodeValue; + xml::add_element($obj_doc, $obj_element, "type", $activity_type); + + $id = $xpath->query("atom:id", $activity)->item(0); + if (is_object($id)) { + $obj_element->appendChild($obj_doc->importNode($id, true)); + } + + $title = $xpath->query("atom:title", $activity)->item(0); + if (is_object($title)) { + $obj_element->appendChild($obj_doc->importNode($title, true)); + } + + $links = $xpath->query("atom:link", $activity); + if (is_object($links)) { + foreach ($links AS $link) { + $obj_element->appendChild($obj_doc->importNode($link, true)); + } + } + + $content = $xpath->query("atom:content", $activity)->item(0); + if (is_object($content)) { + $obj_element->appendChild($obj_doc->importNode($content, true)); + } + + $obj_doc->appendChild($obj_element); + + $objxml = $obj_doc->saveXML($obj_element); + + /// @todo This isn't totally clean. We should find a way to transform the namespaces + $objxml = str_replace("<".$element.' xmlns="http://www.w3.org/2005/Atom">', "<".$element.">", $objxml); + return($objxml); + } + + /** + * @brief Processes the mail elements + * + * @param object $xpath XPath object + * @param object $mail mail elements + * @param array $importer Record of the importer user mixed with contact of the content + * @todo Find good type-hints for all parameter + */ + private static function process_mail($xpath, $mail, $importer) { + + logger("Processing mails"); + + /// @TODO Rewrite this to one statement + $msg = array(); + $msg["uid"] = $importer["importer_uid"]; + $msg["from-name"] = $xpath->query("dfrn:sender/dfrn:name/text()", $mail)->item(0)->nodeValue; + $msg["from-url"] = $xpath->query("dfrn:sender/dfrn:uri/text()", $mail)->item(0)->nodeValue; + $msg["from-photo"] = $xpath->query("dfrn:sender/dfrn:avatar/text()", $mail)->item(0)->nodeValue; + $msg["contact-id"] = $importer["id"]; + $msg["uri"] = $xpath->query("dfrn:id/text()", $mail)->item(0)->nodeValue; + $msg["parent-uri"] = $xpath->query("dfrn:in-reply-to/text()", $mail)->item(0)->nodeValue; + $msg["created"] = $xpath->query("dfrn:sentdate/text()", $mail)->item(0)->nodeValue; + $msg["title"] = $xpath->query("dfrn:subject/text()", $mail)->item(0)->nodeValue; + $msg["body"] = $xpath->query("dfrn:content/text()", $mail)->item(0)->nodeValue; + $msg["seen"] = 0; + $msg["replied"] = 0; + + dba::insert('mail', $msg); + + // send notifications. + /// @TODO Arange this mess + $notif_params = array( + "type" => NOTIFY_MAIL, + "notify_flags" => $importer["notify-flags"], + "language" => $importer["language"], + "to_name" => $importer["username"], + "to_email" => $importer["email"], + "uid" => $importer["importer_uid"], + "item" => $msg, + "source_name" => $msg["from-name"], + "source_link" => $importer["url"], + "source_photo" => $importer["thumb"], + "verb" => ACTIVITY_POST, + "otype" => "mail" + ); + + notification($notif_params); + + logger("Mail is processed, notification was sent."); + } + + /** + * @brief Processes the suggestion elements + * + * @param object $xpath XPath object + * @param object $suggestion suggestion elements + * @param array $importer Record of the importer user mixed with contact of the content + * @todo Find good type-hints for all parameter + */ + private static function process_suggestion($xpath, $suggestion, $importer) { + $a = get_app(); + + logger("Processing suggestions"); + + /// @TODO Rewrite this to one statement + $suggest = array(); + $suggest["uid"] = $importer["importer_uid"]; + $suggest["cid"] = $importer["id"]; + $suggest["url"] = $xpath->query("dfrn:url/text()", $suggestion)->item(0)->nodeValue; + $suggest["name"] = $xpath->query("dfrn:name/text()", $suggestion)->item(0)->nodeValue; + $suggest["photo"] = $xpath->query("dfrn:photo/text()", $suggestion)->item(0)->nodeValue; + $suggest["request"] = $xpath->query("dfrn:request/text()", $suggestion)->item(0)->nodeValue; + $suggest["body"] = $xpath->query("dfrn:note/text()", $suggestion)->item(0)->nodeValue; + + // Does our member already have a friend matching this description? + + $r = q("SELECT `id` FROM `contact` WHERE `name` = '%s' AND `nurl` = '%s' AND `uid` = %d LIMIT 1", + dbesc($suggest["name"]), + dbesc(normalise_link($suggest["url"])), + intval($suggest["uid"]) + ); + + /* + * The valid result means the friend we're about to send a friend + * suggestion already has them in their contact, which means no further + * action is required. + * + * @see https://github.com/friendica/friendica/pull/3254#discussion_r107315246 + */ + if (Dbm::is_result($r)) { + return false; + } + + // Do we already have an fcontact record for this person? + + $fid = 0; + $r = q("SELECT `id` FROM `fcontact` WHERE `url` = '%s' AND `name` = '%s' AND `request` = '%s' LIMIT 1", + dbesc($suggest["url"]), + dbesc($suggest["name"]), + dbesc($suggest["request"]) + ); + if (Dbm::is_result($r)) { + $fid = $r[0]["id"]; + + // OK, we do. Do we already have an introduction for this person ? + $r = q("SELECT `id` FROM `intro` WHERE `uid` = %d AND `fid` = %d LIMIT 1", + intval($suggest["uid"]), + intval($fid) + ); + + /* + * The valid result means the friend we're about to send a friend + * suggestion already has them in their contact, which means no further + * action is required. + * + * @see https://github.com/friendica/friendica/pull/3254#discussion_r107315246 + */ + if (Dbm::is_result($r)) { + return false; + } + } + if (!$fid) { + $r = q("INSERT INTO `fcontact` (`name`,`url`,`photo`,`request`) VALUES ('%s', '%s', '%s', '%s')", + dbesc($suggest["name"]), + dbesc($suggest["url"]), + dbesc($suggest["photo"]), + dbesc($suggest["request"]) + ); + } + $r = q("SELECT `id` FROM `fcontact` WHERE `url` = '%s' AND `name` = '%s' AND `request` = '%s' LIMIT 1", + dbesc($suggest["url"]), + dbesc($suggest["name"]), + dbesc($suggest["request"]) + ); + + /* + * If no record in fcontact is found, below INSERT statement will not + * link an introduction to it. + */ + if (!Dbm::is_result($r)) { + // database record did not get created. Quietly give up. + killme(); + } + + $fid = $r[0]["id"]; + + $hash = random_string(); + + $r = q("INSERT INTO `intro` (`uid`, `fid`, `contact-id`, `note`, `hash`, `datetime`, `blocked`) + VALUES(%d, %d, %d, '%s', '%s', '%s', %d)", + intval($suggest["uid"]), + intval($fid), + intval($suggest["cid"]), + dbesc($suggest["body"]), + dbesc($hash), + dbesc(datetime_convert()), + intval(0) + ); + + notification(array( + "type" => NOTIFY_SUGGEST, + "notify_flags" => $importer["notify-flags"], + "language" => $importer["language"], + "to_name" => $importer["username"], + "to_email" => $importer["email"], + "uid" => $importer["importer_uid"], + "item" => $suggest, + "link" => System::baseUrl()."/notifications/intros", + "source_name" => $importer["name"], + "source_link" => $importer["url"], + "source_photo" => $importer["photo"], + "verb" => ACTIVITY_REQ_FRIEND, + "otype" => "intro" + )); + + return true; + + } + + /** + * @brief Processes the relocation elements + * + * @param object $xpath XPath object + * @param object $relocation relocation elements + * @param array $importer Record of the importer user mixed with contact of the content + * @todo Find good type-hints for all parameter + */ + private static function process_relocation($xpath, $relocation, $importer) { + + logger("Processing relocations"); + + /// @TODO Rewrite this to one statement + $relocate = array(); + $relocate["uid"] = $importer["importer_uid"]; + $relocate["cid"] = $importer["id"]; + $relocate["url"] = $xpath->query("dfrn:url/text()", $relocation)->item(0)->nodeValue; + $relocate["addr"] = $xpath->query("dfrn:addr/text()", $relocation)->item(0)->nodeValue; + $relocate["name"] = $xpath->query("dfrn:name/text()", $relocation)->item(0)->nodeValue; + $relocate["avatar"] = $xpath->query("dfrn:avatar/text()", $relocation)->item(0)->nodeValue; + $relocate["photo"] = $xpath->query("dfrn:photo/text()", $relocation)->item(0)->nodeValue; + $relocate["thumb"] = $xpath->query("dfrn:thumb/text()", $relocation)->item(0)->nodeValue; + $relocate["micro"] = $xpath->query("dfrn:micro/text()", $relocation)->item(0)->nodeValue; + $relocate["request"] = $xpath->query("dfrn:request/text()", $relocation)->item(0)->nodeValue; + $relocate["confirm"] = $xpath->query("dfrn:confirm/text()", $relocation)->item(0)->nodeValue; + $relocate["notify"] = $xpath->query("dfrn:notify/text()", $relocation)->item(0)->nodeValue; + $relocate["poll"] = $xpath->query("dfrn:poll/text()", $relocation)->item(0)->nodeValue; + $relocate["sitepubkey"] = $xpath->query("dfrn:sitepubkey/text()", $relocation)->item(0)->nodeValue; + + if (($relocate["avatar"] == "") && ($relocate["photo"] != "")) { + $relocate["avatar"] = $relocate["photo"]; + } + + if ($relocate["addr"] == "") { + $relocate["addr"] = preg_replace("=(https?://)(.*)/profile/(.*)=ism", "$3@$2", $relocate["url"]); + } + + // update contact + $r = q("SELECT `photo`, `url` FROM `contact` WHERE `id` = %d AND `uid` = %d;", + intval($importer["id"]), + intval($importer["importer_uid"])); + + if (!Dbm::is_result($r)) { + logger("Query failed to execute, no result returned in " . __FUNCTION__); + return false; + } + + $old = $r[0]; + + // Update the gcontact entry + $relocate["server_url"] = preg_replace("=(https?://)(.*)/profile/(.*)=ism", "$1$2", $relocate["url"]); + + $x = q("UPDATE `gcontact` SET + `name` = '%s', + `photo` = '%s', + `url` = '%s', + `nurl` = '%s', + `addr` = '%s', + `connect` = '%s', + `notify` = '%s', + `server_url` = '%s' + WHERE `nurl` = '%s';", + dbesc($relocate["name"]), + dbesc($relocate["avatar"]), + dbesc($relocate["url"]), + dbesc(normalise_link($relocate["url"])), + dbesc($relocate["addr"]), + dbesc($relocate["addr"]), + dbesc($relocate["notify"]), + dbesc($relocate["server_url"]), + dbesc(normalise_link($old["url"]))); + + // Update the contact table. We try to find every entry. + $x = q("UPDATE `contact` SET + `name` = '%s', + `avatar` = '%s', + `url` = '%s', + `nurl` = '%s', + `addr` = '%s', + `request` = '%s', + `confirm` = '%s', + `notify` = '%s', + `poll` = '%s', + `site-pubkey` = '%s' + WHERE (`id` = %d AND `uid` = %d) OR (`nurl` = '%s');", + dbesc($relocate["name"]), + dbesc($relocate["avatar"]), + dbesc($relocate["url"]), + dbesc(normalise_link($relocate["url"])), + dbesc($relocate["addr"]), + dbesc($relocate["request"]), + dbesc($relocate["confirm"]), + dbesc($relocate["notify"]), + dbesc($relocate["poll"]), + dbesc($relocate["sitepubkey"]), + intval($importer["id"]), + intval($importer["importer_uid"]), + dbesc(normalise_link($old["url"]))); + + update_contact_avatar($relocate["avatar"], $importer["importer_uid"], $importer["id"], true); + + if ($x === false) { + return false; + } + + // update items + /// @todo This is an extreme performance killer + $fields = array( + 'owner-link' => array($old["url"], $relocate["url"]), + 'author-link' => array($old["url"], $relocate["url"]), + //'owner-avatar' => array($old["photo"], $relocate["photo"]), + //'author-avatar' => array($old["photo"], $relocate["photo"]), + ); + foreach ($fields as $n=>$f) { + $r = q("SELECT `id` FROM `item` WHERE `%s` = '%s' AND `uid` = %d LIMIT 1", + $n, dbesc($f[0]), + intval($importer["importer_uid"])); + + if (Dbm::is_result($r)) { + $x = q("UPDATE `item` SET `%s` = '%s' WHERE `%s` = '%s' AND `uid` = %d", + $n, dbesc($f[1]), + $n, dbesc($f[0]), + intval($importer["importer_uid"])); + + if ($x === false) { + return false; + } + } + } + + /// @TODO + /// merge with current record, current contents have priority + /// update record, set url-updated + /// update profile photos + /// schedule a scan? + return true; + } + + /** + * @brief Updates an item + * + * @param array $current the current item record + * @param array $item the new item record + * @param array $importer Record of the importer user mixed with contact of the content + * @param int $entrytype Is it a toplevel entry, a comment or a relayed comment? + * @todo set proper type-hints (array?) + */ + private static function update_content($current, $item, $importer, $entrytype) { + $changed = false; + + if (edited_timestamp_is_newer($current, $item)) { + + // do not accept (ignore) an earlier edit than one we currently have. + if (datetime_convert("UTC","UTC",$item["edited"]) < $current["edited"]) { + return false; + } + + $fields = array('title' => $item["title"], 'body' => $item["body"], + 'tag' => $item["tag"], 'changed' => datetime_convert(), + 'edited' => datetime_convert("UTC", "UTC", $item["edited"])); + + $condition = array("`uri` = ? AND `uid` IN (0, ?)", $item["uri"], $importer["importer_uid"]); + dba::update('item', $fields, $condition); + + create_tags_from_itemuri($item["uri"], $importer["importer_uid"]); + update_thread_uri($item["uri"], $importer["importer_uid"]); + + $changed = true; + + if ($entrytype == DFRN_REPLY_RC) { + Worker::add(PRIORITY_HIGH, "notifier","comment-import", $current["id"]); + } + } + + // update last-child if it changes + if ($item["last-child"] && ($item["last-child"] != $current["last-child"])) { + $r = q("UPDATE `item` SET `last-child` = 0, `changed` = '%s' WHERE `parent-uri` = '%s' AND `uid` IN (0, %d)", + dbesc(datetime_convert()), + dbesc($item["parent-uri"]), + intval($importer["importer_uid"]) + ); + $r = q("UPDATE `item` SET `last-child` = %d , `changed` = '%s' WHERE `uri` = '%s' AND `uid` IN (0, %d)", + intval($item["last-child"]), + dbesc(datetime_convert()), + dbesc($item["uri"]), + intval($importer["importer_uid"]) + ); + } + return $changed; + } + + /** + * @brief Detects the entry type of the item + * + * @param array $importer Record of the importer user mixed with contact of the content + * @param array $item the new item record + * + * @return int Is it a toplevel entry, a comment or a relayed comment? + * @todo set proper type-hints (array?) + */ + private static function get_entry_type($importer, $item) { + if ($item["parent-uri"] != $item["uri"]) { + $community = false; + + if ($importer["page-flags"] == PAGE_COMMUNITY || $importer["page-flags"] == PAGE_PRVGROUP) { + $sql_extra = ""; + $community = true; + logger("possible community action"); + } else { + $sql_extra = " AND `contact`.`self` AND `item`.`wall` "; + } + + // was the top-level post for this action written by somebody on this site? + // Specifically, the recipient? + + $is_a_remote_action = false; + + $r = q("SELECT `item`.`parent-uri` FROM `item` + WHERE `item`.`uri` = '%s' + LIMIT 1", + dbesc($item["parent-uri"]) + ); + if (Dbm::is_result($r)) { + $r = q("SELECT `item`.`forum_mode`, `item`.`wall` FROM `item` + INNER JOIN `contact` ON `contact`.`id` = `item`.`contact-id` + WHERE `item`.`uri` = '%s' AND (`item`.`parent-uri` = '%s' OR `item`.`thr-parent` = '%s') + AND `item`.`uid` = %d + $sql_extra + LIMIT 1", + dbesc($r[0]["parent-uri"]), + dbesc($r[0]["parent-uri"]), + dbesc($r[0]["parent-uri"]), + intval($importer["importer_uid"]) + ); + if (Dbm::is_result($r)) { + $is_a_remote_action = true; + } + } + + /* + * Does this have the characteristics of a community or private group action? + * If it's an action to a wall post on a community/prvgroup page it's a + * valid community action. Also forum_mode makes it valid for sure. + * If neither, it's not. + */ + + /// @TODO Maybe merge these if() blocks into one? + if ($is_a_remote_action && $community && (!$r[0]["forum_mode"]) && (!$r[0]["wall"])) { + $is_a_remote_action = false; + logger("not a community action"); + } + + if ($is_a_remote_action) { + return DFRN_REPLY_RC; + } else { + return DFRN_REPLY; + } + } else { + return DFRN_TOP_LEVEL; + } + + } + + /** + * @brief Send a "poke" + * + * @param array $item the new item record + * @param array $importer Record of the importer user mixed with contact of the content + * @param int $posted_id The record number of item record that was just posted + * @todo set proper type-hints (array?) + */ + private static function do_poke($item, $importer, $posted_id) { + $verb = urldecode(substr($item["verb"],strpos($item["verb"], "#")+1)); + if (!$verb) { + return; + } + $xo = parse_xml_string($item["object"],false); + + if (($xo->type == ACTIVITY_OBJ_PERSON) && ($xo->id)) { + + // somebody was poked/prodded. Was it me? + foreach ($xo->link as $l) { + $atts = $l->attributes(); + switch ($atts["rel"]) { + case "alternate": + $Blink = $atts["href"]; + break; + default: + break; + } + } + + if ($Blink && link_compare($Blink, System::baseUrl() . "/profile/" . $importer["nickname"])) { + + // send a notification + notification(array( + "type" => NOTIFY_POKE, + "notify_flags" => $importer["notify-flags"], + "language" => $importer["language"], + "to_name" => $importer["username"], + "to_email" => $importer["email"], + "uid" => $importer["importer_uid"], + "item" => $item, + "link" => System::baseUrl()."/display/".urlencode(get_item_guid($posted_id)), + "source_name" => stripslashes($item["author-name"]), + "source_link" => $item["author-link"], + "source_photo" => ((link_compare($item["author-link"],$importer["url"])) + ? $importer["thumb"] : $item["author-avatar"]), + "verb" => $item["verb"], + "otype" => "person", + "activity" => $verb, + "parent" => $item["parent"] + )); + } + } + } + + /** + * @brief Processes several actions, depending on the verb + * + * @param int $entrytype Is it a toplevel entry, a comment or a relayed comment? + * @param array $importer Record of the importer user mixed with contact of the content + * @param array $item the new item record + * @param bool $is_like Is the verb a "like"? + * + * @return bool Should the processing of the entries be continued? + * @todo set proper type-hints (array?) + */ + private static function process_verbs($entrytype, $importer, &$item, &$is_like) { + + logger("Process verb ".$item["verb"]." and object-type ".$item["object-type"]." for entrytype ".$entrytype, LOGGER_DEBUG); + + if (($entrytype == DFRN_TOP_LEVEL)) { + // The filling of the the "contact" variable is done for legcy reasons + // The functions below are partly used by ostatus.php as well - where we have this variable + $r = q("SELECT * FROM `contact` WHERE `id` = %d", intval($importer["id"])); + $contact = $r[0]; + $nickname = $contact["nick"]; + + // Big question: Do we need these functions? They were part of the "consume_feed" function. + // This function once was responsible for DFRN and OStatus. + if (activity_match($item["verb"], ACTIVITY_FOLLOW)) { + logger("New follower"); + new_follower($importer, $contact, $item, $nickname); + return false; + } + if (activity_match($item["verb"], ACTIVITY_UNFOLLOW)) { + logger("Lost follower"); + lose_follower($importer, $contact, $item); + return false; + } + if (activity_match($item["verb"], ACTIVITY_REQ_FRIEND)) { + logger("New friend request"); + new_follower($importer, $contact, $item, $nickname, true); + return false; + } + if (activity_match($item["verb"], ACTIVITY_UNFRIEND)) { + logger("Lost sharer"); + lose_sharer($importer, $contact, $item); + return false; + } + } else { + if (($item["verb"] == ACTIVITY_LIKE) + || ($item["verb"] == ACTIVITY_DISLIKE) + || ($item["verb"] == ACTIVITY_ATTEND) + || ($item["verb"] == ACTIVITY_ATTENDNO) + || ($item["verb"] == ACTIVITY_ATTENDMAYBE)) { + $is_like = true; + $item["type"] = "activity"; + $item["gravity"] = GRAVITY_LIKE; + // only one like or dislike per person + // splitted into two queries for performance issues + $r = q("SELECT `id` FROM `item` WHERE `uid` = %d AND `author-link` = '%s' AND `verb` = '%s' AND `parent-uri` = '%s' AND NOT `deleted` LIMIT 1", + intval($item["uid"]), + dbesc($item["author-link"]), + dbesc($item["verb"]), + dbesc($item["parent-uri"]) + ); + if (Dbm::is_result($r)) { + return false; + } + + $r = q("SELECT `id` FROM `item` WHERE `uid` = %d AND `author-link` = '%s' AND `verb` = '%s' AND `thr-parent` = '%s' AND NOT `deleted` LIMIT 1", + intval($item["uid"]), + dbesc($item["author-link"]), + dbesc($item["verb"]), + dbesc($item["parent-uri"]) + ); + if (Dbm::is_result($r)) { + return false; + } + } else { + $is_like = false; + } + + if (($item["verb"] == ACTIVITY_TAG) && ($item["object-type"] == ACTIVITY_OBJ_TAGTERM)) { + + $xo = parse_xml_string($item["object"],false); + $xt = parse_xml_string($item["target"],false); + + if ($xt->type == ACTIVITY_OBJ_NOTE) { + $r = q("SELECT `id`, `tag` FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1", + dbesc($xt->id), + intval($importer["importer_uid"]) + ); + + if (!Dbm::is_result($r)) { + logger("Query failed to execute, no result returned in " . __FUNCTION__); + return false; + } + + // extract tag, if not duplicate, add to parent item + if ($xo->content) { + if (!(stristr($r[0]["tag"],trim($xo->content)))) { + q("UPDATE `item` SET `tag` = '%s' WHERE `id` = %d", + dbesc($r[0]["tag"] . (strlen($r[0]["tag"]) ? ',' : '') . '#[url=' . $xo->id . ']'. $xo->content . '[/url]'), + intval($r[0]["id"]) + ); + create_tags_from_item($r[0]["id"]); + } + } + } + } + } + return true; + } + + /** + * @brief Processes the link elements + * + * @param object $links link elements + * @param array $item the item record + * @todo set proper type-hints + */ + private static function parse_links($links, &$item) { + $rel = ""; + $href = ""; + $type = ""; + $length = "0"; + $title = ""; + foreach ($links AS $link) { + foreach ($link->attributes AS $attributes) { + /// @TODO Rewrite these repeated (same) if () statements to a switch() + if ($attributes->name == "href") { + $href = $attributes->textContent; + } + if ($attributes->name == "rel") { + $rel = $attributes->textContent; + } + if ($attributes->name == "type") { + $type = $attributes->textContent; + } + if ($attributes->name == "length") { + $length = $attributes->textContent; + } + if ($attributes->name == "title") { + $title = $attributes->textContent; + } + } + if (($rel != "") && ($href != "")) { + switch ($rel) { + case "alternate": + $item["plink"] = $href; + break; + case "enclosure": + $enclosure = $href; + if (strlen($item["attach"])) { + $item["attach"] .= ","; + } + + $item["attach"] .= '[attach]href="' . $href . '" length="' . $length . '" type="' . $type . '" title="' . $title . '"[/attach]'; + break; + } + } + } + } + + /** + * @brief Processes the entry elements which contain the items and comments + * + * @param array $header Array of the header elements that always stay the same + * @param object $xpath XPath object + * @param object $entry entry elements + * @param array $importer Record of the importer user mixed with contact of the content + * @todo Add type-hints + */ + private static function process_entry($header, $xpath, $entry, $importer, $xml) { + + logger("Processing entries"); + + $item = $header; + + $item["protocol"] = PROTOCOL_DFRN; + + $item["source"] = $xml; + + // Get the uri + $item["uri"] = $xpath->query("atom:id/text()", $entry)->item(0)->nodeValue; + + $item["edited"] = $xpath->query("atom:updated/text()", $entry)->item(0)->nodeValue; + + $current = q("SELECT `id`, `uid`, `last-child`, `edited`, `body` FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1", + dbesc($item["uri"]), + intval($importer["importer_uid"]) + ); + + // Is there an existing item? + if (Dbm::is_result($current) && edited_timestamp_is_newer($current[0], $item) && + (datetime_convert("UTC","UTC",$item["edited"]) < $current[0]["edited"])) { + logger("Item ".$item["uri"]." already existed.", LOGGER_DEBUG); + return; + } + + // Fetch the owner + $owner = self::fetchauthor($xpath, $entry, $importer, "dfrn:owner", true); + + $item["owner-name"] = $owner["name"]; + $item["owner-link"] = $owner["link"]; + $item["owner-avatar"] = $owner["avatar"]; + + // fetch the author + $author = self::fetchauthor($xpath, $entry, $importer, "atom:author", true); + + $item["author-name"] = $author["name"]; + $item["author-link"] = $author["link"]; + $item["author-avatar"] = $author["avatar"]; + + $item["title"] = $xpath->query("atom:title/text()", $entry)->item(0)->nodeValue; + + $item["created"] = $xpath->query("atom:published/text()", $entry)->item(0)->nodeValue; + + $item["body"] = $xpath->query("dfrn:env/text()", $entry)->item(0)->nodeValue; + $item["body"] = str_replace(array(' ',"\t","\r","\n"), array('','','',''),$item["body"]); + // make sure nobody is trying to sneak some html tags by us + $item["body"] = notags(base64url_decode($item["body"])); + + $item["body"] = limit_body_size($item["body"]); + + /// @todo Do we really need this check for HTML elements? (It was copied from the old function) + if ((strpos($item['body'],'<') !== false) && (strpos($item['body'],'>') !== false)) { + + $item['body'] = reltoabs($item['body'],$base_url); + + $item['body'] = html2bb_video($item['body']); + + $item['body'] = oembed_html2bbcode($item['body']); + + $config = HTMLPurifier_Config::createDefault(); + $config->set('Cache.DefinitionImpl', null); + + // we shouldn't need a whitelist, because the bbcode converter + // will strip out any unsupported tags. + + $purifier = new HTMLPurifier($config); + $item['body'] = $purifier->purify($item['body']); + + $item['body'] = @html2bbcode($item['body']); + } + + /// @todo We should check for a repeated post and if we know the repeated author. + + // We don't need the content element since "dfrn:env" is always present + //$item["body"] = $xpath->query("atom:content/text()", $entry)->item(0)->nodeValue; + + $item["last-child"] = $xpath->query("dfrn:comment-allow/text()", $entry)->item(0)->nodeValue; + $item["location"] = $xpath->query("dfrn:location/text()", $entry)->item(0)->nodeValue; + + $georsspoint = $xpath->query("georss:point", $entry); + if ($georsspoint) { + $item["coord"] = $georsspoint->item(0)->nodeValue; + } + + $item["private"] = $xpath->query("dfrn:private/text()", $entry)->item(0)->nodeValue; + + $item["extid"] = $xpath->query("dfrn:extid/text()", $entry)->item(0)->nodeValue; + + if ($xpath->query("dfrn:bookmark/text()", $entry)->item(0)->nodeValue == "true") { + $item["bookmark"] = true; + } + + $notice_info = $xpath->query("statusnet:notice_info", $entry); + if ($notice_info && ($notice_info->length > 0)) { + foreach ($notice_info->item(0)->attributes AS $attributes) { + if ($attributes->name == "source") { + $item["app"] = strip_tags($attributes->textContent); + } + } + } + + $item["guid"] = $xpath->query("dfrn:diaspora_guid/text()", $entry)->item(0)->nodeValue; + + // We store the data from "dfrn:diaspora_signature" in a different table, this is done in "item_store" + $dsprsig = unxmlify($xpath->query("dfrn:diaspora_signature/text()", $entry)->item(0)->nodeValue); + if ($dsprsig != "") { + $item["dsprsig"] = $dsprsig; + } + + $item["verb"] = $xpath->query("activity:verb/text()", $entry)->item(0)->nodeValue; + + if ($xpath->query("activity:object-type/text()", $entry)->item(0)->nodeValue != "") { + $item["object-type"] = $xpath->query("activity:object-type/text()", $entry)->item(0)->nodeValue; + } + + $object = $xpath->query("activity:object", $entry)->item(0); + $item["object"] = self::transform_activity($xpath, $object, "object"); + + if (trim($item["object"]) != "") { + $r = parse_xml_string($item["object"], false); + if (isset($r->type)) { + $item["object-type"] = $r->type; + } + } + + $target = $xpath->query("activity:target", $entry)->item(0); + $item["target"] = self::transform_activity($xpath, $target, "target"); + + $categories = $xpath->query("atom:category", $entry); + if ($categories) { + foreach ($categories AS $category) { + $term = ""; + $scheme = ""; + foreach ($category->attributes AS $attributes) { + if ($attributes->name == "term") { + $term = $attributes->textContent; + } + + if ($attributes->name == "scheme") { + $scheme = $attributes->textContent; + } + } + + if (($term != "") && ($scheme != "")) { + $parts = explode(":", $scheme); + if ((count($parts) >= 4) && (array_shift($parts) == "X-DFRN")) { + $termhash = array_shift($parts); + $termurl = implode(":", $parts); + + if (strlen($item["tag"])) { + $item["tag"] .= ","; + } + + $item["tag"] .= $termhash . "[url=" . $termurl . "]" . $term . "[/url]"; + } + } + } + } + + $enclosure = ""; + + $links = $xpath->query("atom:link", $entry); + if ($links) { + self::parse_links($links, $item); + } + + $item['conversation-uri'] = $xpath->query('ostatus:conversation/text()', $entry)->item(0)->nodeValue; + + $conv = $xpath->query('ostatus:conversation', $entry); + if (is_object($conv->item(0))) { + foreach ($conv->item(0)->attributes AS $attributes) { + if ($attributes->name == "ref") { + $item['conversation-uri'] = $attributes->textContent; + } + if ($attributes->name == "href") { + $item['conversation-href'] = $attributes->textContent; + } + } + } + + // Is it a reply or a top level posting? + $item["parent-uri"] = $item["uri"]; + + $inreplyto = $xpath->query("thr:in-reply-to", $entry); + if (is_object($inreplyto->item(0))) { + foreach ($inreplyto->item(0)->attributes AS $attributes) { + if ($attributes->name == "ref") { + $item["parent-uri"] = $attributes->textContent; + } + } + } + + // Get the type of the item (Top level post, reply or remote reply) + $entrytype = self::get_entry_type($importer, $item); + + // Now assign the rest of the values that depend on the type of the message + if (in_array($entrytype, array(DFRN_REPLY, DFRN_REPLY_RC))) { + if (!isset($item["object-type"])) { + $item["object-type"] = ACTIVITY_OBJ_COMMENT; + } + + if ($item["contact-id"] != $owner["contact-id"]) { + $item["contact-id"] = $owner["contact-id"]; + } + + if (($item["network"] != $owner["network"]) && ($owner["network"] != "")) { + $item["network"] = $owner["network"]; + } + + if ($item["contact-id"] != $author["contact-id"]) { + $item["contact-id"] = $author["contact-id"]; + } + + if (($item["network"] != $author["network"]) && ($author["network"] != "")) { + $item["network"] = $author["network"]; + } + + /// @TODO maybe remove this old-lost code then? + // This code was taken from the old DFRN code + // When activated, forums don't work. + // And: Why should we disallow commenting by followers? + // the behaviour is now similar to the Diaspora part. + //if ($importer["rel"] == CONTACT_IS_FOLLOWER) { + // logger("Contact ".$importer["id"]." is only follower. Quitting", LOGGER_DEBUG); + // return; + //} + } + + if ($entrytype == DFRN_REPLY_RC) { + $item["type"] = "remote-comment"; + $item["wall"] = 1; + } elseif ($entrytype == DFRN_TOP_LEVEL) { + if (!isset($item["object-type"])) { + $item["object-type"] = ACTIVITY_OBJ_NOTE; + } + + // Is it an event? + if ($item["object-type"] == ACTIVITY_OBJ_EVENT) { + logger("Item ".$item["uri"]." seems to contain an event.", LOGGER_DEBUG); + $ev = bbtoevent($item["body"]); + if ((x($ev, "desc") || x($ev, "summary")) && x($ev, "start")) { + logger("Event in item ".$item["uri"]." was found.", LOGGER_DEBUG); + /// @TODO Mixure of "/' ahead ... + $ev["cid"] = $importer["id"]; + $ev["uid"] = $importer["uid"]; + $ev["uri"] = $item["uri"]; + $ev["edited"] = $item["edited"]; + $ev['private'] = $item['private']; + $ev["guid"] = $item["guid"]; + + $r = q("SELECT `id` FROM `event` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1", + dbesc($item["uri"]), + intval($importer["uid"]) + ); + if (Dbm::is_result($r)) { + $ev["id"] = $r[0]["id"]; + } + + $event_id = event_store($ev); + logger("Event ".$event_id." was stored", LOGGER_DEBUG); + return; + } + } + } + + if (!self::process_verbs($entrytype, $importer, $item, $is_like)) { + logger("Exiting because 'process_verbs' told us so", LOGGER_DEBUG); + return; + } + + // Update content if 'updated' changes + if (Dbm::is_result($current)) { + if (self::update_content($r[0], $item, $importer, $entrytype)) { + logger("Item ".$item["uri"]." was updated.", LOGGER_DEBUG); + } else { + logger("Item ".$item["uri"]." already existed.", LOGGER_DEBUG); + } + return; + } + + if (in_array($entrytype, array(DFRN_REPLY, DFRN_REPLY_RC))) { + $posted_id = item_store($item); + $parent = 0; + + if ($posted_id) { + + logger("Reply from contact ".$item["contact-id"]." was stored with id ".$posted_id, LOGGER_DEBUG); + + $item["id"] = $posted_id; + + $r = q("SELECT `parent`, `parent-uri` FROM `item` WHERE `id` = %d AND `uid` = %d LIMIT 1", + intval($posted_id), + intval($importer["importer_uid"]) + ); + if (Dbm::is_result($r)) { + $parent = $r[0]["parent"]; + $parent_uri = $r[0]["parent-uri"]; + } + + if (!$is_like) { + $r1 = q("UPDATE `item` SET `last-child` = 0, `changed` = '%s' WHERE `uid` = %d AND `parent` = %d", + dbesc(datetime_convert()), + intval($importer["importer_uid"]), + intval($r[0]["parent"]) + ); + + $r2 = q("UPDATE `item` SET `last-child` = 1, `changed` = '%s' WHERE `uid` = %d AND `id` = %d", + dbesc(datetime_convert()), + intval($importer["importer_uid"]), + intval($posted_id) + ); + } + + if ($posted_id && $parent && ($entrytype == DFRN_REPLY_RC)) { + logger("Notifying followers about comment ".$posted_id, LOGGER_DEBUG); + Worker::add(PRIORITY_HIGH, "notifier", "comment-import", $posted_id); + } + + return true; + } + } else { // $entrytype == DFRN_TOP_LEVEL + if (!link_compare($item["owner-link"],$importer["url"])) { + /* + * The item owner info is not our contact. It's OK and is to be expected if this is a tgroup delivery, + * but otherwise there's a possible data mixup on the sender's system. + * the tgroup delivery code called from item_store will correct it if it's a forum, + * but we're going to unconditionally correct it here so that the post will always be owned by our contact. + */ + logger('Correcting item owner.', LOGGER_DEBUG); + $item["owner-name"] = $importer["senderName"]; + $item["owner-link"] = $importer["url"]; + $item["owner-avatar"] = $importer["thumb"]; + } + + if (($importer["rel"] == CONTACT_IS_FOLLOWER) && (!tgroup_check($importer["importer_uid"], $item))) { + logger("Contact ".$importer["id"]." is only follower and tgroup check was negative.", LOGGER_DEBUG); + return; + } + + // This is my contact on another system, but it's really me. + // Turn this into a wall post. + $notify = item_is_remote_self($importer, $item); + + $posted_id = item_store($item, false, $notify); + + logger("Item was stored with id ".$posted_id, LOGGER_DEBUG); + + if (stristr($item["verb"],ACTIVITY_POKE)) + self::do_poke($item, $importer, $posted_id); + } + } + + /** + * @brief Deletes items + * + * @param object $xpath XPath object + * @param object $deletion deletion elements + * @param array $importer Record of the importer user mixed with contact of the content + * @todo set proper type-hints + */ + private static function process_deletion($xpath, $deletion, $importer) { + + logger("Processing deletions"); + + foreach ($deletion->attributes AS $attributes) { + if ($attributes->name == "ref") { + $uri = $attributes->textContent; + } + if ($attributes->name == "when") { + $when = $attributes->textContent; + } + } + if ($when) { + $when = datetime_convert("UTC", "UTC", $when, "Y-m-d H:i:s"); + } else { + $when = datetime_convert("UTC", "UTC", "now", "Y-m-d H:i:s"); + } + + if (!$uri || !$importer["id"]) { + return false; + } + + /// @todo Only select the used fields + $r = q("SELECT `item`.*, `contact`.`self` FROM `item` INNER JOIN `contact` on `item`.`contact-id` = `contact`.`id` + WHERE `uri` = '%s' AND `item`.`uid` = %d AND `contact-id` = %d AND NOT `item`.`file` LIKE '%%[%%' LIMIT 1", + dbesc($uri), + intval($importer["uid"]), + intval($importer["id"]) + ); + if (!Dbm::is_result($r)) { + logger("Item with uri " . $uri . " from contact " . $importer["id"] . " for user " . $importer["uid"] . " wasn't found.", LOGGER_DEBUG); + return; + } else { + + $item = $r[0]; + + $entrytype = self::get_entry_type($importer, $item); + + if (!$item["deleted"]) { + logger('deleting item '.$item["id"].' uri='.$uri, LOGGER_DEBUG); + } else { + return; + } + + if ($item["object-type"] == ACTIVITY_OBJ_EVENT) { + logger("Deleting event ".$item["event-id"], LOGGER_DEBUG); + event_delete($item["event-id"]); + } + + if (($item["verb"] == ACTIVITY_TAG) && ($item["object-type"] == ACTIVITY_OBJ_TAGTERM)) { + + $xo = parse_xml_string($item["object"],false); + $xt = parse_xml_string($item["target"],false); + + if ($xt->type == ACTIVITY_OBJ_NOTE) { + $i = q("SELECT `id`, `contact-id`, `tag` FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1", + dbesc($xt->id), + intval($importer["importer_uid"]) + ); + if (Dbm::is_result($i)) { + + // For tags, the owner cannot remove the tag on the author's copy of the post. + + $owner_remove = (($item["contact-id"] == $i[0]["contact-id"]) ? true: false); + $author_remove = (($item["origin"] && $item["self"]) ? true : false); + $author_copy = (($item["origin"]) ? true : false); + + if ($owner_remove && $author_copy) { + return; + } + if ($author_remove || $owner_remove) { + $tags = explode(',',$i[0]["tag"]); + $newtags = array(); + if (count($tags)) { + foreach ($tags as $tag) { + if (trim($tag) !== trim($xo->body)) { + $newtags[] = trim($tag); + } + } + } + q("UPDATE `item` SET `tag` = '%s' WHERE `id` = %d", + dbesc(implode(',', $newtags)), + intval($i[0]["id"]) + ); + create_tags_from_item($i[0]["id"]); + } + } + } + } + + if ($entrytype == DFRN_TOP_LEVEL) { + $r = q("UPDATE `item` SET `deleted` = 1, `edited` = '%s', `changed` = '%s', + `body` = '', `title` = '' + WHERE `parent-uri` = '%s' AND `uid` IN (0, %d)", + dbesc($when), + dbesc(datetime_convert()), + dbesc($uri), + intval($importer["uid"]) + ); + create_tags_from_itemuri($uri, $importer["uid"]); + create_files_from_itemuri($uri, $importer["uid"]); + update_thread_uri($uri, $importer["uid"]); + } else { + $r = q("UPDATE `item` SET `deleted` = 1, `edited` = '%s', `changed` = '%s', + `body` = '', `title` = '' + WHERE `uri` = '%s' AND `uid` IN (0, %d)", + dbesc($when), + dbesc(datetime_convert()), + dbesc($uri), + intval($importer["uid"]) + ); + create_tags_from_itemuri($uri, $importer["uid"]); + create_files_from_itemuri($uri, $importer["uid"]); + update_thread_uri($uri, $importer["importer_uid"]); + if ($item["last-child"]) { + // ensure that last-child is set in case the comment that had it just got wiped. + q("UPDATE `item` SET `last-child` = 0, `changed` = '%s' WHERE `parent-uri` = '%s' AND `uid` IN (0, %d)", + dbesc(datetime_convert()), + dbesc($item["parent-uri"]), + intval($item["uid"]) + ); + // who is the last child now? + $r = q("SELECT `id` FROM `item` WHERE `parent-uri` = '%s' AND `type` != 'activity' AND `deleted` = 0 AND `moderated` = 0 AND `uid` = %d + ORDER BY `created` DESC LIMIT 1", + dbesc($item["parent-uri"]), + intval($importer["uid"]) + ); + if (Dbm::is_result($r)) { + q("UPDATE `item` SET `last-child` = 1 WHERE `id` = %d", + intval($r[0]["id"]) + ); + } + } + // if this is a relayed delete, propagate it to other recipients + + if ($entrytype == DFRN_REPLY_RC) { + logger("Notifying followers about deletion of post " . $item["id"], LOGGER_DEBUG); + Worker::add(PRIORITY_HIGH, "notifier","drop", $item["id"]); + } + } + } + } + + /** + * @brief Imports a DFRN message + * + * @param text $xml The DFRN message + * @param array $importer Record of the importer user mixed with contact of the content + * @param bool $sort_by_date Is used when feeds are polled + * @return integer Import status + * @todo set proper type-hints + */ + public static function import($xml, $importer, $sort_by_date = false) { + + if ($xml == "") { + return 400; + } + + $doc = new DOMDocument(); + @$doc->loadXML($xml); + + $xpath = new DomXPath($doc); + $xpath->registerNamespace("atom", NAMESPACE_ATOM1); + $xpath->registerNamespace("thr", NAMESPACE_THREAD); + $xpath->registerNamespace("at", NAMESPACE_TOMB); + $xpath->registerNamespace("media", NAMESPACE_MEDIA); + $xpath->registerNamespace("dfrn", NAMESPACE_DFRN); + $xpath->registerNamespace("activity", NAMESPACE_ACTIVITY); + $xpath->registerNamespace("georss", NAMESPACE_GEORSS); + $xpath->registerNamespace("poco", NAMESPACE_POCO); + $xpath->registerNamespace("ostatus", NAMESPACE_OSTATUS); + $xpath->registerNamespace("statusnet", NAMESPACE_STATUSNET); + + $header = array(); + $header["uid"] = $importer["uid"]; + $header["network"] = NETWORK_DFRN; + $header["type"] = "remote"; + $header["wall"] = 0; + $header["origin"] = 0; + $header["contact-id"] = $importer["id"]; + + // Update the contact table if the data has changed + + // The "atom:author" is only present in feeds + if ($xpath->query("/atom:feed/atom:author")->length > 0) { + self::fetchauthor($xpath, $doc->firstChild, $importer, "atom:author", false, $xml); + } + + // Only the "dfrn:owner" in the head section contains all data + if ($xpath->query("/atom:feed/dfrn:owner")->length > 0) { + self::fetchauthor($xpath, $doc->firstChild, $importer, "dfrn:owner", false, $xml); + } + + logger("Import DFRN message for user " . $importer["uid"] . " from contact " . $importer["id"], LOGGER_DEBUG); + + // The account type is new since 3.5.1 + if ($xpath->query("/atom:feed/dfrn:account_type")->length > 0) { + $accounttype = intval($xpath->evaluate("/atom:feed/dfrn:account_type/text()", $context)->item(0)->nodeValue); + + if ($accounttype != $importer["contact-type"]) { + dba::update('contact', array('contact-type' => $accounttype), array('id' => $importer["id"])); + } + } + + // is it a public forum? Private forums aren't supported with this method + // This is deprecated since 3.5.1 + $forum = intval($xpath->evaluate("/atom:feed/dfrn:community/text()", $context)->item(0)->nodeValue); + + if ($forum != $importer["forum"]) { + $condition = array('`forum` != ? AND `id` = ?', $forum, $importer["id"]); + dba::update('contact', array('forum' => $forum), $condition); + } + + // We are processing relocations even if we are ignoring a contact + $relocations = $xpath->query("/atom:feed/dfrn:relocate"); + foreach ($relocations AS $relocation) { + self::process_relocation($xpath, $relocation, $importer); + } + + if ($importer["readonly"]) { + // We aren't receiving stuff from this person. But we will quietly ignore them + // rather than a blatant "go away" message. + logger('ignoring contact '.$importer["id"]); + return 403; + } + + $mails = $xpath->query("/atom:feed/dfrn:mail"); + foreach ($mails AS $mail) { + self::process_mail($xpath, $mail, $importer); + } + + $suggestions = $xpath->query("/atom:feed/dfrn:suggest"); + foreach ($suggestions AS $suggestion) { + self::process_suggestion($xpath, $suggestion, $importer); + } + + $deletions = $xpath->query("/atom:feed/at:deleted-entry"); + foreach ($deletions AS $deletion) { + self::process_deletion($xpath, $deletion, $importer); + } + + if (!$sort_by_date) { + $entries = $xpath->query("/atom:feed/atom:entry"); + foreach ($entries AS $entry) { + self::process_entry($header, $xpath, $entry, $importer, $xml); + } + } else { + $newentries = array(); + $entries = $xpath->query("/atom:feed/atom:entry"); + foreach ($entries AS $entry) { + $created = $xpath->query("atom:published/text()", $entry)->item(0)->nodeValue; + $newentries[strtotime($created)] = $entry; + } + + // Now sort after the publishing date + ksort($newentries); + + foreach ($newentries AS $entry) { + self::process_entry($header, $xpath, $entry, $importer, $xml); + } + } + logger("Import done for user " . $importer["uid"] . " from contact " . $importer["id"], LOGGER_DEBUG); + return 200; + } +} diff --git a/src/Protocol/Diaspora.php b/src/Protocol/Diaspora.php new file mode 100644 index 0000000000..5960d32af8 --- /dev/null +++ b/src/Protocol/Diaspora.php @@ -0,0 +1,3948 @@ +children('http://salmon-protocol.org/ns/magic-env'); + + if (sizeof($children) == 0) { + logger("XML has no children"); + return false; + } + + $handle = ""; + + $data = base64url_decode($children->data); + $type = $children->data->attributes()->type[0]; + + $encoding = $children->encoding; + + $alg = $children->alg; + + $sig = base64url_decode($children->sig); + $key_id = $children->sig->attributes()->key_id[0]; + if ($key_id != "") + $handle = base64url_decode($key_id); + + $b64url_data = base64url_encode($data); + $msg = str_replace(array("\n", "\r", " ", "\t"), array("", "", "", ""), $b64url_data); + + $signable_data = $msg.".".base64url_encode($type).".".base64url_encode($encoding).".".base64url_encode($alg); + + $key = self::key($handle); + + $verify = rsa_verify($signable_data, $sig, $key); + if (!$verify) { + logger('Message did not verify. Discarding.'); + return false; + } + + return $data; + } + + /** + * @brief encrypts data via AES + * + * @param string $key The AES key + * @param string $iv The IV (is used for CBC encoding) + * @param string $data The data that is to be encrypted + * + * @return string encrypted data + */ + private static function aes_encrypt($key, $iv, $data) { + return openssl_encrypt($data, 'aes-256-cbc', str_pad($key, 32, "\0"), OPENSSL_RAW_DATA, str_pad($iv, 16, "\0")); + } + + /** + * @brief decrypts data via AES + * + * @param string $key The AES key + * @param string $iv The IV (is used for CBC encoding) + * @param string $encrypted The encrypted data + * + * @return string decrypted data + */ + private static function aes_decrypt($key, $iv, $encrypted) { + return openssl_decrypt($encrypted,'aes-256-cbc', str_pad($key, 32, "\0"), OPENSSL_RAW_DATA,str_pad($iv, 16, "\0")); + } + + /** + * @brief: Decodes incoming Diaspora message in the new format + * + * @param array $importer Array of the importer user + * @param string $raw raw post message + * + * @return array + * 'message' -> decoded Diaspora XML message + * 'author' -> author diaspora handle + * 'key' -> author public key (converted to pkcs#8) + */ + public static function decode_raw($importer, $raw) { + $data = json_decode($raw); + + // Is it a private post? Then decrypt the outer Salmon + if (is_object($data)) { + $encrypted_aes_key_bundle = base64_decode($data->aes_key); + $ciphertext = base64_decode($data->encrypted_magic_envelope); + + $outer_key_bundle = ''; + @openssl_private_decrypt($encrypted_aes_key_bundle, $outer_key_bundle, $importer['prvkey']); + $j_outer_key_bundle = json_decode($outer_key_bundle); + + if (!is_object($j_outer_key_bundle)) { + logger('Outer Salmon did not verify. Discarding.'); + http_status_exit(400); + } + + $outer_iv = base64_decode($j_outer_key_bundle->iv); + $outer_key = base64_decode($j_outer_key_bundle->key); + + $xml = self::aes_decrypt($outer_key, $outer_iv, $ciphertext); + } else { + $xml = $raw; + } + + $basedom = parse_xml_string($xml); + + if (!is_object($basedom)) { + logger('Received data does not seem to be an XML. Discarding. '.$xml); + http_status_exit(400); + } + + $base = $basedom->children(NAMESPACE_SALMON_ME); + + // Not sure if this cleaning is needed + $data = str_replace(array(" ", "\t", "\r", "\n"), array("", "", "", ""), $base->data); + + // Build the signed data + $type = $base->data[0]->attributes()->type[0]; + $encoding = $base->encoding; + $alg = $base->alg; + $signed_data = $data.'.'.base64url_encode($type).'.'.base64url_encode($encoding).'.'.base64url_encode($alg); + + // This is the signature + $signature = base64url_decode($base->sig); + + // Get the senders' public key + $key_id = $base->sig[0]->attributes()->key_id[0]; + $author_addr = base64_decode($key_id); + $key = self::key($author_addr); + + $verify = rsa_verify($signed_data, $signature, $key); + if (!$verify) { + logger('Message did not verify. Discarding.'); + http_status_exit(400); + } + + return array('message' => (string)base64url_decode($base->data), + 'author' => unxmlify($author_addr), + 'key' => (string)$key); + } + + /** + * @brief: Decodes incoming Diaspora message in the deprecated format + * + * @param array $importer Array of the importer user + * @param string $xml urldecoded Diaspora salmon + * + * @return array + * 'message' -> decoded Diaspora XML message + * 'author' -> author diaspora handle + * 'key' -> author public key (converted to pkcs#8) + */ + public static function decode($importer, $xml) { + + $public = false; + $basedom = parse_xml_string($xml); + + if (!is_object($basedom)) { + logger("XML is not parseable."); + return false; + } + $children = $basedom->children('https://joindiaspora.com/protocol'); + + if ($children->header) { + $public = true; + $author_link = str_replace('acct:','',$children->header->author_id); + } else { + // This happens with posts from a relais + if (!$importer) { + logger("This is no private post in the old format", LOGGER_DEBUG); + return false; + } + + $encrypted_header = json_decode(base64_decode($children->encrypted_header)); + + $encrypted_aes_key_bundle = base64_decode($encrypted_header->aes_key); + $ciphertext = base64_decode($encrypted_header->ciphertext); + + $outer_key_bundle = ''; + openssl_private_decrypt($encrypted_aes_key_bundle,$outer_key_bundle,$importer['prvkey']); + + $j_outer_key_bundle = json_decode($outer_key_bundle); + + $outer_iv = base64_decode($j_outer_key_bundle->iv); + $outer_key = base64_decode($j_outer_key_bundle->key); + + $decrypted = self::aes_decrypt($outer_key, $outer_iv, $ciphertext); + + logger('decrypted: '.$decrypted, LOGGER_DEBUG); + $idom = parse_xml_string($decrypted); + + $inner_iv = base64_decode($idom->iv); + $inner_aes_key = base64_decode($idom->aes_key); + + $author_link = str_replace('acct:','',$idom->author_id); + } + + $dom = $basedom->children(NAMESPACE_SALMON_ME); + + // figure out where in the DOM tree our data is hiding + + if ($dom->provenance->data) + $base = $dom->provenance; + elseif ($dom->env->data) + $base = $dom->env; + elseif ($dom->data) + $base = $dom; + + if (!$base) { + logger('unable to locate salmon data in xml'); + http_status_exit(400); + } + + + // Stash the signature away for now. We have to find their key or it won't be good for anything. + $signature = base64url_decode($base->sig); + + // unpack the data + + // strip whitespace so our data element will return to one big base64 blob + $data = str_replace(array(" ","\t","\r","\n"),array("","","",""),$base->data); + + + // stash away some other stuff for later + + $type = $base->data[0]->attributes()->type[0]; + $keyhash = $base->sig[0]->attributes()->keyhash[0]; + $encoding = $base->encoding; + $alg = $base->alg; + + + $signed_data = $data.'.'.base64url_encode($type).'.'.base64url_encode($encoding).'.'.base64url_encode($alg); + + + // decode the data + $data = base64url_decode($data); + + + if ($public) + $inner_decrypted = $data; + else { + + // Decode the encrypted blob + + $inner_encrypted = base64_decode($data); + $inner_decrypted = self::aes_decrypt($inner_aes_key, $inner_iv, $inner_encrypted); + } + + if (!$author_link) { + logger('Could not retrieve author URI.'); + http_status_exit(400); + } + // Once we have the author URI, go to the web and try to find their public key + // (first this will look it up locally if it is in the fcontact cache) + // This will also convert diaspora public key from pkcs#1 to pkcs#8 + + logger('Fetching key for '.$author_link); + $key = self::key($author_link); + + if (!$key) { + logger('Could not retrieve author key.'); + http_status_exit(400); + } + + $verify = rsa_verify($signed_data,$signature,$key); + + if (!$verify) { + logger('Message did not verify. Discarding.'); + http_status_exit(400); + } + + logger('Message verified.'); + + return array('message' => (string)$inner_decrypted, + 'author' => unxmlify($author_link), + 'key' => (string)$key); + } + + + /** + * @brief Dispatches public messages and find the fitting receivers + * + * @param array $msg The post that will be dispatched + * + * @return int The message id of the generated message, "true" or "false" if there was an error + */ + public static function dispatch_public($msg) { + + $enabled = intval(Config::get("system", "diaspora_enabled")); + if (!$enabled) { + logger("diaspora is disabled"); + return false; + } + + if (!($postdata = self::valid_posting($msg))) { + logger("Invalid posting"); + return false; + } + + $fields = $postdata['fields']; + + // Is it a an action (comment, like, ...) for our own post? + if (isset($fields->parent_guid) && !$postdata["relayed"]) { + $guid = notags(unxmlify($fields->parent_guid)); + $importer = self::importer_for_guid($guid); + if (is_array($importer)) { + logger("delivering to origin: ".$importer["name"]); + $message_id = self::dispatch($importer, $msg, $fields); + return $message_id; + } + } + + // Process item retractions. This has to be done separated from the other stuff, + // since retractions for comments could come even from non followers. + if (!empty($fields) && in_array($fields->getName(), array('retraction'))) { + $target = notags(unxmlify($fields->target_type)); + if (in_array($target, array("Comment", "Like", "Post", "Reshare", "StatusMessage"))) { + logger('processing retraction for '.$target, LOGGER_DEBUG); + $importer = array("uid" => 0, "page-flags" => PAGE_FREELOVE); + $message_id = self::dispatch($importer, $msg, $fields); + return $message_id; + } + } + + // Now distribute it to the followers + $r = q("SELECT `user`.* FROM `user` WHERE `user`.`uid` IN + (SELECT `contact`.`uid` FROM `contact` WHERE `contact`.`network` = '%s' AND `contact`.`addr` = '%s') + AND NOT `account_expired` AND NOT `account_removed`", + dbesc(NETWORK_DIASPORA), + dbesc($msg["author"]) + ); + + if (Dbm::is_result($r)) { + foreach ($r as $rr) { + logger("delivering to: ".$rr["username"]); + self::dispatch($rr, $msg, $fields); + } + } elseif (!Config::get('system', 'relay_subscribe', false)) { + logger("Unwanted message from ".$msg["author"]." send by ".$_SERVER["REMOTE_ADDR"]." with ".$_SERVER["HTTP_USER_AGENT"].": ".print_r($msg, true), LOGGER_DEBUG); + } else { + // Use a dummy importer to import the data for the public copy + $importer = array("uid" => 0, "page-flags" => PAGE_FREELOVE); + $message_id = self::dispatch($importer, $msg, $fields); + } + + return $message_id; + } + + /** + * @brief Dispatches the different message types to the different functions + * + * @param array $importer Array of the importer user + * @param array $msg The post that will be dispatched + * @param object $fields SimpleXML object that contains the message + * + * @return int The message id of the generated message, "true" or "false" if there was an error + */ + public static function dispatch($importer, $msg, $fields = null) { + + // The sender is the handle of the contact that sent the message. + // This will often be different with relayed messages (for example "like" and "comment") + $sender = $msg["author"]; + + // This is only needed for private postings since this is already done for public ones before + if (is_null($fields)) { + if (!($postdata = self::valid_posting($msg))) { + logger("Invalid posting"); + return false; + } + $fields = $postdata['fields']; + } + + $type = $fields->getName(); + + logger("Received message type ".$type." from ".$sender." for user ".$importer["uid"], LOGGER_DEBUG); + + switch ($type) { + case "account_migration": + return self::receiveAccountMigration($importer, $fields); + + case "account_deletion": + return self::receive_account_deletion($importer, $fields); + + case "comment": + return self::receive_comment($importer, $sender, $fields, $msg["message"]); + + case "contact": + return self::receive_contact_request($importer, $fields); + + case "conversation": + return self::receive_conversation($importer, $msg, $fields); + + case "like": + return self::receive_like($importer, $sender, $fields); + + case "message": + return self::receive_message($importer, $fields); + + case "participation": // Not implemented + return self::receive_participation($importer, $fields); + + case "photo": // Not implemented + return self::receive_photo($importer, $fields); + + case "poll_participation": // Not implemented + return self::receive_poll_participation($importer, $fields); + + case "profile": + return self::receive_profile($importer, $fields); + + case "reshare": + return self::receive_reshare($importer, $fields, $msg["message"]); + + case "retraction": + return self::receive_retraction($importer, $sender, $fields); + + case "status_message": + return self::receive_status_message($importer, $fields, $msg["message"]); + + default: + logger("Unknown message type ".$type); + return false; + } + + return true; + } + + /** + * @brief Checks if a posting is valid and fetches the data fields. + * + * This function does not only check the signature. + * It also does the conversion between the old and the new diaspora format. + * + * @param array $msg Array with the XML, the sender handle and the sender signature + * + * @return bool|array If the posting is valid then an array with an SimpleXML object is returned + */ + private static function valid_posting($msg) { + + $data = parse_xml_string($msg["message"]); + + if (!is_object($data)) { + logger("No valid XML ".$msg["message"], LOGGER_DEBUG); + return false; + } + + $first_child = $data->getName(); + + // Is this the new or the old version? + if ($data->getName() == "XML") { + $oldXML = true; + foreach ($data->post->children() as $child) + $element = $child; + } else { + $oldXML = false; + $element = $data; + } + + $type = $element->getName(); + $orig_type = $type; + + logger("Got message type ".$type.": ".$msg["message"], LOGGER_DATA); + + // All retractions are handled identically from now on. + // In the new version there will only be "retraction". + if (in_array($type, array("signed_retraction", "relayable_retraction"))) + $type = "retraction"; + + if ($type == "request") + $type = "contact"; + + $fields = new SimpleXMLElement("<".$type."/>"); + + $signed_data = ""; + + foreach ($element->children() AS $fieldname => $entry) { + if ($oldXML) { + // Translation for the old XML structure + if ($fieldname == "diaspora_handle") { + $fieldname = "author"; + } + if ($fieldname == "participant_handles") { + $fieldname = "participants"; + } + if (in_array($type, array("like", "participation"))) { + if ($fieldname == "target_type") { + $fieldname = "parent_type"; + } + } + if ($fieldname == "sender_handle") { + $fieldname = "author"; + } + if ($fieldname == "recipient_handle") { + $fieldname = "recipient"; + } + if ($fieldname == "root_diaspora_id") { + $fieldname = "root_author"; + } + if ($type == "status_message") { + if ($fieldname == "raw_message") { + $fieldname = "text"; + } + } + if ($type == "retraction") { + if ($fieldname == "post_guid") { + $fieldname = "target_guid"; + } + if ($fieldname == "type") { + $fieldname = "target_type"; + } + } + } + + if (($fieldname == "author_signature") && ($entry != "")) + $author_signature = base64_decode($entry); + elseif (($fieldname == "parent_author_signature") && ($entry != "")) + $parent_author_signature = base64_decode($entry); + elseif (!in_array($fieldname, array("author_signature", "parent_author_signature", "target_author_signature"))) { + if ($signed_data != "") { + $signed_data .= ";"; + $signed_data_parent .= ";"; + } + + $signed_data .= $entry; + } + if (!in_array($fieldname, array("parent_author_signature", "target_author_signature")) || + ($orig_type == "relayable_retraction")) + xml::copy($entry, $fields, $fieldname); + } + + // This is something that shouldn't happen at all. + if (in_array($type, array("status_message", "reshare", "profile"))) + if ($msg["author"] != $fields->author) { + logger("Message handle is not the same as envelope sender. Quitting this message."); + return false; + } + + // Only some message types have signatures. So we quit here for the other types. + if (!in_array($type, array("comment", "like"))) { + return array("fields" => $fields, "relayed" => false); + } + // No author_signature? This is a must, so we quit. + if (!isset($author_signature)) { + logger("No author signature for type ".$type." - Message: ".$msg["message"], LOGGER_DEBUG); + return false; + } + + if (isset($parent_author_signature)) { + $relayed = true; + + $key = self::key($msg["author"]); + + if (!rsa_verify($signed_data, $parent_author_signature, $key, "sha256")) { + logger("No valid parent author signature for parent author ".$msg["author"]. " in type ".$type." - signed data: ".$signed_data." - Message: ".$msg["message"]." - Signature ".$parent_author_signature, LOGGER_DEBUG); + return false; + } + } else { + $relayed = false; + } + + $key = self::key($fields->author); + + if (!rsa_verify($signed_data, $author_signature, $key, "sha256")) { + logger("No valid author signature for author ".$fields->author. " in type ".$type." - signed data: ".$signed_data." - Message: ".$msg["message"]." - Signature ".$author_signature, LOGGER_DEBUG); + return false; + } else { + return array("fields" => $fields, "relayed" => $relayed); + } + } + + /** + * @brief Fetches the public key for a given handle + * + * @param string $handle The handle + * + * @return string The public key + */ + private static function key($handle) { + $handle = strval($handle); + + logger("Fetching diaspora key for: ".$handle); + + $r = self::person_by_handle($handle); + if ($r) + return $r["pubkey"]; + + return ""; + } + + /** + * @brief Fetches data for a given handle + * + * @param string $handle The handle + * + * @return array the queried data + */ + public static function person_by_handle($handle) { + + $r = q("SELECT * FROM `fcontact` WHERE `network` = '%s' AND `addr` = '%s' LIMIT 1", + dbesc(NETWORK_DIASPORA), + dbesc($handle) + ); + if ($r) { + $person = $r[0]; + logger("In cache ".print_r($r,true), LOGGER_DEBUG); + + // update record occasionally so it doesn't get stale + $d = strtotime($person["updated"]." +00:00"); + if ($d < strtotime("now - 14 days")) + $update = true; + + if ($person["guid"] == "") + $update = true; + } + + if (!$person || $update) { + logger("create or refresh", LOGGER_DEBUG); + $r = Probe::uri($handle, NETWORK_DIASPORA); + + // Note that Friendica contacts will return a "Diaspora person" + // if Diaspora connectivity is enabled on their server + if ($r && ($r["network"] === NETWORK_DIASPORA)) { + self::add_fcontact($r, $update); + $person = $r; + } + } + return $person; + } + + /** + * @brief Updates the fcontact table + * + * @param array $arr The fcontact data + * @param bool $update Update or insert? + * + * @return string The id of the fcontact entry + */ + private static function add_fcontact($arr, $update = false) { + + if ($update) { + $r = q("UPDATE `fcontact` SET + `name` = '%s', + `photo` = '%s', + `request` = '%s', + `nick` = '%s', + `addr` = '%s', + `guid` = '%s', + `batch` = '%s', + `notify` = '%s', + `poll` = '%s', + `confirm` = '%s', + `alias` = '%s', + `pubkey` = '%s', + `updated` = '%s' + WHERE `url` = '%s' AND `network` = '%s'", + dbesc($arr["name"]), + dbesc($arr["photo"]), + dbesc($arr["request"]), + dbesc($arr["nick"]), + dbesc(strtolower($arr["addr"])), + dbesc($arr["guid"]), + dbesc($arr["batch"]), + dbesc($arr["notify"]), + dbesc($arr["poll"]), + dbesc($arr["confirm"]), + dbesc($arr["alias"]), + dbesc($arr["pubkey"]), + dbesc(datetime_convert()), + dbesc($arr["url"]), + dbesc($arr["network"]) + ); + } else { + $r = q("INSERT INTO `fcontact` (`url`,`name`,`photo`,`request`,`nick`,`addr`, `guid`, + `batch`, `notify`,`poll`,`confirm`,`network`,`alias`,`pubkey`,`updated`) + VALUES ('%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s')", + dbesc($arr["url"]), + dbesc($arr["name"]), + dbesc($arr["photo"]), + dbesc($arr["request"]), + dbesc($arr["nick"]), + dbesc($arr["addr"]), + dbesc($arr["guid"]), + dbesc($arr["batch"]), + dbesc($arr["notify"]), + dbesc($arr["poll"]), + dbesc($arr["confirm"]), + dbesc($arr["network"]), + dbesc($arr["alias"]), + dbesc($arr["pubkey"]), + dbesc(datetime_convert()) + ); + } + + return $r; + } + + /** + * @brief get a handle (user@domain.tld) from a given contact id or gcontact id + * + * @param int $contact_id The id in the contact table + * @param int $gcontact_id The id in the gcontact table + * + * @return string the handle + */ + public static function handle_from_contact($contact_id, $gcontact_id = 0) { + $handle = false; + + logger("contact id is ".$contact_id." - gcontact id is ".$gcontact_id, LOGGER_DEBUG); + + if ($gcontact_id != 0) { + $r = q("SELECT `addr` FROM `gcontact` WHERE `id` = %d AND `addr` != ''", + intval($gcontact_id)); + + if (Dbm::is_result($r)) { + return strtolower($r[0]["addr"]); + } + } + + $r = q("SELECT `network`, `addr`, `self`, `url`, `nick` FROM `contact` WHERE `id` = %d", + intval($contact_id)); + + if (Dbm::is_result($r)) { + $contact = $r[0]; + + logger("contact 'self' = ".$contact['self']." 'url' = ".$contact['url'], LOGGER_DEBUG); + + if ($contact['addr'] != "") { + $handle = $contact['addr']; + } else { + $baseurl_start = strpos($contact['url'],'://') + 3; + $baseurl_length = strpos($contact['url'],'/profile') - $baseurl_start; // allows installations in a subdirectory--not sure how Diaspora will handle + $baseurl = substr($contact['url'], $baseurl_start, $baseurl_length); + $handle = $contact['nick'].'@'.$baseurl; + } + } + + return strtolower($handle); + } + + /** + * @brief get a url (scheme://domain.tld/u/user) from a given Diaspora* + * fcontact guid + * + * @param mixed $fcontact_guid Hexadecimal string guid + * + * @return string the contact url or null + */ + public static function url_from_contact_guid($fcontact_guid) { + logger("fcontact guid is ".$fcontact_guid, LOGGER_DEBUG); + + $r = q("SELECT `url` FROM `fcontact` WHERE `url` != '' AND `network` = '%s' AND `guid` = '%s'", + dbesc(NETWORK_DIASPORA), + dbesc($fcontact_guid) + ); + + if (Dbm::is_result($r)) { + return $r[0]['url']; + } + + return null; + } + + /** + * @brief Get a contact id for a given handle + * + * @param int $uid The user id + * @param string $handle The handle in the format user@domain.tld + * + * @return The contact id + */ + private static function contact_by_handle($uid, $handle) { + + // First do a direct search on the contact table + $r = q("SELECT * FROM `contact` WHERE `uid` = %d AND `addr` = '%s' LIMIT 1", + intval($uid), + dbesc($handle) + ); + + if (Dbm::is_result($r)) { + return $r[0]; + } else { + /* + * We haven't found it? + * We use another function for it that will possibly create a contact entry. + */ + $cid = get_contact($handle, $uid); + + if ($cid > 0) { + /// @TODO Contact retrieval should be encapsulated into an "entity" class like `Contact` + $r = q("SELECT * FROM `contact` WHERE `id` = %d LIMIT 1", intval($cid)); + + if (Dbm::is_result($r)) { + return $r[0]; + } + } + } + + $handle_parts = explode("@", $handle); + $nurl_sql = "%%://".$handle_parts[1]."%%/profile/".$handle_parts[0]; + $r = q("SELECT * FROM `contact` WHERE `network` = '%s' AND `uid` = %d AND `nurl` LIKE '%s' LIMIT 1", + dbesc(NETWORK_DFRN), + intval($uid), + dbesc($nurl_sql) + ); + if (Dbm::is_result($r)) { + return $r[0]; + } + + logger("Haven't found contact for user ".$uid." and handle ".$handle, LOGGER_DEBUG); + return false; + } + + /** + * @brief Check if posting is allowed for this contact + * + * @param array $importer Array of the importer user + * @param array $contact The contact that is checked + * @param bool $is_comment Is the check for a comment? + * + * @return bool is the contact allowed to post? + */ + private static function post_allow($importer, $contact, $is_comment = false) { + + /* + * Perhaps we were already sharing with this person. Now they're sharing with us. + * That makes us friends. + * Normally this should have handled by getting a request - but this could get lost + */ + if ($contact["rel"] == CONTACT_IS_FOLLOWER && in_array($importer["page-flags"], array(PAGE_FREELOVE))) { + dba::update('contact', array('rel' => CONTACT_IS_FRIEND, 'writable' => true), + array('id' => $contact["id"], 'uid' => $contact["uid"])); + + $contact["rel"] = CONTACT_IS_FRIEND; + logger("defining user ".$contact["nick"]." as friend"); + } + + // We don't seem to like that person + if ($contact["blocked"] || $contact["readonly"] || $contact["archive"]) { + // Maybe blocked, don't accept. + return false; + // We are following this person? + } elseif (($contact["rel"] == CONTACT_IS_SHARING) || ($contact["rel"] == CONTACT_IS_FRIEND)) { + // Yes, then it is fine. + return true; + // Is it a post to a community? + } elseif (($contact["rel"] == CONTACT_IS_FOLLOWER) && ($importer["page-flags"] == PAGE_COMMUNITY)) { + // That's good + return true; + // Is the message a global user or a comment? + } elseif (($importer["uid"] == 0) || $is_comment) { + // Messages for the global users and comments are always accepted + return true; + } + + return false; + } + + /** + * @brief Fetches the contact id for a handle and checks if posting is allowed + * + * @param array $importer Array of the importer user + * @param string $handle The checked handle in the format user@domain.tld + * @param bool $is_comment Is the check for a comment? + * + * @return array The contact data + */ + private static function allowed_contact_by_handle($importer, $handle, $is_comment = false) { + $contact = self::contact_by_handle($importer["uid"], $handle); + if (!$contact) { + logger("A Contact for handle ".$handle." and user ".$importer["uid"]." was not found"); + // If a contact isn't found, we accept it anyway if it is a comment + if ($is_comment) { + return $importer; + } else { + return false; + } + } + + if (!self::post_allow($importer, $contact, $is_comment)) { + logger("The handle: ".$handle." is not allowed to post to user ".$importer["uid"]); + return false; + } + return $contact; + } + + /** + * @brief Does the message already exists on the system? + * + * @param int $uid The user id + * @param string $guid The guid of the message + * + * @return int|bool message id if the message already was stored into the system - or false. + */ + private static function message_exists($uid, $guid) { + $r = q("SELECT `id` FROM `item` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1", + intval($uid), + dbesc($guid) + ); + + if (Dbm::is_result($r)) { + logger("message ".$guid." already exists for user ".$uid); + return $r[0]["id"]; + } + + return false; + } + + /** + * @brief Checks for links to posts in a message + * + * @param array $item The item array + */ + private static function fetch_guid($item) { + $expression = "=diaspora://.*?/post/([0-9A-Za-z\-_@.:]{15,254}[0-9A-Za-z])=ism"; + preg_replace_callback($expression, + function ($match) use ($item) { + return self::fetch_guid_sub($match, $item); + }, $item["body"]); + + preg_replace_callback("&\[url=/posts/([^\[\]]*)\](.*)\[\/url\]&Usi", + function ($match) use ($item) { + return self::fetch_guid_sub($match, $item); + }, $item["body"]); + } + + /** + * @brief Checks for relative /people/* links in an item body to match local + * contacts or prepends the remote host taken from the author link. + * + * @param string $body The item body to replace links from + * @param string $author_link The author link for missing local contact fallback + * + * @return the replaced string + */ + public static function replace_people_guid($body, $author_link) { + $return = preg_replace_callback("&\[url=/people/([^\[\]]*)\](.*)\[\/url\]&Usi", + function ($match) use ($author_link) { + // $match + // 0 => '[url=/people/0123456789abcdef]Foo Bar[/url]' + // 1 => '0123456789abcdef' + // 2 => 'Foo Bar' + $handle = self::url_from_contact_guid($match[1]); + + if ($handle) { + $return = '@[url='.$handle.']'.$match[2].'[/url]'; + } else { + // No local match, restoring absolute remote URL from author scheme and host + $author_url = parse_url($author_link); + $return = '[url='.$author_url['scheme'].'://'.$author_url['host'].'/people/'.$match[1].']'.$match[2].'[/url]'; + } + + return $return; + }, $body); + + return $return; + } + + /** + * @brief sub function of "fetch_guid" which checks for links in messages + * + * @param array $match array containing a link that has to be checked for a message link + * @param array $item The item array + */ + private static function fetch_guid_sub($match, $item) { + if (!self::store_by_guid($match[1], $item["author-link"])) + self::store_by_guid($match[1], $item["owner-link"]); + } + + /** + * @brief Fetches an item with a given guid from a given server + * + * @param string $guid the message guid + * @param string $server The server address + * @param int $uid The user id of the user + * + * @return int the message id of the stored message or false + */ + private static function store_by_guid($guid, $server, $uid = 0) { + $serverparts = parse_url($server); + $server = $serverparts["scheme"]."://".$serverparts["host"]; + + logger("Trying to fetch item ".$guid." from ".$server, LOGGER_DEBUG); + + $msg = self::message($guid, $server); + + if (!$msg) + return false; + + logger("Successfully fetched item ".$guid." from ".$server, LOGGER_DEBUG); + + // Now call the dispatcher + return self::dispatch_public($msg); + } + + /** + * @brief Fetches a message from a server + * + * @param string $guid message guid + * @param string $server The url of the server + * @param int $level Endless loop prevention + * + * @return array + * 'message' => The message XML + * 'author' => The author handle + * 'key' => The public key of the author + */ + private static function message($guid, $server, $level = 0) { + + if ($level > 5) + return false; + + // This will work for new Diaspora servers and Friendica servers from 3.5 + $source_url = $server."/fetch/post/".urlencode($guid); + + logger("Fetch post from ".$source_url, LOGGER_DEBUG); + + $envelope = fetch_url($source_url); + if ($envelope) { + logger("Envelope was fetched.", LOGGER_DEBUG); + $x = self::verify_magic_envelope($envelope); + if (!$x) + logger("Envelope could not be verified.", LOGGER_DEBUG); + else + logger("Envelope was verified.", LOGGER_DEBUG); + } else + $x = false; + + // This will work for older Diaspora and Friendica servers + if (!$x) { + $source_url = $server."/p/".urlencode($guid).".xml"; + logger("Fetch post from ".$source_url, LOGGER_DEBUG); + + $x = fetch_url($source_url); + if (!$x) + return false; + } + + $source_xml = parse_xml_string($x); + + if (!is_object($source_xml)) + return false; + + if ($source_xml->post->reshare) { + // Reshare of a reshare - old Diaspora version + logger("Message is a reshare", LOGGER_DEBUG); + return self::message($source_xml->post->reshare->root_guid, $server, ++$level); + } elseif ($source_xml->getName() == "reshare") { + // Reshare of a reshare - new Diaspora version + logger("Message is a new reshare", LOGGER_DEBUG); + return self::message($source_xml->root_guid, $server, ++$level); + } + + $author = ""; + + // Fetch the author - for the old and the new Diaspora version + if ($source_xml->post->status_message->diaspora_handle) + $author = (string)$source_xml->post->status_message->diaspora_handle; + elseif ($source_xml->author && ($source_xml->getName() == "status_message")) + $author = (string)$source_xml->author; + + // If this isn't a "status_message" then quit + if (!$author) { + logger("Message doesn't seem to be a status message", LOGGER_DEBUG); + return false; + } + + $msg = array("message" => $x, "author" => $author); + + $msg["key"] = self::key($msg["author"]); + + return $msg; + } + + /** + * @brief Fetches the item record of a given guid + * + * @param int $uid The user id + * @param string $guid message guid + * @param string $author The handle of the item + * @param array $contact The contact of the item owner + * + * @return array the item record + */ + private static function parent_item($uid, $guid, $author, $contact) { + $r = q("SELECT `id`, `parent`, `body`, `wall`, `uri`, `guid`, `private`, `origin`, + `author-name`, `author-link`, `author-avatar`, + `owner-name`, `owner-link`, `owner-avatar` + FROM `item` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1", + intval($uid), dbesc($guid)); + + if (!$r) { + $result = self::store_by_guid($guid, $contact["url"], $uid); + + if (!$result) { + $person = self::person_by_handle($author); + $result = self::store_by_guid($guid, $person["url"], $uid); + } + + if ($result) { + logger("Fetched missing item ".$guid." - result: ".$result, LOGGER_DEBUG); + + $r = q("SELECT `id`, `body`, `wall`, `uri`, `private`, `origin`, + `author-name`, `author-link`, `author-avatar`, + `owner-name`, `owner-link`, `owner-avatar` + FROM `item` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1", + intval($uid), dbesc($guid)); + } + } + + if (!$r) { + logger("parent item not found: parent: ".$guid." - user: ".$uid); + return false; + } else { + logger("parent item found: parent: ".$guid." - user: ".$uid); + return $r[0]; + } + } + + /** + * @brief returns contact details + * + * @param array $contact The default contact if the person isn't found + * @param array $person The record of the person + * @param int $uid The user id + * + * @return array + * 'cid' => contact id + * 'network' => network type + */ + private static function author_contact_by_url($contact, $person, $uid) { + + $r = q("SELECT `id`, `network`, `url` FROM `contact` WHERE `nurl` = '%s' AND `uid` = %d LIMIT 1", + dbesc(normalise_link($person["url"])), intval($uid)); + if ($r) { + $cid = $r[0]["id"]; + $network = $r[0]["network"]; + + // We are receiving content from a user that possibly is about to be terminated + // This means the user is vital, so we remove a possible termination date. + unmark_for_death($r[0]); + } else { + $cid = $contact["id"]; + $network = NETWORK_DIASPORA; + } + + return array("cid" => $cid, "network" => $network); + } + + /** + * @brief Is the profile a hubzilla profile? + * + * @param string $url The profile link + * + * @return bool is it a hubzilla server? + */ + public static function is_redmatrix($url) { + return(strstr($url, "/channel/")); + } + + /** + * @brief Generate a post link with a given handle and message guid + * + * @param string $addr The user handle + * @param string $guid message guid + * + * @return string the post link + */ + private static function plink($addr, $guid, $parent_guid = '') { + $r = q("SELECT `url`, `nick`, `network` FROM `fcontact` WHERE `addr`='%s' LIMIT 1", dbesc($addr)); + + // Fallback + if (!Dbm::is_result($r)) { + if ($parent_guid != '') { + return "https://".substr($addr,strpos($addr,"@") + 1)."/posts/".$parent_guid."#".$guid; + } else { + return "https://".substr($addr,strpos($addr,"@") + 1)."/posts/".$guid; + } + } + + // Friendica contacts are often detected as Diaspora contacts in the "fcontact" table + // So we try another way as well. + $s = q("SELECT `network` FROM `gcontact` WHERE `nurl`='%s' LIMIT 1", dbesc(normalise_link($r[0]["url"]))); + if (Dbm::is_result($s)) { + $r[0]["network"] = $s[0]["network"]; + } + + if ($r[0]["network"] == NETWORK_DFRN) { + return str_replace("/profile/".$r[0]["nick"]."/", "/display/".$guid, $r[0]["url"]."/"); + } + + if (self::is_redmatrix($r[0]["url"])) { + return $r[0]["url"]."/?f=&mid=".$guid; + } + + if ($parent_guid != '') { + return "https://".substr($addr,strpos($addr,"@")+1)."/posts/".$parent_guid."#".$guid; + } else { + return "https://".substr($addr,strpos($addr,"@")+1)."/posts/".$guid; + } + } + + /** + * @brief Receives account migration + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool Success + */ + private static function receiveAccountMigration($importer, $data) { + $old_handle = notags(unxmlify($data->author)); + $new_handle = notags(unxmlify($data->profile->author)); + $signature = notags(unxmlify($data->signature)); + + $contact = self::contact_by_handle($importer["uid"], $old_handle); + if (!$contact) { + logger("cannot find contact for sender: ".$old_handle." and user ".$importer["uid"]); + return false; + } + + logger("Got migration for ".$old_handle.", to ".$new_handle." with user ".$importer["uid"]); + + // Check signature + $signed_text = 'AccountMigration:'.$old_handle.':'.$new_handle; + $key = self::key($old_handle); + if (!rsa_verify($signed_text, $signature, $key, "sha256")) { + logger('No valid signature for migration.'); + return false; + } + + // Update the profile + self::receive_profile($importer, $data->profile); + + // change the technical stuff in contact and gcontact + $data = Probe::uri($new_handle); + if ($data['network'] == NETWORK_PHANTOM) { + logger('Account for '.$new_handle." couldn't be probed."); + return false; + } + + $fields = array('url' => $data['url'], 'nurl' => normalise_link($data['url']), + 'name' => $data['name'], 'nick' => $data['nick'], + 'addr' => $data['addr'], 'batch' => $data['batch'], + 'notify' => $data['notify'], 'poll' => $data['poll'], + 'network' => $data['network']); + + dba::update('contact', $fields, array('addr' => $old_handle)); + + $fields = array('url' => $data['url'], 'nurl' => normalise_link($data['url']), + 'name' => $data['name'], 'nick' => $data['nick'], + 'addr' => $data['addr'], 'connect' => $data['addr'], + 'notify' => $data['notify'], 'photo' => $data['photo'], + 'server_url' => $data['baseurl'], 'network' => $data['network']); + + dba::update('gcontact', $fields, array('addr' => $old_handle)); + + logger('Contacts are updated.'); + + // update items + /// @todo This is an extreme performance killer + $fields = array( + 'owner-link' => array($contact["url"], $data["url"]), + 'author-link' => array($contact["url"], $data["url"]), + ); + foreach ($fields as $n=>$f) { + $r = q("SELECT `id` FROM `item` WHERE `%s` = '%s' AND `uid` = %d LIMIT 1", + $n, dbesc($f[0]), + intval($importer["uid"])); + + if (Dbm::is_result($r)) { + $x = q("UPDATE `item` SET `%s` = '%s' WHERE `%s` = '%s' AND `uid` = %d", + $n, dbesc($f[1]), + $n, dbesc($f[0]), + intval($importer["uid"])); + + if ($x === false) { + return false; + } + } + } + + logger('Items are updated.'); + + return true; + } + + /** + * @brief Processes an account deletion + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool Success + */ + private static function receive_account_deletion($importer, $data) { + + /// @todo Account deletion should remove the contact from the global contacts as well + + $author = notags(unxmlify($data->author)); + + $contact = self::contact_by_handle($importer["uid"], $author); + if (!$contact) { + logger("cannot find contact for author: ".$author); + return false; + } + + // We now remove the contact + contact_remove($contact["id"]); + return true; + } + + /** + * @brief Fetch the uri from our database if we already have this item (maybe from ourselves) + * + * @param string $author Author handle + * @param string $guid Message guid + * @param boolean $onlyfound Only return uri when found in the database + * + * @return string The constructed uri or the one from our database + */ + private static function get_uri_from_guid($author, $guid, $onlyfound = false) { + + $r = q("SELECT `uri` FROM `item` WHERE `guid` = '%s' LIMIT 1", dbesc($guid)); + if (Dbm::is_result($r)) { + return $r[0]["uri"]; + } elseif (!$onlyfound) { + return $author.":".$guid; + } + + return ""; + } + + /** + * @brief Fetch the guid from our database with a given uri + * + * @param string $author Author handle + * @param string $uri Message uri + * + * @return string The post guid + */ + private static function get_guid_from_uri($uri, $uid) { + + $r = q("SELECT `guid` FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1", dbesc($uri), intval($uid)); + if (Dbm::is_result($r)) { + return $r[0]["guid"]; + } else { + return false; + } + } + + /** + * @brief Find the best importer for a comment, like, ... + * + * @param string $guid The guid of the item + * + * @return array|boolean the origin owner of that post - or false + */ + private static function importer_for_guid($guid) { + $item = dba::fetch_first("SELECT `uid` FROM `item` WHERE `origin` AND `guid` = ? LIMIT 1", $guid); + + if (Dbm::is_result($item)) { + logger("Found user ".$item['uid']." as owner of item ".$guid, LOGGER_DEBUG); + $contact = dba::fetch_first("SELECT * FROM `contact` WHERE `self` AND `uid` = ?", $item['uid']); + if (Dbm::is_result($contact)) { + return $contact; + } + } + return false; + } + + /** + * @brief Processes an incoming comment + * + * @param array $importer Array of the importer user + * @param string $sender The sender of the message + * @param object $data The message object + * @param string $xml The original XML of the message + * + * @return int The message id of the generated comment or "false" if there was an error + */ + private static function receive_comment($importer, $sender, $data, $xml) { + $author = notags(unxmlify($data->author)); + $guid = notags(unxmlify($data->guid)); + $parent_guid = notags(unxmlify($data->parent_guid)); + $text = unxmlify($data->text); + + if (isset($data->created_at)) { + $created_at = datetime_convert("UTC", "UTC", notags(unxmlify($data->created_at))); + } else { + $created_at = datetime_convert(); + } + + if (isset($data->thread_parent_guid)) { + $thread_parent_guid = notags(unxmlify($data->thread_parent_guid)); + $thr_uri = self::get_uri_from_guid("", $thread_parent_guid, true); + } else { + $thr_uri = ""; + } + + $contact = self::allowed_contact_by_handle($importer, $sender, true); + if (!$contact) { + return false; + } + + $message_id = self::message_exists($importer["uid"], $guid); + if ($message_id) { + return true; + } + + $parent_item = self::parent_item($importer["uid"], $parent_guid, $author, $contact); + if (!$parent_item) { + return false; + } + + $person = self::person_by_handle($author); + if (!is_array($person)) { + logger("unable to find author details"); + return false; + } + + // Fetch the contact id - if we know this contact + $author_contact = self::author_contact_by_url($contact, $person, $importer["uid"]); + + $datarray = array(); + + $datarray["uid"] = $importer["uid"]; + $datarray["contact-id"] = $author_contact["cid"]; + $datarray["network"] = $author_contact["network"]; + + $datarray["author-name"] = $person["name"]; + $datarray["author-link"] = $person["url"]; + $datarray["author-avatar"] = ((x($person,"thumb")) ? $person["thumb"] : $person["photo"]); + + $datarray["owner-name"] = $contact["name"]; + $datarray["owner-link"] = $contact["url"]; + $datarray["owner-avatar"] = ((x($contact,"thumb")) ? $contact["thumb"] : $contact["photo"]); + + $datarray["guid"] = $guid; + $datarray["uri"] = self::get_uri_from_guid($author, $guid); + + $datarray["type"] = "remote-comment"; + $datarray["verb"] = ACTIVITY_POST; + $datarray["gravity"] = GRAVITY_COMMENT; + + if ($thr_uri != "") { + $datarray["parent-uri"] = $thr_uri; + } else { + $datarray["parent-uri"] = $parent_item["uri"]; + } + + $datarray["object-type"] = ACTIVITY_OBJ_COMMENT; + + $datarray["protocol"] = PROTOCOL_DIASPORA; + $datarray["source"] = $xml; + + $datarray["changed"] = $datarray["created"] = $datarray["edited"] = $created_at; + + $datarray["plink"] = self::plink($author, $guid, $parent_item['guid']); + + $body = diaspora2bb($text); + + $datarray["body"] = self::replace_people_guid($body, $person["url"]); + + self::fetch_guid($datarray); + + $message_id = item_store($datarray); + + if ($message_id <= 0) { + return false; + } + + if ($message_id) { + logger("Stored comment ".$datarray["guid"]." with message id ".$message_id, LOGGER_DEBUG); + } + + // If we are the origin of the parent we store the original data and notify our followers + if ($message_id && $parent_item["origin"]) { + + // Formerly we stored the signed text, the signature and the author in different fields. + // We now store the raw data so that we are more flexible. + dba::insert('sign', array('iid' => $message_id, 'signed_text' => json_encode($data))); + + // notify others + Worker::add(PRIORITY_HIGH, "notifier", "comment-import", $message_id); + } + + return true; + } + + /** + * @brief processes and stores private messages + * + * @param array $importer Array of the importer user + * @param array $contact The contact of the message + * @param object $data The message object + * @param array $msg Array of the processed message, author handle and key + * @param object $mesg The private message + * @param array $conversation The conversation record to which this message belongs + * + * @return bool "true" if it was successful + */ + private static function receive_conversation_message($importer, $contact, $data, $msg, $mesg, $conversation) { + $author = notags(unxmlify($data->author)); + $guid = notags(unxmlify($data->guid)); + $subject = notags(unxmlify($data->subject)); + + // "diaspora_handle" is the element name from the old version + // "author" is the element name from the new version + if ($mesg->author) { + $msg_author = notags(unxmlify($mesg->author)); + } elseif ($mesg->diaspora_handle) { + $msg_author = notags(unxmlify($mesg->diaspora_handle)); + } else { + return false; + } + + $msg_guid = notags(unxmlify($mesg->guid)); + $msg_conversation_guid = notags(unxmlify($mesg->conversation_guid)); + $msg_text = unxmlify($mesg->text); + $msg_created_at = datetime_convert("UTC", "UTC", notags(unxmlify($mesg->created_at))); + + if ($msg_conversation_guid != $guid) { + logger("message conversation guid does not belong to the current conversation."); + return false; + } + + $body = diaspora2bb($msg_text); + $message_uri = $msg_author.":".$msg_guid; + + $person = self::person_by_handle($msg_author); + + dba::lock('mail'); + + $r = q("SELECT `id` FROM `mail` WHERE `guid` = '%s' AND `uid` = %d LIMIT 1", + dbesc($msg_guid), + intval($importer["uid"]) + ); + if (Dbm::is_result($r)) { + logger("duplicate message already delivered.", LOGGER_DEBUG); + return false; + } + + q("INSERT INTO `mail` (`uid`, `guid`, `convid`, `from-name`,`from-photo`,`from-url`,`contact-id`,`title`,`body`,`seen`,`reply`,`uri`,`parent-uri`,`created`) + VALUES (%d, '%s', %d, '%s', '%s', '%s', %d, '%s', '%s', %d, %d, '%s','%s','%s')", + intval($importer["uid"]), + dbesc($msg_guid), + intval($conversation["id"]), + dbesc($person["name"]), + dbesc($person["photo"]), + dbesc($person["url"]), + intval($contact["id"]), + dbesc($subject), + dbesc($body), + 0, + 0, + dbesc($message_uri), + dbesc($author.":".$guid), + dbesc($msg_created_at) + ); + + dba::unlock(); + + dba::update('conv', array('updated' => datetime_convert()), array('id' => $conversation["id"])); + + notification(array( + "type" => NOTIFY_MAIL, + "notify_flags" => $importer["notify-flags"], + "language" => $importer["language"], + "to_name" => $importer["username"], + "to_email" => $importer["email"], + "uid" =>$importer["uid"], + "item" => array("subject" => $subject, "body" => $body), + "source_name" => $person["name"], + "source_link" => $person["url"], + "source_photo" => $person["thumb"], + "verb" => ACTIVITY_POST, + "otype" => "mail" + )); + return true; + } + + /** + * @brief Processes new private messages (answers to private messages are processed elsewhere) + * + * @param array $importer Array of the importer user + * @param array $msg Array of the processed message, author handle and key + * @param object $data The message object + * + * @return bool Success + */ + private static function receive_conversation($importer, $msg, $data) { + $author = notags(unxmlify($data->author)); + $guid = notags(unxmlify($data->guid)); + $subject = notags(unxmlify($data->subject)); + $created_at = datetime_convert("UTC", "UTC", notags(unxmlify($data->created_at))); + $participants = notags(unxmlify($data->participants)); + + $messages = $data->message; + + if (!count($messages)) { + logger("empty conversation"); + return false; + } + + $contact = self::allowed_contact_by_handle($importer, $msg["author"], true); + if (!$contact) + return false; + + $conversation = null; + + $c = q("SELECT * FROM `conv` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1", + intval($importer["uid"]), + dbesc($guid) + ); + if ($c) + $conversation = $c[0]; + else { + $r = q("INSERT INTO `conv` (`uid`, `guid`, `creator`, `created`, `updated`, `subject`, `recips`) + VALUES (%d, '%s', '%s', '%s', '%s', '%s', '%s')", + intval($importer["uid"]), + dbesc($guid), + dbesc($author), + dbesc($created_at), + dbesc(datetime_convert()), + dbesc($subject), + dbesc($participants) + ); + if ($r) + $c = q("SELECT * FROM `conv` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1", + intval($importer["uid"]), + dbesc($guid) + ); + + if ($c) + $conversation = $c[0]; + } + if (!$conversation) { + logger("unable to create conversation."); + return false; + } + + foreach ($messages as $mesg) + self::receive_conversation_message($importer, $contact, $data, $msg, $mesg, $conversation); + + return true; + } + + /** + * @brief Creates the body for a "like" message + * + * @param array $contact The contact that send us the "like" + * @param array $parent_item The item array of the parent item + * @param string $guid message guid + * + * @return string the body + */ + private static function construct_like_body($contact, $parent_item, $guid) { + $bodyverb = t('%1$s likes %2$s\'s %3$s'); + + $ulink = "[url=".$contact["url"]."]".$contact["name"]."[/url]"; + $alink = "[url=".$parent_item["author-link"]."]".$parent_item["author-name"]."[/url]"; + $plink = "[url=".System::baseUrl()."/display/".urlencode($guid)."]".t("status")."[/url]"; + + return sprintf($bodyverb, $ulink, $alink, $plink); + } + + /** + * @brief Creates a XML object for a "like" + * + * @param array $importer Array of the importer user + * @param array $parent_item The item array of the parent item + * + * @return string The XML + */ + private static function construct_like_object($importer, $parent_item) { + $objtype = ACTIVITY_OBJ_NOTE; + $link = ''; + $parent_body = $parent_item["body"]; + + $xmldata = array("object" => array("type" => $objtype, + "local" => "1", + "id" => $parent_item["uri"], + "link" => $link, + "title" => "", + "content" => $parent_body)); + + return xml::from_array($xmldata, $xml, true); + } + + /** + * @brief Processes "like" messages + * + * @param array $importer Array of the importer user + * @param string $sender The sender of the message + * @param object $data The message object + * + * @return int The message id of the generated like or "false" if there was an error + */ + private static function receive_like($importer, $sender, $data) { + $author = notags(unxmlify($data->author)); + $guid = notags(unxmlify($data->guid)); + $parent_guid = notags(unxmlify($data->parent_guid)); + $parent_type = notags(unxmlify($data->parent_type)); + $positive = notags(unxmlify($data->positive)); + + // likes on comments aren't supported by Diaspora - only on posts + // But maybe this will be supported in the future, so we will accept it. + if (!in_array($parent_type, array("Post", "Comment"))) + return false; + + $contact = self::allowed_contact_by_handle($importer, $sender, true); + if (!$contact) + return false; + + $message_id = self::message_exists($importer["uid"], $guid); + if ($message_id) + return true; + + $parent_item = self::parent_item($importer["uid"], $parent_guid, $author, $contact); + if (!$parent_item) + return false; + + $person = self::person_by_handle($author); + if (!is_array($person)) { + logger("unable to find author details"); + return false; + } + + // Fetch the contact id - if we know this contact + $author_contact = self::author_contact_by_url($contact, $person, $importer["uid"]); + + // "positive" = "false" would be a Dislike - wich isn't currently supported by Diaspora + // We would accept this anyhow. + if ($positive == "true") + $verb = ACTIVITY_LIKE; + else + $verb = ACTIVITY_DISLIKE; + + $datarray = array(); + + $datarray["protocol"] = PROTOCOL_DIASPORA; + + $datarray["uid"] = $importer["uid"]; + $datarray["contact-id"] = $author_contact["cid"]; + $datarray["network"] = $author_contact["network"]; + + $datarray["author-name"] = $person["name"]; + $datarray["author-link"] = $person["url"]; + $datarray["author-avatar"] = ((x($person,"thumb")) ? $person["thumb"] : $person["photo"]); + + $datarray["owner-name"] = $contact["name"]; + $datarray["owner-link"] = $contact["url"]; + $datarray["owner-avatar"] = ((x($contact,"thumb")) ? $contact["thumb"] : $contact["photo"]); + + $datarray["guid"] = $guid; + $datarray["uri"] = self::get_uri_from_guid($author, $guid); + + $datarray["type"] = "activity"; + $datarray["verb"] = $verb; + $datarray["gravity"] = GRAVITY_LIKE; + $datarray["parent-uri"] = $parent_item["uri"]; + + $datarray["object-type"] = ACTIVITY_OBJ_NOTE; + $datarray["object"] = self::construct_like_object($importer, $parent_item); + + $datarray["body"] = self::construct_like_body($contact, $parent_item, $guid); + + $message_id = item_store($datarray); + + if ($message_id <= 0) { + return false; + } + + if ($message_id) { + logger("Stored like ".$datarray["guid"]." with message id ".$message_id, LOGGER_DEBUG); + } + + // like on comments have the comment as parent. So we need to fetch the toplevel parent + if ($parent_item["id"] != $parent_item["parent"]) { + $toplevel = dba::select('item', array('origin'), array('id' => $parent_item["parent"]), array('limit' => 1)); + $origin = $toplevel["origin"]; + } else { + $origin = $parent_item["origin"]; + } + + // If we are the origin of the parent we store the original data and notify our followers + if ($message_id && $origin) { + + // Formerly we stored the signed text, the signature and the author in different fields. + // We now store the raw data so that we are more flexible. + dba::insert('sign', array('iid' => $message_id, 'signed_text' => json_encode($data))); + + // notify others + Worker::add(PRIORITY_HIGH, "notifier", "comment-import", $message_id); + } + + return true; + } + + /** + * @brief Processes private messages + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool Success? + */ + private static function receive_message($importer, $data) { + $author = notags(unxmlify($data->author)); + $guid = notags(unxmlify($data->guid)); + $conversation_guid = notags(unxmlify($data->conversation_guid)); + $text = unxmlify($data->text); + $created_at = datetime_convert("UTC", "UTC", notags(unxmlify($data->created_at))); + + $contact = self::allowed_contact_by_handle($importer, $author, true); + if (!$contact) { + return false; + } + + $conversation = null; + + $c = q("SELECT * FROM `conv` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1", + intval($importer["uid"]), + dbesc($conversation_guid) + ); + if ($c) { + $conversation = $c[0]; + } else { + logger("conversation not available."); + return false; + } + + $message_uri = $author.":".$guid; + + $person = self::person_by_handle($author); + if (!$person) { + logger("unable to find author details"); + return false; + } + + $body = diaspora2bb($text); + + $body = self::replace_people_guid($body, $person["url"]); + + dba::lock('mail'); + + $r = q("SELECT `id` FROM `mail` WHERE `guid` = '%s' AND `uid` = %d LIMIT 1", + dbesc($guid), + intval($importer["uid"]) + ); + if (Dbm::is_result($r)) { + logger("duplicate message already delivered.", LOGGER_DEBUG); + return false; + } + + q("INSERT INTO `mail` (`uid`, `guid`, `convid`, `from-name`,`from-photo`,`from-url`,`contact-id`,`title`,`body`,`seen`,`reply`,`uri`,`parent-uri`,`created`) + VALUES ( %d, '%s', %d, '%s', '%s', '%s', %d, '%s', '%s', %d, %d, '%s','%s','%s')", + intval($importer["uid"]), + dbesc($guid), + intval($conversation["id"]), + dbesc($person["name"]), + dbesc($person["photo"]), + dbesc($person["url"]), + intval($contact["id"]), + dbesc($conversation["subject"]), + dbesc($body), + 0, + 1, + dbesc($message_uri), + dbesc($author.":".$conversation["guid"]), + dbesc($created_at) + ); + + dba::unlock(); + + dba::update('conv', array('updated' => datetime_convert()), array('id' => $conversation["id"])); + return true; + } + + /** + * @brief Processes participations - unsupported by now + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool always true + */ + private static function receive_participation($importer, $data) { + // I'm not sure if we can fully support this message type + return true; + } + + /** + * @brief Processes photos - unneeded + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool always true + */ + private static function receive_photo($importer, $data) { + // There doesn't seem to be a reason for this function, since the photo data is transmitted in the status message as well + return true; + } + + /** + * @brief Processes poll participations - unssupported + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool always true + */ + private static function receive_poll_participation($importer, $data) { + // We don't support polls by now + return true; + } + + /** + * @brief Processes incoming profile updates + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool Success + */ + private static function receive_profile($importer, $data) { + $author = strtolower(notags(unxmlify($data->author))); + + $contact = self::contact_by_handle($importer["uid"], $author); + if (!$contact) + return false; + + $name = unxmlify($data->first_name).((strlen($data->last_name)) ? " ".unxmlify($data->last_name) : ""); + $image_url = unxmlify($data->image_url); + $birthday = unxmlify($data->birthday); + $gender = unxmlify($data->gender); + $about = diaspora2bb(unxmlify($data->bio)); + $location = diaspora2bb(unxmlify($data->location)); + $searchable = (unxmlify($data->searchable) == "true"); + $nsfw = (unxmlify($data->nsfw) == "true"); + $tags = unxmlify($data->tag_string); + + $tags = explode("#", $tags); + + $keywords = array(); + foreach ($tags as $tag) { + $tag = trim(strtolower($tag)); + if ($tag != "") + $keywords[] = $tag; + } + + $keywords = implode(", ", $keywords); + + $handle_parts = explode("@", $author); + $nick = $handle_parts[0]; + + if ($name === "") + $name = $handle_parts[0]; + + if ( preg_match("|^https?://|", $image_url) === 0) + $image_url = "http://".$handle_parts[1].$image_url; + + update_contact_avatar($image_url, $importer["uid"], $contact["id"]); + + // Generic birthday. We don't know the timezone. The year is irrelevant. + + $birthday = str_replace("1000", "1901", $birthday); + + if ($birthday != "") + $birthday = datetime_convert("UTC", "UTC", $birthday, "Y-m-d"); + + // this is to prevent multiple birthday notifications in a single year + // if we already have a stored birthday and the 'm-d' part hasn't changed, preserve the entry, which will preserve the notify year + + if (substr($birthday,5) === substr($contact["bd"],5)) + $birthday = $contact["bd"]; + + $r = q("UPDATE `contact` SET `name` = '%s', `nick` = '%s', `addr` = '%s', `name-date` = '%s', `bd` = '%s', + `location` = '%s', `about` = '%s', `keywords` = '%s', `gender` = '%s' WHERE `id` = %d AND `uid` = %d", + dbesc($name), + dbesc($nick), + dbesc($author), + dbesc(datetime_convert()), + dbesc($birthday), + dbesc($location), + dbesc($about), + dbesc($keywords), + dbesc($gender), + intval($contact["id"]), + intval($importer["uid"]) + ); + + $gcontact = array("url" => $contact["url"], "network" => NETWORK_DIASPORA, "generation" => 2, + "photo" => $image_url, "name" => $name, "location" => $location, + "about" => $about, "birthday" => $birthday, "gender" => $gender, + "addr" => $author, "nick" => $nick, "keywords" => $keywords, + "hide" => !$searchable, "nsfw" => $nsfw); + + $gcid = update_gcontact($gcontact); + + link_gcontact($gcid, $importer["uid"], $contact["id"]); + + logger("Profile of contact ".$contact["id"]." stored for user ".$importer["uid"], LOGGER_DEBUG); + + return true; + } + + /** + * @brief Processes incoming friend requests + * + * @param array $importer Array of the importer user + * @param array $contact The contact that send the request + */ + private static function receive_request_make_friend($importer, $contact) { + + $a = get_app(); + + if ($contact["rel"] == CONTACT_IS_SHARING) { + dba::update('contact', array('rel' => CONTACT_IS_FRIEND, 'writable' => true), + array('id' => $contact["id"], 'uid' => $importer["uid"])); + } + // send notification + + $r = q("SELECT `hide-friends` FROM `profile` WHERE `uid` = %d AND `is-default` = 1 LIMIT 1", + intval($importer["uid"]) + ); + + if ($r && !$r[0]["hide-friends"] && !$contact["hidden"] && intval(PConfig::get($importer["uid"], "system", "post_newfriend"))) { + + $self = q("SELECT * FROM `contact` WHERE `self` AND `uid` = %d LIMIT 1", + intval($importer["uid"]) + ); + + // they are not CONTACT_IS_FOLLOWER anymore but that's what we have in the array + + if ($self && $contact["rel"] == CONTACT_IS_FOLLOWER) { + + $arr = array(); + $arr["protocol"] = PROTOCOL_DIASPORA; + $arr["uri"] = $arr["parent-uri"] = item_new_uri($a->get_hostname(), $importer["uid"]); + $arr["uid"] = $importer["uid"]; + $arr["contact-id"] = $self[0]["id"]; + $arr["wall"] = 1; + $arr["type"] = 'wall'; + $arr["gravity"] = 0; + $arr["origin"] = 1; + $arr["author-name"] = $arr["owner-name"] = $self[0]["name"]; + $arr["author-link"] = $arr["owner-link"] = $self[0]["url"]; + $arr["author-avatar"] = $arr["owner-avatar"] = $self[0]["thumb"]; + $arr["verb"] = ACTIVITY_FRIEND; + $arr["object-type"] = ACTIVITY_OBJ_PERSON; + + $A = "[url=".$self[0]["url"]."]".$self[0]["name"]."[/url]"; + $B = "[url=".$contact["url"]."]".$contact["name"]."[/url]"; + $BPhoto = "[url=".$contact["url"]."][img]".$contact["thumb"]."[/img][/url]"; + $arr["body"] = sprintf(t("%1$s is now friends with %2$s"), $A, $B)."\n\n\n".$Bphoto; + + $arr["object"] = self::construct_new_friend_object($contact); + + $arr["last-child"] = 1; + + $arr["allow_cid"] = $user[0]["allow_cid"]; + $arr["allow_gid"] = $user[0]["allow_gid"]; + $arr["deny_cid"] = $user[0]["deny_cid"]; + $arr["deny_gid"] = $user[0]["deny_gid"]; + + $i = item_store($arr); + if ($i) + Worker::add(PRIORITY_HIGH, "notifier", "activity", $i); + } + } + } + + /** + * @brief Creates a XML object for a "new friend" message + * + * @param array $contact Array of the contact + * + * @return string The XML + */ + private static function construct_new_friend_object($contact) { + $objtype = ACTIVITY_OBJ_PERSON; + $link = ''."\n". + ''."\n"; + + $xmldata = array("object" => array("type" => $objtype, + "title" => $contact["name"], + "id" => $contact["url"]."/".$contact["name"], + "link" => $link)); + + return xml::from_array($xmldata, $xml, true); + } + + /** + * @brief Processes incoming sharing notification + * + * @param array $importer Array of the importer user + * @param object $data The message object + * + * @return bool Success + */ + private static function receive_contact_request($importer, $data) { + $author = unxmlify($data->author); + $recipient = unxmlify($data->recipient); + + if (!$author || !$recipient) { + return false; + } + + // the current protocol version doesn't know these fields + // That means that we will assume their existance + if (isset($data->following)) { + $following = (unxmlify($data->following) == "true"); + } else { + $following = true; + } + + if (isset($data->sharing)) { + $sharing = (unxmlify($data->sharing) == "true"); + } else { + $sharing = true; + } + + $contact = self::contact_by_handle($importer["uid"],$author); + + // perhaps we were already sharing with this person. Now they're sharing with us. + // That makes us friends. + if ($contact) { + if ($following) { + logger("Author ".$author." (Contact ".$contact["id"].") wants to follow us.", LOGGER_DEBUG); + self::receive_request_make_friend($importer, $contact); + + // refetch the contact array + $contact = self::contact_by_handle($importer["uid"],$author); + + // If we are now friends, we are sending a share message. + // Normally we needn't to do so, but the first message could have been vanished. + if (in_array($contact["rel"], array(CONTACT_IS_FRIEND))) { + $u = q("SELECT * FROM `user` WHERE `uid` = %d LIMIT 1", intval($importer["uid"])); + if ($u) { + logger("Sending share message to author ".$author." - Contact: ".$contact["id"]." - User: ".$importer["uid"], LOGGER_DEBUG); + $ret = self::send_share($u[0], $contact); + } + } + return true; + } else { + logger("Author ".$author." doesn't want to follow us anymore.", LOGGER_DEBUG); + lose_follower($importer, $contact); + return true; + } + } + + if (!$following && $sharing && in_array($importer["page-flags"], array(PAGE_SOAPBOX, PAGE_NORMAL))) { + logger("Author ".$author." wants to share with us - but doesn't want to listen. Request is ignored.", LOGGER_DEBUG); + return false; + } elseif (!$following && !$sharing) { + logger("Author ".$author." doesn't want anything - and we don't know the author. Request is ignored.", LOGGER_DEBUG); + return false; + } elseif (!$following && $sharing) { + logger("Author ".$author." wants to share with us.", LOGGER_DEBUG); + } elseif ($following && $sharing) { + logger("Author ".$author." wants to have a bidirectional conection.", LOGGER_DEBUG); + } elseif ($following && !$sharing) { + logger("Author ".$author." wants to listen to us.", LOGGER_DEBUG); + } + + $ret = self::person_by_handle($author); + + if (!$ret || ($ret["network"] != NETWORK_DIASPORA)) { + logger("Cannot resolve diaspora handle ".$author." for ".$recipient); + return false; + } + + $batch = (($ret["batch"]) ? $ret["batch"] : implode("/", array_slice(explode("/", $ret["url"]), 0, 3))."/receive/public"); + + $r = q("INSERT INTO `contact` (`uid`, `network`,`addr`,`created`,`url`,`nurl`,`batch`,`name`,`nick`,`photo`,`pubkey`,`notify`,`poll`,`blocked`,`priority`) + VALUES (%d, '%s', '%s', '%s', '%s','%s','%s','%s','%s','%s','%s','%s','%s',%d,%d)", + intval($importer["uid"]), + dbesc($ret["network"]), + dbesc($ret["addr"]), + datetime_convert(), + dbesc($ret["url"]), + dbesc(normalise_link($ret["url"])), + dbesc($batch), + dbesc($ret["name"]), + dbesc($ret["nick"]), + dbesc($ret["photo"]), + dbesc($ret["pubkey"]), + dbesc($ret["notify"]), + dbesc($ret["poll"]), + 1, + 2 + ); + + // find the contact record we just created + + $contact_record = self::contact_by_handle($importer["uid"],$author); + + if (!$contact_record) { + logger("unable to locate newly created contact record."); + return; + } + + logger("Author ".$author." was added as contact number ".$contact_record["id"].".", LOGGER_DEBUG); + + $def_gid = get_default_group($importer['uid'], $ret["network"]); + + if (intval($def_gid)) + group_add_member($importer["uid"], "", $contact_record["id"], $def_gid); + + update_contact_avatar($ret["photo"], $importer['uid'], $contact_record["id"], true); + + if ($importer["page-flags"] == PAGE_NORMAL) { + + logger("Sending intra message for author ".$author.".", LOGGER_DEBUG); + + $hash = random_string().(string)time(); // Generate a confirm_key + + $ret = q("INSERT INTO `intro` (`uid`, `contact-id`, `blocked`, `knowyou`, `note`, `hash`, `datetime`) + VALUES (%d, %d, %d, %d, '%s', '%s', '%s')", + intval($importer["uid"]), + intval($contact_record["id"]), + 0, + 0, + dbesc(t("Sharing notification from Diaspora network")), + dbesc($hash), + dbesc(datetime_convert()) + ); + } else { + + // automatic friend approval + + logger("Does an automatic friend approval for author ".$author.".", LOGGER_DEBUG); + + update_contact_avatar($contact_record["photo"],$importer["uid"],$contact_record["id"]); + + // technically they are sharing with us (CONTACT_IS_SHARING), + // but if our page-type is PAGE_COMMUNITY or PAGE_SOAPBOX + // we are going to change the relationship and make them a follower. + + if (($importer["page-flags"] == PAGE_FREELOVE) && $sharing && $following) + $new_relation = CONTACT_IS_FRIEND; + elseif (($importer["page-flags"] == PAGE_FREELOVE) && $sharing) + $new_relation = CONTACT_IS_SHARING; + else + $new_relation = CONTACT_IS_FOLLOWER; + + $r = q("UPDATE `contact` SET `rel` = %d, + `name-date` = '%s', + `uri-date` = '%s', + `blocked` = 0, + `pending` = 0, + `writable` = 1 + WHERE `id` = %d + ", + intval($new_relation), + dbesc(datetime_convert()), + dbesc(datetime_convert()), + intval($contact_record["id"]) + ); + + $u = q("SELECT * FROM `user` WHERE `uid` = %d LIMIT 1", intval($importer["uid"])); + if ($u) { + logger("Sending share message (Relation: ".$new_relation.") to author ".$author." - Contact: ".$contact_record["id"]." - User: ".$importer["uid"], LOGGER_DEBUG); + $ret = self::send_share($u[0], $contact_record); + + // Send the profile data, maybe it weren't transmitted before + self::send_profile($importer["uid"], array($contact_record)); + } + } + + return true; + } + + /** + * @brief Fetches a message with a given guid + * + * @param string $guid message guid + * @param string $orig_author handle of the original post + * @param string $author handle of the sharer + * + * @return array The fetched item + */ + private static function original_item($guid, $orig_author, $author) { + + // Do we already have this item? + $r = q("SELECT `body`, `tag`, `app`, `created`, `object-type`, `uri`, `guid`, + `author-name`, `author-link`, `author-avatar` + FROM `item` WHERE `guid` = '%s' AND `visible` AND NOT `deleted` AND `body` != '' LIMIT 1", + dbesc($guid)); + + if (Dbm::is_result($r)) { + logger("reshared message ".$guid." already exists on system."); + + // Maybe it is already a reshared item? + // Then refetch the content, if it is a reshare from a reshare. + // If it is a reshared post from another network then reformat to avoid display problems with two share elements + if (self::is_reshare($r[0]["body"], true)) { + $r = array(); + } elseif (self::is_reshare($r[0]["body"], false) || strstr($r[0]["body"], "[share")) { + $r[0]["body"] = diaspora2bb(bb2diaspora($r[0]["body"])); + + $r[0]["body"] = self::replace_people_guid($r[0]["body"], $r[0]["author-link"]); + + // Add OEmbed and other information to the body + $r[0]["body"] = add_page_info_to_body($r[0]["body"], false, true); + + return $r[0]; + } else { + return $r[0]; + } + } + + if (!Dbm::is_result($r)) { + $server = "https://".substr($orig_author, strpos($orig_author, "@") + 1); + logger("1st try: reshared message ".$guid." will be fetched via SSL from the server ".$server); + $item_id = self::store_by_guid($guid, $server); + + if (!$item_id) { + $server = "http://".substr($orig_author, strpos($orig_author, "@") + 1); + logger("2nd try: reshared message ".$guid." will be fetched without SLL from the server ".$server); + $item_id = self::store_by_guid($guid, $server); + } + + if ($item_id) { + $r = q("SELECT `body`, `tag`, `app`, `created`, `object-type`, `uri`, `guid`, + `author-name`, `author-link`, `author-avatar` + FROM `item` WHERE `id` = %d AND `visible` AND NOT `deleted` AND `body` != '' LIMIT 1", + intval($item_id)); + + if (Dbm::is_result($r)) { + // If it is a reshared post from another network then reformat to avoid display problems with two share elements + if (self::is_reshare($r[0]["body"], false)) { + $r[0]["body"] = diaspora2bb(bb2diaspora($r[0]["body"])); + $r[0]["body"] = self::replace_people_guid($r[0]["body"], $r[0]["author-link"]); + } + + return $r[0]; + } + + } + } + return false; + } + + /** + * @brief Processes a reshare message + * + * @param array $importer Array of the importer user + * @param object $data The message object + * @param string $xml The original XML of the message + * + * @return int the message id + */ + private static function receive_reshare($importer, $data, $xml) { + $author = notags(unxmlify($data->author)); + $guid = notags(unxmlify($data->guid)); + $created_at = datetime_convert("UTC", "UTC", notags(unxmlify($data->created_at))); + $root_author = notags(unxmlify($data->root_author)); + $root_guid = notags(unxmlify($data->root_guid)); + /// @todo handle unprocessed property "provider_display_name" + $public = notags(unxmlify($data->public)); + + $contact = self::allowed_contact_by_handle($importer, $author, false); + if (!$contact) { + return false; + } + + $message_id = self::message_exists($importer["uid"], $guid); + if ($message_id) { + return true; + } + + $original_item = self::original_item($root_guid, $root_author, $author); + if (!$original_item) { + return false; + } + + $orig_url = System::baseUrl()."/display/".$original_item["guid"]; + + $datarray = array(); + + $datarray["uid"] = $importer["uid"]; + $datarray["contact-id"] = $contact["id"]; + $datarray["network"] = NETWORK_DIASPORA; + + $datarray["author-name"] = $contact["name"]; + $datarray["author-link"] = $contact["url"]; + $datarray["author-avatar"] = ((x($contact,"thumb")) ? $contact["thumb"] : $contact["photo"]); + + $datarray["owner-name"] = $datarray["author-name"]; + $datarray["owner-link"] = $datarray["author-link"]; + $datarray["owner-avatar"] = $datarray["author-avatar"]; + + $datarray["guid"] = $guid; + $datarray["uri"] = $datarray["parent-uri"] = self::get_uri_from_guid($author, $guid); + + $datarray["verb"] = ACTIVITY_POST; + $datarray["gravity"] = GRAVITY_PARENT; + + $datarray["protocol"] = PROTOCOL_DIASPORA; + $datarray["source"] = $xml; + + $prefix = share_header($original_item["author-name"], $original_item["author-link"], $original_item["author-avatar"], + $original_item["guid"], $original_item["created"], $orig_url); + $datarray["body"] = $prefix.$original_item["body"]."[/share]"; + + $datarray["tag"] = $original_item["tag"]; + $datarray["app"] = $original_item["app"]; + + $datarray["plink"] = self::plink($author, $guid); + $datarray["private"] = (($public == "false") ? 1 : 0); + $datarray["changed"] = $datarray["created"] = $datarray["edited"] = $created_at; + + $datarray["object-type"] = $original_item["object-type"]; + + self::fetch_guid($datarray); + $message_id = item_store($datarray); + + if ($message_id) { + logger("Stored reshare ".$datarray["guid"]." with message id ".$message_id, LOGGER_DEBUG); + return true; + } else { + return false; + } + } + + /** + * @brief Processes retractions + * + * @param array $importer Array of the importer user + * @param array $contact The contact of the item owner + * @param object $data The message object + * + * @return bool success + */ + private static function item_retraction($importer, $contact, $data) { + $author = notags(unxmlify($data->author)); + $target_guid = notags(unxmlify($data->target_guid)); + $target_type = notags(unxmlify($data->target_type)); + + $person = self::person_by_handle($author); + if (!is_array($person)) { + logger("unable to find author detail for ".$author); + return false; + } + + if (empty($contact["url"])) { + $contact["url"] = $person["url"]; + } + + // Fetch items that are about to be deleted + $fields = array('uid', 'id', 'parent', 'parent-uri', 'author-link'); + + // When we receive a public retraction, we delete every item that we find. + if ($importer['uid'] == 0) { + $condition = array("`guid` = ? AND NOT `file` LIKE '%%[%%' AND NOT `deleted`", $target_guid); + } else { + $condition = array("`guid` = ? AND `uid` = ? AND NOT `file` LIKE '%%[%%' AND NOT `deleted`", $target_guid, $importer['uid']); + } + $r = dba::select('item', $fields, $condition); + if (!Dbm::is_result($r)) { + logger("Target guid ".$target_guid." was not found on this system for user ".$importer['uid']."."); + return false; + } + + while ($item = dba::fetch($r)) { + // Fetch the parent item + $parent = dba::select('item', array('author-link', 'origin'), array('id' => $item["parent"]), array('limit' => 1)); + + // Only delete it if the parent author really fits + if (!link_compare($parent["author-link"], $contact["url"]) && !link_compare($item["author-link"], $contact["url"])) { + logger("Thread author ".$parent["author-link"]." and item author ".$item["author-link"]." don't fit to expected contact ".$contact["url"], LOGGER_DEBUG); + continue; + } + + // Currently we don't have a central deletion function that we could use in this case. The function "item_drop" doesn't work for that case + dba::update('item', array('deleted' => true, 'title' => '', 'body' => '', + 'edited' => datetime_convert(), 'changed' => datetime_convert()), + array('id' => $item["id"])); + + // Delete the thread - if it is a starting post and not a comment + if ($target_type != 'Comment') { + delete_thread($item["id"], $item["parent-uri"]); + } + + logger("Deleted target ".$target_guid." (".$item["id"].") from user ".$item["uid"]." parent: ".$item["parent"], LOGGER_DEBUG); + + // Now check if the retraction needs to be relayed by us + if ($parent["origin"]) { + // notify others + Worker::add(PRIORITY_HIGH, "notifier", "drop", $item["id"]); + } + } + + return true; + } + + /** + * @brief Receives retraction messages + * + * @param array $importer Array of the importer user + * @param string $sender The sender of the message + * @param object $data The message object + * + * @return bool Success + */ + private static function receive_retraction($importer, $sender, $data) { + $target_type = notags(unxmlify($data->target_type)); + + $contact = self::contact_by_handle($importer["uid"], $sender); + if (!$contact && (in_array($target_type, array("Contact", "Person")))) { + logger("cannot find contact for sender: ".$sender." and user ".$importer["uid"]); + return false; + } + + logger("Got retraction for ".$target_type.", sender ".$sender." and user ".$importer["uid"], LOGGER_DEBUG); + + switch ($target_type) { + case "Comment": + case "Like": + case "Post": + case "Reshare": + case "StatusMessage": + return self::item_retraction($importer, $contact, $data); + + case "Contact": + case "Person": + /// @todo What should we do with an "unshare"? + // Removing the contact isn't correct since we still can read the public items + contact_remove($contact["id"]); + return true; + + default: + logger("Unknown target type ".$target_type); + return false; + } + return true; + } + + /** + * @brief Receives status messages + * + * @param array $importer Array of the importer user + * @param object $data The message object + * @param string $xml The original XML of the message + * + * @return int The message id of the newly created item + */ + private static function receive_status_message($importer, $data, $xml) { + $author = notags(unxmlify($data->author)); + $guid = notags(unxmlify($data->guid)); + $created_at = datetime_convert("UTC", "UTC", notags(unxmlify($data->created_at))); + $public = notags(unxmlify($data->public)); + $text = unxmlify($data->text); + $provider_display_name = notags(unxmlify($data->provider_display_name)); + + $contact = self::allowed_contact_by_handle($importer, $author, false); + if (!$contact) { + return false; + } + + $message_id = self::message_exists($importer["uid"], $guid); + if ($message_id) { + return true; + } + + $address = array(); + if ($data->location) { + foreach ($data->location->children() AS $fieldname => $data) { + $address[$fieldname] = notags(unxmlify($data)); + } + } + + $body = diaspora2bb($text); + + $datarray = array(); + + // Attach embedded pictures to the body + if ($data->photo) { + foreach ($data->photo AS $photo) { + $body = "[img]".unxmlify($photo->remote_photo_path). + unxmlify($photo->remote_photo_name)."[/img]\n".$body; + } + + $datarray["object-type"] = ACTIVITY_OBJ_IMAGE; + } else { + $datarray["object-type"] = ACTIVITY_OBJ_NOTE; + + // Add OEmbed and other information to the body + if (!self::is_redmatrix($contact["url"])) { + $body = add_page_info_to_body($body, false, true); + } + } + + /// @todo enable support for polls + //if ($data->poll) { + // foreach ($data->poll AS $poll) + // print_r($poll); + // die("poll!\n"); + //} + + /// @todo enable support for events + + $datarray["uid"] = $importer["uid"]; + $datarray["contact-id"] = $contact["id"]; + $datarray["network"] = NETWORK_DIASPORA; + + $datarray["author-name"] = $contact["name"]; + $datarray["author-link"] = $contact["url"]; + $datarray["author-avatar"] = ((x($contact,"thumb")) ? $contact["thumb"] : $contact["photo"]); + + $datarray["owner-name"] = $datarray["author-name"]; + $datarray["owner-link"] = $datarray["author-link"]; + $datarray["owner-avatar"] = $datarray["author-avatar"]; + + $datarray["guid"] = $guid; + $datarray["uri"] = $datarray["parent-uri"] = self::get_uri_from_guid($author, $guid); + + $datarray["verb"] = ACTIVITY_POST; + $datarray["gravity"] = GRAVITY_PARENT; + + $datarray["protocol"] = PROTOCOL_DIASPORA; + $datarray["source"] = $xml; + + $datarray["body"] = self::replace_people_guid($body, $contact["url"]); + + if ($provider_display_name != "") { + $datarray["app"] = $provider_display_name; + } + + $datarray["plink"] = self::plink($author, $guid); + $datarray["private"] = (($public == "false") ? 1 : 0); + $datarray["changed"] = $datarray["created"] = $datarray["edited"] = $created_at; + + if (isset($address["address"])) { + $datarray["location"] = $address["address"]; + } + + if (isset($address["lat"]) && isset($address["lng"])) { + $datarray["coord"] = $address["lat"]." ".$address["lng"]; + } + + self::fetch_guid($datarray); + $message_id = item_store($datarray); + + if ($message_id) { + logger("Stored item ".$datarray["guid"]." with message id ".$message_id, LOGGER_DEBUG); + return true; + } else { + return false; + } + } + + /* ************************************************************************************** * + * Here are all the functions that are needed to transmit data with the Diaspora protocol * + * ************************************************************************************** */ + + /** + * @brief returnes the handle of a contact + * + * @param array $me contact array + * + * @return string the handle in the format user@domain.tld + */ + private static function my_handle($contact) { + if ($contact["addr"] != "") { + return $contact["addr"]; + } + + // Normally we should have a filled "addr" field - but in the past this wasn't the case + // So - just in case - we build the the address here. + if ($contact["nickname"] != "") { + $nick = $contact["nickname"]; + } else { + $nick = $contact["nick"]; + } + + return $nick."@".substr(System::baseUrl(), strpos(System::baseUrl(),"://") + 3); + } + + + /** + * @brief Creates the data for a private message in the new format + * + * @param string $msg The message that is to be transmitted + * @param array $user The record of the sender + * @param array $contact Target of the communication + * @param string $prvkey The private key of the sender + * @param string $pubkey The public key of the receiver + * + * @return string The encrypted data + */ + public static function encode_private_data($msg, $user, $contact, $prvkey, $pubkey) { + + logger("Message: ".$msg, LOGGER_DATA); + + // without a public key nothing will work + if (!$pubkey) { + logger("pubkey missing: contact id: ".$contact["id"]); + return false; + } + + $aes_key = openssl_random_pseudo_bytes(32); + $b_aes_key = base64_encode($aes_key); + $iv = openssl_random_pseudo_bytes(16); + $b_iv = base64_encode($iv); + + $ciphertext = self::aes_encrypt($aes_key, $iv, $msg); + + $json = json_encode(array("iv" => $b_iv, "key" => $b_aes_key)); + + $encrypted_key_bundle = ""; + openssl_public_encrypt($json, $encrypted_key_bundle, $pubkey); + + $json_object = json_encode(array("aes_key" => base64_encode($encrypted_key_bundle), + "encrypted_magic_envelope" => base64_encode($ciphertext))); + + return $json_object; + } + + /** + * @brief Creates the envelope for the "fetch" endpoint and for the new format + * + * @param string $msg The message that is to be transmitted + * @param array $user The record of the sender + * + * @return string The envelope + */ + public static function build_magic_envelope($msg, $user) { + + $b64url_data = base64url_encode($msg); + $data = str_replace(array("\n", "\r", " ", "\t"), array("", "", "", ""), $b64url_data); + + $key_id = base64url_encode(self::my_handle($user)); + $type = "application/xml"; + $encoding = "base64url"; + $alg = "RSA-SHA256"; + $signable_data = $data.".".base64url_encode($type).".".base64url_encode($encoding).".".base64url_encode($alg); + + // Fallback if the private key wasn't transmitted in the expected field + if ($user['uprvkey'] == "") + $user['uprvkey'] = $user['prvkey']; + + $signature = rsa_sign($signable_data, $user["uprvkey"]); + $sig = base64url_encode($signature); + + $xmldata = array("me:env" => array("me:data" => $data, + "@attributes" => array("type" => $type), + "me:encoding" => $encoding, + "me:alg" => $alg, + "me:sig" => $sig, + "@attributes2" => array("key_id" => $key_id))); + + $namespaces = array("me" => "http://salmon-protocol.org/ns/magic-env"); + + return xml::from_array($xmldata, $xml, false, $namespaces); + } + + /** + * @brief Create the envelope for a message + * + * @param string $msg The message that is to be transmitted + * @param array $user The record of the sender + * @param array $contact Target of the communication + * @param string $prvkey The private key of the sender + * @param string $pubkey The public key of the receiver + * @param bool $public Is the message public? + * + * @return string The message that will be transmitted to other servers + */ + private static function build_message($msg, $user, $contact, $prvkey, $pubkey, $public = false) { + + // The message is put into an envelope with the sender's signature + $envelope = self::build_magic_envelope($msg, $user); + + // Private messages are put into a second envelope, encrypted with the receivers public key + if (!$public) { + $envelope = self::encode_private_data($envelope, $user, $contact, $prvkey, $pubkey); + } + + return $envelope; + } + + /** + * @brief Creates a signature for a message + * + * @param array $owner the array of the owner of the message + * @param array $message The message that is to be signed + * + * @return string The signature + */ + private static function signature($owner, $message) { + $sigmsg = $message; + unset($sigmsg["author_signature"]); + unset($sigmsg["parent_author_signature"]); + + $signed_text = implode(";", $sigmsg); + + return base64_encode(rsa_sign($signed_text, $owner["uprvkey"], "sha256")); + } + + /** + * @brief Transmit a message to a target server + * + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * @param string $envelope The message that is to be transmitted + * @param bool $public_batch Is it a public post? + * @param bool $queue_run Is the transmission called from the queue? + * @param string $guid message guid + * + * @return int Result of the transmission + */ + public static function transmit($owner, $contact, $envelope, $public_batch, $queue_run=false, $guid = "") { + + $a = get_app(); + + $enabled = intval(Config::get("system", "diaspora_enabled")); + if (!$enabled) + return 200; + + $logid = random_string(4); + $dest_url = (($public_batch) ? $contact["batch"] : $contact["notify"]); + if (!$dest_url) { + logger("no url for contact: ".$contact["id"]." batch mode =".$public_batch); + return 0; + } + + logger("transmit: ".$logid."-".$guid." ".$dest_url); + + if (!$queue_run && was_recently_delayed($contact["id"])) { + $return_code = 0; + } else { + if (!intval(Config::get("system", "diaspora_test"))) { + $content_type = (($public_batch) ? "application/magic-envelope+xml" : "application/json"); + + post_url($dest_url."/", $envelope, array("Content-Type: ".$content_type)); + $return_code = $a->get_curl_code(); + } else { + logger("test_mode"); + return 200; + } + } + + logger("transmit: ".$logid."-".$guid." returns: ".$return_code); + + if (!$return_code || (($return_code == 503) && (stristr($a->get_curl_headers(), "retry-after")))) { + logger("queue message"); + + $r = q("SELECT `id` FROM `queue` WHERE `cid` = %d AND `network` = '%s' AND `content` = '%s' AND `batch` = %d LIMIT 1", + intval($contact["id"]), + dbesc(NETWORK_DIASPORA), + dbesc($envelope), + intval($public_batch) + ); + if ($r) { + logger("add_to_queue ignored - identical item already in queue"); + } else { + // queue message for redelivery + add_to_queue($contact["id"], NETWORK_DIASPORA, $envelope, $public_batch); + + // The message could not be delivered. We mark the contact as "dead" + mark_for_death($contact); + } + } elseif (($return_code >= 200) && ($return_code <= 299)) { + // We successfully delivered a message, the contact is alive + unmark_for_death($contact); + } + + return(($return_code) ? $return_code : (-1)); + } + + + /** + * @brief Build the post xml + * + * @param string $type The message type + * @param array $message The message data + * + * @return string The post XML + */ + public static function build_post_xml($type, $message) { + + $data = array($type => $message); + + return xml::from_array($data, $xml); + } + + /** + * @brief Builds and transmit messages + * + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * @param string $type The message type + * @param array $message The message data + * @param bool $public_batch Is it a public post? + * @param string $guid message guid + * @param bool $spool Should the transmission be spooled or transmitted? + * + * @return int Result of the transmission + */ + private static function build_and_transmit($owner, $contact, $type, $message, $public_batch = false, $guid = "", $spool = false) { + + $msg = self::build_post_xml($type, $message); + + logger('message: '.$msg, LOGGER_DATA); + logger('send guid '.$guid, LOGGER_DEBUG); + + // Fallback if the private key wasn't transmitted in the expected field + if ($owner['uprvkey'] == "") + $owner['uprvkey'] = $owner['prvkey']; + + $envelope = self::build_message($msg, $owner, $contact, $owner['uprvkey'], $contact['pubkey'], $public_batch); + + if ($spool) { + add_to_queue($contact['id'], NETWORK_DIASPORA, $envelope, $public_batch); + return true; + } else + $return_code = self::transmit($owner, $contact, $envelope, $public_batch, false, $guid); + + logger("guid: ".$item["guid"]." result ".$return_code, LOGGER_DEBUG); + + return $return_code; + } + + /** + * @brief sends an account migration + * + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * @param int $uid User ID + * + * @return int The result of the transmission + */ + public static function sendAccountMigration($owner, $contact, $uid) { + + $old_handle = PConfig::get($uid, 'system', 'previous_addr'); + $profile = self::createProfileData($uid); + + $signed_text = 'AccountMigration:'.$old_handle.':'.$profile['author']; + $signature = base64_encode(rsa_sign($signed_text, $owner["uprvkey"], "sha256")); + + $message = array("author" => $old_handle, + "profile" => $profile, + "signature" => $signature); + + logger("Send account migration ".print_r($message, true), LOGGER_DEBUG); + + return self::build_and_transmit($owner, $contact, "account_migration", $message); + } + + /** + * @brief Sends a "share" message + * + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * + * @return int The result of the transmission + */ + public static function send_share($owner, $contact) { + + /** + * @todo support the different possible combinations of "following" and "sharing" + * Currently, Diaspora only interprets the "sharing" field + * + * Before switching this code productive, we have to check all "send_share" calls if "rel" is set correctly + */ + + /* + switch ($contact["rel"]) { + case CONTACT_IS_FRIEND: + $following = true; + $sharing = true; + case CONTACT_IS_SHARING: + $following = false; + $sharing = true; + case CONTACT_IS_FOLLOWER: + $following = true; + $sharing = false; + } + */ + + $message = array("author" => self::my_handle($owner), + "recipient" => $contact["addr"], + "following" => "true", + "sharing" => "true"); + + logger("Send share ".print_r($message, true), LOGGER_DEBUG); + + return self::build_and_transmit($owner, $contact, "contact", $message); + } + + /** + * @brief sends an "unshare" + * + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * + * @return int The result of the transmission + */ + public static function send_unshare($owner, $contact) { + + $message = array("author" => self::my_handle($owner), + "recipient" => $contact["addr"], + "following" => "false", + "sharing" => "false"); + + logger("Send unshare ".print_r($message, true), LOGGER_DEBUG); + + return self::build_and_transmit($owner, $contact, "contact", $message); + } + + /** + * @brief Checks a message body if it is a reshare + * + * @param string $body The message body that is to be check + * @param bool $complete Should it be a complete check or a simple check? + * + * @return array|bool Reshare details or "false" if no reshare + */ + public static function is_reshare($body, $complete = true) { + $body = trim($body); + + // Skip if it isn't a pure repeated messages + // Does it start with a share? + if ((strpos($body, "[share") > 0) && $complete) + return(false); + + // Does it end with a share? + if (strlen($body) > (strrpos($body, "[/share]") + 8)) + return(false); + + $attributes = preg_replace("/\[share(.*?)\]\s?(.*?)\s?\[\/share\]\s?/ism","$1",$body); + // Skip if there is no shared message in there + if ($body == $attributes) + return(false); + + // If we don't do the complete check we quit here + if (!$complete) + return true; + + $guid = ""; + preg_match("/guid='(.*?)'/ism", $attributes, $matches); + if ($matches[1] != "") + $guid = $matches[1]; + + preg_match('/guid="(.*?)"/ism', $attributes, $matches); + if ($matches[1] != "") + $guid = $matches[1]; + + if ($guid != "") { + $r = q("SELECT `contact-id` FROM `item` WHERE `guid` = '%s' AND `network` IN ('%s', '%s') LIMIT 1", + dbesc($guid), NETWORK_DFRN, NETWORK_DIASPORA); + if ($r) { + $ret= array(); + $ret["root_handle"] = self::handle_from_contact($r[0]["contact-id"]); + $ret["root_guid"] = $guid; + return($ret); + } + } + + $profile = ""; + preg_match("/profile='(.*?)'/ism", $attributes, $matches); + if ($matches[1] != "") + $profile = $matches[1]; + + preg_match('/profile="(.*?)"/ism', $attributes, $matches); + if ($matches[1] != "") + $profile = $matches[1]; + + $ret= array(); + + $ret["root_handle"] = preg_replace("=https?://(.*)/u/(.*)=ism", "$2@$1", $profile); + if (($ret["root_handle"] == $profile) || ($ret["root_handle"] == "")) + return(false); + + $link = ""; + preg_match("/link='(.*?)'/ism", $attributes, $matches); + if ($matches[1] != "") + $link = $matches[1]; + + preg_match('/link="(.*?)"/ism', $attributes, $matches); + if ($matches[1] != "") + $link = $matches[1]; + + $ret["root_guid"] = preg_replace("=https?://(.*)/posts/(.*)=ism", "$2", $link); + if (($ret["root_guid"] == $link) || (trim($ret["root_guid"]) == "")) + return(false); + + return($ret); + } + + /** + * @brief Create an event array + * + * @param integer $event_id The id of the event + * + * @return array with event data + */ + private static function build_event($event_id) { + + $r = q("SELECT `guid`, `uid`, `start`, `finish`, `nofinish`, `summary`, `desc`, `location`, `adjust` FROM `event` WHERE `id` = %d", intval($event_id)); + if (!Dbm::is_result($r)) { + return array(); + } + + $event = $r[0]; + + $eventdata = array(); + + $r = q("SELECT `timezone` FROM `user` WHERE `uid` = %d", intval($event['uid'])); + if (!Dbm::is_result($r)) { + return array(); + } + + $user = $r[0]; + + $r = q("SELECT `addr`, `nick` FROM `contact` WHERE `uid` = %d AND `self`", intval($event['uid'])); + if (!Dbm::is_result($r)) { + return array(); + } + + $owner = $r[0]; + + $eventdata['author'] = self::my_handle($owner); + + if ($event['guid']) { + $eventdata['guid'] = $event['guid']; + } + + $mask = 'Y-m-d\TH:i:s\Z'; + + /// @todo - establish "all day" events in Friendica + $eventdata["all_day"] = "false"; + + if (!$event['adjust']) { + $eventdata['timezone'] = $user['timezone']; + + if ($eventdata['timezone'] == "") { + $eventdata['timezone'] = 'UTC'; + } + } + + if ($event['start']) { + $eventdata['start'] = datetime_convert($eventdata['timezone'], "UTC", $event['start'], $mask); + } + if ($event['finish'] && !$event['nofinish']) { + $eventdata['end'] = datetime_convert($eventdata['timezone'], "UTC", $event['finish'], $mask); + } + if ($event['summary']) { + $eventdata['summary'] = html_entity_decode(bb2diaspora($event['summary'])); + } + if ($event['desc']) { + $eventdata['description'] = html_entity_decode(bb2diaspora($event['desc'])); + } + if ($event['location']) { + $location = array(); + $location["address"] = html_entity_decode(bb2diaspora($event['location'])); + $location["lat"] = 0; + $location["lng"] = 0; + $eventdata['location'] = $location; + } + + return $eventdata; + } + + /** + * @brief Create a post (status message or reshare) + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * + * @return array + * 'type' -> Message type ("status_message" or "reshare") + * 'message' -> Array of XML elements of the status + */ + public static function build_status($item, $owner) { + + $cachekey = "diaspora:build_status:".$item['guid']; + + $result = Cache::get($cachekey); + if (!is_null($result)) { + return $result; + } + + $myaddr = self::my_handle($owner); + + $public = (($item["private"]) ? "false" : "true"); + + $created = datetime_convert("UTC", "UTC", $item["created"], 'Y-m-d\TH:i:s\Z'); + + // Detect a share element and do a reshare + if (!$item['private'] && ($ret = self::is_reshare($item["body"]))) { + $message = array("author" => $myaddr, + "guid" => $item["guid"], + "created_at" => $created, + "root_author" => $ret["root_handle"], + "root_guid" => $ret["root_guid"], + "provider_display_name" => $item["app"], + "public" => $public); + + $type = "reshare"; + } else { + $title = $item["title"]; + $body = $item["body"]; + + // convert to markdown + $body = html_entity_decode(bb2diaspora($body)); + + // Adding the title + if (strlen($title)) + $body = "## ".html_entity_decode($title)."\n\n".$body; + + if ($item["attach"]) { + $cnt = preg_match_all('/href=\"(.*?)\"(.*?)title=\"(.*?)\"/ism', $item["attach"], $matches, PREG_SET_ORDER); + if (cnt) { + $body .= "\n".t("Attachments:")."\n"; + foreach ($matches as $mtch) + $body .= "[".$mtch[3]."](".$mtch[1].")\n"; + } + } + + $location = array(); + + if ($item["location"] != "") + $location["address"] = $item["location"]; + + if ($item["coord"] != "") { + $coord = explode(" ", $item["coord"]); + $location["lat"] = $coord[0]; + $location["lng"] = $coord[1]; + } + + $message = array("author" => $myaddr, + "guid" => $item["guid"], + "created_at" => $created, + "public" => $public, + "text" => $body, + "provider_display_name" => $item["app"], + "location" => $location); + + // Diaspora rejects messages when they contain a location without "lat" or "lng" + if (!isset($location["lat"]) || !isset($location["lng"])) { + unset($message["location"]); + } + + if ($item['event-id'] > 0) { + $event = self::build_event($item['event-id']); + if (count($event)) { + $message['event'] = $event; + + /// @todo Once Diaspora supports it, we will remove the body + // $message['text'] = ''; + } + } + + $type = "status_message"; + } + + $msg = array("type" => $type, "message" => $message); + + Cache::set($cachekey, $msg, CACHE_QUARTER_HOUR); + + return $msg; + } + + /** + * @brief Sends a post + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * @param bool $public_batch Is it a public post? + * + * @return int The result of the transmission + */ + public static function send_status($item, $owner, $contact, $public_batch = false) { + + $status = self::build_status($item, $owner); + + return self::build_and_transmit($owner, $contact, $status["type"], $status["message"], $public_batch, $item["guid"]); + } + + /** + * @brief Creates a "like" object + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * + * @return array The data for a "like" + */ + private static function construct_like($item, $owner) { + + $p = q("SELECT `guid`, `uri`, `parent-uri` FROM `item` WHERE `uri` = '%s' LIMIT 1", + dbesc($item["thr-parent"])); + if (!Dbm::is_result($p)) + return false; + + $parent = $p[0]; + + $target_type = ($parent["uri"] === $parent["parent-uri"] ? "Post" : "Comment"); + if ($item['verb'] === ACTIVITY_LIKE) { + $positive = "true"; + } elseif ($item['verb'] === ACTIVITY_DISLIKE) { + $positive = "false"; + } + + return(array("author" => self::my_handle($owner), + "guid" => $item["guid"], + "parent_guid" => $parent["guid"], + "parent_type" => $target_type, + "positive" => $positive, + "author_signature" => "")); + } + + /** + * @brief Creates an "EventParticipation" object + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * + * @return array The data for an "EventParticipation" + */ + private static function construct_attend($item, $owner) { + + $p = q("SELECT `guid`, `uri`, `parent-uri` FROM `item` WHERE `uri` = '%s' LIMIT 1", + dbesc($item["thr-parent"])); + if (!Dbm::is_result($p)) + return false; + + $parent = $p[0]; + + switch ($item['verb']) { + case ACTIVITY_ATTEND: + $attend_answer = 'accepted'; + break; + case ACTIVITY_ATTENDNO: + $attend_answer = 'declined'; + break; + case ACTIVITY_ATTENDMAYBE: + $attend_answer = 'tentative'; + break; + default: + logger('Unknown verb '.$item['verb'].' in item '.$item['guid']); + return false; + } + + return(array("author" => self::my_handle($owner), + "guid" => $item["guid"], + "parent_guid" => $parent["guid"], + "status" => $attend_answer, + "author_signature" => "")); + } + + /** + * @brief Creates the object for a comment + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * + * @return array The data for a comment + */ + private static function construct_comment($item, $owner) { + + $cachekey = "diaspora:construct_comment:".$item['guid']; + + $result = Cache::get($cachekey); + if (!is_null($result)) { + return $result; + } + + $p = q("SELECT `guid` FROM `item` WHERE `parent` = %d AND `id` = %d LIMIT 1", + intval($item["parent"]), + intval($item["parent"]) + ); + + if (!Dbm::is_result($p)) + return false; + + $parent = $p[0]; + + $text = html_entity_decode(bb2diaspora($item["body"])); + $created = datetime_convert("UTC", "UTC", $item["created"], 'Y-m-d\TH:i:s\Z'); + + $comment = array("author" => self::my_handle($owner), + "guid" => $item["guid"], + "created_at" => $created, + "parent_guid" => $parent["guid"], + "text" => $text, + "author_signature" => ""); + + // Send the thread parent guid only if it is a threaded comment + if ($item['thr-parent'] != $item['parent-uri']) { + $comment['thread_parent_guid'] = self::get_guid_from_uri($item['thr-parent'], $item['uid']); + } + + Cache::set($cachekey, $comment, CACHE_QUARTER_HOUR); + + return($comment); + } + + /** + * @brief Send a like or a comment + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * @param bool $public_batch Is it a public post? + * + * @return int The result of the transmission + */ + public static function send_followup($item,$owner,$contact,$public_batch = false) { + + if (in_array($item['verb'], array(ACTIVITY_ATTEND, ACTIVITY_ATTENDNO, ACTIVITY_ATTENDMAYBE))) { + $message = self::construct_attend($item, $owner); + $type = "event_participation"; + } elseif (in_array($item["verb"], array(ACTIVITY_LIKE, ACTIVITY_DISLIKE))) { + $message = self::construct_like($item, $owner); + $type = "like"; + } else { + $message = self::construct_comment($item, $owner); + $type = "comment"; + } + + if (!$message) + return false; + + $message["author_signature"] = self::signature($owner, $message); + + return self::build_and_transmit($owner, $contact, $type, $message, $public_batch, $item["guid"]); + } + + /** + * @brief Creates a message from a signature record entry + * + * @param array $item The item that will be exported + * @param array $signature The entry of the "sign" record + * + * @return string The message + */ + private static function message_from_signature($item, $signature) { + + // Split the signed text + $signed_parts = explode(";", $signature['signed_text']); + + if ($item["deleted"]) { + $message = array("author" => $signature['signer'], + "target_guid" => $signed_parts[0], + "target_type" => $signed_parts[1]); + } elseif (in_array($item["verb"], array(ACTIVITY_LIKE, ACTIVITY_DISLIKE))) { + $message = array("author" => $signed_parts[4], + "guid" => $signed_parts[1], + "parent_guid" => $signed_parts[3], + "parent_type" => $signed_parts[2], + "positive" => $signed_parts[0], + "author_signature" => $signature['signature'], + "parent_author_signature" => ""); + } else { + // Remove the comment guid + $guid = array_shift($signed_parts); + + // Remove the parent guid + $parent_guid = array_shift($signed_parts); + + // Remove the handle + $handle = array_pop($signed_parts); + + // Glue the parts together + $text = implode(";", $signed_parts); + + $message = array("author" => $handle, + "guid" => $guid, + "parent_guid" => $parent_guid, + "text" => implode(";", $signed_parts), + "author_signature" => $signature['signature'], + "parent_author_signature" => ""); + } + return $message; + } + + /** + * @brief Relays messages (like, comment, retraction) to other servers if we are the thread owner + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * @param bool $public_batch Is it a public post? + * + * @return int The result of the transmission + */ + public static function send_relay($item, $owner, $contact, $public_batch = false) { + + if ($item["deleted"]) { + return self::send_retraction($item, $owner, $contact, $public_batch, true); + } elseif (in_array($item["verb"], array(ACTIVITY_LIKE, ACTIVITY_DISLIKE))) { + $type = "like"; + } else { + $type = "comment"; + } + + logger("Got relayable data ".$type." for item ".$item["guid"]." (".$item["id"].")", LOGGER_DEBUG); + + // fetch the original signature + + $r = q("SELECT `signed_text`, `signature`, `signer` FROM `sign` WHERE `iid` = %d LIMIT 1", + intval($item["id"])); + + if (!$r) { + logger("Couldn't fetch signatur for item ".$item["guid"]." (".$item["id"].")", LOGGER_DEBUG); + return false; + } + + $signature = $r[0]; + + // Old way - is used by the internal Friendica functions + /// @todo Change all signatur storing functions to the new format + if ($signature['signed_text'] && $signature['signature'] && $signature['signer']) + $message = self::message_from_signature($item, $signature); + else {// New way + $msg = json_decode($signature['signed_text'], true); + + $message = array(); + if (is_array($msg)) { + foreach ($msg AS $field => $data) { + if (!$item["deleted"]) { + if ($field == "diaspora_handle") { + $field = "author"; + } + if ($field == "target_type") { + $field = "parent_type"; + } + } + + $message[$field] = $data; + } + } else + logger("Signature text for item ".$item["guid"]." (".$item["id"].") couldn't be extracted: ".$signature['signed_text'], LOGGER_DEBUG); + } + + $message["parent_author_signature"] = self::signature($owner, $message); + + logger("Relayed data ".print_r($message, true), LOGGER_DEBUG); + + return self::build_and_transmit($owner, $contact, $type, $message, $public_batch, $item["guid"]); + } + + /** + * @brief Sends a retraction (deletion) of a message, like or comment + * + * @param array $item The item that will be exported + * @param array $owner the array of the item owner + * @param array $contact Target of the communication + * @param bool $public_batch Is it a public post? + * @param bool $relay Is the retraction transmitted from a relay? + * + * @return int The result of the transmission + */ + public static function send_retraction($item, $owner, $contact, $public_batch = false, $relay = false) { + + $itemaddr = self::handle_from_contact($item["contact-id"], $item["gcontact-id"]); + + $msg_type = "retraction"; + + if ($item['id'] == $item['parent']) { + $target_type = "Post"; + } elseif (in_array($item["verb"], array(ACTIVITY_LIKE, ACTIVITY_DISLIKE))) { + $target_type = "Like"; + } else { + $target_type = "Comment"; + } + + $message = array("author" => $itemaddr, + "target_guid" => $item['guid'], + "target_type" => $target_type); + + logger("Got message ".print_r($message, true), LOGGER_DEBUG); + + return self::build_and_transmit($owner, $contact, $msg_type, $message, $public_batch, $item["guid"]); + } + + /** + * @brief Sends a mail + * + * @param array $item The item that will be exported + * @param array $owner The owner + * @param array $contact Target of the communication + * + * @return int The result of the transmission + */ + public static function send_mail($item, $owner, $contact) { + + $myaddr = self::my_handle($owner); + + $r = q("SELECT * FROM `conv` WHERE `id` = %d AND `uid` = %d LIMIT 1", + intval($item["convid"]), + intval($item["uid"]) + ); + + if (!Dbm::is_result($r)) { + logger("conversation not found."); + return; + } + $cnv = $r[0]; + + $conv = array( + "author" => $cnv["creator"], + "guid" => $cnv["guid"], + "subject" => $cnv["subject"], + "created_at" => datetime_convert("UTC", "UTC", $cnv['created'], 'Y-m-d\TH:i:s\Z'), + "participants" => $cnv["recips"] + ); + + $body = bb2diaspora($item["body"]); + $created = datetime_convert("UTC", "UTC", $item["created"], 'Y-m-d\TH:i:s\Z'); + + $msg = array( + "author" => $myaddr, + "guid" => $item["guid"], + "conversation_guid" => $cnv["guid"], + "text" => $body, + "created_at" => $created, + ); + + if ($item["reply"]) { + $message = $msg; + $type = "message"; + } else { + $message = array( + "author" => $cnv["creator"], + "guid" => $cnv["guid"], + "subject" => $cnv["subject"], + "created_at" => datetime_convert("UTC", "UTC", $cnv['created'], 'Y-m-d\TH:i:s\Z'), + "participants" => $cnv["recips"], + "message" => $msg); + + $type = "conversation"; + } + + return self::build_and_transmit($owner, $contact, $type, $message, false, $item["guid"]); + } + + /** + * @brief Create profile data + * + * @param int $uid The user id + * + * @return array The profile data + */ + private static function createProfileData($uid) { + $r = q("SELECT `profile`.`uid` AS `profile_uid`, `profile`.* , `user`.*, `user`.`prvkey` AS `uprvkey`, `contact`.`addr` + FROM `profile` + INNER JOIN `user` ON `profile`.`uid` = `user`.`uid` + INNER JOIN `contact` ON `profile`.`uid` = `contact`.`uid` + WHERE `user`.`uid` = %d AND `profile`.`is-default` AND `contact`.`self` LIMIT 1", + intval($uid) + ); + + if (!$r) { + return array(); + } + + $profile = $r[0]; + + $handle = $profile["addr"]; + $first = ((strpos($profile['name'],' ') + ? trim(substr($profile['name'],0,strpos($profile['name'],' '))) : $profile['name'])); + $last = (($first === $profile['name']) ? '' : trim(substr($profile['name'], strlen($first)))); + $large = System::baseUrl().'/photo/custom/300/'.$profile['uid'].'.jpg'; + $medium = System::baseUrl().'/photo/custom/100/'.$profile['uid'].'.jpg'; + $small = System::baseUrl().'/photo/custom/50/' .$profile['uid'].'.jpg'; + $searchable = (($profile['publish'] && $profile['net-publish']) ? 'true' : 'false'); + + if ($searchable === 'true') { + $dob = '1000-00-00'; + + if (($profile['dob']) && ($profile['dob'] > '0001-01-01')) + $dob = ((intval($profile['dob'])) ? intval($profile['dob']) : '1000') .'-'. datetime_convert('UTC','UTC',$profile['dob'],'m-d'); + + $about = $profile['about']; + $about = strip_tags(bbcode($about)); + + $location = formatted_location($profile); + $tags = ''; + if ($profile['pub_keywords']) { + $kw = str_replace(',',' ',$profile['pub_keywords']); + $kw = str_replace(' ',' ',$kw); + $arr = explode(' ',$profile['pub_keywords']); + if (count($arr)) { + for ($x = 0; $x < 5; $x ++) { + if (trim($arr[$x])) + $tags .= '#'. trim($arr[$x]) .' '; + } + } + } + $tags = trim($tags); + } + + return array("author" => $handle, + "first_name" => $first, + "last_name" => $last, + "image_url" => $large, + "image_url_medium" => $medium, + "image_url_small" => $small, + "birthday" => $dob, + "gender" => $profile['gender'], + "bio" => $about, + "location" => $location, + "searchable" => $searchable, + "nsfw" => "false", + "tag_string" => $tags); + } + + /** + * @brief Sends profile data + * + * @param int $uid The user id + */ + public static function send_profile($uid, $recips = false) { + + if (!$uid) + return; + + if (!$recips) + $recips = q("SELECT `id`,`name`,`network`,`pubkey`,`notify` FROM `contact` WHERE `network` = '%s' + AND `uid` = %d AND `rel` != %d", + dbesc(NETWORK_DIASPORA), + intval($uid), + intval(CONTACT_IS_SHARING) + ); + if (!$recips) + return; + + $message = self::createProfileData($uid); + + foreach ($recips as $recip) { + logger("Send updated profile data for user ".$uid." to contact ".$recip["id"], LOGGER_DEBUG); + self::build_and_transmit($profile, $recip, "profile", $message, false, "", true); + } + } + + /** + * @brief Stores the signature for likes that are created on our system + * + * @param array $contact The contact array of the "like" + * @param int $post_id The post id of the "like" + * + * @return bool Success + */ + public static function store_like_signature($contact, $post_id) { + + // Is the contact the owner? Then fetch the private key + if (!$contact['self'] || ($contact['uid'] == 0)) { + logger("No owner post, so not storing signature", LOGGER_DEBUG); + return false; + } + + $r = q("SELECT `prvkey` FROM `user` WHERE `uid` = %d LIMIT 1", intval($contact['uid'])); + if (!Dbm::is_result($r)) { + return false; + } + + $contact["uprvkey"] = $r[0]['prvkey']; + + $r = q("SELECT * FROM `item` WHERE `id` = %d LIMIT 1", intval($post_id)); + if (!Dbm::is_result($r)) { + return false; + } + + if (!in_array($r[0]["verb"], array(ACTIVITY_LIKE, ACTIVITY_DISLIKE))) { + return false; + } + + $message = self::construct_like($r[0], $contact); + $message["author_signature"] = self::signature($contact, $message); + + /* + * Now store the signature more flexible to dynamically support new fields. + * This will break Diaspora compatibility with Friendica versions prior to 3.5. + */ + dba::insert('sign', array('iid' => $post_id, 'signed_text' => json_encode($message))); + + logger('Stored diaspora like signature'); + return true; + } + + /** + * @brief Stores the signature for comments that are created on our system + * + * @param array $item The item array of the comment + * @param array $contact The contact array of the item owner + * @param string $uprvkey The private key of the sender + * @param int $message_id The message id of the comment + * + * @return bool Success + */ + public static function store_comment_signature($item, $contact, $uprvkey, $message_id) { + + if ($uprvkey == "") { + logger('No private key, so not storing comment signature', LOGGER_DEBUG); + return false; + } + + $contact["uprvkey"] = $uprvkey; + + $message = self::construct_comment($item, $contact); + $message["author_signature"] = self::signature($contact, $message); + + /* + * Now store the signature more flexible to dynamically support new fields. + * This will break Diaspora compatibility with Friendica versions prior to 3.5. + */ + dba::insert('sign', array('iid' => $message_id, 'signed_text' => json_encode($message))); + + logger('Stored diaspora comment signature'); + return true; + } +} diff --git a/src/Util/Lock.php b/src/Util/Lock.php index 8cd38066d1..9bf67d7043 100644 --- a/src/Util/Lock.php +++ b/src/Util/Lock.php @@ -9,9 +9,9 @@ namespace Friendica\Util; */ use Friendica\Core\Config; +use Friendica\Database\Dbm; use Memcache; use dba; -use dbm; /** * @brief This class contain Functions for preventing parallel execution of functions @@ -121,7 +121,7 @@ class Lock { dba::lock('locks'); $lock = dba::select('locks', array('locked', 'pid'), array('name' => $fn_name), array('limit' => 1)); - if (dbm::is_result($lock)) { + if (Dbm::is_result($lock)) { if ($lock['locked']) { // When the process id isn't used anymore, we can safely claim the lock for us. if (!posix_kill($lock['pid'], 0)) { @@ -136,7 +136,7 @@ class Lock { dba::update('locks', array('locked' => true, 'pid' => getmypid()), array('name' => $fn_name)); $got_lock = true; } - } elseif (!dbm::is_result($lock)) { + } elseif (!Dbm::is_result($lock)) { dba::insert('locks', array('name' => $fn_name, 'locked' => true, 'pid' => getmypid())); $got_lock = true; }