2 Unix SMB/CIFS implementation.
3 Implementation of a reliable server_exists()
4 Copyright (C) Volker Lendecke 2010
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "system/filesys.h"
24 #include "dbwrap/dbwrap.h"
25 #include "dbwrap/dbwrap_open.h"
26 #include "lib/tdb_wrap/tdb_wrap.h"
27 #include "lib/param/param.h"
28 #include "ctdbd_conn.h"
37 struct serverid_data {
42 bool serverid_parent_init(TALLOC_CTX *mem_ctx)
45 struct loadparm_context *lp_ctx;
47 lp_ctx = loadparm_init_s3(mem_ctx, loadparm_s3_helpers());
49 DEBUG(0, ("loadparm_init_s3 failed\n"));
54 * Open the tdb in the parent process (smbd) so that our
55 * CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
59 db = tdb_wrap_open(mem_ctx, lock_path("serverid.tdb"),
60 0, TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDWR|O_CREAT,
62 talloc_unlink(mem_ctx, lp_ctx);
64 DEBUG(1, ("could not open serverid.tdb: %s\n",
71 static struct db_context *serverid_db(void)
73 static struct db_context *db;
78 db = db_open(NULL, lock_path("serverid.tdb"), 0,
79 TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
80 O_RDWR|O_CREAT, 0644, DBWRAP_LOCK_ORDER_2);
84 static void serverid_fill_key(const struct server_id *id,
85 struct serverid_key *key)
89 key->task_id = id->task_id;
93 bool serverid_register(const struct server_id id, uint32_t msg_flags)
95 struct db_context *db;
96 struct serverid_key key;
97 struct serverid_data data;
98 struct db_record *rec;
99 TDB_DATA tdbkey, tdbdata;
108 serverid_fill_key(&id, &key);
109 tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
111 rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey);
113 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
118 data.unique_id = id.unique_id;
119 data.msg_flags = msg_flags;
121 tdbdata = make_tdb_data((uint8_t *)&data, sizeof(data));
122 status = dbwrap_record_store(rec, tdbdata, 0);
123 if (!NT_STATUS_IS_OK(status)) {
124 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
128 #ifdef HAVE_CTDB_CONTROL_CHECK_SRVIDS_DECL
129 if (lp_clustering()) {
130 register_with_ctdbd(messaging_ctdbd_connection(), id.unique_id);
139 bool serverid_register_msg_flags(const struct server_id id, bool do_reg,
142 struct db_context *db;
143 struct serverid_key key;
144 struct serverid_data *data;
145 struct db_record *rec;
156 serverid_fill_key(&id, &key);
157 tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
159 rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey);
161 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
165 value = dbwrap_record_get_value(rec);
167 if (value.dsize != sizeof(struct serverid_data)) {
168 DEBUG(1, ("serverid record has unexpected size %d "
169 "(wanted %d)\n", (int)value.dsize,
170 (int)sizeof(struct serverid_data)));
174 data = (struct serverid_data *)value.dptr;
177 data->msg_flags |= msg_flags;
179 data->msg_flags &= ~msg_flags;
182 status = dbwrap_record_store(rec, value, 0);
183 if (!NT_STATUS_IS_OK(status)) {
184 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
194 bool serverid_deregister(struct server_id id)
196 struct db_context *db;
197 struct serverid_key key;
198 struct db_record *rec;
208 serverid_fill_key(&id, &key);
209 tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
211 rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey);
213 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
217 status = dbwrap_record_delete(rec);
218 if (!NT_STATUS_IS_OK(status)) {
219 DEBUG(1, ("Deleting serverid.tdb record failed: %s\n",
229 struct serverid_exists_state {
230 const struct server_id *id;
234 static void server_exists_parse(TDB_DATA key, TDB_DATA data, void *priv)
236 struct serverid_exists_state *state =
237 (struct serverid_exists_state *)priv;
239 if (data.dsize != sizeof(struct serverid_data)) {
240 state->exists = false;
245 * Use memcmp, not direct compare. data.dptr might not be
248 state->exists = (memcmp(&state->id->unique_id, data.dptr,
249 sizeof(state->id->unique_id)) == 0);
252 bool serverid_exists(const struct server_id *id)
257 ok = serverids_exist(id, 1, &result);
265 bool serverids_exist(const struct server_id *ids, int num_ids, bool *results)
267 struct db_context *db;
270 if (!processes_exist(ids, num_ids, results)) {
279 for (i=0; i<num_ids; i++) {
280 struct serverid_exists_state state;
281 struct serverid_key key;
285 if (ids[i].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
293 serverid_fill_key(&ids[i], &key);
294 tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
297 state.exists = false;
298 status = dbwrap_parse_record(db, tdbkey, server_exists_parse, &state);
299 if (!NT_STATUS_IS_OK(status)) {
303 results[i] = state.exists;
308 static bool serverid_rec_parse(const struct db_record *rec,
309 struct server_id *id, uint32_t *msg_flags)
311 struct serverid_key key;
312 struct serverid_data data;
316 tdbkey = dbwrap_record_get_key(rec);
317 tdbdata = dbwrap_record_get_value(rec);
319 if (tdbkey.dsize != sizeof(key)) {
320 DEBUG(1, ("Found invalid key length %d in serverid.tdb\n",
324 if (tdbdata.dsize != sizeof(data)) {
325 DEBUG(1, ("Found invalid value length %d in serverid.tdb\n",
326 (int)tdbdata.dsize));
330 memcpy(&key, tdbkey.dptr, sizeof(key));
331 memcpy(&data, tdbdata.dptr, sizeof(data));
334 id->task_id = key.task_id;
336 id->unique_id = data.unique_id;
337 *msg_flags = data.msg_flags;
341 struct serverid_traverse_read_state {
342 int (*fn)(const struct server_id *id, uint32_t msg_flags,
347 static int serverid_traverse_read_fn(struct db_record *rec, void *private_data)
349 struct serverid_traverse_read_state *state =
350 (struct serverid_traverse_read_state *)private_data;
354 if (!serverid_rec_parse(rec, &id, &msg_flags)) {
357 return state->fn(&id, msg_flags,state->private_data);
360 bool serverid_traverse_read(int (*fn)(const struct server_id *id,
361 uint32_t msg_flags, void *private_data),
364 struct db_context *db;
365 struct serverid_traverse_read_state state;
373 state.private_data = private_data;
375 status = dbwrap_traverse_read(db, serverid_traverse_read_fn, &state,
377 return NT_STATUS_IS_OK(status);
380 struct serverid_traverse_state {
381 int (*fn)(struct db_record *rec, const struct server_id *id,
382 uint32_t msg_flags, void *private_data);
386 static int serverid_traverse_fn(struct db_record *rec, void *private_data)
388 struct serverid_traverse_state *state =
389 (struct serverid_traverse_state *)private_data;
393 if (!serverid_rec_parse(rec, &id, &msg_flags)) {
396 return state->fn(rec, &id, msg_flags, state->private_data);
399 bool serverid_traverse(int (*fn)(struct db_record *rec,
400 const struct server_id *id,
401 uint32_t msg_flags, void *private_data),
404 struct db_context *db;
405 struct serverid_traverse_state state;
413 state.private_data = private_data;
415 status = dbwrap_traverse(db, serverid_traverse_fn, &state, NULL);
416 return NT_STATUS_IS_OK(status);
419 uint64_t serverid_get_random_unique_id(void)
421 uint64_t unique_id = SERVERID_UNIQUE_ID_NOT_TO_VERIFY;
423 while (unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
424 generate_random_buffer((uint8_t *)&unique_id,