source4/wrepl_server/wrepl_scavenging.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    WINS Replication server
   5
   6    Copyright (C) Stefan Metzmacher      2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "librpc/gen_ndr/ndr_winsrepl.h"
  24 #include "wrepl_server/wrepl_server.h"
  25 #include "nbt_server/wins/winsdb.h"
  26 #include "ldb/include/ldb.h"
  27 #include "ldb/include/ldb_errors.h"
  28 #include "system/time.h"
  29 #include "smbd/service_task.h"
  30 #include "lib/messaging/irpc.h"
  31 #include "librpc/gen_ndr/ndr_irpc.h"
  32 #include "librpc/gen_ndr/ndr_nbt.h"
  33
  34 const char *wreplsrv_owner_filter(struct wreplsrv_service *service,
  35                                   TALLOC_CTX *mem_ctx,
  36                                   const char *wins_owner)
  37 {
  38         if (strcmp(wins_owner, service->wins_db->local_owner) == 0) {
  39                 return talloc_asprintf(mem_ctx, "(|(winsOwner=%s)(winsOwner=0.0.0.0))",
  40                                        wins_owner);
  41         }
  42
  43         return talloc_asprintf(mem_ctx, "(&(winsOwner=%s)(!(winsOwner=0.0.0.0)))",
  44                                wins_owner);
  45 }
  46
  47 static NTSTATUS wreplsrv_scavenging_owned_records(struct wreplsrv_service *service, TALLOC_CTX *tmp_mem)
  48 {
  49         NTSTATUS status;
  50         struct winsdb_record *rec = NULL;
  51         struct ldb_result *res = NULL;
  52         const char *owner_filter;
  53         const char *filter;
  54         uint32_t i;
  55         int ret;
  56         time_t now = time(NULL);
  57         const char *now_timestr;
  58         const char *action;
  59         const char *old_state=NULL;
  60         const char *new_state=NULL;
  61         uint32_t modify_flags;
  62         bool modify_record;
  63         bool delete_record;
  64         bool delete_tombstones;
  65         struct timeval tombstone_extra_time;
  66
  67         now_timestr = ldb_timestring(tmp_mem, now);
  68         NT_STATUS_HAVE_NO_MEMORY(now_timestr);
  69         owner_filter = wreplsrv_owner_filter(service, tmp_mem,
  70                                              service->wins_db->local_owner);
  71         NT_STATUS_HAVE_NO_MEMORY(owner_filter);
  72         filter = talloc_asprintf(tmp_mem,
  73                                  "(&%s(objectClass=winsRecord)"
  74                                  "(expireTime<=%s))",
  75                                  owner_filter, now_timestr);
  76         NT_STATUS_HAVE_NO_MEMORY(filter);
  77         ret = ldb_search(service->wins_db->ldb, tmp_mem, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "%s", filter);
  78         if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
  79         DEBUG(10,("WINS scavenging: filter '%s' count %d\n", filter, res->count));
  80
  81         tombstone_extra_time = timeval_add(&service->startup_time,
  82                                            service->config.tombstone_extra_timeout,
  83                                            0);
  84         delete_tombstones = timeval_expired(&tombstone_extra_time);
  85
  86         for (i=0; i < res->count; i++) {
  87                 /*
  88                  * we pass '0' as 'now' here,
  89                  * because we want to get the raw timestamps which are in the DB
  90                  */
  91                 status = winsdb_record(service->wins_db, res->msgs[i], tmp_mem, 0, &rec);
  92                 NT_STATUS_NOT_OK_RETURN(status);
  93                 talloc_free(res->msgs[i]);
  94
  95                 modify_flags    = 0;
  96                 modify_record   = false;
  97                 delete_record   = false;
  98
  99                 switch (rec->state) {
 100                 case WREPL_STATE_ACTIVE:
 101                         old_state       = "active";
 102                         new_state       = "active";
 103                         if (!rec->is_static) {
 104                                 new_state       = "released";
 105                                 rec->state      = WREPL_STATE_RELEASED;
 106                                 rec->expire_time= service->config.tombstone_interval + now;
 107                         }
 108                         modify_flags    = 0;
 109                         modify_record   = true;
 110                         break;
 111
 112                 case WREPL_STATE_RELEASED:
 113                         old_state       = "released";
 114                         new_state       = "tombstone";
 115                         rec->state      = WREPL_STATE_TOMBSTONE;
 116                         rec->expire_time= service->config.tombstone_timeout + now;
 117                         modify_flags    = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
 118                         modify_record   = true;
 119                         break;
 120
 121                 case WREPL_STATE_TOMBSTONE:
 122                         old_state       = "tombstone";
 123                         new_state       = "tombstone";
 124                         if (!delete_tombstones) break;
 125                         new_state       = "deleted";
 126                         delete_record = true;
 127                         break;
 128
 129                 case WREPL_STATE_RESERVED:
 130                         DEBUG(0,("%s: corrupted record: %s\n",
 131                                 __location__, nbt_name_string(rec, rec->name)));
 132                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 133                 }
 134
 135                 if (modify_record) {
 136                         action = "modify";
 137                         ret = winsdb_modify(service->wins_db, rec, modify_flags);
 138                 } else if (delete_record) {
 139                         action = "delete";
 140                         ret = winsdb_delete(service->wins_db, rec);
 141                 } else {
 142                         action = "skip";
 143                         ret = NBT_RCODE_OK;
 144                 }
 145
 146                 if (ret != NBT_RCODE_OK) {
 147                         DEBUG(1,("WINS scavenging: failed to %s name %s (owned:%s -> owned:%s): error:%u\n",
 148                                 action, nbt_name_string(rec, rec->name), old_state, new_state, ret));
 149                 } else {
 150                         DEBUG(4,("WINS scavenging: %s name: %s (owned:%s -> owned:%s)\n",
 151                                 action, nbt_name_string(rec, rec->name), old_state, new_state));
 152                 }
 153
 154                 talloc_free(rec);
 155         }
 156
 157         return NT_STATUS_OK;
 158 }
 159
 160 static NTSTATUS wreplsrv_scavenging_replica_non_active_records(struct wreplsrv_service *service, TALLOC_CTX *tmp_mem)
 161 {
 162         NTSTATUS status;
 163         struct winsdb_record *rec = NULL;
 164         struct ldb_result *res = NULL;
 165         const char *owner_filter;
 166         const char *filter;
 167         uint32_t i;
 168         int ret;
 169         time_t now = time(NULL);
 170         const char *now_timestr;
 171         const char *action;
 172         const char *old_state=NULL;
 173         const char *new_state=NULL;
 174         uint32_t modify_flags;
 175         bool modify_record;
 176         bool delete_record;
 177         bool delete_tombstones;
 178         struct timeval tombstone_extra_time;
 179
 180         now_timestr = ldb_timestring(tmp_mem, now);
 181         NT_STATUS_HAVE_NO_MEMORY(now_timestr);
 182         owner_filter = wreplsrv_owner_filter(service, tmp_mem,
 183                                              service->wins_db->local_owner);
 184         NT_STATUS_HAVE_NO_MEMORY(owner_filter);
 185         filter = talloc_asprintf(tmp_mem,
 186                                  "(&(!%s)(objectClass=winsRecord)"
 187                                  "(!(recordState=%u))(expireTime<=%s))",
 188                                  owner_filter, WREPL_STATE_ACTIVE, now_timestr);
 189         NT_STATUS_HAVE_NO_MEMORY(filter);
 190         ret = ldb_search(service->wins_db->ldb, tmp_mem, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "%s", filter);
 191         if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
 192         DEBUG(10,("WINS scavenging: filter '%s' count %d\n", filter, res->count));
 193
 194         tombstone_extra_time = timeval_add(&service->startup_time,
 195                                            service->config.tombstone_extra_timeout,
 196                                            0);
 197         delete_tombstones = timeval_expired(&tombstone_extra_time);
 198
 199         for (i=0; i < res->count; i++) {
 200                 /*
 201                  * we pass '0' as 'now' here,
 202                  * because we want to get the raw timestamps which are in the DB
 203                  */
 204                 status = winsdb_record(service->wins_db, res->msgs[i], tmp_mem, 0, &rec);
 205                 NT_STATUS_NOT_OK_RETURN(status);
 206                 talloc_free(res->msgs[i]);
 207
 208                 modify_flags    = 0;
 209                 modify_record   = false;
 210                 delete_record   = false;
 211
 212                 switch (rec->state) {
 213                 case WREPL_STATE_ACTIVE:
 214                         DEBUG(0,("%s: corrupted record: %s\n",
 215                                 __location__, nbt_name_string(rec, rec->name)));
 216                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 217
 218                 case WREPL_STATE_RELEASED:
 219                         old_state       = "released";
 220                         new_state       = "tombstone";
 221                         rec->state      = WREPL_STATE_TOMBSTONE;
 222                         rec->expire_time= service->config.tombstone_timeout + now;
 223                         modify_flags    = 0;
 224                         modify_record   = true;
 225                         break;
 226
 227                 case WREPL_STATE_TOMBSTONE:
 228                         old_state       = "tombstone";
 229                         new_state       = "tombstone";
 230                         if (!delete_tombstones) break;
 231                         new_state       = "deleted";
 232                         delete_record = true;
 233                         break;
 234
 235                 case WREPL_STATE_RESERVED:
 236                         DEBUG(0,("%s: corrupted record: %s\n",
 237                                 __location__, nbt_name_string(rec, rec->name)));
 238                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 239                 }
 240
 241                 if (modify_record) {
 242                         action = "modify";
 243                         ret = winsdb_modify(service->wins_db, rec, modify_flags);
 244                 } else if (delete_record) {
 245                         action = "delete";
 246                         ret = winsdb_delete(service->wins_db, rec);
 247                 } else {
 248                         action = "skip";
 249                         ret = NBT_RCODE_OK;
 250                 }
 251
 252                 if (ret != NBT_RCODE_OK) {
 253                         DEBUG(1,("WINS scavenging: failed to %s name %s (replica:%s -> replica:%s): error:%u\n",
 254                                 action, nbt_name_string(rec, rec->name), old_state, new_state, ret));
 255                 } else {
 256                         DEBUG(4,("WINS scavenging: %s name: %s (replica:%s -> replica:%s)\n",
 257                                 action, nbt_name_string(rec, rec->name), old_state, new_state));
 258                 }
 259
 260                 talloc_free(rec);
 261         }
 262
 263         return NT_STATUS_OK;
 264 }
 265
 266 struct verify_state {
 267         struct messaging_context *msg_ctx;
 268         struct wreplsrv_service *service;
 269         struct winsdb_record *rec;
 270         struct nbtd_proxy_wins_challenge r;
 271 };
 272
 273 static void verify_handler(struct irpc_request *ireq)
 274 {
 275         struct verify_state *s = talloc_get_type(ireq->async.private,
 276                                  struct verify_state);
 277         struct winsdb_record *rec = s->rec;
 278         const char *action;
 279         const char *old_state = "active";
 280         const char *new_state = "active";
 281         const char *new_owner = "replica";
 282         uint32_t modify_flags = 0;
 283         bool modify_record = false;
 284         bool delete_record = false;
 285         bool different = false;
 286         int ret;
 287         NTSTATUS status;
 288         uint32_t i, j;
 289
 290         /*
 291          * - if the name isn't present anymore remove our record
 292          * - if the name is found and not a normal group check if the addresses match,
 293          *   - if they don't match remove the record
 294          *   - if they match do nothing
 295          * - if an error happens do nothing
 296          */
 297         status = irpc_call_recv(ireq);
 298         if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
 299                 delete_record = true;
 300                 new_state = "deleted";
 301         } else if (NT_STATUS_IS_OK(status) && rec->type != WREPL_TYPE_GROUP) {
 302                 for (i=0; i < s->r.out.num_addrs; i++) {
 303                         bool found = false;
 304                         for (j=0; rec->addresses[j]; j++) {
 305                                 if (strcmp(s->r.out.addrs[i].addr, rec->addresses[j]->address) == 0) {
 306                                         found = true;
 307                                         break;
 308                                 }
 309                         }
 310                         if (!found) {
 311                                 different = true;
 312                                 break;
 313                         }
 314                 }
 315         } else if (NT_STATUS_IS_OK(status) && rec->type == WREPL_TYPE_GROUP) {
 316                 if (s->r.out.num_addrs != 1 || strcmp(s->r.out.addrs[0].addr, "255.255.255.255") != 0) {
 317                         different = true;
 318                 }
 319         }
 320
 321         if (different) {
 322                 /*
 323                  * if the reply from the owning wins server has different addresses
 324                  * then take the ownership of the record and make it a tombstone
 325                  * this will then hopefully replicated to the original owner of the record
 326                  * which will then propagate it's own record, so that the current record will
 327                  * be replicated to to us
 328                  */
 329                 DEBUG(0,("WINS scavenging: replica %s verify got different addresses from winsserver: %s: tombstoning record\n",
 330                         nbt_name_string(rec, rec->name), rec->wins_owner));
 331
 332                 rec->state      = WREPL_STATE_TOMBSTONE;
 333                 rec->expire_time= time(NULL) + s->service->config.tombstone_timeout;
 334                 for (i=0; rec->addresses[i]; i++) {
 335                         rec->addresses[i]->expire_time = rec->expire_time;
 336                 }
 337                 modify_record   = true;
 338                 modify_flags    = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
 339                 new_state       = "tombstone";
 340                 new_owner       = "owned";
 341         } else if (NT_STATUS_IS_OK(status)) {
 342                 /* if the addresses are the same, just update the timestamps */
 343                 rec->expire_time = time(NULL) + s->service->config.verify_interval;
 344                 for (i=0; rec->addresses[i]; i++) {
 345                         rec->addresses[i]->expire_time = rec->expire_time;
 346                 }
 347                 modify_record   = true;
 348                 modify_flags    = 0;
 349                 new_state       = "active";
 350         }
 351
 352         if (modify_record) {
 353                 action = "modify";
 354                 ret = winsdb_modify(s->service->wins_db, rec, modify_flags);
 355         } else if (delete_record) {
 356                 action = "delete";
 357                 ret = winsdb_delete(s->service->wins_db, rec);
 358         } else {
 359                 action = "skip";
 360                 ret = NBT_RCODE_OK;
 361         }
 362
 363         if (ret != NBT_RCODE_OK) {
 364                 DEBUG(1,("WINS scavenging: failed to %s name %s (replica:%s -> %s:%s): error:%u\n",
 365                         action, nbt_name_string(rec, rec->name), old_state, new_owner, new_state, ret));
 366         } else {
 367                 DEBUG(4,("WINS scavenging: %s name: %s (replica:%s -> %s:%s): %s: %s\n",
 368                         action, nbt_name_string(rec, rec->name), old_state, new_owner, new_state,
 369                         rec->wins_owner, nt_errstr(status)));
 370         }
 371
 372         talloc_free(s);
 373 }
 374
 375 static NTSTATUS wreplsrv_scavenging_replica_active_records(struct wreplsrv_service *service, TALLOC_CTX *tmp_mem)
 376 {
 377         NTSTATUS status;
 378         struct winsdb_record *rec = NULL;
 379         struct ldb_result *res = NULL;
 380         const char *owner_filter;
 381         const char *filter;
 382         uint32_t i;
 383         int ret;
 384         time_t now = time(NULL);
 385         const char *now_timestr;
 386         struct irpc_request *ireq;
 387         struct verify_state *s;
 388         struct server_id *nbt_servers;
 389
 390         nbt_servers = irpc_servers_byname(service->task->msg_ctx, tmp_mem, "nbt_server");
 391         if ((nbt_servers == NULL) || (nbt_servers[0].id == 0)) {
 392                 return NT_STATUS_INTERNAL_ERROR;
 393         }
 394
 395         now_timestr = ldb_timestring(tmp_mem, now);
 396         NT_STATUS_HAVE_NO_MEMORY(now_timestr);
 397         owner_filter = wreplsrv_owner_filter(service, tmp_mem,
 398                                              service->wins_db->local_owner);
 399         NT_STATUS_HAVE_NO_MEMORY(owner_filter);
 400         filter = talloc_asprintf(tmp_mem,
 401                                  "(&(!%s)(objectClass=winsRecord)"
 402                                  "(recordState=%u)(expireTime<=%s))",
 403                                  owner_filter, WREPL_STATE_ACTIVE, now_timestr);
 404         NT_STATUS_HAVE_NO_MEMORY(filter);
 405         ret = ldb_search(service->wins_db->ldb, tmp_mem, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "%s", filter);
 406         if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
 407         DEBUG(10,("WINS scavenging: filter '%s' count %d\n", filter, res->count));
 408
 409         for (i=0; i < res->count; i++) {
 410                 /*
 411                  * we pass '0' as 'now' here,
 412                  * because we want to get the raw timestamps which are in the DB
 413                  */
 414                 status = winsdb_record(service->wins_db, res->msgs[i], tmp_mem, 0, &rec);
 415                 NT_STATUS_NOT_OK_RETURN(status);
 416                 talloc_free(res->msgs[i]);
 417
 418                 if (rec->state != WREPL_STATE_ACTIVE) {
 419                         DEBUG(0,("%s: corrupted record: %s\n",
 420                                 __location__, nbt_name_string(rec, rec->name)));
 421                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 422                 }
 423
 424                 /*
 425                  * ask the owning wins server if the record still exists,
 426                  * if not delete the record
 427                  *
 428                  * TODO: NOTE: this is a simpliefied version, to verify that
 429                  *             a record still exist, I assume that w2k3 uses
 430                  *             DCERPC calls or some WINSREPL packets for this,
 431                  *             but we use a wins name query
 432                  */
 433                 DEBUG(0,("ask wins server '%s' if '%s' with version_id:%llu still exists\n",
 434                          rec->wins_owner, nbt_name_string(rec, rec->name),
 435                          (unsigned long long)rec->version));
 436
 437                 s = talloc_zero(tmp_mem, struct verify_state);
 438                 NT_STATUS_HAVE_NO_MEMORY(s);
 439                 s->msg_ctx      = service->task->msg_ctx;
 440                 s->service      = service;
 441                 s->rec          = talloc_steal(s, rec);
 442
 443                 s->r.in.name            = *rec->name;
 444                 s->r.in.num_addrs       = 1;
 445                 s->r.in.addrs           = talloc_array(s, struct nbtd_proxy_wins_addr, s->r.in.num_addrs);
 446                 NT_STATUS_HAVE_NO_MEMORY(s->r.in.addrs);
 447                 /* TODO: fix pidl to handle inline ipv4address arrays */
 448                 s->r.in.addrs[0].addr   = rec->wins_owner;
 449
 450                 ireq = IRPC_CALL_SEND(s->msg_ctx, nbt_servers[0],
 451                                       irpc, NBTD_PROXY_WINS_CHALLENGE,
 452                                       &s->r, s);
 453                 NT_STATUS_HAVE_NO_MEMORY(ireq);
 454
 455                 ireq->async.fn          = verify_handler;
 456                 ireq->async.private     = s;
 457
 458                 talloc_steal(service, s);
 459         }
 460
 461         return NT_STATUS_OK;
 462 }
 463
 464 NTSTATUS wreplsrv_scavenging_run(struct wreplsrv_service *service)
 465 {
 466         NTSTATUS status;
 467         TALLOC_CTX *tmp_mem;
 468         bool skip_first_run = false;
 469
 470         if (!timeval_expired(&service->scavenging.next_run)) {
 471                 return NT_STATUS_OK;
 472         }
 473
 474         if (timeval_is_zero(&service->scavenging.next_run)) {
 475                 skip_first_run = true;
 476         }
 477
 478         service->scavenging.next_run = timeval_current_ofs(service->config.scavenging_interval, 0);
 479         status = wreplsrv_periodic_schedule(service, service->config.scavenging_interval);
 480         NT_STATUS_NOT_OK_RETURN(status);
 481
 482         /*
 483          * if it's the first time this functions is called (startup)
 484          * the next_run is zero, in this case we should not do scavenging
 485          */
 486         if (skip_first_run) {
 487                 return NT_STATUS_OK;
 488         }
 489
 490         if (service->scavenging.processing) {
 491                 return NT_STATUS_OK;
 492         }
 493
 494         DEBUG(4,("wreplsrv_scavenging_run(): start\n"));
 495
 496         tmp_mem = talloc_new(service);
 497         NT_STATUS_HAVE_NO_MEMORY(tmp_mem);
 498         service->scavenging.processing = true;
 499         status = wreplsrv_scavenging_owned_records(service,tmp_mem);
 500         service->scavenging.processing = false;
 501         talloc_free(tmp_mem);
 502         NT_STATUS_NOT_OK_RETURN(status);
 503
 504         tmp_mem = talloc_new(service);
 505         NT_STATUS_HAVE_NO_MEMORY(tmp_mem);
 506         service->scavenging.processing = true;
 507         status = wreplsrv_scavenging_replica_non_active_records(service, tmp_mem);
 508         service->scavenging.processing = false;
 509         talloc_free(tmp_mem);
 510         NT_STATUS_NOT_OK_RETURN(status);
 511
 512         tmp_mem = talloc_new(service);
 513         NT_STATUS_HAVE_NO_MEMORY(tmp_mem);
 514         service->scavenging.processing = true;
 515         status = wreplsrv_scavenging_replica_active_records(service, tmp_mem);
 516         service->scavenging.processing = false;
 517         talloc_free(tmp_mem);
 518         NT_STATUS_NOT_OK_RETURN(status);
 519
 520         DEBUG(4,("wreplsrv_scavenging_run(): end\n"));
 521
 522         return NT_STATUS_OK;
 523 }