source3/lib/serverid.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Implementation of a reliable server_exists()
   4    Copyright (C) Volker Lendecke 2010
   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 "includes.h"
  21 #include "system/filesys.h"
  22 #include "serverid.h"
  23 #include "util_tdb.h"
  24 #include "dbwrap.h"
  25 #include "lib/util/tdb_wrap.h"
  26
  27 struct serverid_key {
  28         pid_t pid;
  29         uint32_t vnn;
  30 };
  31
  32 struct serverid_data {
  33         uint64_t unique_id;
  34         uint32_t msg_flags;
  35 };
  36
  37 static struct db_context *db_ptr = NULL;
  38
  39 static struct db_context *serverid_init(TALLOC_CTX *mem_ctx)
  40 {
  41         db_ptr = db_open(mem_ctx, lock_path("serverid.tdb"),
  42                          0, TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
  43                          O_RDWR | O_CREAT,
  44                          0644);
  45         return db_ptr;
  46 }
  47
  48 bool serverid_parent_init(TALLOC_CTX *mem_ctx)
  49 {
  50         /*
  51          * Open the tdb in the parent process (smbd) so that our
  52          * CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
  53          * work.
  54          */
  55
  56         if (serverid_init(mem_ctx) == NULL) {
  57                 DEBUG(1, ("could not open serverid.tdb: %s\n",
  58                           strerror(errno)));
  59                 return false;
  60         }
  61
  62         return true;
  63 }
  64
  65 static struct db_context *serverid_db(void)
  66 {
  67         if (db_ptr != NULL) {
  68                 return db_ptr;
  69         }
  70
  71         return serverid_init(NULL);
  72 }
  73
  74 static void serverid_fill_key(const struct server_id *id,
  75                               struct serverid_key *key)
  76 {
  77         ZERO_STRUCTP(key);
  78         key->pid = id->pid;
  79         key->vnn = id->vnn;
  80 }
  81
  82 bool serverid_register(const struct server_id id, uint32_t msg_flags)
  83 {
  84         struct db_context *db;
  85         struct serverid_key key;
  86         struct serverid_data data;
  87         struct db_record *rec;
  88         TDB_DATA tdbkey, tdbdata;
  89         NTSTATUS status;
  90         bool ret = false;
  91
  92         db = serverid_db();
  93         if (db == NULL) {
  94                 return false;
  95         }
  96
  97         serverid_fill_key(&id, &key);
  98         tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
  99
 100         rec = db->fetch_locked(db, talloc_tos(), tdbkey);
 101         if (rec == NULL) {
 102                 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
 103                 return false;
 104         }
 105
 106         ZERO_STRUCT(data);
 107         data.unique_id = id.unique_id;
 108         data.msg_flags = msg_flags;
 109
 110         tdbdata = make_tdb_data((uint8_t *)&data, sizeof(data));
 111         status = rec->store(rec, tdbdata, 0);
 112         if (!NT_STATUS_IS_OK(status)) {
 113                 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
 114                           nt_errstr(status)));
 115                 goto done;
 116         }
 117         ret = true;
 118 done:
 119         TALLOC_FREE(rec);
 120         return ret;
 121 }
 122
 123 bool serverid_register_msg_flags(const struct server_id id, bool do_reg,
 124                                  uint32_t msg_flags)
 125 {
 126         struct db_context *db;
 127         struct serverid_key key;
 128         struct serverid_data *data;
 129         struct db_record *rec;
 130         TDB_DATA tdbkey;
 131         NTSTATUS status;
 132         bool ret = false;
 133
 134         db = serverid_db();
 135         if (db == NULL) {
 136                 return false;
 137         }
 138
 139         serverid_fill_key(&id, &key);
 140         tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
 141
 142         rec = db->fetch_locked(db, talloc_tos(), tdbkey);
 143         if (rec == NULL) {
 144                 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
 145                 return false;
 146         }
 147
 148         if (rec->value.dsize != sizeof(struct serverid_data)) {
 149                 DEBUG(1, ("serverid record has unexpected size %d "
 150                           "(wanted %d)\n", (int)rec->value.dsize,
 151                           (int)sizeof(struct serverid_data)));
 152                 goto done;
 153         }
 154
 155         data = (struct serverid_data *)rec->value.dptr;
 156
 157         if (do_reg) {
 158                 data->msg_flags |= msg_flags;
 159         } else {
 160                 data->msg_flags &= ~msg_flags;
 161         }
 162
 163         status = rec->store(rec, rec->value, 0);
 164         if (!NT_STATUS_IS_OK(status)) {
 165                 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
 166                           nt_errstr(status)));
 167                 goto done;
 168         }
 169         ret = true;
 170 done:
 171         TALLOC_FREE(rec);
 172         return ret;
 173 }
 174
 175 bool serverid_deregister(struct server_id id)
 176 {
 177         struct db_context *db;
 178         struct serverid_key key;
 179         struct db_record *rec;
 180         TDB_DATA tdbkey;
 181         NTSTATUS status;
 182         bool ret = false;
 183
 184         db = serverid_db();
 185         if (db == NULL) {
 186                 return false;
 187         }
 188
 189         serverid_fill_key(&id, &key);
 190         tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
 191
 192         rec = db->fetch_locked(db, talloc_tos(), tdbkey);
 193         if (rec == NULL) {
 194                 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
 195                 return false;
 196         }
 197
 198         status = rec->delete_rec(rec);
 199         if (!NT_STATUS_IS_OK(status)) {
 200                 DEBUG(1, ("Deleting serverid.tdb record failed: %s\n",
 201                           nt_errstr(status)));
 202                 goto done;
 203         }
 204         ret = true;
 205 done:
 206         TALLOC_FREE(rec);
 207         return ret;
 208 }
 209
 210 struct serverid_exists_state {
 211         const struct server_id *id;
 212         bool exists;
 213 };
 214
 215 static int server_exists_parse(TDB_DATA key, TDB_DATA data, void *priv)
 216 {
 217         struct serverid_exists_state *state =
 218                 (struct serverid_exists_state *)priv;
 219
 220         if (data.dsize != sizeof(struct serverid_data)) {
 221                 return -1;
 222         }
 223
 224         /*
 225          * Use memcmp, not direct compare. data.dptr might not be
 226          * aligned.
 227          */
 228         state->exists = (memcmp(&state->id->unique_id, data.dptr,
 229                                 sizeof(state->id->unique_id)) == 0);
 230         return 0;
 231 }
 232
 233 bool serverid_exists(const struct server_id *id)
 234 {
 235         struct db_context *db;
 236         struct serverid_exists_state state;
 237         struct serverid_key key;
 238         TDB_DATA tdbkey;
 239
 240         if (procid_is_me(id)) {
 241                 return true;
 242         }
 243
 244         if (!process_exists(*id)) {
 245                 return false;
 246         }
 247
 248         if (id->unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
 249                 return true;
 250         }
 251
 252         db = serverid_db();
 253         if (db == NULL) {
 254                 return false;
 255         }
 256
 257         serverid_fill_key(id, &key);
 258         tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
 259
 260         state.id = id;
 261         state.exists = false;
 262
 263         if (db->parse_record(db, tdbkey, server_exists_parse, &state) == -1) {
 264                 return false;
 265         }
 266         return state.exists;
 267 }
 268
 269 static bool serverid_rec_parse(const struct db_record *rec,
 270                                struct server_id *id, uint32_t *msg_flags)
 271 {
 272         struct serverid_key key;
 273         struct serverid_data data;
 274
 275         if (rec->key.dsize != sizeof(key)) {
 276                 DEBUG(1, ("Found invalid key length %d in serverid.tdb\n",
 277                           (int)rec->key.dsize));
 278                 return false;
 279         }
 280         if (rec->value.dsize != sizeof(data)) {
 281                 DEBUG(1, ("Found invalid value length %d in serverid.tdb\n",
 282                           (int)rec->value.dsize));
 283                 return false;
 284         }
 285
 286         memcpy(&key, rec->key.dptr, sizeof(key));
 287         memcpy(&data, rec->value.dptr, sizeof(data));
 288
 289         id->pid = key.pid;
 290         id->vnn = key.vnn;
 291         id->unique_id = data.unique_id;
 292         *msg_flags = data.msg_flags;
 293         return true;
 294 }
 295
 296 struct serverid_traverse_read_state {
 297         int (*fn)(const struct server_id *id, uint32_t msg_flags,
 298                   void *private_data);
 299         void *private_data;
 300 };
 301
 302 static int serverid_traverse_read_fn(struct db_record *rec, void *private_data)
 303 {
 304         struct serverid_traverse_read_state *state =
 305                 (struct serverid_traverse_read_state *)private_data;
 306         struct server_id id;
 307         uint32_t msg_flags;
 308
 309         if (!serverid_rec_parse(rec, &id, &msg_flags)) {
 310                 return 0;
 311         }
 312         return state->fn(&id, msg_flags,state->private_data);
 313 }
 314
 315 bool serverid_traverse_read(int (*fn)(const struct server_id *id,
 316                                       uint32_t msg_flags, void *private_data),
 317                             void *private_data)
 318 {
 319         struct db_context *db;
 320         struct serverid_traverse_read_state state;
 321
 322         db = serverid_db();
 323         if (db == NULL) {
 324                 return false;
 325         }
 326         state.fn = fn;
 327         state.private_data = private_data;
 328         return db->traverse_read(db, serverid_traverse_read_fn, &state);
 329 }
 330
 331 struct serverid_traverse_state {
 332         int (*fn)(struct db_record *rec, const struct server_id *id,
 333                   uint32_t msg_flags, void *private_data);
 334         void *private_data;
 335 };
 336
 337 static int serverid_traverse_fn(struct db_record *rec, void *private_data)
 338 {
 339         struct serverid_traverse_state *state =
 340                 (struct serverid_traverse_state *)private_data;
 341         struct server_id id;
 342         uint32_t msg_flags;
 343
 344         if (!serverid_rec_parse(rec, &id, &msg_flags)) {
 345                 return 0;
 346         }
 347         return state->fn(rec, &id, msg_flags, state->private_data);
 348 }
 349
 350 bool serverid_traverse(int (*fn)(struct db_record *rec,
 351                                  const struct server_id *id,
 352                                  uint32_t msg_flags, void *private_data),
 353                             void *private_data)
 354 {
 355         struct db_context *db;
 356         struct serverid_traverse_state state;
 357
 358         db = serverid_db();
 359         if (db == NULL) {
 360                 return false;
 361         }
 362         state.fn = fn;
 363         state.private_data = private_data;
 364         return db->traverse(db, serverid_traverse_fn, &state);
 365 }
 366
 367 uint64_t serverid_get_random_unique_id(void)
 368 {
 369         uint64_t unique_id = SERVERID_UNIQUE_ID_NOT_TO_VERIFY;
 370
 371         while (unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
 372                 generate_random_buffer((uint8_t *)&unique_id,
 373                                         sizeof(unique_id));
 374         }
 375
 376         return unique_id;
 377 }