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         191 : void set_smbd_shim(const struct smbd_shim *shim_functions)
      31             : {
      32         191 :         shim = *shim_functions;
      33         191 : }
      34             : 
      35         808 : void send_stat_cache_delete_message(struct messaging_context *msg_ctx,
      36             :                                     const char *name)
      37             : {
      38         808 :         if (shim.send_stat_cache_delete_message) {
      39         808 :                 shim.send_stat_cache_delete_message(msg_ctx, name);
      40             :         }
      41         808 : }
      42             : 
      43       72114 : bool change_to_root_user(void)
      44             : {
      45       72114 :         if (shim.change_to_root_user) {
      46       72114 :                 return shim.change_to_root_user();
      47             :         }
      48           0 :         return false;
      49             : }
      50             : 
      51        9236 : bool become_authenticated_pipe_user(struct auth_session_info *session_info)
      52             : {
      53        9236 :         if (shim.become_authenticated_pipe_user) {
      54        9236 :                 return shim.become_authenticated_pipe_user(session_info);
      55             :         }
      56             : 
      57           0 :         return false;
      58             : }
      59             : 
      60        9233 : bool unbecome_authenticated_pipe_user(void)
      61             : {
      62        9233 :         if (shim.unbecome_authenticated_pipe_user) {
      63        9233 :                 return shim.unbecome_authenticated_pipe_user();
      64             :         }
      65             : 
      66           0 :         return false;
      67             : }
      68             : 
      69             : /**
      70             :  * The following two functions need to be called from inside the low-level BRL
      71             :  * code for oplocks correctness in smbd.  Since other utility binaries also
      72             :  * link in some of the brl code directly, these dummy functions are necessary
      73             :  * to avoid needing to link in the oplocks code and its dependencies to all of
      74             :  * the utility binaries.
      75             :  */
      76         471 : void contend_level2_oplocks_begin(files_struct *fsp,
      77             :                                   enum level2_contention_type type)
      78             : {
      79         471 :         if (shim.contend_level2_oplocks_begin) {
      80         471 :                 shim.contend_level2_oplocks_begin(fsp, type);
      81             :         }
      82         471 :         return;
      83             : }
      84             : 
      85         471 : void contend_level2_oplocks_end(files_struct *fsp,
      86             :                                 enum level2_contention_type type)
      87             : {
      88         471 :         if (shim.contend_level2_oplocks_end) {
      89         471 :                 shim.contend_level2_oplocks_end(fsp, type);
      90             :         }
      91         471 :         return;
      92             : }
      93             : 
      94       74722 : void become_root(void)
      95             : {
      96       74722 :         if (shim.become_root) {
      97       58560 :                 shim.become_root();
      98             :         }
      99       74722 :         return;
     100             : }
     101             : 
     102       74720 : void unbecome_root(void)
     103             : {
     104       74720 :         if (shim.unbecome_root) {
     105       58558 :                 shim.unbecome_root();
     106             :         }
     107       74720 :         return;
     108             : }
     109             : 
     110           0 : void exit_server(const char *reason)
     111             : {
     112           0 :         if (shim.exit_server) {
     113           0 :                 shim.exit_server(reason);
     114             :         }
     115           0 :         exit(1);
     116             : }
     117             : 
     118        5270 : void exit_server_cleanly(const char *const reason)
     119             : {
     120        5270 :         if (shim.exit_server_cleanly) {
     121        5270 :                 shim.exit_server_cleanly(reason);
     122             :         }
     123           0 :         exit(0);
     124             : }