function probe_content(&$a)
{
    $o .= '<h3>Probe Diagnostic</h3>';
    $o .= '<form action="probe" method="get">';
    $o .= 'Lookup address: <input type="text" style="width: 250px;" name="addr" value="' . $_GET['addr'] . '" />';
    $o .= '<input type="submit" name="submit" value="Submit" /></form>';
    $o .= '<br /><br />';
    if (x($_GET, 'addr')) {
        $channel = $a->get_channel();
        $addr = trim($_GET['addr']);
        $res = zot_finger($addr, $channel, false);
        $o .= '<pre>';
        if ($res['success']) {
            $j = json_decode($res['body'], true);
        } else {
            $o .= sprintf(t('Fetching URL returns error: %1$s'), $res['error'] . "\r\n\r\n");
            $o .= "<strong>https connection failed. Trying again with auto failover to http.</strong>\r\n\r\n";
            $res = zot_finger($addr, $channel, true);
            if ($res['success']) {
                $j = json_decode($res['body'], true);
            } else {
                $o .= sprintf(t('Fetching URL returns error: %1$s'), $res['error'] . "\r\n\r\n");
            }
        }
        if ($j && $j['permissions'] && $j['permissions']['iv']) {
            $j['permissions'] = json_decode(crypto_unencapsulate($j['permissions'], $channel['channel_prvkey']), true);
        }
        $o .= str_replace("\n", '<br />', print_r($j, true));
        $o .= '</pre>';
    }
    return $o;
}

 function GetHublocs($address)
 {
     // Try and find a hubloc for the person attempting to auth.
     // Since we're matching by address, we have to return all entries
     // some of which may be from re-installed hubs; and we'll need to
     // try each sequentially to see if one can pass the test
     $x = q("select * from hubloc left join xchan on xchan_hash = hubloc_hash \n\t\t\twhere hubloc_addr = '%s' order by hubloc_id desc", dbesc($address));
     if (!$x) {
         // finger them if they can't be found.
         $ret = zot_finger($address, null);
         if ($ret['success']) {
             $j = json_decode($ret['body'], true);
             if ($j) {
                 import_xchan($j);
             }
             $x = q("select * from hubloc left join xchan on xchan_hash = hubloc_hash \n\t\t\t\t\twhere hubloc_addr = '%s' order by hubloc_id desc", dbesc($address));
         }
     }
     if (!$x) {
         logger('mod_zot: auth: unable to finger ' . $address);
         $this->Debug('no hubloc found for ' . $address . ' and probing failed.');
         $this->Finalise();
     }
     return $x;
 }

function gprobe_run($argv, $argc)
{
    cli_startup();
    $a = get_app();
    if ($argc != 2) {
        return;
    }
    $url = hex2bin($argv[1]);
    $r = q("select * from xchan where xchan_addr = '%s' limit 1", dbesc($url));
    if (!$r) {
        $x = zot_finger($url, null);
        if ($x['success']) {
            $j = json_decode($x['body'], true);
            $y = import_xchan($j);
        }
    }
    return;
}

 function GetHublocs($address)
 {
     // Try and find a hubloc for the person attempting to auth
     $x = q("select * from hubloc left join xchan on xchan_hash = hubloc_hash \n\t\t\twhere hubloc_addr = '%s' order by hubloc_id desc", dbesc($address));
     if (!$x) {
         // finger them if they can't be found.
         $ret = zot_finger($address, null);
         if ($ret['success']) {
             $j = json_decode($ret['body'], true);
             if ($j) {
                 import_xchan($j);
             }
             $x = q("select * from hubloc left join xchan on xchan_hash = hubloc_hash \n\t\t\t\t\twhere hubloc_addr = '%s' order by hubloc_id desc", dbesc($address));
         }
     }
     if (!$x) {
         logger('mod_zot: auth: unable to finger ' . $address);
         $this->reply_die('no hubloc found for ' . $address . ' and probing failed.');
     }
     return $x;
 }

function chanview_content(&$a)
{
    $observer = $a->get_observer();
    $xchan = null;
    $r = null;
    if ($_REQUEST['hash']) {
        $r = q("select * from xchan where xchan_hash = '%s' limit 1", dbesc($_REQUEST['hash']));
    }
    if ($_REQUEST['address']) {
        $r = q("select * from xchan where xchan_addr = '%s' limit 1", dbesc($_REQUEST['address']));
    } elseif (local_channel() && intval($_REQUEST['cid'])) {
        $r = q("SELECT abook.*, xchan.* \n\t\t\tFROM abook left join xchan on abook_xchan = xchan_hash\n\t\t\tWHERE abook_channel = %d and abook_id = %d LIMIT 1", intval(local_channel()), intval($_REQUEST['cid']));
    } elseif ($_REQUEST['url']) {
        // if somebody re-installed they will have more than one xchan, use the most recent name date as this is
        // the most useful consistently ascending table item we have.
        $r = q("select * from xchan where xchan_url = '%s' order by xchan_name_date desc limit 1", dbesc($_REQUEST['url']));
    }
    if ($r) {
        $a->poi = $r[0];
    }
    // Here, let's see if we have an xchan. If we don't, how we proceed is determined by what
    // info we do have. If it's a URL, we can offer to visit it directly. If it's a webbie or
    // address, we can and should try to import it. If it's just a hash, we can't continue, but we
    // probably wouldn't have a hash if we don't already have an xchan for this channel.
    if (!$a->poi) {
        logger('mod_chanview: fallback');
        // This is hackish - construct a zot address from the url
        if ($_REQUEST['url']) {
            if (preg_match('/https?\\:\\/\\/(.*?)(\\/channel\\/|\\/profile\\/)(.*?)$/ism', $_REQUEST['url'], $matches)) {
                $_REQUEST['address'] = $matches[3] . '@' . $matches[1];
            }
            logger('mod_chanview: constructed address ' . print_r($matches, true));
        }
        if ($_REQUEST['address']) {
            $ret = zot_finger($_REQUEST['address'], null);
            if ($ret['success']) {
                $j = json_decode($ret['body'], true);
                if ($j) {
                    import_xchan($j);
                }
                $r = q("select * from xchan where xchan_addr = '%s' limit 1", dbesc($_REQUEST['address']));
                if ($r) {
                    $a->poi = $r[0];
                }
            }
        }
    }
    if (!$a->poi) {
        //		We don't know who this is, and we can't figure it out from the URL
        //		On the plus side, there's a good chance we know somebody else at that
        //		hub so sending them there with a Zid will probably work anyway.
        $url = $_REQUEST['url'];
        if ($observer) {
            $url = zid($url);
        }
    }
    if ($a->poi) {
        $url = $a->poi['xchan_url'];
        if ($observer) {
            $url = zid($url);
        }
    }
    // let somebody over-ride the iframed viewport presentation
    // or let's just declare this a failed experiment.
    //	if((! local_channel()) || (get_pconfig(local_channel(),'system','chanview_full')))
    goaway($url);
    //	$o = replace_macros(get_markup_template('chanview.tpl'),array(
    //		'$url' => $url,
    //		'$full' => t('toggle full screen mode')
    //	));
    //	return $o;
}

/**
 * @brief
 *
 * Given an update record, probe the channel, grab a zot-info packet and refresh/sync the data.
 *
 * Ignore updating records marked as deleted.
 *
 * If successful, sets ud_last in the DB to the current datetime for this
 * reddress/webbie.
 *
 * @param array $ud Entry from update table
 */
function update_directory_entry($ud)
{
    logger('update_directory_entry: ' . print_r($ud, true), LOGGER_DATA);
    if ($ud['ud_addr'] && !($ud['ud_flags'] & UPDATE_FLAGS_DELETED)) {
        $success = false;
        $x = zot_finger($ud['ud_addr'], '');
        if ($x['success']) {
            $j = json_decode($x['body'], true);
            if ($j) {
                $success = true;
            }
            $y = import_xchan($j, 0, $ud);
        }
        if (!$success) {
            q("update updates set ud_last = '%s' where ud_addr = '%s'", dbesc(datetime_convert()), dbesc($ud['ud_addr']));
        }
    }
}

function mail_post(&$a)
{
    if (!local_user()) {
        return;
    }
    $replyto = x($_REQUEST, 'replyto') ? notags(trim($_REQUEST['replyto'])) : '';
    $subject = x($_REQUEST, 'subject') ? notags(trim($_REQUEST['subject'])) : '';
    $body = x($_REQUEST, 'body') ? escape_tags(trim($_REQUEST['body'])) : '';
    $recipient = x($_REQUEST, 'messageto') ? notags(trim($_REQUEST['messageto'])) : '';
    $rstr = x($_REQUEST, 'messagerecip') ? notags(trim($_REQUEST['messagerecip'])) : '';
    $expires = x($_REQUEST, 'expires') ? datetime_convert(date_default_timezone_get(), 'UTC', $_REQUEST['expires']) : NULL_DATE;
    // If we have a raw string for a recipient which hasn't been auto-filled,
    // it means they probably aren't in our address book, hence we don't know
    // if we have permission to send them private messages.
    // finger them and find out before we try and send it.
    if (!$recipient) {
        $channel = $a->get_channel();
        $ret = zot_finger($rstr, $channel);
        if (!$ret['success']) {
            notice(t('Unable to lookup recipient.') . EOL);
            return;
        }
        $j = json_decode($ret['body'], true);
        logger('message_post: lookup: ' . $url . ' ' . print_r($j, true));
        if (!($j['success'] && $j['guid'])) {
            notice(t('Unable to communicate with requested channel.'));
            return;
        }
        $x = import_xchan($j);
        if (!$x['success']) {
            notice(t('Cannot verify requested channel.'));
            return;
        }
        $recipient = $x['hash'];
        $their_perms = 0;
        $global_perms = get_perms();
        if ($j['permissions']['data']) {
            $permissions = crypto_unencapsulate($j['permissions'], $channel['channel_prvkey']);
            if ($permissions) {
                $permissions = json_decode($permissions);
            }
            logger('decrypted permissions: ' . print_r($permissions, true), LOGGER_DATA);
        } else {
            $permissions = $j['permissions'];
        }
        foreach ($permissions as $k => $v) {
            if ($v) {
                $their_perms = $their_perms | intval($global_perms[$k][1]);
            }
        }
        if (!($their_perms & PERMS_W_MAIL)) {
            notice(t('Selected channel has private message restrictions. Send failed.'));
            return;
        }
    }
    //	if(feature_enabled(local_user(),'richtext')) {
    //		$body = fix_mce_lf($body);
    //	}
    if (!$recipient) {
        notice('No recipient found.');
        $a->argc = 2;
        $a->argv[1] = 'new';
        return;
    }
    // We have a local_user, let send_message use the session channel and save a lookup
    $ret = send_message(0, $recipient, $body, $subject, $replyto, $expires);
    if (!$ret['success']) {
        notice($ret['message']);
    }
    goaway(z_root() . '/message');
}

function new_contact($uid, $url, $channel, $interactive = false, $confirm = false)
{
    $result = array('success' => false, 'message' => '');
    $a = get_app();
    $is_red = false;
    $is_http = strpos($url, '://') !== false ? true : false;
    if ($is_http && substr($url, -1, 1) === '/') {
        $url = substr($url, 0, -1);
    }
    if (!allowed_url($url)) {
        $result['message'] = t('Channel is blocked on this site.');
        return $result;
    }
    if (!$url) {
        $result['message'] = t('Channel location missing.');
        return $result;
    }
    // check service class limits
    $r = q("select count(*) as total from abook where abook_channel = %d and abook_self = 0 ", intval($uid));
    if ($r) {
        $total_channels = $r[0]['total'];
    }
    if (!service_class_allows($uid, 'total_channels', $total_channels)) {
        $result['message'] = upgrade_message();
        return $result;
    }
    $arr = array('url' => $url, 'channel' => array());
    call_hooks('follow', $arr);
    if ($arr['channel']['success']) {
        $ret = $arr['channel'];
    } elseif (!$is_http) {
        $ret = zot_finger($url, $channel);
    }
    if ($ret && $ret['success']) {
        $is_red = true;
        $j = json_decode($ret['body'], true);
    }
    $my_perms = get_channel_default_perms($uid);
    $role = get_pconfig($uid, 'system', 'permissions_role');
    if ($role) {
        $x = get_role_perms($role);
        if ($x['perms_follow']) {
            $my_perms = $x['perms_follow'];
        }
    }
    if ($is_red && $j) {
        logger('follow: ' . $url . ' ' . print_r($j, true), LOGGER_DEBUG);
        if (!($j['success'] && $j['guid'])) {
            $result['message'] = t('Response from remote channel was incomplete.');
            logger('mod_follow: ' . $result['message']);
            return $result;
        }
        // Premium channel, set confirm before callback to avoid recursion
        if (array_key_exists('connect_url', $j) && $interactive && !$confirm) {
            goaway(zid($j['connect_url']));
        }
        // do we have an xchan and hubloc?
        // If not, create them.
        $x = import_xchan($j);
        if (array_key_exists('deleted', $j) && intval($j['deleted'])) {
            $result['message'] = t('Channel was deleted and no longer exists.');
            return $result;
        }
        if (!$x['success']) {
            return $x;
        }
        $xchan_hash = $x['hash'];
        $their_perms = 0;
        $global_perms = get_perms();
        if (array_key_exists('permissions', $j) && array_key_exists('data', $j['permissions'])) {
            $permissions = crypto_unencapsulate(array('data' => $j['permissions']['data'], 'key' => $j['permissions']['key'], 'iv' => $j['permissions']['iv']), $channel['channel_prvkey']);
            if ($permissions) {
                $permissions = json_decode($permissions, true);
            }
            logger('decrypted permissions: ' . print_r($permissions, true), LOGGER_DATA);
        } else {
            $permissions = $j['permissions'];
        }
        foreach ($permissions as $k => $v) {
            if ($v) {
                $their_perms = $their_perms | intval($global_perms[$k][1]);
            }
        }
    } else {
        $their_perms = 0;
        $xchan_hash = '';
        $r = q("select * from xchan where xchan_hash = '%s' or xchan_url = '%s' limit 1", dbesc($url), dbesc($url));
        if (!$r) {
            // attempt network auto-discovery
            if (strpos($url, '@') && !$is_http) {
                $r = discover_by_webbie($url);
            } elseif ($is_http) {
                $r = discover_by_url($url);
                $r['allowed'] = intval(get_config('system', 'feed_contacts'));
            }
            if ($r) {
                $r['channel_id'] = $uid;
                call_hooks('follow_allow', $r);
                if (!$r['allowed']) {
                    $result['message'] = t('Protocol disabled.');
//.........这里部分代码省略.........

 function init()
 {
     $ret = array('success' => false, 'url' => '', 'message' => '');
     logger('mod_magic: invoked', LOGGER_DEBUG);
     logger('mod_magic: args: ' . print_r($_REQUEST, true), LOGGER_DATA);
     $addr = x($_REQUEST, 'addr') ? $_REQUEST['addr'] : '';
     $dest = x($_REQUEST, 'dest') ? $_REQUEST['dest'] : '';
     $test = x($_REQUEST, 'test') ? intval($_REQUEST['test']) : 0;
     $rev = x($_REQUEST, 'rev') ? intval($_REQUEST['rev']) : 0;
     $delegate = x($_REQUEST, 'delegate') ? $_REQUEST['delegate'] : '';
     $parsed = parse_url($dest);
     if (!$parsed) {
         if ($test) {
             $ret['message'] .= 'could not parse ' . $dest . EOL;
             return $ret;
         }
         goaway($dest);
     }
     $basepath = $parsed['scheme'] . '://' . $parsed['host'] . ($parsed['port'] ? ':' . $parsed['port'] : '');
     $x = q("select * from hubloc where hubloc_url = '%s' order by hubloc_connected desc limit 1", dbesc($basepath));
     if (!$x) {
         /*
          * We have no records for, or prior communications with this hub. 
          * If an address was supplied, let's finger them to create a hub record. 
          * Otherwise we'll use the special address '[system]' which will return
          * either a system channel or the first available normal channel. We don't
          * really care about what channel is returned - we need the hub information 
          * from that response so that we can create signed auth packets destined 
          * for that hub.
          *
          */
         $ret = zot_finger($addr ? $addr : '[system]@' . $parsed['host'], null);
         if ($ret['success']) {
             $j = json_decode($ret['body'], true);
             if ($j) {
                 import_xchan($j);
             }
             // Now try again
             $x = q("select * from hubloc where hubloc_url = '%s' order by hubloc_connected desc limit 1", dbesc($basepath));
         }
     }
     if (!$x) {
         if ($rev) {
             goaway($dest);
         } else {
             logger('mod_magic: no channels found for requested hub.' . print_r($_REQUEST, true));
             if ($test) {
                 $ret['message'] .= 'This site has no previous connections with ' . $basepath . EOL;
                 return $ret;
             }
             notice(t('Hub not found.') . EOL);
             return;
         }
     }
     // This is ready-made for a plugin that provides a blacklist or "ask me" before blindly authenticating.
     // By default, we'll proceed without asking.
     $arr = array('channel_id' => local_channel(), 'xchan' => $x[0], 'destination' => $dest, 'proceed' => true);
     call_hooks('magic_auth', $arr);
     $dest = $arr['destination'];
     if (!$arr['proceed']) {
         if ($test) {
             $ret['message'] .= 'cancelled by plugin.' . EOL;
             return $ret;
         }
         goaway($dest);
     }
     if (get_observer_hash() && $x[0]['hubloc_url'] === z_root()) {
         // We are already authenticated on this site and a registered observer.
         // Just redirect.
         if ($test) {
             $ret['success'] = true;
             $ret['message'] .= 'Local site - you are already authenticated.' . EOL;
             return $ret;
         }
         $delegation_success = false;
         if ($delegate) {
             $r = q("select * from channel left join hubloc on channel_hash = hubloc_hash where hubloc_addr = '%s' limit 1", dbesc($delegate));
             if ($r && intval($r[0]['channel_id'])) {
                 $allowed = perm_is_allowed($r[0]['channel_id'], get_observer_hash(), 'delegate');
                 if ($allowed) {
                     $_SESSION['delegate_channel'] = $r[0]['channel_id'];
                     $_SESSION['delegate'] = get_observer_hash();
                     $_SESSION['account_id'] = intval($r[0]['channel_account_id']);
                     change_channel($r[0]['channel_id']);
                     $delegation_success = true;
                 }
             }
         }
         // FIXME: check and honour local delegation
         goaway($dest);
     }
     if (local_channel()) {
         $channel = \App::get_channel();
         $token = random_string();
         $token_sig = base64url_encode(rsa_sign($token, $channel['channel_prvkey']));
         $channel['token'] = $token;
         $channel['token_sig'] = $token_sig;
         \Zotlabs\Zot\Verify::create('auth', $channel['channel_id'], $token, $x[0]['hubloc_url']);
         $target_url = $x[0]['hubloc_callback'] . '/?f=&auth=' . urlencode($channel['channel_address'] . '@' . \App::get_hostname()) . '&sec=' . $token . '&dest=' . urlencode($dest) . '&version=' . ZOT_REVISION;
         if ($delegate) {
//.........这里部分代码省略.........

function post_init(&$a)
{
    // Most access to this endpoint is via the post method.
    // Here we will pick out the magic auth params which arrive
    // as a get request, and the only communications to arrive this way.
    /**
     * Magic Auth
     * ==========
     *
     * So-called "magic auth" takes place by a special exchange. On the site where the "channel to be authenticated" lives (e.g. $mysite), 
     * a redirection is made via $mysite/magic to the zot endpoint of the remote site ($remotesite) with special GET parameters.
     *
     * The endpoint is typically  https://$remotesite/post - or whatever was specified as the callback url in prior communications
     * (we will bootstrap an address and fetch a zot info packet if possible where no prior communications exist)
     *
     * Four GET parameters are supplied:
     *
     ** auth => the urlencoded webbie ([email protected]) of the channel requesting access
     ** dest => the desired destination URL (urlencoded)
     ** sec  => a random string which is also stored on $mysite for use during the verification phase. 
     ** version => the zot revision
     *
     * When this packet is received, an "auth-check" zot message is sent to $mysite.
     * (e.g. if $_GET['auth'] is [email protected], a zot packet is sent to the podunk.edu zot endpoint, which is typically /post)
     * If no information has been recorded about the requesting identity a zot information packet will be retrieved before
     * continuing.
     * 
     * The sender of this packet is an arbitrary/random site channel. The recipients will be a single recipient corresponding
     * to the guid and guid_sig we have associated with the requesting auth identity
     *
     *
     *    {
     *      "type":"auth_check",
     *      "sender":{
     *        "guid":"kgVFf_...",
     *        "guid_sig":"PT9-TApz...",
     *        "url":"http:\/\/podunk.edu",
     *        "url_sig":"T8Bp7j..."
     *      },
     *      "recipients":{
     *        {
     *        "guid":"ZHSqb...",
     *        "guid_sig":"JsAAXi..."
     *        }
     *      }
     *      "callback":"\/post",
     *      "version":1,
     *      "secret":"1eaa661",
     *      "secret_sig":"eKV968b1..."
     *    }
     *
     *
     * auth_check messages MUST use encapsulated encryption. This message is sent to the origination site, which checks the 'secret' to see 
     * if it is the same as the 'sec' which it passed originally. It also checks the secret_sig which is the secret signed by the 
     * destination channel's private key and base64url encoded. If everything checks out, a json packet is returned:
     *
     *    { 
     *      "success":1, 
     *      "confirm":"q0Ysovd1u..."
     *      "service_class":(optional)
     *      "level":(optional)
     *    }
     *
     * 'confirm' in this case is the base64url encoded RSA signature of the concatenation of 'secret' with the
     * base64url encoded whirlpool hash of the requestor's guid and guid_sig; signed with the source channel private key. 
     * This prevents a man-in-the-middle from inserting a rogue success packet. Upon receipt and successful 
     * verification of this packet, the destination site will redirect to the original destination URL and indicate a successful remote login. 
     * Service_class can be used by cooperating sites to provide different access rights based on account rights and subscription plans. It is 
     * a string whose contents are not defined by protocol. Example: "basic" or "gold". 
     *
     *
     *
     */
    if (array_key_exists('auth', $_REQUEST)) {
        $ret = array('success' => false, 'message' => '');
        logger('mod_zot: auth request received.');
        $address = $_REQUEST['auth'];
        $desturl = $_REQUEST['dest'];
        $sec = $_REQUEST['sec'];
        $version = $_REQUEST['version'];
        $test = x($_REQUEST, 'test') ? intval($_REQUEST['test']) : 0;
        // They are authenticating ultimately to the site and not to a particular channel.
        // Any channel will do, providing it's currently active. We just need to have an
        // identity to attach to the packet we send back. So find one.
        $c = q("select * from channel where not ( channel_pageflags & %d ) limit 1", intval(PAGE_REMOVED));
        if (!$c) {
            // nobody here
            logger('mod_zot: auth: unable to find a response channel');
            if ($test) {
                $ret['message'] .= 'no local channels found.' . EOL;
                json_return_and_die($ret);
            }
            goaway($desturl);
        }
        // Try and find a hubloc for the person attempting to auth
        $x = q("select * from hubloc left join xchan on xchan_hash = hubloc_hash where hubloc_addr = '%s' order by hubloc_id desc limit 1", dbesc($address));
        if (!$x) {
            // finger them if they can't be found.
            $ret = zot_finger($address, null);
            if ($ret['success']) {
//.........这里部分代码省略.........

function mail_post(&$a)
{
    if (!local_channel()) {
        return;
    }
    $replyto = x($_REQUEST, 'replyto') ? notags(trim($_REQUEST['replyto'])) : '';
    $subject = x($_REQUEST, 'subject') ? notags(trim($_REQUEST['subject'])) : '';
    $body = x($_REQUEST, 'body') ? escape_tags(trim($_REQUEST['body'])) : '';
    $recipient = x($_REQUEST, 'messageto') ? notags(trim($_REQUEST['messageto'])) : '';
    $rstr = x($_REQUEST, 'messagerecip') ? notags(trim($_REQUEST['messagerecip'])) : '';
    $preview = x($_REQUEST, 'preview') ? intval($_REQUEST['preview']) : 0;
    $expires = x($_REQUEST, 'expires') ? datetime_convert(date_default_timezone_get(), 'UTC', $_REQUEST['expires']) : NULL_DATE;
    // If we have a raw string for a recipient which hasn't been auto-filled,
    // it means they probably aren't in our address book, hence we don't know
    // if we have permission to send them private messages.
    // finger them and find out before we try and send it.
    if (!$recipient) {
        $channel = App::get_channel();
        $ret = zot_finger($rstr, $channel);
        if (!$ret['success']) {
            notice(t('Unable to lookup recipient.') . EOL);
            return;
        }
        $j = json_decode($ret['body'], true);
        logger('message_post: lookup: ' . $url . ' ' . print_r($j, true));
        if (!($j['success'] && $j['guid'])) {
            notice(t('Unable to communicate with requested channel.'));
            return;
        }
        $x = import_xchan($j);
        if (!$x['success']) {
            notice(t('Cannot verify requested channel.'));
            return;
        }
        $recipient = $x['hash'];
        $their_perms = 0;
        $global_perms = get_perms();
        if ($j['permissions']['data']) {
            $permissions = crypto_unencapsulate($j['permissions'], $channel['channel_prvkey']);
            if ($permissions) {
                $permissions = json_decode($permissions);
            }
            logger('decrypted permissions: ' . print_r($permissions, true), LOGGER_DATA);
        } else {
            $permissions = $j['permissions'];
        }
        foreach ($permissions as $k => $v) {
            if ($v) {
                $their_perms = $their_perms | intval($global_perms[$k][1]);
            }
        }
        if (!($their_perms & PERMS_W_MAIL)) {
            notice(t('Selected channel has private message restrictions. Send failed.'));
            // reported issue: let's still save the message and continue. We'll just tell them
            // that nothing useful is likely to happen. They might have spent hours on it.
            //			return;
        }
    }
    //	if(feature_enabled(local_channel(),'richtext')) {
    //		$body = fix_mce_lf($body);
    //	}
    require_once 'include/text.php';
    linkify_tags($a, $body, local_channel());
    if ($preview) {
    }
    if (!$recipient) {
        notice('No recipient found.');
        App::$argc = 2;
        App::$argv[1] = 'new';
        return;
    }
    // We have a local_channel, let send_message use the session channel and save a lookup
    $ret = send_message(0, $recipient, $body, $subject, $replyto, $expires);
    if ($ret['success']) {
        xchan_mail_query($ret['mail']);
        build_sync_packet(0, array('conv' => array($ret['conv']), 'mail' => array(encode_mail($ret['mail'], true))));
    } else {
        notice($ret['message']);
    }
    goaway(z_root() . '/mail/combined');
}

/**
 * With args, register a directory server for this realm.
 * With no args, return a JSON array of directory servers for this realm.
 *
 * @FIXME Not yet implemented: Some realms may require authentication to join their realm.
 * The RED_GLOBAL realm does not require authentication.
 * We would then need a flag in the site table to indicate that they've been
 * validated by the PRIMARY directory for that realm. Sites claiming to be PRIMARY
 * but are not the realm PRIMARY will be marked invalid.
 * 
 * @param App &$a
 */
function regdir_init(&$a)
{
    $result = array('success' => false);
    $url = $_REQUEST['url'];
    $access_token = $_REQUEST['t'];
    $valid = 0;
    // we probably don't need the realm as we will find out in the probe.
    // What we may want to die is throw an error if you're trying to register in a different realm
    // so this configuration issue can be discovered.
    $realm = $_REQUEST['realm'];
    if (!$realm) {
        $realm = DIRECTORY_REALM;
    }
    if ($realm === DIRECTORY_REALM) {
        $valid = 1;
    } else {
        $token = get_config('system', 'realm_token');
        if ($token && $access_token != $token) {
            $result['message'] = 'This realm requires an access token';
            return;
        }
        $valid = 1;
    }
    $dirmode = intval(get_config('system', 'directory_mode'));
    if ($dirmode == DIRECTORY_MODE_NORMAL) {
        $ret['message'] = t('This site is not a directory server');
        json_return_and_die($ret);
    }
    $m = null;
    if ($url) {
        $m = parse_url($url);
        if (!$m || !@dns_get_record($m['host'], DNS_A + DNS_CNAME + DNS_PTR) && !filter_var($m['host'], FILTER_VALIDATE_IP)) {
            $result['message'] = 'unparseable url';
            json_return_and_die($result);
        }
        $f = zot_finger('[system]@' . $m['host']);
        if ($f['success']) {
            $j = json_decode($f['body'], true);
            if ($j['success'] && $j['guid']) {
                $x = import_xchan($j);
                if ($x['success']) {
                    $result['success'] = true;
                }
            }
        }
        if (!$result['success']) {
            $valid = 0;
        }
        q("update site set site_valid = %d where site_url = '%s' limit 1", intval($valid), strtolower($url));
        json_return_and_die($result);
    } else {
        // We can put this in the sql without the condition after 31 august 2015 assuming
        // most directory servers will have updated by then
        // This just makes sure it happens if I forget
        $sql_extra = datetime_convert() > datetime_convert('UTC', 'UTC', '2015-08-31') ? ' and site_valid = 1 ' : '';
        if ($dirmode == DIRECTORY_MODE_STANDALONE) {
            $r = array(array('site_url' => z_root()));
        } else {
            $r = q("select site_url from site where site_flags in ( 1, 2 ) and site_realm = '%s' {$sql_extra} ", dbesc(get_directory_realm()));
        }
        if ($r) {
            $result['success'] = true;
            $result['directories'] = array();
            foreach ($r as $rr) {
                $result['directories'][] = $rr['site_url'];
            }
            json_return_and_die($result);
        }
    }
    json_return_and_die($result);
}

//.........这里部分代码省略.........
    $j = json_decode($s['body'], true);
    if (!$j) {
        logger('poco_load: unable to json_decode returned data.');
        return;
    }
    logger('poco_load: ' . print_r($j, true), LOGGER_DATA);
    if ($xchan) {
        if (array_key_exists('chatrooms', $j) && is_array($j['chatrooms'])) {
            foreach ($j['chatrooms'] as $room) {
                if (!$room['url'] || !$room['desc']) {
                    continue;
                }
                $r = q("select * from xchat where xchat_url = '%s' and xchat_xchan = '%s' limit 1", dbesc($room['url']), dbesc($xchan));
                if ($r) {
                    q("update xchat set xchat_edited = '%s' where xchat_id = %d", dbesc(datetime_convert()), intval($r[0]['xchat_id']));
                } else {
                    $x = q("insert into xchat ( xchat_url, xchat_desc, xchat_xchan, xchat_edited )\n\t\t\t\t\t\tvalues ( '%s', '%s', '%s', '%s' ) ", dbesc(escape_tags($room['url'])), dbesc(escape_tags($room['desc'])), dbesc($xchan), dbesc(datetime_convert()));
                }
            }
        }
        q("delete from xchat where xchat_edited < %s - INTERVAL %s and xchat_xchan = '%s' ", db_utcnow(), db_quoteinterval('7 DAY'), dbesc($xchan));
    }
    if (!(x($j, 'entry') && is_array($j['entry']))) {
        logger('poco_load: no entries');
        return;
    }
    $total = 0;
    foreach ($j['entry'] as $entry) {
        $profile_url = '';
        $profile_photo = '';
        $address = '';
        $name = '';
        $hash = '';
        $rating = 0;
        $name = $entry['displayName'];
        $hash = $entry['hash'];
        $rating = array_key_exists('rating', $entry) && !is_array($entry['rating']) ? intval($entry['rating']) : 0;
        $rating_text = array_key_exists('rating_text', $entry) ? escape_tags($entry['rating_text']) : '';
        if (x($entry, 'urls') && is_array($entry['urls'])) {
            foreach ($entry['urls'] as $url) {
                if ($url['type'] == 'profile') {
                    $profile_url = $url['value'];
                    continue;
                }
                if ($url['type'] == 'zot' || $url['type'] == 'diaspora' || $url['type'] == 'friendica') {
                    $network = $url['type'];
                    $address = str_replace('acct:', '', $url['value']);
                    continue;
                }
            }
        }
        if (x($entry, 'photos') && is_array($entry['photos'])) {
            foreach ($entry['photos'] as $photo) {
                if ($photo['type'] == 'profile') {
                    $profile_photo = $photo['value'];
                    continue;
                }
            }
        }
        if (!$name || !$profile_url || !$profile_photo || !$hash || !$address) {
            logger('poco_load: missing data');
            continue;
        }
        $x = q("select xchan_hash from xchan where xchan_hash = '%s' limit 1", dbesc($hash));
        // We've never seen this person before. Import them.
        if ($x !== false && !count($x)) {
            if ($address) {
                if ($network === 'zot') {
                    $z = zot_finger($address, null);
                    if ($z['success']) {
                        $j = json_decode($z['body'], true);
                        if ($j) {
                            import_xchan($j);
                        }
                    }
                    $x = q("select xchan_hash from xchan where xchan_hash = '%s' limit 1", dbesc($hash));
                    if (!$x) {
                        continue;
                    }
                } else {
                    $x = import_author_diaspora(array('address' => $address));
                    if (!$x) {
                        continue;
                    }
                }
            } else {
                continue;
            }
        }
        $total++;
        $r = q("select * from xlink where xlink_xchan = '%s' and xlink_link = '%s' and xlink_static = 0 limit 1", dbesc($xchan), dbesc($hash));
        if (!$r) {
            q("insert into xlink ( xlink_xchan, xlink_link, xlink_updated, xlink_static ) values ( '%s', '%s', '%s', 0 ) ", dbesc($xchan), dbesc($hash), dbesc(datetime_convert()));
        } else {
            q("update xlink set xlink_updated = '%s' where xlink_id = %d", dbesc(datetime_convert()), intval($r[0]['xlink_id']));
        }
    }
    logger("poco_load: loaded {$total} entries", LOGGER_DEBUG);
    q("delete from xlink where xlink_xchan = '%s' and xlink_updated < %s - INTERVAL %s and xlink_static = 0", dbesc($xchan), db_utcnow(), db_quoteinterval('2 DAY'));
}

//.........这里部分代码省略.........
 * Service_class can be used by cooperating sites to provide different access rights based on account rights and subscription plans. It is 
 * a string whose contents are not defined by protocol. Example: "basic" or "gold".
 *
 * @param[in,out] App &$a
 */
function post_init(&$a)
{
    if (array_key_exists('auth', $_REQUEST)) {
        $ret = array('success' => false, 'message' => '');
        logger('mod_zot: auth request received.');
        $address = $_REQUEST['auth'];
        $desturl = $_REQUEST['dest'];
        $sec = $_REQUEST['sec'];
        $version = $_REQUEST['version'];
        $delegate = $_REQUEST['delegate'];
        $test = x($_REQUEST, 'test') ? intval($_REQUEST['test']) : 0;
        // They are authenticating ultimately to the site and not to a particular channel.
        // Any channel will do, providing it's currently active. We just need to have an
        // identity to attach to the packet we send back. So find one.
        $c = q("select * from channel where channel_removed = 0 limit 1");
        if (!$c) {
            // nobody here
            logger('mod_zot: auth: unable to find a response channel');
            if ($test) {
                $ret['message'] .= 'no local channels found.' . EOL;
                json_return_and_die($ret);
            }
            goaway($desturl);
        }
        // Try and find a hubloc for the person attempting to auth
        $x = q("select * from hubloc left join xchan on xchan_hash = hubloc_hash where hubloc_addr = '%s' order by hubloc_id desc", dbesc($address));
        if (!$x) {
            // finger them if they can't be found.
            $ret = zot_finger($address, null);
            if ($ret['success']) {
                $j = json_decode($ret['body'], true);
                if ($j) {
                    import_xchan($j);
                }
                $x = q("select * from hubloc left join xchan on xchan_hash = hubloc_hash where hubloc_addr = '%s' order by hubloc_id desc", dbesc($address));
            }
        }
        if (!$x) {
            logger('mod_zot: auth: unable to finger ' . $address);
            if ($test) {
                $ret['message'] .= 'no hubloc found for ' . $address . ' and probing failed.' . EOL;
                json_return_and_die($ret);
            }
            goaway($desturl);
        }
        foreach ($x as $xx) {
            logger('mod_zot: auth request received from ' . $xx['hubloc_addr']);
            // check credentials and access
            // If they are already authenticated and haven't changed credentials,
            // we can save an expensive network round trip and improve performance.
            $remote = remote_channel();
            $result = null;
            $remote_service_class = '';
            $remote_level = 0;
            $remote_hub = $xx['hubloc_url'];
            $DNT = 0;
            // Also check that they are coming from the same site as they authenticated with originally.
            $already_authed = $remote && $xx['hubloc_hash'] == $remote && $xx['hubloc_url'] === $_SESSION['remote_hub'] ? true : false;
            if ($delegate && $delegate !== $_SESSION['delegate_channel']) {
                $already_authed = false;
            }

function process_channel_sync_delivery($sender, $arr, $deliveries)
{
    /** @FIXME this will sync red structures (channel, pconfig and abook). Eventually we need to make this application agnostic. */
    $result = array();
    foreach ($deliveries as $d) {
        $r = q("select * from channel where channel_hash = '%s' limit 1", dbesc($d['hash']));
        if (!$r) {
            $result[] = array($d['hash'], 'not found');
            continue;
        }
        $channel = $r[0];
        $max_friends = service_class_fetch($channel['channel_id'], 'total_channels');
        $max_feeds = account_service_class_fetch($channel['channel_account_id'], 'total_feeds');
        if ($channel['channel_hash'] != $sender['hash']) {
            logger('process_channel_sync_delivery: possible forgery. Sender ' . $sender['hash'] . ' is not ' . $channel['channel_hash']);
            $result[] = array($d['hash'], 'channel mismatch', $channel['channel_name'], '');
            continue;
        }
        if (array_key_exists('config', $arr) && is_array($arr['config']) && count($arr['config'])) {
            foreach ($arr['config'] as $cat => $k) {
                foreach ($arr['config'][$cat] as $k => $v) {
                    set_pconfig($channel['channel_id'], $cat, $k, $v);
                }
            }
        }
        if (array_key_exists('channel', $arr) && is_array($arr['channel']) && count($arr['channel'])) {
            $disallowed = array('channel_id', 'channel_account_id', 'channel_primary', 'channel_prvkey', 'channel_address', 'channel_notifyflags');
            $clean = array();
            foreach ($arr['channel'] as $k => $v) {
                if (in_array($k, $disallowed)) {
                    continue;
                }
                $clean[$k] = $v;
            }
            if (count($clean)) {
                foreach ($clean as $k => $v) {
                    $r = dbq("UPDATE channel set " . dbesc($k) . " = '" . dbesc($v) . "' where channel_id = " . intval($channel['channel_id']));
                }
            }
        }
        if (array_key_exists('abook', $arr) && is_array($arr['abook']) && count($arr['abook'])) {
            $total_friends = 0;
            $total_feeds = 0;
            $r = q("select abook_id, abook_flags from abook where abook_channel = %d", intval($channel['channel_id']));
            if ($r) {
                // don't count yourself
                $total_friends = count($r) > 0 ? count($r) - 1 : 0;
                foreach ($r as $rr) {
                    if ($rr['abook_flags'] & ABOOK_FLAG_FEED) {
                        $total_feeds++;
                    }
                }
            }
            $disallowed = array('abo