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/>.
25 #ifdef CLUSTER_SUPPORT
30 struct serverid_data
{
35 static struct db_context
*serverid_db(void)
37 static struct db_context
*db
;
42 db
= db_open(talloc_autofree_context(), lock_path("serverid.tdb"),
43 0, TDB_DEFAULT
|TDB_CLEAR_IF_FIRST
, O_RDWR
|O_CREAT
, 0644);
47 static void serverid_fill_key(const struct server_id
*id
,
48 struct serverid_key
*key
)
52 #ifdef CLUSTER_SUPPORT
57 bool serverid_register(const struct server_id
*id
, uint32_t msg_flags
)
59 struct db_context
*db
;
60 struct serverid_key key
;
61 struct serverid_data data
;
62 struct db_record
*rec
;
63 TDB_DATA tdbkey
, tdbdata
;
72 serverid_fill_key(id
, &key
);
73 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
75 rec
= db
->fetch_locked(db
, talloc_tos(), tdbkey
);
77 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
82 data
.unique_id
= id
->unique_id
;
83 data
.msg_flags
= msg_flags
;
85 tdbdata
= make_tdb_data((uint8_t *)&data
, sizeof(data
));
86 status
= rec
->store(rec
, tdbdata
, 0);
87 if (!NT_STATUS_IS_OK(status
)) {
88 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
98 bool serverid_register_self(uint32_t msg_flags
)
100 struct server_id pid
;
103 return serverid_register(&pid
, msg_flags
);
106 bool serverid_deregister(const struct server_id
*id
)
108 struct db_context
*db
;
109 struct serverid_key key
;
110 struct db_record
*rec
;
120 serverid_fill_key(id
, &key
);
121 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
123 rec
= db
->fetch_locked(db
, talloc_tos(), tdbkey
);
125 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
129 status
= rec
->delete_rec(rec
);
130 if (!NT_STATUS_IS_OK(status
)) {
131 DEBUG(1, ("Deleting serverid.tdb record failed: %s\n",
141 bool serverid_deregister_self(void)
143 struct server_id pid
;
146 return serverid_deregister(&pid
);
149 struct serverid_exists_state
{
150 const struct server_id
*id
;
154 static int server_exists_parse(TDB_DATA key
, TDB_DATA data
, void *priv
)
156 struct serverid_exists_state
*state
=
157 (struct serverid_exists_state
*)priv
;
160 if (data
.dsize
!= sizeof(struct serverid_data
)) {
164 /* memcpy, data.dptr might not be aligned */
165 memcpy(&unique_id
, data
.dptr
, sizeof(unique_id
));
167 state
->exists
= (state
->id
->unique_id
== unique_id
);
171 bool serverid_exists(const struct server_id
*id
)
173 struct db_context
*db
;
174 struct serverid_exists_state state
;
175 struct serverid_key key
;
183 serverid_fill_key(id
, &key
);
184 tdbkey
= make_tdb_data((uint8_t *)&key
, sizeof(key
));
187 state
.exists
= false;
189 if (db
->parse_record(db
, tdbkey
, server_exists_parse
, &state
) == -1) {
195 static bool serverid_rec_parse(const struct db_record
*rec
,
196 struct server_id
*id
, uint32_t *msg_flags
)
198 struct serverid_key key
;
199 struct serverid_data data
;
201 if (rec
->key
.dsize
!= sizeof(key
)) {
202 DEBUG(1, ("Found invalid key length %d in serverid.tdb\n",
203 (int)rec
->key
.dsize
));
206 if (rec
->value
.dsize
!= sizeof(data
)) {
207 DEBUG(1, ("Found invalid value length %d in serverid.tdb\n",
208 (int)rec
->value
.dsize
));
212 memcpy(&key
, rec
->key
.dptr
, sizeof(key
));
213 memcpy(&data
, rec
->value
.dptr
, sizeof(data
));
216 #ifdef CLUSTER_SUPPORT
219 id
->unique_id
= data
.unique_id
;
220 *msg_flags
= data
.msg_flags
;
224 struct serverid_traverse_read_state
{
225 int (*fn
)(const struct server_id
*id
, uint32_t msg_flags
,
230 static int serverid_traverse_read_fn(struct db_record
*rec
, void *private_data
)
232 struct serverid_traverse_read_state
*state
=
233 (struct serverid_traverse_read_state
*)private_data
;
237 if (!serverid_rec_parse(rec
, &id
, &msg_flags
)) {
240 return state
->fn(&id
, msg_flags
,state
->private_data
);
243 bool serverid_traverse_read(int (*fn
)(const struct server_id
*id
,
244 uint32_t msg_flags
, void *private_data
),
247 struct db_context
*db
;
248 struct serverid_traverse_read_state state
;
255 state
.private_data
= private_data
;
256 return db
->traverse_read(db
, serverid_traverse_read_fn
, &state
);
259 struct serverid_traverse_state
{
260 int (*fn
)(struct db_record
*rec
, const struct server_id
*id
,
261 uint32_t msg_flags
, void *private_data
);
265 static int serverid_traverse_fn(struct db_record
*rec
, void *private_data
)
267 struct serverid_traverse_state
*state
=
268 (struct serverid_traverse_state
*)private_data
;
272 if (!serverid_rec_parse(rec
, &id
, &msg_flags
)) {
275 return state
->fn(rec
, &id
, msg_flags
, state
->private_data
);
278 bool serverid_traverse(int (*fn
)(struct db_record
*rec
,
279 const struct server_id
*id
,
280 uint32_t msg_flags
, void *private_data
),
283 struct db_context
*db
;
284 struct serverid_traverse_state state
;
291 state
.private_data
= private_data
;
292 return db
->traverse(db
, serverid_traverse_fn
, &state
);