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"
25 #include "lib/util/tdb_wrap.h"
33 struct serverid_data
{
38 bool serverid_parent_init(TALLOC_CTX
*mem_ctx
)
43 * Open the tdb in the parent process (smbd) so that our
44 * CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
48 db
= tdb_wrap_open(mem_ctx
, lock_path("serverid.tdb"),
49 0, TDB_DEFAULT
|TDB_CLEAR_IF_FIRST
|TDB_INCOMPATIBLE_HASH
, O_RDWR
|O_CREAT
,
52 DEBUG(1, ("could not open serverid.tdb: %s\n",
59 static struct db_context
*serverid_db(void)
61 static struct db_context
*db
;
66 db
= db_open(NULL
, lock_path("serverid.tdb"), 0,
67 TDB_DEFAULT
|TDB_CLEAR_IF_FIRST
|TDB_INCOMPATIBLE_HASH
, O_RDWR
|O_CREAT
, 0644);
71 static void serverid_fill_key(const struct server_id
*id
,
72 struct serverid_key
*key
)
76 key
->task_id
= id
->task_id
;
80 bool serverid_register(const struct server_id id
, uint32_t msg_flags
)
82 struct db_context
*db
;
83 struct serverid_key key
;
84 struct serverid_data data
;
85 struct db_record
*rec
;
86 TDB_DATA tdbkey
, tdbdata
;
95 serverid_fill_key(&id
, &key
);
96 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
98 rec
= db
->fetch_locked(db
, talloc_tos(), tdbkey
);
100 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
105 data
.unique_id
= id
.unique_id
;
106 data
.msg_flags
= msg_flags
;
108 tdbdata
= make_tdb_data((uint8_t *)&data
, sizeof(data
));
109 status
= rec
->store(rec
, tdbdata
, 0);
110 if (!NT_STATUS_IS_OK(status
)) {
111 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
121 bool serverid_register_msg_flags(const struct server_id id
, bool do_reg
,
124 struct db_context
*db
;
125 struct serverid_key key
;
126 struct serverid_data
*data
;
127 struct db_record
*rec
;
137 serverid_fill_key(&id
, &key
);
138 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
140 rec
= db
->fetch_locked(db
, talloc_tos(), tdbkey
);
142 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
146 if (rec
->value
.dsize
!= sizeof(struct serverid_data
)) {
147 DEBUG(1, ("serverid record has unexpected size %d "
148 "(wanted %d)\n", (int)rec
->value
.dsize
,
149 (int)sizeof(struct serverid_data
)));
153 data
= (struct serverid_data
*)rec
->value
.dptr
;
156 data
->msg_flags
|= msg_flags
;
158 data
->msg_flags
&= ~msg_flags
;
161 status
= rec
->store(rec
, rec
->value
, 0);
162 if (!NT_STATUS_IS_OK(status
)) {
163 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
173 bool serverid_deregister(struct server_id id
)
175 struct db_context
*db
;
176 struct serverid_key key
;
177 struct db_record
*rec
;
187 serverid_fill_key(&id
, &key
);
188 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
190 rec
= db
->fetch_locked(db
, talloc_tos(), tdbkey
);
192 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
196 status
= rec
->delete_rec(rec
);
197 if (!NT_STATUS_IS_OK(status
)) {
198 DEBUG(1, ("Deleting serverid.tdb record failed: %s\n",
208 struct serverid_exists_state
{
209 const struct server_id
*id
;
213 static int server_exists_parse(TDB_DATA key
, TDB_DATA data
, void *priv
)
215 struct serverid_exists_state
*state
=
216 (struct serverid_exists_state
*)priv
;
218 if (data
.dsize
!= sizeof(struct serverid_data
)) {
223 * Use memcmp, not direct compare. data.dptr might not be
226 state
->exists
= (memcmp(&state
->id
->unique_id
, data
.dptr
,
227 sizeof(state
->id
->unique_id
)) == 0);
231 bool serverid_exists(const struct server_id
*id
)
233 struct db_context
*db
;
234 struct serverid_exists_state state
;
235 struct serverid_key key
;
238 if (lp_clustering() && !process_exists(*id
)) {
247 serverid_fill_key(id
, &key
);
248 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
251 state
.exists
= false;
253 if (db
->parse_record(db
, tdbkey
, server_exists_parse
, &state
) != 0) {
259 static bool serverid_rec_parse(const struct db_record
*rec
,
260 struct server_id
*id
, uint32_t *msg_flags
)
262 struct serverid_key key
;
263 struct serverid_data data
;
265 if (rec
->key
.dsize
!= sizeof(key
)) {
266 DEBUG(1, ("Found invalid key length %d in serverid.tdb\n",
267 (int)rec
->key
.dsize
));
270 if (rec
->value
.dsize
!= sizeof(data
)) {
271 DEBUG(1, ("Found invalid value length %d in serverid.tdb\n",
272 (int)rec
->value
.dsize
));
276 memcpy(&key
, rec
->key
.dptr
, sizeof(key
));
277 memcpy(&data
, rec
->value
.dptr
, sizeof(data
));
280 id
->task_id
= key
.task_id
;
282 id
->unique_id
= data
.unique_id
;
283 *msg_flags
= data
.msg_flags
;
287 struct serverid_traverse_read_state
{
288 int (*fn
)(const struct server_id
*id
, uint32_t msg_flags
,
293 static int serverid_traverse_read_fn(struct db_record
*rec
, void *private_data
)
295 struct serverid_traverse_read_state
*state
=
296 (struct serverid_traverse_read_state
*)private_data
;
300 if (!serverid_rec_parse(rec
, &id
, &msg_flags
)) {
303 return state
->fn(&id
, msg_flags
,state
->private_data
);
306 bool serverid_traverse_read(int (*fn
)(const struct server_id
*id
,
307 uint32_t msg_flags
, void *private_data
),
310 struct db_context
*db
;
311 struct serverid_traverse_read_state state
;
318 state
.private_data
= private_data
;
319 return db
->traverse_read(db
, serverid_traverse_read_fn
, &state
);
322 struct serverid_traverse_state
{
323 int (*fn
)(struct db_record
*rec
, const struct server_id
*id
,
324 uint32_t msg_flags
, void *private_data
);
328 static int serverid_traverse_fn(struct db_record
*rec
, void *private_data
)
330 struct serverid_traverse_state
*state
=
331 (struct serverid_traverse_state
*)private_data
;
335 if (!serverid_rec_parse(rec
, &id
, &msg_flags
)) {
338 return state
->fn(rec
, &id
, msg_flags
, state
->private_data
);
341 bool serverid_traverse(int (*fn
)(struct db_record
*rec
,
342 const struct server_id
*id
,
343 uint32_t msg_flags
, void *private_data
),
346 struct db_context
*db
;
347 struct serverid_traverse_state state
;
354 state
.private_data
= private_data
;
355 return db
->traverse(db
, serverid_traverse_fn
, &state
);