source3/lib/dumpcore.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4
   5    Copyright (C) Andrew Tridgell 1992-2011
   6
   7    based on old fault.c code, which had:
   8
   9    Copyright (C) Jeremy Allison 2001-2007
  10    Copyright (C) Simo Sorce 2001
  11    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
  12    Copyright (C) James Peach 2006
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 3 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26 */
  27
  28 #include "includes.h"
  29 #include "lib/util/util_file.h"
  30 #include "system/filesys.h"
  31
  32 #ifdef HAVE_SYS_SYSCTL_H
  33 #include <sys/sysctl.h>
  34 #endif
  35
  36 #ifdef HAVE_SYS_PRCTL_H
  37 #include <sys/prctl.h>
  38 #endif
  39
  40 static char *corepath;
  41 static bool using_helper_binary = false;
  42
  43 /**
  44  * Build up the default corepath as "<logbase>/cores/<progname>"
  45  */
  46 static char *get_default_corepath(const char *logbase, const char *progname)
  47 {
  48         const mode_t mode = 0700;
  49         const uid_t uid = getuid();
  50         char *tmp_corepath;
  51
  52         /* Setup core dir in logbase. */
  53         tmp_corepath = talloc_asprintf(NULL, "%s/cores", logbase);
  54         if (!tmp_corepath) {
  55                 DEBUG(0, ("Out of memory\n"));
  56                 return NULL;
  57         }
  58
  59         if (!directory_create_or_exist_strict(tmp_corepath, uid, mode)) {
  60                 DEBUG(0, ("Failed to create %s for user %d with mode 0%o\n",
  61                           tmp_corepath, (int)uid, (int)mode));
  62                 goto err_out;
  63         }
  64
  65         /* Setup progname-specific core subdir */
  66         tmp_corepath = talloc_asprintf_append(tmp_corepath, "/%s", progname);
  67         if (!tmp_corepath) {
  68                 DEBUG(0, ("Out of memory\n"));
  69                 goto err_out;
  70         }
  71
  72         if (!directory_create_or_exist(tmp_corepath, mode)) {
  73                 DEBUG(0, ("Failed to create %s for user %d with mode 0%o\n",
  74                           tmp_corepath, (int)uid, (int)mode));
  75                 goto err_out;
  76         }
  77
  78         return tmp_corepath;
  79
  80  err_out:
  81         talloc_free(tmp_corepath);
  82         return NULL;
  83 }
  84
  85
  86 /**
  87  * Get the FreeBSD corepath.
  88  *
  89  * On FreeBSD the current working directory is ignored when creating a core
  90  * file.  Instead the core directory is controlled via sysctl.  This consults
  91  * the value of "kern.corefile" so the correct corepath can be printed out
  92  * before dump_core() calls abort.
  93  */
  94 #if (defined(FREEBSD) && defined(HAVE_SYSCTLBYNAME))
  95 static char *get_freebsd_corepath(void)
  96 {
  97         char *tmp_corepath = NULL;
  98         char *end = NULL;
  99         size_t len = 128;
 100         int ret;
 101
 102         /* Loop with increasing sizes so we don't allocate too much. */
 103         do {
 104                 if (len > 1024)  {
 105                         goto err_out;
 106                 }
 107
 108                 tmp_corepath = (char *)talloc_realloc(NULL, tmp_corepath,
 109                                                       char, len);
 110                 if (!tmp_corepath) {
 111                         return NULL;
 112                 }
 113
 114                 ret = sysctlbyname("kern.corefile", tmp_corepath, &len, NULL,
 115                                    0);
 116                 if (ret == -1) {
 117                         if (errno != ENOMEM) {
 118                                 DEBUG(0, ("sysctlbyname failed getting "
 119                                           "kern.corefile %s\n",
 120                                           strerror(errno)));
 121                                 goto err_out;
 122                         }
 123
 124                         /* Not a large enough array, try a bigger one. */
 125                         len = len << 1;
 126                 }
 127         } while (ret == -1);
 128
 129         /* Strip off the common filename expansion */
 130         if ((end = strrchr_m(tmp_corepath, '/'))) {
 131                 *end = '\0';
 132         }
 133
 134         return tmp_corepath;
 135
 136  err_out:
 137         if (tmp_corepath) {
 138                 talloc_free(tmp_corepath);
 139         }
 140         return NULL;
 141 }
 142 #endif
 143
 144 #if defined(HAVE_SYS_KERNEL_PROC_CORE_PATTERN)
 145
 146 /**
 147  * Get the Linux corepath.
 148  *
 149  * On Linux the contents of /proc/sys/kernel/core_pattern indicates the
 150  * location of the core path.
 151  */
 152 static char *get_linux_corepath(void)
 153 {
 154         char *end;
 155         int fd;
 156         char *result;
 157
 158         fd = open("/proc/sys/kernel/core_pattern", O_RDONLY, 0);
 159         if (fd == -1) {
 160                 return NULL;
 161         }
 162
 163         result = afdgets(fd, NULL, 0);
 164         close(fd);
 165
 166         if (result == NULL) {
 167                 return NULL;
 168         }
 169
 170         if (result[0] != '/') {
 171                 /*
 172                  * No absolute path, use the default (cwd)
 173                  */
 174                 if (result[0] == '|') {
 175                         /*
 176                         * Core dump handled by helper binaries
 177                         */
 178                         using_helper_binary = true;
 179                 }
 180                 TALLOC_FREE(result);
 181                 return NULL;
 182         }
 183         /* Strip off the common filename expansion */
 184
 185         end = strrchr_m(result, '/');
 186
 187         if ((end != result) /* this would be the only / */
 188             && (end != NULL)) {
 189                 *end = '\0';
 190         }
 191         return result;
 192 }
 193 #endif
 194
 195
 196 /**
 197  * Try getting system-specific corepath if one exists.
 198  *
 199  * If the system doesn't define a corepath, then the default is used.
 200  */
 201 static char *get_corepath(const char *logbase, const char *progname)
 202 {
 203 #if (defined(FREEBSD) && defined(HAVE_SYSCTLBYNAME))
 204         char *tmp_corepath = NULL;
 205         tmp_corepath = get_freebsd_corepath();
 206
 207         /* If this has been set correctly, we're done. */
 208         if (tmp_corepath) {
 209                 return tmp_corepath;
 210         }
 211 #endif
 212
 213 #if defined(HAVE_SYS_KERNEL_PROC_CORE_PATTERN)
 214         char *tmp_corepath = NULL;
 215         tmp_corepath = get_linux_corepath();
 216
 217         /* If this has been set correctly, we're done. */
 218         if (tmp_corepath) {
 219                 return tmp_corepath;
 220         }
 221 #endif
 222
 223         /* Fall back to the default. */
 224         return get_default_corepath(logbase, progname);
 225 }
 226
 227 /*******************************************************************
 228 make all the preparations to safely dump a core file
 229 ********************************************************************/
 230
 231 void dump_core_setup(const char *progname, const char *log_file)
 232 {
 233         char *logbase = NULL;
 234         char *end = NULL;
 235
 236         if (log_file && *log_file) {
 237                 if (asprintf(&logbase, "%s", log_file) < 0) {
 238                         return;
 239                 }
 240                 if ((end = strrchr_m(logbase, '/'))) {
 241                         *end = '\0';
 242                 }
 243         } else {
 244                 /* We will end up here if the log file is given on the command
 245                  * line by the -l option but the "log file" option is not set
 246                  * in smb.conf.
 247                  */
 248                 if (asprintf(&logbase, "%s", get_dyn_LOGFILEBASE()) < 0) {
 249                         return;
 250                 }
 251         }
 252
 253         SMB_ASSERT(progname != NULL);
 254
 255         corepath = get_corepath(logbase, progname);
 256         if (!corepath) {
 257                 DEBUG(0, ("Unable to setup corepath for %s: %s\n", progname,
 258                           strerror(errno)));
 259                 goto out;
 260         }
 261
 262         /* FIXME: if we have a core-plus-pid facility, configurably set
 263          * this up here.
 264          */
 265  out:
 266         SAFE_FREE(logbase);
 267 }
 268
 269  void dump_core(void)
 270 {
 271         static bool called;
 272
 273         if (called) {
 274                 DEBUG(0, ("dump_core() called recursive\n"));
 275                 exit(1);
 276         }
 277         called = true;
 278
 279         /* Note that even if core dumping has been disabled, we still set up
 280          * the core path. This is to handle the case where core dumping is
 281          * turned on in smb.conf and the relevant daemon is not restarted.
 282          */
 283         if (!lp_enable_core_files()) {
 284                 DEBUG(0, ("Exiting on internal error (core file administratively disabled)\n"));
 285                 exit(1);
 286         }
 287
 288 #if DUMP_CORE
 289         /* If we're running as non root we might not be able to dump the core
 290          * file to the corepath.  There must not be an unbecome_root() before
 291          * we call abort(). */
 292         if (geteuid() != sec_initial_uid()) {
 293                 become_root();
 294         }
 295
 296         if (corepath == NULL) {
 297                 DEBUG(0, ("Can not dump core: corepath not set up\n"));
 298                 exit(1);
 299         }
 300
 301         if (*corepath != '\0') {
 302                 /*
 303                  * Check whether coredump is handled by helper binaries or not.
 304                  * If so skip chdir().
 305                  */
 306                 if (!using_helper_binary) {
 307                         /* The chdir might fail if we dump core before we finish
 308                          * processing the config file.
 309                          */
 310                         if (chdir(corepath) != 0) {
 311                                 DEBUG(0, ("unable to change to %s\n", corepath));
 312                                 DEBUGADD(0, ("refusing to dump core\n"));
 313                                 exit(1);
 314                         }
 315
 316                         DEBUG(0,("dumping core in %s\n", corepath));
 317                 } else {
 318                         DEBUG(0,("coredump is handled by helper binary "
 319                                  "specified at /proc/sys/kernel/core_pattern\n"));
 320                 }
 321         }
 322
 323         umask(~(0700));
 324         dbgflush();
 325
 326 #if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
 327         /* On Linux we lose the ability to dump core when we change our user
 328          * ID. We know how to dump core safely, so let's make sure we have our
 329          * dumpable flag set.
 330          */
 331         prctl(PR_SET_DUMPABLE, 1);
 332 #endif
 333
 334         /* Ensure we don't have a signal handler for abort. */
 335 #ifdef SIGABRT
 336         CatchSignal(SIGABRT, SIG_DFL);
 337 #endif
 338
 339         abort();
 340
 341 #else /* DUMP_CORE */
 342         exit(1);
 343 #endif /* DUMP_CORE */
 344 }