source/wrepl_server/wrepl_server.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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "dlinklist.h"
  25 #include "lib/events/events.h"
  26 #include "lib/socket/socket.h"
  27 #include "smbd/service_task.h"
  28 #include "smbd/service_stream.h"
  29 #include "lib/messaging/irpc.h"
  30 #include "librpc/gen_ndr/ndr_winsrepl.h"
  31 #include "wrepl_server/wrepl_server.h"
  32 #include "nbt_server/wins/winsdb.h"
  33 #include "ldb/include/ldb.h"
  34 #include "ldb/include/ldb_errors.h"
  35
  36 /*
  37   open winsdb
  38 */
  39 static NTSTATUS wreplsrv_open_winsdb(struct wreplsrv_service *service)
  40 {
  41         service->wins_db     = winsdb_connect(service);
  42         if (!service->wins_db) {
  43                 return NT_STATUS_INTERNAL_DB_ERROR;
  44         }
  45
  46         /* the default renew interval is 6 days */
  47         service->config.renew_interval    = lp_parm_int(-1,"wreplsrv","renew_interval", 6*24*60*60);
  48
  49         /* the default tombstone (extinction) interval is 6 days */
  50         service->config.tombstone_interval= lp_parm_int(-1,"wreplsrv","tombstone_interval", 6*24*60*60);
  51
  52         /* the default tombstone (extinction) timeout is 1 day */
  53         service->config.tombstone_timeout = lp_parm_int(-1,"wreplsrv","tombstone_timeout", 1*24*60*60);
  54
  55         /* the default verify interval is 24 days */
  56         service->config.verify_interval   = lp_parm_int(-1,"wreplsrv","verify_interval", 24*24*60*60);
  57
  58         /* the maximun interval to the next periodic processing event */
  59         service->config.periodic_interval = lp_parm_int(-1,"wreplsrv","periodic_interval", 60);
  60
  61         return NT_STATUS_OK;
  62 }
  63
  64 struct wreplsrv_partner *wreplsrv_find_partner(struct wreplsrv_service *service, const char *peer_addr)
  65 {
  66         struct wreplsrv_partner *cur;
  67
  68         for (cur = service->partners; cur; cur = cur->next) {
  69                 if (strcmp(cur->address, peer_addr) == 0) {
  70                         return cur;
  71                 }
  72         }
  73
  74         return NULL;
  75 }
  76
  77 /*
  78   load our replication partners
  79 */
  80 static NTSTATUS wreplsrv_load_partners(struct wreplsrv_service *service)
  81 {
  82         struct ldb_result *res = NULL;
  83         int ret;
  84         TALLOC_CTX *tmp_ctx = talloc_new(service);
  85         int i;
  86
  87         /* find the record in the WINS database */
  88         ret = ldb_search(service->wins_db, ldb_dn_explode(tmp_ctx, "CN=PARTNERS"), LDB_SCOPE_ONELEVEL,
  89                          "(objectClass=wreplPartner)", NULL, &res);
  90         if (ret != LDB_SUCCESS) goto failed;
  91         talloc_steal(tmp_ctx, res);
  92         if (res->count == 0) goto done;
  93
  94         for (i=0; i < res->count; i++) {
  95                 struct wreplsrv_partner *partner;
  96
  97                 partner = talloc_zero(service, struct wreplsrv_partner);
  98                 if (partner == NULL) goto failed;
  99
 100                 partner->service                = service;
 101                 partner->address                = ldb_msg_find_string(res->msgs[i], "address", NULL);
 102                 if (!partner->address) goto failed;
 103                 partner->name                   = ldb_msg_find_string(res->msgs[i], "name", partner->address);
 104                 partner->type                   = ldb_msg_find_uint(res->msgs[i], "type", WINSREPL_PARTNER_BOTH);
 105                 partner->pull.interval          = ldb_msg_find_uint(res->msgs[i], "pullInterval",
 106                                                                     WINSREPL_DEFAULT_PULL_INTERVAL);
 107                 partner->pull.retry_interval    = ldb_msg_find_uint(res->msgs[i], "pullRetryInterval",
 108                                                                     WINSREPL_DEFAULT_PULL_RETRY_INTERVAL);
 109                 partner->our_address            = ldb_msg_find_string(res->msgs[i], "ourAddress", NULL);
 110                 partner->push.change_count      = ldb_msg_find_uint(res->msgs[i], "pushChangeCount",
 111                                                                     WINSREPL_DEFAULT_PUSH_CHANGE_COUNT);
 112                 partner->push.use_inform        = ldb_msg_find_uint(res->msgs[i], "pushUseInform", False);
 113
 114                 talloc_steal(partner, partner->address);
 115                 talloc_steal(partner, partner->name);
 116                 talloc_steal(partner, partner->our_address);
 117
 118                 DLIST_ADD(service->partners, partner);
 119         }
 120 done:
 121         talloc_free(tmp_ctx);
 122         return NT_STATUS_OK;
 123 failed:
 124         talloc_free(tmp_ctx);
 125         return NT_STATUS_FOOBAR;
 126 }
 127
 128 BOOL wreplsrv_is_our_address(struct wreplsrv_service *service, const char *address)
 129 {
 130         const char *our_address;
 131
 132         if (lp_interfaces() && lp_bind_interfaces_only()) {
 133                 int num_interfaces = iface_count();
 134                 int i;
 135                 for(i = 0; i < num_interfaces; i++) {
 136                         our_address = iface_n_ip(i);
 137                         if (strcasecmp(our_address, address) == 0) {
 138                                 return True;
 139                         }
 140                 }
 141         } else {
 142                 our_address = lp_socket_address();
 143                 if (strcasecmp(our_address, address) == 0) {
 144                         return True;
 145                 }
 146         }
 147
 148         return False;
 149 }
 150
 151 uint64_t wreplsrv_local_max_version(struct wreplsrv_service *service)
 152 {
 153         int ret;
 154         struct ldb_context *ldb = service->wins_db;
 155         struct ldb_dn *dn;
 156         struct ldb_result *res = NULL;
 157         TALLOC_CTX *tmp_ctx = talloc_new(service);
 158         uint64_t maxVersion = 0;
 159
 160         dn = ldb_dn_explode(tmp_ctx, "CN=VERSION");
 161         if (!dn) goto failed;
 162
 163         /* find the record in the WINS database */
 164         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
 165                          NULL, NULL, &res);
 166         if (ret != LDB_SUCCESS) goto failed;
 167         talloc_steal(tmp_ctx, res);
 168         if (res->count > 1) goto failed;
 169
 170         if (res->count == 1) {
 171                 maxVersion = ldb_msg_find_uint64(res->msgs[0], "maxVersion", 0);
 172         }
 173
 174 failed:
 175         talloc_free(tmp_ctx);
 176         return maxVersion;
 177 }
 178
 179 NTSTATUS wreplsrv_fill_wrepl_table(struct wreplsrv_service *service,
 180                                    TALLOC_CTX *mem_ctx,
 181                                    struct wrepl_table *table_out,
 182                                    const char *our_ip,
 183                                    const char *initiator,
 184                                    BOOL full_table)
 185 {
 186         struct wreplsrv_owner *cur;
 187         uint64_t local_max_version;
 188         uint32_t i = 0;
 189
 190         table_out->partner_count        = 0;
 191         table_out->partners             = NULL;
 192         table_out->initiator            = initiator;
 193
 194         local_max_version = wreplsrv_local_max_version(service);
 195         if (local_max_version > 0) {
 196                 table_out->partner_count++;
 197         }
 198
 199         for (cur = service->table; full_table && cur; cur = cur->next) {
 200                 table_out->partner_count++;
 201         }
 202
 203         table_out->partners = talloc_array(mem_ctx, struct wrepl_wins_owner, table_out->partner_count);
 204         NT_STATUS_HAVE_NO_MEMORY(table_out->partners);
 205
 206         if (local_max_version > 0) {
 207                 table_out->partners[i].address          = our_ip;
 208                 table_out->partners[i].min_version      = 0;
 209                 table_out->partners[i].max_version      = local_max_version;
 210                 table_out->partners[i].type             = 1;
 211                 i++;
 212         }
 213
 214         for (cur = service->table; full_table && cur; cur = cur->next) {
 215                 table_out->partners[i] = cur->owner;
 216                 i++;
 217         }
 218
 219         return NT_STATUS_OK;
 220 }
 221
 222 struct wreplsrv_owner *wreplsrv_find_owner(struct wreplsrv_owner *table, const char *wins_owner)
 223 {
 224         struct wreplsrv_owner *cur;
 225
 226         for (cur = table; cur; cur = cur->next) {
 227                 if (strcmp(cur->owner.address, wins_owner) == 0) {
 228                         return cur;
 229                 }
 230         }
 231
 232         return NULL;
 233 }
 234
 235 /*
 236  update the wins_owner_table max_version, if the given version is the highest version
 237  if no entry for the wins_owner exists yet, create one
 238 */
 239 NTSTATUS wreplsrv_add_table(struct wreplsrv_service *service,
 240                             TALLOC_CTX *mem_ctx, struct wreplsrv_owner **_table,
 241                             const char *wins_owner, uint64_t version)
 242 {
 243         struct wreplsrv_owner *table = *_table;
 244         struct wreplsrv_owner *cur;
 245
 246         if (strcmp(WINSDB_OWNER_LOCAL, wins_owner) == 0) {
 247                 return NT_STATUS_OK;
 248         }
 249
 250         cur = wreplsrv_find_owner(table, wins_owner);
 251
 252         /* if it doesn't exists yet, create one */
 253         if (!cur) {
 254                 cur = talloc_zero(mem_ctx, struct wreplsrv_owner);
 255                 NT_STATUS_HAVE_NO_MEMORY(cur);
 256
 257                 cur->owner.address      = talloc_strdup(cur, wins_owner);
 258                 NT_STATUS_HAVE_NO_MEMORY(cur->owner.address);
 259                 cur->owner.min_version  = 0;
 260                 cur->owner.max_version  = 0;
 261                 cur->owner.type         = 1; /* don't know why this is always 1 */
 262
 263                 cur->partner            = wreplsrv_find_partner(service, wins_owner);
 264
 265                 DLIST_ADD(table, cur);
 266                 *_table = table;
 267         }
 268
 269         /* the min_version is always 0 here, and won't be updated */
 270
 271         /* if the given version is higher the then current nax_version, update */
 272         if (cur->owner.max_version < version) {
 273                 cur->owner.max_version = version;
 274         }
 275
 276         return NT_STATUS_OK;
 277 }
 278
 279 /*
 280   load the partner table
 281 */
 282 static NTSTATUS wreplsrv_load_table(struct wreplsrv_service *service)
 283 {
 284         struct ldb_result *res = NULL;
 285         int ret;
 286         NTSTATUS status;
 287         TALLOC_CTX *tmp_ctx = talloc_new(service);
 288         int i;
 289         const char *wins_owner;
 290         uint64_t version;
 291         const char * const attrs[] = {
 292                 "winsOwner",
 293                 "versionID",
 294                 NULL
 295         };
 296
 297         /* find the record in the WINS database */
 298         ret = ldb_search(service->wins_db, NULL, LDB_SCOPE_SUBTREE,
 299                          "(objectClass=winsRecord)", attrs, &res);
 300         status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 301         if (ret != LDB_SUCCESS) goto failed;
 302         talloc_steal(tmp_ctx, res);
 303         if (res->count == 0) goto done;
 304
 305         for (i=0; i < res->count; i++) {
 306                 wins_owner     = ldb_msg_find_string(res->msgs[i], "winsOwner", NULL);
 307                 version        = ldb_msg_find_uint64(res->msgs[i], "versionID", 0);
 308
 309                 if (wins_owner) {
 310                         status = wreplsrv_add_table(service,
 311                                                     service, &service->table,
 312                                                     wins_owner, version);
 313                         if (!NT_STATUS_IS_OK(status)) goto failed;
 314                 }
 315                 talloc_free(res->msgs[i]);
 316
 317                 /* TODO: what's abut the per address owners? */
 318         }
 319 done:
 320         talloc_free(tmp_ctx);
 321         return NT_STATUS_OK;
 322 failed:
 323         talloc_free(tmp_ctx);
 324         return status;
 325 }
 326
 327 /*
 328   setup our replication partners
 329 */
 330 static NTSTATUS wreplsrv_setup_partners(struct wreplsrv_service *service)
 331 {
 332         NTSTATUS status;
 333
 334         status = wreplsrv_load_partners(service);
 335         NT_STATUS_NOT_OK_RETURN(status);
 336
 337         status = wreplsrv_load_table(service);
 338         NT_STATUS_NOT_OK_RETURN(status);
 339
 340         return NT_STATUS_OK;
 341 }
 342
 343 /*
 344   startup the wrepl task
 345 */
 346 static void wreplsrv_task_init(struct task_server *task)
 347 {
 348         NTSTATUS status;
 349         struct wreplsrv_service *service;
 350
 351         service = talloc_zero(task, struct wreplsrv_service);
 352         if (!service) {
 353                 task_server_terminate(task, "wreplsrv_task_init: out of memory");
 354                 return;
 355         }
 356         service->task = task;
 357         task->private = service;
 358
 359         /*
 360          * setup up all partners, and open the winsdb
 361          */
 362         status = wreplsrv_open_winsdb(service);
 363         if (!NT_STATUS_IS_OK(status)) {
 364                 task_server_terminate(task, "wreplsrv_task_init: wreplsrv_open_winsdb() failed");
 365                 return;
 366         }
 367
 368         /*
 369          * setup timed events for each partner we want to pull from
 370          */
 371         status = wreplsrv_setup_partners(service);
 372         if (!NT_STATUS_IS_OK(status)) {
 373                 task_server_terminate(task, "wreplsrv_task_init: wreplsrv_setup_partners() failed");
 374                 return;
 375         }
 376
 377         /*
 378          * setup listen sockets, so we can anwser requests from our partners,
 379          * which pull from us
 380          */
 381         status = wreplsrv_setup_sockets(service);
 382         if (!NT_STATUS_IS_OK(status)) {
 383                 task_server_terminate(task, "wreplsrv_task_init: wreplsrv_setup_sockets() failed");
 384                 return;
 385         }
 386
 387         status = wreplsrv_setup_periodic(service);
 388         if (!NT_STATUS_IS_OK(status)) {
 389                 task_server_terminate(task, "wreplsrv_task_init: wreplsrv_setup_periodic() failed");
 390                 return;
 391         }
 392
 393         irpc_add_name(task->msg_ctx, "wrepl_server");
 394 }
 395
 396 /*
 397   initialise the WREPL server
 398  */
 399 static NTSTATUS wreplsrv_init(struct event_context *event_ctx, const struct model_ops *model_ops)
 400 {
 401         if (!lp_wins_support()) {
 402                 return NT_STATUS_OK;
 403         }
 404
 405         return task_server_startup(event_ctx, model_ops, wreplsrv_task_init);
 406 }
 407
 408 /*
 409   register ourselves as a available server
 410 */
 411 NTSTATUS server_service_wrepl_init(void)
 412 {
 413         return register_server_service("wrepl", wreplsrv_init);
 414 }