2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
29 * Miscellaneous Bacula memory and thread safe routines
30 * Generally, these are interfaces to system or standard
33 * Bacula utility functions are in util.c
41 static pthread_mutex_t timer_mutex = PTHREAD_MUTEX_INITIALIZER;
42 static pthread_cond_t timer = PTHREAD_COND_INITIALIZER;
45 * This routine will sleep (sec, microsec). Note, however, that if a
46 * signal occurs, it will return early. It is up to the caller
47 * to recall this routine if he/she REALLY wants to sleep the
50 int bmicrosleep(int32_t sec, int32_t usec)
52 struct timespec timeout;
58 timeout.tv_nsec = usec * 1000;
61 stat = nanosleep(&timeout, NULL);
62 if (!(stat < 0 && errno == ENOSYS)) {
65 /* If we reach here it is because nanosleep is not supported by the OS */
68 /* Do it the old way */
69 gettimeofday(&tv, &tz);
70 timeout.tv_nsec += tv.tv_usec * 1000;
71 timeout.tv_sec += tv.tv_sec;
72 while (timeout.tv_nsec >= 1000000000) {
73 timeout.tv_nsec -= 1000000000;
77 Dmsg2(200, "pthread_cond_timedwait sec=%lld usec=%d\n", sec, usec);
78 /* Note, this unlocks mutex during the sleep */
80 stat = pthread_cond_timedwait(&timer, &timer_mutex, &timeout);
83 Dmsg2(200, "pthread_cond_timedwait stat=%d ERR=%s\n", stat,
91 * Guarantee that the string is properly terminated */
92 char *bstrncpy(char *dest, const char *src, int maxlen)
94 strncpy(dest, src, maxlen-1);
100 * Guarantee that the string is properly terminated */
101 char *bstrncpy(char *dest, POOL_MEM &src, int maxlen)
103 strncpy(dest, src.c_str(), maxlen-1);
109 * Note: Here the maxlen is the maximum length permitted
110 * stored in dest, while on Unix systems, it is the maximum characters
111 * that may be copied from src.
113 char *bstrncat(char *dest, const char *src, int maxlen)
115 int len = strlen(dest);
116 if (len < maxlen-1) {
117 strncpy(dest+len, src, maxlen-len-1);
124 * Note: Here the maxlen is the maximum length permitted
125 * stored in dest, while on Unix systems, it is the maximum characters
126 * that may be copied from src.
128 char *bstrncat(char *dest, POOL_MEM &src, int maxlen)
130 int len = strlen(dest);
131 if (len < maxlen-1) {
132 strncpy(dest+len, src.c_str(), maxlen-len-1);
139 * Allows one or both pointers to be NULL
141 bool bstrcmp(const char *s1, const char *s2)
143 if (s1 == s2) return true;
144 if (s1 == NULL || s2 == NULL) return false;
145 return strcmp(s1, s2) == 0;
149 * Get character length of UTF-8 string
152 * U-00000000 - U-0000007F: 0xxxxxxx
153 * U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
154 * U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
155 * U-00010000 - U-001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
156 * U-00200000 - U-03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
157 * U-04000000 - U-7FFFFFFF: 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
159 int cstrlen(const char *str)
161 uint8_t *p = (uint8_t *)str;
167 if ((*p & 0xC0) != 0xC0) {
172 if ((*p & 0xD0) == 0xC0) {
177 if ((*p & 0xF0) == 0xD0) {
182 if ((*p & 0xF8) == 0xF0) {
187 if ((*p & 0xFC) == 0xF8) {
192 if ((*p & 0xFE) == 0xFC) {
197 p++; /* Shouln't get here but must advance */
205 void *bmalloc(size_t size)
210 buf = sm_malloc(file, line, size);
216 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
222 void *b_malloc(const char *file, int line, size_t size)
227 buf = sm_malloc(file, line, size);
233 e_msg(file, line, M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
239 void bfree(void *buf)
242 sm_free(__FILE__, __LINE__, buf);
248 void *brealloc (void *buf, size_t size)
251 buf = sm_realloc(__FILE__, __LINE__, buf, size);
253 buf = realloc(buf, size);
257 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
263 void *bcalloc(size_t size1, size_t size2)
267 buf = calloc(size1, size2);
270 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
275 /* Code now in src/lib/bsnprintf.c */
276 #ifndef USE_BSNPRINTF
282 int bsnprintf(char *str, int32_t size, const char *fmt, ...)
287 va_start(arg_ptr, fmt);
288 len = bvsnprintf(str, size, fmt, arg_ptr);
294 * Implement vsnprintf()
296 int bvsnprintf(char *str, int32_t size, const char *format, va_list ap)
298 #ifdef HAVE_VSNPRINTF
300 len = vsnprintf(str, size, format, ap);
308 buflen = size > BIG_BUF ? size : BIG_BUF;
309 buf = get_memory(buflen);
310 len = vsprintf(buf, format, ap);
312 Emsg0(M_ABORT, 0, _("Buffer overflow.\n"));
314 memcpy(str, buf, len);
315 str[len] = 0; /* len excludes the null */
320 #endif /* USE_BSNPRINTF */
322 #ifndef HAVE_LOCALTIME_R
324 struct tm *localtime_r(const time_t *timep, struct tm *tm)
326 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
330 ltm = localtime(timep);
332 memcpy(tm, ltm, sizeof(struct tm));
335 return ltm ? tm : NULL;
337 #endif /* HAVE_LOCALTIME_R */
339 #ifndef HAVE_READDIR_R
343 int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
345 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
351 ndir = readdir(dirp);
354 memcpy(entry, ndir, sizeof(struct dirent));
355 strcpy(entry->d_name, ndir->d_name);
365 #endif /* HAVE_READDIR_R */
368 int b_strerror(int errnum, char *buf, size_t bufsiz)
370 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
376 msg = strerror(errnum);
378 msg = _("Bad errno");
381 bstrncpy(buf, msg, bufsiz);
387 /* These routines are not normally turned on */
389 void b_memset(const char *file, int line, void *mem, int val, size_t num)
391 /* Testing for 2000 byte zero at beginning of Volume block */
392 if (num > 1900 && num < 3000) {
393 Pmsg3(000, _("Memset for %d bytes at %s:%d\n"), (int)num, file, line);
395 memset(mem, val, num);
399 #if !defined(HAVE_WIN32)
400 static int del_pid_file_ok = FALSE;
404 * Create a standard "Unix" pid file.
406 void create_pid_file(char *dir, const char *progname, int port)
408 #if !defined(HAVE_WIN32)
412 POOLMEM *fname = get_pool_memory(PM_FNAME);
415 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
416 if (stat(fname, &statp) == 0) {
417 /* File exists, see what we have */
419 if ((pidfd = open(fname, O_RDONLY|O_BINARY, 0)) < 0 ||
420 read(pidfd, &pidbuf, sizeof(pidbuf)) < 0 ||
421 sscanf(pidbuf, "%d", &oldpid) != 1) {
423 Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname,
426 /* Some OSes (IRIX) don't bother to clean out the old pid files after a crash, and
427 * since they use a deterministic algorithm for assigning PIDs, we can have
428 * pid conflicts with the old PID file after a reboot.
429 * The intent the following code is to check if the oldpid read from the pid
430 * file is the same as the currently executing process's pid,
431 * and if oldpid == getpid(), skip the attempt to
432 * kill(oldpid,0), since the attempt is guaranteed to succeed,
433 * but the success won't actually mean that there is an
434 * another Bacula process already running.
435 * For more details see bug #797.
437 if ((oldpid != (int)getpid()) && (kill(oldpid, 0) != -1 || errno != ESRCH)) {
438 Emsg3(M_ERROR_TERM, 0, _("%s is already running. pid=%d\nCheck file %s\n"),
439 progname, oldpid, fname);
441 /* He is not alive, so take over file ownership */
442 unlink(fname); /* remove stale pid file */
444 /* Create new pid file */
445 if ((pidfd = open(fname, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, 0640)) >= 0) {
446 len = sprintf(pidbuf, "%d\n", (int)getpid());
447 write(pidfd, pidbuf, len);
449 del_pid_file_ok = TRUE; /* we created it so we can delete it */
452 Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname,
455 free_pool_memory(fname);
461 * Delete the pid file if we created it
463 int delete_pid_file(char *dir, const char *progname, int port)
465 #if !defined(HAVE_WIN32)
466 POOLMEM *fname = get_pool_memory(PM_FNAME);
468 if (!del_pid_file_ok) {
469 free_pool_memory(fname);
472 del_pid_file_ok = FALSE;
473 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
475 free_pool_memory(fname);
483 uint64_t last_jobs_addr;
484 uint64_t reserved[20];
487 static struct s_state_hdr state_hdr = {
494 * Open and read the state file for the daemon
496 void read_state_file(char *dir, const char *progname, int port)
501 POOLMEM *fname = get_pool_memory(PM_FNAME);
502 struct s_state_hdr hdr;
503 int hdr_size = sizeof(hdr);
505 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
506 /* If file exists, see what we have */
507 // Dmsg1(10, "O_BINARY=%d\n", O_BINARY);
508 if ((sfd = open(fname, O_RDONLY|O_BINARY)) < 0) {
510 Dmsg3(010, "Could not open state file. sfd=%d size=%d: ERR=%s\n",
511 sfd, sizeof(hdr), be.bstrerror());
514 if ((stat=read(sfd, &hdr, hdr_size)) != hdr_size) {
516 Dmsg4(010, "Could not read state file. sfd=%d stat=%d size=%d: ERR=%s\n",
517 sfd, (int)stat, hdr_size, be.bstrerror());
520 if (hdr.version != state_hdr.version) {
521 Dmsg2(010, "Bad hdr version. Wanted %d got %d\n",
522 state_hdr.version, hdr.version);
526 if (strcmp(hdr.id, state_hdr.id) != 0) {
527 Dmsg0(000, "State file header id invalid.\n");
530 // Dmsg1(010, "Read header of %d bytes.\n", sizeof(hdr));
531 if (!read_last_jobs_list(sfd, hdr.last_jobs_addr)) {
542 free_pool_memory(fname);
546 * Write the state file
548 void write_state_file(char *dir, const char *progname, int port)
552 POOLMEM *fname = get_pool_memory(PM_FNAME);
554 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
555 /* Create new state file */
557 if ((sfd = open(fname, O_CREAT|O_WRONLY|O_BINARY, 0640)) < 0) {
559 Dmsg2(000, "Could not create state file. %s ERR=%s\n", fname, be.bstrerror());
560 Emsg2(M_ERROR, 0, _("Could not create state file. %s ERR=%s\n"), fname, be.bstrerror());
563 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
565 Dmsg1(000, "Write hdr error: ERR=%s\n", be.bstrerror());
568 // Dmsg1(010, "Wrote header of %d bytes\n", sizeof(state_hdr));
569 state_hdr.last_jobs_addr = sizeof(state_hdr);
570 state_hdr.reserved[0] = write_last_jobs_list(sfd, state_hdr.last_jobs_addr);
571 // Dmsg1(010, "write last job end = %d\n", (int)state_hdr.reserved[0]);
572 if (lseek(sfd, 0, SEEK_SET) < 0) {
574 Dmsg1(000, "lseek error: ERR=%s\n", be.bstrerror());
577 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
579 Pmsg1(000, _("Write final hdr error: ERR=%s\n"), be.bstrerror());
583 // Dmsg1(010, "rewrote header = %d\n", sizeof(state_hdr));
591 free_pool_memory(fname);
595 /* BSDI does not have this. This is a *poor* simulation */
598 strtoll(const char *ptr, char **endptr, int base)
600 return (long long int)strtod(ptr, endptr);
605 * Bacula's implementation of fgets(). The difference is that it handles
606 * being interrupted by a signal (e.g. a SIGCHLD).
609 char *bfgets(char *s, int size, FILE *fd)
614 for (int i=0; i < size-1; i++) {
618 } while (ch == EOF && ferror(fd) && (errno == EINTR || errno == EAGAIN));
628 if (ch == '\r') { /* Support for Mac/Windows file format */
630 if (ch != '\n') { /* Mac (\r only) */
631 (void)ungetc(ch, fd); /* Push next character back to fd */
644 * Make a "unique" filename. It is important that if
645 * called again with the same "what" that the result
646 * will be identical. This allows us to use the file
647 * without saving its name, and re-generate the name
648 * so that it can be deleted.
650 void make_unique_filename(POOLMEM **name, int Id, char *what)
652 Mmsg(name, "%s/%s.%s.%d.tmp", working_directory, my_name, what, Id);
655 char *escape_filename(const char *file_path)
657 if (file_path == NULL || strpbrk(file_path, "\"\\") == NULL) {
661 char *escaped_path = (char *)bmalloc(2 * (strlen(file_path) + 1));
662 char *cur_char = escaped_path;
665 if (*file_path == '\\' || *file_path == '"') {
669 *cur_char++ = *file_path++;