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/dbwrap.h"
  25 #include "dbwrap/dbwrap_open.h"
  26 #include "lib/tdb_wrap/tdb_wrap.h"
  27 #include "lib/param/param.h"
  28 #include "ctdbd_conn.h"
  29 #include "messages.h"
  30
  31 struct serverid_key {
  32         pid_t pid;
  33         uint32_t task_id;
  34         uint32_t vnn;
  35 };
  36
  37 struct serverid_data {
  38         uint64_t unique_id;
  39         uint32_t msg_flags;
  40 };
  41
  42 bool serverid_parent_init(TALLOC_CTX *mem_ctx)
  43 {
  44         struct tdb_wrap *db;
  45         struct loadparm_context *lp_ctx;
  46
  47         lp_ctx = loadparm_init_s3(mem_ctx, loadparm_s3_helpers());
  48         if (lp_ctx == NULL) {
  49                 DEBUG(0, ("loadparm_init_s3 failed\n"));
  50                 return false;
  51         }
  52
  53         /*
  54          * Open the tdb in the parent process (smbd) so that our
  55          * CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
  56          * work.
  57          */
  58
  59         db = tdb_wrap_open(mem_ctx, lock_path("serverid.tdb"),
  60                            0, TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDWR|O_CREAT,
  61                            0644, lp_ctx);
  62         talloc_unlink(mem_ctx, lp_ctx);
  63         if (db == NULL) {
  64                 DEBUG(1, ("could not open serverid.tdb: %s\n",
  65                           strerror(errno)));
  66                 return false;
  67         }
  68         return true;
  69 }
  70
  71 static struct db_context *serverid_db(void)
  72 {
  73         static struct db_context *db;
  74
  75         if (db != NULL) {
  76                 return db;
  77         }
  78         db = db_open(NULL, lock_path("serverid.tdb"), 0,
  79                      TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
  80                      O_RDWR|O_CREAT, 0644, DBWRAP_LOCK_ORDER_2);
  81         return db;
  82 }
  83
  84 static void serverid_fill_key(const struct server_id *id,
  85                               struct serverid_key *key)
  86 {
  87         ZERO_STRUCTP(key);
  88         key->pid = id->pid;
  89         key->task_id = id->task_id;
  90         key->vnn = id->vnn;
  91 }
  92
  93 bool serverid_register(const struct server_id id, uint32_t msg_flags)
  94 {
  95         struct db_context *db;
  96         struct serverid_key key;
  97         struct serverid_data data;
  98         struct db_record *rec;
  99         TDB_DATA tdbkey, tdbdata;
 100         NTSTATUS status;
 101         bool ret = false;
 102
 103         db = serverid_db();
 104         if (db == NULL) {
 105                 return false;
 106         }
 107
 108         serverid_fill_key(&id, &key);
 109         tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
 110
 111         rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey);
 112         if (rec == NULL) {
 113                 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
 114                 return false;
 115         }
 116
 117         ZERO_STRUCT(data);
 118         data.unique_id = id.unique_id;
 119         data.msg_flags = msg_flags;
 120
 121         tdbdata = make_tdb_data((uint8_t *)&data, sizeof(data));
 122         status = dbwrap_record_store(rec, tdbdata, 0);
 123         if (!NT_STATUS_IS_OK(status)) {
 124                 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
 125                           nt_errstr(status)));
 126                 goto done;
 127         }
 128 #ifdef HAVE_CTDB_CONTROL_CHECK_SRVIDS_DECL
 129         if (lp_clustering()) {
 130                 register_with_ctdbd(messaging_ctdbd_connection(), id.unique_id);
 131         }
 132 #endif
 133         ret = true;
 134 done:
 135         TALLOC_FREE(rec);
 136         return ret;
 137 }
 138
 139 bool serverid_register_msg_flags(const struct server_id id, bool do_reg,
 140                                  uint32_t msg_flags)
 141 {
 142         struct db_context *db;
 143         struct serverid_key key;
 144         struct serverid_data *data;
 145         struct db_record *rec;
 146         TDB_DATA tdbkey;
 147         TDB_DATA value;
 148         NTSTATUS status;
 149         bool ret = false;
 150
 151         db = serverid_db();
 152         if (db == NULL) {
 153                 return false;
 154         }
 155
 156         serverid_fill_key(&id, &key);
 157         tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
 158
 159         rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey);
 160         if (rec == NULL) {
 161                 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
 162                 return false;
 163         }
 164
 165         value = dbwrap_record_get_value(rec);
 166
 167         if (value.dsize != sizeof(struct serverid_data)) {
 168                 DEBUG(1, ("serverid record has unexpected size %d "
 169                           "(wanted %d)\n", (int)value.dsize,
 170                           (int)sizeof(struct serverid_data)));
 171                 goto done;
 172         }
 173
 174         data = (struct serverid_data *)value.dptr;
 175
 176         if (do_reg) {
 177                 data->msg_flags |= msg_flags;
 178         } else {
 179                 data->msg_flags &= ~msg_flags;
 180         }
 181
 182         status = dbwrap_record_store(rec, value, 0);
 183         if (!NT_STATUS_IS_OK(status)) {
 184                 DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
 185                           nt_errstr(status)));
 186                 goto done;
 187         }
 188         ret = true;
 189 done:
 190         TALLOC_FREE(rec);
 191         return ret;
 192 }
 193
 194 bool serverid_deregister(struct server_id id)
 195 {
 196         struct db_context *db;
 197         struct serverid_key key;
 198         struct db_record *rec;
 199         TDB_DATA tdbkey;
 200         NTSTATUS status;
 201         bool ret = false;
 202
 203         db = serverid_db();
 204         if (db == NULL) {
 205                 return false;
 206         }
 207
 208         serverid_fill_key(&id, &key);
 209         tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
 210
 211         rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey);
 212         if (rec == NULL) {
 213                 DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
 214                 return false;
 215         }
 216
 217         status = dbwrap_record_delete(rec);
 218         if (!NT_STATUS_IS_OK(status)) {
 219                 DEBUG(1, ("Deleting serverid.tdb record failed: %s\n",
 220                           nt_errstr(status)));
 221                 goto done;
 222         }
 223         ret = true;
 224 done:
 225         TALLOC_FREE(rec);
 226         return ret;
 227 }
 228
 229 struct serverid_exists_state {
 230         const struct server_id *id;
 231         bool exists;
 232 };
 233
 234 static void server_exists_parse(TDB_DATA key, TDB_DATA data, void *priv)
 235 {
 236         struct serverid_exists_state *state =
 237                 (struct serverid_exists_state *)priv;
 238
 239         if (data.dsize != sizeof(struct serverid_data)) {
 240                 state->exists = false;
 241                 return;
 242         }
 243
 244         /*
 245          * Use memcmp, not direct compare. data.dptr might not be
 246          * aligned.
 247          */
 248         state->exists = (memcmp(&state->id->unique_id, data.dptr,
 249                                 sizeof(state->id->unique_id)) == 0);
 250 }
 251
 252 bool serverid_exists(const struct server_id *id)
 253 {
 254         bool result = false;
 255         bool ok = false;
 256
 257         ok = serverids_exist(id, 1, &result);
 258         if (!ok) {
 259                 return false;
 260         }
 261
 262         return result;
 263 }
 264
 265 bool serverids_exist(const struct server_id *ids, int num_ids, bool *results)
 266 {
 267         int *todo_idx = NULL;
 268         struct server_id *todo_ids = NULL;
 269         bool *todo_results = NULL;
 270         int todo_num = 0;
 271         int *remote_idx = NULL;
 272         int remote_num = 0;
 273         int *verify_idx = NULL;
 274         int verify_num = 0;
 275         int t, idx;
 276         bool result = false;
 277         struct db_context *db;
 278
 279         db = serverid_db();
 280         if (db == NULL) {
 281                 return false;
 282         }
 283
 284         todo_idx = talloc_array(talloc_tos(), int, num_ids);
 285         if (todo_idx == NULL) {
 286                 goto fail;
 287         }
 288         todo_ids = talloc_array(talloc_tos(), struct server_id, num_ids);
 289         if (todo_ids == NULL) {
 290                 goto fail;
 291         }
 292         todo_results = talloc_array(talloc_tos(), bool, num_ids);
 293         if (todo_results == NULL) {
 294                 goto fail;
 295         }
 296
 297         remote_idx = talloc_array(talloc_tos(), int, num_ids);
 298         if (remote_idx == NULL) {
 299                 goto fail;
 300         }
 301         verify_idx = talloc_array(talloc_tos(), int, num_ids);
 302         if (verify_idx == NULL) {
 303                 goto fail;
 304         }
 305
 306         for (idx=0; idx<num_ids; idx++) {
 307                 results[idx] = false;
 308
 309                 if (server_id_is_disconnected(&ids[idx])) {
 310                         continue;
 311                 }
 312
 313                 if (procid_is_me(&ids[idx])) {
 314                         results[idx] = true;
 315                         continue;
 316                 }
 317
 318                 if (procid_is_local(&ids[idx])) {
 319                         bool exists = process_exists_by_pid(ids[idx].pid);
 320
 321                         if (!exists) {
 322                                 continue;
 323                         }
 324
 325                         if (ids[idx].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
 326                                 results[idx] = true;
 327                                 continue;
 328                         }
 329
 330                         verify_idx[verify_num] = idx;
 331                         verify_num += 1;
 332                         continue;
 333                 }
 334
 335                 if (!lp_clustering()) {
 336                         continue;
 337                 }
 338
 339                 remote_idx[remote_num] = idx;
 340                 remote_num += 1;
 341         }
 342
 343 #ifdef HAVE_CTDB_CONTROL_CHECK_SRVIDS_DECL
 344         if (remote_num != 0) {
 345                 int old_remote_num = remote_num;
 346
 347                 remote_num = 0;
 348                 todo_num = 0;
 349
 350                 for (t=0; t<old_remote_num; t++) {
 351                         idx = remote_idx[t];
 352
 353                         if (ids[idx].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
 354                                 remote_idx[remote_num] = idx;
 355                                 remote_num += 1;
 356                                 continue;
 357                         }
 358
 359                         todo_idx[todo_num] = idx;
 360                         todo_ids[todo_num] = ids[idx];
 361                         todo_results[todo_num] = false;
 362                         todo_num += 1;
 363                 }
 364
 365                 /*
 366                  * Note: this only uses CTDB_CONTROL_CHECK_SRVIDS
 367                  * to verify that the server_id still exists,
 368                  * which means only the server_id.unique_id and
 369                  * server_id.vnn are verified, while server_id.pid
 370                  * is not verified at all.
 371                  *
 372                  * TODO: do we want to verify server_id.pid somehow?
 373                  */
 374                 if (!ctdb_serverids_exist(messaging_ctdbd_connection(),
 375                                           todo_ids, todo_num, todo_results))
 376                 {
 377                         goto fail;
 378                 }
 379
 380                 for (t=0; t<todo_num; t++) {
 381                         idx = todo_idx[t];
 382
 383                         results[idx] = todo_results[t];
 384                 }
 385         }
 386 #endif
 387
 388         if (remote_num != 0) {
 389                 todo_num = 0;
 390
 391                 for (t=0; t<remote_num; t++) {
 392                         idx = remote_idx[t];
 393                         todo_idx[todo_num] = idx;
 394                         todo_ids[todo_num] = ids[idx];
 395                         todo_results[todo_num] = false;
 396                         todo_num += 1;
 397                 }
 398
 399 #ifdef CLUSTER_SUPPORT
 400                 if (!ctdb_processes_exist(messaging_ctdbd_connection(),
 401                                           todo_ids, todo_num,
 402                                           todo_results)) {
 403                         goto fail;
 404                 }
 405 #endif
 406
 407                 for (t=0; t<todo_num; t++) {
 408                         idx = todo_idx[t];
 409
 410                         if (!todo_results[t]) {
 411                                 continue;
 412                         }
 413
 414                         if (ids[idx].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
 415                                 results[idx] = true;
 416                                 continue;
 417                         }
 418
 419                         verify_idx[verify_num] = idx;
 420                         verify_num += 1;
 421                 }
 422         }
 423
 424         for (t=0; t<verify_num; t++) {
 425                 struct serverid_exists_state state;
 426                 struct serverid_key key;
 427                 TDB_DATA tdbkey;
 428                 NTSTATUS status;
 429
 430                 idx = verify_idx[t];
 431
 432                 serverid_fill_key(&ids[idx], &key);
 433                 tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
 434
 435                 state.id = &ids[idx];
 436                 state.exists = false;
 437                 status = dbwrap_parse_record(db, tdbkey, server_exists_parse, &state);
 438                 if (!NT_STATUS_IS_OK(status)) {
 439                         results[idx] = false;
 440                         continue;
 441                 }
 442                 results[idx] = state.exists;
 443         }
 444
 445         result = true;
 446 fail:
 447         TALLOC_FREE(verify_idx);
 448         TALLOC_FREE(remote_idx);
 449         TALLOC_FREE(todo_results);
 450         TALLOC_FREE(todo_ids);
 451         TALLOC_FREE(todo_idx);
 452         return result;
 453 }
 454
 455 static bool serverid_rec_parse(const struct db_record *rec,
 456                                struct server_id *id, uint32_t *msg_flags)
 457 {
 458         struct serverid_key key;
 459         struct serverid_data data;
 460         TDB_DATA tdbkey;
 461         TDB_DATA tdbdata;
 462
 463         tdbkey = dbwrap_record_get_key(rec);
 464         tdbdata = dbwrap_record_get_value(rec);
 465
 466         if (tdbkey.dsize != sizeof(key)) {
 467                 DEBUG(1, ("Found invalid key length %d in serverid.tdb\n",
 468                           (int)tdbkey.dsize));
 469                 return false;
 470         }
 471         if (tdbdata.dsize != sizeof(data)) {
 472                 DEBUG(1, ("Found invalid value length %d in serverid.tdb\n",
 473                           (int)tdbdata.dsize));
 474                 return false;
 475         }
 476
 477         memcpy(&key, tdbkey.dptr, sizeof(key));
 478         memcpy(&data, tdbdata.dptr, sizeof(data));
 479
 480         id->pid = key.pid;
 481         id->task_id = key.task_id;
 482         id->vnn = key.vnn;
 483         id->unique_id = data.unique_id;
 484         *msg_flags = data.msg_flags;
 485         return true;
 486 }
 487
 488 struct serverid_traverse_read_state {
 489         int (*fn)(const struct server_id *id, uint32_t msg_flags,
 490                   void *private_data);
 491         void *private_data;
 492 };
 493
 494 static int serverid_traverse_read_fn(struct db_record *rec, void *private_data)
 495 {
 496         struct serverid_traverse_read_state *state =
 497                 (struct serverid_traverse_read_state *)private_data;
 498         struct server_id id;
 499         uint32_t msg_flags;
 500
 501         if (!serverid_rec_parse(rec, &id, &msg_flags)) {
 502                 return 0;
 503         }
 504         return state->fn(&id, msg_flags,state->private_data);
 505 }
 506
 507 bool serverid_traverse_read(int (*fn)(const struct server_id *id,
 508                                       uint32_t msg_flags, void *private_data),
 509                             void *private_data)
 510 {
 511         struct db_context *db;
 512         struct serverid_traverse_read_state state;
 513         NTSTATUS status;
 514
 515         db = serverid_db();
 516         if (db == NULL) {
 517                 return false;
 518         }
 519         state.fn = fn;
 520         state.private_data = private_data;
 521
 522         status = dbwrap_traverse_read(db, serverid_traverse_read_fn, &state,
 523                                       NULL);
 524         return NT_STATUS_IS_OK(status);
 525 }
 526
 527 struct serverid_traverse_state {
 528         int (*fn)(struct db_record *rec, const struct server_id *id,
 529                   uint32_t msg_flags, void *private_data);
 530         void *private_data;
 531 };
 532
 533 static int serverid_traverse_fn(struct db_record *rec, void *private_data)
 534 {
 535         struct serverid_traverse_state *state =
 536                 (struct serverid_traverse_state *)private_data;
 537         struct server_id id;
 538         uint32_t msg_flags;
 539
 540         if (!serverid_rec_parse(rec, &id, &msg_flags)) {
 541                 return 0;
 542         }
 543         return state->fn(rec, &id, msg_flags, state->private_data);
 544 }
 545
 546 bool serverid_traverse(int (*fn)(struct db_record *rec,
 547                                  const struct server_id *id,
 548                                  uint32_t msg_flags, void *private_data),
 549                             void *private_data)
 550 {
 551         struct db_context *db;
 552         struct serverid_traverse_state state;
 553         NTSTATUS status;
 554
 555         db = serverid_db();
 556         if (db == NULL) {
 557                 return false;
 558         }
 559         state.fn = fn;
 560         state.private_data = private_data;
 561
 562         status = dbwrap_traverse(db, serverid_traverse_fn, &state, NULL);
 563         return NT_STATUS_IS_OK(status);
 564 }
 565
 566 uint64_t serverid_get_random_unique_id(void)
 567 {
 568         uint64_t unique_id = SERVERID_UNIQUE_ID_NOT_TO_VERIFY;
 569
 570         while (unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
 571                 generate_random_buffer((uint8_t *)&unique_id,
 572                                        sizeof(unique_id));
 573         }
 574
 575         return unique_id;
 576 }