Search line:
if (” !== $dsn->getOption(‘verify_peer’) && !filter_var($dsn->getOption(‘verify_peer’, true), \FILTER_VALIDATE_BOOLEAN)) {

and replace with this line or set true to false:
if (” !== $dsn->getOption(‘verify_peer’) && !filter_var($dsn->getOption(‘verify_peer’, false), \FILTER_VALIDATE_BOOLEAN)) {

also if this line below are true, change to false:
$streamOptions[‘ssl’][‘verify_peer’] = false;
$streamOptions[‘ssl’][‘verify_peer_name’] = false;

Zakładając, iż masz już poprawnie zainstalowany system Debian 12 w wersji 12, oraz serwer stron www (internetowych), a nie masz obsługi PHP w wersji 8.3, postępuj wedle poniższych kroków:

Przygotowanie do instalacji:

apt-get update && apt-get upgrade -y
apt install ca-certificates apt-transport-https software-properties-common lsb-release
curl -sSL https://packages.sury.org/php/README.txt | sudo bash -x
apt-get update && apt-get upgrade -y

Przykładowa instalacja w konfiguracji:

apt install php8.3 php8.3-cgi php8.3-cli php8.3-common php8.3-curl php8.3-fpm php8.3-http php8.3-imagick php8.3-imap libapache2-mod-fcgid libapache2-mod-php8.3 php8.3-maxminddb php8.3-mbstring php8.3-memcache php8.3-memcached php8.3-mysql php8.3-oauth php8.3-opcache php8.3-pgsql php8.3-redis php8.3-soap php8.3-xml php8.3-xsl php8.3-yaml php8.3-zip -y
a2enmod proxy_fcgi setenvif
a2enconf php8.3-fpm
systemctl restart apache2

<?php
$DBType = "mysql";
$DBHost = "database-host";
$DBPort = "3306";
$DBEnco = "utf-8";
$DBUser = "database-user";
$DBPass = "database-password";
$DBName = "database-name";
try {
$DBCon=new PDO("$DBType:host=$DBHost;port=$DBPort;encoding=$DBEnco;dbname=$DBName",$DBUser,$DBPass);
$DBCon->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
// Connected
} catch(PDOException $DBError) {
// Not Connected
echo '<strong>'.$DBError->getMessage().'</strong>';
exit;
}
?>

EXAMPLES:

1.
<?php
$BLang= Locale::acceptFromHttp($_SERVER[‘HTTP_ACCEPT_LANGUAGE’]);
echo $BLang; // Return: en
?>

2.
<?php
$BLang= locale_accept_from_http($_SERVER[‘HTTP_ACCEPT_LANGUAGE’]);
echo $BLang; // Return: en
?>

3. Using substr function to get the first two letters of the string.
<?php
$BLang = substr($_SERVER[‘HTTP_ACCEPT_LANGUAGE’], 0, 2);
echo $BLang; // Return: en
?>

4. Example of global variable $_SERVER[‘HTTP_ACCEPT_LANGUAGE’]
<?php
$BLang = $_SERVER[‘HTTP_ACCEPT_LANGUAGE’];
echo $BLang; // Return: en,en-US;q=0.9,en-GB;q=0.8,en-GB-oxendict;q=0.7,en-CA;q=0.6,en-IE;q=0.5,en-AU;q=0.4,en-NZ;q=0.3,en-ZA;q=0.2,de;q=0.1,de-DE;q=0.1,de-AT;q=0.1,de-CH;q=0.1,de-LI;q=0.1,pl;q=0.1,pt;q=0.1,pt-PT;q=0.1,pt-BR;q=0.1
?>

Detecting browser language is an important process for websites that cater to multiple audiences in different countries and languages. In this guide, we’ll discuss how to detect a user’s browser language in PHP.

In today’s globalized world, it has become increasingly important for websites to be able to detect users’ browser languages to provide a personalized experience. This is even more relevant for websites that offer content or services in multiple languages and cater to a wide audience.

Fortunately, detecting a user’s browser language in PHP is an easy process. The most common way to detect a user’s browser language is through their HTTP Accept-Language header. This header contains the list of language codes that the user’s browser supports.

To detect and analyze the Accept-Language header, we can use the $_SERVER[‘HTTP_ACCEPT_LANGUAGE’] variable. It is a comma-separated string of language codes ordered by priority according to the user.

Once you have the contents of the Accept-Language header, you can parse and analyze it. To do this, use the PHP explode() function. This function will break up the comma-separated list into an array of language codes.

Using the array of language codes, you can loop through each one and test if it is one of the languages supported by your website. If any of the languages in the list are supported by your website, you can set it as the language for that user.

In conclusion, detecting a user’s browser language in PHP is a relatively simple process. With the help of the $_SERVER[‘HTTP_ACCEPT_LANGUAGE’] variable and the explode() function, it is possible to parse and analyze the user’s language preferences and provide them with a personalized experience. This can be an important factor in providing an intuitive user experience across a wide variety of users.

<?php
function GetUserIP() {
if(isset($_SERVER[“HTTP_CF_CONNECTING_IP”])) {
$_SERVER[‘REMOTE_ADDR’] = $_SERVER[“HTTP_CF_CONNECTING_IP”];
$_SERVER[‘HTTP_CLIENT_IP’] = $_SERVER[“HTTP_CF_CONNECTING_IP”];
}
$client = @$_SERVER[‘HTTP_CLIENT_IP’];
$forward = @$_SERVER[‘HTTP_X_FORWARDED_FOR’];
$remote = $_SERVER[‘REMOTE_ADDR’];
if(filter_var($client, FILTER_VALIDATE_IP)) {
$ip = $client;
} elseif (filter_var($forward, FILTER_VALIDATE_IP)) {
$ip = $forward;
} else {
$ip = $remote;
}
return $ip;
}
?>

<?php
$UserIP = GetUserIP();
echo $UserIP;
?>

A visitor IP address is the unique identifier that websites use to identify and track a device (e.g. a computer or mobile device) when a user visits a webpage. Each time a user visits a website, their computer or device is assigned an IP address from the Internet Service Provider (ISP) that allows the site to recognize the IP address of the device which is used to log the visits. When a device connects to the internet, it is assigned an IP address which is a unique numerical code that is used to identify it on the network.

The visitor IP address is a useful tool for webmasters as it allows them to gain valuable insights about the visitors that access their site. With the IP address, webmasters can track a user’s geographical location, determine whether the visitor has been to the website before and even which browser and operating system they are using to access the page. This data can then be used to personalize the page content to better serve the visitor.

By tracking visitor IP addresses, website owners can also track potentially malicious attempts to access a website. This information can be used to identify malicious actors and enhance the overall security of the website.

Generally, a website visitor’s IP address is securely encrypted and is not publicly visible as it passes through multiple networks, making it difficult to trace back to the user. However, some websites may accidentally retain an IP address or unintentionally log a visitor’s IP address, which can potentially be used for malicious purposes.

In conclusion, visitor IP address is a powerful and useful tool for website owners as it allows them to gain valuable insights into their visitors and proactively protect their website. While visitor IP addresses should remain encrypted so as not to cause any security threats, website owners should take extra precautions to ensure that their visitors’ private data is protected.

$mail->SMTPOptions = [
‘ssl’ => [
‘verify_peer’ => false,
‘verify_peer_name’ => false,
‘allow_self_signed’ => true,
]
];

Recently, the popular open source email transfer client PHPMailer has implemented additional security measures to limit the risk of unauthorized emails being transmitted through their system. One of these measures is the ability to disable SMTP SSL certificate verification in PHP, which can be done by following the steps outlined in this article.

SMTP Secure Sockets Layer (SSL) is an encryption protocol used for data transfer between two machines. It is widely used for communication between networks, including email transfer. With SSL enabled, PHPMailer can verify the authenticity of a secure link established between two computers, protecting users from potential exploits.

However, there may be instances when users wish to disable this feature, either for convenience or to reduce network latency. For instance, if the user is not expecting a large volume of emails or is running a development environment, disabling SMTP SSL certificate verification may not be necessary.

To disable SMTP SSL certificate verification in PHPMailer, users must edit the initialization of the PHPMailer class instance. The verification is enabled by default, but can be easily disabled by setting the “SMTPAutoTLS” parameter to “false”.

Once this is done, the verification requirement will no longer be enforced when sending emails. This setting should not be used in production environments, as it can increase the risk of email spoofing. It is strongly recommended that users enable SSL verification if sending emails to any public address.

In conclusion, PHPMailer has implemented a number of security measures to protect users from potential exploits while transferring emails. SSL certificate verification is one of these features, and can be easily disabled in the initialization of the PHPMailer class instance. However, this should not be done in production environments as it can reduce the level of security.

You must update your composer by using:
composer update
composer update nesbot/carbon

How to install composer on Linux Debian:

apt install curl php-cli php-mbstring git unzip
cd /
cd /tmp
curl -sS https://getcomposer.org/installer -o composer-setup.php
HASH='curl -sS https://composer.github.io/installer.sig'
echo $HASH
php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php --install-dir=/usr/local/bin --filename=composer
composer

----- OR -----

apt install composer -y
cd /tmp
curl -sS https://getcomposer.org/installer -o composer-setup.php
php composer-setup.php --install-dir=/usr/bin --filename=composer

In the web application development world, Laravel Carbon is a powerful tool for manipulating date and time. Specifically, the CarbonCarbon::setLastErrors() method of Carbon can be used to set and retrieve errors that occur during the execution of a time/date operation. This method is extremely useful in detecting, handling, and debugging time and date errors.

The setLastErrors() method is initialized with no errors and sets or retrieves the last errors occurred during the instantiation of a Carbon object with an array of errors. The errors themselves are categorized as “warnings” and “fatal” with the former indicating issues related to the specific syntax used for the Carbon object, while the latter indicating errors that will prevent the Carbon object from functioning correctly.

Therefore, with the setLastErrors() method, it is possible to modify the way Carbon will generate dates and times, allowing developers to provide faster feedback on errors. The advantage of this method is that it allows developers to parse and correct any suspicious or erroneous statements present in their code, making debugging time/date related errors much easier.

In conclusion, the CarbonCarbon::setLastErrors() method is a useful functionality provided by the Laravel Carbon library that simplifies debugging time and date related errors. This method is an invaluable tool for web application developers, allowing them to identify, handle, and debug errors faster.

<?php
$mysqli = new mysqli(“host”, “username”, “password”, “dbname”, “port”, “socket”);
if($mysqli -> connect_errno) {
echo “MySQL Connection Error: ” . $mysqli -> connect_error;
exit();
}
?>

MySQL Query:

MySQL is a database management system that has become very popular among web developers and system administrators. It provides powerful features, such as querying, searching, inserting, updating, and deleting data. In this article, we will take a look at how to connect to MySQL, use queries to select, search, insert, update and delete data.

To begin, we need to connect to the MySQL server using either the command line interface or a suitable tool like phpMyAdmin. Once connected, we can create a database, tables, and insert data. With a properly configured database, we can begin running queries.

The most basic query is the SELECT statement which retrieves data from the database. We will specify what data to be retrieved, the table in which it is stored and any optional conditions or orderings.

For example, a query to retrieve all rows from the “users” table could look like this: SELECT * FROM users.

To make more specific queries, we can use the WHERE clause to limit the result set. For example: SELECT * FROM users WHERE age > 20. This query will only return records of users that are older than 20.

In addition to retrieving records, MySQL also allows us to search for data in text fields. The LIKE operator can be used to search for a certain string in a particular field. For example, if we wanted to search for users with a certain name we could use this query: SELECT * FROM users WHERE name LIKE ‘John’

Inserting data into the database is quite easy as well. All we need to do is use the INSERT statement with the required columns and values. For example: INSERT INTO users (name, email, age) VALUES (‘John’, ‘john@example.com’, 32). This query will insert a record with the values provided into the users table.

Updating records is also simple. To update one or more records, we can use the UPDATE statement. For example: UPDATE users SET age = 33 WHERE name = ‘John’. This will set the age of any user with the name “John” to 33.

Finally, to delete records from the database, we can use the DELETE statement. For example: DELETE FROM users WHERE age > 40. This query will delete any user records with an age greater than 40.

MySQL has many powerful features for managing, querying, searching, inserting, updating, and deleting data. By following the instructions in this article, you will be able to use these features to your advantage.

Deprecation Notice in ./../../php/Twig/Loader/FilesystemLoader.php
realpath(): Passing null to parameter #1 ($path) of type string is deprecated

Backtrace

FilesystemLoader.php: realpath(NULL)
./libraries/classes/Template.php: TwigLoaderFilesystemLoader->__construct(string ‘/usr/share/phpmyadmin//templates/’)
./libraries/classes/Theme.php: PhpMyAdminTemplate->__construct()
./libraries/classes/Theme.php: PhpMyAdminTheme->__construct()
./libraries/classes/ThemeManager.php: PhpMyAdminTheme::load(
string ‘./themes/pmahomme’,
string ‘/usr/share/phpmyadmin/./themes/pmahomme/’,
)
./libraries/classes/ThemeManager.php: PhpMyAdminThemeManager->loadThemes()
./libraries/classes/ThemeManager.php: PhpMyAdminThemeManager->__construct()
./libraries/classes/ThemeManager.php: PhpMyAdminThemeManager::getInstance()
./libraries/common.inc.php: PhpMyAdminThemeManager::initializeTheme()
./index.php: require_once(./libraries/common.inc.php)

***

Deprecation Notice in ./../../php/Twig/Node/Node.php
Return type of TwigNodeNode::getIterator() should either be compatible with IteratorAggregate::getIterator(): Traversable, or the #[ReturnTypeWillChange] attribute should be used to temporarily suppress the notice

Backtrace

autoload.php: require(./../../php/Twig/Node/Node.php)
{closure}(string ‘Twig\Node\Node’)
TwigFilter.php: class_exists(string ‘Twig\Node\Node’)
autoload.php: require(./../../php/Twig/TwigFilter.php)
CoreExtension.php: {closure}(string ‘Twig\TwigFilter’)
ExtensionSet.php: TwigExtensionCoreExtension->getFilters()
ExtensionSet.php: TwigExtensionSet->initExtension()
ExtensionSet.php: TwigExtensionSet->initExtensions()
Environment.php: TwigExtensionSet->getFilter(string ‘error’)
./../../../../../../var/lib/phpmyadmin/tmp/twig/49/49433f77d3462b2488dfef3699484854e3c55e4b348dae30482fadd1ce008731.php: TwigEnvironment->getFilter(string ‘error’)
Template.php: __TwigTemplate_95dd0b99dd97a989e49170a5554a1e0ce6595b0346e92b70254c854745cea47e->doDisplay(
array,
array,
)
Template.php: TwigTemplate->displayWithErrorHandling(
array,
array,
)
Template.php: TwigTemplate->display(array)
TemplateWrapper.php: TwigTemplate->render(
array,
array,
)
./libraries/classes/Template.php: TwigTemplateWrapper->render(array)
./libraries/classes/Plugins/Auth/AuthenticationCookie.php: PhpMyAdminTemplate->render(
string ‘login/header’,
array,
)
./libraries/classes/Plugins/AuthenticationPlugin.php: PhpMyAdminPluginsAuthAuthenticationCookie->showLoginForm()
./libraries/common.inc.php: PhpMyAdminPluginsAuthenticationPlugin->authenticate()
./index.php: require_once(./libraries/common.inc.php)

How to FIX:

Update your phpMyAdmin manualy…

Enter to the directory:
cd /usr/share/

Rename your phpMyAdmin directory to phpmyadmin.bak:
mv /usr/share/phpmyadmin/ /usr/share/phpmyadmin.bak

Create a new phpMyAdmin folder:
mkdir /usr/share/phpmyadmin/

Enter to the directory:
cd /usr/share/phpmyadmin/

Download and extract phpMyAdmin:
wget https://www.phpmyadmin.net/downloads/phpMyAdmin-latest-all-languages.tar.gz
tar xzf phpMyAdmin-*-all-languages.tar.gz

List folders:
ls

You should see a new folder phpMyAdmin-*-all-languages

Move the contents of this folder to /usr/share/phpmyadmin:
mv phpMyAdmin-*-all-languages/* /usr/share/phpmyadmin

Make a copy of /usr/share/phpmyadmin/config.sample.inc.php:
cp /usr/share/phpmyadmin/config.sample.inc.php /usr/share/phpmyadmin/config.inc

Edit the /usr/share/phpmyadmin/config.inc.php

Search line:
$cfg[‘blowfish_secret’] = ”; /* YOU MUST FILL IN THIS FOR COOKIE AUTH! */
And change to (example):
$cfg[‘blowfish_secret’] = ‘2RQ&Vb&ShmZMJcSR’; /* YOU MUST FILL IN THIS FOR COOKIE AUTH! */

Search line (example):
$cfg[‘TempDir’] = ‘/tmp’;
And change to:
$cfg[‘TempDir’] = ‘/var/tmp/phpMyAdmin’;
if you don’t have this line (Temporary Directory Config), after line declare(strict_types=1);, add:
$cfg[‘TempDir’] = ‘/var/tmp/phpMyAdmin’;

Create temporary directory:
mkdir -p /var/tmp/phpMyAdmin
chown www-data:www-data /var/tmp/phpMyAdmin
chmod -R 700 /var/tmp/phpMyAdmin

Cleanup:
rm -rf /usr/share/phpmyadmin/phpMyAdmin-latest-all-languages.tar.gz

Now check your new phpMyAdmin installation is working correctly, if working correctly you can delete backup folder:
rm -rf /usr/share/phpmyadmin.bak

On November 28th, 2020, the PHP community issued a deprecation notice for the popular open source web application, phpMyAdmin. The notice came as part of the release of PHP 8, the latest version of the programming language. phpMyAdmin was originally developed as an interface used to manage MySQL databases on web servers, and has since grown into a widely used open source application that can also manage MariaDB, PostgreSQL, and other databases.

The deprecation notice states that, in the interest of performance, security, and accuracy, the implementation of mysqlnd driver for phpMyAdmin will be removed in favor of mysqli (or its object-oriented variant). This new driver offers better handling of database queries and quoting of strings. The phpMyAdmin development team also noted that they will no longer support the use of the mysql extension in phpMyAdmin or any other application.

In addition to these changes, the phpMyAdmin developers have also released modified versions of their existing application that are compatible with PHP 8. Users should upgrade their versions of phpMyAdmin in order to take advantage of the new features and performance improvements.

The deprecation of the mysql extension in favor of mysqli has long been a worry for phpMyAdmin users. Although it may be difficult for some users to make the transition, the new benefits are hard to deny. The improved performance, security and accuracy provided by mysqli make the move to PHP 8 a wise decision for most, if not all, phpMyAdmin users.