2011-08-09 00:44:29 -04:00
< ? php
2015-12-25 17:17:34 -05:00
/**
* @ file include / diaspora . php
2016-03-14 18:11:43 -04:00
* @ brief The implementation of the diaspora protocol
2016-07-14 01:20:20 -04:00
*
* The new protocol is described here : http :// diaspora . github . io / diaspora_federation / index . html
* Currently this implementation here interprets the old and the new protocol and sends the old one .
* This will change in the future .
2015-12-25 17:17:34 -05:00
*/
2015-07-11 08:37:02 -04:00
2017-02-10 15:45:22 -05:00
use \Friendica\Core\Config ;
2017-03-30 14:29:12 -04:00
require_once 'include/items.php' ;
require_once 'include/bb2diaspora.php' ;
require_once 'include/Scrape.php' ;
require_once 'include/Contact.php' ;
require_once 'include/Photo.php' ;
require_once 'include/socgraph.php' ;
require_once 'include/group.php' ;
require_once 'include/xml.php' ;
require_once 'include/datetime.php' ;
require_once 'include/queue_fn.php' ;
require_once 'include/cache.php' ;
2011-09-14 22:33:42 -04:00
2016-03-14 18:11:43 -04:00
/**
* @ brief This class contain functions to create and send Diaspora XML files
*
*/
2016-12-20 12:44:15 -05:00
class Diaspora {
2011-09-14 22:33:42 -04:00
2016-03-17 18:44:18 -04:00
/**
* @ brief Return a list of relay servers
*
* This is an experimental Diaspora feature .
*
* @ return array of relay servers
*/
2016-03-14 18:11:43 -04:00
public static function relay_list () {
2016-02-27 17:54:17 -05:00
2016-03-14 18:11:43 -04:00
$serverdata = get_config ( " system " , " relay_server " );
if ( $serverdata == " " )
return array ();
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
$relay = array ();
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
$servers = explode ( " , " , $serverdata );
2011-10-17 20:39:25 -04:00
2017-04-04 13:47:32 -04:00
foreach ( $servers AS $server ) {
2016-03-14 18:11:43 -04:00
$server = trim ( $server );
2017-01-13 05:37:39 -05:00
$addr = " relay@ " . str_replace ( " http:// " , " " , normalise_link ( $server ));
2016-03-14 18:11:43 -04:00
$batch = $server . " /receive/public " ;
2011-08-24 04:21:24 -04:00
2017-01-13 05:37:39 -05:00
$relais = q ( " SELECT `batch`, `id`, `name`,`network` FROM `contact` WHERE `uid` = 0 AND `batch` = '%s' AND `addr` = '%s' AND `nurl` = '%s' LIMIT 1 " ,
dbesc ( $batch ), dbesc ( $addr ), dbesc ( normalise_link ( $server )));
2011-08-24 04:21:24 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $relais ) {
$r = q ( " INSERT INTO `contact` (`uid`, `created`, `name`, `nick`, `addr`, `url`, `nurl`, `batch`, `network`, `rel`, `blocked`, `pending`, `writable`, `name-date`, `uri-date`, `avatar-date`)
VALUES ( 0 , '%s' , '%s' , 'relay' , '%s' , '%s' , '%s' , '%s' , '%s' , % d , 0 , 0 , 1 , '%s' , '%s' , '%s' ) " ,
datetime_convert (),
dbesc ( $addr ),
dbesc ( $addr ),
dbesc ( $server ),
dbesc ( normalise_link ( $server )),
dbesc ( $batch ),
dbesc ( NETWORK_DIASPORA ),
intval ( CONTACT_IS_FOLLOWER ),
dbesc ( datetime_convert ()),
dbesc ( datetime_convert ()),
dbesc ( datetime_convert ())
);
2011-11-30 20:08:16 -05:00
2016-03-14 18:11:43 -04:00
$relais = q ( " SELECT `batch`, `id`, `name`,`network` FROM `contact` WHERE `uid` = 0 AND `batch` = '%s' LIMIT 1 " , dbesc ( $batch ));
if ( $relais )
$relay [] = $relais [ 0 ];
} else
$relay [] = $relais [ 0 ];
}
2011-11-30 20:08:16 -05:00
2016-03-14 18:11:43 -04:00
return $relay ;
2011-08-24 04:21:24 -04:00
}
2012-08-10 00:06:18 -04:00
2016-03-17 18:44:18 -04:00
/**
* @ brief repairs a signature that was double encoded
*
2016-03-18 17:28:20 -04:00
* The function is unused at the moment . It was copied from the old implementation .
*
2016-03-17 18:44:18 -04:00
* @ param string $signature The signature
* @ param string $handle The handle of the signature owner
* @ param integer $level This value is only set inside this function to avoid endless loops
*
2016-03-21 14:58:45 -04:00
* @ return string the repaired signature
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function repair_signature ( $signature , $handle = " " , $level = 1 ) {
2012-08-10 00:06:18 -04:00
2016-03-14 18:11:43 -04:00
if ( $signature == " " )
return ( $signature );
2012-08-10 00:06:18 -04:00
2016-03-14 18:11:43 -04:00
if ( base64_encode ( base64_decode ( base64_decode ( $signature ))) == base64_decode ( $signature )) {
$signature = base64_decode ( $signature );
logger ( " Repaired double encoded signature from Diaspora/Hubzilla handle " . $handle . " - level " . $level , LOGGER_DEBUG );
2012-08-10 00:06:18 -04:00
2016-03-14 18:11:43 -04:00
// Do a recursive call to be able to fix even multiple levels
if ( $level < 10 )
$signature = self :: repair_signature ( $signature , $handle , ++ $level );
2012-08-10 00:06:18 -04:00
}
2016-03-14 18:11:43 -04:00
return ( $signature );
2012-08-10 00:06:18 -04:00
}
2016-06-30 16:18:48 -04:00
/**
* @ brief verify the envelope and return the verified data
*
* @ param string $envelope The magic envelope
*
* @ return string verified data
*/
2016-12-29 18:27:11 -05:00
private static function verify_magic_envelope ( $envelope ) {
2016-06-30 16:18:48 -04:00
$basedom = parse_xml_string ( $envelope , false );
if ( ! is_object ( $basedom )) {
logger ( " Envelope is no XML file " );
return false ;
}
$children = $basedom -> 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 ;
}
2017-03-30 14:29:12 -04:00
/**
* @ 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 ) {
2017-03-30 19:21:52 -04:00
return openssl_encrypt ( $data , 'aes-256-cbc' , str_pad ( $key , 32 , " \0 " ), OPENSSL_RAW_DATA , str_pad ( $iv , 16 , " \0 " ));
2017-03-30 14:29:12 -04:00
}
/**
* @ 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 ) {
2017-03-30 19:21:52 -04:00
return openssl_decrypt ( $encrypted , 'aes-256-cbc' , str_pad ( $key , 32 , " \0 " ), OPENSSL_RAW_DATA , str_pad ( $iv , 16 , " \0 " ));
2017-03-30 14:29:12 -04:00
}
2016-03-14 18:11:43 -04:00
/**
* @ brief : Decodes incoming Diaspora message
*
2016-03-17 18:44:18 -04:00
* @ param array $importer Array of the importer user
2016-03-14 18:11:43 -04:00
* @ 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)
*/
2016-03-27 17:25:32 -04:00
public static function decode ( $importer , $xml ) {
2012-08-10 00:06:18 -04:00
2016-03-14 18:11:43 -04:00
$public = false ;
$basedom = parse_xml_string ( $xml );
2011-08-22 22:27:40 -04:00
2016-03-14 18:11:43 -04:00
if ( ! is_object ( $basedom ))
return false ;
2012-06-14 22:58:25 -04:00
2016-03-14 18:11:43 -04:00
$children = $basedom -> children ( 'https://joindiaspora.com/protocol' );
2012-06-14 22:58:25 -04:00
2017-04-04 13:47:32 -04:00
if ( $children -> header ) {
2016-03-14 18:11:43 -04:00
$public = true ;
$author_link = str_replace ( 'acct:' , '' , $children -> header -> author_id );
} else {
2012-07-05 21:01:13 -04:00
2016-03-14 18:11:43 -04:00
$encrypted_header = json_decode ( base64_decode ( $children -> encrypted_header ));
2012-06-14 22:58:25 -04:00
2016-03-14 18:11:43 -04:00
$encrypted_aes_key_bundle = base64_decode ( $encrypted_header -> aes_key );
$ciphertext = base64_decode ( $encrypted_header -> ciphertext );
2012-06-14 22:58:25 -04:00
2016-03-14 18:11:43 -04:00
$outer_key_bundle = '' ;
openssl_private_decrypt ( $encrypted_aes_key_bundle , $outer_key_bundle , $importer [ 'prvkey' ]);
2012-06-14 22:58:25 -04:00
2016-03-14 18:11:43 -04:00
$j_outer_key_bundle = json_decode ( $outer_key_bundle );
2012-06-14 22:58:25 -04:00
2016-03-14 18:11:43 -04:00
$outer_iv = base64_decode ( $j_outer_key_bundle -> iv );
$outer_key = base64_decode ( $j_outer_key_bundle -> key );
2011-08-22 22:27:40 -04:00
2017-03-30 14:29:12 -04:00
$decrypted = self :: aes_decrypt ( $outer_key , $outer_iv , $ciphertext );
2011-08-22 22:27:40 -04:00
2016-03-14 18:11:43 -04:00
logger ( 'decrypted: ' . $decrypted , LOGGER_DEBUG );
$idom = parse_xml_string ( $decrypted , false );
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
$inner_iv = base64_decode ( $idom -> iv );
$inner_aes_key = base64_decode ( $idom -> aes_key );
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
$author_link = str_replace ( 'acct:' , '' , $idom -> author_id );
}
2014-04-21 18:58:17 -04:00
2016-03-14 18:11:43 -04:00
$dom = $basedom -> children ( NAMESPACE_SALMON_ME );
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
// figure out where in the DOM tree our data is hiding
2011-09-22 07:11:39 -04:00
2017-04-04 13:47:32 -04:00
if ( $dom -> provenance -> data )
2016-03-14 18:11:43 -04:00
$base = $dom -> provenance ;
2017-04-04 13:47:32 -04:00
elseif ( $dom -> env -> data )
2016-03-14 18:11:43 -04:00
$base = $dom -> env ;
2017-04-04 13:47:32 -04:00
elseif ( $dom -> data )
2016-03-14 18:11:43 -04:00
$base = $dom ;
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $base ) {
logger ( 'unable to locate salmon data in xml' );
http_status_exit ( 400 );
}
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
// 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 );
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
// unpack the data
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
// strip whitespace so our data element will return to one big base64 blob
$data = str_replace ( array ( " " , " \t " , " \r " , " \n " ), array ( " " , " " , " " , " " ), $base -> data );
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
// stash away some other stuff for later
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
$type = $base -> data [ 0 ] -> attributes () -> type [ 0 ];
$keyhash = $base -> sig [ 0 ] -> attributes () -> keyhash [ 0 ];
$encoding = $base -> encoding ;
$alg = $base -> alg ;
2011-09-18 23:17:44 -04:00
2016-03-14 18:11:43 -04:00
$signed_data = $data . '.' . base64url_encode ( $type ) . '.' . base64url_encode ( $encoding ) . '.' . base64url_encode ( $alg );
2011-09-18 23:17:44 -04:00
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
// decode the data
$data = base64url_decode ( $data );
2011-09-22 07:11:39 -04:00
2011-08-19 07:48:54 -04:00
2017-04-04 13:47:32 -04:00
if ( $public )
2016-03-14 18:11:43 -04:00
$inner_decrypted = $data ;
else {
2011-12-19 19:51:57 -05:00
2016-03-14 18:11:43 -04:00
// Decode the encrypted blob
2011-12-19 19:51:57 -05:00
2016-03-14 18:11:43 -04:00
$inner_encrypted = base64_decode ( $data );
2017-03-30 14:29:12 -04:00
$inner_decrypted = self :: aes_decrypt ( $inner_aes_key , $inner_iv , $inner_encrypted );
2016-03-14 18:11:43 -04:00
}
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
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
2014-05-03 17:40:34 -04:00
2016-03-14 18:11:43 -04:00
logger ( 'Fetching key for ' . $author_link );
$key = self :: key ( $author_link );
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $key ) {
logger ( 'Could not retrieve author key.' );
http_status_exit ( 400 );
}
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
$verify = rsa_verify ( $signed_data , $signature , $key );
2011-08-09 09:40:28 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $verify ) {
logger ( 'Message did not verify. Discarding.' );
http_status_exit ( 400 );
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
logger ( 'Message verified.' );
2011-09-14 22:33:42 -04:00
2016-03-15 15:14:08 -04:00
return array ( 'message' => ( string ) $inner_decrypted ,
'author' => unxmlify ( $author_link ),
'key' => ( string ) $key );
2016-03-14 18:11:43 -04:00
}
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
/**
* @ brief Dispatches public messages and find the fitting receivers
*
* @ param array $msg The post that will be dispatched
*
2016-03-28 16:35:11 -04:00
* @ return int The message id of the generated message , " true " or " false " if there was an error
2016-03-14 18:11:43 -04:00
*/
public static function dispatch_public ( $msg ) {
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
$enabled = intval ( get_config ( " system " , " diaspora_enabled " ));
if ( ! $enabled ) {
logger ( " diaspora is disabled " );
return false ;
}
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
// 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 " ])
);
2017-02-11 18:37:15 -05:00
2017-02-10 15:45:22 -05:00
if ( dbm :: is_result ( $r )) {
2016-12-20 15:13:50 -05:00
foreach ( $r as $rr ) {
2016-03-14 18:11:43 -04:00
logger ( " delivering to: " . $rr [ " username " ]);
2017-05-02 15:48:11 -04:00
self :: dispatch ( $rr , $msg );
2016-03-14 18:11:43 -04:00
}
2017-01-11 07:02:18 -05:00
} else {
2017-02-11 18:37:15 -05:00
// Use a dummy importer to import the data for the public copy
2017-05-02 14:42:01 -04:00
// or for comments from unknown people
$importer = array ( " uid " => 0 , " page-flags " => PAGE_FREELOVE );
2017-05-02 15:48:11 -04:00
$message_id = self :: dispatch ( $importer , $msg );
2017-02-10 15:45:22 -05:00
}
2016-03-28 16:35:11 -04:00
return $message_id ;
2016-03-14 18:11:43 -04:00
}
2011-08-22 07:55:09 -04:00
2016-03-14 18:11:43 -04:00
/**
* @ 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
*
2016-03-28 16:35:11 -04:00
* @ return int The message id of the generated message , " true " or " false " if there was an error
2016-03-14 18:11:43 -04:00
*/
public static function dispatch ( $importer , $msg ) {
2011-08-22 07:55:09 -04:00
2016-03-14 18:11:43 -04:00
// 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 " ];
2011-08-22 07:55:09 -04:00
2016-12-20 12:44:15 -05:00
if ( ! self :: valid_posting ( $msg , $fields )) {
2016-03-14 18:11:43 -04:00
logger ( " Invalid posting " );
return false ;
}
2011-08-21 20:24:50 -04:00
2016-03-14 18:11:43 -04:00
$type = $fields -> getName ();
2011-08-09 00:44:29 -04:00
2017-05-02 14:42:01 -04:00
$social_relay = Config :: get ( 'system' , 'relay_subscribe' , false );
2017-05-02 15:48:11 -04:00
if ( ! $social_relay AND ( in_array ( $type , array ( 'status_message' , 'reshare' )))) {
2017-05-02 14:42:01 -04:00
logger ( " Unwanted message from " . $sender . " send by " . $_SERVER [ " REMOTE_ADDR " ] . " with " . $_SERVER [ " HTTP_USER_AGENT " ] . " : " . print_r ( $msg , true ), LOGGER_DEBUG );
}
2016-03-14 18:11:43 -04:00
logger ( " Received message type " . $type . " from " . $sender . " for user " . $importer [ " uid " ], LOGGER_DEBUG );
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
switch ( $type ) {
case " account_deletion " :
return self :: receive_account_deletion ( $importer , $fields );
2011-08-09 00:44:29 -04:00
2016-03-14 18:11:43 -04:00
case " comment " :
2016-03-14 18:54:01 -04:00
return self :: receive_comment ( $importer , $sender , $fields , $msg [ " message " ]);
2011-08-09 05:53:51 -04:00
2016-03-24 19:49:18 -04:00
case " contact " :
return self :: receive_contact_request ( $importer , $fields );
2016-03-14 18:11:43 -04:00
case " conversation " :
return self :: receive_conversation ( $importer , $msg , $fields );
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
case " like " :
return self :: receive_like ( $importer , $sender , $fields );
2011-08-15 08:27:24 -04:00
2016-03-14 18:11:43 -04:00
case " message " :
return self :: receive_message ( $importer , $fields );
2011-08-15 08:27:24 -04:00
2016-03-14 18:11:43 -04:00
case " participation " : // Not implemented
return self :: receive_participation ( $importer , $fields );
2016-03-13 11:14:51 -04:00
2016-03-14 18:11:43 -04:00
case " photo " : // Not implemented
return self :: receive_photo ( $importer , $fields );
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
case " poll_participation " : // Not implemented
return self :: receive_poll_participation ( $importer , $fields );
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
case " profile " :
return self :: receive_profile ( $importer , $fields );
2014-05-03 17:40:34 -04:00
2016-03-14 18:11:43 -04:00
case " reshare " :
2016-03-14 19:26:28 -04:00
return self :: receive_reshare ( $importer , $fields , $msg [ " message " ]);
2011-09-14 22:33:42 -04:00
2016-03-14 18:11:43 -04:00
case " retraction " :
return self :: receive_retraction ( $importer , $sender , $fields );
2011-09-14 22:33:42 -04:00
2016-03-14 18:11:43 -04:00
case " status_message " :
2016-03-14 18:54:01 -04:00
return self :: receive_status_message ( $importer , $fields , $msg [ " message " ]);
2011-09-14 22:33:42 -04:00
2016-03-14 18:11:43 -04:00
default :
logger ( " Unknown message type " . $type );
return false ;
}
2011-09-14 22:33:42 -04:00
2016-03-14 18:11:43 -04:00
return true ;
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
/**
* @ 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
* @ param object $fields SimpleXML object that contains the posting when it is valid
*
* @ return bool Is the posting valid ?
*/
2016-12-29 18:27:11 -05:00
private static function valid_posting ( $msg , & $fields ) {
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$data = parse_xml_string ( $msg [ " message " ], false );
2011-08-15 09:27:17 -04:00
2016-06-29 04:33:43 -04:00
if ( ! is_object ( $data )) {
logger ( " No valid XML " . $msg [ " message " ], LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return false ;
2016-06-29 04:33:43 -04:00
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$first_child = $data -> getName ();
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
// 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 ;
}
2011-08-20 07:53:11 -04:00
2016-03-14 18:11:43 -04:00
$type = $element -> getName ();
$orig_type = $type ;
2011-08-09 05:53:51 -04:00
2016-07-10 06:09:58 -04:00
logger ( " Got message type " . $type . " : " . $msg [ " message " ], LOGGER_DATA );
2016-03-14 18:11:43 -04:00
// 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 " ;
2011-08-09 05:53:51 -04:00
2016-03-24 19:49:18 -04:00
if ( $type == " request " )
$type = " contact " ;
2016-03-14 18:11:43 -04:00
$fields = new SimpleXMLElement ( " < " . $type . " /> " );
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$signed_data = " " ;
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
foreach ( $element -> children () AS $fieldname => $entry ) {
if ( $oldXML ) {
// Translation for the old XML structure
if ( $fieldname == " diaspora_handle " )
$fieldname = " author " ;
2011-09-14 22:33:42 -04:00
2016-03-14 18:11:43 -04:00
if ( $fieldname == " participant_handles " )
$fieldname = " participants " ;
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
if ( in_array ( $type , array ( " like " , " participation " ))) {
if ( $fieldname == " target_type " )
$fieldname = " parent_type " ;
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
if ( $fieldname == " sender_handle " )
$fieldname = " author " ;
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
if ( $fieldname == " recipient_handle " )
$fieldname = " recipient " ;
2014-04-04 04:52:53 -04:00
2016-03-14 18:11:43 -04:00
if ( $fieldname == " root_diaspora_id " )
$fieldname = " root_author " ;
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
if ( $type == " retraction " ) {
if ( $fieldname == " post_guid " )
$fieldname = " target_guid " ;
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
if ( $fieldname == " type " )
$fieldname = " target_type " ;
}
}
2011-08-09 05:53:51 -04:00
2016-06-29 04:33:43 -04:00
if (( $fieldname == " author_signature " ) AND ( $entry != " " ))
2016-03-14 18:11:43 -04:00
$author_signature = base64_decode ( $entry );
2016-06-29 04:33:43 -04:00
elseif (( $fieldname == " parent_author_signature " ) AND ( $entry != " " ))
2016-03-14 18:11:43 -04:00
$parent_author_signature = base64_decode ( $entry );
2016-06-29 14:37:04 -04:00
elseif ( ! in_array ( $fieldname , array ( " author_signature " , " parent_author_signature " , " target_author_signature " ))) {
2016-03-14 18:11:43 -04:00
if ( $signed_data != " " ) {
$signed_data .= " ; " ;
$signed_data_parent .= " ; " ;
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$signed_data .= $entry ;
}
if ( ! in_array ( $fieldname , array ( " parent_author_signature " , " target_author_signature " )) OR
( $orig_type == " relayable_retraction " ))
xml :: copy ( $entry , $fields , $fieldname );
}
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
// 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 ;
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
// Only some message types have signatures. So we quit here for the other types.
if ( ! in_array ( $type , array ( " comment " , " message " , " like " )))
return true ;
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
// No author_signature? This is a must, so we quit.
2016-06-29 04:33:43 -04:00
if ( ! isset ( $author_signature )) {
2016-06-29 14:37:04 -04:00
logger ( " No author signature for type " . $type . " - Message: " . $msg [ " message " ], LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return false ;
2016-06-29 04:33:43 -04:00
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
if ( isset ( $parent_author_signature )) {
$key = self :: key ( $msg [ " author " ]);
2011-08-17 07:24:26 -04:00
2016-06-29 04:33:43 -04:00
if ( ! rsa_verify ( $signed_data , $parent_author_signature , $key , " sha256 " )) {
2016-12-29 12:11:59 -05:00
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 );
2016-03-14 18:11:43 -04:00
return false ;
2016-06-29 04:33:43 -04:00
}
2016-03-14 18:11:43 -04:00
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$key = self :: key ( $fields -> author );
2011-08-09 05:53:51 -04:00
2016-06-29 04:33:43 -04:00
if ( ! rsa_verify ( $signed_data , $author_signature , $key , " sha256 " )) {
2016-12-29 12:11:59 -05:00
logger ( " No valid author signature for author " . $fields -> author . " in type " . $type . " - signed data: " . $signed_data . " - Message: " . $msg [ " message " ] . " - Signature " . $author_signature , LOGGER_DEBUG );
2016-06-29 04:33:43 -04:00
return false ;
} else
return true ;
2016-03-14 18:11:43 -04:00
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
/**
* @ brief Fetches the public key for a given handle
*
* @ param string $handle The handle
*
* @ return string The public key
*/
2016-12-29 18:27:11 -05:00
private static function key ( $handle ) {
2016-03-14 18:11:43 -04:00
$handle = strval ( $handle );
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
logger ( " Fetching diaspora key for: " . $handle );
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$r = self :: person_by_handle ( $handle );
2017-04-04 13:47:32 -04:00
if ( $r )
2016-03-14 18:11:43 -04:00
return $r [ " pubkey " ];
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
return " " ;
2011-09-14 22:33:42 -04:00
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
/**
* @ brief Fetches data for a given handle
*
* @ param string $handle The handle
*
* @ return array the queried data
*/
2016-12-29 18:27:11 -05:00
private static function person_by_handle ( $handle ) {
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$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 );
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
// update record occasionally so it doesn't get stale
$d = strtotime ( $person [ " updated " ] . " +00:00 " );
if ( $d < strtotime ( " now - 14 days " ))
$update = true ;
2016-07-10 06:09:58 -04:00
if ( $person [ " guid " ] == " " )
$update = true ;
2016-03-14 18:11:43 -04:00
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $person OR $update ) {
logger ( " create or refresh " , LOGGER_DEBUG );
$r = probe_url ( $handle , PROBE_DIASPORA );
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
// Note that Friendica contacts will return a "Diaspora person"
// if Diaspora connectivity is enabled on their server
if ( $r AND ( $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
*/
2016-12-29 18:27:11 -05:00
private static function add_fcontact ( $arr , $update = false ) {
2016-03-14 18:11:43 -04:00
2017-04-04 13:47:32 -04:00
if ( $update ) {
2016-03-14 18:11:43 -04:00
$r = q ( " UPDATE `fcontact` SET
`name` = '%s' ,
`photo` = '%s' ,
`request` = '%s' ,
`nick` = '%s' ,
`addr` = '%s' ,
2016-07-10 06:09:58 -04:00
`guid` = '%s' ,
2016-03-14 18:11:43 -04:00
`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 " ]),
2016-08-23 01:48:48 -04:00
dbesc ( strtolower ( $arr [ " addr " ])),
2016-07-10 06:09:58 -04:00
dbesc ( $arr [ " guid " ]),
2016-03-14 18:11:43 -04:00
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 {
2016-07-10 06:09:58 -04:00
$r = q ( " INSERT INTO `fcontact` (`url`,`name`,`photo`,`request`,`nick`,`addr`, `guid`,
2016-03-14 18:11:43 -04:00
`batch` , `notify` , `poll` , `confirm` , `network` , `alias` , `pubkey` , `updated` )
2016-07-15 11:25:30 -04:00
VALUES ( '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' ) " ,
2016-03-14 18:11:43 -04:00
dbesc ( $arr [ " url " ]),
dbesc ( $arr [ " name " ]),
dbesc ( $arr [ " photo " ]),
dbesc ( $arr [ " request " ]),
dbesc ( $arr [ " nick " ]),
dbesc ( $arr [ " addr " ]),
2016-07-10 06:09:58 -04:00
dbesc ( $arr [ " guid " ]),
2016-03-14 18:11:43 -04:00
dbesc ( $arr [ " batch " ]),
dbesc ( $arr [ " notify " ]),
dbesc ( $arr [ " poll " ]),
dbesc ( $arr [ " confirm " ]),
dbesc ( $arr [ " network " ]),
dbesc ( $arr [ " alias " ]),
dbesc ( $arr [ " pubkey " ]),
dbesc ( datetime_convert ())
);
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
return $r ;
2011-08-09 05:53:51 -04:00
}
2016-03-17 18:44:18 -04:00
/**
* @ 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
*/
2016-03-17 07:24:23 -04:00
public static function handle_from_contact ( $contact_id , $gcontact_id = 0 ) {
2016-12-20 12:49:50 -05:00
$handle = false ;
2011-08-09 05:53:51 -04:00
2016-03-17 07:24:23 -04:00
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 ));
2016-12-20 12:49:50 -05:00
if ( dbm :: is_result ( $r )) {
2016-08-23 01:48:48 -04:00
return strtolower ( $r [ 0 ][ " addr " ]);
2016-12-20 12:49:50 -05:00
}
2016-03-17 07:24:23 -04:00
}
2011-08-09 05:53:51 -04:00
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT `network`, `addr`, `self`, `url`, `nick` FROM `contact` WHERE `id` = %d " ,
2016-03-17 07:24:23 -04:00
intval ( $contact_id ));
2016-12-20 12:49:50 -05:00
if ( dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
$contact = $r [ 0 ];
logger ( " contact 'self' = " . $contact [ 'self' ] . " 'url' = " . $contact [ 'url' ], LOGGER_DEBUG );
2016-12-20 12:49:50 -05:00
if ( $contact [ 'addr' ] != " " ) {
2016-03-14 18:11:43 -04:00
$handle = $contact [ 'addr' ];
2016-12-20 12:49:50 -05:00
} else {
2016-03-14 18:11:43 -04:00
$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 ;
}
}
2013-01-20 08:08:28 -05:00
2016-08-23 01:48:48 -04:00
return strtolower ( $handle );
2016-03-14 18:11:43 -04:00
}
2011-08-10 08:10:48 -04:00
2016-12-19 23:30:50 -05:00
/**
2016-12-20 12:49:32 -05:00
* @ brief get a url ( scheme :// domain . tld / u / user ) from a given Diaspora *
* fcontact guid
2016-12-19 23:30:50 -05:00
*
2016-12-20 12:49:32 -05:00
* @ param mixed $fcontact_guid Hexadecimal string guid
2016-12-19 23:30:50 -05:00
*
2016-12-20 12:49:32 -05:00
* @ return string the contact url or null
2016-12-19 23:30:50 -05:00
*/
2016-12-20 14:33:33 -05:00
public static function url_from_contact_guid ( $fcontact_guid ) {
2016-12-20 12:49:32 -05:00
logger ( " fcontact guid is " . $fcontact_guid , LOGGER_DEBUG );
2016-12-19 23:30:50 -05:00
2016-12-20 20:52:42 -05:00
$r = q ( " SELECT `url` FROM `fcontact` WHERE `url` != '' AND `network` = '%s' AND `guid` = '%s' " ,
dbesc ( NETWORK_DIASPORA ),
dbesc ( $fcontact_guid )
);
2016-12-19 23:30:50 -05:00
2016-12-20 12:49:32 -05:00
if ( dbm :: is_result ( $r )) {
2016-12-19 23:30:50 -05:00
return $r [ 0 ][ 'url' ];
}
return null ;
}
2016-03-17 18:44:18 -04:00
/**
* @ 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
*/
2016-12-29 18:27:11 -05:00
private static function contact_by_handle ( $uid , $handle ) {
2017-01-04 14:13:50 -05:00
// First do a direct search on the contact table
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT * FROM `contact` WHERE `uid` = %d AND `addr` = '%s' LIMIT 1 " ,
intval ( $uid ),
dbesc ( $handle )
);
2011-11-12 07:06:33 -05:00
2017-01-06 08:30:12 -05:00
if ( dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
return $r [ 0 ];
2017-01-04 14:13:50 -05:00
} 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 ) {
$r = q ( " SELECT * FROM `contact` WHERE `id` = %d LIMIT 1 " , intval ( $cid ));
if ( dbm :: is_result ( $r )) {
return $r [ 0 ];
}
}
}
2011-08-12 06:01:11 -04:00
2016-03-14 18:11:43 -04:00
$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 )
);
2017-01-07 08:52:30 -05:00
if ( dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
return $r [ 0 ];
2017-01-04 14:13:50 -05:00
}
2013-01-20 08:08:28 -05:00
2017-01-04 14:13:50 -05:00
logger ( " Haven't found contact for user " . $uid . " and handle " . $handle , LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return false ;
}
2011-08-16 02:19:17 -04:00
2016-03-17 18:44:18 -04:00
/**
* @ 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 ?
*/
2016-12-29 18:27:11 -05:00
private static function post_allow ( $importer , $contact , $is_comment = false ) {
2011-08-17 07:24:26 -04:00
// perhaps we were already sharing with this person. Now they're sharing with us.
// That makes us friends.
2016-03-14 18:11:43 -04:00
// Normally this should have handled by getting a request - but this could get lost
2017-04-04 13:47:32 -04:00
if ( $contact [ " rel " ] == CONTACT_IS_FOLLOWER && in_array ( $importer [ " page-flags " ], array ( PAGE_FREELOVE ))) {
2014-03-09 04:19:14 -04:00
q ( " UPDATE `contact` SET `rel` = %d, `writable` = 1 WHERE `id` = %d AND `uid` = %d " ,
2011-08-16 02:19:17 -04:00
intval ( CONTACT_IS_FRIEND ),
2016-03-14 18:11:43 -04:00
intval ( $contact [ " id " ]),
intval ( $importer [ " uid " ])
2011-08-16 02:19:17 -04:00
);
2016-03-14 18:11:43 -04:00
$contact [ " rel " ] = CONTACT_IS_FRIEND ;
logger ( " defining user " . $contact [ " nick " ] . " as friend " );
2011-08-16 02:19:17 -04:00
}
2011-11-12 07:06:33 -05:00
2017-05-02 15:48:11 -04:00
if ( $contact [ " blocked " ] || $contact [ " readonly " ] || $contact [ " archive " ]) {
2016-03-14 18:11:43 -04:00
return false ;
2017-05-02 15:48:11 -04:00
} elseif (( $contact [ " rel " ] == CONTACT_IS_SHARING ) || ( $contact [ " rel " ] == CONTACT_IS_FRIEND )) {
2016-03-14 18:11:43 -04:00
return true ;
2017-05-02 15:48:11 -04:00
} elseif (( $contact [ " rel " ] == CONTACT_IS_FOLLOWER ) && ( $importer [ " page-flags " ] == PAGE_COMMUNITY )) {
return true ;
}
// Messages for the global users and comments are always accepted
if (( $importer [ " uid " ] == 0 ) || $is_comment ) {
2016-03-14 18:11:43 -04:00
return true ;
2017-05-02 15:48:11 -04:00
}
2011-11-12 07:06:33 -05:00
2016-03-14 18:11:43 -04:00
return false ;
2011-08-12 06:01:11 -04:00
}
2013-12-26 19:58:21 -05:00
2016-03-17 18:44:18 -04:00
/**
* @ 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 ?
*
2016-03-27 17:38:35 -04:00
* @ return array The contact data
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function allowed_contact_by_handle ( $importer , $handle , $is_comment = false ) {
2016-03-14 18:11:43 -04:00
$contact = self :: contact_by_handle ( $importer [ " uid " ], $handle );
if ( ! $contact ) {
logger ( " A Contact for handle " . $handle . " and user " . $importer [ " uid " ] . " was not found " );
return false ;
}
2011-08-13 09:52:33 -04:00
2016-03-14 18:11:43 -04:00
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 ;
2011-08-13 09:52:33 -04:00
}
2011-08-19 01:03:58 -04:00
2016-03-17 18:44:18 -04:00
/**
* @ brief Does the message already exists on the system ?
*
* @ param int $uid The user id
* @ param string $guid The guid of the message
2016-03-24 10:59:53 -04:00
*
2016-03-23 04:22:59 -04:00
* @ return int | bool message id if the message already was stored into the system - or false .
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function message_exists ( $uid , $guid ) {
2017-01-06 08:30:12 -05:00
$r = q ( " SELECT `id` FROM `item` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1 " ,
2016-03-14 18:11:43 -04:00
intval ( $uid ),
dbesc ( $guid )
);
2011-08-16 03:52:34 -04:00
2017-01-06 08:30:12 -05:00
if ( dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
logger ( " message " . $guid . " already exists for user " . $uid );
2016-03-23 04:22:59 -04:00
return $r [ 0 ][ " id " ];
2016-03-14 18:11:43 -04:00
}
2011-08-12 06:01:11 -04:00
2016-03-14 18:11:43 -04:00
return false ;
2012-01-04 17:30:25 -05:00
}
2016-03-17 18:44:18 -04:00
/**
* @ brief Checks for links to posts in a message
*
* @ param array $item The item array
*/
2016-12-29 18:27:11 -05:00
private static function fetch_guid ( $item ) {
2016-03-14 18:11:43 -04:00
preg_replace_callback ( " & \ [url=/posts/([^ \ [ \ ]]*) \ ](.*) \ [ \ /url \ ]&Usi " ,
function ( $match ) use ( $item ){
return ( self :: fetch_guid_sub ( $match , $item ));
}, $item [ " body " ]);
2012-05-18 01:44:52 -04:00
}
2016-12-19 23:30:50 -05:00
/**
2016-12-20 12:49:32 -05:00
* @ brief Checks for relative / people /* links in an item body to match local
* contacts or prepends the remote host taken from the author link .
2016-12-19 23:30:50 -05:00
*
* @ param string $body The item body to replace links from
* @ param string $author_link The author link for missing local contact fallback
2016-12-20 12:49:32 -05:00
*
* @ return the replaced string
2016-12-19 23:30:50 -05:00
*/
public function replace_people_guid ( $body , $author_link ) {
$return = preg_replace_callback ( " & \ [url=/people/([^ \ [ \ ]]*) \ ](.*) \ [ \ /url \ ]&Usi " ,
2016-12-20 12:49:32 -05:00
function ( $match ) use ( $author_link ) {
2016-12-19 23:30:50 -05:00
// $match
// 0 => '[url=/people/0123456789abcdef]Foo Bar[/url]'
// 1 => '0123456789abcdef'
// 2 => 'Foo Bar'
2016-12-20 14:33:33 -05:00
$handle = self :: url_from_contact_guid ( $match [ 1 ]);
2016-12-19 23:30:50 -05:00
if ( $handle ) {
$return = '@[url=' . $handle . ']' . $match [ 2 ] . '[/url]' ;
2016-12-20 14:33:33 -05:00
} else {
2016-12-19 23:30:50 -05:00
// 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 ;
}
2016-03-17 18:44:18 -04:00
/**
2016-03-21 14:58:45 -04:00
* @ brief sub function of " fetch_guid " which checks for links in messages
2016-03-17 18:44:18 -04:00
*
* @ param array $match array containing a link that has to be checked for a message link
* @ param array $item The item array
*/
2016-12-29 18:27:11 -05:00
private static function fetch_guid_sub ( $match , $item ) {
2016-03-14 18:11:43 -04:00
if ( ! self :: store_by_guid ( $match [ 1 ], $item [ " author-link " ]))
self :: store_by_guid ( $match [ 1 ], $item [ " owner-link " ]);
2011-08-13 09:52:33 -04:00
}
2012-01-04 17:30:25 -05:00
2016-03-17 18:44:18 -04:00
/**
* @ 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
*/
2016-12-29 18:27:11 -05:00
private static function store_by_guid ( $guid , $server , $uid = 0 ) {
2016-03-14 18:11:43 -04:00
$serverparts = parse_url ( $server );
$server = $serverparts [ " scheme " ] . " :// " . $serverparts [ " host " ];
2012-01-04 17:30:25 -05:00
2016-03-14 18:11:43 -04:00
logger ( " Trying to fetch item " . $guid . " from " . $server , LOGGER_DEBUG );
2012-01-04 17:30:25 -05:00
2016-03-14 18:11:43 -04:00
$msg = self :: message ( $guid , $server );
2014-04-04 04:52:53 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $msg )
return false ;
2012-01-04 17:30:25 -05:00
2016-03-14 18:11:43 -04:00
logger ( " Successfully fetched item " . $guid . " from " . $server , LOGGER_DEBUG );
2012-01-05 16:25:43 -05:00
2016-03-14 18:11:43 -04:00
// Now call the dispatcher
return self :: dispatch_public ( $msg );
2012-01-04 17:30:25 -05:00
}
2011-08-19 01:03:58 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Fetches a message from a server
2016-03-17 18:44:18 -04:00
*
* @ param string $guid message guid
2016-03-18 03:07:23 -04:00
* @ param string $server The url of the server
* @ param int $level Endless loop prevention
2016-03-17 18:44:18 -04:00
*
2016-03-21 14:58:45 -04:00
* @ return array
* 'message' => The message XML
* 'author' => The author handle
* 'key' => The public key of the author
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function message ( $guid , $server , $level = 0 ) {
2011-08-10 08:10:48 -04:00
2016-03-14 18:11:43 -04:00
if ( $level > 5 )
return false ;
2013-01-20 08:08:28 -05:00
2016-06-30 16:18:48 -04:00
// This will work for new Diaspora servers and Friendica servers from 3.5
$source_url = $server . " /fetch/post/ " . $guid ;
logger ( " Fetch post from " . $source_url , LOGGER_DEBUG );
$envelope = fetch_url ( $source_url );
2017-04-04 13:47:32 -04:00
if ( $envelope ) {
2016-06-30 16:18:48 -04:00
logger ( " Envelope was fetched. " , LOGGER_DEBUG );
$x = self :: verify_magic_envelope ( $envelope );
2016-06-30 16:58:56 -04:00
if ( ! $x )
2016-06-30 16:18:48 -04:00
logger ( " Envelope could not be verified. " , LOGGER_DEBUG );
2016-06-30 16:58:56 -04:00
else
logger ( " Envelope was verified. " , LOGGER_DEBUG );
} else
$x = false ;
// This will work for older Diaspora and Friendica servers
if ( ! $x ) {
2016-06-30 16:18:48 -04:00
$source_url = $server . " /p/ " . $guid . " .xml " ;
logger ( " Fetch post from " . $source_url , LOGGER_DEBUG );
$x = fetch_url ( $source_url );
2017-04-04 13:47:32 -04:00
if ( ! $x )
2016-06-30 16:18:48 -04:00
return false ;
}
2015-08-09 08:28:59 -04:00
2016-03-14 18:11:43 -04:00
$source_xml = parse_xml_string ( $x , false );
2015-08-09 08:28:59 -04:00
2016-03-14 18:11:43 -04:00
if ( ! is_object ( $source_xml ))
return false ;
2012-02-22 22:56:28 -05:00
2016-03-14 18:11:43 -04:00
if ( $source_xml -> post -> reshare ) {
// Reshare of a reshare - old Diaspora version
2016-06-30 16:42:46 -04:00
logger ( " Message is a reshare " , LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return self :: message ( $source_xml -> post -> reshare -> root_guid , $server , ++ $level );
} elseif ( $source_xml -> getName () == " reshare " ) {
// Reshare of a reshare - new Diaspora version
2016-06-30 16:42:46 -04:00
logger ( " Message is a new reshare " , LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return self :: message ( $source_xml -> root_guid , $server , ++ $level );
}
2015-04-24 18:50:48 -04:00
2016-03-14 18:11:43 -04:00
$author = " " ;
2015-04-06 06:26:31 -04:00
2016-03-14 18:11:43 -04:00
// 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 AND ( $source_xml -> getName () == " status_message " ))
$author = ( string ) $source_xml -> author ;
2015-04-06 06:26:31 -04:00
2016-03-14 18:11:43 -04:00
// If this isn't a "status_message" then quit
2016-06-30 16:42:46 -04:00
if ( ! $author ) {
logger ( " Message doesn't seem to be a status message " , LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return false ;
2016-06-30 16:42:46 -04:00
}
2015-05-25 13:07:59 -04:00
2016-03-14 18:11:43 -04:00
$msg = array ( " message " => $x , " author " => $author );
2015-05-25 13:07:59 -04:00
2016-03-14 18:11:43 -04:00
$msg [ " key " ] = self :: key ( $msg [ " author " ]);
2015-04-06 06:26:31 -04:00
2016-03-14 18:11:43 -04:00
return $msg ;
}
2012-02-22 22:56:28 -05:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Fetches the item record of a given guid
2016-03-17 18:44:18 -04:00
*
* @ param int $uid The user id
* @ param string $guid message guid
2016-03-18 03:07:23 -04:00
* @ param string $author The handle of the item
2016-03-18 17:28:20 -04:00
* @ param array $contact The contact of the item owner
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return array the item record
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function parent_item ( $uid , $guid , $author , $contact ) {
2016-03-14 18:11:43 -04:00
$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 ));
2016-01-21 07:57:21 -05:00
2017-04-04 13:47:32 -04:00
if ( ! $r ) {
2016-03-14 18:11:43 -04:00
$result = self :: store_by_guid ( $guid , $contact [ " url " ], $uid );
2016-01-21 07:57:21 -05:00
2016-03-14 18:11:43 -04:00
if ( ! $result ) {
$person = self :: person_by_handle ( $author );
$result = self :: store_by_guid ( $guid , $person [ " url " ], $uid );
}
2016-01-21 07:21:47 -05:00
2016-03-14 18:11:43 -04:00
if ( $result ) {
logger ( " Fetched missing item " . $guid . " - result: " . $result , LOGGER_DEBUG );
2016-01-21 07:21:47 -05:00
2016-03-14 18:11:43 -04:00
$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 ));
}
}
2016-01-21 07:21:47 -05:00
2016-03-14 18:11:43 -04:00
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 ];
}
}
2011-08-10 08:10:48 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief returns contact details
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ param array $contact The default contact if the person isn ' t found
* @ param array $person The record of the person
2016-03-17 18:44:18 -04:00
* @ param int $uid The user id
*
2016-03-27 17:38:35 -04:00
* @ return array
* 'cid' => contact id
* 'network' => network type
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function author_contact_by_url ( $contact , $person , $uid ) {
2011-08-16 02:19:17 -04:00
2016-11-19 15:10:29 -05:00
$r = q ( " SELECT `id`, `network`, `url` FROM `contact` WHERE `nurl` = '%s' AND `uid` = %d LIMIT 1 " ,
2016-03-14 18:11:43 -04:00
dbesc ( normalise_link ( $person [ " url " ])), intval ( $uid ));
if ( $r ) {
$cid = $r [ 0 ][ " id " ];
$network = $r [ 0 ][ " network " ];
2016-11-19 15:10:29 -05:00
// We are receiving content from a user that is about to be terminated
// This means the user is vital, so we remove a possible termination date.
unmark_for_death ( $contact );
2016-03-14 18:11:43 -04:00
} else {
$cid = $contact [ " id " ];
$network = NETWORK_DIASPORA ;
}
2012-07-09 01:32:04 -04:00
2016-11-19 15:10:29 -05:00
return array ( " cid " => $cid , " network " => $network );
2015-08-09 14:39:11 -04:00
}
2011-08-16 02:19:17 -04:00
2016-03-17 18:44:18 -04:00
/**
* @ brief Is the profile a hubzilla profile ?
*
* @ param string $url The profile link
*
* @ return bool is it a hubzilla server ?
*/
2016-03-14 18:11:43 -04:00
public static function is_redmatrix ( $url ) {
return ( strstr ( $url , " /channel/ " ));
2011-08-16 02:19:17 -04:00
}
2016-03-17 18:44:18 -04:00
/**
* @ brief Generate a post link with a given handle and message guid
*
2016-03-18 03:07:23 -04:00
* @ param string $addr The user handle
2016-03-17 18:44:18 -04:00
* @ param string $guid message guid
*
* @ return string the post link
*/
2016-12-29 18:27:11 -05:00
private static function plink ( $addr , $guid ) {
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT `url`, `nick`, `network` FROM `fcontact` WHERE `addr`='%s' LIMIT 1 " , dbesc ( $addr ));
2011-08-13 19:39:59 -04:00
2016-03-14 18:11:43 -04:00
// Fallback
if ( ! $r )
return " https:// " . substr ( $addr , strpos ( $addr , " @ " ) + 1 ) . " /posts/ " . $guid ;
2011-08-13 19:39:59 -04:00
2016-03-14 18:11:43 -04:00
// 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 ( $s )
$r [ 0 ][ " network " ] = $s [ 0 ][ " network " ];
2011-08-13 19:39:59 -04:00
2016-03-14 18:11:43 -04:00
if ( $r [ 0 ][ " network " ] == NETWORK_DFRN )
return ( str_replace ( " /profile/ " . $r [ 0 ][ " nick " ] . " / " , " /display/ " . $guid , $r [ 0 ][ " url " ] . " / " ));
2011-10-05 23:48:00 -04:00
2016-03-14 18:11:43 -04:00
if ( self :: is_redmatrix ( $r [ 0 ][ " url " ]))
return $r [ 0 ][ " url " ] . " /?f=&mid= " . $guid ;
2015-05-25 07:27:45 -04:00
2016-03-14 18:11:43 -04:00
return " https:// " . substr ( $addr , strpos ( $addr , " @ " ) + 1 ) . " /posts/ " . $guid ;
2015-05-25 07:27:45 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes an account deletion
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool Success
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_account_deletion ( $importer , $data ) {
2016-04-19 01:39:17 -04:00
/// @todo Account deletion should remove the contact from the global contacts as well
2016-03-14 18:11:43 -04:00
$author = notags ( unxmlify ( $data -> author ));
2011-10-05 23:48:00 -04:00
2016-03-14 18:11:43 -04:00
$contact = self :: contact_by_handle ( $importer [ " uid " ], $author );
if ( ! $contact ) {
logger ( " cannot find contact for author: " . $author );
return false ;
2011-12-06 18:24:01 -05:00
}
2015-02-02 18:29:21 -05:00
2016-03-14 18:11:43 -04:00
// We now remove the contact
contact_remove ( $contact [ " id " ]);
return true ;
}
2015-02-02 18:29:21 -05:00
2016-06-20 16:48:55 -04:00
/**
* @ 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
2016-12-27 09:37:48 -05:00
* @ param boolean $onlyfound Only return uri when found in the database
2016-06-20 16:48:55 -04:00
*
* @ return string The constructed uri or the one from our database
*/
2016-12-27 09:37:48 -05:00
private static function get_uri_from_guid ( $author , $guid , $onlyfound = false ) {
2016-06-20 16:48:55 -04:00
$r = q ( " SELECT `uri` FROM `item` WHERE `guid` = '%s' LIMIT 1 " , dbesc ( $guid ));
2016-12-27 09:37:48 -05:00
if ( dbm :: is_result ( $r )) {
2016-06-20 16:48:55 -04:00
return $r [ 0 ][ " uri " ];
2016-12-27 09:37:48 -05:00
} elseif ( ! $onlyfound ) {
2016-06-20 16:48:55 -04:00
return $author . " : " . $guid ;
2016-12-27 09:37:48 -05:00
}
return " " ;
2016-06-20 16:48:55 -04:00
}
2016-12-27 07:59:15 -05:00
/**
* @ 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 ));
2016-12-30 05:03:02 -05:00
if ( dbm :: is_result ( $r )) {
2016-12-27 07:59:15 -05:00
return $r [ 0 ][ " guid " ];
2016-12-30 05:03:02 -05:00
} else {
2016-12-27 07:59:15 -05:00
return false ;
2016-12-30 05:03:02 -05:00
}
2016-12-27 07:59:15 -05:00
}
2017-05-02 14:42:01 -04:00
/**
* @ brief Find the best importer for a comment
*
* @ param array $importer Array of the importer user
* @ param string $guid The guid of the item
*
* @ return array the importer that fits the best
*/
private static function importer_for_comment ( $importer , $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 );
2017-05-02 15:48:11 -04:00
$contact = dba :: fetch_first ( " SELECT `uid`, `page-flags` FROM `contact` WHERE `self` AND `uid` = ? " , $item [ 'uid' ]);
2017-05-02 14:42:01 -04:00
if ( dbm :: is_result ( $contact )) {
$importer = $contact ;
}
}
return $importer ;
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes an incoming comment
2016-03-17 18:44:18 -04:00
*
* @ 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
*/
2016-12-29 18:27:11 -05:00
private static function receive_comment ( $importer , $sender , $data , $xml ) {
2016-03-14 18:11:43 -04:00
$guid = notags ( unxmlify ( $data -> guid ));
$parent_guid = notags ( unxmlify ( $data -> parent_guid ));
$text = unxmlify ( $data -> text );
$author = notags ( unxmlify ( $data -> author ));
2015-02-01 15:54:44 -05:00
2016-12-20 12:49:50 -05:00
if ( isset ( $data -> created_at )) {
2016-07-14 01:20:20 -04:00
$created_at = datetime_convert ( " UTC " , " UTC " , notags ( unxmlify ( $data -> created_at )));
2016-12-20 12:49:50 -05:00
} else {
2016-07-14 01:20:20 -04:00
$created_at = datetime_convert ();
2016-12-20 12:49:50 -05:00
}
2016-07-14 01:20:20 -04:00
2016-12-27 09:37:48 -05:00
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 = " " ;
}
2017-05-02 14:42:01 -04:00
// Find the best importer when there was no importer found
if ( $importer [ " uid " ] == 0 ) {
$importer = self :: importer_for_comment ( $importer , $parent_guid );
}
2016-03-14 18:11:43 -04:00
$contact = self :: allowed_contact_by_handle ( $importer , $sender , true );
2016-12-20 12:49:50 -05:00
if ( ! $contact ) {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-20 12:49:50 -05:00
}
2015-05-09 13:39:47 -04:00
2016-03-23 04:22:59 -04:00
$message_id = self :: message_exists ( $importer [ " uid " ], $guid );
2016-12-20 12:49:50 -05:00
if ( $message_id ) {
2016-03-23 04:22:59 -04:00
return $message_id ;
2016-12-20 12:49:50 -05:00
}
2015-02-02 18:29:21 -05:00
2016-03-14 18:11:43 -04:00
$parent_item = self :: parent_item ( $importer [ " uid " ], $parent_guid , $author , $contact );
2016-12-20 12:49:50 -05:00
if ( ! $parent_item ) {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-20 12:49:50 -05:00
}
2015-02-01 15:54:44 -05:00
2016-03-14 18:11:43 -04:00
$person = self :: person_by_handle ( $author );
if ( ! is_array ( $person )) {
logger ( " unable to find author details " );
return false ;
}
2015-02-01 15:54:44 -05:00
2016-03-14 18:11:43 -04:00
// Fetch the contact id - if we know this contact
$author_contact = self :: author_contact_by_url ( $contact , $person , $importer [ " uid " ]);
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
$datarray = array ();
2015-02-01 15:54:44 -05:00
2016-03-14 18:11:43 -04:00
$datarray [ " uid " ] = $importer [ " uid " ];
$datarray [ " contact-id " ] = $author_contact [ " cid " ];
$datarray [ " network " ] = $author_contact [ " network " ];
2015-02-01 15:54:44 -05:00
2016-03-14 18:11:43 -04:00
$datarray [ " author-name " ] = $person [ " name " ];
$datarray [ " author-link " ] = $person [ " url " ];
$datarray [ " author-avatar " ] = (( x ( $person , " thumb " )) ? $person [ " thumb " ] : $person [ " photo " ]);
2015-02-01 15:54:44 -05:00
2016-03-14 18:11:43 -04:00
$datarray [ " owner-name " ] = $contact [ " name " ];
$datarray [ " owner-link " ] = $contact [ " url " ];
$datarray [ " owner-avatar " ] = (( x ( $contact , " thumb " )) ? $contact [ " thumb " ] : $contact [ " photo " ]);
2015-09-05 06:11:14 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " guid " ] = $guid ;
2016-06-20 16:48:55 -04:00
$datarray [ " uri " ] = self :: get_uri_from_guid ( $author , $guid );
2015-09-05 06:11:14 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " type " ] = " remote-comment " ;
$datarray [ " verb " ] = ACTIVITY_POST ;
$datarray [ " gravity " ] = GRAVITY_COMMENT ;
2016-12-27 09:37:48 -05:00
if ( $thr_uri != " " ) {
$datarray [ " parent-uri " ] = $thr_uri ;
} else {
$datarray [ " parent-uri " ] = $parent_item [ " uri " ];
}
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " object-type " ] = ACTIVITY_OBJ_COMMENT ;
2017-04-27 16:38:46 -04:00
$datarray [ " protocol " ] = PROTOCOL_DIASPORA ;
$datarray [ " source " ] = $xml ;
2015-02-01 15:54:44 -05:00
2016-07-14 01:20:20 -04:00
$datarray [ " changed " ] = $datarray [ " created " ] = $datarray [ " edited " ] = $created_at ;
2016-12-20 12:49:32 -05:00
$body = diaspora2bb ( $text );
2015-02-02 14:24:19 -05:00
2016-12-20 12:49:32 -05:00
$datarray [ " body " ] = self :: replace_people_guid ( $body , $person [ " url " ]);
2015-02-02 14:24:19 -05:00
2016-03-14 18:11:43 -04:00
self :: fetch_guid ( $datarray );
2015-02-01 15:54:44 -05:00
2016-03-14 18:11:43 -04:00
$message_id = item_store ( $datarray );
2015-01-24 18:01:58 -05:00
2016-12-20 12:49:50 -05:00
if ( $message_id ) {
2016-03-14 18:11:43 -04:00
logger ( " Stored comment " . $datarray [ " guid " ] . " with message id " . $message_id , LOGGER_DEBUG );
2016-12-20 12:49:50 -05:00
}
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
// If we are the origin of the parent we store the original data and notify our followers
2017-04-04 13:47:32 -04:00
if ( $message_id AND $parent_item [ " origin " ]) {
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
// 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.
q ( " INSERT INTO `sign` (`iid`,`signed_text`) VALUES (%d,'%s') " ,
intval ( $message_id ),
dbesc ( json_encode ( $data ))
);
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
// notify others
2016-08-03 12:24:22 -04:00
proc_run ( PRIORITY_HIGH , " include/notifier.php " , " comment-import " , $message_id );
2016-03-14 18:11:43 -04:00
}
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
return $message_id ;
}
2015-01-24 18:01:58 -05:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief processes and stores private messages
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
2016-03-18 17:28:20 -04:00
* @ param array $contact The contact of the message
2016-03-17 18:44:18 -04:00
* @ param object $data The message object
2016-03-18 03:07:23 -04:00
* @ 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
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return bool " true " if it was successful
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_conversation_message ( $importer , $contact , $data , $msg , $mesg , $conversation ) {
2016-03-14 18:11:43 -04:00
$guid = notags ( unxmlify ( $data -> guid ));
$subject = notags ( unxmlify ( $data -> subject ));
$author = notags ( unxmlify ( $data -> author ));
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
$msg_guid = notags ( unxmlify ( $mesg -> guid ));
$msg_parent_guid = notags ( unxmlify ( $mesg -> parent_guid ));
$msg_parent_author_signature = notags ( unxmlify ( $mesg -> parent_author_signature ));
$msg_author_signature = notags ( unxmlify ( $mesg -> author_signature ));
$msg_text = unxmlify ( $mesg -> text );
$msg_created_at = datetime_convert ( " UTC " , " UTC " , notags ( unxmlify ( $mesg -> created_at )));
// "diaspora_handle" is the element name from the old version
// "author" is the element name from the new version
2016-12-20 12:49:50 -05:00
if ( $mesg -> author ) {
2016-03-14 18:11:43 -04:00
$msg_author = notags ( unxmlify ( $mesg -> author ));
2016-12-20 12:49:50 -05:00
} elseif ( $mesg -> diaspora_handle ) {
2016-03-14 18:11:43 -04:00
$msg_author = notags ( unxmlify ( $mesg -> diaspora_handle ));
2016-12-20 12:49:50 -05:00
} else {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-20 12:49:50 -05:00
}
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
$msg_conversation_guid = notags ( unxmlify ( $mesg -> conversation_guid ));
2015-01-24 18:01:58 -05:00
2016-12-20 12:49:50 -05:00
if ( $msg_conversation_guid != $guid ) {
2016-03-14 18:11:43 -04:00
logger ( " message conversation guid does not belong to the current conversation. " );
return false ;
}
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
$body = diaspora2bb ( $msg_text );
$message_uri = $msg_author . " : " . $msg_guid ;
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
$author_signed_data = $msg_guid . " ; " . $msg_parent_guid . " ; " . $msg_text . " ; " . unxmlify ( $mesg -> created_at ) . " ; " . $msg_author . " ; " . $msg_conversation_guid ;
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
$author_signature = base64_decode ( $msg_author_signature );
2015-05-25 07:27:45 -04:00
2016-12-20 12:49:50 -05:00
if ( strcasecmp ( $msg_author , $msg [ " author " ]) == 0 ) {
2016-03-14 18:11:43 -04:00
$person = $contact ;
$key = $msg [ " key " ];
} else {
$person = self :: person_by_handle ( $msg_author );
2015-01-24 18:01:58 -05:00
2016-12-20 12:49:50 -05:00
if ( is_array ( $person ) && x ( $person , " pubkey " )) {
2016-03-14 18:11:43 -04:00
$key = $person [ " pubkey " ];
2016-12-20 12:49:50 -05:00
} else {
2016-03-14 18:11:43 -04:00
logger ( " unable to find author details " );
return false ;
}
}
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
if ( ! rsa_verify ( $author_signed_data , $author_signature , $key , " sha256 " )) {
logger ( " verification failed. " );
return false ;
}
2015-01-24 18:01:58 -05:00
2016-12-20 12:49:50 -05:00
if ( $msg_parent_author_signature ) {
2016-03-14 18:11:43 -04:00
$owner_signed_data = $msg_guid . " ; " . $msg_parent_guid . " ; " . $msg_text . " ; " . unxmlify ( $mesg -> created_at ) . " ; " . $msg_author . " ; " . $msg_conversation_guid ;
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
$parent_author_signature = base64_decode ( $msg_parent_author_signature );
2015-03-01 14:40:38 -05:00
2016-03-14 18:11:43 -04:00
$key = $msg [ " key " ];
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
if ( ! rsa_verify ( $owner_signed_data , $parent_author_signature , $key , " sha256 " )) {
logger ( " owner verification failed. " );
return false ;
}
}
2011-10-18 18:56:35 -04:00
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT `id` FROM `mail` WHERE `uri` = '%s' LIMIT 1 " ,
dbesc ( $message_uri )
);
2016-12-14 03:42:36 -05:00
if ( dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
logger ( " duplicate message already delivered. " , LOGGER_DEBUG );
return false ;
}
2011-10-20 05:07:38 -04:00
2016-03-14 18:11:43 -04:00
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 )
);
2011-10-18 18:56:35 -04:00
2016-03-14 18:11:43 -04:00
q ( " UPDATE `conv` SET `updated` = '%s' WHERE `id` = %d " ,
dbesc ( datetime_convert ()),
intval ( $conversation [ " id " ])
);
2011-10-20 05:07:38 -04:00
2016-03-14 18:11:43 -04:00
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 "
));
2016-03-18 03:07:23 -04:00
return true ;
2012-07-09 01:32:04 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes new private messages ( answers to private messages are processed elsewhere )
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
2016-03-18 03:07:23 -04:00
* @ param array $msg Array of the processed message , author handle and key
2016-03-17 18:44:18 -04:00
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool Success
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_conversation ( $importer , $msg , $data ) {
2016-03-14 18:11:43 -04:00
$guid = notags ( unxmlify ( $data -> guid ));
$subject = notags ( unxmlify ( $data -> subject ));
$created_at = datetime_convert ( " UTC " , " UTC " , notags ( unxmlify ( $data -> created_at )));
$author = notags ( unxmlify ( $data -> author ));
$participants = notags ( unxmlify ( $data -> participants ));
2011-10-18 18:56:35 -04:00
2016-03-14 18:11:43 -04:00
$messages = $data -> message ;
2011-10-18 18:56:35 -04:00
2016-03-14 18:11:43 -04:00
if ( ! count ( $messages )) {
logger ( " empty conversation " );
return false ;
2015-05-03 16:15:26 -04:00
}
2014-03-23 13:50:28 -04:00
2016-03-14 18:11:43 -04:00
$contact = self :: allowed_contact_by_handle ( $importer , $msg [ " author " ], true );
if ( ! $contact )
return false ;
2014-03-23 13:50:28 -04:00
2016-03-14 18:11:43 -04:00
$conversation = null ;
2014-03-23 13:50:28 -04:00
2016-03-14 18:11:43 -04:00
$c = q ( " SELECT * FROM `conv` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1 " ,
intval ( $importer [ " uid " ]),
dbesc ( $guid )
);
2017-04-04 13:47:32 -04:00
if ( $c )
2016-03-14 18:11:43 -04:00
$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 ),
2016-07-14 01:20:20 -04:00
dbesc ( $created_at ),
2016-03-14 18:11:43 -04:00
dbesc ( datetime_convert ()),
dbesc ( $subject ),
dbesc ( $participants )
);
2017-04-04 13:47:32 -04:00
if ( $r )
2016-03-14 18:11:43 -04:00
$c = q ( " SELECT * FROM `conv` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1 " ,
intval ( $importer [ " uid " ]),
dbesc ( $guid )
);
2017-04-04 13:47:32 -04:00
if ( $c )
2016-03-14 18:11:43 -04:00
$conversation = $c [ 0 ];
2015-01-24 18:01:58 -05:00
}
2016-03-14 18:11:43 -04:00
if ( ! $conversation ) {
logger ( " unable to create conversation. " );
return ;
2014-03-23 13:50:28 -04:00
}
2017-04-04 13:47:32 -04:00
foreach ( $messages as $mesg )
2016-03-14 18:11:43 -04:00
self :: receive_conversation_message ( $importer , $contact , $data , $msg , $mesg , $conversation );
2011-10-18 18:56:35 -04:00
2016-03-14 18:11:43 -04:00
return true ;
2012-11-17 10:27:49 -05:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Creates the body for a " like " message
2016-03-17 18:44:18 -04:00
*
2016-03-18 17:28:20 -04:00
* @ param array $contact The contact that send us the " like "
* @ param array $parent_item The item array of the parent item
2016-03-17 18:44:18 -04:00
* @ param string $guid message guid
*
2016-03-18 17:28:20 -04:00
* @ return string the body
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function construct_like_body ( $contact , $parent_item , $guid ) {
2016-03-14 18:11:43 -04:00
$bodyverb = t ( '%1$s likes %2$s\'s %3$s' );
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
$ulink = " [url= " . $contact [ " url " ] . " ] " . $contact [ " name " ] . " [/url] " ;
$alink = " [url= " . $parent_item [ " author-link " ] . " ] " . $parent_item [ " author-name " ] . " [/url] " ;
$plink = " [url= " . App :: get_baseurl () . " /display/ " . urlencode ( $guid ) . " ] " . t ( " status " ) . " [/url] " ;
2015-01-24 18:01:58 -05:00
2016-03-14 18:11:43 -04:00
return sprintf ( $bodyverb , $ulink , $alink , $plink );
2015-01-24 18:01:58 -05:00
}
2011-10-18 18:56:35 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Creates a XML object for a " like "
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
2016-03-18 17:28:20 -04:00
* @ param array $parent_item The item array of the parent item
2016-03-17 18:44:18 -04:00
*
2016-03-18 17:28:20 -04:00
* @ return string The XML
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function construct_like_object ( $importer , $parent_item ) {
2016-03-14 18:11:43 -04:00
$objtype = ACTIVITY_OBJ_NOTE ;
$link = '<link rel="alternate" type="text/html" href="' . App :: get_baseurl () . " /display/ " . $importer [ " nickname " ] . " / " . $parent_item [ " id " ] . '" />' ;
$parent_body = $parent_item [ " body " ];
2011-10-18 18:56:35 -04:00
2016-03-14 18:11:43 -04:00
$xmldata = array ( " object " => array ( " type " => $objtype ,
" local " => " 1 " ,
" id " => $parent_item [ " uri " ],
" link " => $link ,
" title " => " " ,
" content " => $parent_body ));
2011-10-18 18:56:35 -04:00
2016-03-14 18:11:43 -04:00
return xml :: from_array ( $xmldata , $xml , true );
}
2011-10-18 18:56:35 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes " like " messages
2016-03-17 18:44:18 -04:00
*
* @ 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
*/
2016-12-29 18:27:11 -05:00
private static function receive_like ( $importer , $sender , $data ) {
2016-03-14 18:11:43 -04:00
$positive = notags ( unxmlify ( $data -> positive ));
$guid = notags ( unxmlify ( $data -> guid ));
$parent_type = notags ( unxmlify ( $data -> parent_type ));
$parent_guid = notags ( unxmlify ( $data -> parent_guid ));
$author = notags ( unxmlify ( $data -> author ));
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
// 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 ;
2011-10-17 20:39:25 -04:00
2017-05-02 15:48:11 -04:00
// Find the best importer when there was no importer found
if ( $importer [ " uid " ] == 0 ) {
$importer = self :: importer_for_comment ( $importer , $parent_guid );
}
2016-03-14 18:11:43 -04:00
$contact = self :: allowed_contact_by_handle ( $importer , $sender , true );
if ( ! $contact )
return false ;
2012-07-09 01:32:04 -04:00
2016-03-23 04:22:59 -04:00
$message_id = self :: message_exists ( $importer [ " uid " ], $guid );
if ( $message_id )
return $message_id ;
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
$parent_item = self :: parent_item ( $importer [ " uid " ], $parent_guid , $author , $contact );
if ( ! $parent_item )
return false ;
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
$person = self :: person_by_handle ( $author );
if ( ! is_array ( $person )) {
logger ( " unable to find author details " );
return false ;
}
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
// Fetch the contact id - if we know this contact
$author_contact = self :: author_contact_by_url ( $contact , $person , $importer [ " uid " ]);
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
// "positive" = "false" would be a Dislike - wich isn't currently supported by Diaspora
// We would accept this anyhow.
2016-03-24 19:49:18 -04:00
if ( $positive == " true " )
2016-03-14 18:11:43 -04:00
$verb = ACTIVITY_LIKE ;
else
$verb = ACTIVITY_DISLIKE ;
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
$datarray = array ();
2011-10-17 20:39:25 -04:00
2017-04-28 02:03:04 -04:00
$datarray [ " protocol " ] = PROTOCOL_DIASPORA ;
2016-03-14 18:11:43 -04:00
$datarray [ " uid " ] = $importer [ " uid " ];
$datarray [ " contact-id " ] = $author_contact [ " cid " ];
$datarray [ " network " ] = $author_contact [ " network " ];
2011-10-17 20:39:25 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " author-name " ] = $person [ " name " ];
$datarray [ " author-link " ] = $person [ " url " ];
$datarray [ " author-avatar " ] = (( x ( $person , " thumb " )) ? $person [ " thumb " ] : $person [ " photo " ]);
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " owner-name " ] = $contact [ " name " ];
$datarray [ " owner-link " ] = $contact [ " url " ];
$datarray [ " owner-avatar " ] = (( x ( $contact , " thumb " )) ? $contact [ " thumb " ] : $contact [ " photo " ]);
2011-08-16 02:19:17 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " guid " ] = $guid ;
2016-06-20 16:48:55 -04:00
$datarray [ " uri " ] = self :: get_uri_from_guid ( $author , $guid );
2011-08-16 02:19:17 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " type " ] = " activity " ;
$datarray [ " verb " ] = $verb ;
$datarray [ " gravity " ] = GRAVITY_LIKE ;
$datarray [ " parent-uri " ] = $parent_item [ " uri " ];
2011-08-16 02:19:17 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " object-type " ] = ACTIVITY_OBJ_NOTE ;
$datarray [ " object " ] = self :: construct_like_object ( $importer , $parent_item );
2011-08-26 20:52:24 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " body " ] = self :: construct_like_body ( $contact , $parent_item , $guid );
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
$message_id = item_store ( $datarray );
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
if ( $message_id )
logger ( " Stored like " . $datarray [ " guid " ] . " with message id " . $message_id , LOGGER_DEBUG );
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
// If we are the origin of the parent we store the original data and notify our followers
2017-04-04 13:47:32 -04:00
if ( $message_id AND $parent_item [ " origin " ]) {
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
// 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.
q ( " INSERT INTO `sign` (`iid`,`signed_text`) VALUES (%d,'%s') " ,
intval ( $message_id ),
dbesc ( json_encode ( $data ))
2015-05-09 13:39:47 -04:00
);
2016-03-14 18:11:43 -04:00
// notify others
2016-08-03 12:24:22 -04:00
proc_run ( PRIORITY_HIGH , " include/notifier.php " , " comment-import " , $message_id );
2015-05-09 13:39:47 -04:00
}
2016-03-14 18:11:43 -04:00
return $message_id ;
2011-08-17 07:24:26 -04:00
}
2011-08-13 22:03:59 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes private messages
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool Success ?
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_message ( $importer , $data ) {
2016-03-14 18:11:43 -04:00
$guid = notags ( unxmlify ( $data -> guid ));
$parent_guid = notags ( unxmlify ( $data -> parent_guid ));
$text = unxmlify ( $data -> text );
$created_at = datetime_convert ( " UTC " , " UTC " , notags ( unxmlify ( $data -> created_at )));
$author = notags ( unxmlify ( $data -> author ));
$conversation_guid = notags ( unxmlify ( $data -> conversation_guid ));
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
$contact = self :: allowed_contact_by_handle ( $importer , $author , true );
2016-12-20 12:49:50 -05:00
if ( ! $contact ) {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-20 12:49:50 -05:00
}
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
$conversation = null ;
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
$c = q ( " SELECT * FROM `conv` WHERE `uid` = %d AND `guid` = '%s' LIMIT 1 " ,
intval ( $importer [ " uid " ]),
dbesc ( $conversation_guid )
);
2016-12-20 12:49:50 -05:00
if ( $c ) {
2016-03-14 18:11:43 -04:00
$conversation = $c [ 0 ];
2016-12-20 12:49:50 -05:00
} else {
2016-03-14 18:11:43 -04:00
logger ( " conversation not available. " );
return false ;
}
2012-06-09 15:54:21 -04:00
2016-03-14 18:11:43 -04:00
$message_uri = $author . " : " . $guid ;
2012-06-09 15:54:21 -04:00
2016-03-14 18:11:43 -04:00
$person = self :: person_by_handle ( $author );
if ( ! $person ) {
logger ( " unable to find author details " );
return false ;
2011-08-17 07:24:26 -04:00
}
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT `id` FROM `mail` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1 " ,
dbesc ( $message_uri ),
intval ( $importer [ " uid " ])
);
2016-12-20 12:49:50 -05:00
if ( dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
logger ( " duplicate message already delivered. " , LOGGER_DEBUG );
return false ;
2011-08-17 07:24:26 -04:00
}
2016-12-20 12:49:32 -05:00
$body = diaspora2bb ( $text );
$body = self :: replace_people_guid ( $body , $person [ " url " ]);
2016-03-14 18:11:43 -04:00
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 . " : " . $parent_guid ),
dbesc ( $created_at )
);
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
q ( " UPDATE `conv` SET `updated` = '%s' WHERE `id` = %d " ,
dbesc ( datetime_convert ()),
intval ( $conversation [ " id " ])
);
2012-06-10 10:41:23 -04:00
2016-03-14 18:11:43 -04:00
return true ;
2012-06-10 10:41:23 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes participations - unsupported by now
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
*
* @ return bool always true
*/
2016-12-29 18:27:11 -05:00
private static function receive_participation ( $importer , $data ) {
2016-03-14 18:11:43 -04:00
// I'm not sure if we can fully support this message type
return true ;
2015-12-01 09:36:32 -05:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes photos - unneeded
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool always true
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_photo ( $importer , $data ) {
2016-03-14 18:11:43 -04:00
// 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 ;
}
2011-08-17 07:24:26 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes poll participations - unssupported
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool always true
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_poll_participation ( $importer , $data ) {
2016-03-14 18:11:43 -04:00
// We don't support polls by now
return true ;
2011-08-24 07:42:28 -04:00
}
2012-03-16 08:19:29 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes incoming profile updates
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool Success
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_profile ( $importer , $data ) {
2016-08-23 01:48:48 -04:00
$author = strtolower ( notags ( unxmlify ( $data -> author )));
2011-08-10 08:10:48 -04:00
2016-03-14 18:11:43 -04:00
$contact = self :: contact_by_handle ( $importer [ " uid " ], $author );
if ( ! $contact )
2016-03-17 18:44:18 -04:00
return false ;
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$name = unxmlify ( $data -> first_name ) . (( strlen ( $data -> last_name )) ? " " . unxmlify ( $data -> last_name ) : " " );
$image_url = unxmlify ( $data -> image_url );
$birthday = unxmlify ( $data -> birthday );
$location = diaspora2bb ( unxmlify ( $data -> location ));
$about = diaspora2bb ( unxmlify ( $data -> bio ));
$gender = unxmlify ( $data -> gender );
$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 ;
}
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$keywords = implode ( " , " , $keywords );
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$handle_parts = explode ( " @ " , $author );
$nick = $handle_parts [ 0 ];
2011-11-27 20:41:23 -05:00
2017-04-04 13:47:32 -04:00
if ( $name === " " )
2016-03-14 18:11:43 -04:00
$name = $handle_parts [ 0 ];
2011-11-27 20:41:23 -05:00
2017-04-04 13:47:32 -04:00
if ( preg_match ( " |^https?://| " , $image_url ) === 0 )
2016-03-14 18:11:43 -04:00
$image_url = " http:// " . $handle_parts [ 1 ] . $image_url ;
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
update_contact_avatar ( $image_url , $importer [ " uid " ], $contact [ " id " ]);
2015-08-09 08:28:59 -04:00
2016-03-14 18:11:43 -04:00
// Generic birthday. We don't know the timezone. The year is irrelevant.
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$birthday = str_replace ( " 1000 " , " 1901 " , $birthday );
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
if ( $birthday != " " )
$birthday = datetime_convert ( " UTC " , " UTC " , $birthday , " Y-m-d " );
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
// 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
2011-11-27 20:41:23 -05:00
2017-04-04 13:47:32 -04:00
if ( substr ( $birthday , 5 ) === substr ( $contact [ " bd " ], 5 ))
2016-03-14 18:11:43 -04:00
$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 ),
2011-12-06 03:16:13 -05:00
dbesc ( datetime_convert ()),
2016-03-14 18:11:43 -04:00
dbesc ( $birthday ),
dbesc ( $location ),
dbesc ( $about ),
dbesc ( $keywords ),
dbesc ( $gender ),
intval ( $contact [ " id " ]),
intval ( $importer [ " uid " ])
2011-11-29 04:19:09 -05:00
);
2016-03-14 18:11:43 -04:00
$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 );
2011-12-04 20:26:55 -05:00
2017-03-22 01:26:44 -04:00
$gcid = update_gcontact ( $gcontact );
link_gcontact ( $gcid , $importer [ " uid " ], $contact [ " id " ]);
2011-12-04 20:26:55 -05:00
2016-03-14 18:11:43 -04:00
logger ( " Profile of contact " . $contact [ " id " ] . " stored for user " . $importer [ " uid " ], LOGGER_DEBUG );
2011-12-04 20:26:55 -05:00
2016-03-14 18:11:43 -04:00
return true ;
}
2011-12-04 20:26:55 -05:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes incoming friend requests
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
2016-03-18 17:28:20 -04:00
* @ param array $contact The contact that send the request
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_request_make_friend ( $importer , $contact ) {
2011-12-04 20:26:55 -05:00
2016-03-14 18:11:43 -04:00
$a = get_app ();
2011-12-04 20:26:55 -05:00
2017-04-04 13:47:32 -04:00
if ( $contact [ " rel " ] == CONTACT_IS_FOLLOWER && in_array ( $importer [ " page-flags " ], array ( PAGE_FREELOVE ))) {
2016-03-14 18:11:43 -04:00
q ( " UPDATE `contact` SET `rel` = %d, `writable` = 1 WHERE `id` = %d AND `uid` = %d " ,
intval ( CONTACT_IS_FRIEND ),
intval ( $contact [ " id " ]),
intval ( $importer [ " uid " ])
);
2011-11-27 20:41:23 -05:00
}
2016-03-14 18:11:43 -04:00
// send notification
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT `hide-friends` FROM `profile` WHERE `uid` = %d AND `is-default` = 1 LIMIT 1 " ,
intval ( $importer [ " uid " ])
2014-03-09 04:19:14 -04:00
);
2011-12-27 18:49:47 -05:00
2017-04-04 13:47:32 -04:00
if ( $r && ! $r [ 0 ][ " hide-friends " ] && ! $contact [ " hidden " ] && intval ( get_pconfig ( $importer [ " uid " ], " system " , " post_newfriend " ))) {
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$self = q ( " SELECT * FROM `contact` WHERE `self` AND `uid` = %d LIMIT 1 " ,
intval ( $importer [ " uid " ])
);
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
// they are not CONTACT_IS_FOLLOWER anymore but that's what we have in the array
2011-12-06 22:15:42 -05:00
2017-04-04 13:47:32 -04:00
if ( $self && $contact [ " rel " ] == CONTACT_IS_FOLLOWER ) {
2011-12-06 22:15:42 -05:00
2016-03-14 18:11:43 -04:00
$arr = array ();
2017-04-28 02:03:04 -04:00
$arr [ " protocol " ] = PROTOCOL_DIASPORA ;
2016-03-14 18:11:43 -04:00
$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 ;
2016-03-23 17:12:08 -04:00
$arr [ " object " ] = self :: construct_new_friend_object ( $contact );
2016-03-14 18:11:43 -04:00
$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 " ];
2011-12-06 22:15:42 -05:00
2016-03-14 18:11:43 -04:00
$i = item_store ( $arr );
2017-04-04 13:47:32 -04:00
if ( $i )
2016-08-03 12:24:22 -04:00
proc_run ( PRIORITY_HIGH , " include/notifier.php " , " activity " , $i );
2016-03-14 18:11:43 -04:00
}
}
2011-12-06 22:15:42 -05:00
}
2016-03-23 17:12:08 -04:00
/**
* @ brief Creates a XML object for a " new friend " message
*
* @ param array $contact Array of the contact
*
* @ return string The XML
*/
2016-12-29 18:27:11 -05:00
private static function construct_new_friend_object ( $contact ) {
2016-12-28 22:13:57 -05:00
$objtype = ACTIVITY_OBJ_PERSON ;
$link = '<link rel="alternate" type="text/html" href="' . $contact [ " url " ] . '" />' . " \n " .
'<link rel="photo" type="image/jpeg" href="' . $contact [ " thumb " ] . '" />' . " \n " ;
2016-03-23 17:12:08 -04:00
2016-12-28 22:13:57 -05:00
$xmldata = array ( " object " => array ( " type " => $objtype ,
" title " => $contact [ " name " ],
" id " => $contact [ " url " ] . " / " . $contact [ " name " ],
" link " => $link ));
2016-03-23 17:12:08 -04:00
2016-12-28 22:13:57 -05:00
return xml :: from_array ( $xmldata , $xml , true );
}
2016-03-23 17:12:08 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes incoming sharing notification
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool Success
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_contact_request ( $importer , $data ) {
2016-03-14 18:11:43 -04:00
$author = unxmlify ( $data -> author );
$recipient = unxmlify ( $data -> recipient );
2011-12-06 22:15:42 -05:00
2016-12-22 05:33:00 -05:00
if ( ! $author || ! $recipient ) {
2016-03-18 17:28:20 -04:00
return false ;
2016-12-22 05:33:00 -05:00
}
2014-03-16 12:46:05 -04:00
2016-03-24 19:49:18 -04:00
// the current protocol version doesn't know these fields
// That means that we will assume their existance
2016-12-22 05:33:00 -05:00
if ( isset ( $data -> following )) {
2016-03-24 19:49:18 -04:00
$following = ( unxmlify ( $data -> following ) == " true " );
2016-12-22 05:33:00 -05:00
} else {
2016-03-24 19:49:18 -04:00
$following = true ;
2016-12-22 05:33:00 -05:00
}
2011-12-06 22:15:42 -05:00
2016-12-22 05:33:00 -05:00
if ( isset ( $data -> sharing )) {
2016-03-24 19:49:18 -04:00
$sharing = ( unxmlify ( $data -> sharing ) == " true " );
2016-12-22 05:33:00 -05:00
} else {
2016-03-24 19:49:18 -04:00
$sharing = true ;
2016-12-22 05:33:00 -05:00
}
2011-11-27 20:41:23 -05:00
2016-03-24 19:49:18 -04:00
$contact = self :: contact_by_handle ( $importer [ " uid " ], $author );
2011-11-27 20:41:23 -05:00
2016-03-24 19:49:18 -04:00
// perhaps we were already sharing with this person. Now they're sharing with us.
// That makes us friends.
if ( $contact ) {
if ( $following AND $sharing ) {
2016-07-10 06:09:58 -04:00
logger ( " Author " . $author . " (Contact " . $contact [ " id " ] . " ) wants to have a bidirectional conection. " , LOGGER_DEBUG );
2016-03-24 19:49:18 -04:00
self :: receive_request_make_friend ( $importer , $contact );
2016-07-10 06:09:58 -04:00
// 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 , CONTACT_IS_FOLLOWER ))) {
2016-07-10 06:18:10 -04:00
$u = q ( " SELECT * FROM `user` WHERE `uid` = %d LIMIT 1 " , intval ( $importer [ " uid " ]));
2016-12-22 05:33:00 -05:00
if ( $u ) {
2016-07-10 06:09:58 -04:00
logger ( " Sending share message to author " . $author . " - Contact: " . $contact [ " id " ] . " - User: " . $importer [ " uid " ], LOGGER_DEBUG );
$ret = self :: send_share ( $u [ 0 ], $contact );
}
}
2016-03-24 19:49:18 -04:00
return true ;
2016-07-10 06:09:58 -04:00
} else { /// @todo Handle all possible variations of adding and retracting of permissions
logger ( " Author " . $author . " (Contact " . $contact [ " id " ] . " ) wants to change the relationship: Following: " . $following . " - sharing: " . $sharing . " (By now unsupported) " , LOGGER_DEBUG );
2016-03-24 19:49:18 -04:00
return false ;
2016-07-10 06:09:58 -04:00
}
2016-03-24 19:49:18 -04:00
}
if ( ! $following AND $sharing AND 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 AND ! $sharing ) {
logger ( " Author " . $author . " doesn't want anything - and we don't know the author. Request is ignored. " , LOGGER_DEBUG );
return false ;
2016-07-10 06:09:58 -04:00
} elseif ( ! $following AND $sharing ) {
logger ( " Author " . $author . " wants to share with us. " , LOGGER_DEBUG );
} elseif ( $following AND $sharing ) {
logger ( " Author " . $author . " wants to have a bidirectional conection. " , LOGGER_DEBUG );
} elseif ( $following AND ! $sharing ) {
logger ( " Author " . $author . " wants to listen to us. " , LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
}
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$ret = self :: person_by_handle ( $author );
2011-12-06 22:15:42 -05:00
2016-03-14 18:11:43 -04:00
if ( ! $ret || ( $ret [ " network " ] != NETWORK_DIASPORA )) {
logger ( " Cannot resolve diaspora handle " . $author . " for " . $recipient );
return false ;
}
2011-12-06 22:15:42 -05:00
2016-03-14 18:11:43 -04:00
$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
);
2011-12-06 22:15:42 -05:00
2016-03-14 18:11:43 -04:00
// find the contact record we just created
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
$contact_record = self :: contact_by_handle ( $importer [ " uid " ], $author );
2011-11-27 20:41:23 -05:00
2016-03-14 18:11:43 -04:00
if ( ! $contact_record ) {
logger ( " unable to locate newly created contact record. " );
return ;
}
2011-08-23 21:17:35 -04:00
2016-07-10 06:09:58 -04:00
logger ( " Author " . $author . " was added as contact number " . $contact_record [ " id " ] . " . " , LOGGER_DEBUG );
2016-04-13 16:21:23 -04:00
$def_gid = get_default_group ( $importer [ 'uid' ], $ret [ " network " ]);
2012-01-22 18:25:29 -05:00
2017-04-04 13:47:32 -04:00
if ( intval ( $def_gid ))
2016-04-13 16:21:23 -04:00
group_add_member ( $importer [ " uid " ], " " , $contact_record [ " id " ], $def_gid );
2012-01-22 18:25:29 -05:00
2016-06-25 07:56:55 -04:00
update_contact_avatar ( $ret [ " photo " ], $importer [ 'uid' ], $contact_record [ " id " ], true );
2017-04-04 13:47:32 -04:00
if ( $importer [ " page-flags " ] == PAGE_NORMAL ) {
2011-08-23 21:17:35 -04:00
2016-07-10 06:09:58 -04:00
logger ( " Sending intra message for author " . $author . " . " , LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
$hash = random_string () . ( string ) time (); // Generate a confirm_key
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$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 {
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
// automatic friend approval
2011-08-23 21:17:35 -04:00
2016-07-10 06:09:58 -04:00
logger ( " Does an automatic friend approval for author " . $author . " . " , LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
update_contact_avatar ( $contact_record [ " photo " ], $importer [ " uid " ], $contact_record [ " id " ]);
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
// 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.
2011-08-23 21:17:35 -04:00
2016-03-24 19:49:18 -04:00
if (( $importer [ " page-flags " ] == PAGE_FREELOVE ) AND $sharing AND $following )
2016-03-14 18:11:43 -04:00
$new_relation = CONTACT_IS_FRIEND ;
2016-03-24 19:49:18 -04:00
elseif (( $importer [ " page-flags " ] == PAGE_FREELOVE ) AND $sharing )
$new_relation = CONTACT_IS_SHARING ;
2016-03-14 18:11:43 -04:00
else
$new_relation = CONTACT_IS_FOLLOWER ;
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$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 " ])
);
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$u = q ( " SELECT * FROM `user` WHERE `uid` = %d LIMIT 1 " , intval ( $importer [ " uid " ]));
2017-04-04 13:47:32 -04:00
if ( $u ) {
2016-07-10 06:09:58 -04:00
logger ( " Sending share message (Relation: " . $new_relation . " ) to author " . $author . " - Contact: " . $contact_record [ " id " ] . " - User: " . $importer [ " uid " ], LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
$ret = self :: send_share ( $u [ 0 ], $contact_record );
2016-07-10 07:11:09 -04:00
// Send the profile data, maybe it weren't transmitted before
self :: send_profile ( $importer [ " uid " ], array ( $contact_record ));
2016-07-10 06:09:58 -04:00
}
2016-03-14 18:11:43 -04:00
}
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
return true ;
2011-08-23 21:17:35 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Fetches a message with a given guid
2016-03-17 18:44:18 -04:00
*
* @ param string $guid message guid
2016-03-18 17:28:20 -04:00
* @ param string $orig_author handle of the original post
* @ param string $author handle of the sharer
2016-03-17 18:44:18 -04:00
*
2016-03-18 17:28:20 -04:00
* @ return array The fetched item
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function original_item ( $guid , $orig_author , $author ) {
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
// 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 ));
2015-05-09 13:39:47 -04:00
2016-12-20 12:49:50 -05:00
if ( dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
logger ( " reshared message " . $guid . " already exists on system. " );
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
// Maybe it is already a reshared item?
2016-03-22 18:00:42 -04:00
// 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
2016-12-20 12:49:50 -05:00
if ( self :: is_reshare ( $r [ 0 ][ " body " ], true )) {
2016-03-14 18:11:43 -04:00
$r = array ();
2016-12-20 12:49:50 -05:00
} elseif ( self :: is_reshare ( $r [ 0 ][ " body " ], false )) {
2016-03-22 18:00:42 -04:00
$r [ 0 ][ " body " ] = diaspora2bb ( bb2diaspora ( $r [ 0 ][ " body " ]));
2016-03-23 02:36:17 -04:00
2016-12-20 12:49:32 -05:00
$r [ 0 ][ " body " ] = self :: replace_people_guid ( $r [ 0 ][ " body " ], $r [ 0 ][ " author-link " ]);
2016-03-23 02:36:17 -04:00
// Add OEmbed and other information to the body
$r [ 0 ][ " body " ] = add_page_info_to_body ( $r [ 0 ][ " body " ], false , true );
2016-03-22 18:00:42 -04:00
return $r [ 0 ];
2016-12-20 12:49:50 -05:00
} else {
2016-03-14 18:11:43 -04:00
return $r [ 0 ];
2016-12-20 12:49:50 -05:00
}
2013-01-12 08:52:15 -05:00
}
2015-05-03 15:25:03 -04:00
2016-12-20 12:49:50 -05:00
if ( ! dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
$server = " https:// " . substr ( $orig_author , strpos ( $orig_author , " @ " ) + 1 );
2016-06-30 16:58:56 -04:00
logger ( " 1st try: reshared message " . $guid . " will be fetched via SSL from the server " . $server );
2016-03-14 18:11:43 -04:00
$item_id = self :: store_by_guid ( $guid , $server );
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $item_id ) {
$server = " http:// " . substr ( $orig_author , strpos ( $orig_author , " @ " ) + 1 );
2016-06-30 16:58:56 -04:00
logger ( " 2nd try: reshared message " . $guid . " will be fetched without SLL from the server " . $server );
2016-03-14 18:11:43 -04:00
$item_id = self :: store_by_guid ( $guid , $server );
}
2011-10-28 19:13:54 -04:00
2016-03-14 18:11:43 -04:00
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 ));
2016-01-14 15:56:37 -05:00
2016-12-20 12:49:50 -05:00
if ( dbm :: is_result ( $r )) {
2016-05-06 02:22:27 -04:00
// If it is a reshared post from another network then reformat to avoid display problems with two share elements
2016-12-19 23:30:50 -05:00
if ( self :: is_reshare ( $r [ 0 ][ " body " ], false )) {
2016-05-06 02:22:27 -04:00
$r [ 0 ][ " body " ] = diaspora2bb ( bb2diaspora ( $r [ 0 ][ " body " ]));
2016-12-20 12:49:32 -05:00
$r [ 0 ][ " body " ] = self :: replace_people_guid ( $r [ 0 ][ " body " ], $r [ 0 ][ " author-link " ]);
2016-12-19 23:30:50 -05:00
}
2016-05-06 02:22:27 -04:00
2016-03-14 18:11:43 -04:00
return $r [ 0 ];
2016-05-06 02:22:27 -04:00
}
2016-01-14 15:56:37 -05:00
2016-03-14 18:11:43 -04:00
}
}
return false ;
2011-10-06 00:02:00 -04:00
}
2011-08-23 21:17:35 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes a reshare message
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
* @ param string $xml The original XML of the message
*
2016-03-18 17:28:20 -04:00
* @ return int the message id
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_reshare ( $importer , $data , $xml ) {
2016-03-14 18:11:43 -04:00
$root_author = notags ( unxmlify ( $data -> root_author ));
$root_guid = notags ( unxmlify ( $data -> root_guid ));
$guid = notags ( unxmlify ( $data -> guid ));
$author = notags ( unxmlify ( $data -> author ));
$public = notags ( unxmlify ( $data -> public ));
2016-07-14 01:20:20 -04:00
$created_at = datetime_convert ( " UTC " , " UTC " , notags ( unxmlify ( $data -> created_at )));
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$contact = self :: allowed_contact_by_handle ( $importer , $author , false );
2016-12-22 05:33:00 -05:00
if ( ! $contact ) {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-22 05:33:00 -05:00
}
2011-08-23 21:17:35 -04:00
2016-03-23 04:22:59 -04:00
$message_id = self :: message_exists ( $importer [ " uid " ], $guid );
2016-12-22 05:33:00 -05:00
if ( $message_id ) {
2016-03-23 04:22:59 -04:00
return $message_id ;
2016-12-22 05:33:00 -05:00
}
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$original_item = self :: original_item ( $root_guid , $root_author , $author );
2016-12-22 05:33:00 -05:00
if ( ! $original_item ) {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-22 05:33:00 -05:00
}
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$orig_url = App :: get_baseurl () . " /display/ " . $original_item [ " guid " ];
2011-08-10 08:10:48 -04:00
2016-03-14 18:11:43 -04:00
$datarray = array ();
2011-08-16 02:19:17 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " uid " ] = $importer [ " uid " ];
$datarray [ " contact-id " ] = $contact [ " id " ];
$datarray [ " network " ] = NETWORK_DIASPORA ;
2011-08-16 02:19:17 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " author-name " ] = $contact [ " name " ];
$datarray [ " author-link " ] = $contact [ " url " ];
$datarray [ " author-avatar " ] = (( x ( $contact , " thumb " )) ? $contact [ " thumb " ] : $contact [ " photo " ]);
2011-08-17 07:24:26 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " owner-name " ] = $datarray [ " author-name " ];
$datarray [ " owner-link " ] = $datarray [ " author-link " ];
$datarray [ " owner-avatar " ] = $datarray [ " author-avatar " ];
2011-08-17 01:31:14 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " guid " ] = $guid ;
2016-06-20 16:48:55 -04:00
$datarray [ " uri " ] = $datarray [ " parent-uri " ] = self :: get_uri_from_guid ( $author , $guid );
2011-08-16 02:19:17 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " verb " ] = ACTIVITY_POST ;
$datarray [ " gravity " ] = GRAVITY_PARENT ;
2011-08-16 02:19:17 -04:00
2017-04-27 16:38:46 -04:00
$datarray [ " protocol " ] = PROTOCOL_DIASPORA ;
$datarray [ " source " ] = $xml ;
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
$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] " ;
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " tag " ] = $original_item [ " tag " ];
$datarray [ " app " ] = $original_item [ " app " ];
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " plink " ] = self :: plink ( $author , $guid );
$datarray [ " private " ] = (( $public == " false " ) ? 1 : 0 );
2016-07-14 01:20:20 -04:00
$datarray [ " changed " ] = $datarray [ " created " ] = $datarray [ " edited " ] = $created_at ;
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " object-type " ] = $original_item [ " object-type " ];
2015-05-09 13:39:47 -04:00
2016-03-14 18:11:43 -04:00
self :: fetch_guid ( $datarray );
$message_id = item_store ( $datarray );
2011-08-13 22:03:59 -04:00
2016-12-22 05:33:00 -05:00
if ( $message_id ) {
2016-03-14 18:11:43 -04:00
logger ( " Stored reshare " . $datarray [ " guid " ] . " with message id " . $message_id , LOGGER_DEBUG );
2016-12-22 05:33:00 -05:00
}
2011-08-17 01:31:14 -04:00
2016-03-14 18:11:43 -04:00
return $message_id ;
2011-08-17 01:31:14 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Processes retractions
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
2016-03-18 17:28:20 -04:00
* @ param array $contact The contact of the item owner
2016-03-17 18:44:18 -04:00
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool success
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function item_retraction ( $importer , $contact , $data ) {
2016-03-14 18:11:43 -04:00
$target_type = notags ( unxmlify ( $data -> target_type ));
$target_guid = notags ( unxmlify ( $data -> target_guid ));
$author = notags ( unxmlify ( $data -> author ));
2011-08-17 01:31:14 -04:00
2016-03-14 18:11:43 -04:00
$person = self :: person_by_handle ( $author );
if ( ! is_array ( $person )) {
logger ( " unable to find author detail for " . $author );
return false ;
}
2015-03-22 16:53:13 -04:00
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT `id`, `parent`, `parent-uri`, `author-link` FROM `item` WHERE `guid` = '%s' AND `uid` = %d AND NOT `file` LIKE '%%[%%' LIMIT 1 " ,
dbesc ( $target_guid ),
intval ( $importer [ " uid " ])
);
2016-12-22 05:29:56 -05:00
if ( ! $r ) {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-22 05:29:56 -05:00
}
2015-03-22 16:53:13 -04:00
2016-03-14 18:11:43 -04:00
// Check if the sender is the thread owner
$p = q ( " SELECT `id`, `author-link`, `origin` FROM `item` WHERE `id` = %d " ,
intval ( $r [ 0 ][ " parent " ]));
2011-08-13 22:03:59 -04:00
2016-03-14 18:11:43 -04:00
// Only delete it if the parent author really fits
if ( ! link_compare ( $p [ 0 ][ " author-link " ], $contact [ " url " ]) AND ! link_compare ( $r [ 0 ][ " author-link " ], $contact [ " url " ])) {
logger ( " Thread author " . $p [ 0 ][ " author-link " ] . " and item author " . $r [ 0 ][ " author-link " ] . " don't fit to expected contact " . $contact [ " url " ], LOGGER_DEBUG );
return false ;
}
2011-08-13 22:03:59 -04:00
2016-03-14 18:11:43 -04:00
// 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
q ( " UPDATE `item` SET `deleted` = 1, `edited` = '%s', `changed` = '%s', `body` = '' , `title` = '' WHERE `id` = %d " ,
dbesc ( datetime_convert ()),
dbesc ( datetime_convert ()),
intval ( $r [ 0 ][ " id " ])
);
delete_thread ( $r [ 0 ][ " id " ], $r [ 0 ][ " parent-uri " ]);
2015-03-22 16:53:13 -04:00
2016-03-14 18:11:43 -04:00
logger ( " Deleted target " . $target_guid . " ( " . $r [ 0 ][ " id " ] . " ) from user " . $importer [ " uid " ] . " parent: " . $p [ 0 ][ " id " ], LOGGER_DEBUG );
2012-06-09 15:54:21 -04:00
2016-03-14 18:11:43 -04:00
// Now check if the retraction needs to be relayed by us
2016-12-22 05:29:56 -05:00
if ( $p [ 0 ][ " origin " ]) {
2016-03-14 18:11:43 -04:00
// notify others
2016-08-03 12:24:22 -04:00
proc_run ( PRIORITY_HIGH , " include/notifier.php " , " drop " , $r [ 0 ][ " id " ]);
2011-08-17 01:31:14 -04:00
}
2016-03-18 17:28:20 -04:00
return true ;
2011-08-17 01:31:14 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Receives retraction messages
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param string $sender The sender of the message
* @ param object $data The message object
*
2016-03-18 17:28:20 -04:00
* @ return bool Success
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_retraction ( $importer , $sender , $data ) {
2016-03-14 18:11:43 -04:00
$target_type = notags ( unxmlify ( $data -> target_type ));
2011-08-17 01:31:14 -04:00
2016-03-14 18:11:43 -04:00
$contact = self :: contact_by_handle ( $importer [ " uid " ], $sender );
if ( ! $contact ) {
logger ( " cannot find contact for sender: " . $sender . " and user " . $importer [ " uid " ]);
return false ;
}
2012-06-10 10:41:23 -04:00
2016-03-14 18:11:43 -04:00
logger ( " Got retraction for " . $target_type . " , sender " . $sender . " and user " . $importer [ " uid " ], LOGGER_DEBUG );
switch ( $target_type ) {
case " Comment " :
case " Like " :
case " Post " : // "Post" will be supported in a future version
case " Reshare " :
case " StatusMessage " :
return self :: item_retraction ( $importer , $contact , $data );;
2016-04-19 01:39:17 -04:00
case " Contact " :
2016-03-14 18:11:43 -04:00
case " Person " :
/// @todo What should we do with an "unshare"?
// Removing the contact isn't correct since we still can read the public items
2016-04-19 01:39:17 -04:00
contact_remove ( $contact [ " id " ]);
2016-03-14 18:11:43 -04:00
return true ;
default :
logger ( " Unknown target type " . $target_type );
return false ;
2012-06-10 10:41:23 -04:00
}
2016-03-14 18:11:43 -04:00
return true ;
2012-06-10 10:41:23 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Receives status messages
2016-03-17 18:44:18 -04:00
*
* @ param array $importer Array of the importer user
* @ param object $data The message object
* @ param string $xml The original XML of the message
*
2016-03-18 17:28:20 -04:00
* @ return int The message id of the newly created item
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function receive_status_message ( $importer , $data , $xml ) {
2016-03-14 18:11:43 -04:00
$raw_message = unxmlify ( $data -> raw_message );
$guid = notags ( unxmlify ( $data -> guid ));
$author = notags ( unxmlify ( $data -> author ));
$public = notags ( unxmlify ( $data -> public ));
2016-07-14 01:20:20 -04:00
$created_at = datetime_convert ( " UTC " , " UTC " , notags ( unxmlify ( $data -> created_at )));
2016-03-14 18:11:43 -04:00
$provider_display_name = notags ( unxmlify ( $data -> provider_display_name ));
2011-08-13 22:03:59 -04:00
2016-03-14 18:11:43 -04:00
/// @todo enable support for polls
//if ($data->poll) {
// foreach ($data->poll AS $poll)
// print_r($poll);
// die("poll!\n");
//}
$contact = self :: allowed_contact_by_handle ( $importer , $author , false );
2016-12-20 12:49:50 -05:00
if ( ! $contact ) {
2016-03-14 18:11:43 -04:00
return false ;
2016-12-20 12:49:50 -05:00
}
2011-08-13 22:03:59 -04:00
2016-03-23 04:22:59 -04:00
$message_id = self :: message_exists ( $importer [ " uid " ], $guid );
2016-12-20 12:49:50 -05:00
if ( $message_id ) {
2016-03-23 04:22:59 -04:00
return $message_id ;
2016-12-20 12:49:50 -05:00
}
2011-08-10 08:10:48 -04:00
2016-03-14 18:11:43 -04:00
$address = array ();
2016-12-20 12:49:50 -05:00
if ( $data -> location ) {
foreach ( $data -> location -> children () AS $fieldname => $data ) {
2016-03-14 18:11:43 -04:00
$address [ $fieldname ] = notags ( unxmlify ( $data ));
2016-12-20 12:49:50 -05:00
}
}
2011-08-16 02:19:17 -04:00
2016-03-14 18:11:43 -04:00
$body = diaspora2bb ( $raw_message );
2011-12-21 17:42:12 -05:00
2016-03-14 18:11:43 -04:00
$datarray = array ();
2011-08-16 02:19:17 -04:00
2016-03-24 10:59:53 -04:00
// Attach embedded pictures to the body
2016-03-14 18:11:43 -04:00
if ( $data -> photo ) {
2016-12-20 12:49:50 -05:00
foreach ( $data -> photo AS $photo ) {
2016-03-15 15:14:08 -04:00
$body = " [img] " . unxmlify ( $photo -> remote_photo_path ) .
unxmlify ( $photo -> remote_photo_name ) . " [/img] \n " . $body ;
2016-12-20 12:49:50 -05:00
}
2011-08-16 02:19:17 -04:00
2016-12-20 02:10:47 -05:00
$datarray [ " object-type " ] = ACTIVITY_OBJ_IMAGE ;
2016-03-14 18:11:43 -04:00
} else {
$datarray [ " object-type " ] = ACTIVITY_OBJ_NOTE ;
2015-12-03 02:35:47 -05:00
2016-03-14 18:11:43 -04:00
// Add OEmbed and other information to the body
2016-12-20 12:49:50 -05:00
if ( ! self :: is_redmatrix ( $contact [ " url " ])) {
2016-03-14 18:11:43 -04:00
$body = add_page_info_to_body ( $body , false , true );
2016-12-20 12:49:50 -05:00
}
2011-08-22 23:35:34 -04:00
}
2011-08-10 08:10:48 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " uid " ] = $importer [ " uid " ];
$datarray [ " contact-id " ] = $contact [ " id " ];
$datarray [ " network " ] = NETWORK_DIASPORA ;
2011-10-13 21:32:02 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " author-name " ] = $contact [ " name " ];
$datarray [ " author-link " ] = $contact [ " url " ];
$datarray [ " author-avatar " ] = (( x ( $contact , " thumb " )) ? $contact [ " thumb " ] : $contact [ " photo " ]);
2011-12-21 17:42:12 -05:00
2016-03-14 18:11:43 -04:00
$datarray [ " owner-name " ] = $datarray [ " author-name " ];
$datarray [ " owner-link " ] = $datarray [ " author-link " ];
$datarray [ " owner-avatar " ] = $datarray [ " author-avatar " ];
2011-11-05 17:45:29 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " guid " ] = $guid ;
2016-06-20 16:48:55 -04:00
$datarray [ " uri " ] = $datarray [ " parent-uri " ] = self :: get_uri_from_guid ( $author , $guid );
2011-11-05 17:45:29 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " verb " ] = ACTIVITY_POST ;
$datarray [ " gravity " ] = GRAVITY_PARENT ;
2012-05-25 20:26:09 -04:00
2017-04-27 16:38:46 -04:00
$datarray [ " protocol " ] = PROTOCOL_DIASPORA ;
$datarray [ " source " ] = $xml ;
2011-11-05 17:45:29 -04:00
2016-12-20 12:49:32 -05:00
$datarray [ " body " ] = self :: replace_people_guid ( $body , $contact [ " url " ]);
2011-11-05 17:45:29 -04:00
2016-12-20 12:49:50 -05:00
if ( $provider_display_name != " " ) {
2016-03-14 18:11:43 -04:00
$datarray [ " app " ] = $provider_display_name ;
2016-12-20 12:49:50 -05:00
}
2011-11-05 17:45:29 -04:00
2016-03-14 18:11:43 -04:00
$datarray [ " plink " ] = self :: plink ( $author , $guid );
$datarray [ " private " ] = (( $public == " false " ) ? 1 : 0 );
2016-07-14 01:20:20 -04:00
$datarray [ " changed " ] = $datarray [ " created " ] = $datarray [ " edited " ] = $created_at ;
2011-11-05 17:45:29 -04:00
2016-12-20 12:49:50 -05:00
if ( isset ( $address [ " address " ])) {
2016-03-14 18:11:43 -04:00
$datarray [ " location " ] = $address [ " address " ];
2016-12-20 12:49:50 -05:00
}
2012-05-25 20:26:09 -04:00
2016-12-20 12:49:50 -05:00
if ( isset ( $address [ " lat " ]) AND isset ( $address [ " lng " ])) {
2016-03-14 18:11:43 -04:00
$datarray [ " coord " ] = $address [ " lat " ] . " " . $address [ " lng " ];
2016-12-20 12:49:50 -05:00
}
2012-06-09 15:54:21 -04:00
2016-03-14 18:11:43 -04:00
self :: fetch_guid ( $datarray );
$message_id = item_store ( $datarray );
2012-06-09 15:54:21 -04:00
2016-12-20 12:49:50 -05:00
if ( $message_id ) {
2016-03-14 18:11:43 -04:00
logger ( " Stored item " . $datarray [ " guid " ] . " with message id " . $message_id , LOGGER_DEBUG );
2016-12-20 12:49:50 -05:00
}
2011-11-05 17:45:29 -04:00
2016-03-14 18:11:43 -04:00
return $message_id ;
}
2011-11-05 17:45:29 -04:00
2016-03-23 17:12:08 -04:00
/* ************************************************************************************** *
2016-03-14 18:11:43 -04:00
* Here are all the functions that are needed to transmit data with the Diaspora protocol *
2016-03-23 17:12:08 -04:00
* ************************************************************************************** */
2012-06-09 15:54:21 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief returnes the handle of a contact
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ param array $me contact array
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return string the handle in the format user @ domain . tld
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function my_handle ( $contact ) {
2016-12-22 05:29:56 -05:00
if ( $contact [ " addr " ] != " " ) {
2016-03-14 18:11:43 -04:00
return $contact [ " addr " ];
2016-12-22 05:29:56 -05:00
}
2012-05-25 20:26:09 -04:00
2016-03-14 18:11:43 -04:00
// 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.
2016-12-22 05:29:56 -05:00
if ( $contact [ " nickname " ] != " " ) {
2016-03-19 10:49:47 -04:00
$nick = $contact [ " nickname " ];
2016-12-22 05:29:56 -05:00
} else {
2016-03-19 10:49:47 -04:00
$nick = $contact [ " nick " ];
2016-12-22 05:29:56 -05:00
}
2016-03-19 10:49:47 -04:00
return $nick . " @ " . substr ( App :: get_baseurl (), strpos ( App :: get_baseurl (), " :// " ) + 3 );
2011-11-05 17:45:29 -04:00
}
2016-06-30 01:32:07 -04:00
/**
* @ brief Creates the envelope for the " fetch " endpoint
*
* @ param string $msg The message that is to be transmitted
* @ param array $user The record of the sender
*
* @ return string The envelope
*/
2016-06-30 16:18:48 -04:00
public static function build_magic_envelope ( $msg , $user ) {
2016-06-30 01:32:07 -04:00
$b64url_data = base64url_encode ( $msg );
$data = str_replace ( array ( " \n " , " \r " , " " , " \t " ), array ( " " , " " , " " , " " ), $b64url_data );
2016-12-20 12:44:15 -05:00
$key_id = base64url_encode ( self :: my_handle ( $user ));
2016-06-30 01:32:07 -04:00
$type = " application/xml " ;
$encoding = " base64url " ;
$alg = " RSA-SHA256 " ;
$signable_data = $data . " . " . base64url_encode ( $type ) . " . " . base64url_encode ( $encoding ) . " . " . base64url_encode ( $alg );
$signature = rsa_sign ( $signable_data , $user [ " prvkey " ]);
$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 );
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Creates the envelope for a public message
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ 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
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return string The envelope
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function build_public_message ( $msg , $user , $contact , $prvkey , $pubkey ) {
2011-11-05 17:45:29 -04:00
2016-03-14 18:11:43 -04:00
logger ( " Message: " . $msg , LOGGER_DATA );
2011-10-13 21:32:02 -04:00
2016-03-14 18:11:43 -04:00
$handle = self :: my_handle ( $user );
2011-10-13 21:32:02 -04:00
2016-03-14 18:11:43 -04:00
$b64url_data = base64url_encode ( $msg );
2012-07-09 01:32:04 -04:00
2016-03-14 18:11:43 -04:00
$data = str_replace ( array ( " \n " , " \r " , " " , " \t " ), array ( " " , " " , " " , " " ), $b64url_data );
2012-07-09 01:32:04 -04:00
2016-03-14 18:11:43 -04:00
$type = " application/xml " ;
$encoding = " base64url " ;
$alg = " RSA-SHA256 " ;
2015-01-25 07:19:37 -05:00
2016-03-14 18:11:43 -04:00
$signable_data = $data . " . " . base64url_encode ( $type ) . " . " . base64url_encode ( $encoding ) . " . " . base64url_encode ( $alg );
2012-09-19 22:35:39 -04:00
2016-03-14 18:11:43 -04:00
$signature = rsa_sign ( $signable_data , $prvkey );
$sig = base64url_encode ( $signature );
2016-01-06 08:13:59 -05:00
2016-03-14 18:11:43 -04:00
$xmldata = array ( " diaspora " => array ( " header " => array ( " author_id " => $handle ),
2016-06-30 01:32:07 -04:00
" me:env " => array ( " me:encoding " => $encoding ,
" me:alg " => $alg ,
" me:data " => $data ,
" @attributes " => array ( " type " => $type ),
" me:sig " => $sig )));
2015-01-06 19:46:13 -05:00
2016-03-14 18:11:43 -04:00
$namespaces = array ( " " => " https://joindiaspora.com/protocol " ,
" me " => " http://salmon-protocol.org/ns/magic-env " );
$magic_env = xml :: from_array ( $xmldata , $xml , false , $namespaces );
logger ( " magic_env: " . $magic_env , LOGGER_DATA );
return $magic_env ;
2012-09-19 22:35:39 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Creates the envelope for a private message
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ 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
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return string The envelope
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function build_private_message ( $msg , $user , $contact , $prvkey , $pubkey ) {
2011-10-13 21:32:02 -04:00
2016-03-14 18:11:43 -04:00
logger ( " Message: " . $msg , LOGGER_DATA );
2011-10-18 04:12:51 -04:00
2016-03-14 18:11:43 -04:00
// without a public key nothing will work
2015-01-06 19:46:13 -05:00
2016-03-14 18:11:43 -04:00
if ( ! $pubkey ) {
logger ( " pubkey missing: contact id: " . $contact [ " id " ]);
return false ;
}
2011-10-13 21:32:02 -04:00
2017-04-01 04:28:42 -04:00
$inner_aes_key = openssl_random_pseudo_bytes ( 32 );
2016-03-14 18:11:43 -04:00
$b_inner_aes_key = base64_encode ( $inner_aes_key );
2017-04-01 04:28:42 -04:00
$inner_iv = openssl_random_pseudo_bytes ( 16 );
2016-03-14 18:11:43 -04:00
$b_inner_iv = base64_encode ( $inner_iv );
2011-10-18 04:12:51 -04:00
2017-04-01 04:28:42 -04:00
$outer_aes_key = openssl_random_pseudo_bytes ( 32 );
2016-03-14 18:11:43 -04:00
$b_outer_aes_key = base64_encode ( $outer_aes_key );
2017-04-01 04:28:42 -04:00
$outer_iv = openssl_random_pseudo_bytes ( 16 );
2016-03-14 18:11:43 -04:00
$b_outer_iv = base64_encode ( $outer_iv );
2011-10-14 03:20:37 -04:00
2016-03-14 18:11:43 -04:00
$handle = self :: my_handle ( $user );
2011-12-19 22:06:25 -05:00
2017-03-31 02:22:43 -04:00
$inner_encrypted = self :: aes_encrypt ( $inner_aes_key , $inner_iv , $msg );
2011-12-19 22:06:25 -05:00
2016-03-14 18:11:43 -04:00
$b64_data = base64_encode ( $inner_encrypted );
2012-02-25 01:47:43 -05:00
2011-10-18 04:12:51 -04:00
2016-03-14 18:11:43 -04:00
$b64url_data = base64url_encode ( $b64_data );
$data = str_replace ( array ( " \n " , " \r " , " " , " \t " ), array ( " " , " " , " " , " " ), $b64url_data );
2015-01-25 07:19:37 -05:00
2016-03-14 18:11:43 -04:00
$type = " application/xml " ;
$encoding = " base64url " ;
$alg = " RSA-SHA256 " ;
2011-10-13 21:32:02 -04:00
2016-03-14 18:11:43 -04:00
$signable_data = $data . " . " . base64url_encode ( $type ) . " . " . base64url_encode ( $encoding ) . " . " . base64url_encode ( $alg );
2011-10-13 21:32:02 -04:00
2016-03-14 18:11:43 -04:00
$signature = rsa_sign ( $signable_data , $prvkey );
$sig = base64url_encode ( $signature );
2011-10-13 21:32:02 -04:00
2016-03-14 18:11:43 -04:00
$xmldata = array ( " decrypted_header " => array ( " iv " => $b_inner_iv ,
" aes_key " => $b_inner_aes_key ,
" author_id " => $handle ));
2011-08-14 23:38:31 -04:00
2016-03-14 18:11:43 -04:00
$decrypted_header = xml :: from_array ( $xmldata , $xml , true );
2011-08-14 23:38:31 -04:00
2017-03-31 02:22:43 -04:00
$ciphertext = self :: aes_encrypt ( $outer_aes_key , $outer_iv , $decrypted_header );
2011-08-14 23:38:31 -04:00
2016-03-14 18:11:43 -04:00
$outer_json = json_encode ( array ( " iv " => $b_outer_iv , " key " => $b_outer_aes_key ));
2011-08-14 23:38:31 -04:00
2016-03-14 18:11:43 -04:00
$encrypted_outer_key_bundle = " " ;
openssl_public_encrypt ( $outer_json , $encrypted_outer_key_bundle , $pubkey );
2011-08-22 23:35:34 -04:00
2016-03-14 18:11:43 -04:00
$b64_encrypted_outer_key_bundle = base64_encode ( $encrypted_outer_key_bundle );
2011-08-22 23:35:34 -04:00
2016-03-14 18:11:43 -04:00
logger ( " outer_bundle: " . $b64_encrypted_outer_key_bundle . " key: " . $pubkey , LOGGER_DATA );
2011-08-22 23:35:34 -04:00
2016-03-14 18:11:43 -04:00
$encrypted_header_json_object = json_encode ( array ( " aes_key " => base64_encode ( $encrypted_outer_key_bundle ),
" ciphertext " => base64_encode ( $ciphertext )));
$cipher_json = base64_encode ( $encrypted_header_json_object );
2011-08-22 23:35:34 -04:00
2016-03-14 18:11:43 -04:00
$xmldata = array ( " diaspora " => array ( " encrypted_header " => $cipher_json ,
2016-06-29 16:50:30 -04:00
" me:env " => array ( " me:encoding " => $encoding ,
" me:alg " => $alg ,
2016-03-14 18:11:43 -04:00
" me:data " => $data ,
2016-06-29 16:50:30 -04:00
" @attributes " => array ( " type " => $type ),
2016-03-14 18:11:43 -04:00
" me:sig " => $sig )));
2011-08-24 04:21:24 -04:00
2016-03-14 18:11:43 -04:00
$namespaces = array ( " " => " https://joindiaspora.com/protocol " ,
" me " => " http://salmon-protocol.org/ns/magic-env " );
$magic_env = xml :: from_array ( $xmldata , $xml , false , $namespaces );
2011-08-22 23:35:34 -04:00
2016-03-14 18:11:43 -04:00
logger ( " magic_env: " . $magic_env , LOGGER_DATA );
return $magic_env ;
}
2011-08-22 23:35:34 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Create the envelope for a message
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ 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 ?
2016-03-17 18:44:18 -04:00
*
2016-03-18 17:28:20 -04:00
* @ return string The message that will be transmitted to other servers
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function build_message ( $msg , $user , $contact , $prvkey , $pubkey , $public = false ) {
2011-08-15 00:23:02 -04:00
2016-03-14 18:11:43 -04:00
if ( $public )
$magic_env = self :: build_public_message ( $msg , $user , $contact , $prvkey , $pubkey );
else
$magic_env = self :: build_private_message ( $msg , $user , $contact , $prvkey , $pubkey );
2011-08-15 00:23:02 -04:00
2016-03-14 18:11:43 -04:00
// The data that will be transmitted is double encoded via "urlencode", strange ...
$slap = " xml= " . urlencode ( urlencode ( $magic_env ));
return $slap ;
}
2011-08-23 21:17:35 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Creates a signature for a message
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ param array $owner the array of the owner of the message
* @ param array $message The message that is to be signed
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return string The signature
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function signature ( $owner , $message ) {
2016-03-14 18:11:43 -04:00
$sigmsg = $message ;
unset ( $sigmsg [ " author_signature " ]);
unset ( $sigmsg [ " parent_author_signature " ]);
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$signed_text = implode ( " ; " , $sigmsg );
2011-10-23 22:05:32 -04:00
2016-03-14 18:11:43 -04:00
return base64_encode ( rsa_sign ( $signed_text , $owner [ " uprvkey " ], " sha256 " ));
2012-06-17 13:49:05 -04:00
}
2012-06-23 06:42:01 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Transmit a message to a target server
2016-03-17 18:44:18 -04:00
*
* @ param array $owner the array of the item owner
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
* @ param string $slap The message that is to be transmitted
2016-03-17 18:44:18 -04:00
* @ param bool $public_batch Is it a public post ?
2016-03-18 03:07:23 -04:00
* @ param bool $queue_run Is the transmission called from the queue ?
2016-03-17 18:44:18 -04:00
* @ param string $guid message guid
*
2016-03-18 03:07:23 -04:00
* @ return int Result of the transmission
2016-03-17 18:44:18 -04:00
*/
2016-03-14 18:11:43 -04:00
public static function transmit ( $owner , $contact , $slap , $public_batch , $queue_run = false , $guid = " " ) {
$a = get_app ();
$enabled = intval ( get_config ( " system " , " diaspora_enabled " ));
2017-04-04 13:47:32 -04:00
if ( ! $enabled )
2016-03-14 18:11:43 -04:00
return 200 ;
2012-06-17 13:49:05 -04:00
2016-03-14 18:11:43 -04:00
$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 ;
}
2012-04-01 22:16:13 -04:00
2016-03-14 18:11:43 -04:00
logger ( " transmit: " . $logid . " - " . $guid . " " . $dest_url );
2012-04-01 22:16:13 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $queue_run && was_recently_delayed ( $contact [ " id " ])) {
$return_code = 0 ;
} else {
if ( ! intval ( get_config ( " system " , " diaspora_test " ))) {
post_url ( $dest_url . " / " , $slap );
$return_code = $a -> get_curl_code ();
} else {
logger ( " test_mode " );
return 200 ;
2011-11-01 20:30:52 -04:00
}
}
2016-03-14 18:11:43 -04:00
logger ( " transmit: " . $logid . " - " . $guid . " returns: " . $return_code );
2011-11-01 20:30:52 -04:00
2016-12-20 15:13:50 -05:00
if ( ! $return_code || (( $return_code == 503 ) && ( stristr ( $a -> get_curl_headers (), " retry-after " )))) {
2016-03-14 18:11:43 -04:00
logger ( " queue message " );
2011-08-15 00:23:02 -04:00
2016-03-14 18:11:43 -04:00
$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 ( $slap ),
intval ( $public_batch )
);
2016-12-20 15:13:50 -05:00
if ( $r ) {
2016-03-14 18:11:43 -04:00
logger ( " add_to_queue ignored - identical item already in queue " );
} else {
// queue message for redelivery
add_to_queue ( $contact [ " id " ], NETWORK_DIASPORA , $slap , $public_batch );
2016-11-19 15:10:29 -05:00
// The message could not be delivered. We mark the contact as "dead"
mark_for_death ( $contact );
2016-03-14 18:11:43 -04:00
}
2016-11-19 15:10:29 -05:00
} elseif (( $return_code >= 200 ) AND ( $return_code <= 299 )) {
// We successfully delivered a message, the contact is alive
unmark_for_death ( $contact );
2016-03-14 18:11:43 -04:00
}
2011-08-15 00:23:02 -04:00
2016-03-14 18:11:43 -04:00
return (( $return_code ) ? $return_code : ( - 1 ));
2014-04-25 19:35:02 -04:00
}
2011-08-15 00:23:02 -04:00
2016-06-30 01:46:00 -04:00
/**
* @ 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 ( " XML " => array ( " post " => array ( $type => $message )));
return xml :: from_array ( $data , $xml );
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Builds and transmit messages
2016-03-17 18:44:18 -04:00
*
* @ param array $owner the array of the item owner
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
* @ param string $type The message type
* @ param array $message The message data
2016-03-17 18:44:18 -04:00
* @ param bool $public_batch Is it a public post ?
* @ param string $guid message guid
2016-03-18 03:07:23 -04:00
* @ param bool $spool Should the transmission be spooled or transmitted ?
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return int Result of the transmission
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function build_and_transmit ( $owner , $contact , $type , $message , $public_batch = false , $guid = " " , $spool = false ) {
2011-08-23 21:17:35 -04:00
2016-06-30 01:56:06 -04:00
$msg = self :: build_post_xml ( $type , $message );
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
logger ( 'message: ' . $msg , LOGGER_DATA );
logger ( 'send guid ' . $guid , LOGGER_DEBUG );
2011-08-15 00:23:02 -04:00
2016-07-10 06:18:10 -04:00
// Fallback if the private key wasn't transmitted in the expected field
if ( $owner [ 'uprvkey' ] == " " )
$owner [ 'uprvkey' ] = $owner [ 'prvkey' ];
2016-03-14 18:11:43 -04:00
$slap = self :: build_message ( $msg , $owner , $contact , $owner [ 'uprvkey' ], $contact [ 'pubkey' ], $public_batch );
2014-04-25 19:35:02 -04:00
2016-03-14 18:11:43 -04:00
if ( $spool ) {
add_to_queue ( $contact [ 'id' ], NETWORK_DIASPORA , $slap , $public_batch );
return true ;
} else
$return_code = self :: transmit ( $owner , $contact , $slap , $public_batch , false , $guid );
2014-04-25 19:35:02 -04:00
2016-03-14 18:11:43 -04:00
logger ( " guid: " . $item [ " guid " ] . " result " . $return_code , LOGGER_DEBUG );
2014-04-25 19:35:02 -04:00
2016-03-14 18:11:43 -04:00
return $return_code ;
}
2014-04-25 19:35:02 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Sends a " share " message
2016-03-17 18:44:18 -04:00
*
* @ param array $owner the array of the item owner
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
2016-03-17 18:44:18 -04:00
*
* @ return int The result of the transmission
*/
2016-03-14 18:11:43 -04:00
public static function send_share ( $owner , $contact ) {
2015-04-03 07:06:19 -04:00
2016-03-14 18:11:43 -04:00
$message = array ( " sender_handle " => self :: my_handle ( $owner ),
" recipient_handle " => $contact [ " addr " ]);
2015-04-03 07:06:19 -04:00
2016-07-10 06:09:58 -04:00
logger ( " Send share " . print_r ( $message , true ), LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return self :: build_and_transmit ( $owner , $contact , " request " , $message );
2015-04-03 07:06:19 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief sends an " unshare "
2016-03-17 18:44:18 -04:00
*
* @ param array $owner the array of the item owner
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
2016-03-17 18:44:18 -04:00
*
* @ return int The result of the transmission
*/
2016-03-14 18:11:43 -04:00
public static function send_unshare ( $owner , $contact ) {
2014-04-25 19:35:02 -04:00
2016-03-14 18:11:43 -04:00
$message = array ( " post_guid " => $owner [ " guid " ],
" diaspora_handle " => self :: my_handle ( $owner ),
" type " => " Person " );
2014-04-25 19:35:02 -04:00
2016-07-10 06:09:58 -04:00
logger ( " Send unshare " . print_r ( $message , true ), LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return self :: build_and_transmit ( $owner , $contact , " retraction " , $message );
}
2014-04-25 19:35:02 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Checks a message body if it is a reshare
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ param string $body The message body that is to be check
* @ param bool $complete Should it be a complete check or a simple check ?
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return array | bool Reshare details or " false " if no reshare
2016-03-17 18:44:18 -04:00
*/
2016-03-16 16:27:07 -04:00
public static function is_reshare ( $body , $complete = true ) {
2016-03-14 18:11:43 -04:00
$body = trim ( $body );
2014-04-25 19:35:02 -04:00
2016-03-14 18:11:43 -04:00
// Skip if it isn't a pure repeated messages
// Does it start with a share?
2016-05-06 02:22:27 -04:00
if (( strpos ( $body , " [share " ) > 0 ) AND $complete )
2016-03-14 18:11:43 -04:00
return ( false );
2014-04-25 19:35:02 -04:00
2016-03-14 18:11:43 -04:00
// Does it end with a share?
if ( strlen ( $body ) > ( strrpos ( $body , " [/share] " ) + 8 ))
return ( false );
2014-04-25 19:35:02 -04:00
2016-03-14 18:11:43 -04:00
$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 );
2014-04-25 19:35:02 -04:00
2016-03-16 16:27:07 -04:00
// If we don't do the complete check we quit here
if ( ! $complete )
return true ;
2016-03-14 18:11:43 -04:00
$guid = " " ;
preg_match ( " /guid='(.*?)'/ism " , $attributes , $matches );
if ( $matches [ 1 ] != " " )
$guid = $matches [ 1 ];
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
preg_match ( '/guid="(.*?)"/ism' , $attributes , $matches );
if ( $matches [ 1 ] != " " )
$guid = $matches [ 1 ];
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
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 );
}
}
2011-08-24 04:21:24 -04:00
2016-03-14 18:11:43 -04:00
$profile = " " ;
preg_match ( " /profile='(.*?)'/ism " , $attributes , $matches );
if ( $matches [ 1 ] != " " )
$profile = $matches [ 1 ];
2016-01-11 08:24:54 -05:00
2016-03-14 18:11:43 -04:00
preg_match ( '/profile="(.*?)"/ism' , $attributes , $matches );
if ( $matches [ 1 ] != " " )
$profile = $matches [ 1 ];
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$ret = array ();
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$ret [ " root_handle " ] = preg_replace ( " =https?://(.*)/u/(.*)=ism " , " $ 2@ $ 1 " , $profile );
if (( $ret [ " root_handle " ] == $profile ) OR ( $ret [ " root_handle " ] == " " ))
return ( false );
2011-08-23 21:17:35 -04:00
2016-03-14 18:11:43 -04:00
$link = " " ;
preg_match ( " /link='(.*?)'/ism " , $attributes , $matches );
if ( $matches [ 1 ] != " " )
$link = $matches [ 1 ];
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
preg_match ( '/link="(.*?)"/ism' , $attributes , $matches );
if ( $matches [ 1 ] != " " )
$link = $matches [ 1 ];
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
$ret [ " root_guid " ] = preg_replace ( " =https?://(.*)/posts/(.*)=ism " , " $ 2 " , $link );
2016-03-24 16:32:55 -04:00
if (( $ret [ " root_guid " ] == $link ) OR ( trim ( $ret [ " root_guid " ]) == " " ))
2016-03-14 18:11:43 -04:00
return ( false );
2016-03-24 16:32:55 -04:00
2016-03-14 18:11:43 -04:00
return ( $ret );
2011-08-19 00:09:44 -04:00
}
2016-12-28 22:13:57 -05:00
/**
* @ 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 ) {
2016-12-29 18:27:11 -05:00
2016-12-29 22:31:38 -05:00
$r = q ( " SELECT `guid`, `uid`, `start`, `finish`, `nofinish`, `summary`, `desc`, `location`, `adjust` FROM `event` WHERE `id` = %d " , intval ( $event_id ));
2016-12-28 22:13:57 -05:00
if ( ! dbm :: is_result ( $r )) {
return array ();
}
2016-12-29 18:27:11 -05:00
$event = $r [ 0 ];
2016-12-28 22:13:57 -05:00
$eventdata = array ();
2016-12-29 18:27:11 -05:00
$r = q ( " SELECT `timezone` FROM `user` WHERE `uid` = %d " , intval ( $event [ 'uid' ]));
if ( ! dbm :: is_result ( $r )) {
return array ();
}
$user = $r [ 0 ];
2016-12-28 22:13:57 -05:00
2016-12-29 22:31:38 -05:00
$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' ;
2016-12-30 05:03:02 -05:00
/// @todo - establish "all day" events in Friendica
2016-12-29 22:31:38 -05:00
$eventdata [ " all_day " ] = " false " ;
if ( ! $event [ 'adjust' ]) {
2016-12-29 18:27:11 -05:00
$eventdata [ 'timezone' ] = $user [ 'timezone' ];
if ( $eventdata [ 'timezone' ] == " " ) {
$eventdata [ 'timezone' ] = 'UTC' ;
}
2016-12-28 22:13:57 -05:00
}
2016-12-29 18:27:11 -05:00
if ( $event [ 'start' ]) {
2016-12-29 22:31:38 -05:00
$eventdata [ 'start' ] = datetime_convert ( $eventdata [ 'timezone' ], " UTC " , $event [ 'start' ], $mask );
2016-12-28 22:13:57 -05:00
}
2016-12-29 22:31:38 -05:00
if ( $event [ 'finish' ] AND ! $event [ 'nofinish' ]) {
$eventdata [ 'end' ] = datetime_convert ( $eventdata [ 'timezone' ], " UTC " , $event [ 'finish' ], $mask );
2016-12-28 22:13:57 -05:00
}
2016-12-29 18:27:11 -05:00
if ( $event [ 'summary' ]) {
$eventdata [ 'summary' ] = html_entity_decode ( bb2diaspora ( $event [ 'summary' ]));
2016-12-28 22:13:57 -05:00
}
2016-12-29 18:27:11 -05:00
if ( $event [ 'desc' ]) {
$eventdata [ 'description' ] = html_entity_decode ( bb2diaspora ( $event [ 'desc' ]));
2016-12-28 22:13:57 -05:00
}
2016-12-29 18:27:11 -05:00
if ( $event [ 'location' ]) {
2016-12-28 22:13:57 -05:00
$location = array ();
2016-12-29 18:27:11 -05:00
$location [ " address " ] = html_entity_decode ( bb2diaspora ( $event [ 'location' ]));
2016-12-28 22:13:57 -05:00
$location [ " lat " ] = 0 ;
$location [ " lng " ] = 0 ;
$eventdata [ 'location' ] = $location ;
}
return $eventdata ;
}
2016-03-17 18:44:18 -04:00
/**
2016-06-30 01:32:07 -04:00
* @ brief Create a post ( status message or reshare )
2016-03-17 18:44:18 -04:00
*
* @ param array $item The item that will be exported
* @ param array $owner the array of the item owner
*
2016-06-30 01:32:07 -04:00
* @ return array
* 'type' -> Message type ( " status_message " or " reshare " )
* 'message' -> Array of XML elements of the status
2016-03-17 18:44:18 -04:00
*/
2016-06-30 01:32:07 -04:00
public static function build_status ( $item , $owner ) {
2011-08-19 00:09:44 -04:00
2016-12-29 18:27:11 -05:00
$cachekey = " diaspora:build_status: " . $item [ 'guid' ];
$result = Cache :: get ( $cachekey );
if ( ! is_null ( $result )) {
return $result ;
}
2016-03-14 18:11:43 -04:00
$myaddr = self :: my_handle ( $owner );
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
$public = (( $item [ " private " ]) ? " false " : " true " );
2011-08-19 00:09:44 -04:00
2016-12-27 07:59:15 -05:00
$created = datetime_convert ( " UTC " , " UTC " , $item [ " created " ], 'Y-m-d\TH:i:s\Z' );
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
// Detect a share element and do a reshare
if ( ! $item [ 'private' ] AND ( $ret = self :: is_reshare ( $item [ " body " ]))) {
$message = array ( " root_diaspora_id " => $ret [ " root_handle " ],
" root_guid " => $ret [ " root_guid " ],
" guid " => $item [ " guid " ],
" diaspora_handle " => $myaddr ,
" public " => $public ,
" created_at " => $created ,
" provider_display_name " => $item [ " app " ]);
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
$type = " reshare " ;
} else {
$title = $item [ " title " ];
$body = $item [ " body " ];
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
// convert to markdown
$body = html_entity_decode ( bb2diaspora ( $body ));
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
// Adding the title
2017-04-04 13:47:32 -04:00
if ( strlen ( $title ))
2016-03-14 18:11:43 -04:00
$body = " ## " . html_entity_decode ( $title ) . " \n \n " . $body ;
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
if ( $item [ " attach " ]) {
$cnt = preg_match_all ( '/href=\"(.*?)\"(.*?)title=\"(.*?)\"/ism' , $item [ " attach " ], $matches , PREG_SET_ORDER );
2017-04-04 13:47:32 -04:00
if ( cnt ) {
2016-03-14 18:11:43 -04:00
$body .= " \n " . t ( " Attachments: " ) . " \n " ;
2017-04-04 13:47:32 -04:00
foreach ( $matches as $mtch )
2016-03-14 18:11:43 -04:00
$body .= " [ " . $mtch [ 3 ] . " ]( " . $mtch [ 1 ] . " ) \n " ;
}
}
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
$location = array ();
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
if ( $item [ " location " ] != " " )
$location [ " address " ] = $item [ " location " ];
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
if ( $item [ " coord " ] != " " ) {
$coord = explode ( " " , $item [ " coord " ]);
$location [ " lat " ] = $coord [ 0 ];
$location [ " lng " ] = $coord [ 1 ];
}
2012-06-17 01:58:22 -04:00
2016-03-14 18:11:43 -04:00
$message = array ( " raw_message " => $body ,
" location " => $location ,
" guid " => $item [ " guid " ],
" diaspora_handle " => $myaddr ,
" public " => $public ,
" created_at " => $created ,
" provider_display_name " => $item [ " app " ]);
2011-08-19 00:09:44 -04:00
2016-11-13 13:28:55 -05:00
// Diaspora rejects messages when they contain a location without "lat" or "lng"
2016-11-13 12:42:26 -05:00
if ( ! isset ( $location [ " lat " ]) OR ! isset ( $location [ " lng " ])) {
2016-03-14 18:11:43 -04:00
unset ( $message [ " location " ]);
2016-11-13 12:42:26 -05:00
}
2012-06-17 01:58:22 -04:00
2016-12-28 22:13:57 -05:00
if ( $item [ 'event-id' ] > 0 ) {
$event = self :: build_event ( $item [ 'event-id' ]);
if ( count ( $event )) {
$message [ 'event' ] = $event ;
2016-12-29 22:31:38 -05:00
/// @todo Once Diaspora supports it, we will remove the body
// $message['raw_message'] = '';
2016-12-28 22:13:57 -05:00
}
}
2016-03-14 18:11:43 -04:00
$type = " status_message " ;
}
2016-12-29 18:27:11 -05:00
$msg = array ( " type " => $type , " message " => $message );
Cache :: set ( $cachekey , $msg , CACHE_QUARTER_HOUR );
return $msg ;
2016-06-30 01:32:07 -04:00
}
/**
* @ 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 ) {
2016-12-20 12:44:15 -05:00
$status = self :: build_status ( $item , $owner );
2012-06-17 01:58:22 -04:00
2016-06-30 01:32:07 -04:00
return self :: build_and_transmit ( $owner , $contact , $status [ " type " ], $status [ " message " ], $public_batch , $item [ " guid " ]);
2012-06-02 18:11:31 -04:00
}
2012-06-17 01:58:22 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Creates a " like " object
2016-03-17 18:44:18 -04:00
*
* @ param array $item The item that will be exported
* @ param array $owner the array of the item owner
*
2016-03-18 17:28:20 -04:00
* @ return array The data for a " like "
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function construct_like ( $item , $owner ) {
2012-06-17 01:58:22 -04:00
2016-03-14 18:11:43 -04:00
$p = q ( " SELECT `guid`, `uri`, `parent-uri` FROM `item` WHERE `uri` = '%s' LIMIT 1 " ,
dbesc ( $item [ " thr-parent " ]));
2016-12-14 03:42:36 -05:00
if ( ! dbm :: is_result ( $p ))
2016-03-14 18:11:43 -04:00
return false ;
2012-05-31 21:40:12 -04:00
2016-03-14 18:11:43 -04:00
$parent = $p [ 0 ];
2016-01-19 22:22:07 -05:00
2016-03-14 18:11:43 -04:00
$target_type = ( $parent [ " uri " ] === $parent [ " parent-uri " ] ? " Post " : " Comment " );
2016-12-30 17:40:30 -05:00
if ( $item [ 'verb' ] === ACTIVITY_LIKE ) {
$positive = " true " ;
} elseif ( $item [ 'verb' ] === ACTIVITY_DISLIKE ) {
$positive = " false " ;
}
2016-01-19 22:22:07 -05:00
2016-03-14 18:11:43 -04:00
return ( array ( " positive " => $positive ,
" guid " => $item [ " guid " ],
" target_type " => $target_type ,
" parent_guid " => $parent [ " guid " ],
2016-03-19 10:49:47 -04:00
" author_signature " => " " ,
2016-03-17 18:44:18 -04:00
" diaspora_handle " => self :: my_handle ( $owner )));
2016-03-14 18:11:43 -04:00
}
2016-01-19 22:22:07 -05:00
2016-12-30 17:31:21 -05:00
/**
* @ 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 " => " " ));
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Creates the object for a comment
2016-03-17 18:44:18 -04:00
*
* @ param array $item The item that will be exported
* @ param array $owner the array of the item owner
*
2016-03-18 17:28:20 -04:00
* @ return array The data for a comment
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function construct_comment ( $item , $owner ) {
2016-01-19 22:22:07 -05:00
2016-12-30 18:18:31 -05:00
$cachekey = " diaspora:construct_comment: " . $item [ 'guid' ];
$result = Cache :: get ( $cachekey );
if ( ! is_null ( $result )) {
return $result ;
}
2016-03-14 18:11:43 -04:00
$p = q ( " SELECT `guid` FROM `item` WHERE `parent` = %d AND `id` = %d LIMIT 1 " ,
intval ( $item [ " parent " ]),
intval ( $item [ " parent " ])
);
2011-08-28 08:00:30 -04:00
2016-09-18 17:21:18 -04:00
if ( ! dbm :: is_result ( $p ))
2016-03-14 18:11:43 -04:00
return false ;
2012-08-10 00:06:18 -04:00
2016-03-14 18:11:43 -04:00
$parent = $p [ 0 ];
2011-08-26 10:29:22 -04:00
2016-03-14 18:11:43 -04:00
$text = html_entity_decode ( bb2diaspora ( $item [ " body " ]));
2016-12-27 07:59:15 -05:00
$created = datetime_convert ( " UTC " , " UTC " , $item [ " created " ], 'Y-m-d\TH:i:s\Z' );
2016-01-19 22:22:07 -05:00
2016-12-27 07:59:15 -05:00
$comment = array ( " guid " => $item [ " guid " ],
2016-03-14 18:11:43 -04:00
" parent_guid " => $parent [ " guid " ],
" author_signature " => " " ,
" text " => $text ,
2016-12-27 07:59:15 -05:00
/// @todo Currently disabled until Diaspora supports it: "created_at" => $created,
" diaspora_handle " => self :: my_handle ( $owner ));
// 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' ]);
}
2016-12-30 18:18:31 -05:00
Cache :: set ( $cachekey , $comment , CACHE_QUARTER_HOUR );
2016-12-27 07:59:15 -05:00
return ( $comment );
2016-01-19 22:22:07 -05:00
}
2012-06-24 00:04:20 -04:00
2016-03-17 18:44:18 -04:00
/**
* @ 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
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
2016-03-17 18:44:18 -04:00
* @ param bool $public_batch Is it a public post ?
*
* @ return int The result of the transmission
*/
2016-03-14 18:11:43 -04:00
public static function send_followup ( $item , $owner , $contact , $public_batch = false ) {
2011-08-19 00:09:44 -04:00
2016-12-30 17:31:21 -05:00
if ( in_array ( $item [ 'verb' ], array ( ACTIVITY_ATTEND , ACTIVITY_ATTENDNO , ACTIVITY_ATTENDMAYBE ))) {
$message = self :: construct_attend ( $item , $owner );
$type = " event_participation " ;
2016-12-30 17:40:30 -05:00
} elseif ( in_array ( $item [ " verb " ], array ( ACTIVITY_LIKE , ACTIVITY_DISLIKE ))) {
2016-03-14 18:11:43 -04:00
$message = self :: construct_like ( $item , $owner );
$type = " like " ;
} else {
$message = self :: construct_comment ( $item , $owner );
$type = " comment " ;
}
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $message )
return false ;
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
$message [ " author_signature " ] = self :: signature ( $owner , $message );
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
return self :: build_and_transmit ( $owner , $contact , $type , $message , $public_batch , $item [ " guid " ]);
}
2011-08-19 00:09:44 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Creates a message from a signature record entry
2016-03-17 18:44:18 -04:00
*
* @ param array $item The item that will be exported
2016-03-18 03:07:23 -04:00
* @ param array $signature The entry of the " sign " record
2016-03-17 18:44:18 -04:00
*
2016-03-18 03:07:23 -04:00
* @ return string The message
2016-03-17 18:44:18 -04:00
*/
2016-12-29 18:27:11 -05:00
private static function message_from_signature ( $item , $signature ) {
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
// Split the signed text
$signed_parts = explode ( " ; " , $signature [ 'signed_text' ]);
if ( $item [ " deleted " ])
$message = array ( " parent_author_signature " => " " ,
" target_guid " => $signed_parts [ 0 ],
" target_type " => $signed_parts [ 1 ],
" sender_handle " => $signature [ 'signer' ],
" target_author_signature " => $signature [ 'signature' ]);
elseif ( $item [ 'verb' ] === ACTIVITY_LIKE )
$message = array ( " positive " => $signed_parts [ 0 ],
" guid " => $signed_parts [ 1 ],
" target_type " => $signed_parts [ 2 ],
" parent_guid " => $signed_parts [ 3 ],
" parent_author_signature " => " " ,
" author_signature " => $signature [ 'signature' ],
" diaspora_handle " => $signed_parts [ 4 ]);
else {
// Remove the comment guid
$guid = array_shift ( $signed_parts );
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
// Remove the parent guid
$parent_guid = array_shift ( $signed_parts );
2011-08-19 00:09:44 -04:00
2016-03-14 18:11:43 -04:00
// Remove the handle
$handle = array_pop ( $signed_parts );
2012-05-31 21:40:12 -04:00
2016-03-14 18:11:43 -04:00
// Glue the parts together
$text = implode ( " ; " , $signed_parts );
2015-05-25 07:27:45 -04:00
2016-03-14 18:11:43 -04:00
$message = array ( " guid " => $guid ,
" parent_guid " => $parent_guid ,
" parent_author_signature " => " " ,
" author_signature " => $signature [ 'signature' ],
" text " => implode ( " ; " , $signed_parts ),
" diaspora_handle " => $handle );
}
return $message ;
2012-05-31 21:40:12 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Relays messages ( like , comment , retraction ) to other servers if we are the thread owner
2016-03-17 18:44:18 -04:00
*
* @ param array $item The item that will be exported
* @ param array $owner the array of the item owner
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
2016-03-17 18:44:18 -04:00
* @ param bool $public_batch Is it a public post ?
*
* @ return int The result of the transmission
*/
2016-03-14 18:11:43 -04:00
public static function send_relay ( $item , $owner , $contact , $public_batch = false ) {
2011-11-05 17:45:29 -04:00
2016-03-17 07:24:23 -04:00
if ( $item [ " deleted " ])
return self :: send_retraction ( $item , $owner , $contact , $public_batch , true );
elseif ( $item [ 'verb' ] === ACTIVITY_LIKE )
2016-03-14 18:11:43 -04:00
$type = " like " ;
2016-03-17 07:24:23 -04:00
else
2016-03-14 18:11:43 -04:00
$type = " comment " ;
2011-08-24 04:21:24 -04:00
2016-03-14 18:11:43 -04:00
logger ( " Got relayable data " . $type . " for item " . $item [ " guid " ] . " ( " . $item [ " id " ] . " ) " , LOGGER_DEBUG );
2011-12-06 03:16:13 -05:00
2016-03-14 18:11:43 -04:00
// fetch the original signature
2011-12-06 03:16:13 -05:00
2016-03-17 07:24:23 -04:00
$r = q ( " SELECT `signed_text`, `signature`, `signer` FROM `sign` WHERE `iid` = %d LIMIT 1 " ,
2016-03-14 18:11:43 -04:00
intval ( $item [ " id " ]));
2011-12-06 03:16:13 -05:00
2016-03-15 15:14:08 -04:00
if ( ! $r ) {
2016-03-16 19:37:44 -04:00
logger ( " Couldn't fetch signatur for item " . $item [ " guid " ] . " ( " . $item [ " id " ] . " ) " , LOGGER_DEBUG );
2016-03-15 15:14:08 -04:00
return false ;
}
2011-12-06 03:16:13 -05:00
2016-03-14 18:11:43 -04:00
$signature = $r [ 0 ];
2011-12-06 03:16:13 -05:00
2016-03-14 18:11:43 -04:00
// Old way - is used by the internal Friendica functions
/// @todo Change all signatur storing functions to the new format
if ( $signature [ 'signed_text' ] AND $signature [ 'signature' ] AND $signature [ 'signer' ])
2016-03-18 03:07:23 -04:00
$message = self :: message_from_signature ( $item , $signature );
2016-03-14 18:11:43 -04:00
else { // New way
$msg = json_decode ( $signature [ 'signed_text' ], true );
2011-12-06 03:16:13 -05:00
2016-03-14 18:11:43 -04:00
$message = array ();
2016-03-16 14:30:46 -04:00
if ( is_array ( $msg )) {
foreach ( $msg AS $field => $data ) {
if ( ! $item [ " deleted " ]) {
if ( $field == " author " )
$field = " diaspora_handle " ;
if ( $field == " parent_type " )
$field = " target_type " ;
}
$message [ $field ] = $data ;
2016-03-14 18:11:43 -04:00
}
2016-03-16 14:30:46 -04:00
} else
logger ( " Signature text for item " . $item [ " guid " ] . " ( " . $item [ " id " ] . " ) couldn't be extracted: " . $signature [ 'signed_text' ], LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
}
2011-12-06 03:16:13 -05:00
2016-03-17 07:24:23 -04:00
$message [ " parent_author_signature " ] = self :: signature ( $owner , $message );
2011-08-24 04:21:24 -04:00
2016-03-14 18:11:43 -04:00
logger ( " Relayed data " . print_r ( $message , true ), LOGGER_DEBUG );
2011-08-24 04:21:24 -04:00
2016-03-14 18:11:43 -04:00
return self :: build_and_transmit ( $owner , $contact , $type , $message , $public_batch , $item [ " guid " ]);
2012-04-04 23:48:35 -04:00
}
2016-03-17 18:44:18 -04:00
/**
2016-03-18 03:07:23 -04:00
* @ brief Sends a retraction ( deletion ) of a message , like or comment
2016-03-17 18:44:18 -04:00
*
* @ param array $item The item that will be exported
* @ param array $owner the array of the item owner
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
2016-03-17 18:44:18 -04:00
* @ param bool $public_batch Is it a public post ?
2016-03-18 03:07:23 -04:00
* @ param bool $relay Is the retraction transmitted from a relay ?
2016-03-17 18:44:18 -04:00
*
* @ return int The result of the transmission
*/
2016-03-17 07:24:23 -04:00
public static function send_retraction ( $item , $owner , $contact , $public_batch = false , $relay = false ) {
2016-03-16 19:37:44 -04:00
2016-03-17 07:24:23 -04:00
$itemaddr = self :: handle_from_contact ( $item [ " contact-id " ], $item [ " gcontact-id " ]);
2011-11-06 19:48:13 -05:00
2016-03-14 18:11:43 -04:00
// Check whether the retraction is for a top-level post or whether it's a relayable
if ( $item [ " uri " ] !== $item [ " parent-uri " ]) {
$msg_type = " relayable_retraction " ;
$target_type = (( $item [ " verb " ] === ACTIVITY_LIKE ) ? " Like " : " Comment " );
2013-10-02 16:17:56 -04:00
} else {
2016-03-14 18:11:43 -04:00
$msg_type = " signed_retraction " ;
$target_type = " StatusMessage " ;
2012-05-07 18:54:49 -04:00
}
2016-03-14 18:11:43 -04:00
2016-03-17 07:24:23 -04:00
if ( $relay AND ( $item [ " uri " ] !== $item [ " parent-uri " ]))
$signature = " parent_author_signature " ;
else
$signature = " target_author_signature " ;
2016-03-14 18:11:43 -04:00
$signed_text = $item [ " guid " ] . " ; " . $target_type ;
$message = array ( " target_guid " => $item [ 'guid' ],
" target_type " => $target_type ,
2016-03-16 19:37:44 -04:00
" sender_handle " => $itemaddr ,
2016-03-17 07:24:23 -04:00
$signature => base64_encode ( rsa_sign ( $signed_text , $owner [ 'uprvkey' ], 'sha256' )));
2016-03-16 19:37:44 -04:00
logger ( " Got message " . print_r ( $message , true ), LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
return self :: build_and_transmit ( $owner , $contact , $msg_type , $message , $public_batch , $item [ " guid " ]);
2012-01-26 23:46:42 -05:00
}
2013-10-02 16:17:56 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Sends a mail
2016-03-17 18:44:18 -04:00
*
* @ param array $item The item that will be exported
* @ param array $owner The owner
2016-03-18 03:07:23 -04:00
* @ param array $contact Target of the communication
2016-03-17 18:44:18 -04:00
*
* @ return int The result of the transmission
*/
2016-03-14 18:11:43 -04:00
public static function send_mail ( $item , $owner , $contact ) {
2011-08-24 04:21:24 -04:00
2016-03-14 18:11:43 -04:00
$myaddr = self :: my_handle ( $owner );
2011-11-06 19:48:13 -05:00
2016-03-14 18:11:43 -04:00
$r = q ( " SELECT * FROM `conv` WHERE `id` = %d AND `uid` = %d LIMIT 1 " ,
intval ( $item [ " convid " ]),
intval ( $item [ " uid " ])
2011-11-06 19:48:13 -05:00
);
2011-08-19 00:09:44 -04:00
2016-09-18 17:21:18 -04:00
if ( ! dbm :: is_result ( $r )) {
2016-03-14 18:11:43 -04:00
logger ( " conversation not found. " );
return ;
}
$cnv = $r [ 0 ];
$conv = array (
" guid " => $cnv [ " guid " ],
" subject " => $cnv [ " subject " ],
2016-12-27 07:59:15 -05:00
" created_at " => datetime_convert ( " UTC " , " UTC " , $cnv [ 'created' ], 'Y-m-d\TH:i:s\Z' ),
2016-03-14 18:11:43 -04:00
" diaspora_handle " => $cnv [ " creator " ],
" participant_handles " => $cnv [ " recips " ]
);
2011-09-27 22:27:47 -04:00
2016-03-14 18:11:43 -04:00
$body = bb2diaspora ( $item [ " body " ]);
2016-12-27 07:59:15 -05:00
$created = datetime_convert ( " UTC " , " UTC " , $item [ " created " ], 'Y-m-d\TH:i:s\Z' );
2016-03-14 18:11:43 -04:00
$signed_text = $item [ " guid " ] . " ; " . $cnv [ " guid " ] . " ; " . $body . " ; " . $created . " ; " . $myaddr . " ; " . $cnv [ 'guid' ];
$sig = base64_encode ( rsa_sign ( $signed_text , $owner [ " uprvkey " ], " sha256 " ));
$msg = array (
" guid " => $item [ " guid " ],
" parent_guid " => $cnv [ " guid " ],
" parent_author_signature " => $sig ,
" author_signature " => $sig ,
" text " => $body ,
" created_at " => $created ,
" diaspora_handle " => $myaddr ,
" conversation_guid " => $cnv [ " guid " ]
);
2015-08-09 14:39:11 -04:00
2016-03-14 18:11:43 -04:00
if ( $item [ " reply " ]) {
$message = $msg ;
$type = " message " ;
} else {
$message = array ( " guid " => $cnv [ " guid " ],
" subject " => $cnv [ " subject " ],
2016-12-27 07:59:15 -05:00
" created_at " => datetime_convert ( " UTC " , " UTC " , $cnv [ 'created' ], 'Y-m-d\TH:i:s\Z' ),
2016-03-14 18:11:43 -04:00
" message " => $msg ,
" diaspora_handle " => $cnv [ " creator " ],
" participant_handles " => $cnv [ " recips " ]);
$type = " conversation " ;
}
2015-08-09 14:39:11 -04:00
2016-03-14 18:11:43 -04:00
return self :: build_and_transmit ( $owner , $contact , $type , $message , false , $item [ " guid " ]);
}
2015-08-09 14:39:11 -04:00
2016-03-17 18:44:18 -04:00
/**
2016-03-18 17:28:20 -04:00
* @ brief Sends profile data
2016-03-17 18:44:18 -04:00
*
* @ param int $uid The user id
*/
2016-07-10 07:11:09 -04:00
public static function send_profile ( $uid , $recips = false ) {
2015-08-09 14:39:11 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $uid )
return ;
2015-08-09 14:39:11 -04:00
2016-07-10 07:11:09 -04:00
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 )
);
2016-03-14 18:11:43 -04:00
if ( ! $recips )
return ;
2015-08-09 14:39:11 -04:00
2016-03-14 18:11:43 -04:00
$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 )
);
2015-08-09 14:39:11 -04:00
2016-03-14 18:11:43 -04:00
if ( ! $r )
return ;
2015-08-09 14:39:11 -04:00
2016-03-14 18:11:43 -04:00
$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 = App :: get_baseurl () . '/photo/custom/300/' . $profile [ 'uid' ] . '.jpg' ;
$medium = App :: get_baseurl () . '/photo/custom/100/' . $profile [ 'uid' ] . '.jpg' ;
$small = App :: get_baseurl () . '/photo/custom/50/' . $profile [ 'uid' ] . '.jpg' ;
$searchable = (( $profile [ 'publish' ] && $profile [ 'net-publish' ]) ? 'true' : 'false' );
if ( $searchable === 'true' ) {
$dob = '1000-00-00' ;
2017-04-11 17:00:45 -04:00
if (( $profile [ 'dob' ]) && ( $profile [ 'dob' ] > '0001-01-01' ))
2016-03-14 18:11:43 -04:00
$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 )) {
2017-04-04 13:47:32 -04:00
for ( $x = 0 ; $x < 5 ; $x ++ ) {
2016-03-14 18:11:43 -04:00
if ( trim ( $arr [ $x ]))
$tags .= '#' . trim ( $arr [ $x ]) . ' ' ;
}
}
}
$tags = trim ( $tags );
}
2015-08-09 14:39:11 -04:00
2016-03-14 18:11:43 -04:00
$message = array ( " diaspora_handle " => $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 ,
" tag_string " => $tags );
2017-04-04 13:47:32 -04:00
foreach ( $recips as $recip ) {
2016-07-10 07:11:09 -04:00
logger ( " Send updated profile data for user " . $uid . " to contact " . $recip [ " id " ], LOGGER_DEBUG );
2016-03-14 18:11:43 -04:00
self :: build_and_transmit ( $profile , $recip , " profile " , $message , false , " " , true );
2016-07-10 07:11:09 -04:00
}
2015-08-09 14:39:11 -04:00
}
2016-03-19 10:49:47 -04:00
/**
* @ 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
*/
2016-03-23 17:12:08 -04:00
public static function store_like_signature ( $contact , $post_id ) {
2016-03-19 10:49:47 -04:00
// Is the contact the owner? Then fetch the private key
if ( ! $contact [ 'self' ] OR ( $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' ]));
2017-04-04 13:47:32 -04:00
if ( ! dbm :: is_result ( $r )) {
2016-03-19 10:49:47 -04:00
return false ;
2017-04-04 13:47:32 -04:00
}
2016-03-19 10:49:47 -04:00
$contact [ " uprvkey " ] = $r [ 0 ][ 'prvkey' ];
$r = q ( " SELECT * FROM `item` WHERE `id` = %d LIMIT 1 " , intval ( $post_id ));
2017-04-04 13:47:32 -04:00
if ( ! dbm :: is_result ( $r )) {
2016-03-19 10:49:47 -04:00
return false ;
2017-04-04 13:47:32 -04:00
}
2016-03-19 10:49:47 -04:00
2017-04-04 13:47:32 -04:00
if ( ! in_array ( $r [ 0 ][ " verb " ], array ( ACTIVITY_LIKE , ACTIVITY_DISLIKE ))) {
2016-03-19 10:49:47 -04:00
return false ;
2017-04-04 13:47:32 -04:00
}
2016-03-19 10:49:47 -04:00
$message = self :: construct_like ( $r [ 0 ], $contact );
$message [ " author_signature " ] = self :: signature ( $contact , $message );
2016-12-28 08:30:55 -05:00
// We now store the signature more flexible to dynamically support new fields.
// This will break Diaspora compatibility with Friendica versions prior to 3.5.
q ( " INSERT INTO `sign` (`iid`,`signed_text`) VALUES (%d,'%s') " ,
intval ( $message_id ),
dbesc ( json_encode ( $message ))
2016-03-19 10:49:47 -04:00
);
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
*/
2016-03-23 17:12:08 -04:00
public static function store_comment_signature ( $item , $contact , $uprvkey , $message_id ) {
2016-03-19 10:49:47 -04:00
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 );
2016-12-28 08:30:55 -05:00
// We now store the signature more flexible to dynamically support new fields.
// This will break Diaspora compatibility with Friendica versions prior to 3.5.
q ( " INSERT INTO `sign` (`iid`,`signed_text`) VALUES (%d,'%s') " ,
2016-03-19 10:49:47 -04:00
intval ( $message_id ),
2016-12-28 08:30:55 -05:00
dbesc ( json_encode ( $message ))
2016-03-19 10:49:47 -04:00
);
logger ( 'Stored diaspora comment signature' );
return true ;
}
2015-08-09 14:39:11 -04:00
}
2016-03-14 18:11:43 -04:00
?>