friendica-github/src/Util/Network.php

634 lines
16 KiB
PHP
Raw Normal View History

<?php
/**
2022-01-02 07:27:47 +00:00
* @copyright Copyright (C) 2010-2022, the Friendica project
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
namespace Friendica\Util;
use Friendica\Core\Hook;
2018-10-29 21:20:46 +00:00
use Friendica\Core\Logger;
use Friendica\DI;
use Friendica\Model\Contact;
2022-07-05 05:04:05 +00:00
use Friendica\Network\HTTPClient\Client\HttpClientAccept;
2022-07-14 05:39:25 +00:00
use Friendica\Network\HTTPClient\Client\HttpClientOptions;
2021-10-29 23:21:07 +00:00
use Friendica\Network\HTTPException\NotModifiedException;
2022-05-11 11:06:14 +00:00
use GuzzleHttp\Psr7\Uri;
class Network
{
/**
* Return raw post data from a post request
*
* @return string post data
*/
public static function postdata()
{
return file_get_contents('php://input');
}
/**
2020-01-19 06:05:23 +00:00
* Check URL to see if it's real
*
* Take a URL from the wild, prepend http:// if necessary
* and check DNS to see if it's real (or check if is a valid IP address)
*
* @param string $url The URL to be validated
*
* @return string|boolean The actual working URL, false else
2019-01-06 21:06:53 +00:00
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/
public static function isUrlValid(string $url)
{
if (DI::config()->get('system', 'disable_url_validation')) {
return $url;
}
// no naked subdomains (allow localhost for tests)
if (strpos($url, '.') === false && strpos($url, '/localhost/') === false) {
return false;
}
if (substr($url, 0, 4) != 'http') {
$url = 'http://' . $url;
}
2022-07-05 05:04:05 +00:00
$xrd_timeout = DI::config()->get('system', 'xrd_timeout');
$host = parse_url($url, PHP_URL_HOST);
if (empty($host) || !(filter_var($host, FILTER_VALIDATE_IP) || @dns_get_record($host . '.', DNS_A + DNS_AAAA))) {
2022-07-05 05:04:05 +00:00
return false;
}
2022-07-14 05:39:25 +00:00
if (in_array(parse_url($url, PHP_URL_SCHEME), ['https', 'http'])) {
$options = [HttpClientOptions::VERIFY => true, HttpClientOptions::TIMEOUT => $xrd_timeout];
$curlResult = DI::httpClient()->head($url, $options);
2022-07-14 05:39:25 +00:00
// Workaround for systems that can't handle a HEAD request. Don't retry on timeouts.
if (!$curlResult->isSuccess() && ($curlResult->getReturnCode() >= 400) && !in_array($curlResult->getReturnCode(), [408, 504])) {
$curlResult = DI::httpClient()->get($url, HttpClientAccept::DEFAULT, $options);
2022-07-14 05:39:25 +00:00
}
if (!$curlResult->isSuccess()) {
Logger::notice('Url not reachable', ['host' => $host, 'url' => $url]);
return false;
} elseif ($curlResult->isRedirectUrl()) {
$url = $curlResult->getRedirectUrl();
}
}
2022-07-05 05:04:05 +00:00
return $url;
}
/**
2020-01-19 06:05:23 +00:00
* Checks that email is an actual resolvable internet address
*
* @param string $addr The email address
* @return boolean True if it's a valid email address, false if it's not
*/
2022-06-23 14:03:55 +00:00
public static function isEmailDomainValid(string $addr): bool
{
if (DI::config()->get('system', 'disable_email_validation')) {
return true;
}
if (! strpos($addr, '@')) {
return false;
}
$h = substr($addr, strpos($addr, '@') + 1);
2018-08-02 17:07:20 +00:00
// Concerning the @ see here: https://stackoverflow.com/questions/36280957/dns-get-record-a-temporary-server-error-occurred
2022-07-05 05:04:05 +00:00
if ($h && (@dns_get_record($h, DNS_A + DNS_AAAA + DNS_MX) || filter_var($h, FILTER_VALIDATE_IP))) {
return true;
}
2018-08-02 17:07:20 +00:00
if ($h && @dns_get_record($h, DNS_CNAME + DNS_MX)) {
return true;
}
return false;
}
/**
2020-01-19 06:05:23 +00:00
* Check if URL is allowed
*
* Check $url against our list of allowed sites,
* wildcards allowed. If allowed_sites is unset return true;
*
* @param string $url URL which get tested
* @return boolean True if url is allowed otherwise return false
*/
2022-06-23 14:03:55 +00:00
public static function isUrlAllowed(string $url): bool
{
$h = @parse_url($url);
if (! $h) {
return false;
}
$str_allowed = DI::config()->get('system', 'allowed_sites');
if (! $str_allowed) {
return true;
}
$found = false;
$host = strtolower($h['host']);
// always allow our own site
if ($host == strtolower($_SERVER['SERVER_NAME'])) {
return true;
}
$fnmatch = function_exists('fnmatch');
$allowed = explode(',', $str_allowed);
if (count($allowed)) {
foreach ($allowed as $a) {
$pat = strtolower(trim($a));
if (($fnmatch && fnmatch($pat, $host)) || ($pat == $host)) {
$found = true;
break;
}
}
}
return $found;
}
/**
* Checks if the provided url domain is on the domain blocklist.
* Returns true if it is or malformed URL, false if not.
*
* @param string $url The url to check the domain from
*
* @return boolean
*/
2022-06-23 14:03:55 +00:00
public static function isUrlBlocked(string $url): bool
{
2018-07-18 01:00:22 +00:00
$host = @parse_url($url, PHP_URL_HOST);
if (!$host) {
return false;
}
$domain_blocklist = DI::config()->get('system', 'blocklist', []);
if (!$domain_blocklist) {
return false;
}
foreach ($domain_blocklist as $domain_block) {
if (fnmatch(strtolower($domain_block['domain']), strtolower($host))) {
return true;
}
}
return false;
}
/**
* Checks if the provided url is on the list of domains where redirects are blocked.
* Returns true if it is or malformed URL, false if not.
*
* @param string $url The url to check the domain from
*
* @return boolean
*/
2022-06-23 14:03:55 +00:00
public static function isRedirectBlocked(string $url): bool
{
$host = @parse_url($url, PHP_URL_HOST);
if (!$host) {
return false;
}
$no_redirect_list = DI::config()->get('system', 'no_redirect_list', []);
if (!$no_redirect_list) {
return false;
}
foreach ($no_redirect_list as $no_redirect) {
if (fnmatch(strtolower($no_redirect), strtolower($host))) {
return true;
}
}
return false;
}
/**
2020-01-19 06:05:23 +00:00
* Check if email address is allowed to register here.
*
* Compare against our list (wildcards allowed).
*
* @param string $email email address
* @return boolean False if not allowed, true if allowed
2019-01-06 21:06:53 +00:00
* or if allowed list is not configured
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/
2022-06-23 14:03:55 +00:00
public static function isEmailDomainAllowed(string $email): bool
{
$domain = strtolower(substr($email, strpos($email, '@') + 1));
if (!$domain) {
return false;
}
$str_allowed = DI::config()->get('system', 'allowed_email', '');
if (empty($str_allowed)) {
return true;
}
$allowed = explode(',', $str_allowed);
return self::isDomainAllowed($domain, $allowed);
}
/**
* Checks for the existence of a domain in a domain list
*
* @param string $domain
* @param array $domain_list
*
* @return boolean
*/
2022-06-23 14:03:55 +00:00
public static function isDomainAllowed(string $domain, array $domain_list): bool
{
$found = false;
foreach ($domain_list as $item) {
$pat = strtolower(trim($item));
if (fnmatch($pat, $domain) || ($pat == $domain)) {
$found = true;
break;
}
}
return $found;
}
2022-06-23 14:03:55 +00:00
public static function lookupAvatarByEmail(string $email): string
{
$avatar['size'] = 300;
$avatar['email'] = $email;
$avatar['url'] = '';
$avatar['success'] = false;
Hook::callAll('avatar_lookup', $avatar);
if (! $avatar['success']) {
$avatar['url'] = DI::baseUrl() . Contact::DEFAULT_AVATAR_PHOTO;
}
2021-10-20 18:53:52 +00:00
Logger::info('Avatar: ' . $avatar['email'] . ' ' . $avatar['url']);
return $avatar['url'];
}
/**
2020-01-19 06:05:23 +00:00
* Remove Google Analytics and other tracking platforms params from URL
*
* @param string $url Any user-submitted URL that may contain tracking params
*
* @return string The same URL stripped of tracking parameters
*/
2022-06-23 14:03:55 +00:00
public static function stripTrackingQueryParams(string $url): string
{
$urldata = parse_url($url);
2022-06-23 14:03:55 +00:00
if (!empty($urldata['query'])) {
$query = $urldata['query'];
parse_str($query, $querydata);
if (is_array($querydata)) {
foreach ($querydata as $param => $value) {
if (in_array(
$param,
[
2022-06-23 14:03:55 +00:00
'utm_source', 'utm_medium', 'utm_term', 'utm_content', 'utm_campaign',
// As seen from Purism
'mtm_source', 'mtm_medium', 'mtm_term', 'mtm_content', 'mtm_campaign',
'wt_mc', 'pk_campaign', 'pk_kwd', 'mc_cid', 'mc_eid',
'fb_action_ids', 'fb_action_types', 'fb_ref',
'awesm', 'wtrid',
'woo_campaign', 'woo_source', 'woo_medium', 'woo_content', 'woo_term']
)
) {
2022-06-23 14:03:55 +00:00
$pair = $param . '=' . urlencode($value);
$url = str_replace($pair, '', $url);
// Second try: if the url isn't encoded completely
2022-06-23 14:03:55 +00:00
$pair = $param . '=' . str_replace(' ', '+', $value);
$url = str_replace($pair, '', $url);
// Third try: Maybey the url isn't encoded at all
2022-06-23 14:03:55 +00:00
$pair = $param . '=' . $value;
$url = str_replace($pair, '', $url);
2022-06-23 14:03:55 +00:00
$url = str_replace(['?&', '&&'], ['?', ''], $url);
}
}
}
2022-06-23 14:03:55 +00:00
if (substr($url, -1, 1) == '?') {
$url = substr($url, 0, -1);
}
}
return $url;
}
/**
* Add a missing base path (scheme and host) to a given url
*
* @param string $url
* @param string $basepath
*
* @return string url
*/
public static function addBasePath(string $url, string $basepath): string
{
if (!empty(parse_url($url, PHP_URL_SCHEME)) || empty(parse_url($basepath, PHP_URL_SCHEME)) || empty($url) || empty(parse_url($url))) {
return $url;
}
2022-06-23 14:03:55 +00:00
$base = [
'scheme' => parse_url($basepath, PHP_URL_SCHEME),
'host' => parse_url($basepath, PHP_URL_HOST),
];
$parts = array_merge($base, parse_url('/' . ltrim($url, '/')));
return self::unparseURL($parts);
}
/**
2020-01-19 06:05:23 +00:00
* Find the matching part between two url
*
* @param string $url1
* @param string $url2
*
2022-06-23 14:03:55 +00:00
* @return string The matching part or empty string on error
*/
2022-06-23 14:03:55 +00:00
public static function getUrlMatch(string $url1, string $url2): string
{
2022-06-23 14:03:55 +00:00
if (($url1 == '') || ($url2 == '')) {
return '';
}
$url1 = Strings::normaliseLink($url1);
$url2 = Strings::normaliseLink($url2);
$parts1 = parse_url($url1);
$parts2 = parse_url($url2);
2022-06-23 14:03:55 +00:00
if (!isset($parts1['host']) || !isset($parts2['host'])) {
return '';
}
2022-06-23 14:03:55 +00:00
if (empty($parts1['scheme'])) {
$parts1['scheme'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
if (empty($parts2['scheme'])) {
$parts2['scheme'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
if ($parts1['scheme'] != $parts2['scheme']) {
return '';
}
2022-06-23 14:03:55 +00:00
if (empty($parts1['host'])) {
$parts1['host'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
if (empty($parts2['host'])) {
$parts2['host'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
if ($parts1['host'] != $parts2['host']) {
return '';
}
2022-06-23 14:03:55 +00:00
if (empty($parts1['port'])) {
$parts1['port'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
if (empty($parts2['port'])) {
$parts2['port'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
if ($parts1['port'] != $parts2['port']) {
return '';
}
2022-06-23 14:03:55 +00:00
$match = $parts1['scheme'] . '://' . $parts1['host'];
2022-06-23 14:03:55 +00:00
if ($parts1['port']) {
$match .= ':' . $parts1['port'];
}
2022-06-23 14:03:55 +00:00
if (empty($parts1['path'])) {
$parts1['path'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
if (empty($parts2['path'])) {
$parts2['path'] = '';
2018-07-08 12:58:43 +00:00
}
2022-06-23 14:03:55 +00:00
$pathparts1 = explode('/', $parts1['path']);
$pathparts2 = explode('/', $parts2['path']);
$i = 0;
2022-06-23 14:03:55 +00:00
$path = '';
do {
$path1 = $pathparts1[$i] ?? '';
$path2 = $pathparts2[$i] ?? '';
if ($path1 == $path2) {
2022-06-23 14:03:55 +00:00
$path .= $path1 . '/';
}
} while (($path1 == $path2) && ($i++ <= count($pathparts1)));
$match .= $path;
return Strings::normaliseLink($match);
}
/**
2020-01-19 06:05:23 +00:00
* Glue url parts together
*
* @param array $parsed URL parts
*
* @return string|null The glued URL or null on error
2022-05-11 11:06:14 +00:00
* @deprecated since version 2021.12, use GuzzleHttp\Psr7\Uri::fromParts($parts) instead
*/
2022-06-23 14:03:55 +00:00
public static function unparseURL(array $parsed): string
{
$get = function ($key) use ($parsed) {
return isset($parsed[$key]) ? $parsed[$key] : null;
};
$pass = $get('pass');
$user = $get('user');
$userinfo = $pass !== null ? "$user:$pass" : $user;
$port = $get('port');
$scheme = $get('scheme');
$query = $get('query');
$fragment = $get('fragment');
$authority = ($userinfo !== null ? $userinfo . '@' : '') .
$get('host') .
($port ? ":$port" : '');
2022-11-09 22:16:12 +00:00
return (!empty($scheme) ? $scheme . ':' : '') .
(!empty($authority) ? '//' . $authority : '') .
$get('path') .
2022-11-09 22:16:12 +00:00
(!empty($query) ? '?' . $query : '') .
(!empty($fragment) ? '#' . $fragment : '');
}
2022-05-11 06:34:25 +00:00
/**
* Convert an URI to an IDN compatible URI
*
* @param string $uri
*
2022-05-11 06:34:25 +00:00
* @return string
*/
public static function convertToIdn(string $uri): string
{
$parts = parse_url($uri);
if (!empty($parts['scheme']) && !empty($parts['host'])) {
$parts['host'] = idn_to_ascii($parts['host']);
2022-07-29 16:05:04 +00:00
$uri = (string)Uri::fromParts($parts);
} else {
2022-05-11 06:55:02 +00:00
$parts = explode('@', $uri);
if (count($parts) == 2) {
$uri = $parts[0] . '@' . idn_to_ascii($parts[1]);
} else {
$uri = idn_to_ascii($uri);
2022-05-11 06:55:02 +00:00
}
2022-05-11 06:34:25 +00:00
}
return $uri;
}
/**
2019-04-08 21:12:34 +00:00
* Switch the scheme of an url between http and https
*
2022-06-23 14:03:55 +00:00
* @param string $url
*
2022-06-23 14:03:55 +00:00
* @return string Switched URL
*/
2022-06-23 14:03:55 +00:00
public static function switchScheme(string $url): string
{
2019-04-08 21:12:34 +00:00
$scheme = parse_url($url, PHP_URL_SCHEME);
if (empty($scheme)) {
return $url;
}
2019-04-08 21:12:34 +00:00
if ($scheme === 'http') {
$url = str_replace('http://', 'https://', $url);
2019-04-08 21:12:34 +00:00
} elseif ($scheme === 'https') {
$url = str_replace('https://', 'http://', $url);
}
2019-04-08 21:12:34 +00:00
return $url;
}
/**
* Adds query string parameters to the provided URI. Replace the value of existing keys.
*
* @param string $path
* @param array $additionalParams Associative array of parameters
*
* @return string
*/
2022-06-23 14:03:55 +00:00
public static function appendQueryParam(string $path, array $additionalParams): string
{
$parsed = parse_url($path);
$params = [];
if (!empty($parsed['query'])) {
parse_str($parsed['query'], $params);
}
$params = array_merge($params, $additionalParams);
$parsed['query'] = http_build_query($params);
return self::unparseURL($parsed);
}
2020-04-05 21:58:09 +00:00
/**
* Generates ETag and Last-Modified response headers and checks them against
* If-None-Match and If-Modified-Since request headers if present.
*
* Blocking function, sends 304 headers and exits if check passes.
*
* @param string $etag The page etag
* @param string $last_modified The page last modification UTC date
*
2022-06-23 14:03:55 +00:00
* @return void
2020-04-05 21:58:09 +00:00
* @throws \Exception
*/
public static function checkEtagModified(string $etag, string $last_modified)
{
$last_modified = DateTimeFormat::utc($last_modified, 'D, d M Y H:i:s') . ' GMT';
/**
* @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.26
*/
$if_none_match = filter_input(INPUT_SERVER, 'HTTP_IF_NONE_MATCH');
$if_modified_since = filter_input(INPUT_SERVER, 'HTTP_IF_MODIFIED_SINCE');
$flag_not_modified = null;
if ($if_none_match) {
$result = [];
preg_match('/^(?:W\/")?([^"]+)"?$/i', $etag, $result);
$etagTrimmed = $result[1];
// Lazy exact ETag match, could check weak/strong ETags
$flag_not_modified = $if_none_match == '*' || strpos($if_none_match, $etagTrimmed) !== false;
}
if ($if_modified_since && (!$if_none_match || $flag_not_modified)) {
// Lazy exact Last-Modified match, could check If-Modified-Since validity
$flag_not_modified = $if_modified_since == $last_modified;
}
header('Etag: ' . $etag);
header('Last-Modified: ' . $last_modified);
if ($flag_not_modified) {
2021-10-29 23:21:07 +00:00
throw new NotModifiedException();
2020-04-05 21:58:09 +00:00
}
}
2021-05-26 09:24:37 +00:00
/**
* Check if the given URL is a local link
*
2022-07-05 05:04:05 +00:00
* @param string $url
*
2022-07-05 05:04:05 +00:00
* @return bool
2021-05-26 09:24:37 +00:00
*/
2022-06-23 14:03:55 +00:00
public static function isLocalLink(string $url): bool
2021-05-26 09:24:37 +00:00
{
return (strpos(Strings::normaliseLink($url), Strings::normaliseLink(DI::baseUrl())) !== false);
}
/**
* Check if the given URL is a valid HTTP/HTTPS URL
*
2022-07-05 05:04:05 +00:00
* @param string $url
* @return bool
*/
2022-06-23 14:03:55 +00:00
public static function isValidHttpUrl(string $url): bool
{
2022-04-03 07:31:42 +00:00
$scheme = parse_url($url, PHP_URL_SCHEME);
return !empty($scheme) && in_array($scheme, ['http', 'https']) && parse_url($url, PHP_URL_HOST);
}
}