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