mirror of
https://github.com/samba-team/samba.git
synced 2024-12-24 21:34:56 +03:00
2327471756
Signed-off-by: Ralph Boehme <slow@samba.org> Reviewed-by: Swen Schillig <swen@linux.ibm.com> Reviewed-by: Volker Lendecke <vl@samba.org> Autobuild-User(master): Jeremy Allison <jra@samba.org> Autobuild-Date(master): Mon Aug 3 22:21:04 UTC 2020 on sn-devel-184
334 lines
7.3 KiB
C
334 lines
7.3 KiB
C
/*
|
|
* Unix SMB/CIFS implementation.
|
|
* Utils for caching sid2name and name2sid
|
|
* Copyright (C) Volker Lendecke 2017
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "replace.h"
|
|
#include "namemap_cache.h"
|
|
#include "source3/lib/gencache.h"
|
|
#include "lib/util/debug.h"
|
|
#include "lib/util/strv.h"
|
|
#include "lib/util/util.h"
|
|
#include "lib/util/talloc_stack.h"
|
|
#include "lib/util/charset/charset.h"
|
|
#include "libcli/security/dom_sid.h"
|
|
#include "lib/util/smb_strtox.h"
|
|
|
|
bool namemap_cache_set_sid2name(const struct dom_sid *sid,
|
|
const char *domain, const char *name,
|
|
enum lsa_SidType type, time_t timeout)
|
|
{
|
|
char typebuf[16];
|
|
struct dom_sid_buf sidbuf;
|
|
char keybuf[sizeof(sidbuf.buf)+10];
|
|
char *val = NULL;
|
|
DATA_BLOB data;
|
|
int ret;
|
|
bool ok = false;
|
|
|
|
if ((sid == NULL) || is_null_sid(sid)) {
|
|
return true;
|
|
}
|
|
if (domain == NULL) {
|
|
domain = "";
|
|
}
|
|
if (name == NULL) {
|
|
name = "";
|
|
}
|
|
if (type == SID_NAME_UNKNOWN) {
|
|
domain = "";
|
|
name = "";
|
|
}
|
|
|
|
snprintf(typebuf, sizeof(typebuf), "%d", (int)type);
|
|
|
|
ret = strv_add(talloc_tos(), &val, domain);
|
|
if (ret != 0) {
|
|
DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
|
|
goto fail;
|
|
}
|
|
ret = strv_add(NULL, &val, name);
|
|
if (ret != 0) {
|
|
DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
|
|
goto fail;
|
|
}
|
|
ret = strv_add(NULL, &val, typebuf);
|
|
if (ret != 0) {
|
|
DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
|
|
goto fail;
|
|
}
|
|
|
|
dom_sid_str_buf(sid, &sidbuf);
|
|
snprintf(keybuf, sizeof(keybuf), "SID2NAME/%s", sidbuf.buf);
|
|
|
|
data = data_blob_const(val, talloc_get_size(val));
|
|
|
|
ok = gencache_set_data_blob(keybuf, data, timeout);
|
|
if (!ok) {
|
|
DBG_DEBUG("gencache_set_data_blob failed\n");
|
|
}
|
|
fail:
|
|
TALLOC_FREE(val);
|
|
return ok;
|
|
}
|
|
|
|
struct namemap_cache_find_sid_state {
|
|
void (*fn)(const char *domain,
|
|
const char *name,
|
|
enum lsa_SidType type,
|
|
bool expired,
|
|
void *private_data);
|
|
void *private_data;
|
|
bool ok;
|
|
};
|
|
|
|
static void namemap_cache_find_sid_parser(
|
|
const struct gencache_timeout *timeout,
|
|
DATA_BLOB blob,
|
|
void *private_data)
|
|
{
|
|
struct namemap_cache_find_sid_state *state = private_data;
|
|
const char *strv = (const char *)blob.data;
|
|
size_t strv_len = blob.length;
|
|
const char *domain;
|
|
const char *name;
|
|
const char *typebuf;
|
|
int error = 0;
|
|
unsigned long type;
|
|
|
|
state->ok = false;
|
|
|
|
domain = strv_len_next(strv, strv_len, NULL);
|
|
if (domain == NULL) {
|
|
return;
|
|
}
|
|
name = strv_len_next(strv, strv_len, domain);
|
|
if (name == NULL) {
|
|
return;
|
|
}
|
|
typebuf = strv_len_next(strv, strv_len, name);
|
|
if (typebuf == NULL) {
|
|
return;
|
|
}
|
|
|
|
type = smb_strtoul(typebuf, NULL, 10, &error, SMB_STR_FULL_STR_CONV);
|
|
if (error != 0) {
|
|
return;
|
|
}
|
|
|
|
state->fn(domain,
|
|
name,
|
|
(enum lsa_SidType)type,
|
|
gencache_timeout_expired(timeout),
|
|
state->private_data);
|
|
|
|
state->ok = true;
|
|
}
|
|
|
|
bool namemap_cache_find_sid(const struct dom_sid *sid,
|
|
void (*fn)(const char *domain,
|
|
const char *name,
|
|
enum lsa_SidType type,
|
|
bool expired,
|
|
void *private_data),
|
|
void *private_data)
|
|
{
|
|
struct namemap_cache_find_sid_state state = {
|
|
.fn = fn, .private_data = private_data
|
|
};
|
|
struct dom_sid_buf sidbuf;
|
|
char keybuf[sizeof(sidbuf.buf)+10];
|
|
bool ok;
|
|
|
|
dom_sid_str_buf(sid, &sidbuf);
|
|
snprintf(keybuf, sizeof(keybuf), "SID2NAME/%s", sidbuf.buf);
|
|
|
|
ok = gencache_parse(keybuf, namemap_cache_find_sid_parser, &state);
|
|
if (!ok) {
|
|
DBG_DEBUG("gencache_parse(%s) failed\n", keybuf);
|
|
return false;
|
|
}
|
|
|
|
if (!state.ok) {
|
|
DBG_DEBUG("Could not parse %s, deleting\n", keybuf);
|
|
gencache_del(keybuf);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool namemap_cache_set_name2sid(const char *domain, const char *name,
|
|
const struct dom_sid *sid,
|
|
enum lsa_SidType type,
|
|
time_t timeout)
|
|
{
|
|
char typebuf[16];
|
|
struct dom_sid_buf sidbuf = {{0}};
|
|
char *key;
|
|
char *key_upper;
|
|
char *val = NULL;
|
|
DATA_BLOB data;
|
|
int ret;
|
|
bool ok = false;
|
|
|
|
if (domain == NULL) {
|
|
domain = "";
|
|
}
|
|
if (name == NULL) {
|
|
name = "";
|
|
}
|
|
if (type != SID_NAME_UNKNOWN) {
|
|
dom_sid_str_buf(sid, &sidbuf);
|
|
}
|
|
|
|
snprintf(typebuf, sizeof(typebuf), "%d", (int)type);
|
|
|
|
key = talloc_asprintf(talloc_tos(), "NAME2SID/%s\\%s", domain, name);
|
|
if (key == NULL) {
|
|
DBG_DEBUG("talloc_asprintf failed\n");
|
|
goto fail;
|
|
}
|
|
key_upper = strupper_talloc(key, key);
|
|
if (key_upper == NULL) {
|
|
DBG_DEBUG("strupper_talloc failed\n");
|
|
goto fail;
|
|
}
|
|
|
|
ret = strv_add(key, &val, sidbuf.buf);
|
|
if (ret != 0) {
|
|
DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
|
|
goto fail;
|
|
}
|
|
ret = strv_add(NULL, &val, typebuf);
|
|
if (ret != 0) {
|
|
DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
|
|
goto fail;
|
|
}
|
|
|
|
data = data_blob_const(val, talloc_get_size(val));
|
|
|
|
ok = gencache_set_data_blob(key_upper, data, timeout);
|
|
if (!ok) {
|
|
DBG_DEBUG("gencache_set_data_blob failed\n");
|
|
}
|
|
fail:
|
|
TALLOC_FREE(key);
|
|
return ok;
|
|
}
|
|
|
|
struct namemap_cache_find_name_state {
|
|
void (*fn)(const struct dom_sid *sid,
|
|
enum lsa_SidType type,
|
|
bool expired,
|
|
void *private_data);
|
|
void *private_data;
|
|
bool ok;
|
|
};
|
|
|
|
static void namemap_cache_find_name_parser(
|
|
const struct gencache_timeout *timeout,
|
|
DATA_BLOB blob,
|
|
void *private_data)
|
|
{
|
|
struct namemap_cache_find_name_state *state = private_data;
|
|
const char *strv = (const char *)blob.data;
|
|
size_t strv_len = blob.length;
|
|
const char *sidbuf;
|
|
const char *sid_endptr;
|
|
const char *typebuf;
|
|
int error = 0;
|
|
struct dom_sid sid;
|
|
unsigned long type;
|
|
bool ok;
|
|
|
|
state->ok = false;
|
|
|
|
sidbuf = strv_len_next(strv, strv_len, NULL);
|
|
if (sidbuf == NULL) {
|
|
return;
|
|
}
|
|
typebuf = strv_len_next(strv, strv_len, sidbuf);
|
|
if (typebuf == NULL) {
|
|
return;
|
|
}
|
|
|
|
ok = dom_sid_parse_endp(sidbuf, &sid, &sid_endptr);
|
|
if (!ok) {
|
|
return;
|
|
}
|
|
if (*sid_endptr != '\0') {
|
|
return;
|
|
}
|
|
|
|
type = smb_strtoul(typebuf, NULL, 10, &error, SMB_STR_FULL_STR_CONV);
|
|
if (error != 0) {
|
|
return;
|
|
}
|
|
|
|
state->fn(&sid,
|
|
(enum lsa_SidType)type,
|
|
gencache_timeout_expired(timeout),
|
|
state->private_data);
|
|
|
|
state->ok = true;
|
|
}
|
|
|
|
bool namemap_cache_find_name(const char *domain,
|
|
const char *name,
|
|
void (*fn)(const struct dom_sid *sid,
|
|
enum lsa_SidType type,
|
|
bool expired,
|
|
void *private_data),
|
|
void *private_data)
|
|
{
|
|
struct namemap_cache_find_name_state state = {
|
|
.fn = fn, .private_data = private_data
|
|
};
|
|
char *key;
|
|
char *key_upper;
|
|
bool ret = false;
|
|
bool ok;
|
|
|
|
key = talloc_asprintf(talloc_tos(), "NAME2SID/%s\\%s", domain, name);
|
|
if (key == NULL) {
|
|
DBG_DEBUG("talloc_asprintf failed\n");
|
|
return false;
|
|
}
|
|
key_upper = strupper_talloc(key, key);
|
|
if (key_upper == NULL) {
|
|
DBG_DEBUG("strupper_talloc failed\n");
|
|
goto fail;
|
|
}
|
|
|
|
ok = gencache_parse(key_upper, namemap_cache_find_name_parser, &state);
|
|
if (!ok) {
|
|
DBG_DEBUG("gencache_parse(%s) failed\n", key_upper);
|
|
goto fail;
|
|
}
|
|
|
|
if (!state.ok) {
|
|
DBG_DEBUG("Could not parse %s, deleting\n", key_upper);
|
|
goto fail;
|
|
}
|
|
|
|
ret = true;
|
|
fail:
|
|
TALLOC_FREE(key);
|
|
return ret;
|
|
}
|