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