{ "mode": "perldoc", "parameter": "CGI::Session", "section": "", "url": "https://www.chedong.com/phpMan.php/perldoc/CGI%3A%3ASession/json", "generated": "2026-06-09T13:55:30Z", "synopsis": "# Object initialization:\nuse CGI::Session;\n$session = CGI::Session->new();\n$CGISESSID = $session->id();\n# Send proper HTTP header with cookies:\nprint $session->header();\n# Storing data in the session:\n$session->param('fname', 'Sherzod');\n# or\n$session->param(-name=>'lname', -value=>'Ruzmetov');\n# Flush the data from memory to the storage driver at least before your\n# program finishes since auto-flushing can be unreliable.\n$session->flush();\n# Retrieving data:\nmy $fname = $session->param('fname');\n# or\nmy $lname = $session->param(-name=>'lname');\n# Clearing a certain session parameter:\n$session->clear([\"lname\", \"fname\"]);\n# Expire 'isloggedin' flag after 10 idle minutes:\n$session->expire('isloggedin', '+10m')\n# Expire the session itself after 1 idle hour:\n$session->expire('+1h');\n# Delete the session for good:\n$session->delete();\n$session->flush(); # Recommended practice says use flush() after delete().", "sections": { "NAME": { "content": "CGI::Session - persistent session data in CGI applications\n", "subsections": [] }, "SYNOPSIS": { "content": "# Object initialization:\nuse CGI::Session;\n$session = CGI::Session->new();\n\n$CGISESSID = $session->id();\n\n# Send proper HTTP header with cookies:\nprint $session->header();\n\n# Storing data in the session:\n$session->param('fname', 'Sherzod');\n# or\n$session->param(-name=>'lname', -value=>'Ruzmetov');\n\n# Flush the data from memory to the storage driver at least before your\n# program finishes since auto-flushing can be unreliable.\n$session->flush();\n\n# Retrieving data:\nmy $fname = $session->param('fname');\n# or\nmy $lname = $session->param(-name=>'lname');\n\n# Clearing a certain session parameter:\n$session->clear([\"lname\", \"fname\"]);\n\n# Expire 'isloggedin' flag after 10 idle minutes:\n$session->expire('isloggedin', '+10m')\n\n# Expire the session itself after 1 idle hour:\n$session->expire('+1h');\n\n# Delete the session for good:\n$session->delete();\n$session->flush(); # Recommended practice says use flush() after delete().\n", "subsections": [] }, "DESCRIPTION": { "content": "CGI::Session provides an easy, reliable and modular session management system across HTTP\nrequests.\n", "subsections": [] }, "METHODS": { "content": "Following is the overview of all the available methods accessible via CGI::Session object.\n\nnew()\nnew( $sid )\nnew( $query )\nnew( $dsn, $query||$sid )\nnew( $dsn, $query||$sid, \\%dsnargs )\nnew( $dsn, $query||$sid, \\%dsnargs, \\%sessionparams )\nConstructor. Returns new session object, or undef on failure. Error message is accessible\nthrough errstr() - class method. If called on an already initialized session will re-initialize\nthe session based on already configured object. This is only useful after a call to load().\n\nCan accept up to three arguments, $dsn - Data Source Name, $query||$sid - query object OR a\nstring representing session id, and finally, \\%dsnargs, arguments used by $dsn components.\n\nIf called without any arguments, $dsn defaults to *driver:file;serializer:default;id:md5*,\n$query||$sid defaults to \"CGI->new()\", and \"\\%dsnargs\" defaults to *undef*.\n\nIf called with a single argument, it will be treated either as $query object, or $sid, depending\non its type. If argument is a string , \"new()\" will treat it as session id and will attempt to\nretrieve the session from data store. If it fails, will create a new session id, which will be\naccessible through id() method. If argument is an object, cookie() and param() methods will be\ncalled on that object to recover a potential $sid and retrieve it from data store. If it fails,\n\"new()\" will create a new session id, which will be accessible through id() method. \"name()\"\nwill define the name of the query parameter and/or cookie name to be requested, defaults to\n*CGISESSID*.\n\nIf called with two arguments first will be treated as $dsn, and second will be treated as $query\nor $sid or undef, depending on its type. Some examples of this syntax are:\n\n$s = CGI::Session->new(\"driver:mysql\", undef);\n$s = CGI::Session->new(\"driver:sqlite\", $sid);\n$s = CGI::Session->new(\"driver:dbfile\", $query);\n$s = CGI::Session->new(\"serializer:storable;id:incr\", $sid);\n# etc...\n\nBriefly, \"new()\" will return an initialized session object with a valid id, whereas \"load()\" may\nreturn an empty session object with an undefined id.\n\nTests are provided (t/newwithundef.t and t/loadwithundef.t) to clarify the result of calling\n\"new()\" and \"load()\" with undef, or with an initialized CGI object with an undefined or fake\nCGISESSID.\n\nYou are strongly advised to run the old-fashioned 'make test TESTFILES=t/newwithundef.t\nTESTVERBOSE=1' or the new-fangled 'prove -v t/newwithundef.t', for both new*.t and load*.t,\nand examine the output.\n\nFollowing data source components are supported:\n\n* driver - CGI::Session driver. Available drivers are file, dbfile, mysql and sqlite. Third\nparty drivers are welcome. For driver specs consider CGI::Session::Driver\n\n* serializer - serializer to be used to encode the data structure before saving in the disk.\nAvailable serializers are storable, freezethaw and default. Default serializer will use\nData::Dumper.\n\n* id - ID generator to use when new session is to be created. Available ID generator is md5\n\nFor example, to get CGI::Session store its data using DBFile and serialize data using\nFreezeThaw:\n\n$s = CGI::Session->new(\"driver:DBFile;serializer:FreezeThaw\", undef);\n\nIf called with three arguments, first two will be treated as in the previous example, and third\nargument will be \"\\%dsnargs\", which will be passed to $dsn components (namely, driver,\nserializer and id generators) for initialization purposes. Since all the $dsn components must\ninitialize to some default value, this third argument should not be required for most drivers to\noperate properly.\n\nIf called with four arguments, the first three match previous examples. The fourth argument must\nbe a hash reference with parameters to be used by the CGI::Session object. (see \\%sessionparams\nabove )\n\nThe following is a list of the current keys:\n\n* name - Name to use for the cookie/query parameter name. This defaults to CGISESSID. This can\nbe altered or accessed by the \"name\" accessor.\n\nundef is acceptable as a valid placeholder to any of the above arguments, which will force\ndefault behavior.\n\nload()\nload( $query||$sid )\nload( $dsn, $query||$sid )\nload( $dsn, $query, \\%dsnargs )\nload( $dsn, $query, \\%dsnargs, \\%sessionparams )\nAccepts the same arguments as new(), and also returns a new session object, or undef on failure.\nThe difference is, new() can create a new session if it detects expired and non-existing\nsessions, but \"load()\" does not.\n\n\"load()\" is useful to detect expired or non-existing sessions without forcing the library to\ncreate new sessions. So now you can do something like this:\n\n$s = CGI::Session->load() or die CGI::Session->errstr();\nif ( $s->isexpired ) {\nprint $s->header(),\n$cgi->starthtml(),\n$cgi->p(\"Your session timed out! Refresh the screen to start new session!\")\n$cgi->endhtml();\nexit(0);\n}\n\nif ( $s->isempty ) {\n$s = $s->new() or die $s->errstr;\n}\n\nNotice: All *expired* sessions are empty, but not all *empty* sessions are expired!\n\nBriefly, \"new()\" will return an initialized session object with a valid id, whereas \"load()\" may\nreturn an empty session object with an undefined id.\n\nTests are provided (t/newwithundef.t and t/loadwithundef.t) to clarify the result of calling\n\"new()\" and \"load()\" with undef, or with an initialized CGI object with an undefined or fake\nCGISESSID.\n\nYou are strongly advised to run the old-fashioned 'make test TESTFILES=t/newwithundef.t\nTESTVERBOSE=1' or the new-fangled 'prove -v t/newwithundef.t', for both new*.t and load*.t,\nand examine the output.\n\nid()\nReturns effective ID for a session. Since effective ID and claimed ID can differ, valid session\nid should always be retrieved using this method.\n\nparam($name)\nparam(-name=>$name)\nUsed in either of the above syntax returns a session parameter set to $name or undef if it\ndoesn't exist. If it's called on a deleted method param() will issue a warning but return value\nis not defined.\n\nparam($name, $value)\nparam(-name=>$name, -value=>$value)\nUsed in either of the above syntax assigns a new value to $name parameter, which can later be\nretrieved with previously introduced param() syntax. $value may be a scalar, arrayref or\nhashref.\n\nAttempts to set parameter names that start with *SESSION* will trigger a warning and undef\nwill be returned.\n\nparamhashref()\nDeprecated. Use dataref() instead.\n\ndataref()\nReturns reference to session's data table:\n\n$params = $s->dataref();\n$sid = $params->{SESSIONID};\n$name= $params->{name};\n# etc...\n\nUseful for having all session data in a hashref, but too risky to update.\n\nsaveparam()\nsaveparam($query)\nsaveparam($query, \\@list)\nSaves query parameters to session object. In other words, it's the same as calling param($name,\n$value) for every single query parameter returned by \"$query->param()\". The first argument, if\npresent, should be either CGI object or any object which can provide param() method. If it's\nundef, defaults to the return value of query(), which returns \"CGI->new\". If second argument is\npresent and is a reference to an array, only those query parameters found in the array will be\nstored in the session. undef is a valid placeholder for any argument to force default behavior.\n\nloadparam()\nloadparam($query)\nloadparam($query, \\@list)\nLoads session parameters into a query object. The first argument, if present, should be query\nobject, or any other object which can provide param() method. If second argument is present and\nis a reference to an array, only parameters found in that array will be loaded to the query\nobject.\n\nclear()\nclear('field')\nclear(\\@list)\nClears parameters from the session object.\n\nWith no parameters, all fields are cleared. If passed a single parameter or a reference to an\narray, only the named parameters are cleared.\n\nflush()\nSynchronizes data in memory with the copy serialized by the driver. Call flush() if you need to\naccess the session from outside the current session object. You should call flush() sometime\nbefore your program exits.\n\nAs a last resort, CGI::Session will automatically call flush for you just before the program\nterminates or session object goes out of scope. Automatic flushing has proven to be unreliable,\nand in some cases is now required in places that worked with CGI::Session 3.x.\n\nAlways explicitly calling \"flush()\" on the session before the program exits is recommended. For\nextra safety, call it immediately after every important session update.\n\nAlso see \"A Warning about Auto-flushing\"\n\natime()\nRead-only method. Returns the last access time of the session in seconds from epoch. This time\nis used internally while auto-expiring sessions and/or session parameters.\n\nctime()\nRead-only method. Returns the time when the session was first created in seconds from epoch.\n\nexpire()\nexpire($time)\nexpire($param, $time)\nSets expiration interval relative to atime().\n\nIf used with no arguments, returns the expiration interval if it was ever set. If no expiration\nwas ever set, returns undef. For backwards compatibility, a method named \"etime()\" does the same\nthing.\n\nSecond form sets an expiration time. This value is checked when previously stored session is\nasked to be retrieved, and if its expiration interval has passed, it will be expunged from the\ndisk immediately. Passing 0 cancels expiration.\n\nBy using the third syntax you can set the expiration interval for a particular session\nparameter, say *~logged-in*. This would cause the library call clear() on the parameter when its\ntime is up. Note it only makes sense to set this value to something *earlier* than when the\nwhole session expires. Passing 0 cancels expiration.\n\nAll the time values should be given in the form of seconds. Following keywords are also\nsupported for your convenience:\n\n+-----------+---------------+\n| alias | meaning |\n+-----------+---------------+\n| s | Second |\n| m | Minute |\n| h | Hour |\n| d | Day |\n| w | Week |\n| M | Month |\n| y | Year |\n+-----------+---------------+\n\nExamples:\n\n$session->expire(\"2h\"); # expires in two hours\n$session->expire(0); # cancel expiration\n$session->expire(\"~logged-in\", \"10m\"); # expires '~logged-in' parameter after 10 idle minutes\n\nNote: all the expiration times are relative to session's last access time, not to its creation\ntime. To expire a session immediately, call delete(). To expire a specific session parameter\nimmediately, call clear([$name]).\n\nisnew()\nReturns true only for a brand new session.\n\nisexpired()\nTests whether session initialized using load() is to be expired. This method works only on\nsessions initialized with load():\n\n$s = CGI::Session->load() or die CGI::Session->errstr;\nif ( $s->isexpired ) {\ndie \"Your session expired. Please refresh\";\n}\nif ( $s->isempty ) {\n$s = $s->new() or die $s->errstr;\n}\n\nisempty()\nReturns true for sessions that are empty. It's preferred way of testing whether requested\nsession was loaded successfully or not:\n\n$s = CGI::Session->load($sid);\nif ( $s->isempty ) {\n$s = $s->new();\n}\n\nActually, the above code is nothing but waste. The same effect could've been achieved by saying:\n\n$s = CGI::Session->new( $sid );\n", "subsections": [ { "name": "is_empty", "content": "session afterwards. See isexpired() for an example.\n\nipmatch()\nReturns true if $ENV{REMOTEADDR} matches the remote address stored in the session.\n\nIf you have an application where you are sure your users' IPs are constant during a session, you\ncan consider enabling an option to make this check:\n\nuse CGI::Session '-ipmatch';\n\nUsually you don't call ipmatch() directly, but by using the above method. It is useful only if\nyou want to call it inside of coderef passed to the find() method.\n\ndelete()\nSets the objects status to be \"deleted\". Subsequent read/write requests on the same object will\nfail. To physically delete it from the data store you need to call flush(). CGI::Session\nattempts to do this automatically when the object is being destroyed (usually as the script\nexits), but see \"A Warning about Auto-flushing\".\n\nfind( \\&code )\nfind( $dsn, \\&code )\nfind( $dsn, \\&code, \\%dsnargs )\nExperimental feature. Executes \\&code for every session object stored in disk, passing\ninitialized CGI::Session object as the first argument of \\&code. Useful for housekeeping\npurposes, such as for removing expired sessions. Following line, for instance, will remove\nsessions already expired, but are still in disk:\n\nThe following line, for instance, will remove sessions already expired, but which are still on\ndisk:\n\nCGI::Session->find( sub {} );\n\nNotice, above \\&code didn't have to do anything, because load(), which is called to initialize\nsessions inside find(), will automatically remove expired sessions. Following example will\nremove all the objects that are 10+ days old:\n\nCGI::Session->find( \\&purge );\nsub purge {\nmy ($session) = @;\nnext if $session->isempty; # <-- already expired?!\nif ( ($session->ctime + 3600*240) <= time() ) {\n$session->delete();\n$session->flush(); # Recommended practice says use flush() after delete().\n}\n}\n\nNote: find will not change the modification or access times on the sessions it returns.\n\nExplanation of the 3 parameters to \"find()\":\n\n$dsn\nThis is the DSN (Data Source Name) used by CGI::Session to control what type of sessions you\npreviously created and what type of sessions you now wish method \"find()\" to pass to your\ncallback.\n\nThe default value is defined above, in the docs for method \"new()\", and is\n'driver:file;serializer:default;id:md5'.\n\nDo not confuse this DSN with the DSN arguments mentioned just below, under \\%dsnargs.\n\n\\&code\nThis is the callback provided by you (i.e. the caller of method \"find()\") which is called by\nCGI::Session once for each session found by method \"find()\" which matches the given $dsn.\n\nThere is no default value for this coderef.\n\nWhen your callback is actually called, the only parameter is a session. If you want to call\na subroutine you already have with more parameters, you can achieve this by creating an\nanonymous subroutine that calls your subroutine with the parameters you want. For example:\n\nCGI::Session->find($dsn, sub { mysubroutine( @, 'param 1', 'param 2' ) } );\nCGI::Session->find($dsn, sub { $coderef->( @, $extraarg ) } );\n\nOr if you wish, you can define a sub generator as such:\n\nsub coderefwithargs {\nmy ( $coderef, @params ) = @;\nreturn sub { $coderef->( @, @params ) };\n}\n\nCGI::Session->find($dsn, coderefwithargs( $coderef, 'param 1', 'param 2' ) );\n\n\\%dsnargs\nIf your $dsn uses file-based storage, then this hashref might contain keys such as:\n\n{\nDirectory => Value 1,\nNoFlock => Value 2,\nUMask => Value 3\n}\n\nIf your $dsn uses db-based storage, then this hashref contains (up to) 3 keys, and looks\nlike:\n\n{\nDataSource => Value 1,\nUser => Value 2,\nPassword => Value 3\n}\n\nThese 3 form the DSN, username and password used by DBI to control access to your database\nserver, and hence are only relevant when using db-based sessions.\n\nThe default value of this hashref is undef.\n\nNote: find() is meant to be convenient, not necessarily efficient. It's best suited in cron\nscripts.\n\nname($newname)\nThe $newname parameter is optional. If supplied it sets the query or cookie parameter name to\nbe used.\n\nIt defaults to *$CGI::Session::NAME*, which defaults to *CGISESSID*.\n\nYou are strongly discouraged from using the global variable *$CGI::Session::NAME*, since it is\ndeprecated (as are all global variables) and will be removed in a future version of this module.\n\nReturn value: The current query or cookie parameter name.\n" } ] }, "MISCELLANEOUS METHODS": { "content": "remoteaddr()\nReturns the remote address of the user who created the session for the first time. Returns undef\nif variable REMOTEADDR wasn't present in the environment when the session was created.\n\nerrstr()\nClass method. Returns last error message from the library.\n\ndump()\nReturns a dump of the session object. Useful for debugging purposes only.\n\nheader()\nA wrapper for \"CGI\"'s header() method. Calling this method is equivalent to something like this:\n\n$cookie = CGI::Cookie->new(-name=>$session->name, -value=>$session->id);\nprint $cgi->header(-cookie=>$cookie, @);\n\nYou can minimize the above into:\n\nprint $session->header();\n\nIt will retrieve the name of the session cookie from \"$session-\"name()> which defaults to\n$CGI::Session::NAME. If you want to use a different name for your session cookie, do something\nlike this before creating session object:\n\nCGI::Session->name(\"MYSID\");\n$session = CGI::Session->new(undef, $cgi, \\%attrs);\n\nNow, $session->header() uses \"MYSID\" as the name for the session cookie. For all additional\noptions that can be passed, see the \"header()\" docs in \"CGI\".\n\nquery()\nReturns query object associated with current session object. Default query object class is\n\"CGI\".\n\nDEPRECATED METHODS\nThese methods exist solely for for compatibility with CGI::Session 3.x.\n\nclose()\nCloses the session. Using flush() is recommended instead, since that's exactly what a call to", "subsections": [ { "name": "close", "content": "" } ] }, "DISTRIBUTION": { "content": "CGI::Session consists of several components such as drivers, serializers and id generators. This\nsection lists what is available.\n\nDRIVERS\nThe following drivers are included in the standard distribution:\n\n* file - default driver for storing session data in plain files. Full name:\nCGI::Session::Driver::file\n\n* dbfile - for storing session data in BerkelyDB. Requires: DBFile. Full name:\nCGI::Session::Driver::dbfile\n\n* mysql - for storing session data in MySQL tables. Requires DBI and DBD::mysql. Full name:\nCGI::Session::Driver::mysql\n\n* sqlite - for storing session data in SQLite. Requires DBI and DBD::SQLite. Full name:\nCGI::Session::Driver::sqlite\n\nOther drivers are available from CPAN.\n\nSERIALIZERS\n* default - default data serializer. Uses standard Data::Dumper. Full name:\nCGI::Session::Serialize::default.\n\n* storable - serializes data using Storable. Requires Storable. Full name:\nCGI::Session::Serialize::storable.\n\n* freezethaw - serializes data using FreezeThaw. Requires FreezeThaw. Full name:\nCGI::Session::Serialize::freezethaw\n\n* yaml - serializes data using YAML. Requires YAML or YAML::Syck. Full name:\nCGI::Session::Serialize::yaml\n\nID GENERATORS\nThe following ID generators are included in the standard distribution.\n\n* md5 - generates 32 character long hexadecimal string. Requires Digest::MD5. Full name:\nCGI::Session::ID::md5.\n\n* incr - generates incremental session ids.\n\n* static - generates static session ids. CGI::Session::ID::static\n\nA Warning about Auto-flushing\nAuto-flushing can be unreliable for the following reasons. Explicit flushing after key session\nupdates is recommended.\n\nIf the \"DBI\" handle goes out of scope before the session variable\nFor database-stored sessions, if the \"DBI\" handle has gone out of scope before the\nauto-flushing happens, auto-flushing will fail.\n\nCircular references\nIf the calling code contains a circular reference, it's possible that your \"CGI::Session\"\nobject will not be destroyed until it is too late for auto-flushing to work. You can find\ncircular references with a tool like Devel::Cycle.\n\nIn particular, these modules are known to contain circular references which lead to this\nproblem:\n\nCGI::Application::Plugin::DebugScreen V 0.06\nCGI::Application::Plugin::ErrorPage before version 1.20\n\nSignal handlers\nIf your application may receive signals, there is an increased chance that the signal will\narrive after the session was updated but before it is auto-flushed at object destruction\ntime.\n\nA Warning about UTF8\nYou are strongly encouraged to refer to, at least, the first of these articles, for help with\nUTF8.\n\n\n\n\n\n\n\n\n\n\n\nBriefly, these are the issues:\n\nThe file containing the source code of your program\nConsider \"use utf8;\" or \"use encoding 'utf8';\".\n\nInfluencing the encoding of the program's input\nUse:\n\nbinmode STDIN, \":encoding(utf8)\";.\n\nOf course, the program can get input from other sources, e.g. HTML template files, not just STDIN.\n\nInfluencing the encoding of the program's output\nUse:\n\nbinmode STDOUT, \":encoding(utf8)\";\n\nWhen using CGI.pm, you can use $q->charset('UTF-8'). This is the same as passing 'UTF-8' to CGI's C method.\n\nAlternately, when using CGI::Session, you can use $session->header(charset => 'utf-8'), which will be\npassed to the query object's C method. Clearly this is preferable when the query object might not be\nof type CGI.\n\nSee L for a fuller discussion of the use of the C method in conjunction with cookies.\n", "subsections": [] }, "TRANSLATIONS": { "content": "This document is also available in Japanese.\n\no Translation based on 4.14: http://digit.que.ne.jp/work/index.cgi?Perldoc/ja\n\no Translation based on 3.11, including Cookbook and Tutorial:\nhttp://perldoc.jp/docs/modules/CGI-Session-3.11/\n", "subsections": [] }, "CREDITS": { "content": "CGI::Session evolved to what it is today with the help of following developers. The list doesn't\nfollow any strict order, but somewhat chronological. Specifics can be found in Changes file\n\nAndy Lester\nBrian King \nOlivier Dragon \nAdam Jacob \nIgor Plisco \nMark Stosberg\nMatt LeBlanc \nShawn Sorichetti\nRon Savage\nRhesa Rozendaal\nHe suggested Devel::Cycle to help debugging.\n\nAlso, many people on the CGI::Application and CGI::Session mailing lists have contributed ideas\nand suggestions, and battled publicly with bugs, all of which has helped.\n", "subsections": [] }, "COPYRIGHT": { "content": "Copyright (C) 2001-2005 Sherzod Ruzmetov . All rights reserved. This library\nis free software. You can modify and or distribute it under the same terms as Perl itself.\n", "subsections": [] }, "PUBLIC CODE REPOSITORY": { "content": "You can see what the developers have been up to since the last release by checking out the code\nrepository. You can browse the git repository from here:\n\nhttp://github.com/cromedome/cgi-session/tree/master\n\nOr check out the code with:\n\ngit clone git://github.com/cromedome/cgi-session.git\n", "subsections": [] }, "SUPPORT": { "content": "If you need help using CGI::Session, ask on the mailing list. You can ask the list by sending\nyour questions to cgi-session-user@lists.sourceforge.net .\n\nYou can subscribe to the mailing list at\nhttps://lists.sourceforge.net/lists/listinfo/cgi-session-user .\n\nBug reports can be submitted at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=CGI-Session\n", "subsections": [] }, "AUTHOR": { "content": "Sherzod Ruzmetov \"sherzodr@cpan.org\"\n\nMark Stosberg became a co-maintainer during the development of 4.0. \"markstos@cpan.org\".\n\nRon Savage became a co-maintainer during the development of 4.30. \"rsavage@cpan.org\".\n\nIf you would like support, ask on the mailing list as describe above. The maintainers and other\nusers are subscribed to it.\n", "subsections": [] }, "SEE ALSO": { "content": "To learn more both about the philosophy and CGI::Session programming style, consider the\nfollowing:\n\n* CGI::Session::Tutorial - extended CGI::Session manual. Also includes library architecture\nand driver specifications.\n\n* We also provide mailing lists for CGI::Session users. To subscribe to the list or browse the\narchives visit https://lists.sourceforge.net/lists/listinfo/cgi-session-user\n\n* RFC 2109 - The primary spec for cookie handing in use, defining the \"Cookie:\" and\n\"Set-Cookie:\" HTTP headers. Available at . A newer\nspec, RFC 2965 is meant to obsolete it with \"Set-Cookie2\" and \"Cookie2\" headers, but even of\n2008, the newer spec is not widely supported. See \n\n* Apache::Session - an alternative to CGI::Session.\n", "subsections": [] } }, "summary": "CGI::Session - persistent session data in CGI applications", "flags": [], "examples": [], "see_also": [] }