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
)
254 struct db_context
*db
;
255 struct serverid_exists_state state
;
256 struct serverid_key key
;
260 if (procid_is_me(id
)) {
264 if (!process_exists(*id
)) {
268 if (id
->unique_id
== SERVERID_UNIQUE_ID_NOT_TO_VERIFY
) {
277 serverid_fill_key(id
, &key
);
278 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
281 state
.exists
= false;
283 status
= dbwrap_parse_record(db
, tdbkey
, server_exists_parse
, &state
);
284 if (!NT_STATUS_IS_OK(status
)) {
290 bool serverids_exist(const struct server_id
*ids
, int num_ids
, bool *results
)
292 struct db_context
*db
;
295 #ifdef HAVE_CTDB_CONTROL_CHECK_SRVIDS_DECL
296 if (lp_clustering()) {
297 return ctdb_serverids_exist(messaging_ctdbd_connection(),
298 ids
, num_ids
, results
);
301 if (!processes_exist(ids
, num_ids
, results
)) {
310 for (i
=0; i
<num_ids
; i
++) {
311 struct serverid_exists_state state
;
312 struct serverid_key key
;
316 if (ids
[i
].unique_id
== SERVERID_UNIQUE_ID_NOT_TO_VERIFY
) {
324 serverid_fill_key(&ids
[i
], &key
);
325 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
328 state
.exists
= false;
329 status
= dbwrap_parse_record(db
, tdbkey
, server_exists_parse
, &state
);
330 if (!NT_STATUS_IS_OK(status
)) {
334 results
[i
] = state
.exists
;
339 static bool serverid_rec_parse(const struct db_record
*rec
,
340 struct server_id
*id
, uint32_t *msg_flags
)
342 struct serverid_key key
;
343 struct serverid_data data
;
347 tdbkey
= dbwrap_record_get_key(rec
);
348 tdbdata
= dbwrap_record_get_value(rec
);
350 if (tdbkey
.dsize
!= sizeof(key
)) {
351 DEBUG(1, ("Found invalid key length %d in serverid.tdb\n",
355 if (tdbdata
.dsize
!= sizeof(data
)) {
356 DEBUG(1, ("Found invalid value length %d in serverid.tdb\n",
357 (int)tdbdata
.dsize
));
361 memcpy(&key
, tdbkey
.dptr
, sizeof(key
));
362 memcpy(&data
, tdbdata
.dptr
, sizeof(data
));
365 id
->task_id
= key
.task_id
;
367 id
->unique_id
= data
.unique_id
;
368 *msg_flags
= data
.msg_flags
;
372 struct serverid_traverse_read_state
{
373 int (*fn
)(const struct server_id
*id
, uint32_t msg_flags
,
378 static int serverid_traverse_read_fn(struct db_record
*rec
, void *private_data
)
380 struct serverid_traverse_read_state
*state
=
381 (struct serverid_traverse_read_state
*)private_data
;
385 if (!serverid_rec_parse(rec
, &id
, &msg_flags
)) {
388 return state
->fn(&id
, msg_flags
,state
->private_data
);
391 bool serverid_traverse_read(int (*fn
)(const struct server_id
*id
,
392 uint32_t msg_flags
, void *private_data
),
395 struct db_context
*db
;
396 struct serverid_traverse_read_state state
;
404 state
.private_data
= private_data
;
406 status
= dbwrap_traverse_read(db
, serverid_traverse_read_fn
, &state
,
408 return NT_STATUS_IS_OK(status
);
411 struct serverid_traverse_state
{
412 int (*fn
)(struct db_record
*rec
, const struct server_id
*id
,
413 uint32_t msg_flags
, void *private_data
);
417 static int serverid_traverse_fn(struct db_record
*rec
, void *private_data
)
419 struct serverid_traverse_state
*state
=
420 (struct serverid_traverse_state
*)private_data
;
424 if (!serverid_rec_parse(rec
, &id
, &msg_flags
)) {
427 return state
->fn(rec
, &id
, msg_flags
, state
->private_data
);
430 bool serverid_traverse(int (*fn
)(struct db_record
*rec
,
431 const struct server_id
*id
,
432 uint32_t msg_flags
, void *private_data
),
435 struct db_context
*db
;
436 struct serverid_traverse_state state
;
444 state
.private_data
= private_data
;
446 status
= dbwrap_traverse(db
, serverid_traverse_fn
, &state
, NULL
);
447 return NT_STATUS_IS_OK(status
);
450 uint64_t serverid_get_random_unique_id(void)
452 uint64_t unique_id
= SERVERID_UNIQUE_ID_NOT_TO_VERIFY
;
454 while (unique_id
== SERVERID_UNIQUE_ID_NOT_TO_VERIFY
) {
455 generate_random_buffer((uint8_t *)&unique_id
,
462 bool serverid_equal(const struct server_id
*p1
, const struct server_id
*p2
)
464 if (p1
->pid
!= p2
->pid
) {
468 if (p1
->task_id
!= p2
->task_id
) {
472 if (p1
->vnn
!= p2
->vnn
) {
476 if (p1
->unique_id
!= p2
->unique_id
) {