source3/locking/share_mode_lock.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Locking functions
   4    Copyright (C) Andrew Tridgell 1992-2000
   5    Copyright (C) Jeremy Allison 1992-2006
   6    Copyright (C) Volker Lendecke 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    Revision History:
  22
  23    12 aug 96: Erik.Devriendt@te6.siemens.be
  24    added support for shared memory implementation of share mode locking
  25
  26    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
  27    locking to deal with multiple share modes per open file.
  28
  29    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
  30    support.
  31
  32    rewritten completely to use new tdb code. Tridge, Dec '99
  33
  34    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
  35    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
  36 */
  37
  38 #include "includes.h"
  39 #include "system/filesys.h"
  40 #include "locking/proto.h"
  41 #include "smbd/globals.h"
  42 #include "dbwrap/dbwrap.h"
  43 #include "dbwrap/dbwrap_open.h"
  44 #include "../libcli/security/security.h"
  45 #include "serverid.h"
  46 #include "messages.h"
  47 #include "util_tdb.h"
  48 #include "../librpc/gen_ndr/ndr_open_files.h"
  49
  50 #undef DBGC_CLASS
  51 #define DBGC_CLASS DBGC_LOCKING
  52
  53 #define NO_LOCKING_COUNT (-1)
  54
  55 /* the locking database handle */
  56 static struct db_context *lock_db;
  57
  58 static bool locking_init_internal(bool read_only)
  59 {
  60         brl_init(read_only);
  61
  62         if (lock_db)
  63                 return True;
  64
  65         lock_db = db_open(NULL, lock_path("locking.tdb"),
  66                           lp_open_files_db_hash_size(),
  67                           TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
  68                           read_only?O_RDONLY:O_RDWR|O_CREAT, 0644,
  69                           DBWRAP_LOCK_ORDER_1);
  70
  71         if (!lock_db) {
  72                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
  73                 return False;
  74         }
  75
  76         if (!posix_locking_init(read_only))
  77                 return False;
  78
  79         return True;
  80 }
  81
  82 bool locking_init(void)
  83 {
  84         return locking_init_internal(false);
  85 }
  86
  87 bool locking_init_readonly(void)
  88 {
  89         return locking_init_internal(true);
  90 }
  91
  92 /*******************************************************************
  93  Deinitialize the share_mode management.
  94 ******************************************************************/
  95
  96 bool locking_end(void)
  97 {
  98         brl_shutdown();
  99         TALLOC_FREE(lock_db);
 100         return true;
 101 }
 102
 103 /*******************************************************************
 104  Form a static locking key for a dev/inode pair.
 105 ******************************************************************/
 106
 107 static TDB_DATA locking_key(const struct file_id *id)
 108 {
 109         return make_tdb_data((const uint8_t *)id, sizeof(*id));
 110 }
 111
 112 /*******************************************************************
 113  Get all share mode entries for a dev/inode pair.
 114 ********************************************************************/
 115
 116 static struct share_mode_data *parse_share_modes(TALLOC_CTX *mem_ctx,
 117                                                  const TDB_DATA dbuf)
 118 {
 119         struct share_mode_data *d;
 120         enum ndr_err_code ndr_err;
 121         DATA_BLOB blob;
 122
 123         d = talloc(mem_ctx, struct share_mode_data);
 124         if (d == NULL) {
 125                 DEBUG(0, ("talloc failed\n"));
 126                 goto fail;
 127         }
 128
 129         blob.data = dbuf.dptr;
 130         blob.length = dbuf.dsize;
 131
 132         ndr_err = ndr_pull_struct_blob(
 133                 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
 134         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 135                 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
 136                 goto fail;
 137         }
 138
 139         d->modified = false;
 140         d->fresh = false;
 141
 142         if (DEBUGLEVEL >= 10) {
 143                 DEBUG(10, ("parse_share_modes:\n"));
 144                 NDR_PRINT_DEBUG(share_mode_data, d);
 145         }
 146
 147         return d;
 148 fail:
 149         TALLOC_FREE(d);
 150         return NULL;
 151 }
 152
 153 /*******************************************************************
 154  Create a storable data blob from a modified share_mode_data struct.
 155 ********************************************************************/
 156
 157 static TDB_DATA unparse_share_modes(struct share_mode_data *d)
 158 {
 159         DATA_BLOB blob;
 160         enum ndr_err_code ndr_err;
 161
 162         if (DEBUGLEVEL >= 10) {
 163                 DEBUG(10, ("unparse_share_modes:\n"));
 164                 NDR_PRINT_DEBUG(share_mode_data, d);
 165         }
 166
 167         if (d->num_share_modes == 0) {
 168                 DEBUG(10, ("No used share mode found\n"));
 169                 return make_tdb_data(NULL, 0);
 170         }
 171
 172         ndr_err = ndr_push_struct_blob(
 173                 &blob, d, d, (ndr_push_flags_fn_t)ndr_push_share_mode_data);
 174         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 175                 smb_panic("ndr_push_share_mode_lock failed");
 176         }
 177
 178         return make_tdb_data(blob.data, blob.length);
 179 }
 180
 181 /*******************************************************************
 182  If modified, store the share_mode_data back into the database.
 183 ********************************************************************/
 184
 185 static int share_mode_data_destructor(struct share_mode_data *d)
 186 {
 187         NTSTATUS status;
 188         TDB_DATA data;
 189
 190         if (!d->modified) {
 191                 return 0;
 192         }
 193
 194         data = unparse_share_modes(d);
 195
 196         if (data.dptr == NULL) {
 197                 if (!d->fresh) {
 198                         /* There has been an entry before, delete it */
 199
 200                         status = dbwrap_record_delete(d->record);
 201                         if (!NT_STATUS_IS_OK(status)) {
 202                                 char *errmsg;
 203
 204                                 DEBUG(0, ("delete_rec returned %s\n",
 205                                           nt_errstr(status)));
 206
 207                                 if (asprintf(&errmsg, "could not delete share "
 208                                              "entry: %s\n",
 209                                              nt_errstr(status)) == -1) {
 210                                         smb_panic("could not delete share"
 211                                                   "entry");
 212                                 }
 213                                 smb_panic(errmsg);
 214                         }
 215                 }
 216                 goto done;
 217         }
 218
 219         status = dbwrap_record_store(d->record, data, TDB_REPLACE);
 220         if (!NT_STATUS_IS_OK(status)) {
 221                 char *errmsg;
 222
 223                 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
 224
 225                 if (asprintf(&errmsg, "could not store share mode entry: %s",
 226                              nt_errstr(status)) == -1) {
 227                         smb_panic("could not store share mode entry");
 228                 }
 229                 smb_panic(errmsg);
 230         }
 231
 232  done:
 233
 234         return 0;
 235 }
 236
 237 /*******************************************************************
 238  Allocate a new share_mode_data struct, mark it unmodified.
 239  fresh is set to note that currently there is no database entry.
 240 ********************************************************************/
 241
 242 static struct share_mode_data *fresh_share_mode_lock(
 243         TALLOC_CTX *mem_ctx, const char *servicepath,
 244         const struct smb_filename *smb_fname,
 245         const struct timespec *old_write_time)
 246 {
 247         struct share_mode_data *d;
 248
 249         if ((servicepath == NULL) || (smb_fname == NULL) ||
 250             (old_write_time == NULL)) {
 251                 return NULL;
 252         }
 253
 254         d = talloc_zero(mem_ctx, struct share_mode_data);
 255         if (d == NULL) {
 256                 goto fail;
 257         }
 258         d->base_name = talloc_strdup(d, smb_fname->base_name);
 259         if (d->base_name == NULL) {
 260                 goto fail;
 261         }
 262         if (smb_fname->stream_name != NULL) {
 263                 d->stream_name = talloc_strdup(d, smb_fname->stream_name);
 264                 if (d->stream_name == NULL) {
 265                         goto fail;
 266                 }
 267         }
 268         d->servicepath = talloc_strdup(d, servicepath);
 269         if (d->servicepath == NULL) {
 270                 goto fail;
 271         }
 272         d->old_write_time = *old_write_time;
 273         d->modified = false;
 274         d->fresh = true;
 275         return d;
 276 fail:
 277         DEBUG(0, ("talloc failed\n"));
 278         TALLOC_FREE(d);
 279         return NULL;
 280 }
 281
 282 /*******************************************************************
 283  Either fetch a share mode from the database, or allocate a fresh
 284  one if the record doesn't exist.
 285 ********************************************************************/
 286
 287 static struct share_mode_lock *get_share_mode_lock_internal(
 288         TALLOC_CTX *mem_ctx, struct file_id id,
 289         const char *servicepath, const struct smb_filename *smb_fname,
 290         const struct timespec *old_write_time)
 291 {
 292         struct share_mode_lock *lck;
 293         struct share_mode_data *d;
 294         struct db_record *rec;
 295         TDB_DATA key = locking_key(&id);
 296         TDB_DATA value;
 297
 298         rec = dbwrap_fetch_locked(lock_db, mem_ctx, key);
 299         if (rec == NULL) {
 300                 DEBUG(3, ("Could not lock share entry\n"));
 301                 return NULL;
 302         }
 303
 304         value = dbwrap_record_get_value(rec);
 305
 306         if (value.dptr == NULL) {
 307                 d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
 308                                           old_write_time);
 309         } else {
 310                 d = parse_share_modes(mem_ctx, value);
 311         }
 312
 313         if (d == NULL) {
 314                 DEBUG(5, ("get_share_mode_lock_internal: "
 315                         "Could not get share mode lock\n"));
 316                 TALLOC_FREE(rec);
 317                 return NULL;
 318         }
 319         d->id = id;
 320         d->record = talloc_move(d, &rec);
 321         talloc_set_destructor(d, share_mode_data_destructor);
 322
 323         lck = talloc(mem_ctx, struct share_mode_lock);
 324         if (lck == NULL) {
 325                 DEBUG(1, ("talloc failed\n"));
 326                 TALLOC_FREE(d);
 327                 return NULL;
 328         }
 329         lck->data = talloc_move(lck, &d);
 330         return lck;
 331 }
 332
 333 /*
 334  * We can only ever have one share mode locked. Users of
 335  * get_share_mode_lock never see this, it will be refcounted by
 336  * talloc_reference.
 337  */
 338 static struct share_mode_lock *the_lock;
 339
 340 static int the_lock_destructor(struct share_mode_lock *l)
 341 {
 342         the_lock = NULL;
 343         return 0;
 344 }
 345
 346 /*******************************************************************
 347  Get a share_mode_lock, Reference counted to allow nested calls.
 348 ********************************************************************/
 349
 350 struct share_mode_lock *get_share_mode_lock(
 351         TALLOC_CTX *mem_ctx,
 352         struct file_id id,
 353         const char *servicepath,
 354         const struct smb_filename *smb_fname,
 355         const struct timespec *old_write_time)
 356 {
 357         TALLOC_CTX *frame = talloc_stackframe();
 358
 359         struct share_mode_lock *lck;
 360
 361         if (the_lock == NULL) {
 362                 the_lock = get_share_mode_lock_internal(
 363                         frame, id, servicepath, smb_fname, old_write_time);
 364                 if (the_lock == NULL) {
 365                         goto fail;
 366                 }
 367                 talloc_set_destructor(the_lock, the_lock_destructor);
 368         }
 369         if (!file_id_equal(&the_lock->data->id, &id)) {
 370                 DEBUG(1, ("Can not lock two share modes simultaneously\n"));
 371                 goto fail;
 372         }
 373         lck = talloc(mem_ctx, struct share_mode_lock);
 374         if (lck == NULL) {
 375                 DEBUG(1, ("talloc failed\n"));
 376                 goto fail;
 377         }
 378         if (talloc_reference(lck, the_lock) == NULL) {
 379                 DEBUG(1, ("talloc_reference failed\n"));
 380                 goto fail;
 381         }
 382         lck->data = the_lock->data;
 383         TALLOC_FREE(frame);
 384         return lck;
 385 fail:
 386         TALLOC_FREE(frame);
 387         return NULL;
 388 }
 389
 390 static void fetch_share_mode_unlocked_parser(
 391         TDB_DATA key, TDB_DATA data, void *private_data)
 392 {
 393         struct share_mode_lock *lck = talloc_get_type_abort(
 394                 private_data, struct share_mode_lock);
 395
 396         lck->data = parse_share_modes(lck, data);
 397 }
 398
 399 /*******************************************************************
 400  Get a share_mode_lock without locking the database or reference
 401  counting. Used by smbstatus to display existing share modes.
 402 ********************************************************************/
 403
 404 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
 405                                                   struct file_id id)
 406 {
 407         struct share_mode_lock *lck;
 408         TDB_DATA key = locking_key(&id);
 409         NTSTATUS status;
 410
 411         lck = talloc(mem_ctx, struct share_mode_lock);
 412         if (lck == NULL) {
 413                 DEBUG(0, ("talloc failed\n"));
 414                 return NULL;
 415         }
 416         status = dbwrap_parse_record(
 417                 lock_db, key, fetch_share_mode_unlocked_parser, lck);
 418         if (!NT_STATUS_IS_OK(status) ||
 419             (lck->data == NULL)) {
 420                 TALLOC_FREE(lck);
 421                 return NULL;
 422         }
 423         return lck;
 424 }
 425
 426 struct forall_state {
 427         void (*fn)(const struct share_mode_entry *entry,
 428                    const char *sharepath,
 429                    const char *fname,
 430                    void *private_data);
 431         void *private_data;
 432 };
 433
 434 static int traverse_fn(struct db_record *rec, void *_state)
 435 {
 436         struct forall_state *state = (struct forall_state *)_state;
 437         uint32_t i;
 438         TDB_DATA key;
 439         TDB_DATA value;
 440         DATA_BLOB blob;
 441         enum ndr_err_code ndr_err;
 442         struct share_mode_data *d;
 443
 444         key = dbwrap_record_get_key(rec);
 445         value = dbwrap_record_get_value(rec);
 446
 447         /* Ensure this is a locking_key record. */
 448         if (key.dsize != sizeof(struct file_id))
 449                 return 0;
 450
 451         d = talloc(talloc_tos(), struct share_mode_data);
 452         if (d == NULL) {
 453                 return 0;
 454         }
 455
 456         blob.data = value.dptr;
 457         blob.length = value.dsize;
 458
 459         ndr_err = ndr_pull_struct_blob(
 460                 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
 461         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 462                 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
 463                 return 0;
 464         }
 465         for (i=0; i<d->num_share_modes; i++) {
 466                 state->fn(&d->share_modes[i],
 467                           d->servicepath, d->base_name,
 468                           state->private_data);
 469         }
 470         TALLOC_FREE(d);
 471
 472         return 0;
 473 }
 474
 475 /*******************************************************************
 476  Call the specified function on each entry under management by the
 477  share mode system.
 478 ********************************************************************/
 479
 480 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
 481                                  const char *, void *),
 482                       void *private_data)
 483 {
 484         struct forall_state state;
 485         NTSTATUS status;
 486         int count;
 487
 488         if (lock_db == NULL)
 489                 return 0;
 490
 491         state.fn = fn;
 492         state.private_data = private_data;
 493
 494         status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
 495                                       &count);
 496
 497         if (!NT_STATUS_IS_OK(status)) {
 498                 return -1;
 499         } else {
 500                 return count;
 501         }
 502 }