1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-25 23:21:54 +03:00
samba-mirror/source3/lib/cleanupdb.c
Volker Lendecke 23ba1dabf5 lib: Avoid an #include includes.h
Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>
2022-10-27 18:18:36 +00:00

170 lines
3.9 KiB
C

/*
Unix SMB/CIFS implementation.
Implementation of reliable cleanup events
Copyright (C) Ralph Boehme 2016
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/tdb_wrap/tdb_wrap.h"
#include "lib/util/talloc_stack.h"
#include "lib/util/debug.h"
#include "source3/lib/cleanupdb.h"
#include "source3/lib/util_path.h"
struct cleanup_key {
pid_t pid;
};
struct cleanup_rec {
bool unclean;
};
static struct tdb_wrap *cleanup_db(void)
{
static struct tdb_wrap *db;
char *db_path = NULL;
int tdbflags = TDB_INCOMPATIBLE_HASH | TDB_CLEAR_IF_FIRST |
TDB_MUTEX_LOCKING;
if (db != NULL) {
return db;
}
db_path = lock_path(talloc_tos(), "smbd_cleanupd.tdb");
if (db_path == NULL) {
return NULL;
}
db = tdb_wrap_open(NULL, db_path, 0, tdbflags,
O_CREAT | O_RDWR, 0644);
if (db == NULL) {
DBG_ERR("Failed to open smbd_cleanupd.tdb\n");
}
TALLOC_FREE(db_path);
return db;
}
bool cleanupdb_store_child(const pid_t pid, const bool unclean)
{
struct tdb_wrap *db;
struct cleanup_key key = { .pid = pid };
struct cleanup_rec rec = { .unclean = unclean };
TDB_DATA tdbkey = { .dptr = (uint8_t *)&key, .dsize = sizeof(key) };
TDB_DATA tdbdata = { .dptr = (uint8_t *)&rec, .dsize = sizeof(rec) };
int result;
db = cleanup_db();
if (db == NULL) {
return false;
}
result = tdb_store(db->tdb, tdbkey, tdbdata, TDB_REPLACE);
if (result != 0) {
DBG_ERR("tdb_store failed for pid %d\n", (int)pid);
return false;
}
return true;
}
bool cleanupdb_delete_child(const pid_t pid)
{
struct tdb_wrap *db;
struct cleanup_key key = { .pid = pid };
TDB_DATA tdbkey = { .dptr = (uint8_t *)&key, .dsize = sizeof(key) };
int result;
db = cleanup_db();
if (db == NULL) {
return false;
}
result = tdb_delete(db->tdb, tdbkey);
if (result != 0) {
DBG_ERR("tdb_delete failed for pid %d\n", (int)pid);
return false;
}
return true;
}
struct cleanup_read_state {
int (*fn)(const pid_t pid, const bool cleanup, void *private_data);
void *private_data;
};
static int cleanup_traverse_fn(struct tdb_context *tdb,
TDB_DATA key, TDB_DATA value,
void *private_data)
{
struct cleanup_read_state *state =
(struct cleanup_read_state *)private_data;
struct cleanup_key ckey;
struct cleanup_rec rec;
int result;
if (key.dsize != sizeof(struct cleanup_key)) {
DBG_ERR("Found invalid key length %zu in cleanup.tdb\n",
key.dsize);
return -1;
}
memcpy(&ckey, key.dptr, sizeof(struct cleanup_key));
if (value.dsize != sizeof(struct cleanup_rec)) {
DBG_ERR("Found invalid value length %zu in cleanup.tdb\n",
value.dsize);
return -1;
}
memcpy(&rec, value.dptr, sizeof(struct cleanup_rec));
result = state->fn(ckey.pid, rec.unclean, state->private_data);
if (result != 0) {
return -1;
}
return 0;
}
int cleanupdb_traverse_read(int (*fn)(const pid_t pid,
const bool cleanup,
void *private_data),
void *private_data)
{
struct tdb_wrap *db;
struct cleanup_read_state state;
int result;
db = cleanup_db();
if (db == NULL) {
return -1;
}
state = (struct cleanup_read_state) {
.fn = fn,
.private_data = private_data
};
result = tdb_traverse_read(db->tdb, cleanup_traverse_fn, &state);
if (result < 0) {
DBG_ERR("tdb_traverse_read failed\n");
return -1;
}
return result;
}