Line data    Source code

       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    Runtime plugin adapter for various "smbd"-functions.
       4             : 
       5             :    Copyright (C) Gerald (Jerry) Carter          2004.
       6             :    Copyright (C) Andrew Bartlett                2011.
       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             : 
      22             : /* Shim functions required due to the horrible dependency mess
      23             :    in Samba. */
      24             : 
      25             : #include "includes.h"
      26             : #include "smbd_shim.h"
      27             : 
      28             : static struct smbd_shim shim;
      29             : 
      30         609 : void set_smbd_shim(const struct smbd_shim *shim_functions)
      31             : {
      32         609 :         shim = *shim_functions;
      33         609 : }
      34             : 
      35      793012 : bool change_to_root_user(void)
      36             : {
      37      793012 :         if (shim.change_to_root_user) {
      38      792744 :                 return shim.change_to_root_user();
      39             :         }
      40         268 :         return false;
      41             : }
      42             : 
      43      603606 : bool become_authenticated_pipe_user(struct auth_session_info *session_info)
      44             : {
      45      603606 :         if (shim.become_authenticated_pipe_user) {
      46      603606 :                 return shim.become_authenticated_pipe_user(session_info);
      47             :         }
      48             : 
      49           0 :         return false;
      50             : }
      51             : 
      52      603606 : bool unbecome_authenticated_pipe_user(void)
      53             : {
      54      603606 :         if (shim.unbecome_authenticated_pipe_user) {
      55      603606 :                 return shim.unbecome_authenticated_pipe_user();
      56             :         }
      57             : 
      58           0 :         return false;
      59             : }
      60             : 
      61             : /**
      62             :  * The following two functions need to be called from inside the low-level BRL
      63             :  * code for oplocks correctness in smbd.  Since other utility binaries also
      64             :  * link in some of the brl code directly, these dummy functions are necessary
      65             :  * to avoid needing to link in the oplocks code and its dependencies to all of
      66             :  * the utility binaries.
      67             :  */
      68      193386 : void contend_level2_oplocks_begin(files_struct *fsp,
      69             :                                   enum level2_contention_type type)
      70             : {
      71      193386 :         if (shim.contend_level2_oplocks_begin) {
      72      193386 :                 shim.contend_level2_oplocks_begin(fsp, type);
      73             :         }
      74      193386 :         return;
      75             : }
      76             : 
      77      192978 : void contend_level2_oplocks_end(files_struct *fsp,
      78             :                                 enum level2_contention_type type)
      79             : {
      80      192978 :         if (shim.contend_level2_oplocks_end) {
      81      192978 :                 shim.contend_level2_oplocks_end(fsp, type);
      82             :         }
      83      192978 :         return;
      84             : }
      85             : 
      86     3939874 : void become_root(void)
      87             : {
      88     3939874 :         if (shim.become_root) {
      89     3903557 :                 shim.become_root();
      90             :         }
      91     3939874 :         return;
      92             : }
      93             : 
      94     3939874 : void unbecome_root(void)
      95             : {
      96     3939874 :         if (shim.unbecome_root) {
      97     3903557 :                 shim.unbecome_root();
      98             :         }
      99     3939874 :         return;
     100             : }
     101             : 
     102           0 : void exit_server(const char *reason)
     103             : {
     104           0 :         if (shim.exit_server) {
     105           0 :                 shim.exit_server(reason);
     106             :         }
     107           0 :         exit(1);
     108             : }
     109             : 
     110       31551 : void exit_server_cleanly(const char *const reason)
     111             : {
     112       31551 :         if (shim.exit_server_cleanly) {
     113       31551 :                 shim.exit_server_cleanly(reason);
     114             :         }
     115           0 :         exit(0);
     116             : }