2018-01-26 22:51:07 -05:00
|
|
|
<?php
|
|
|
|
/**
|
2022-01-02 02:27:47 -05:00
|
|
|
* @copyright Copyright (C) 2010-2022, the Friendica project
|
2020-02-09 10:18:46 -05:00
|
|
|
*
|
|
|
|
* @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/>.
|
|
|
|
*
|
2018-01-26 22:51:07 -05:00
|
|
|
*/
|
2020-02-09 10:18:46 -05:00
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
namespace Friendica\Util;
|
|
|
|
|
2018-12-26 01:06:24 -05:00
|
|
|
use Friendica\Core\Hook;
|
2018-10-29 17:20:46 -04:00
|
|
|
use Friendica\Core\Logger;
|
2019-12-15 17:50:35 -05:00
|
|
|
use Friendica\DI;
|
2020-08-18 16:30:24 -04:00
|
|
|
use Friendica\Model\Contact;
|
2021-10-29 19:21:07 -04:00
|
|
|
use Friendica\Network\HTTPException\NotModifiedException;
|
2018-01-26 22:51:07 -05:00
|
|
|
|
|
|
|
class Network
|
|
|
|
{
|
|
|
|
|
2019-07-30 18:26:01 -04:00
|
|
|
/**
|
|
|
|
* Return raw post data from a post request
|
|
|
|
*
|
|
|
|
* @return string post data
|
|
|
|
*/
|
|
|
|
public static function postdata()
|
|
|
|
{
|
|
|
|
return file_get_contents('php://input');
|
|
|
|
}
|
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
/**
|
2020-01-19 01:05:23 -05:00
|
|
|
* Check URL to see if it's real
|
2018-01-26 22:51:07 -05:00
|
|
|
*
|
|
|
|
* 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 16:06:53 -05:00
|
|
|
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
|
2018-01-26 22:51:07 -05:00
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function isUrlValid(string $url)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
2020-01-19 15:21:13 -05:00
|
|
|
if (DI::config()->get('system', 'disable_url_validation')) {
|
2018-01-26 22:51:07 -05:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// @TODO Really suppress function outcomes? Why not find them + debug them?
|
|
|
|
$h = @parse_url($url);
|
|
|
|
|
2019-10-16 08:58:09 -04:00
|
|
|
if (!empty($h['host']) && (@dns_get_record($h['host'], DNS_A + DNS_CNAME) || filter_var($h['host'], FILTER_VALIDATE_IP))) {
|
2018-01-26 22:51:07 -05:00
|
|
|
return $url;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-01-19 01:05:23 -05:00
|
|
|
* Checks that email is an actual resolvable internet address
|
2018-01-26 22:51:07 -05:00
|
|
|
*
|
|
|
|
* @param string $addr The email address
|
|
|
|
* @return boolean True if it's a valid email address, false if it's not
|
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function isEmailDomainValid(string $addr)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
2020-01-19 15:21:13 -05:00
|
|
|
if (DI::config()->get('system', 'disable_email_validation')) {
|
2018-01-26 22:51:07 -05:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (! strpos($addr, '@')) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
$h = substr($addr, strpos($addr, '@') + 1);
|
|
|
|
|
2018-08-02 13:07:20 -04:00
|
|
|
// Concerning the @ see here: https://stackoverflow.com/questions/36280957/dns-get-record-a-temporary-server-error-occurred
|
2019-10-16 08:58:09 -04:00
|
|
|
if ($h && (@dns_get_record($h, DNS_A + DNS_MX) || filter_var($h, FILTER_VALIDATE_IP))) {
|
2018-06-03 05:29:06 -04:00
|
|
|
return true;
|
|
|
|
}
|
2018-08-02 13:07:20 -04:00
|
|
|
if ($h && @dns_get_record($h, DNS_CNAME + DNS_MX)) {
|
2018-01-26 22:51:07 -05:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-01-19 01:05:23 -05:00
|
|
|
* Check if URL is allowed
|
2018-01-26 22:51:07 -05:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function isUrlAllowed(string $url)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
|
|
|
$h = @parse_url($url);
|
|
|
|
|
|
|
|
if (! $h) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-01-19 15:21:13 -05:00
|
|
|
$str_allowed = DI::config()->get('system', 'allowed_sites');
|
2018-01-26 22:51:07 -05:00
|
|
|
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
|
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function isUrlBlocked(string $url)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
2018-07-17 21:00:22 -04:00
|
|
|
$host = @parse_url($url, PHP_URL_HOST);
|
2018-08-26 15:49:39 -04:00
|
|
|
if (!$host) {
|
|
|
|
return false;
|
2018-01-26 22:51:07 -05:00
|
|
|
}
|
|
|
|
|
2020-01-19 15:21:13 -05:00
|
|
|
$domain_blocklist = DI::config()->get('system', 'blocklist', []);
|
2018-08-26 15:49:39 -04:00
|
|
|
if (!$domain_blocklist) {
|
2018-01-26 22:51:07 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($domain_blocklist as $domain_block) {
|
2019-07-25 22:36:25 -04:00
|
|
|
if (fnmatch(strtolower($domain_block['domain']), strtolower($host))) {
|
2018-01-26 22:51:07 -05:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-09-16 00:56:37 -04:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
public static function isRedirectBlocked(string $url)
|
|
|
|
{
|
|
|
|
$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;
|
|
|
|
}
|
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
/**
|
2020-01-19 01:05:23 -05:00
|
|
|
* Check if email address is allowed to register here.
|
2018-01-26 22:51:07 -05:00
|
|
|
*
|
|
|
|
* Compare against our list (wildcards allowed).
|
|
|
|
*
|
|
|
|
* @param string $email email address
|
|
|
|
* @return boolean False if not allowed, true if allowed
|
2019-01-06 16:06:53 -05:00
|
|
|
* or if allowed list is not configured
|
|
|
|
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
|
2018-01-26 22:51:07 -05:00
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function isEmailDomainAllowed(string $email)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
|
|
|
$domain = strtolower(substr($email, strpos($email, '@') + 1));
|
|
|
|
if (!$domain) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-01-19 15:21:13 -05:00
|
|
|
$str_allowed = DI::config()->get('system', 'allowed_email', '');
|
2018-11-30 09:06:22 -05:00
|
|
|
if (empty($str_allowed)) {
|
2018-01-26 22:51:07 -05:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
$allowed = explode(',', $str_allowed);
|
|
|
|
|
2018-01-27 11:13:41 -05:00
|
|
|
return self::isDomainAllowed($domain, $allowed);
|
2018-01-26 22:51:07 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks for the existence of a domain in a domain list
|
|
|
|
*
|
|
|
|
* @param string $domain
|
|
|
|
* @param array $domain_list
|
|
|
|
* @return boolean
|
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function isDomainAllowed(string $domain, array $domain_list)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
|
|
|
$found = false;
|
|
|
|
|
|
|
|
foreach ($domain_list as $item) {
|
|
|
|
$pat = strtolower(trim($item));
|
|
|
|
if (fnmatch($pat, $domain) || ($pat == $domain)) {
|
|
|
|
$found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $found;
|
|
|
|
}
|
|
|
|
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function lookupAvatarByEmail(string $email)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
2018-10-23 10:36:57 -04:00
|
|
|
$avatar['size'] = 300;
|
2018-01-26 22:51:07 -05:00
|
|
|
$avatar['email'] = $email;
|
|
|
|
$avatar['url'] = '';
|
|
|
|
$avatar['success'] = false;
|
|
|
|
|
2018-12-26 01:06:24 -05:00
|
|
|
Hook::callAll('avatar_lookup', $avatar);
|
2018-01-26 22:51:07 -05:00
|
|
|
|
|
|
|
if (! $avatar['success']) {
|
2020-08-18 16:30:24 -04:00
|
|
|
$avatar['url'] = DI::baseUrl() . Contact::DEFAULT_AVATAR_PHOTO;
|
2018-01-26 22:51:07 -05:00
|
|
|
}
|
|
|
|
|
2021-10-20 14:53:52 -04:00
|
|
|
Logger::info('Avatar: ' . $avatar['email'] . ' ' . $avatar['url']);
|
2018-01-26 22:51:07 -05:00
|
|
|
return $avatar['url'];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-01-19 01:05:23 -05:00
|
|
|
* Remove Google Analytics and other tracking platforms params from URL
|
2018-01-26 22:51:07 -05:00
|
|
|
*
|
|
|
|
* @param string $url Any user-submitted URL that may contain tracking params
|
|
|
|
* @return string The same URL stripped of tracking parameters
|
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function stripTrackingQueryParams(string $url)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
|
|
|
$urldata = parse_url($url);
|
2018-07-08 08:58:43 -04:00
|
|
|
if (!empty($urldata["query"])) {
|
2018-01-26 22:51:07 -05:00
|
|
|
$query = $urldata["query"];
|
|
|
|
parse_str($query, $querydata);
|
|
|
|
|
|
|
|
if (is_array($querydata)) {
|
|
|
|
foreach ($querydata as $param => $value) {
|
|
|
|
if (in_array(
|
|
|
|
$param,
|
|
|
|
[
|
|
|
|
"utm_source", "utm_medium", "utm_term", "utm_content", "utm_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"]
|
|
|
|
)
|
|
|
|
) {
|
|
|
|
$pair = $param . "=" . urlencode($value);
|
|
|
|
$url = str_replace($pair, "", $url);
|
|
|
|
|
|
|
|
// Second try: if the url isn't encoded completely
|
|
|
|
$pair = $param . "=" . str_replace(" ", "+", $value);
|
|
|
|
$url = str_replace($pair, "", $url);
|
|
|
|
|
|
|
|
// Third try: Maybey the url isn't encoded at all
|
|
|
|
$pair = $param . "=" . $value;
|
|
|
|
$url = str_replace($pair, "", $url);
|
|
|
|
|
|
|
|
$url = str_replace(["?&", "&&"], ["?", ""], $url);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (substr($url, -1, 1) == "?") {
|
|
|
|
$url = substr($url, 0, -1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $url;
|
|
|
|
}
|
|
|
|
|
2020-07-12 08:45:34 -04:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
if (!empty(parse_url($url, PHP_URL_SCHEME)) || empty(parse_url($basepath, PHP_URL_SCHEME)) || empty($url) || empty(parse_url($url))) {
|
|
|
|
return $url;
|
|
|
|
}
|
|
|
|
|
|
|
|
$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);
|
|
|
|
}
|
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
/**
|
2020-01-19 01:05:23 -05:00
|
|
|
* Find the matching part between two url
|
2018-01-26 22:51:07 -05:00
|
|
|
*
|
|
|
|
* @param string $url1
|
|
|
|
* @param string $url2
|
|
|
|
* @return string The matching part
|
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function getUrlMatch(string $url1, string $url2)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
|
|
|
if (($url1 == "") || ($url2 == "")) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2018-11-08 11:28:29 -05:00
|
|
|
$url1 = Strings::normaliseLink($url1);
|
|
|
|
$url2 = Strings::normaliseLink($url2);
|
2018-01-26 22:51:07 -05:00
|
|
|
|
|
|
|
$parts1 = parse_url($url1);
|
|
|
|
$parts2 = parse_url($url2);
|
|
|
|
|
|
|
|
if (!isset($parts1["host"]) || !isset($parts2["host"])) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2018-07-08 08:58:43 -04:00
|
|
|
if (empty($parts1["scheme"])) {
|
|
|
|
$parts1["scheme"] = '';
|
|
|
|
}
|
|
|
|
if (empty($parts2["scheme"])) {
|
|
|
|
$parts2["scheme"] = '';
|
|
|
|
}
|
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
if ($parts1["scheme"] != $parts2["scheme"]) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2018-07-08 08:58:43 -04:00
|
|
|
if (empty($parts1["host"])) {
|
|
|
|
$parts1["host"] = '';
|
|
|
|
}
|
|
|
|
if (empty($parts2["host"])) {
|
|
|
|
$parts2["host"] = '';
|
|
|
|
}
|
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
if ($parts1["host"] != $parts2["host"]) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2018-07-08 08:58:43 -04:00
|
|
|
if (empty($parts1["port"])) {
|
|
|
|
$parts1["port"] = '';
|
|
|
|
}
|
|
|
|
if (empty($parts2["port"])) {
|
|
|
|
$parts2["port"] = '';
|
|
|
|
}
|
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
if ($parts1["port"] != $parts2["port"]) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
$match = $parts1["scheme"]."://".$parts1["host"];
|
|
|
|
|
|
|
|
if ($parts1["port"]) {
|
|
|
|
$match .= ":".$parts1["port"];
|
|
|
|
}
|
|
|
|
|
2018-07-08 08:58:43 -04:00
|
|
|
if (empty($parts1["path"])) {
|
|
|
|
$parts1["path"] = '';
|
|
|
|
}
|
|
|
|
if (empty($parts2["path"])) {
|
|
|
|
$parts2["path"] = '';
|
|
|
|
}
|
|
|
|
|
2018-01-26 22:51:07 -05:00
|
|
|
$pathparts1 = explode("/", $parts1["path"]);
|
|
|
|
$pathparts2 = explode("/", $parts2["path"]);
|
|
|
|
|
|
|
|
$i = 0;
|
|
|
|
$path = "";
|
|
|
|
do {
|
2019-10-16 08:35:14 -04:00
|
|
|
$path1 = $pathparts1[$i] ?? '';
|
|
|
|
$path2 = $pathparts2[$i] ?? '';
|
2018-01-26 22:51:07 -05:00
|
|
|
|
|
|
|
if ($path1 == $path2) {
|
|
|
|
$path .= $path1."/";
|
|
|
|
}
|
|
|
|
} while (($path1 == $path2) && ($i++ <= count($pathparts1)));
|
|
|
|
|
|
|
|
$match .= $path;
|
|
|
|
|
2018-11-08 11:28:29 -05:00
|
|
|
return Strings::normaliseLink($match);
|
2018-01-26 22:51:07 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-01-19 01:05:23 -05:00
|
|
|
* Glue url parts together
|
2018-01-26 22:51:07 -05:00
|
|
|
*
|
|
|
|
* @param array $parsed URL parts
|
|
|
|
*
|
2021-12-02 07:53:14 -05:00
|
|
|
* @return string The glued URL.
|
|
|
|
* @deprecated since version 2021.12, use a UriInterface object like GuzzleHttp\Psr7\Uri instead
|
2018-01-26 22:51:07 -05:00
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function unparseURL(array $parsed)
|
2018-01-26 22:51:07 -05:00
|
|
|
{
|
|
|
|
$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" : '');
|
|
|
|
|
|
|
|
return (strlen($scheme) ? $scheme.":" : '') .
|
|
|
|
(strlen($authority) ? "//".$authority : '') .
|
|
|
|
$get('path') .
|
|
|
|
(strlen($query) ? "?".$query : '') .
|
|
|
|
(strlen($fragment) ? "#".$fragment : '');
|
|
|
|
}
|
2019-04-08 15:12:10 -04:00
|
|
|
|
2022-05-11 02:34:25 -04:00
|
|
|
/**
|
|
|
|
* Convert an URI to an IDN compatible URI
|
|
|
|
*
|
|
|
|
* @param string $uri
|
|
|
|
* @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']);
|
|
|
|
$uri = self::unparseURL($parts);
|
2022-05-11 02:58:26 -04:00
|
|
|
} else {
|
2022-05-11 02:55:02 -04:00
|
|
|
$parts = explode('@', $uri);
|
|
|
|
if (count($parts) == 2) {
|
|
|
|
$uri = $parts[0] . '@' . idn_to_ascii($parts[1]);
|
2022-05-11 02:58:26 -04:00
|
|
|
} else {
|
|
|
|
$uri = idn_to_ascii($uri);
|
2022-05-11 02:55:02 -04:00
|
|
|
}
|
2022-05-11 02:34:25 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return $uri;
|
|
|
|
}
|
2019-04-08 15:12:10 -04:00
|
|
|
|
|
|
|
/**
|
2019-04-08 17:12:34 -04:00
|
|
|
* Switch the scheme of an url between http and https
|
2019-04-08 15:12:10 -04:00
|
|
|
*
|
|
|
|
* @param string $url URL
|
|
|
|
*
|
|
|
|
* @return string switched URL
|
|
|
|
*/
|
2019-06-10 06:06:41 -04:00
|
|
|
public static function switchScheme(string $url)
|
2019-04-08 15:12:10 -04:00
|
|
|
{
|
2019-04-08 17:12:34 -04:00
|
|
|
$scheme = parse_url($url, PHP_URL_SCHEME);
|
|
|
|
if (empty($scheme)) {
|
2019-04-08 15:12:10 -04:00
|
|
|
return $url;
|
|
|
|
}
|
2019-04-08 17:12:34 -04:00
|
|
|
|
|
|
|
if ($scheme === 'http') {
|
2019-04-08 15:12:10 -04:00
|
|
|
$url = str_replace('http://', 'https://', $url);
|
2019-04-08 17:12:34 -04:00
|
|
|
} elseif ($scheme === 'https') {
|
2019-04-08 15:12:10 -04:00
|
|
|
$url = str_replace('https://', 'http://', $url);
|
|
|
|
}
|
2019-04-08 17:12:34 -04:00
|
|
|
|
2019-04-08 15:12:10 -04:00
|
|
|
return $url;
|
|
|
|
}
|
2020-01-31 19:39:15 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
public static function appendQueryParam(string $path, array $additionalParams)
|
|
|
|
{
|
|
|
|
$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 17:58:09 -04: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
|
|
|
|
* @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 19:21:07 -04:00
|
|
|
throw new NotModifiedException();
|
2020-04-05 17:58:09 -04:00
|
|
|
}
|
|
|
|
}
|
2021-05-26 05:24:37 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the given URL is a local link
|
|
|
|
*
|
|
|
|
* @param string $url
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public static function isLocalLink(string $url)
|
|
|
|
{
|
|
|
|
return (strpos(Strings::normaliseLink($url), Strings::normaliseLink(DI::baseUrl())) !== false);
|
|
|
|
}
|
2022-04-03 03:21:36 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the given URL is a valid HTTP/HTTPS URL
|
|
|
|
*
|
|
|
|
* @param string $url
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public static function isValidHttpUrl(string $url)
|
|
|
|
{
|
2022-04-03 03:31:42 -04:00
|
|
|
$scheme = parse_url($url, PHP_URL_SCHEME);
|
|
|
|
return !empty($scheme) && in_array($scheme, ['http', 'https']) && parse_url($url, PHP_URL_HOST);
|
2022-04-03 03:21:36 -04:00
|
|
|
}
|
2018-01-26 22:51:07 -05:00
|
|
|
}
|