mirror of
https://github.com/samba-team/samba.git
synced 2024-12-22 13:34:15 +03:00
668d3459ac
Signed-off-by: Volker Lendecke <vl@samba.org> Reviewed-by: Jeremy Allison <jra@samba.org>
651 lines
16 KiB
C
651 lines
16 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
|
|
idmap script backend, used for Samba setups where you need to map SIDs to
|
|
specific UIDs/GIDs.
|
|
|
|
Copyright (C) Richard Sharpe 2014.
|
|
|
|
This is heavily based upon idmap_tdb2.c, which is:
|
|
|
|
Copyright (C) Tim Potter 2000
|
|
Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
|
|
Copyright (C) Jeremy Allison 2006
|
|
Copyright (C) Simo Sorce 2003-2006
|
|
Copyright (C) Michael Adam 2009-2010
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
#include "system/filesys.h"
|
|
#include "winbindd.h"
|
|
#include "idmap.h"
|
|
#include "idmap_rw.h"
|
|
#include "../libcli/security/dom_sid.h"
|
|
#include "lib/util_file.h"
|
|
#include "lib/util/tevent_unix.h"
|
|
|
|
#undef DBGC_CLASS
|
|
#define DBGC_CLASS DBGC_IDMAP
|
|
|
|
struct idmap_script_context {
|
|
const char *script; /* script to provide idmaps */
|
|
};
|
|
|
|
/*
|
|
run a script to perform a mapping
|
|
|
|
The script should accept the following command lines:
|
|
|
|
SIDTOID S-1-xxxx -> XID:<id> | ERR:<str>
|
|
SIDTOID S-1-xxxx -> UID:<id> | ERR:<str>
|
|
SIDTOID S-1-xxxx -> GID:<id> | ERR:<str>
|
|
IDTOSID XID xxxx -> SID:<sid> | ERR:<str>
|
|
IDTOSID UID xxxx -> SID:<sid> | ERR:<str>
|
|
IDTOSID GID xxxx -> SID:<sid> | ERR:<str>
|
|
|
|
where XID means both a UID and a GID. This is the case for ID_TYPE_BOTH.
|
|
|
|
TODO: Needs more validation ... like that we got a UID when we asked for one.
|
|
*/
|
|
|
|
struct idmap_script_xid2sid_state {
|
|
char **argl;
|
|
size_t idx;
|
|
uint8_t *out;
|
|
};
|
|
|
|
static void idmap_script_xid2sid_done(struct tevent_req *subreq);
|
|
|
|
static struct tevent_req *idmap_script_xid2sid_send(
|
|
TALLOC_CTX *mem_ctx, struct tevent_context *ev,
|
|
struct unixid xid, const char *script, size_t idx)
|
|
{
|
|
struct tevent_req *req, *subreq;
|
|
struct idmap_script_xid2sid_state *state;
|
|
char key;
|
|
|
|
req = tevent_req_create(mem_ctx, &state,
|
|
struct idmap_script_xid2sid_state);
|
|
if (req == NULL) {
|
|
return NULL;
|
|
}
|
|
state->idx = idx;
|
|
|
|
switch (xid.type) {
|
|
case ID_TYPE_UID:
|
|
key = 'U';
|
|
break;
|
|
case ID_TYPE_GID:
|
|
key = 'G';
|
|
break;
|
|
case ID_TYPE_BOTH:
|
|
key = 'X';
|
|
break;
|
|
default:
|
|
DBG_WARNING("INVALID unix ID type: 0x02%x\n", xid.type);
|
|
tevent_req_error(req, EINVAL);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
state->argl = str_list_make_empty(state);
|
|
str_list_add_printf(&state->argl, "%s", script);
|
|
str_list_add_printf(&state->argl, "IDTOSID");
|
|
str_list_add_printf(&state->argl, "%cID", key);
|
|
str_list_add_printf(&state->argl, "%lu", (unsigned long)xid.id);
|
|
if (tevent_req_nomem(state->argl, req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
subreq = file_ploadv_send(state, ev, state->argl, 1024);
|
|
if (tevent_req_nomem(subreq, req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
tevent_req_set_callback(subreq, idmap_script_xid2sid_done, req);
|
|
return req;
|
|
}
|
|
|
|
static void idmap_script_xid2sid_done(struct tevent_req *subreq)
|
|
{
|
|
struct tevent_req *req = tevent_req_callback_data(
|
|
subreq, struct tevent_req);
|
|
struct idmap_script_xid2sid_state *state = tevent_req_data(
|
|
req, struct idmap_script_xid2sid_state);
|
|
int ret;
|
|
|
|
ret = file_ploadv_recv(subreq, state, &state->out);
|
|
TALLOC_FREE(subreq);
|
|
if (tevent_req_error(req, ret)) {
|
|
return;
|
|
}
|
|
tevent_req_done(req);
|
|
}
|
|
|
|
static int idmap_script_xid2sid_recv(struct tevent_req *req, size_t *idx,
|
|
enum id_mapping *status,
|
|
struct dom_sid *sid)
|
|
{
|
|
struct idmap_script_xid2sid_state *state = tevent_req_data(
|
|
req, struct idmap_script_xid2sid_state);
|
|
char *out = (char *)state->out;
|
|
size_t out_size = talloc_get_size(out);
|
|
int err;
|
|
|
|
if (tevent_req_is_unix_error(req, &err)) {
|
|
return err;
|
|
}
|
|
|
|
if (out_size == 0) {
|
|
goto unmapped;
|
|
}
|
|
if (state->out[out_size-1] != '\0') {
|
|
goto unmapped;
|
|
}
|
|
|
|
*idx = state->idx;
|
|
|
|
if ((strncmp(out, "SID:S-", 6) != 0) ||
|
|
!dom_sid_parse(out+4, sid)) {
|
|
DBG_WARNING("Bad sid from script: %s\n", out);
|
|
goto unmapped;
|
|
}
|
|
|
|
*status = ID_MAPPED;
|
|
return 0;
|
|
|
|
unmapped:
|
|
*sid = (struct dom_sid) {0};
|
|
*status = ID_UNMAPPED;
|
|
return 0;
|
|
}
|
|
|
|
struct idmap_script_xids2sids_state {
|
|
struct id_map **ids;
|
|
size_t num_ids;
|
|
size_t num_done;
|
|
};
|
|
|
|
static void idmap_script_xids2sids_done(struct tevent_req *subreq);
|
|
|
|
static struct tevent_req *idmap_script_xids2sids_send(
|
|
TALLOC_CTX *mem_ctx, struct tevent_context *ev,
|
|
struct id_map **ids, size_t num_ids, const char *script)
|
|
{
|
|
struct tevent_req *req;
|
|
struct idmap_script_xids2sids_state *state;
|
|
size_t i;
|
|
|
|
req = tevent_req_create(mem_ctx, &state,
|
|
struct idmap_script_xids2sids_state);
|
|
if (req == NULL) {
|
|
return NULL;
|
|
}
|
|
state->ids = ids;
|
|
state->num_ids = num_ids;
|
|
|
|
if (state->num_ids == 0) {
|
|
tevent_req_done(req);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
for (i=0; i<num_ids; i++) {
|
|
struct tevent_req *subreq;
|
|
|
|
subreq = idmap_script_xid2sid_send(
|
|
state, ev, ids[i]->xid, script, i);
|
|
if (tevent_req_nomem(subreq, req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
tevent_req_set_callback(subreq, idmap_script_xids2sids_done,
|
|
req);
|
|
}
|
|
|
|
return req;
|
|
}
|
|
|
|
static void idmap_script_xids2sids_done(struct tevent_req *subreq)
|
|
{
|
|
struct tevent_req *req = tevent_req_callback_data(
|
|
subreq, struct tevent_req);
|
|
struct idmap_script_xids2sids_state *state = tevent_req_data(
|
|
req, struct idmap_script_xids2sids_state);
|
|
size_t idx = 0;
|
|
enum id_mapping status = ID_UNKNOWN;
|
|
struct dom_sid sid = {0};
|
|
int ret;
|
|
|
|
ret = idmap_script_xid2sid_recv(subreq, &idx, &status, &sid);
|
|
TALLOC_FREE(subreq);
|
|
if (tevent_req_error(req, ret)) {
|
|
return;
|
|
}
|
|
|
|
if (idx >= state->num_ids) {
|
|
tevent_req_error(req, EINVAL);
|
|
return;
|
|
}
|
|
|
|
state->ids[idx]->status = status;
|
|
|
|
state->ids[idx]->sid = dom_sid_dup(state->ids, &sid);
|
|
if (tevent_req_nomem(state->ids[idx]->sid, req)) {
|
|
return;
|
|
}
|
|
|
|
state->num_done += 1;
|
|
|
|
if (state->num_done >= state->num_ids) {
|
|
tevent_req_done(req);
|
|
}
|
|
}
|
|
|
|
static int idmap_script_xids2sids_recv(struct tevent_req *req)
|
|
{
|
|
return tevent_req_simple_recv_unix(req);
|
|
}
|
|
|
|
static int idmap_script_xids2sids(struct id_map **ids, size_t num_ids,
|
|
const char *script)
|
|
{
|
|
TALLOC_CTX *frame = talloc_stackframe();
|
|
struct tevent_context *ev;
|
|
struct tevent_req *req;
|
|
int ret = ENOMEM;
|
|
|
|
ev = samba_tevent_context_init(frame);
|
|
if (ev == NULL) {
|
|
goto fail;
|
|
}
|
|
req = idmap_script_xids2sids_send(frame, ev, ids, num_ids, script);
|
|
if (req == NULL) {
|
|
goto fail;
|
|
}
|
|
if (!tevent_req_poll(req, ev)) {
|
|
ret = errno;
|
|
goto fail;
|
|
}
|
|
ret = idmap_script_xids2sids_recv(req);
|
|
fail:
|
|
TALLOC_FREE(frame);
|
|
return ret;
|
|
}
|
|
|
|
static NTSTATUS idmap_script_unixids_to_sids(struct idmap_domain *dom,
|
|
struct id_map **ids)
|
|
{
|
|
struct idmap_script_context *ctx = talloc_get_type_abort(
|
|
dom->private_data, struct idmap_script_context);
|
|
int ret;
|
|
size_t i, num_ids, num_mapped;
|
|
|
|
DEBUG(10, ("%s called ...\n", __func__));
|
|
/* Init status to avoid surprise ... */
|
|
for (i = 0; ids[i]; i++) {
|
|
ids[i]->status = ID_UNKNOWN;
|
|
}
|
|
num_ids = i;
|
|
|
|
ret = idmap_script_xids2sids(ids, num_ids, ctx->script);
|
|
if (ret != 0) {
|
|
DBG_DEBUG("idmap_script_xids2sids returned %s\n",
|
|
strerror(ret));
|
|
return map_nt_error_from_unix(ret);
|
|
}
|
|
|
|
num_mapped = 0;
|
|
|
|
for (i = 0; ids[i]; i++) {
|
|
if (ids[i]->status == ID_MAPPED) {
|
|
num_mapped += 1;
|
|
}
|
|
}
|
|
|
|
if (num_mapped == 0) {
|
|
return NT_STATUS_NONE_MAPPED;
|
|
}
|
|
if (num_mapped < num_ids) {
|
|
return STATUS_SOME_UNMAPPED;
|
|
}
|
|
return NT_STATUS_OK;
|
|
}
|
|
|
|
struct idmap_script_sid2xid_state {
|
|
char **argl;
|
|
size_t idx;
|
|
uint8_t *out;
|
|
};
|
|
|
|
static void idmap_script_sid2xid_done(struct tevent_req *subreq);
|
|
|
|
static struct tevent_req *idmap_script_sid2xid_send(
|
|
TALLOC_CTX *mem_ctx, struct tevent_context *ev,
|
|
const struct dom_sid *sid, const char *script, size_t idx)
|
|
{
|
|
struct tevent_req *req, *subreq;
|
|
struct idmap_script_sid2xid_state *state;
|
|
struct dom_sid_buf sidbuf;
|
|
|
|
req = tevent_req_create(mem_ctx, &state,
|
|
struct idmap_script_sid2xid_state);
|
|
if (req == NULL) {
|
|
return NULL;
|
|
}
|
|
state->idx = idx;
|
|
|
|
state->argl = str_list_make_empty(state);
|
|
str_list_add_printf(&state->argl, "%s", script);
|
|
str_list_add_printf(&state->argl, "SIDTOID");
|
|
str_list_add_printf(
|
|
&state->argl, "%s", dom_sid_str_buf(sid, &sidbuf));
|
|
if (tevent_req_nomem(state->argl, req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
subreq = file_ploadv_send(state, ev, state->argl, 1024);
|
|
if (tevent_req_nomem(subreq, req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
tevent_req_set_callback(subreq, idmap_script_sid2xid_done, req);
|
|
return req;
|
|
}
|
|
|
|
static void idmap_script_sid2xid_done(struct tevent_req *subreq)
|
|
{
|
|
struct tevent_req *req = tevent_req_callback_data(
|
|
subreq, struct tevent_req);
|
|
struct idmap_script_sid2xid_state *state = tevent_req_data(
|
|
req, struct idmap_script_sid2xid_state);
|
|
int ret;
|
|
|
|
ret = file_ploadv_recv(subreq, state, &state->out);
|
|
TALLOC_FREE(subreq);
|
|
if (tevent_req_error(req, ret)) {
|
|
return;
|
|
}
|
|
tevent_req_done(req);
|
|
}
|
|
|
|
static int idmap_script_sid2xid_recv(struct tevent_req *req,
|
|
size_t *idx, enum id_mapping *status,
|
|
struct unixid *xid)
|
|
{
|
|
struct idmap_script_sid2xid_state *state = tevent_req_data(
|
|
req, struct idmap_script_sid2xid_state);
|
|
char *out = (char *)state->out;
|
|
size_t out_size = talloc_get_size(out);
|
|
unsigned long v;
|
|
int err;
|
|
|
|
if (tevent_req_is_unix_error(req, &err)) {
|
|
return err;
|
|
}
|
|
|
|
if (out_size == 0) {
|
|
goto unmapped;
|
|
}
|
|
if (state->out[out_size-1] != '\0') {
|
|
goto unmapped;
|
|
}
|
|
|
|
*idx = state->idx;
|
|
|
|
if (sscanf(out, "XID:%lu\n", &v) == 1) {
|
|
*xid = (struct unixid) { .id = v, .type = ID_TYPE_BOTH };
|
|
} else if (sscanf(out, "UID:%lu\n", &v) == 1) {
|
|
*xid = (struct unixid) { .id = v, .type = ID_TYPE_UID };
|
|
} else if (sscanf(out, "GID:%lu\n", &v) == 1) {
|
|
*xid = (struct unixid) { .id = v, .type = ID_TYPE_GID };
|
|
} else {
|
|
goto unmapped;
|
|
}
|
|
|
|
*status = ID_MAPPED;
|
|
return 0;
|
|
|
|
unmapped:
|
|
*xid = (struct unixid) { .id = UINT32_MAX,
|
|
.type = ID_TYPE_NOT_SPECIFIED };
|
|
*status = ID_UNMAPPED;
|
|
return 0;
|
|
}
|
|
|
|
struct idmap_script_sids2xids_state {
|
|
struct id_map **ids;
|
|
size_t num_ids;
|
|
size_t num_done;
|
|
};
|
|
|
|
static void idmap_script_sids2xids_done(struct tevent_req *subreq);
|
|
|
|
static struct tevent_req *idmap_script_sids2xids_send(
|
|
TALLOC_CTX *mem_ctx, struct tevent_context *ev,
|
|
struct id_map **ids, size_t num_ids, const char *script)
|
|
{
|
|
struct tevent_req *req;
|
|
struct idmap_script_sids2xids_state *state;
|
|
size_t i;
|
|
|
|
req = tevent_req_create(mem_ctx, &state,
|
|
struct idmap_script_sids2xids_state);
|
|
if (req == NULL) {
|
|
return NULL;
|
|
}
|
|
state->ids = ids;
|
|
state->num_ids = num_ids;
|
|
|
|
if (state->num_ids == 0) {
|
|
tevent_req_done(req);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
for (i=0; i<num_ids; i++) {
|
|
struct tevent_req *subreq;
|
|
|
|
subreq = idmap_script_sid2xid_send(
|
|
state, ev, ids[i]->sid, script, i);
|
|
if (tevent_req_nomem(subreq, req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
tevent_req_set_callback(subreq, idmap_script_sids2xids_done,
|
|
req);
|
|
}
|
|
|
|
return req;
|
|
}
|
|
|
|
static void idmap_script_sids2xids_done(struct tevent_req *subreq)
|
|
{
|
|
struct tevent_req *req = tevent_req_callback_data(
|
|
subreq, struct tevent_req);
|
|
struct idmap_script_sids2xids_state *state = tevent_req_data(
|
|
req, struct idmap_script_sids2xids_state);
|
|
size_t idx = 0;
|
|
enum id_mapping status = ID_UNKNOWN;
|
|
struct unixid xid = { .id = UINT32_MAX,
|
|
.type = ID_TYPE_NOT_SPECIFIED };
|
|
int ret;
|
|
|
|
ret = idmap_script_sid2xid_recv(subreq, &idx, &status, &xid);
|
|
TALLOC_FREE(subreq);
|
|
if (tevent_req_error(req, ret)) {
|
|
return;
|
|
}
|
|
|
|
if (idx >= state->num_ids) {
|
|
tevent_req_error(req, EINVAL);
|
|
return;
|
|
}
|
|
|
|
state->ids[idx]->status = status;
|
|
state->ids[idx]->xid = xid;
|
|
|
|
state->num_done += 1;
|
|
|
|
if (state->num_done >= state->num_ids) {
|
|
tevent_req_done(req);
|
|
}
|
|
}
|
|
|
|
static int idmap_script_sids2xids_recv(struct tevent_req *req)
|
|
{
|
|
return tevent_req_simple_recv_unix(req);
|
|
}
|
|
|
|
static int idmap_script_sids2xids(struct id_map **ids, size_t num_ids,
|
|
const char *script)
|
|
{
|
|
TALLOC_CTX *frame = talloc_stackframe();
|
|
struct tevent_context *ev;
|
|
struct tevent_req *req;
|
|
int ret = ENOMEM;
|
|
|
|
ev = samba_tevent_context_init(frame);
|
|
if (ev == NULL) {
|
|
goto fail;
|
|
}
|
|
req = idmap_script_sids2xids_send(frame, ev, ids, num_ids, script);
|
|
if (req == NULL) {
|
|
goto fail;
|
|
}
|
|
if (!tevent_req_poll(req, ev)) {
|
|
ret = errno;
|
|
goto fail;
|
|
}
|
|
ret = idmap_script_sids2xids_recv(req);
|
|
fail:
|
|
TALLOC_FREE(frame);
|
|
return ret;
|
|
}
|
|
|
|
static NTSTATUS idmap_script_sids_to_unixids(struct idmap_domain *dom,
|
|
struct id_map **ids)
|
|
{
|
|
struct idmap_script_context *ctx = talloc_get_type_abort(
|
|
dom->private_data, struct idmap_script_context);
|
|
int ret;
|
|
size_t i, num_ids, num_mapped;
|
|
|
|
DEBUG(10, ("%s called ...\n", __func__));
|
|
/* Init status to avoid surprise ... */
|
|
for (i = 0; ids[i]; i++) {
|
|
ids[i]->status = ID_UNKNOWN;
|
|
}
|
|
num_ids = i;
|
|
|
|
ret = idmap_script_sids2xids(ids, num_ids, ctx->script);
|
|
if (ret != 0) {
|
|
DBG_DEBUG("idmap_script_sids2xids returned %s\n",
|
|
strerror(ret));
|
|
return map_nt_error_from_unix(ret);
|
|
}
|
|
|
|
num_mapped = 0;
|
|
|
|
for (i=0; i<num_ids; i++) {
|
|
struct id_map *map = ids[i];
|
|
|
|
if ((map->status == ID_MAPPED) &&
|
|
!idmap_unix_id_is_in_range(map->xid.id, dom)) {
|
|
DBG_INFO("Script returned id (%u) out of range "
|
|
"(%u - %u). Filtered!\n",
|
|
map->xid.id, dom->low_id, dom->high_id);
|
|
map->status = ID_UNMAPPED;
|
|
}
|
|
|
|
if (map->status == ID_MAPPED) {
|
|
num_mapped += 1;
|
|
}
|
|
}
|
|
|
|
if (num_mapped == 0) {
|
|
return NT_STATUS_NONE_MAPPED;
|
|
}
|
|
if (num_mapped < num_ids) {
|
|
return STATUS_SOME_UNMAPPED;
|
|
}
|
|
return NT_STATUS_OK;
|
|
}
|
|
|
|
/*
|
|
* Initialise idmap_script database.
|
|
*/
|
|
static NTSTATUS idmap_script_db_init(struct idmap_domain *dom)
|
|
{
|
|
NTSTATUS ret;
|
|
struct idmap_script_context *ctx;
|
|
const char * idmap_script = NULL;
|
|
const char *ctx_script = NULL;
|
|
|
|
DEBUG(10, ("%s called ...\n", __func__));
|
|
|
|
ctx = talloc_zero(dom, struct idmap_script_context);
|
|
if (!ctx) {
|
|
DEBUG(0, ("Out of memory!\n"));
|
|
ret = NT_STATUS_NO_MEMORY;
|
|
goto failed;
|
|
}
|
|
|
|
ctx_script = idmap_config_const_string(dom->name, "script", NULL);
|
|
|
|
/* Do we even need to handle this? */
|
|
idmap_script = lp_parm_const_string(-1, "idmap", "script", NULL);
|
|
if (idmap_script != NULL) {
|
|
DEBUG(0, ("Warning: 'idmap:script' is deprecated. "
|
|
" Please use 'idmap config * : script' instead!\n"));
|
|
}
|
|
|
|
if (strequal(dom->name, "*") && ctx_script == NULL) {
|
|
/* fall back to idmap:script for backwards compatibility */
|
|
ctx_script = idmap_script;
|
|
}
|
|
|
|
if (ctx_script) {
|
|
DEBUG(1, ("using idmap script '%s'\n", ctx->script));
|
|
/*
|
|
* We must ensure this memory is owned by ctx.
|
|
* The ctx_script const pointer is a pointer into
|
|
* the config file data and may become invalid
|
|
* on config file reload. BUG: 13956
|
|
*/
|
|
ctx->script = talloc_strdup(ctx, ctx_script);
|
|
if (ctx->script == NULL) {
|
|
ret = NT_STATUS_NO_MEMORY;
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
dom->private_data = ctx;
|
|
dom->read_only = true; /* We do not allocate!*/
|
|
|
|
return NT_STATUS_OK;
|
|
|
|
failed:
|
|
talloc_free(ctx);
|
|
return ret;
|
|
}
|
|
|
|
static const struct idmap_methods db_methods = {
|
|
.init = idmap_script_db_init,
|
|
.unixids_to_sids = idmap_script_unixids_to_sids,
|
|
.sids_to_unixids = idmap_script_sids_to_unixids,
|
|
};
|
|
|
|
static_decl_idmap;
|
|
NTSTATUS idmap_script_init(TALLOC_CTX *ctx)
|
|
{
|
|
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "script", &db_methods);
|
|
}
|