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(service, struct wreplsrv_partner);
  84                 if (partner == NULL) goto failed;
  85
  86                 partner->address        = ldb_msg_find_string(res[i], "address", NULL);
  87                 if (!partner->address) goto failed;
  88                 partner->name           = ldb_msg_find_string(res[i], "name", partner->address);
  89                 partner->type           = ldb_msg_find_int(res[i], "type", WINSREPL_PARTNER_BOTH);
  90                 partner->pull.interval  = ldb_msg_find_int(res[i], "pullInterval", WINSREPL_DEFAULT_PULL_INTERVAL);
  91                 partner->our_address    = ldb_msg_find_string(res[i], "ourAddress", NULL);
  92
  93                 talloc_steal(partner, partner->address);
  94                 talloc_steal(partner, partner->name);
  95                 talloc_steal(partner, partner->our_address);
  96
  97                 DLIST_ADD(service->partners, partner);
  98         }
  99 done:
 100         talloc_free(tmp_ctx);
 101         return NT_STATUS_OK;
 102 failed:
 103         talloc_free(tmp_ctx);
 104         return NT_STATUS_FOOBAR;
 105 }
 106
 107 uint64_t wreplsrv_local_max_version(struct wreplsrv_service *service)
 108 {
 109         int ret;
 110         struct ldb_context *ldb = service->wins_db;
 111         struct ldb_dn *dn;
 112         struct ldb_message **res = NULL;
 113         TALLOC_CTX *tmp_ctx = talloc_new(service);
 114         uint64_t maxVersion = 0;
 115
 116         dn = ldb_dn_explode(tmp_ctx, "CN=VERSION");
 117         if (!dn) goto failed;
 118
 119         /* find the record in the WINS database */
 120         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
 121                          NULL, NULL, &res);
 122         if (res != NULL) {
 123                 talloc_steal(tmp_ctx, res);
 124         }
 125         if (ret < 0) goto failed;
 126         if (ret > 1) goto failed;
 127
 128         if (ret == 1) {
 129                 maxVersion = ldb_msg_find_uint64(res[0], "maxVersion", 0);
 130         }
 131
 132 failed:
 133         talloc_free(tmp_ctx);
 134         return maxVersion;
 135 }
 136
 137 struct wreplsrv_owner *wreplsrv_find_owner(struct wreplsrv_owner *table, const char *wins_owner)
 138 {
 139         struct wreplsrv_owner *cur;
 140
 141         for (cur = table; cur; cur = cur->next) {
 142                 if (strcmp(cur->owner.address, wins_owner) == 0) {
 143                         return cur;
 144                 }
 145         }
 146
 147         return NULL;
 148 }
 149
 150 /*
 151  update the wins_owner_table max_version, if the given version is the highest version
 152  if no entry for the wins_owner exists yet, create one
 153 */
 154 static NTSTATUS wreplsrv_add_table(struct wreplsrv_service *service,
 155                                    TALLOC_CTX *mem_ctx, struct wreplsrv_owner **_table,
 156                                    const char *wins_owner, uint64_t version)
 157 {
 158         struct wreplsrv_owner *table = *_table;
 159         struct wreplsrv_owner *cur;
 160
 161         if (strcmp(WINSDB_OWNER_LOCAL, wins_owner) == 0) {
 162                 return NT_STATUS_OK;
 163         }
 164
 165         cur = wreplsrv_find_owner(table, wins_owner);
 166
 167         /* if it doesn't exists yet, create one */
 168         if (!cur) {
 169                 cur = talloc_zero(mem_ctx, struct wreplsrv_owner);
 170                 NT_STATUS_HAVE_NO_MEMORY(cur);
 171
 172                 cur->owner.address      = talloc_strdup(cur, wins_owner);
 173                 NT_STATUS_HAVE_NO_MEMORY(cur->owner.address);
 174                 cur->owner.min_version  = 0;
 175                 cur->owner.max_version  = 0;
 176                 cur->owner.type         = 1; /* don't know why this is always 1 */
 177
 178                 cur->partner            = wreplsrv_find_partner(service, wins_owner);
 179
 180                 DLIST_ADD(table, cur);
 181                 *_table = table;
 182         }
 183
 184         /* the min_version is always 0 here, and won't be updated */
 185
 186         /* if the given version is higher the then current nax_version, update */
 187         if (cur->owner.max_version < version) {
 188                 cur->owner.max_version = version;
 189         }
 190
 191         return NT_STATUS_OK;
 192 }
 193
 194 /*
 195   load the partner table
 196 */
 197 static NTSTATUS wreplsrv_load_table(struct wreplsrv_service *service)
 198 {
 199         struct ldb_message **res = NULL;
 200         int ret;
 201         NTSTATUS status;
 202         TALLOC_CTX *tmp_ctx = talloc_new(service);
 203         int i;
 204         const char *wins_owner;
 205         uint64_t version;
 206         const char * const attrs[] = {
 207                 "winsOwner",
 208                 "versionID",
 209                 NULL
 210         };
 211
 212         /* find the record in the WINS database */
 213         ret = ldb_search(service->wins_db, NULL, LDB_SCOPE_SUBTREE,
 214                          "(objectClass=winsRecord)", attrs, &res);
 215         if (res != NULL) {
 216                 talloc_steal(tmp_ctx, res);
 217         }
 218         status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 219         if (ret < 0) goto failed;
 220         if (ret == 0) goto done;
 221
 222         for (i=0; i < ret; i++) {
 223                 wins_owner     = ldb_msg_find_string(res[i], "winsOwner", NULL);
 224                 version        = ldb_msg_find_uint64(res[i], "versionID", 0);
 225
 226                 if (wins_owner) {
 227                         status = wreplsrv_add_table(service,
 228                                                     service, &service->table,
 229                                                     wins_owner, version);
 230                         if (!NT_STATUS_IS_OK(status)) goto failed;
 231                 }
 232                 talloc_free(res[i]);
 233
 234                 /* TODO: what's abut the per address owners? */
 235         }
 236 done:
 237         talloc_free(tmp_ctx);
 238         return NT_STATUS_OK;
 239 failed:
 240         talloc_free(tmp_ctx);
 241         return status;
 242 }
 243
 244 /*
 245   setup our replication partners
 246 */
 247 static NTSTATUS wreplsrv_setup_partners(struct wreplsrv_service *service)
 248 {
 249         NTSTATUS status;
 250
 251         status = wreplsrv_load_partners(service);
 252         NT_STATUS_NOT_OK_RETURN(status);
 253
 254         status = wreplsrv_load_table(service);
 255         NT_STATUS_NOT_OK_RETURN(status);
 256
 257         return NT_STATUS_OK;
 258 }
 259
 260 /*
 261   startup the wrepl task
 262 */
 263 static void wreplsrv_task_init(struct task_server *task)
 264 {
 265         NTSTATUS status;
 266         struct wreplsrv_service *service;
 267
 268         service = talloc_zero(task, struct wreplsrv_service);
 269         if (!service) {
 270                 task_server_terminate(task, "wreplsrv_task_init: out of memory");
 271                 return;
 272         }
 273         service->task = task;
 274         task->private = service;
 275
 276         /*
 277          * setup up all partners, and open the winsdb
 278          */
 279         status = wreplsrv_open_winsdb(service);
 280         if (!NT_STATUS_IS_OK(status)) {
 281                 task_server_terminate(task, "wreplsrv_task_init: wreplsrv_open_winsdb() failed");
 282                 return;
 283         }
 284
 285         /*
 286          * setup timed events for each partner we want to pull from
 287          */
 288         status = wreplsrv_setup_partners(service);
 289         if (!NT_STATUS_IS_OK(status)) {
 290                 task_server_terminate(task, "wreplsrv_task_init: wreplsrv_setup_partners() failed");
 291                 return;
 292         }
 293
 294         /*
 295          * setup listen sockets, so we can anwser requests from our partners,
 296          * which pull from us
 297          */
 298         status = wreplsrv_setup_sockets(service);
 299         if (!NT_STATUS_IS_OK(status)) {
 300                 task_server_terminate(task, "wreplsrv_task_init: wreplsrv_setup_sockets() failed");
 301                 return;
 302         }
 303
 304         irpc_add_name(task->msg_ctx, "wrepl_server");
 305 }
 306
 307 /*
 308   initialise the WREPL server
 309  */
 310 static NTSTATUS wreplsrv_init(struct event_context *event_ctx, const struct model_ops *model_ops)
 311 {
 312         return task_server_startup(event_ctx, model_ops, wreplsrv_task_init);
 313 }
 314
 315 /*
 316   register ourselves as a available server
 317 */
 318 NTSTATUS server_service_wrepl_init(void)
 319 {
 320         return register_server_service("wrepl", wreplsrv_init);
 321 }