Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

258 lines (205 sloc) 6.329 kB
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* Cherokee
*
* Authors:
* Alvaro Lopez Ortega <alvaro@alobbs.com>
*
* Copyright (C) 2001-2014 Alvaro Lopez Ortega
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
#include "common-internal.h"
#include "validator_authlist.h"
#include "connection.h"
#include "connection-protected.h"
#include "plugin_loader.h"
#include "util.h"
#define ENTRIES "validator,authlist"
/* Plug-in initialization
*/
PLUGIN_INFO_VALIDATOR_EASIEST_INIT (authlist, http_auth_basic | http_auth_digest);
typedef struct {
cherokee_list_t listed;
cherokee_buffer_t user;
cherokee_buffer_t password;
} entry_t;
#define ENTRY(e) ((entry_t *)(e))
static ret_t
entry_new (entry_t **ret)
{
entry_t *entry;
entry = (entry_t *) malloc(sizeof(entry_t));
if (entry == NULL)
return ret_nomem;
INIT_LIST_HEAD (&entry->listed);
cherokee_buffer_init (&entry->user);
cherokee_buffer_init (&entry->password);
*ret = entry;
return ret_ok;
}
static ret_t
entry_free (entry_t *entry)
{
cherokee_buffer_mrproper (&entry->user);
cherokee_buffer_mrproper (&entry->password);
free (entry);
return ret_ok;
}
static ret_t
props_free (cherokee_validator_authlist_props_t *props)
{
cherokee_list_t *i, *j;
list_for_each_safe (i, j, &props->users) {
entry_free (ENTRY(i));
}
return cherokee_validator_props_free_base (VALIDATOR_PROPS(props));
}
static ret_t
add_new_user (cherokee_validator_authlist_props_t *props,
cherokee_config_node_t *conf)
{
ret_t ret;
cherokee_buffer_t *tmp;
entry_t *entry = NULL;
ret = entry_new (&entry);
if (ret != ret_ok)
return ret;
ret = cherokee_config_node_read (conf, "user", &tmp);
if (ret != ret_ok) {
LOG_ERROR (CHEROKEE_ERROR_VALIDATOR_AUTHLIST_USER, conf->val.buf);
entry_free (entry);
return ret_error;
}
cherokee_buffer_add_buffer (&entry->user, tmp);
TRACE (ENTRIES, "Adding user='%s'\n", entry->user.buf);
ret = cherokee_config_node_read (conf, "password", &tmp);
if (ret != ret_ok) {
LOG_ERROR (CHEROKEE_ERROR_VALIDATOR_AUTHLIST_PASSWORD, conf->val.buf);
entry_free (entry);
return ret_error;
}
cherokee_buffer_add_buffer (&entry->password, tmp);
cherokee_list_add (&entry->listed, &props->users);
return ret_ok;
}
ret_t
cherokee_validator_authlist_configure (cherokee_config_node_t *conf,
cherokee_server_t *srv,
cherokee_module_props_t **_props)
{
ret_t ret;
cherokee_list_t *i;
cherokee_validator_authlist_props_t *props;
cherokee_config_node_t *subconf;
UNUSED(srv);
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, validator_authlist_props);
cherokee_validator_props_init_base (VALIDATOR_PROPS(n), MODULE_PROPS_FREE(props_free));
INIT_LIST_HEAD (&n->users);
*_props = MODULE_PROPS(n);
}
props = PROP_AUTHLIST(*_props);
/* Read the configuration tree
*/
ret = cherokee_config_node_get (conf, "list", &subconf);
if (ret != ret_ok) {
LOG_WARNING_S (CHEROKEE_ERROR_VALIDATOR_AUTHLIST_EMPTY);
goto out;
}
cherokee_config_node_foreach (i, subconf) {
ret = add_new_user (props, CONFIG_NODE(i));
if (ret != ret_ok)
return ret;
}
out:
return ret_ok;
}
static ret_t
authlist_free (cherokee_validator_authlist_t *authlist)
{
cherokee_validator_free_base (VALIDATOR(authlist));
return ret_ok;
}
static ret_t
authlist_check (cherokee_validator_authlist_t *authlist,
cherokee_connection_t *conn)
{
int re;
ret_t ret;
entry_t *entry;
cherokee_list_t *i;
cherokee_validator_authlist_props_t *props = VAL_AUTHLIST_PROP(authlist);
list_for_each (i, &props->users) {
entry = ENTRY(i);
/* Check the user name
*/
re = cherokee_buffer_cmp_buf (&entry->user, &conn->validator->user);
if (re != 0)
continue;
/* Check his password
*/
switch (conn->req_auth_type) {
case http_auth_basic:
/* The password field is empty
*/
if ((cherokee_buffer_is_empty (&entry->password)) &&
(cherokee_buffer_is_empty (&conn->validator->passwd)))
return ret_ok;
/* Check the real password
*/
re = cherokee_buffer_cmp_buf (&entry->password,
&conn->validator->passwd);
if (re == 0)
return ret_ok;
break;
case http_auth_digest:
ret = cherokee_validator_digest_check (VALIDATOR(authlist),
&entry->password, conn);
if (ret == ret_ok)
return ret;
break;
default:
SHOULDNT_HAPPEN;
}
}
return ret_deny;
}
static ret_t
authlist_add_headers (cherokee_validator_authlist_t *authlist,
cherokee_connection_t *conn,
cherokee_buffer_t *buf)
{
UNUSED(authlist);
UNUSED(conn);
UNUSED(buf);
return ret_ok;
}
ret_t
cherokee_validator_authlist_new (cherokee_validator_authlist_t **authlist,
cherokee_module_props_t *props)
{
CHEROKEE_NEW_STRUCT(n,validator_authlist);
/* Init
*/
cherokee_validator_init_base (VALIDATOR(n), VALIDATOR_PROPS(props), PLUGIN_INFO_VALIDATOR_PTR(authlist));
VALIDATOR(n)->support = http_auth_basic | http_auth_digest;
MODULE(n)->free = (module_func_free_t) authlist_free;
VALIDATOR(n)->check = (validator_func_check_t) authlist_check;
VALIDATOR(n)->add_headers = (validator_func_add_headers_t) authlist_add_headers;
/* Return obj
*/
*authlist = n;
return ret_ok;
}
Jump to Line
Something went wrong with that request. Please try again.