LCOV - code coverage report
Current view: top level - lib/util - debug_s3.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 23 49 46.9 %
Date: 2021-09-23 10:06:22 Functions: 2 5 40.0 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    Samba utility functions
       4             :    Copyright (C) Andrew Bartlett 2011
       5             :    Copyright (C) Andrew Tridgell 1992-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 "lib/util/server_id.h"
      23             : #include "librpc/gen_ndr/messaging.h"
      24             : #include "messages.h"
      25             : #include "lib/util/memory.h"
      26             : 
      27             : /* This is the Samba3-specific implementation of reopen_logs(), which
      28             :  * calls out to the s3 loadparm code, and means that we don't depend
      29             :  * on loadparm directly. */
      30             : 
      31      136046 : bool reopen_logs(void)
      32             : {
      33      136046 :         if (lp_loaded()) {
      34      952322 :                 struct debug_settings settings = {
      35      136046 :                         .max_log_size = lp_max_log_size(),
      36      136046 :                         .timestamp_logs = lp_timestamp_logs(),
      37      136046 :                         .debug_prefix_timestamp = lp_debug_prefix_timestamp(),
      38      136046 :                         .debug_hires_timestamp = lp_debug_hires_timestamp(),
      39      136046 :                         .debug_pid = lp_debug_pid(),
      40      136046 :                         .debug_uid = lp_debug_uid(),
      41      136046 :                         .debug_class = lp_debug_class(),
      42             :                 };
      43      119302 :                 const struct loadparm_substitution *lp_sub =
      44       16744 :                         loadparm_s3_global_substitution();
      45             : 
      46      136046 :                 debug_set_logfile(lp_logfile(talloc_tos(), lp_sub));
      47      136046 :                 debug_parse_levels(lp_log_level(talloc_tos(), lp_sub));
      48      272092 :                 debug_set_settings(&settings,
      49      136046 :                                    lp_logging(talloc_tos(), lp_sub),
      50             :                                    lp_syslog(),
      51      136046 :                                    lp_syslog_only());
      52             :         } else {
      53             :                 /*
      54             :                  * Parameters are not yet loaded - configure debugging with
      55             :                  * reasonable defaults to enable logging for early
      56             :                  * startup failures.
      57             :                  */
      58           0 :                 struct debug_settings settings = {
      59             :                         .max_log_size = 5000,
      60             :                         .timestamp_logs = true,
      61             :                         .debug_prefix_timestamp = false,
      62             :                         .debug_hires_timestamp = true,
      63             :                         .debug_pid = false,
      64             :                         .debug_uid = false,
      65             :                         .debug_class = false,
      66             :                 };
      67           0 :                 debug_set_settings(&settings,
      68             :                                    "file",
      69             :                                    1,
      70             :                                    false);
      71             :         }
      72      136046 :         return reopen_logs_internal();
      73             : }
      74             : 
      75             : /****************************************************************************
      76             :  Receive a "set debug level" message.
      77             : ****************************************************************************/
      78             : 
      79           0 : void debug_message(struct messaging_context *msg_ctx,
      80             :                           void *private_data,
      81             :                           uint32_t msg_type,
      82             :                           struct server_id src,
      83             :                           DATA_BLOB *data)
      84             : {
      85           0 :         const char *params_str = (const char *)data->data;
      86             : 
      87             :         /* Check, it's a proper string! */
      88           0 :         if (params_str[(data->length)-1] != '\0') {
      89           0 :                 DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
      90             :                           (unsigned int)procid_to_pid(&src),
      91             :                           (unsigned int)getpid()));
      92           0 :                 return;
      93             :         }
      94             : 
      95           0 :         DEBUG(3, ("INFO: Remote set of debug to `%s'  (pid %u from pid %u)\n",
      96             :                   params_str, (unsigned int)getpid(),
      97             :                   (unsigned int)procid_to_pid(&src)));
      98             : 
      99           0 :         debug_parse_levels(params_str);
     100             : }
     101             : 
     102             : /****************************************************************************
     103             :  Return current debug level.
     104             : ****************************************************************************/
     105             : 
     106           0 : static void debuglevel_message(struct messaging_context *msg_ctx,
     107             :                                void *private_data, 
     108             :                                uint32_t msg_type, 
     109             :                                struct server_id src,
     110             :                                DATA_BLOB *data)
     111             : {
     112           0 :         char *message = debug_list_class_names_and_levels();
     113             :         struct server_id_buf tmp;
     114             : 
     115           0 :         if (!message) {
     116           0 :                 DEBUG(0,("debuglevel_message - debug_list_class_names_and_levels returned NULL\n"));
     117           0 :                 return;
     118             :         }
     119             : 
     120           0 :         DEBUG(1, ("INFO: Received REQ_DEBUGLEVEL message from PID %s\n",
     121             :                   server_id_str_buf(src, &tmp)));
     122           0 :         messaging_send_buf(msg_ctx, src, MSG_DEBUGLEVEL,
     123           0 :                            (uint8_t *)message, strlen(message) + 1);
     124             : 
     125           0 :         TALLOC_FREE(message);
     126             : }
     127             : 
     128           0 : static void debug_ringbuf_log(struct messaging_context *msg_ctx,
     129             :                               void *private_data,
     130             :                               uint32_t msg_type,
     131             :                               struct server_id src,
     132             :                               DATA_BLOB *data)
     133             : {
     134           0 :         char *log = debug_get_ringbuf();
     135           0 :         size_t logsize = debug_get_ringbuf_size();
     136             : 
     137           0 :         if (log == NULL) {
     138           0 :                 log = discard_const_p(char, "*disabled*\n");
     139           0 :                 logsize = strlen(log) + 1;
     140             :         }
     141             : 
     142           0 :         messaging_send_buf(msg_ctx, src, MSG_RINGBUF_LOG, (uint8_t *)log,
     143             :                            logsize);
     144           0 : }
     145             : 
     146        4394 : void debug_register_msgs(struct messaging_context *msg_ctx)
     147             : {
     148        4394 :         messaging_register(msg_ctx, NULL, MSG_DEBUG, debug_message);
     149        4394 :         messaging_register(msg_ctx, NULL, MSG_REQ_DEBUGLEVEL,
     150             :                            debuglevel_message);
     151        4394 :         messaging_register(msg_ctx, NULL, MSG_REQ_RINGBUF_LOG,
     152             :                            debug_ringbuf_log);
     153        4394 : }

Generated by: LCOV version 1.13