LCOV - code coverage report
Current view: top level - source3/lib - server_mutex.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 19 35 54.3 %
Date: 2021-09-23 10:06:22 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             :    Authenticate against a remote domain
       4             :    Copyright (C) Andrew Tridgell 1992-2002
       5             :    Copyright (C) Andrew Bartlett 2002
       6             :    
       7             :    This program is free software; you can redistribute it and/or modify
       8             :    it under the terms of the GNU General Public License as published by
       9             :    the Free Software Foundation; either version 3 of the License, or
      10             :    (at your option) any later version.
      11             :    
      12             :    This program is distributed in the hope that it will be useful,
      13             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :    GNU General Public License for more details.
      16             :    
      17             :    You should have received a copy of the GNU General Public License
      18             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      19             : */
      20             : 
      21             : #include "includes.h"
      22             : #include "system/filesys.h"
      23             : #include "lib/tdb_wrap/tdb_wrap.h"
      24             : #include "util_tdb.h"
      25             : #include "lib/param/param.h"
      26             : 
      27             : /* For reasons known only to MS, many of their NT/Win2k versions
      28             :    need serialised access only.  Two connections at the same time
      29             :    may (in certain situations) cause connections to be reset,
      30             :    or access to be denied.
      31             : 
      32             :    This locking allows smbd's multithread architecture to look
      33             :    like the single-connection that NT makes. */
      34             : 
      35             : struct named_mutex {
      36             :         struct tdb_wrap *tdb;
      37             :         char *name;
      38             : };
      39             : 
      40          51 : static int unlock_named_mutex(struct named_mutex *mutex)
      41             : {
      42          51 :         tdb_unlock_bystring(mutex->tdb->tdb, mutex->name);
      43          51 :         return 0;
      44             : }
      45             : 
      46          51 : struct named_mutex *grab_named_mutex(TALLOC_CTX *mem_ctx, const char *name,
      47             :                                      int timeout)
      48             : {
      49             :         struct named_mutex *result;
      50             :         struct loadparm_context *lp_ctx;
      51             :         char *fname;
      52             : 
      53          51 :         result = talloc(mem_ctx, struct named_mutex);
      54          51 :         if (result == NULL) {
      55           0 :                 DEBUG(0, ("talloc failed\n"));
      56           0 :                 return NULL;
      57             :         }
      58             : 
      59          51 :         lp_ctx = loadparm_init_s3(result, loadparm_s3_helpers());
      60          51 :         if (lp_ctx == NULL) {
      61           0 :                 DEBUG(0, ("loadparm_init_s3 failed\n"));
      62           0 :                 talloc_free(result);
      63           0 :                 return NULL;
      64             :         }
      65             : 
      66          51 :         result->name = talloc_strdup(result, name);
      67          51 :         if (result->name == NULL) {
      68           0 :                 DEBUG(0, ("talloc failed\n"));
      69           0 :                 TALLOC_FREE(result);
      70           0 :                 return NULL;
      71             :         }
      72             : 
      73          51 :         fname = lock_path(talloc_tos(), "mutex.tdb");
      74          51 :         if (fname == NULL) {
      75           0 :                 TALLOC_FREE(result);
      76           0 :                 return NULL;
      77             :         }
      78             : 
      79          51 :         result->tdb = tdb_wrap_open(result, fname,
      80             :                                     lpcfg_tdb_hash_size(lp_ctx, fname),
      81             :                                     lpcfg_tdb_flags(lp_ctx,
      82             :                                                     TDB_DEFAULT |
      83             :                                                     TDB_CLEAR_IF_FIRST |
      84             :                                                     TDB_INCOMPATIBLE_HASH),
      85             :                                     O_RDWR|O_CREAT, 0600);
      86          51 :         TALLOC_FREE(fname);
      87          51 :         talloc_unlink(result, lp_ctx);
      88          51 :         if (result->tdb == NULL) {
      89           0 :                 DEBUG(1, ("Could not open mutex.tdb: %s\n",
      90             :                           strerror(errno)));
      91           0 :                 TALLOC_FREE(result);
      92           0 :                 return NULL;
      93             :         }
      94             : 
      95          51 :         if (tdb_lock_bystring_with_timeout(result->tdb->tdb, name,
      96             :                                            timeout) != 0) {
      97           0 :                 DEBUG(1, ("Could not get the lock for %s\n", name));
      98           0 :                 TALLOC_FREE(result);
      99           0 :                 return NULL;
     100             :         }
     101             : 
     102          51 :         talloc_set_destructor(result, unlock_named_mutex);
     103          51 :         return result;
     104             : }

Generated by: LCOV version 1.13