1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-22 13:34:15 +03:00
samba-mirror/lib/util/server_id_db.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

354 lines
7.3 KiB
C
Raw Normal View History

/*
* Map names to server_ids
*
* Copyright Volker Lendecke <vl@samba.org> 2014
*
* 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 "system/filesys.h"
#include "lib/util/server_id.h"
#include "lib/util/server_id_db.h"
#include "lib/tdb_wrap/tdb_wrap.h"
#include "lib/util/strv.h"
#include "lib/util/util_tdb.h"
#include "lib/util/samba_util.h"
static TDB_DATA talloc_tdb_data(void *ptr)
{
return (TDB_DATA) { .dptr = ptr, .dsize = talloc_get_size(ptr) };
}
struct server_id_db {
struct server_id pid;
struct tdb_wrap *tdb;
char *names;
};
static int server_id_db_destructor(struct server_id_db *db);
struct server_id_db *server_id_db_init(TALLOC_CTX *mem_ctx,
struct server_id pid,
const char *base_path,
int hash_size, int tdb_flags)
{
struct server_id_db *db;
size_t pathlen = strlen(base_path) + 11;
char path[pathlen];
db = talloc(mem_ctx, struct server_id_db);
if (db == NULL) {
return NULL;
}
db->pid = pid;
db->names = NULL;
snprintf(path, pathlen, "%s/names.tdb", base_path);
db->tdb = tdb_wrap_open(db, path, hash_size, tdb_flags,
O_RDWR|O_CREAT, 0660);
if (db->tdb == NULL) {
TALLOC_FREE(db);
return NULL;
}
talloc_set_destructor(db, server_id_db_destructor);
return db;
}
void server_id_db_reinit(struct server_id_db *db, struct server_id pid)
{
db->pid = pid;
TALLOC_FREE(db->names);
}
struct server_id server_id_db_pid(struct server_id_db *db)
{
return db->pid;
}
static int server_id_db_destructor(struct server_id_db *db)
{
char *name = NULL;
while ((name = strv_next(db->names, name)) != NULL) {
server_id_db_remove(db, name);
}
return 0;
}
int server_id_db_add(struct server_id_db *db, const char *name)
{
struct tdb_context *tdb = db->tdb->tdb;
TDB_DATA key;
char *n;
int ret;
n = strv_find(db->names, name);
if (n != NULL) {
return EEXIST;
}
ret = strv_add(db, &db->names, name);
if (ret != 0) {
return ret;
}
key = string_term_tdb_data(name);
{
struct server_id_buf _buf;
char *idbuf = server_id_str_buf_unique(db->pid, &_buf);
size_t idlen = strlen(idbuf) + 1;
ret = tdb_append(
tdb, key,
(TDB_DATA) { .dptr = (uint8_t *)idbuf, .dsize = idlen });
}
if (ret != 0) {
enum TDB_ERROR err = tdb_error(tdb);
strv_delete(&db->names, strv_find(db->names, name));
return map_unix_error_from_tdb(err);
}
return 0;
}
int server_id_db_prune_name(struct server_id_db *db, const char *name,
struct server_id server)
{
struct tdb_context *tdb = db->tdb->tdb;
struct server_id_buf _buf;
char *idbuf = server_id_str_buf_unique(server, &_buf);
TDB_DATA key;
uint8_t *data;
size_t datalen;
char *ids, *id;
int ret;
key = string_term_tdb_data(name);
ret = tdb_chainlock(tdb, key);
if (ret == -1) {
enum TDB_ERROR err = tdb_error(tdb);
return map_unix_error_from_tdb(err);
}
ret = tdb_fetch_talloc(tdb, key, db, &data);
if (ret != 0) {
tdb_chainunlock(tdb, key);
return ret;
}
datalen = talloc_get_size(data);
if ((datalen == 0) || (data[datalen-1] != '\0')) {
tdb_chainunlock(tdb, key);
TALLOC_FREE(data);
return EINVAL;
}
ids = (char *)data;
id = strv_find(ids, idbuf);
if (id == NULL) {
tdb_chainunlock(tdb, key);
TALLOC_FREE(data);
return ENOENT;
}
strv_delete(&ids, id);
if (talloc_get_size(ids) == 0) {
ret = tdb_delete(tdb, key);
} else {
ret = tdb_store(tdb, key, talloc_tdb_data(ids), TDB_MODIFY);
}
TALLOC_FREE(data);
tdb_chainunlock(tdb, key);
if (ret == -1) {
enum TDB_ERROR err = tdb_error(tdb);
return map_unix_error_from_tdb(err);
}
return 0;
}
int server_id_db_remove(struct server_id_db *db, const char *name)
{
char *n;
int ret;
n = strv_find(db->names, name);
if (n == NULL) {
return ENOENT;
}
ret = server_id_db_prune_name(db, name, db->pid);
if (ret != 0) {
return ret;
}
strv_delete(&db->names, n);
return 0;
}
int server_id_db_lookup(struct server_id_db *db, const char *name,
TALLOC_CTX *mem_ctx, unsigned *pnum_servers,
struct server_id **pservers)
{
struct tdb_context *tdb = db->tdb->tdb;
TDB_DATA key;
uint8_t *data;
size_t datalen;
char *ids, *id;
unsigned num_servers;
struct server_id *servers;
int i, ret;
key = string_term_tdb_data(name);
ret = tdb_fetch_talloc(tdb, key, mem_ctx, &data);
if (ret != 0) {
return ret;
}
datalen = talloc_get_size(data);
if ((datalen == 0) || (data[datalen-1] != '\0')) {
TALLOC_FREE(data);
return EINVAL;
}
ids = (char *)data;
num_servers = strv_count(ids);
servers = talloc_array(mem_ctx, struct server_id, num_servers);
if (servers == NULL) {
TALLOC_FREE(data);
return ENOMEM;
}
i = 0;
for (id = ids; id != NULL; id = strv_next(ids, id)) {
servers[i++] = server_id_from_string(NONCLUSTER_VNN, id);
}
TALLOC_FREE(data);
*pnum_servers = num_servers;
*pservers = servers;
return 0;
}
bool server_id_db_lookup_one(struct server_id_db *db, const char *name,
struct server_id *server)
{
int ret;
unsigned num_servers;
struct server_id *servers;
ret = server_id_db_lookup(db, name, db, &num_servers, &servers);
if (ret != 0) {
return false;
}
if (num_servers == 0) {
TALLOC_FREE(servers);
return false;
}
*server = servers[0];
TALLOC_FREE(servers);
return true;
}
struct server_id_db_traverse_state {
TALLOC_CTX *mem_ctx;
int (*fn)(const char *name,
unsigned num_servers,
const struct server_id *servers,
void *private_data);
void *private_data;
};
static int server_id_db_traverse_fn(struct tdb_context *tdb,
TDB_DATA key, TDB_DATA data,
void *private_data)
{
struct server_id_db_traverse_state *state = private_data;
const char *name;
char *ids, *id;
unsigned num_servers;
struct server_id *servers;
int i, ret;
if (key.dsize == 0) {
return 0;
}
if (key.dptr[key.dsize-1] != '\0') {
return 0;
}
name = (const char *)key.dptr;
ids = (char *)talloc_memdup(state->mem_ctx, data.dptr, data.dsize);
if (ids == NULL) {
return 0;
}
num_servers = strv_count(ids);
servers = talloc_array(ids, struct server_id, num_servers);
i = 0;
for (id = ids; id != NULL; id = strv_next(ids, id)) {
servers[i++] = server_id_from_string(NONCLUSTER_VNN, id);
}
ret = state->fn(name, num_servers, servers, state->private_data);
TALLOC_FREE(ids);
return ret;
}
int server_id_db_traverse_read(struct server_id_db *db,
int (*fn)(const char *name,
unsigned num_servers,
const struct server_id *servers,
void *private_data),
void *private_data)
{
struct server_id_db_traverse_state state;
int ret;
state = (struct server_id_db_traverse_state) {
.fn = fn, .private_data = private_data,
.mem_ctx = talloc_new(db)
};
if (state.mem_ctx == NULL) {
return ENOMEM;
}
ret = tdb_traverse_read(db->tdb->tdb, server_id_db_traverse_fn,
&state);
TALLOC_FREE(state.mem_ctx);
return ret;
}