lib: Add lib/util/server_id.h
[kai/samba-autobuild/.git] / lib / util / server_id_db.c
1 /*
2  * Map names to server_ids
3  *
4  * Copyright Volker Lendecke <vl@samba.org> 2014
5  *
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.
10  *
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.
15  *
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/>.
18  */
19
20 #include "replace.h"
21 #include "system/filesys.h"
22 #include "lib/util/server_id.h"
23 #include "lib/util/server_id_db.h"
24 #include "lib/tdb_wrap/tdb_wrap.h"
25 #include "lib/util/strv.h"
26 #include "lib/util/util_tdb.h"
27 #include "lib/util/samba_util.h"
28
29 static TDB_DATA talloc_tdb_data(void *ptr)
30 {
31         return (TDB_DATA) { .dptr = ptr, .dsize = talloc_get_size(ptr) };
32 }
33
34 struct server_id_db {
35         struct server_id pid;
36         struct tdb_wrap *tdb;
37         char *names;
38 };
39
40 static int server_id_db_destructor(struct server_id_db *db);
41
42 struct server_id_db *server_id_db_init(TALLOC_CTX *mem_ctx,
43                                        struct server_id pid,
44                                        const char *base_path,
45                                        int hash_size, int tdb_flags)
46 {
47         struct server_id_db *db;
48         size_t pathlen = strlen(base_path) + 11;
49         char path[pathlen];
50
51         db = talloc(mem_ctx, struct server_id_db);
52         if (db == NULL) {
53                 return NULL;
54         }
55         db->pid = pid;
56         db->names = NULL;
57
58         snprintf(path, pathlen, "%s/names.tdb", base_path);
59
60         db->tdb = tdb_wrap_open(db, path, hash_size, tdb_flags,
61                                 O_RDWR|O_CREAT, 0660);
62         if (db->tdb == NULL) {
63                 TALLOC_FREE(db);
64                 return NULL;
65         }
66
67         talloc_set_destructor(db, server_id_db_destructor);
68
69         return db;
70 }
71
72 void server_id_db_reinit(struct server_id_db *db, struct server_id pid)
73 {
74         db->pid = pid;
75         TALLOC_FREE(db->names);
76 }
77
78 struct server_id server_id_db_pid(struct server_id_db *db)
79 {
80         return db->pid;
81 }
82
83 static int server_id_db_destructor(struct server_id_db *db)
84 {
85         char *name = NULL;
86
87         while ((name = strv_next(db->names, name)) != NULL) {
88                 server_id_db_remove(db, name);
89         }
90
91         return 0;
92 }
93
94 int server_id_db_add(struct server_id_db *db, const char *name)
95 {
96         struct tdb_context *tdb = db->tdb->tdb;
97         TDB_DATA key;
98         char *n;
99         int ret;
100
101         n = strv_find(db->names, name);
102         if (n != NULL) {
103                 return EEXIST;
104         }
105
106         ret = strv_add(db, &db->names, name);
107         if (ret != 0) {
108                 return ret;
109         }
110
111         key = string_term_tdb_data(name);
112
113         {
114                 size_t idlen = server_id_str_buf_unique(db->pid, NULL, 0);
115                 char idbuf[idlen];
116
117                 server_id_str_buf_unique(db->pid, idbuf, idlen);
118
119                 ret = tdb_append(
120                         tdb, key,
121                         (TDB_DATA) { .dptr = (uint8_t *)idbuf, .dsize = idlen });
122         }
123
124         if (ret != 0) {
125                 enum TDB_ERROR err = tdb_error(tdb);
126                 strv_delete(&db->names, strv_find(db->names, name));
127                 return map_unix_error_from_tdb(err);
128         }
129
130         return 0;
131 }
132
133 int server_id_db_prune_name(struct server_id_db *db, const char *name,
134                             struct server_id server)
135 {
136         struct tdb_context *tdb = db->tdb->tdb;
137         size_t idbuf_len = server_id_str_buf_unique(server, NULL, 0);
138         char idbuf[idbuf_len];
139         TDB_DATA key;
140         uint8_t *data;
141         char *ids, *id;
142         int ret;
143
144         key = string_term_tdb_data(name);
145         server_id_str_buf_unique(server, idbuf, idbuf_len);
146
147         ret = tdb_chainlock(tdb, key);
148         if (ret == -1) {
149                 enum TDB_ERROR err = tdb_error(tdb);
150                 return map_unix_error_from_tdb(err);
151         }
152
153         ret = tdb_fetch_talloc(tdb, key, db, &data);
154         if (ret != 0) {
155                 tdb_chainunlock(tdb, key);
156                 return ret;
157         }
158
159         ids = (char *)data;
160
161         id = strv_find(ids, idbuf);
162         if (id == NULL) {
163                 tdb_chainunlock(tdb, key);
164                 TALLOC_FREE(data);
165                 return ENOENT;
166         }
167
168         strv_delete(&ids, id);
169         ret = tdb_store(tdb, key, talloc_tdb_data(ids), TDB_MODIFY);
170         TALLOC_FREE(data);
171
172         tdb_chainunlock(tdb, key);
173
174         return 0;
175 }
176
177 int server_id_db_remove(struct server_id_db *db, const char *name)
178 {
179         char *n;
180         int ret;
181
182         n = strv_find(db->names, name);
183         if (n == NULL) {
184                 return ENOENT;
185         }
186
187         ret = server_id_db_prune_name(db, name, db->pid);
188         if (ret != 0) {
189                 return ret;
190         }
191
192         strv_delete(&db->names, n);
193         return 0;
194 }
195
196 int server_id_db_lookup(struct server_id_db *db, const char *name,
197                         TALLOC_CTX *mem_ctx, unsigned *pnum_servers,
198                         struct server_id **pservers)
199 {
200         struct tdb_context *tdb = db->tdb->tdb;
201         TDB_DATA key;
202         uint8_t *data;
203         char *ids, *id;
204         unsigned num_servers;
205         struct server_id *servers;
206         int i, ret;
207
208         key = string_term_tdb_data(name);
209
210         ret = tdb_fetch_talloc(tdb, key, mem_ctx, &data);
211         if (ret != 0) {
212                 return ret;
213         }
214
215         ids = (char *)data;
216         num_servers = strv_count(ids);
217
218         servers = talloc_array(mem_ctx, struct server_id, num_servers);
219         if (servers == NULL) {
220                 TALLOC_FREE(data);
221                 return ENOMEM;
222         }
223
224         i = 0;
225
226         for (id = ids; id != NULL; id = strv_next(ids, id)) {
227                 servers[i++] = server_id_from_string(NONCLUSTER_VNN, id);
228         }
229
230         TALLOC_FREE(data);
231
232         *pnum_servers = num_servers;
233         *pservers = servers;
234
235         return 0;
236 }
237
238 bool server_id_db_lookup_one(struct server_id_db *db, const char *name,
239                              struct server_id *server)
240 {
241         int ret;
242         unsigned num_servers;
243         struct server_id *servers;
244
245         ret = server_id_db_lookup(db, name, db, &num_servers, &servers);
246         if (ret != 0) {
247                 return false;
248         }
249         if (num_servers == 0) {
250                 TALLOC_FREE(servers);
251                 return false;
252         }
253         *server = servers[0];
254         TALLOC_FREE(servers);
255         return true;
256 }
257
258 struct server_id_db_traverse_state {
259         TALLOC_CTX *mem_ctx;
260         int (*fn)(const char *name,
261                   unsigned num_servers,
262                   const struct server_id *servers,
263                   void *private_data);
264         void *private_data;
265 };
266
267 static int server_id_db_traverse_fn(struct tdb_context *tdb,
268                                     TDB_DATA key, TDB_DATA data,
269                                     void *private_data)
270 {
271         struct server_id_db_traverse_state *state = private_data;
272         const char *name;
273         char *ids, *id;
274         unsigned num_servers;
275         struct server_id *servers;
276         int i, ret;
277
278         if (key.dsize == 0) {
279                 return 0;
280         }
281         if (key.dptr[key.dsize-1] != '\0') {
282                 return 0;
283         }
284         name = (const char *)key.dptr;
285
286         ids = (char *)talloc_memdup(state->mem_ctx, data.dptr, data.dsize);
287         if (ids == NULL) {
288                 return 0;
289         }
290
291         num_servers = strv_count(ids);
292         servers = talloc_array(ids, struct server_id, num_servers);
293
294         i = 0;
295
296         for (id = ids; id != NULL; id = strv_next(ids, id)) {
297                 servers[i++] = server_id_from_string(NONCLUSTER_VNN, id);
298         }
299
300         ret = state->fn(name, num_servers, servers, state->private_data);
301
302         TALLOC_FREE(ids);
303
304         return ret;
305 }
306
307 int server_id_db_traverse_read(struct server_id_db *db,
308                                int (*fn)(const char *name,
309                                          unsigned num_servers,
310                                          const struct server_id *servers,
311                                          void *private_data),
312                                void *private_data)
313 {
314         struct server_id_db_traverse_state state;
315         int ret;
316
317         state = (struct server_id_db_traverse_state) {
318                 .fn = fn, .private_data = private_data,
319                 .mem_ctx = talloc_new(db)
320         };
321
322         if (state.mem_ctx == NULL) {
323                 return ENOMEM;
324         }
325
326         ret = tdb_traverse_read(db->tdb->tdb, server_id_db_traverse_fn,
327                                 &state);
328         TALLOC_FREE(state.mem_ctx);
329         return ret;
330 }