+/*
+ Bacula® - The Network Backup Solution
+
+ Copyright (C) 2000-2014 Free Software Foundation Europe e.V.
+
+ The main author of Bacula is Kern Sibbald, with contributions from many
+ others, a complete list can be found in the file AUTHORS.
+
+ You may use this file and others of this release according to the
+ license defined in the LICENSE file, which includes the Affero General
+ Public License, v3.0 ("AGPLv3") and some additional permissions and
+ terms pursuant to its AGPLv3 Section 7.
+
+ Bacula® is a registered trademark of Kern Sibbald.
+*/
/*
* Miscellaneous Bacula memory and thread safe routines
* Generally, these are interfaces to system or standard
*
* Bacula utility functions are in util.c
*
- * Version $Id$
*/
-/*
- Copyright (C) 2000-2005 Kern Sibbald
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License
- version 2 as amended with additional clauses defined in the
- file LICENSE in the main source directory.
+#include "bacula.h"
+#ifndef HAVE_REGEX_H
+#include "lib/bregex.h"
+#else
+#include <regex.h>
+#endif
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- the file LICENSE for additional details.
+static pthread_mutex_t timer_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t timer = PTHREAD_COND_INITIALIZER;
+/*
+ * Quote a string
*/
+POOLMEM *quote_string(POOLMEM *snew, const char *old)
+{
+ char *n;
+ int i;
+ if (!old) {
+ strcpy(snew, "null");
+ return snew;
+ }
+ n = snew;
+ *n++ = '"';
+ for (i=0; old[i]; i++) {
+ switch (old[i]) {
+ case '"':
+ *n++ = '\\';
+ *n++ = '"';
+ break;
+ case '\\':
+ *n++ = '\\';
+ *n++ = '\\';
+ break;
+ default:
+ *n++ = old[i];
+ break;
+ }
+ }
+ *n++ = '"';
+ *n = 0;
+ return snew;
+}
-#include "bacula.h"
-#ifdef HAVE_PWD_H
-#include <pwd.h>
-#endif
-#ifdef HAVE_GRP_H
-#include <grp.h>
-#endif
+/*
+ * Quote a where (list of addresses separated by spaces)
+ */
+POOLMEM *quote_where(POOLMEM *snew, const char *old)
+{
+ char *n;
+ int i;
-static pthread_mutex_t timer_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t timer = PTHREAD_COND_INITIALIZER;
+ if (!old) {
+ strcpy(snew, "null");
+ return snew;
+ }
+ n = snew;
+ *n++ = '"';
+ for (i=0; old[i]; i++) {
+ switch (old[i]) {
+ case ' ':
+ *n++ = '"';
+ *n++ = ',';
+ *n++ = '"';
+ break;
+ case '"':
+ *n++ = '\\';
+ *n++ = '"';
+ break;
+ case '\\':
+ *n++ = '\\';
+ *n++ = '\\';
+ break;
+ default:
+ *n++ = old[i];
+ break;
+ }
+ }
+ *n++ = '"';
+ *n = 0;
+ return snew;
+}
+
+/*
+ * This routine is a somewhat safer unlink in that it
+ * allows you to run a regex on the filename before
+ * excepting it. It also requires the file to be in
+ * the working directory.
+ */
+int safer_unlink(const char *pathname, const char *regx)
+{
+ int rc;
+ regex_t preg1;
+ char prbuf[500];
+ const int nmatch = 30;
+ regmatch_t pmatch[nmatch];
+ int rtn;
+
+ /* Name must start with working directory */
+ if (strncmp(pathname, working_directory, strlen(working_directory)) != 0) {
+ Pmsg1(000, "Safe_unlink excluded: %s\n", pathname);
+ return EROFS;
+ }
+
+ /* Compile regex expression */
+ rc = regcomp(&preg1, regx, REG_EXTENDED);
+ if (rc != 0) {
+ regerror(rc, &preg1, prbuf, sizeof(prbuf));
+ Pmsg2(000, _("safe_unlink could not compile regex pattern \"%s\" ERR=%s\n"),
+ regx, prbuf);
+ return ENOENT;
+ }
+
+ /* Unlink files that match regexes */
+ if (regexec(&preg1, pathname, nmatch, pmatch, 0) == 0) {
+ Dmsg1(100, "safe_unlink unlinking: %s\n", pathname);
+ rtn = unlink(pathname);
+ } else {
+ Pmsg2(000, "safe_unlink regex failed: regex=%s file=%s\n", regx, pathname);
+ rtn = EROFS;
+ }
+ regfree(&preg1);
+ return rtn;
+}
/*
* This routine will sleep (sec, microsec). Note, however, that if a
* to recall this routine if he/she REALLY wants to sleep the
* requested time.
*/
-int bmicrosleep(time_t sec, long usec)
+int bmicrosleep(int32_t sec, int32_t usec)
{
struct timespec timeout;
struct timeval tv;
if (stat != 0) {
berrno be;
Dmsg2(200, "pthread_cond_timedwait stat=%d ERR=%s\n", stat,
- be.strerror(stat));
+ be.bstrerror(stat));
}
V(timer_mutex);
return stat;
return dest;
}
-
+/*
+ * Note: Here the maxlen is the maximum length permitted
+ * stored in dest, while on Unix systems, it is the maximum characters
+ * that may be copied from src.
+ */
char *bstrncat(char *dest, const char *src, int maxlen)
{
- strncat(dest, src, maxlen-1);
+ int len = strlen(dest);
+ if (len < maxlen-1) {
+ strncpy(dest+len, src, maxlen-len-1);
+ }
dest[maxlen-1] = 0;
return dest;
}
+/*
+ * Note: Here the maxlen is the maximum length permitted
+ * stored in dest, while on Unix systems, it is the maximum characters
+ * that may be copied from src.
+ */
char *bstrncat(char *dest, POOL_MEM &src, int maxlen)
{
- strncat(dest, src.c_str(), maxlen-1);
+ int len = strlen(dest);
+ if (len < maxlen-1) {
+ strncpy(dest+len, src.c_str(), maxlen-len-1);
+ }
dest[maxlen-1] = 0;
return dest;
}
+/*
+ * Allows one or both pointers to be NULL
+ */
+bool bstrcmp(const char *s1, const char *s2)
+{
+ if (s1 == s2) return true;
+ if (s1 == NULL || s2 == NULL) return false;
+ return strcmp(s1, s2) == 0;
+}
+
+/*
+ * Allows one or both pointers to be NULL
+ */
+bool bstrcasecmp(const char *s1, const char *s2)
+{
+ if (s1 == s2) return true;
+ if (s1 == NULL || s2 == NULL) return false;
+ return strcasecmp(s1, s2) == 0;
+}
+
+
/*
* Get character length of UTF-8 string
*
* Valid UTF-8 codes
- * U-00000000 - U-0000007F: 0xxxxxxx
- * U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
- * U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
- * U-00010000 - U-001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- * U-00200000 - U-03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+ * U-00000000 - U-0000007F: 0xxxxxxx
+ * U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
+ * U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
+ * U-00010000 - U-001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ * U-00200000 - U-03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
* U-04000000 - U-7FFFFFFF: 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
*/
int cstrlen(const char *str)
{
uint8_t *p = (uint8_t *)str;
int len = 0;
+ if (str == NULL) {
+ return 0;
+ }
while (*p) {
if ((*p & 0xC0) != 0xC0) {
p++;
-#ifndef DEBUG
+#ifndef bmalloc
void *bmalloc(size_t size)
{
void *buf;
+#ifdef SMARTALLOC
+ buf = sm_malloc(file, line, size);
+#else
buf = malloc(size);
+#endif
if (buf == NULL) {
- Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
+ berrno be;
+ Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
}
return buf;
}
buf = malloc(size);
#endif
if (buf == NULL) {
- e_msg(file, line, M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
+ berrno be;
+ e_msg(file, line, M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
}
return buf;
}
+void bfree(void *buf)
+{
+#ifdef SMARTALLOC
+ sm_free(__FILE__, __LINE__, buf);
+#else
+ free(buf);
+#endif
+}
+
void *brealloc (void *buf, size_t size)
{
+#ifdef SMARTALOC
+ buf = sm_realloc(__FILE__, __LINE__, buf, size);
+#else
buf = realloc(buf, size);
+#endif
if (buf == NULL) {
- Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
+ berrno be;
+ Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
}
return buf;
}
-void *bcalloc (size_t size1, size_t size2)
+void *bcalloc(size_t size1, size_t size2)
{
void *buf;
buf = calloc(size1, size2);
if (buf == NULL) {
- Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
+ berrno be;
+ Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
}
return buf;
}
#endif /* HAVE_READDIR_R */
-int bstrerror(int errnum, char *buf, size_t bufsiz)
+int b_strerror(int errnum, char *buf, size_t bufsiz)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int stat = 0;
return stat;
}
-/*
- * These are mutex routines that do error checking
- * for deadlock and such. Normally not turned on.
- */
-#ifdef DEBUG_MUTEX
-void _p(char *file, int line, pthread_mutex_t *m)
-{
- int errstat;
- if ((errstat = pthread_mutex_trylock(m))) {
- e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock.\n"));
- /* We didn't get the lock, so do it definitely now */
- if ((errstat=pthread_mutex_lock(m))) {
- berrno be;
- e_msg(file, line, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
- be.strerror(errstat));
- } else {
- e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock resolved.\n"));
- }
-
- }
-}
-
-void _v(char *file, int line, pthread_mutex_t *m)
-{
- int errstat;
-
- if ((errstat=pthread_mutex_trylock(m)) == 0) {
- berrno be;
- e_msg(file, line, M_ERROR, 0, _("Mutex unlock not locked. ERR=%s\n"),
- be.strerror(errstat));
- }
- if ((errstat=pthread_mutex_unlock(m))) {
- berrno be;
- e_msg(file, line, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
- be.strerror(errstat));
- }
-}
-
-#else
-
-void _p(pthread_mutex_t *m)
-{
- int errstat;
- if ((errstat=pthread_mutex_lock(m))) {
- berrno be;
- e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
- be.strerror(errstat));
- }
-}
-
-void _v(pthread_mutex_t *m)
-{
- int errstat;
- if ((errstat=pthread_mutex_unlock(m))) {
- berrno be;
- e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
- be.strerror(errstat));
- }
-}
-
-#endif /* DEBUG_MUTEX */
-
#ifdef DEBUG_MEMSET
/* These routines are not normally turned on */
#undef memset
}
#endif
-#if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
+#if !defined(HAVE_WIN32)
static int del_pid_file_ok = FALSE;
#endif
*/
void create_pid_file(char *dir, const char *progname, int port)
{
-#if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
+#if !defined(HAVE_WIN32)
int pidfd, len;
int oldpid;
char pidbuf[20];
if ((pidfd = open(fname, O_RDONLY|O_BINARY, 0)) < 0 ||
read(pidfd, &pidbuf, sizeof(pidbuf)) < 0 ||
sscanf(pidbuf, "%d", &oldpid) != 1) {
- Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname, strerror(errno));
+ berrno be;
+ Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname,
+ be.bstrerror());
}
- /* See if other Bacula is still alive */
- if (kill(oldpid, 0) != -1 || errno != ESRCH) {
+ /* Some OSes (IRIX) don't bother to clean out the old pid files after a crash, and
+ * since they use a deterministic algorithm for assigning PIDs, we can have
+ * pid conflicts with the old PID file after a reboot.
+ * The intent the following code is to check if the oldpid read from the pid
+ * file is the same as the currently executing process's pid,
+ * and if oldpid == getpid(), skip the attempt to
+ * kill(oldpid,0), since the attempt is guaranteed to succeed,
+ * but the success won't actually mean that there is an
+ * another Bacula process already running.
+ * For more details see bug #797.
+ */
+ if ((oldpid != (int)getpid()) && (kill(oldpid, 0) != -1 || errno != ESRCH)) {
Emsg3(M_ERROR_TERM, 0, _("%s is already running. pid=%d\nCheck file %s\n"),
progname, oldpid, fname);
}
close(pidfd);
del_pid_file_ok = TRUE; /* we created it so we can delete it */
} else {
- Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname, strerror(errno));
+ berrno be;
+ Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname,
+ be.bstrerror());
}
free_pool_memory(fname);
#endif
*/
int delete_pid_file(char *dir, const char *progname, int port)
{
-#if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
+#if !defined(HAVE_WIN32)
POOLMEM *fname = get_pool_memory(PM_FNAME);
if (!del_pid_file_ok) {
static struct s_state_hdr state_hdr = {
"Bacula State\n",
- 3,
+ 4,
0
};
Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
/* If file exists, see what we have */
// Dmsg1(10, "O_BINARY=%d\n", O_BINARY);
- if ((sfd = open(fname, O_RDONLY|O_BINARY, 0)) < 0) {
+ if ((sfd = open(fname, O_RDONLY|O_BINARY)) < 0) {
+ berrno be;
Dmsg3(010, "Could not open state file. sfd=%d size=%d: ERR=%s\n",
- sfd, sizeof(hdr), strerror(errno));
+ sfd, (int)sizeof(hdr), be.bstrerror());
goto bail_out;
}
if ((stat=read(sfd, &hdr, hdr_size)) != hdr_size) {
+ berrno be;
Dmsg4(010, "Could not read state file. sfd=%d stat=%d size=%d: ERR=%s\n",
- sfd, (int)stat, hdr_size, strerror(errno));
+ sfd, (int)stat, hdr_size, be.bstrerror());
goto bail_out;
}
if (hdr.version != state_hdr.version) {
/*
* Write the state file
*/
+static pthread_mutex_t state_mutex = PTHREAD_MUTEX_INITIALIZER;
+
void write_state_file(char *dir, const char *progname, int port)
{
int sfd;
bool ok = false;
POOLMEM *fname = get_pool_memory(PM_FNAME);
+ P(state_mutex); /* Only one job at a time can call here */
Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
/* Create new state file */
+ unlink(fname);
if ((sfd = open(fname, O_CREAT|O_WRONLY|O_BINARY, 0640)) < 0) {
berrno be;
- Dmsg2(000, "Could not create state file. %s ERR=%s\n", fname, be.strerror());
- Emsg2(M_ERROR, 0, _("Could not create state file. %s ERR=%s\n"), fname, be.strerror());
+ Dmsg2(000, "Could not create state file. %s ERR=%s\n", fname, be.bstrerror());
+ Emsg2(M_ERROR, 0, _("Could not create state file. %s ERR=%s\n"), fname, be.bstrerror());
goto bail_out;
}
if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
berrno be;
- Dmsg1(000, "Write hdr error: ERR=%s\n", be.strerror());
+ Dmsg1(000, "Write hdr error: ERR=%s\n", be.bstrerror());
goto bail_out;
}
// Dmsg1(010, "Wrote header of %d bytes\n", sizeof(state_hdr));
// Dmsg1(010, "write last job end = %d\n", (int)state_hdr.reserved[0]);
if (lseek(sfd, 0, SEEK_SET) < 0) {
berrno be;
- Dmsg1(000, "lseek error: ERR=%s\n", be.strerror());
+ Dmsg1(000, "lseek error: ERR=%s\n", be.bstrerror());
goto bail_out;
}
if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
berrno be;
- Pmsg1(000, _("Write final hdr error: ERR=%s\n"), be.strerror());
+ Pmsg1(000, _("Write final hdr error: ERR=%s\n"), be.bstrerror());
goto bail_out;
}
ok = true;
if (!ok) {
unlink(fname);
}
+ V(state_mutex);
free_pool_memory(fname);
}
-/*
- * Drop to privilege new userid and new gid if non-NULL
- */
-void drop(char *uid, char *gid)
-{
-#ifdef HAVE_GRP_H
- if (gid) {
- struct group *group;
- gid_t gr_list[1];
-
- if ((group = getgrnam(gid)) == NULL) {
- Emsg1(M_ERROR_TERM, 0, _("Could not find specified group: %s\n"), gid);
- }
- if (setgid(group->gr_gid)) {
- Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
- }
- gr_list[0] = group->gr_gid;
- if (setgroups(1, gr_list)) {
- Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
- }
- }
-#endif
-
-#ifdef HAVE_PWD_H
- if (uid) {
- struct passwd *passw;
- if ((passw = getpwnam(uid)) == NULL) {
- Emsg1(M_ERROR_TERM, 0, _("Could not find specified userid: %s\n"), uid);
- }
- if (setuid(passw->pw_uid)) {
- Emsg1(M_ERROR_TERM, 0, _("Could not set specified userid: %s\n"), uid);
- }
- }
-#endif
-
-}
-
-
/* BSDI does not have this. This is a *poor* simulation */
#ifndef HAVE_STRTOLL
long long int
do {
errno = 0;
ch = fgetc(fd);
- } while (ch == -1 && (errno == EINTR || errno == EAGAIN));
- if (ch == -1) {
+ } while (ch == EOF && ferror(fd) && (errno == EINTR || errno == EAGAIN));
+ if (ch == EOF) {
if (i == 0) {
return NULL;
} else {
*p = 0;
if (ch == '\r') { /* Support for Mac/Windows file format */
ch = fgetc(fd);
- if (ch == '\n') { /* Windows (\r\n) */
- *p++ = ch;
- *p = 0;
+ if (ch != '\n') { /* Mac (\r only) */
+ (void)ungetc(ch, fd); /* Push next character back to fd */
+ }
+ p[-1] = '\n';
+ break;
+ }
+ if (ch == '\n') {
+ break;
+ }
+ }
+ return s;
+}
+
+/*
+ * Bacula's implementation of fgets(). The difference is that it handles
+ * being interrupted by a signal (e.g. a SIGCHLD) and it has a
+ * different calling sequence which implements input lines of
+ * up to a million characters.
+ */
+char *bfgets(POOLMEM *&s, FILE *fd)
+{
+ int ch;
+ int soft_max;
+ int i = 0;
+
+ s[0] = 0;
+ soft_max = sizeof_pool_memory(s) - 10;
+ for ( ;; ) {
+ do {
+ errno = 0;
+ ch = fgetc(fd);
+ } while (ch == EOF && ferror(fd) && (errno == EINTR || errno == EAGAIN));
+ if (ch == EOF) {
+ if (i == 0) {
+ return NULL;
+ } else {
+ return s;
+ }
+ }
+ if (i > soft_max) {
+ /* Insanity check */
+ if (soft_max > 1000000) {
+ return s;
}
- else { /* Mac (\r only) */
+ s = check_pool_memory_size(s, soft_max+10000);
+ soft_max = sizeof_pool_memory(s) - 10;
+ }
+ s[i++] = ch;
+ s[i] = 0;
+ if (ch == '\r') { /* Support for Mac/Windows file format */
+ ch = fgetc(fd);
+ if (ch != '\n') { /* Mac (\r only) */
(void)ungetc(ch, fd); /* Push next character back to fd */
}
+ s[i-1] = '\n';
break;
}
if (ch == '\n') {
{
Mmsg(name, "%s/%s.%s.%d.tmp", working_directory, my_name, what, Id);
}
+
+char *escape_filename(const char *file_path)
+{
+ if (file_path == NULL || strpbrk(file_path, "\"\\") == NULL) {
+ return NULL;
+ }
+
+ char *escaped_path = (char *)bmalloc(2 * (strlen(file_path) + 1));
+ char *cur_char = escaped_path;
+
+ while (*file_path) {
+ if (*file_path == '\\' || *file_path == '"') {
+ *cur_char++ = '\\';
+ }
+
+ *cur_char++ = *file_path++;
+ }
+
+ *cur_char = '\0';
+
+ return escaped_path;
+}
+
+/*
+ * For the moment preventing suspensions is only
+ * implement on Windows.
+ */
+#ifndef HAVE_WIN32
+void prevent_os_suspensions()
+{ }
+
+void allow_os_suspensions()
+{ }
+#endif
+
+
+#if HAVE_BACKTRACE && HAVE_GCC
+#include <cxxabi.h>
+#include <execinfo.h>
+void stack_trace()
+{
+ const size_t max_depth = 100;
+ size_t stack_depth;
+ void *stack_addrs[max_depth];
+ char **stack_strings;
+
+ stack_depth = backtrace(stack_addrs, max_depth);
+ stack_strings = backtrace_symbols(stack_addrs, stack_depth);
+
+ for (size_t i = 3; i < stack_depth; i++) {
+ size_t sz = 200; /* just a guess, template names will go much wider */
+ char *function = (char *)actuallymalloc(sz);
+ char *begin = 0, *end = 0;
+ /* find the parentheses and address offset surrounding the mangled name */
+ for (char *j = stack_strings[i]; *j; ++j) {
+ if (*j == '(') {
+ begin = j;
+ } else if (*j == '+') {
+ end = j;
+ }
+ }
+ if (begin && end) {
+ *begin++ = '\0';
+ *end = '\0';
+ /* found our mangled name, now in [begin, end] */
+
+ int status;
+ char *ret = abi::__cxa_demangle(begin, function, &sz, &status);
+ if (ret) {
+ /* return value may be a realloc() of the input */
+ function = ret;
+ } else {
+ /* demangling failed, just pretend it's a C function with no args */
+ strncpy(function, begin, sz);
+ strncat(function, "()", sz);
+ function[sz-1] = '\0';
+ }
+ Pmsg2(000, " %s:%s\n", stack_strings[i], function);
+
+ } else {
+ /* didn't find the mangled name, just print the whole line */
+ Pmsg1(000, " %s\n", stack_strings[i]);
+ }
+ actuallyfree(function);
+ }
+ actuallyfree(stack_strings); /* malloc()ed by backtrace_symbols */
+}
+#else /* HAVE_BACKTRACE && HAVE_GCC */
+void stack_trace() {}
+#endif /* HAVE_BACKTRACE && HAVE_GCC */
projects / bacula / bacula / blobdiff