Php error warning session start



linux-notes.org

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Добавить комментарий Отменить ответ

Этот сайт использует Akismet для борьбы со спамом. Узнайте, как обрабатываются ваши данные комментариев.

Источник

session_start

(PHP 4, PHP 5, PHP 7, PHP 8)

session_start — Стартует новую сессию, либо возобновляет существующую

Описание

Функция session_start() создаёт сессию, либо возобновляет существующую, основываясь на идентификаторе сессии, переданном через GET- или POST-запрос, либо переданный через cookie.

Когда вызвана функция session_start() или когда сессия создаётся автоматически, PHP вызовет открытие и чтение обработчиков записи сессии. Это могут быть как встроенные обработчики, так и предоставляемые модулями (например, SQLite или Memcached); или вообще определённый пользователем обработчик, заданный функцией session_set_save_handler() . Callback-функция чтения извлечёт все существующие данные сессии (сохранённые в специальном сериализованном виде), десериализует их и занесёт в суперглобальный массив $_SESSION, после чего вернёт сохранённые данные обработчику сессий PHP.

Для использования именованных сессий, используйте session_name() перед session_start() .

Если разрешена опция session.use_trans_sid, функция session_start() регистрирует внутренний обработчик вывода для перезаписи URL.

Если пользователь использует ob_gzhandler или что-то подобное совместно с функцией ob_start() , порядок функций важен для правильного вывода. К примеру, ob_gzhandler должен быть зарегистрирован до старта сессии.

Список параметров

Если задано, то должно быть ассоциативным массивом, переопределяющим текущие директивы конфигурации сессий. Ключи не должны иметь префикса session. .

В дополнение к обычному набору конфигурационных директив, может быть добавлена опция read_and_close . Если установлена в true , то сессия будет закрыта сразу же после прочтения, теоретически позволяя избежать блокировки, если данные сессии не будут изменяться.

Возвращаемые значения

Функция возвращает true , если сессия успешно стартована, в противном случае false .

Список изменений

Версия Описание
7.1.0 session_start() теперь возвращает false и больше не инициализирует $_SESSION , когда она не смогла запустить сессию.

Примеры

Простой пример сессии

Пример #1 page1.php

echo ‘Добро пожаловать на страницу 1’ ;

$_SESSION [ ‘favcolor’ ] = ‘green’ ;
$_SESSION [ ‘animal’ ] = ‘cat’ ;
$_SESSION [ ‘time’ ] = time ();

// Работает, если сессионная cookie принята
echo ‘
page 2′ ;

// Или можно передать идентификатор сессии, если нужно
echo ‘
. SID . ‘»>page 2’ ;
?>

После просмотра page1.php , вторая страница page2.php чудесным образом получит все данные сессии. Читайте раздел работа с сессиями, там рассказывается про передачу идентификаторов сессий. В частности там рассказывается про то, что такое константа SID .

Пример #2 page2.php

echo ‘Добро пожаловать на страницу 2
‘ ;

echo $_SESSION [ ‘favcolor’ ]; // green
echo $_SESSION [ ‘animal’ ]; // cat
echo date ( ‘Y m d H:i:s’ , $_SESSION [ ‘time’ ]);

// Можете тут использовать идентификатор сессии, как в page1.php
echo ‘
page 1′ ;
?>

Передача опций в session_start()

Пример #3 Переопределение времени жизни cookie

Пример #4 Чтение и закрытие сессии

Примечания

Для использования сессий на основе cookie, функция session_start() должна быть вызвана перед выводом чего бы то ни было в браузер.

Эта функция отсылает несколько заголовков HTTP, в зависимости от настроек. Смотрите описание функции session_cache_limiter() для управления этими заголовками.

Смотрите также

  • $_SESSION
  • Директива конфигурации session.auto_start
  • session_id() — Получает и/или устанавливает идентификатор текущей сессии

User Contributed Notes 39 notes

If you want to handle sessions with a class, I wrote this little class:

/*
Use the static method getInstance to get the object.
*/

class Session
<
const SESSION_STARTED = TRUE ;
const SESSION_NOT_STARTED = FALSE ;

// The state of the session
private $sessionState = self :: SESSION_NOT_STARTED ;

// THE only instance of the class
private static $instance ;

private function __construct () <>

/**
* Returns THE instance of ‘Session’.
* The session is automatically initialized if it wasn’t.
*
* @return object
**/

public static function getInstance ()
<
if ( !isset( self :: $instance ))
<
self :: $instance = new self ;
>

self :: $instance -> startSession ();

return self :: $instance ;
>

/**
* (Re)starts the session.
*
* @return bool TRUE if the session has been initialized, else FALSE.
**/

public function startSession ()
<
if ( $this -> sessionState == self :: SESSION_NOT_STARTED )
<
$this -> sessionState = session_start ();
>

return $this -> sessionState ;
>

/**
* Stores datas in the session.
* Example: $instance->foo = ‘bar’;
*
* @param name Name of the datas.
* @param value Your datas.
* @return void
**/

public function __set ( $name , $value )
<
$_SESSION [ $name ] = $value ;
>

/**
* Gets datas from the session.
* Example: echo $instance->foo;
*
* @param name Name of the datas to get.
* @return mixed Datas stored in session.
**/

public function __get ( $name )
<
if ( isset( $_SESSION [ $name ]))
<
return $_SESSION [ $name ];
>
>

public function __isset ( $name )
<
return isset( $_SESSION [ $name ]);
>

public function __unset ( $name )
<
unset( $_SESSION [ $name ] );
>

/**
* Destroys the current session.
*
* @return bool TRUE is session has been deleted, else FALSE.
**/

public function destroy ()
<
if ( $this -> sessionState == self :: SESSION_STARTED )
<
$this -> sessionState = ! session_destroy ();
unset( $_SESSION );

return ! $this -> sessionState ;
>

// We get the instance
$data = Session :: getInstance ();

// Let’s store datas in the session
$data -> nickname = ‘Someone’ ;
$data -> age = 18 ;

// Let’s display datas
printf ( ‘

My name is %s and I\’m %d years old.

‘ , $data -> nickname , $data -> age );

/*
It will display:

printf ( » , print_r ( $_SESSION , TRUE ));

// TRUE
var_dump ( isset( $data -> nickname ));

// We destroy the session
$data -> destroy ();

// FALSE
var_dump ( isset( $data -> nickname ));

?>

I prefer using this class instead of using directly the array $_SESSION.

The constant SID would always be » (an empty string) if directive session.use_trans_sid in php ini file is set to 0.

So remember to set session.use_trans_sid to 1 and restart your server before you use SID in your php script.

I recently made an interesting observation:

It seems that `session_start()` can return `true` even if the session was not properly created. In my case, the disk storage was full and so the session data could not be written to disk. I had some logic that resulted in an infinite loop when the session was not written to disk.

To check if the session really was saved to disk I used:

«`
function safe_session_start () <
# Attempt to start a session
if (!@\ session_start ()) return false ;

#
# Check if we need to perform
# the write test.
#
if (!isset( $_SESSION [ ‘__validated’ ])) <
$_SESSION [ ‘__validated’ ] = 1 ;

# Attempt to write session to disk
@\ session_write_close ();

# Unset the variable from memory.
# This step may be unnecessary
unset( $_SESSION [ ‘__validated’ ]);

# Re-start session
@\ session_start ();

# Check if variable value is retained
if (!isset( $_SESSION [ ‘__validated’ ])) <
# Session was not written to disk
return false ;
>
>

if (! safe_session_start ()) <
# Sessions are probably not written to disk.
# Handle error accordingly.
>

Took me quite a while to figure this out.

Maybe it helps someone!

If you are using a custom session handler via session_set_save_handler() then calling session_start() in PHP 7.1 you might see an error like this:
session_start(): Failed to read session data: user (path: /var/lib/php/session) in .

As of this writing, it seems to be happening in PHP 7.1, and things look OK in PHP7.0.

It is also hard to track down because if a session already exists for this id (maybe created by an earlier version of PHP), it will not trigger this issue because the $session_data will not be null.

The fix is simple. you just need to check for ‘null’ during your read function:

function read ( $id )
<
//. pull the data out of the DB, off the disk, memcache, etc
$session_data = getSessionDataFromSomewhere ( $id );

//check to see if $session_data is null before returning (CRITICAL)
if( is_null ( $session_data ))
<
$session_data = » ; //use empty string instead of null!
>

As others have noted, PHP’s session handler is blocking. When one of your scripts calls session_start(), any other script that also calls session_start() with the same session ID will sleep until the first script closes the session.

A common workaround to this is call session_start() and session_write_close() each time you want to update the session.

The problem with this, is that each time you call session_start(), PHP prints a duplicate copy of the session cookie to the HTTP response header. Do this enough times (as you might do in a long-running script), and the response header can get so large that it causes web servers & browsers to crash or reject your response as malformed.

This error has been reported to PHP HQ, but they’ve marked it «Won’t fix» because they say you’re not supposed to open and close the session during a single script like this. https://bugs.php.net/bug.php?id=31455

As a workaround, I’ve written a function that uses headers_list() and header_remove() to clear out the duplicate cookies. It’s interesting to note that even on requests when PHP sends duplicate session cookies, headers_list() still only lists one copy of the session cookie. Nonetheless, calling header_remove() removes all the duplicate copies.

/**
* Every time you call session_start(), PHP adds another
* identical session cookie to the response header. Do this
* enough times, and your response header becomes big enough
* to choke the web server.
*
* This method clears out the duplicate session cookies. You can
* call it after each time you’ve called session_start(), or call it
* just before you send your headers.
*/
function clear_duplicate_cookies () <
// If headers have already been sent, there’s nothing we can do
if ( headers_sent ()) <
return;
>

$cookies = array();
foreach ( headers_list () as $header ) <
// Identify cookie headers
if ( strpos ( $header , ‘Set-Cookie:’ ) === 0 ) <
$cookies [] = $header ;
>
>
// Removes all cookie headers, including duplicates
header_remove ( ‘Set-Cookie’ );

// Restore one copy of each cookie
foreach( array_unique ( $cookies ) as $cookie ) <
header ( $cookie , false );
>
>
?>

PHP locks the session file until it is closed. If you have 2 scripts using the same session (i.e. from the same user) then the 2nd script will not finish its call to session_start() until the first script finishes execution.

If you have scripts that run for more than a second and users may be making more than 1 request at a time then it is worth calling session_write_close() as soon as you’ve finished writing session data.

// a lock is places on the session, so other scripts will have to wait
session_start ();

// do all your writing to $_SESSION
$_SESSION [ ‘a’ ] = 1 ;

// $_SESSION can still be read, but writing will not update the session.
// the lock is removed and other scripts can now read the session
session_write_close ();

Unfortunately, after pulling my hair out trying to figure out why my application was working fine in every browser other than IE ( Internet Explorer) (Opera, Chrome, Firefox, Safari are what I’ve tested this in) — when using a DNS CNAME record (like a vanity name that is different from the DNS A record, which is the hostname of the server) sessions do not work correctly.

If you store a session var while on the CNAME:
vanity.example.com and the hostname of the server is hosname.example.com
Then try to call the variable from a different page, it will not find it because of the CNAME (I guess it store the variable under the hostname, then when trying to read it it’s still looking under the CNAME) the same application works fine when accessing it under the hostname directly. Keep in mind that I was testing this on an internal network.

PHP Manual specifically denotes this common mistake:

Depending on the session handler, not all characters are allowed within the session id. For example, the file session handler only allows characters in the range a-z A-Z 0-9 , (comma) and — (minus)!

See session_id() manual page for more details.

When you have an import script that takes long to execute, the browser seem to lock up and you cannot access the website anymore. this is because a request is reading and locking the session file to prevent corruption.

you can either
— use a different session handler with session_set_save_handler()
— use session_write_close() in the import script as soon you don’t need session anymore (best moment is just before the long during part takes place), you can session_start when ever you want and as many times you like if your import script requires session variables changed.

example
(); //initiate / open session
$_SESSION [ ‘count’ ] = 0 ; // store something in the session
session_write_close (); //now close it,
# from here every other script can be run (and makes it seem like multitasking)
for( $i = 0 ; $i 100 ; $i ++) < //do 100 cycles
session_start (); //open the session again for editing a variable
$_SESSION [ ‘count’ ] += 1 ; //change variable
session_write_close (); //now close the session again!
sleep ( 2 ); //every cycle sleep two seconds, or do a heavy task
>
?>

3 easy but vital things about Sessions in AJAX Apps.

// It is VERY important to include a Period if using
// a whole domain. (.yourdomain.com)
// It is VERY important to set the root path your session will always
// operate in. (/members) will ensure sessions will NOT be interfered
// with a session with a path of say (/admin) . so you can log in
// as /admin and as /members. NEVER do unset($_SESSION)
// $_SESSION=array(); is preferred, session_unset(); session_destroy();

session_set_cookie_params ( 0 , ‘/members’ , ‘.yourdomain.com’ , 0 , 1 );
session_start ();
$_SESSION = array();
session_unset ();
session_destroy ();

session_set_cookie_params ( 0 , ‘/members’ , ‘.yourdomain.com’ , 0 , 1 );
session_start ();

$_SESSION [ ‘whatever’ ] = ‘youwhat’ ;

// To be safe, clear out your $_SESSION array
// Next, what most people do NOT do is delete the session cookie!
// It is easy to delete a cookie by expiring it long before the current time.
// The ONLY WAY to delete a cookie, is to make sure ALL parameters match the
// cookie to be deleted. which is easy to get those params with
// session_get_cookie_params().
// FInally, use session_unset(); and session_destroy(); in this order to ensure
// Chrome, IE, Firefox and others, are properly destroying the session.
$_SESSION = array();
if ( ini_get ( ‘session.use_cookies’ ))
<
$p = session_get_cookie_params ();
setcookie ( session_name (), » , time () — 31536000 , $p [ ‘path’ ], $p [ ‘domain’ ], $p [ ‘secure’ ], $p [ ‘httponly’ ]);
>
session_unset ();
session_destroy ();

// AJAX and SESSIONS.
// Example. you start a session based PHP page, which then calls an Ajax (XMLHTTP) authenticated
// using the SAME SESSION to Poll and output the data, for example. But, you notice when you
// try to start the Polling AJAX call always HANGS and seems to hang at the session_start().
// This is because the session is opened in the first page, calls the AJAX polling example, and
// tries to open the same session (for authentication) and do the AJAX call, you MUST call
// session_write_close(); meaning you are done writing to the $_SESSION variable, which really
// represents a file that must be CLOSED with session_write_close();.
// THAN you can call your AJAX Polling code to reopen the same session and do its polling.
// Normally, the $_SESSION is closed automatically when the script is closed or finished executing
// So, if you need to keep a PHP page running after opening a SESSION, simply close it when finished
// writing to $_SESSION so the AJAX polling page can authenticate and use the same session in a
// seperate web page.

?>

Hope this helps someone with their sessions.
Thanks.

Источник

Читайте также:  Std ofstream open error
Оцените статью
toolgir.ru
Adblock
detector