s4:gensec/gssapi: use gensec_gssapi_max_{input,wrapped}_size() for all backends
[Samba.git] / lib / util / server_id_db.c
blob7f5b055f1715fc6ead2cdb056293328c62b44c21
1 /*
2 * Map names to server_ids
4 * Copyright Volker Lendecke <vl@samba.org> 2014
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/>.
20 #include "replace.h"
21 #include "system/filesys.h"
22 #include "lib/util/server_id_db.h"
23 #include "lib/tdb_wrap/tdb_wrap.h"
24 #include "lib/util/strv.h"
25 #include "lib/util/util_tdb.h"
26 #include "lib/util/samba_util.h"
28 static TDB_DATA talloc_tdb_data(void *ptr)
30 return (TDB_DATA) { .dptr = ptr, .dsize = talloc_get_size(ptr) };
33 struct server_id_db {
34 struct server_id pid;
35 struct tdb_wrap *tdb;
36 char *names;
39 static int server_id_db_destructor(struct server_id_db *db);
41 struct server_id_db *server_id_db_init(TALLOC_CTX *mem_ctx,
42 struct server_id pid,
43 const char *base_path,
44 int hash_size, int tdb_flags)
46 struct server_id_db *db;
47 size_t pathlen = strlen(base_path) + 11;
48 char path[pathlen];
50 db = talloc(mem_ctx, struct server_id_db);
51 if (db == NULL) {
52 return NULL;
54 db->pid = pid;
55 db->names = NULL;
57 snprintf(path, pathlen, "%s/names.tdb", base_path);
59 db->tdb = tdb_wrap_open(db, path, hash_size, tdb_flags,
60 O_RDWR|O_CREAT, 0660);
61 if (db->tdb == NULL) {
62 TALLOC_FREE(db);
63 return NULL;
66 talloc_set_destructor(db, server_id_db_destructor);
68 return db;
71 void server_id_db_reinit(struct server_id_db *db, struct server_id pid)
73 db->pid = pid;
74 TALLOC_FREE(db->names);
77 static int server_id_db_destructor(struct server_id_db *db)
79 char *name = NULL;
81 while ((name = strv_next(db->names, name)) != NULL) {
82 server_id_db_remove(db, name);
85 return 0;
88 int server_id_db_add(struct server_id_db *db, const char *name)
90 struct tdb_context *tdb = db->tdb->tdb;
91 struct server_id_buf buf;
92 TDB_DATA key, data;
93 char *n;
94 int ret;
96 n = strv_find(db->names, name);
97 if (n != NULL) {
98 return EEXIST;
101 ret = strv_add(db, &db->names, name);
102 if (ret != 0) {
103 return ret;
106 key = string_term_tdb_data(name);
108 server_id_str_buf(db->pid, &buf);
109 data = string_term_tdb_data(buf.buf);
111 ret = tdb_append(tdb, key, data);
112 if (ret != 0) {
113 enum TDB_ERROR err = tdb_error(tdb);
114 strv_delete(&db->names, strv_find(db->names, name));
115 return map_unix_error_from_tdb(err);
118 return 0;
121 int server_id_db_remove(struct server_id_db *db, const char *name)
123 struct tdb_context *tdb = db->tdb->tdb;
124 struct server_id_buf buf;
125 TDB_DATA key;
126 uint8_t *data;
127 char *ids, *n, *id;
128 int ret;
130 n = strv_find(db->names, name);
131 if (n == NULL) {
132 return ENOENT;
135 key = string_term_tdb_data(name);
136 server_id_str_buf(db->pid, &buf);
138 ret = tdb_chainlock(tdb, key);
139 if (ret == -1) {
140 enum TDB_ERROR err = tdb_error(tdb);
141 return map_unix_error_from_tdb(err);
144 ret = tdb_fetch_talloc(tdb, key, db, &data);
145 if (ret != 0) {
146 tdb_chainunlock(tdb, key);
147 return ret;
150 ids = (char *)data;
152 id = strv_find(ids, buf.buf);
153 if (id == NULL) {
154 tdb_chainunlock(tdb, key);
155 TALLOC_FREE(data);
156 return ENOENT;
159 strv_delete(&ids, id);
160 ret = tdb_store(tdb, key, talloc_tdb_data(ids), TDB_MODIFY);
161 TALLOC_FREE(data);
163 tdb_chainunlock(tdb, key);
165 if (ret == -1) {
166 enum TDB_ERROR err = tdb_error(tdb);
167 return map_unix_error_from_tdb(err);
170 strv_delete(&db->names, n);
171 return 0;
174 int server_id_db_lookup(struct server_id_db *db, const char *name,
175 TALLOC_CTX *mem_ctx, unsigned *pnum_servers,
176 struct server_id **pservers)
178 struct tdb_context *tdb = db->tdb->tdb;
179 TDB_DATA key;
180 uint8_t *data;
181 char *ids, *id;
182 unsigned num_servers;
183 struct server_id *servers;
184 int i, ret;
186 key = string_term_tdb_data(name);
188 ret = tdb_fetch_talloc(tdb, key, mem_ctx, &data);
189 if (ret != 0) {
190 return ret;
193 ids = (char *)data;
194 num_servers = strv_count(ids);
196 servers = talloc_array(mem_ctx, struct server_id, num_servers);
197 if (servers == NULL) {
198 TALLOC_FREE(data);
199 return ENOMEM;
202 i = 0;
204 for (id = ids; id != NULL; id = strv_next(ids, id)) {
205 servers[i++] = server_id_from_string(NONCLUSTER_VNN, id);
208 TALLOC_FREE(data);
210 *pnum_servers = num_servers;
211 *pservers = servers;
213 return 0;
216 bool server_id_db_lookup_one(struct server_id_db *db, const char *name,
217 struct server_id *server)
219 int ret;
220 unsigned num_servers;
221 struct server_id *servers;
223 ret = server_id_db_lookup(db, name, db, &num_servers, &servers);
224 if (ret != 0) {
225 return false;
227 if (num_servers == 0) {
228 TALLOC_FREE(servers);
229 return false;
231 *server = servers[0];
232 TALLOC_FREE(servers);
233 return true;
236 struct server_id_db_traverse_state {
237 TALLOC_CTX *mem_ctx;
238 int (*fn)(const char *name,
239 unsigned num_servers,
240 const struct server_id *servers,
241 void *private_data);
242 void *private_data;
245 static int server_id_db_traverse_fn(struct tdb_context *tdb,
246 TDB_DATA key, TDB_DATA data,
247 void *private_data)
249 struct server_id_db_traverse_state *state = private_data;
250 const char *name;
251 char *ids, *id;
252 unsigned num_servers;
253 struct server_id *servers;
254 int i, ret;
256 if (key.dsize == 0) {
257 return 0;
259 if (key.dptr[key.dsize-1] != '\0') {
260 return 0;
262 name = (const char *)key.dptr;
264 ids = (char *)talloc_memdup(state->mem_ctx, data.dptr, data.dsize);
265 if (ids == NULL) {
266 return 0;
269 num_servers = strv_count(ids);
270 servers = talloc_array(ids, struct server_id, num_servers);
272 i = 0;
274 for (id = ids; id != NULL; id = strv_next(ids, id)) {
275 servers[i++] = server_id_from_string(NONCLUSTER_VNN, id);
278 ret = state->fn(name, num_servers, servers, state->private_data);
280 TALLOC_FREE(ids);
282 return ret;
285 int server_id_db_traverse_read(struct server_id_db *db,
286 int (*fn)(const char *name,
287 unsigned num_servers,
288 const struct server_id *servers,
289 void *private_data),
290 void *private_data)
292 struct server_id_db_traverse_state state;
293 int ret;
295 state = (struct server_id_db_traverse_state) {
296 .fn = fn, .private_data = private_data,
297 .mem_ctx = talloc_new(db)
300 if (state.mem_ctx == NULL) {
301 return ENOMEM;
304 ret = tdb_traverse_read(db->tdb->tdb, server_id_db_traverse_fn,
305 &state);
306 TALLOC_FREE(state.mem_ctx);
307 return ret;