| Session Plugin Function Description |
|---|
|
struct soap_session* soap_start_session(struct soap *
soap, const char *domain, const char *path);\n
Create a session in the database and a session ID cookie. Behaves the
same as `soap_get_session` if the client already has a valid session ID
cookie. Returns pointer to the session node, or `NULL` if the session
could not be created.
|
|
struct soap_session* soap_get_session(struct soap *soap,
const char *domain, const char *path);\n
Get the current session. Can be used as a 'touch'. Returns pointer to the
session node, or `NULL` if the session is not found or is expired.
|
|
int soap_get_num_sessions(struct soap *soap, const
char *domain, const char *path);\n
Get the number of sessions in the database. Returns `-1` if the session
is not found or is expired.
|
|
struct soap_session* soap_regenerate_session_id(struct soap *
soap, const char *domain, const char *path);\n
Create a new session ID for the current session and update the session ID
cookie. Returns pointer to the session node, or `NULL` if the session
is not found or is expired.
|
|
int soap_get_num_session_vars(struct soap *soap, const
char *domain, const char *path);\n
Get the number of session variables in the current session. Returns `-1` if
the session is not found or is expired.
|
|
void soap_end_session(struct soap *soap, const char *
domain, const char *path);\n
Delete the current session from the database and clear the client's
session ID cookie.
|
|
void soap_end_sessions(struct soap *soap, const char *
domain, const char *path);\n
Delete all sessions in the database and clear the current session ID
cookie.
|
|
struct soap_session_var* soap_set_session_var(struct soap *
soap, const char *name, const char *value, const char
*domain, const char *path);\n
Set a session variable with the given `name` and `value` in the current
session, overwring any old `value`. Returns pointer to the session variable
node, or `NULL` if the session is not found or is expired.
|
|
const char* soap_get_session_var(struct soap *soap,
const char *name, const char *domain, const char *path);
\n
Get the `value` of the session variable with the given `name` in the
current session. Returns `NULL` if the session is not found or is expired.
|
|
void soap_clr_session_var(struct soap *soap, const
char *name, const char *domain, const char *path);\n
Delete the session variable with the given `name` in the current
session.
|
|
void soap_clr_session_vars(struct soap *soap, const
char *domain, const char *path); \n
Delete all session variables in the current session.
|
For managing session settings (see section: @ref settings), the following API is provided:
| Session Plugin Function Description (Settings / Misc.) |
|---|
|
int soap_set_session_rolling(struct soap *
soap, int rolling, const char *domain, const char *
path);\n
Set the `rolling` setting for the current session. Zero (non-rolling) means
the session ID cookie is only set when the session is first created.
Non-zero (rolling) means the session ID cookie will be re-set on every
response. If successful, returns SOAP_OK, or SOAP_ERR otherwise.
|
|
int soap_get_session_rolling(struct soap *
soap, const char *domain, const char *path);\n
Get the `rolling` setting for the current session. Returns `-1` if the
session is not found or is expired.
|
|
int soap_set_session_cookie_maxage(struct soap *
soap, long maxage, const char *domain, const char *
path);\n
Set the `cookie_maxage` member for the current session. This will be used
to set the session ID cookie's `Max-Age` and `Expires` attributes. `-1` means
the cookie will have no `Max-Age` or `Expires` attributes. If successful,
returns SOAP_OK, or SOAP_ERR otherwise.
|
|
long soap_get_session_cookie_maxage(struct soap *
soap, const char *domain, const char *path);\n
Get the `cookie_maxage` member for the current session. Returns `0` if the
session is not found or is expired.
|
|
int soap_set_session_max_inactive_secs(struct soap *
soap, long max, const char *domain, const char *
path);\n
Set the `max_inactive_secs` member for the current session. This is
the maximum amount of stale time in seconds before a session is marked
as expired (to be purged) on the server-side. `-1` means the session will
never expire. If successful, returns SOAP_OK, or SOAP_ERR otherwise.
|
|
long soap_get_session_max_inactive_secs(struct soap *
soap, const char *domain, const char *path);\n
Get the `max_inactive_secs` member for the current session. Returns `0`
if the session is not found or is expired.
|
|
struct soap_session* soap_get_sessions_head(); \n
Get `soap_sessions`, the first node in the sessions linked list. Not
necessary unless low-level list management is needed (see section: @ref
internals).
|
@section settings Settings
In `plugins/session.h`, the following constants are defined:
| Name | Default | Description
| ------------------------------------- | --------------------- | --------------------------------------------------
| `SESSION_COOKIE_NAME` | `"GSOAP_SESSIONID"` | The name to use for session ID cookies.
| `SESSION_MAX` | `8192` | The max number of sessions allowed in the database. Any attempt to create more sessions than this will fail.
| `SESSIONS_DEFAULT_MAX_INACTIVE_SECS` | `300` | The default time in seconds for sessions' `max_inactive_secs` member. `-1` means the session will never expire server-side.
| `SESSION_PURGE_INTERVAL` | `300` | On every session database access, the time since the last database purge is checked. If it's been longer than this interval (in seconds), any expired sessions will be purged with `soap_purge_sessions()`. `0` means a purge will occcur on every database access. `-1` means a purge will never occur.
Set these values to whatever makes sense for your application.
In each session node, the following settings are declared:
| Name | Default | Description
| ----------------------- | ------------------------------------ | -----------------------
| `rolling` | `0` | Non-rolling (`0`) means the session ID cookie is only set when the session is first created. Rolling (non-`0`) means the session ID cookie will be re-set on every response after any part of the session has been touched.
| `cookie_maxage` | `-1` | This will be used to set the session ID cookie's `Max-Age` and `Expires` attributes. `-1` means the cookie will have no `Max-Age` or `Expires` attributes.
| `max_inactive_secs` | `SESSIONS_DEFAULT_MAX_INACTIVE_SECS` | This is the maximum amount of stale time in seconds before a session is marked as expired (to be purged) on the server-side. `-1` means the session will never expire server-side. This should probably be set equal to `cookie_maxage` unless that value is `-1`.
@note
These settings should not be changed directly. See the @ref api section for
functions to manage these settings.
@section internals The Internals
The session database is stored as a linked list pointed to by `soap_sessions`
(accessible by calling `soap_get_sessions_head()`). Session nodes are of type
`struct soap_session` and are declared as:
@code
struct soap_session
{
struct soap_session *next;
const char *id;
struct soap_session_var *session_vars;
struct soap_session_var *session_vars_tail;
int num_session_vars; // the total number of session_vars we have in this session
long cookie_maxage; // client time in seconds before the cookie expires (-1 for session cookie)
int rolling; // whether or not we should set the cookie's maxage on every response
time_t last_touched; // time that we last touched this session or its vars
long max_inactive_secs; // server time in seconds before inactive session expires (-1 to never expire)
// this should usually be at least as high as cookie_maxage
};
@endcode
The `session_vars` member is a pointer to the session's linked list of session
variables. Session variable nodes are of type `struct soap_session_var` and are
declared as:
@code
struct soap_session_var
{
struct soap_session_var *next;
const char *name;
const char *value;
};
@endcode
*/
#include "sessions.h"
#ifdef __cplusplus
extern "C" {
#endif
const char sessions_id[] = SESSIONS_ID;
/** Head node of session database (linked list) */
static struct soap_session *soap_sessions = NULL;
/** Tail node of session database */
static struct soap_session *soap_sessions_tail = NULL;
/** Number of sessions in database */
static int num_sessions = 0;
/** Time that we last purged expired sessions */
static time_t last_purged_sessions;
/** Session database lock */
static MUTEX_TYPE sessions_lock = MUTEX_INITIALIZER;
/******************************************************************************\
*
* Forward decls
*
\******************************************************************************/
static int sessions_init(struct soap *soap);
static void sessions_delete(struct soap *soap, struct soap_plugin *p);
/******************************************************************************\
*
* Plugin registry
*
\******************************************************************************/
/**
@brief Plugin registry function, invoked by soap_register_plugin.
*/
SOAP_FMAC1
int
SOAP_FMAC2
sessions(struct soap *soap, struct soap_plugin *p, void *arg)
{
(void)arg;
p->id = sessions_id;
/* register the destructor */
p->fdelete = sessions_delete;
if (sessions_init(soap))
return SOAP_EOM; /* return error */
return SOAP_OK;
}
/******************************************************************************/
/**
@brief Used by plugin registry function.
*/
static int
sessions_init(struct soap *soap)
{
(void)soap;
last_purged_sessions = time(NULL);
return SOAP_OK;
}
/******************************************************************************\
*
* Callbacks
*
\******************************************************************************/
/**
@brief Deletes all sessions. Called when plugin is ended by first caller.
*/
static void
sessions_delete(struct soap *soap, struct soap_plugin *p)
{
(void)p;
soap_end_sessions(soap, NULL, NULL);
}
/******************************************************************************\
*
* For Internal Plugin Use (NOT THREAD-SAFE ALONE)
*
\******************************************************************************/
/**
@brief Intended for internal plugin use. Creates a cookie that will be sent to
the client, named SESSION_COOKIE_NAME with the given value, domain,
and path.
*/
SOAP_FMAC1
void
SOAP_FMAC2
soap_session_cookie_create(struct soap *soap, const char *value, const char *domain, const char *path, long maxage)
{
/* create session ID cookie */
soap_set_cookie(soap, SESSION_COOKIE_NAME, value, domain, path);
soap_set_cookie_session(soap, SESSION_COOKIE_NAME, domain, path);
soap_set_cookie_expire(soap, SESSION_COOKIE_NAME, maxage, domain, path);
}
/******************************************************************************/
/**
@brief Intended for internal plugin use. Creates a cookie that will be sent to
the client, named SESSION_COOKIE_NAME with the given domain and path. The value
will be empty and it will be set to expire when the client recieves it. This
ensures the session ID is no longer in the client's cookie.
*/
SOAP_FMAC1
void
SOAP_FMAC2
soap_session_cookie_delete(struct soap *soap, const char *domain, const char *path)
{
/* delete client-side cookie */
soap_set_cookie(soap, SESSION_COOKIE_NAME, "", domain, path);
soap_set_cookie_session(soap, SESSION_COOKIE_NAME, domain, path);
soap_set_cookie_expire(soap, SESSION_COOKIE_NAME, 0, domain, path);
}
/******************************************************************************/
/**
@brief Intended for internal plugin use. Find the current session with
domain and path. Returns NULL if not found or if the session is expired (for
normal use, set `when` to `time(NULL)`). Will also clear the cookie if the
session is expired.
*/
SOAP_FMAC1
struct soap_session*
SOAP_FMAC2
soap_session_internal_find(struct soap *soap, const char *domain, const char *path, time_t when)
{
struct soap_session *s = NULL;
const char *id;
id = soap_cookie_value(soap, SESSION_COOKIE_NAME, domain, path);
if (id)
{
for (s = soap_sessions; s; s = s->next)
if (s && !strcmp(s->id, id))
break;
if (!s)
return NULL;
if (s->max_inactive_secs >= 0 && (s->last_touched + s->max_inactive_secs <= when))
{
/* session has expired and has not been purged, or NULL */
soap_session_cookie_delete(soap, domain, path);
return NULL;
}
}
return s;
}
/******************************************************************************\
*
* Sessions Public API
*
\******************************************************************************/
/**
@brief Gets soap_sessions (first node in sessions linked list).
*/
SOAP_FMAC1
struct soap_session*
SOAP_FMAC2
soap_get_sessions_head()
{
return soap_sessions;
}
/******************************************************************************/
/**
@brief Removes all sessions that have been stale longer than their
max_inactive_secs allows. -1 max_inactive_secs means the session will
never expire. The when parameter is usually the current time, i.e. time(NULL)
to purge sessions that expire after the when time.
This is called internally every time a session or a session_var is accessed, so
it shouldn't ever be necessary to manually call this function.
Only will purge when the last time we purged was more than SESSION_PURGE_INTERVAL
seconds ago (defined in sessions.h).
SESSION_PURGE_INTERVAL == -1 means never purge.
SESSION_PURGE_INTERVAL == 0 means always purge.
*/
SOAP_FMAC1
void
SOAP_FMAC2
soap_purge_sessions(struct soap *soap, const char *domain, const char *path, time_t when)
{
struct soap_session *s, *t;
struct soap_session_var *v;
const char *id;
if (SESSION_PURGE_INTERVAL == -1)
return;
MUTEX_LOCK(sessions_lock);
/* If we purge the current session, we'll want to clear
the cookie, too. So grab the current ID to check against. */
id = soap_cookie_value(soap, SESSION_COOKIE_NAME, domain, path);
/* not time to purge yet */
if (SESSION_PURGE_INTERVAL && (last_purged_sessions + SESSION_PURGE_INTERVAL >= when))
{
MUTEX_UNLOCK(sessions_lock);
return;
}
last_purged_sessions = when;
s = soap_sessions;
while (s)
{
t = s->next;
/* delete session if its older than allowed */
if (s->max_inactive_secs >= 0 && (s->last_touched + s->max_inactive_secs <= when))
{
/* clear the cookie if this was the current session */
if (id && !strcmp(id, s->id))
soap_session_cookie_delete(soap, domain, path);
/* delete session vars */
for (v = s->session_vars; v;)
{
struct soap_session_var *u;
if (v->name)
SOAP_FREE(soap, v->name);
if (v->value)
SOAP_FREE(soap, v->value);
u = v->next;
SOAP_FREE(soap, v);
v = u;
}
/* delete session data */
if (s->id)
SOAP_FREE(soap, s->id);
/* deleting not last node? */
if (t)
{
/* adjust tail if this was second to last */
if (t == soap_sessions_tail)
soap_sessions_tail = s;
s->id = t->id;
s->session_vars = t->session_vars;
s->session_vars_tail = t->session_vars_tail;
s->num_session_vars = t->num_session_vars;
s->cookie_maxage = t->cookie_maxage;
s->rolling = t->rolling;
s->last_touched = t->last_touched;
s->max_inactive_secs = t->max_inactive_secs;
s->next = t->next;
SOAP_FREE(soap, t);
}
else /* deleting the last node */
{
/* set tail to previous node */
struct soap_session *u = soap_sessions;
while (u && u->next != s)
u = u->next;
soap_sessions_tail = u;
if (soap_sessions_tail == NULL)
soap_sessions = NULL;
else
soap_sessions_tail->next = NULL;
SOAP_FREE(soap, s);
/* to end the loop */
s = NULL;
}
num_sessions--;
}
else
{
/* only move s to the next node if we didn't do a deletion
(because we moved the next node onto s if we did do a deletion) */
s = t;
}
}
MUTEX_UNLOCK(sessions_lock);
}
/******************************************************************************/
/**
@brief Gets the number of sessions in the database.
*/
SOAP_FMAC1
int
SOAP_FMAC2
soap_get_num_sessions(struct soap *soap, const char *domain, const char *path)
{
/* purge first, so num_sessions will not include expired ones */
soap_purge_sessions(soap, domain, path, time(NULL));
return num_sessions;
}
/******************************************************************************/
/**
@brief Finds the session identified by the cookie with name SESSION_COOKIE_NAME
and the given domain and path. Updates session's last_touched to now. Returns
NULL if not found.
*/
SOAP_FMAC1
struct soap_session*
SOAP_FMAC2
soap_get_session(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return NULL;
}
s->last_touched = now;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return s;
}
/******************************************************************************/
/**
@brief Creates a new session with a random 128-bit ID. A cookie will be created
with name SESSION_COOKIE_NAME and the given domain and path. If there
already exists a session ID cookie, the only action will be updating the
session's last_touched to now. Returns a pointer to the session.
*/
SOAP_FMAC1
struct soap_session*
SOAP_FMAC2
soap_start_session(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s = NULL;
time_t now = time(NULL);
const char *id;
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
id = soap_cookie_value(soap, SESSION_COOKIE_NAME, domain, path);
if (id)
{
for (s = soap_sessions; s; s = s->next)
if (!strcmp(s->id, id))
break;
}
if (!s)
{
/* check if we have too many sessions */
if (num_sessions >= SESSION_MAX)
{
MUTEX_UNLOCK(sessions_lock);
return NULL;
}
/* create new session */
s = (struct soap_session*)SOAP_MALLOC(soap, sizeof(struct soap_session));
if (s)
{
/* generate random 128-bit session ID */
s->id = (const char*)soap_strdup(NULL, soap_rand_uuid(soap, NULL));
s->session_vars = NULL;
s->session_vars_tail = NULL;
s->num_session_vars = 0;
s->cookie_maxage = -1;
s->rolling = 0;
s->last_touched = now;
s->max_inactive_secs = SESSIONS_DEFAULT_MAX_INACTIVE_SECS;
/* add to end of list */
if (num_sessions == 0)
soap_sessions = s;
else
soap_sessions_tail->next = s;
soap_sessions_tail = s;
soap_sessions_tail->next = NULL;
num_sessions++;
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
}
}
else
{
/* session already exists */
if (s->max_inactive_secs >= 0 && (s->last_touched + s->max_inactive_secs <= now))
{
/* session has expired and has not been purged, or NULL */
soap_session_cookie_delete(soap, domain, path);
}
else
{
/* update last_touched */
s->last_touched = now;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
}
}
MUTEX_UNLOCK(sessions_lock);
return s;
}
/******************************************************************************/
/**
@brief The session ID for the current session (identified by the cookie with
name SESSION_COOKIE_NAME and the given domain and path) will be set to a new
random 128-bit ID. Also updates the cookie. Returns a pointer to the session.
*/
SOAP_FMAC1
struct soap_session*
SOAP_FMAC2
soap_regenerate_session_id(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return NULL;
}
s->last_touched = now;
if (s->id)
SOAP_FREE(soap, s->id);
/* generate random 128-bit session ID if one wasn't provided */
s->id = (const char*)soap_strdup(NULL, soap_rand_uuid(soap, NULL));
/* reset session ID cookie */
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return s;
}
/******************************************************************************/
/**
@brief Frees all sessions in database.
*/
SOAP_FMAC1
void
SOAP_FMAC2
soap_end_sessions(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
MUTEX_LOCK(sessions_lock);
last_purged_sessions = time(NULL);
s = soap_sessions;
while (s)
{
/* delete session_vars */
struct soap_session *t = s->next;
struct soap_session_var *v = s->session_vars;
while (v)
{
struct soap_session_var *u;
if (v->name)
SOAP_FREE(soap, v->name);
if (v->value)
SOAP_FREE(soap, v->value);
u = v->next;
SOAP_FREE(soap, v);
v = u;
}
/* delete session */
if (s->id)
SOAP_FREE(soap, s->id);
SOAP_FREE(soap, s);
s = t;
}
soap_sessions = NULL;
soap_sessions_tail = NULL;
num_sessions = 0;
/* clear session ID cookie */
soap_session_cookie_delete(soap, domain, path);
MUTEX_UNLOCK(sessions_lock);
}
/******************************************************************************/
/**
@brief Frees the current session (identified by the cookie with name
SESSION_COOKIE_NAME and the given domain and path). Also clears the cookie.
*/
SOAP_FMAC1
void
SOAP_FMAC2
soap_end_session(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
struct soap_session_var *v;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return;
}
/* deleting whether expired or not */
/* delete session vars */
for (v = s->session_vars; v;)
{
struct soap_session_var *u;
if (v->name)
SOAP_FREE(soap, v->name);
if (v->value)
SOAP_FREE(soap, v->value);
u = v->next;
SOAP_FREE(soap, v);
v = u;
}
/* delete session data */
if (s->id)
SOAP_FREE(soap, s->id);
struct soap_session *temp = s->next;
/* deleting not last node */
if (temp != NULL)
{
/* adjust tail if this was second to last */
if (temp == soap_sessions_tail)
soap_sessions_tail = s;
s->id = temp->id;
s->session_vars = temp->session_vars;
s->session_vars_tail = temp->session_vars_tail;
s->num_session_vars = temp->num_session_vars;
s->cookie_maxage = temp->cookie_maxage;
s->last_touched = temp->last_touched;
s->max_inactive_secs = temp->max_inactive_secs;
s->next = temp->next;
SOAP_FREE(soap, temp);
}
/* deleting the last node */
else
{
/* set tail to previous node */
struct soap_session *t = soap_sessions;
while (t && t->next != s)
t = t->next;
soap_sessions_tail = t;
if (soap_sessions_tail == NULL)
soap_sessions = NULL;
else
soap_sessions_tail->next = NULL;
SOAP_FREE(soap, s);
}
num_sessions--;
/* delete client-side cookie */
soap_session_cookie_delete(soap, domain, path);
MUTEX_UNLOCK(sessions_lock);
}
/******************************************************************************/
/**
@brief Gets the cookie_maxage for the current session (identified by the cookie
with name SESSION_COOKIE_NAME and the given domain and path). -1 means the
cookie is a session cookie. 0 means a session was not found or
is expired.
*/
SOAP_FMAC1
long
SOAP_FMAC2
soap_get_session_cookie_maxage(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
long result;
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return 0;
}
result = s->cookie_maxage;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return result;
}
/******************************************************************************/
/**
@brief Sets the cookie_maxage for the current session (identified by the
cookie with name SESSION_COOKIE_NAME and the given domain and path). -1 means
the cookie will be a session cookie. If successful, returns
SOAP_OK, or SOAP_ERR otherwise.
*/
SOAP_FMAC1
int
SOAP_FMAC2
soap_set_session_cookie_maxage(struct soap *soap, long maxage, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return SOAP_ERR;
}
s->cookie_maxage = maxage;
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return SOAP_OK;
}
/******************************************************************************/
/**
@brief Gets the max_inactive_secs for the current session (identified by
the cookie with name SESSION_COOKIE_NAME and the given domain and path). -1
means the session will never expire. 0 means the session wasn't found or
is expired.
*/
SOAP_FMAC1
long
SOAP_FMAC2
soap_get_session_max_inactive_secs(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
long result;
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return 0;
}
result = s->max_inactive_secs;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return result;
}
/******************************************************************************/
/**
@brief Sets the max_inactive_secs for the current session (identified by
the cookie with name SESSION_COOKIE_NAME and the given domain and path). -1
means the session will never expire. If successful, returns SOAP_OK, or
SOAP_ERR otherwise.
*/
SOAP_FMAC1
int
SOAP_FMAC2
soap_set_session_max_inactive_secs(struct soap *soap, long max, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return SOAP_ERR;
}
s->max_inactive_secs = max;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return SOAP_OK;
}
/******************************************************************************/
/**
@brief Gets the `rolling` flag for the current session (identified by the
cookie with name SESSION_COOKIE_NAME and the given domain and path). -1 means
the session was not found or is expired.
*/
SOAP_FMAC1
int
SOAP_FMAC2
soap_get_session_rolling(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
int result;
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return -1;
}
result = s->rolling;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return result;
}
/******************************************************************************/
/**
@brief Sets the `rolling` flag for the current session (identified by the
cookie with name SESSION_COOKIE_NAME and the given domain and path). If
successful, returns SOAP_OK, or SOAP_ERR otherwise.
*/
SOAP_FMAC1
int
SOAP_FMAC2
soap_set_session_rolling(struct soap *soap, int rolling, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return SOAP_ERR;
}
s->rolling = rolling;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return SOAP_OK;
}
/******************************************************************************\
*
* Session Variables Public API
*
\******************************************************************************/
/**
@brief Gets the number of sessions variables in the current session (identified
by the cookie with name SESSION_COOKIE_NAME and the given domain and path).
Returns -1 if the session does not exist.
*/
SOAP_FMAC1
int
SOAP_FMAC2
soap_get_num_session_vars(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
time_t now = time(NULL);
int result;
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return -1;
}
result = s->num_session_vars;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
MUTEX_UNLOCK(sessions_lock);
return result;
}
/******************************************************************************/
/**
@brief Returns session_var value by name in the current session (identified by
the cookie with name SESSION_COOKIE_NAME and the given domain and path).
Returns NULL if not found.
*/
SOAP_FMAC1
const char*
SOAP_FMAC2
soap_get_session_var(struct soap *soap, const char *name, const char *domain, const char *path)
{
struct soap_session *s;
struct soap_session_var *v;
time_t now = time(NULL);
const char *value;
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return NULL;
}
s->last_touched = now;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
for (v = s->session_vars; v; v = v->next)
if (!strcmp(v->name, name))
break;
value = v ? v->value : NULL;
MUTEX_UNLOCK(sessions_lock);
return value;
}
/******************************************************************************/
/**
@brief Add new session_var with the given name and value to the current session
(identified by the cookie with name SESSION_COOKIE_NAME and the given domain
and path). If the name is already used, the value is re-written. If successful,
returns pointer to a session_var node in the session's linked list, or NULL
otherwise.
*/
SOAP_FMAC1
struct soap_session_var*
SOAP_FMAC2
soap_set_session_var(struct soap *soap, const char *name, const char *value, const char *domain, const char *path)
{
struct soap_session *s;
struct soap_session_var *v;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return NULL;
}
s->last_touched = now;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
for (v = s->session_vars; v; v = v->next)
if (!strcmp(v->name, name))
break;
if (!v)
{
v = (struct soap_session_var*)SOAP_MALLOC(soap, sizeof(struct soap_session_var));
if (v)
{
size_t l = strlen(name);
char *x = (char*)SOAP_MALLOC(soap, l + 1);
v->name = x;
if (v->name)
soap_strcpy(x, l + 1, name);
l = strlen(value);
x = (char*)SOAP_MALLOC(soap, l + 1);
v->value = x;
if (v->value)
soap_strcpy(x, l + 1, value);
/* add to end of list */
if (s->num_session_vars == 0)
s->session_vars = v;
else
s->session_vars_tail->next = v;
s->session_vars_tail = v;
s->session_vars_tail->next = NULL;
s->num_session_vars++;
}
}
else
{
size_t l = strlen(value);
char *x;
if (v->value)
SOAP_FREE(soap, v->value);
x = (char*)SOAP_MALLOC(soap, l + 1);
v->value = x;
if (v->value)
soap_strcpy(x, l + 1, value);
}
MUTEX_UNLOCK(sessions_lock);
return v;
}
/******************************************************************************/
/**
@brief Frees all session vars in the current session (identified by the cookie
with name SESSION_COOKIE_NAME and the given domain and path).
*/
SOAP_FMAC1
void
SOAP_FMAC2
soap_clr_session_vars(struct soap *soap, const char *domain, const char *path)
{
struct soap_session *s;
struct soap_session_var *v;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return;
}
s->last_touched = now;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
v = s->session_vars;
while (v)
{
struct soap_session_var *u;
if (v->name)
SOAP_FREE(soap, v->name);
if (v->value)
SOAP_FREE(soap, v->value);
u = v->next;
SOAP_FREE(soap, v);
v = u;
}
s->session_vars = NULL;
s->num_session_vars = 0;
MUTEX_UNLOCK(sessions_lock);
}
/******************************************************************************/
/**
@brief Frees session var with the given name in the current session (identified
by the cookie with name SESSION_COOKIE_NAME and the given domain and path).
*/
SOAP_FMAC1
void
SOAP_FMAC2
soap_clr_session_var(struct soap *soap, const char *name, const char *domain, const char *path)
{
struct soap_session *s;
struct soap_session_var *v;
time_t now = time(NULL);
soap_purge_sessions(soap, domain, path, now);
MUTEX_LOCK(sessions_lock);
s = soap_session_internal_find(soap, domain, path, now);
if (!s)
{
MUTEX_UNLOCK(sessions_lock);
return;
}
s->last_touched = now;
if (s->rolling)
soap_session_cookie_create(soap, s->id, domain, path, s->cookie_maxage);
for (v = s->session_vars; v; v = v->next)
if (!strcmp(v->name, name))
break;
if (!v)
{
MUTEX_UNLOCK(sessions_lock);
return;
}
/* delete session var data */
if (v->name)
SOAP_FREE(soap, v->name);
if (v->value)
SOAP_FREE(soap, v->value);
struct soap_session_var *temp = v->next;
/* deleting not last node */
if (temp != NULL)
{
/* adjust tail if this was second to last */
if (temp == s->session_vars_tail)
s->session_vars_tail = v;
v->name = temp->name;
v->value = temp->value;
v->next = temp->next;
SOAP_FREE(soap, temp);
}
/* deleting the last node */
else
{
/* set tail to previous node */
struct soap_session_var *t = s->session_vars;
while (t && t->next != v)
t = t->next;
s->session_vars_tail = t;
if (s->session_vars_tail == NULL)
s->session_vars = NULL;
else
s->session_vars_tail->next = NULL;
SOAP_FREE(soap, v);
}
s->num_session_vars--;
MUTEX_UNLOCK(sessions_lock);
}
/******************************************************************************/
#ifdef __cplusplus
}
#endif