Handler session error

Answer by Ember Nava

However, this is just for capturing the session errors. A better way would be to create a general error handler that creates exceptions from errors and surround code parts that may throw errors with try … catch blocks. ,The regular PHP session functions don’t throw exceptions but trigger errors. Try writing an error handler function and setting the error handler before calling session_start.,I’m looking for a general way to handle session_start errors, not a way to handle one specific error. There are numerous errors which can happen, such as the session directory being full, which cause a fatal error. I want a way to trap those errors and handle them cleanly, without having to write custom handlers for each possibility.,
By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

The regular PHP session functions don’t throw exceptions but trigger errors. Try writing an error handler function and setting the error handler before calling session_start.

function session_error_handling_function($code, $msg, $file, $line) {
    // your handling code here
}

set_error_handler('session_error_handling_function');
session_start();
restore_error_handler();

Answer by Aniya Guzman

I have this at the very top of my send.php file:,And the following at the very top of my test.php file:,So first thing it relate to permission ,Second thing it relate to session.save_path

I have this at the very top of my send.php file:

ob_start();
@session_start();

//some display stuff

$_SESSION['id'] = $id; //$id has a value
header('location: test.php');

And the following at the very top of my test.php file:

ob_start();
@session_start();

error_reporting(E_ALL);
ini_set('display_errors', '1');

print_r($_SESSION);

Answer by Egypt Acosta

session_cache_expire — Get and/or set current cache expire,session_abort — Discard session array changes and finish session,session_cache_limiter — Get and/or set the current cache limiter,session_id — Get and/or set the current session id

There is a nuance we found with session timing out although the user is still active in the session.  The problem has to do with never modifying the session variable.

The GC will clear the session data files based on their last modification time.  Thus if you never modify the session, you simply read from it, then the GC will eventually clean up.

To prevent this you need to ensure that your session is modified within the GC delete time.  You can accomplish this like below.

<?php
if( !isset($_SESSION['last_access']) || (time() - $_SESSION['last_access']) > 60 )
  $_SESSION['last_access'] = time();
?>

This will update the session every 60s to ensure that the modification date is altered.

Answer by Alisson Pugh

Session variables are set with the PHP global variable: $_SESSION.,A session is started with the session_start() function.,Also notice that all session variable values are stored in the global $_SESSION variable:,Note: The session_start() function must be the very
first thing in your document. Before any HTML tags.

session_start();
["favcolor"] = "green";

Answer by Gracie Welch

Error handling is the process of catching errors raised by your program and then taking appropriate action. If you would handle errors properly then it may lead to many unforeseen consequences.,While writing your PHP program you should check all possible error condition before going ahead and take appropriate action when required.,Fatal user-generated error. This is like an E_ERROR set by the programmer using the PHP function trigger_error(),Following is the way you can create one error handling function −

Try following example without having /tmp/test.xt file and with this file.

<?php
   if(!file_exists("/tmp/test.txt")) {
      die("File not found");
   }else {
      $file = fopen("/tmp/test.txt","r");
      print "Opend file sucessfully";
   }
   // Test of the code here.
?>

Syntax

error_function(error_level,error_message, error_file,error_line,error_context);

All the above error level can be set using following PHP built-in library function where level cab be any of the value defined in above table.

int error_reporting ( [int $level] )

Following is the way you can create one error handling function −

<?php
   function handleError($errno, $errstr,$error_file,$error_line) {
      echo "<b>Error:</b> [$errno] $errstr - $error_file:$error_line";
      echo "<br />";
      echo "Terminating PHP Script";
      
      die();
   }
?>

Once you define your custom error handler you need to set it using PHP built-in library set_error_handler function. Now lets examine our example by calling a function which does not exist.

<?php
   error_reporting( E_ERROR );
   
   function handleError($errno, $errstr,$error_file,$error_line) {
      echo "<b>Error:</b> [$errno] $errstr - $error_file:$error_line";
      echo "<br />";
      echo "Terminating PHP Script";
      
      die();
   }
   
   //set error handler
   set_error_handler("handleError");
   
   //trigger error
   myFunction();
?>

Following is the piece of code, copy and paste this code into a file and verify the result.

<?php
   try {
      $error = 'Always throw this error';
      throw new Exception($error);
      
      // Code following an exception is not executed.
      echo 'Never executed';
   }catch (Exception $e) {
      echo 'Caught exception: ',  $e->getMessage(), "n";
   }
   
   // Continue execution
   echo 'Hello World';
?>

You can define your own custom exception handler. Use following function to set a user-defined exception handler function.

string set_exception_handler ( callback $exception_handler )

Example

<?php
   function exception_handler($exception) {
      echo "Uncaught exception: " , $exception->getMessage(), "n";
   }
	
   set_exception_handler('exception_handler');
   throw new Exception('Uncaught Exception');
   
   echo "Not Executedn";
?>

Answer by Stanley Whitaker

The important thing is that the session_start function must be called at the beginning of the script, before any output is sent to the browser. Otherwise, you’ll encounter the infamous Headers are already sent error.,In this article, we’ve explored the basics of session handling in PHP. It’s a key concept which allows you to persist information across web pages.,Session handling is a key concept in PHP that enables user information to be persisted across all the pages of a website or app. In this post, you’ll learn the basics of session handling in PHP.,You can also learn about session variables in my post on using cookies in PHP.

This is the method that you’ll see most often, where a session is started by the session_start function.

<?php
// start a session
session_start();
 
// manipulate session variables
?>

There’s a configuration option in the php.ini file which allows you to start a session automatically for every request—session.auto_start. By default, it’s set to 0, and you can set it to 1 to enable the auto startup functionality.

session.auto_start = 1

On the other hand, if you don’t have access to the php.ini file, and you’re using the Apache web server, you could also set this variable using the .htaccess file.

php_value session.auto_start 1

As we discussed earlier, the server creates a unique number for every new session. If you want to get a session id, you can use the session_id function, as shown in the following snippet.

<?php
session_start();
echo session_id();
?>

That should give you the current session id. The session_id function is interesting in that it can also take one argument—a session id. If you want to replace the system-generated session id with your own, you can supply it to the first argument of the session_id function.

<?php
session_id(YOUR_SESSION_ID);
session_start();
?>

Let’s go through the following example script that demonstrates how to initialize session variables.

<?php
// start a session
session_start();
 
// initialize session variables
$_SESSION['logged_in_user_id'] = '1';
$_SESSION['logged_in_user_name'] = 'Tutsplus';
 
// access session variables
echo $_SESSION['logged_in_user_id'];
echo $_SESSION['logged_in_user_name'];
?>

Let’s see how to modify the session variables.

<?php
session_start();
 
if (!isset($_SESSION['count']))
{
  $_SESSION['count'] = 1;
}
else
{
  ++$_SESSION['count'];
}
 
echo $_SESSION['count'];
?>

On the other hand, if you would like to delete a session variable, you can use the unset function, as shown in the following snippet.

<?php
// start a session
session_start();
 
// initialize a session variable
$_SESSION['logged_in_user_id'] = '1';
 
// unset a session variable
unset($_SESSION['logged_in_user_id']);
?>

So if you’re using the session_destroy function to log a user out, you must unset the $_SESSION variable and unset the session cookie as well. Thus, the recommended way to destroy a session completely is:

<?php
// start a session
session_start();
 
// destroy everything in this session
 
unset($_SESSION);
if (ini_get("session.use_cookies")) {
    $params = session_get_cookie_params();
    setcookie(session_name(), '', time() - 42000, $params["path"], $params["domain"], $params["secure"],$params["httponly"]);
}
 
session_destroy();
?>

In our example, we’re going to store sessions in the MySQL database. So let’s create a table which stores the session data by using the following snippet.

CREATE TABLE `sessions` (
  `session_id` varbinary(192) NOT NULL,
  `created` int(11) NOT NULL DEFAULT '0',
  `session_data` longtext COLLATE utf8mb4_unicode_ci,
  PRIMARY KEY (`session_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Next, let’s see how our custom database session handler looks:

<?php
class MySQLSessionHandler implements SessionHandlerInterface
{
    private $connection;

    public function __construct()
    {
        $this->connection = new mysqli("HOST_NAME","USERNAME","PASSWORD","DATABASENAME");
    }

    public function open($savePath, $sessionName)
    {
        if ($this->connection) {
            return TRUE;
        } else {
            return FALSE;
        }
    }

    public function read($sessionId)
    {
        try {
            $stmt = $this->connection->prepare("SELECT session_data FROM sessions WHERE session_id = ?");
            $stmt->bind_param("s", $sessionId);
            $stmt->execute();
            $stmt->bind_result($sessionData);
            $stmt->fetch();
            $stmt->close();

            return $sessionData ? $sessionData : '';
        } catch (Exception $e) {
            return '';
        }
    }

    public function write($sessionId, $sessionData)
    {
        try {
            $stmt = $this->connection->prepare("REPLACE INTO sessions(`session_id`, `created`, `session_data`) VALUES(?, ?, ?)");
            $stmt->bind_param("sis", $sessionId, $time=time(), $sessionData);
            $stmt->execute();
            $stmt->close();

            return TRUE;
        } catch (Exception $e) {
            return FALSE;
        }
    }

    public function destroy($sessionId)
    {
        try {
            $stmt = $this->connection->prepare("DELETE FROM sessions WHERE session_id = ?");
            $stmt->bind_param("s", $sessionId);
            $stmt->execute();
            $stmt->close();

            return TRUE;
        } catch (Exception $e) {
            return FALSE;
        }
    }

    public function gc($maxlifetime)
    {
        $past = time() - $maxlifetime;

        try {
            $stmt = $this->connection->prepare("DELETE FROM sessions WHERE `created` < ?");
            $stmt->bind_param("i", $past);
            $stmt->execute();
            $stmt->close();

            return TRUE;
        } catch (Exception $e) {
            return FALSE;
        }
    }

    public function close()
    {
        return TRUE;
    }
}

Our custom session handler class MySQLSessionHandler implements the SessionHandlerInterface interface. Thus, it must implement methods that are declared in the SessionHandlerInterface interface. We’ll look at these methods one by one to understand how each one works.

    public function __construct()
    {
        $this->connection = new mysqli("HOST_NAME","USERNAME","PASSWORD","DATABASENAME");
    }

First, to use this code, make sure to replace the HOST_NAME, USERNAME, and other placeholders with actual values in the __construct method.

    public function open($savePath, $sessionName)
    {
        if ($this->connection) {
            return TRUE;
        } else {
            return FALSE;
        }
    }

When the session is started, the open method is called. It returns TRUE if the database connection was successful. If there was any problem setting up the database connection, it returns FALSE.

    public function read($sessionId)
    {
        try {
            $stmt = $this->connection->prepare("SELECT session_data FROM sessions WHERE session_id = ?");
            $stmt->bind_param("s", $sessionId);
            $stmt->execute();
            $stmt->bind_result($sessionData);
            $stmt->fetch();
            $stmt->close();

            return $sessionData ? $sessionData : '';
        } catch (Exception $e) {
            return '';
        }
    }

Next, PHP calls the read method to read the session data. The read method receives the session id as the first argument. We’ll check if there’s any entry available for this session id in the session_data table. If it exists, we’ll return the session data; otherwise, an empty string will be returned.

    public function write($sessionId, $sessionData)
    {
        try {
            $stmt = $this->connection->prepare("REPLACE INTO sessions(`session_id`, `created`, `session_data`) VALUES(?, ?, ?)");
            $stmt->bind_param("sis", $sessionId, $time=time(), $sessionData);
            $stmt->execute();
            $stmt->close();

            return TRUE;
        } catch (Exception $e) {
            return FALSE;
        }
    }

When PHP needs to save or close a session, it calls the write method. It’s used to write the session data in a database. We’ve used the REPLACE syntax to make sure that if an entry exists, it will be updated; otherwise, it’ll be inserted.

    public function close()
    {
        return TRUE;
    }

The close method is called after the session write method has been called. It works similar to a destructor in classes. In our case, there is nothing particular that needs to be done in the close method.

    public function destroy($sessionId)
    {
        try {
            $stmt = $this->connection->prepare("DELETE FROM sessions WHERE session_id = ?");
            $stmt->bind_param("s", $sessionId);
            $stmt->execute();
            $stmt->close();

            return TRUE;
        } catch (Exception $e) {
            return FALSE;
        }
    }

The destroy method is called when the session is destroyed with either the session_destroy or session_regenerate_id function. In this method, the session data is deleted from a database if it exists.

    public function gc($maxlifetime)
    {
        $past = time() - $maxlifetime;

        try {
            $stmt = $this->connection->prepare("DELETE FROM sessions WHERE `created` < ?");
            $stmt->bind_param("i", $past);
            $stmt->execute();
            $stmt->close();

            return TRUE;
        } catch (Exception $e) {
            return FALSE;
        }
    }

Now, let’s see how to use the MySQLSessionHandler handler class.

$objSessionHandler = new MySQLSessionHandler();
session_set_save_handler($objSessionHandler, true);
session_start();
$_SESSION['favoriteWebsite'] = 'tutsplus.com';

Answer by Danna Molina

In PHP, we can use our custom method to display any message or execute any code when error occurs. All we have to do is set our method as the default error handler for PHP using the function set_error_handler(),Error handling is done to gracefully handle errors in the code and provide a better user experience to the end user.,As you can see in the code above the error condition is handled. Now our code will not display any error on scree, rather it will display a message and exit gracefully.,Now let’s see how we can use conditional statements to handle error conditions. This type of error handling is useful when we know situations which may lead to errors beforehand.

An error can occur when we try to divide a number with zero, or try to open a file which doesn’t exist, let’s take an example and see how we can use die() function or conditional statement to handle error conditions.

<?php
    
    $fileName = "noerror.txt";
    // opening the file
    fopen($fileName, "r")
    or die("Unable to open file $fileName");
    
?>

For example, the below code will lead to error:

<?php
    
    function division($numerator, $denominator) {
        // perform division operation
        echo $numerator / $denominator;
    }
    
    // calling the function
    division(7, 0);
    
?>

In such situation, where we know certain condition can lead to error, we can use conditional statement to handle the corner case which will lead to error. Let’s fix the above code:

<?php
    
    function division($numerator, $denominator) {
        // use if statement to check for zero
        if($denominator != 0) {
            echo $numerator / $denominator;
        }
        else {
            echo "Division by zero(0) no allowed!";
        }
    }

    // calling the function
    division(7, 0);
    
?>

Let’s take an example:

<?php
    
    // custom function to handle error
    function studytonight_error_handler($error_no, $error_msg) {
        echo "Oops! Something unexpected happen...";
        echo "Possible reason: " . $error_msg;
        echo "We are working on it.";
    }
    
    // set the above function s default error handler
    set_error_handler("studytonight_error_handler");
    
    $result = 7 / 0;
    
?>

Following is the syntax for this function:

<?php
    // error reporting function
    error_reporting($reporting_level);
    
?>

Answer by Troy Patton

On the call of new SimpleSAMLAuthSimple(‘default-sp’); it tries to create a new session or use the existing session for SimpleSAML, where it fails with an error,But the cookies SimpleSAML and SimpleSAMLAuthToken have values and as seen from the error message I shared in the issue, it tries to load the session using that session id from cookie SimpleSAML.,But for a validation page in the application, it fails after it has user authenticated with IDP and has the auth token already in session.,@jaimeperez I have been looking into sessions configuration and stumbled upon these error messages generated by simplesaml, this is after the authentication is done from the IDP.

Fatal error: Uncaught SimpleSAMLErrorException: Cannot load PHP session with a specific ID. in /var/simplesamlphp/lib/SimpleSAML/SessionHandlerPHP.php:268 
Stack trace: 
#0 /var/simplesamlphp/lib/SimpleSAML/Session.php(344): SimpleSAMLSessionHandlerPHP->loadSession('...') 
#1 /var/simplesamlphp/lib/SimpleSAML/Session.php(259): SimpleSAMLSession::getSession() 
#2 /var/simplesamlphp/lib/SimpleSAML/Auth/Simple.php(51): SimpleSAMLSession::getSessionFromRequest() 
#3 /var/www/html/*.php(14): SimpleSAMLAuthSimple->__construct('default-sp') 
#4 /var/www/html/*.php(186): .....
#5 {main} thrown in /var/simplesamlphp/lib/SimpleSAML/SessionHandlerPHP.php on line 268

Answer by Danna Molina

Exception handling is a powerful mechanism of PHP, which is used to handle runtime errors (runtime errors are called exceptions). So that the normal flow of the application can be maintained.,PHP provides a powerful mechanism, exception handling. It allows you to handle runtime errors such as IOException, SQLException, ClassNotFoundException, and more. A most popular example of exception handling is — divide by zero exception, which is an arithmetic exception.,Exception handling is an important mechanism in PHP, which have the following advantages over error handling -,In other words, — «An unexpected result of a program is an exception, which can be handled by the program itself.» Exceptions can be thrown and caught in PHP.

Exception Message: Value must be less than 1

Хочу описать статью с возможными ошибками работы PHP и сессиями в Unix/Linux. Думаю многие сталкиваются и будет полезно знать как решать ту, или иную ошибку.

Обновлял заббикс и после его обновления, перестал корректно работать, посмотрел лог и увидел:

2017/12/08 21:15:48 [error] 40014#40014: *395 FastCGI sent in stderr: "PHP message: PHP Warning:  require_once(/etc/zabbix/web/maintenance.inc.php): failed to open stream: Permission denied in /usr/share/zabbix/include/classes/core/ZBase.php on line 269

-=== Ошибка 1 ===-

Можно увидить следующую ошибку:

Cannot start session without errors, please check errors given in your PHP and/or webserver log file and configure your PHP installation properly. Also ensure that cookies are enabled in your browser.

Возникла у меня при установке phpmyadmin.

Так же, если имеется cPanel, может возникнуть такая же ошибка, я описывал решение в моей статье:

ошибка в phpMyAdmin «Cannot start session without errors»

-=== Ошибка 2 ===-

При работе с апачем, я получил:

Warning: session_start() [function.session-start]: open(/var/lib/php/session/sess_eqbchncji8kj22f0iqa9g3v7u2, O_RDWR) failed: Permission denied (13) in /var/www/vhosts/httpdocs/index.php on line 6
Warning: Unknown: open(/var/lib/php/session/sess_eqbchncji8kj22f0iqa9g3v7u2, O_RDWR) failed: Permission denied (13) in Unknown on line 0
Warning: Unknown: Failed to write session data (files). Please verify that the current setting of session.save_path is correct (/var/lib/php/session) in Unknown on line 0

-=== Ошибка 3 ===-

Получил еще ошибку:

FastCGI sent in stderr: “PHP message: PHP Warning: Unknown: Failed to write session data (files). Please verify that the current setting of session.save_path is correct (/var/lib/php/session) in Unknown on line 0” while reading upstream, client: 37.***.***.56, server: rtfm.co.ua, request: “POST /wp-admin/admin-ajax.php HTTP/1.1”, upstream: “fastcgi://127.0.0.1:9009”, host: “rtfm.co.ua”, referrer: “http://linux-notes.org/wp-admin/post.php?post=5496&action=edit&message=10”

Другие ошибки я буду добавлять по мере их возникновения.

Решения ошибок работы с PHP сессиями в Unix/Linux

Ну что, пришли к решению. Первое что необходимо сделать, — так проверить путь куда сохраняются сессии, для этого, выполните:

$ php -i |grep save_path

session.save_path => /var/lib/php/session => /var/lib/php/session

Как видно у меня этот путь рассположен в /var/lib/php/session директории.

Проверим права на данную директорию:

# ls -alh /var/lib/php/session

Смотрим от какого юзера идет выполнение php кода:

# ps aux |grep php-fpm

PS: Или, можно зайти в ваш пул php-fpm и найти пользователя от которого он запущен!

Решение довольно примитивное. Для начала, стоит создать папку под использующие сессии (если ее нет еще) и выставить права:

# mkdir /var/lib/php/session
# chmod 1777 /var/lib/php/session

И так же, выставляем владельца и группу:

# chown root:www /var/lib/php/session
# chown -R www: /var/cache/nginx

ИЛИ:

# chmod o+rw /var/lib/php/session

Потом, открываем ваш php.ini и находим строку:

;session.save_path = "/tmp"

И нужно выполнить расскоменчивание данной строки.

PS: Возможно, нужно будет выставить права и владельца!

Если вы используете выделенные пулы под свои php- проекты, то стоит поискать данную строку в:

# grep -lR 'php_value' /etc/php-fpm.d

Если покажет файлы, то стоит посмотреть привести к:

[...]
php_value[session.save_handler] = files
php_value[session.save_path] = /var/lib/php/session
[...]

Перезапускаем php-fpm службу:

# service php-fpm restart

Для апача, следуюет указать следующие строки:

php_value session.save_handler "files"
php_value session.save_path    "/var/lib/php/session"

а поиск файла можно сделать так:

# grep -lR 'php_value' /etc/

И тоже, выполнить перезапуск службы:

# service httpd restart

Вот и все решение! А у меня на этом статья «Ошибки работы с PHP сессиями в Unix/Linux» завершена.

0 Пользователей и 1 Гость просматривают эту тему.

public $session_handler = 'database';