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 char *bstrncat(char *dest, const char *src, int maxlen)
111 strncat(dest, src, maxlen-1);
116 char *bstrncat(char *dest, POOL_MEM &src, int maxlen)
118 strncat(dest, src.c_str(), maxlen-1);
124 * Allows one or both pointers to be NULL
126 bool bstrcmp(const char *s1, const char *s2)
128 if (s1 == s2) return true;
129 if (s1 == NULL || s2 == NULL) return false;
130 return strcmp(s1, s2) == 0;
134 * Get character length of UTF-8 string
137 * U-00000000 - U-0000007F: 0xxxxxxx
138 * U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
139 * U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
140 * U-00010000 - U-001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
141 * U-00200000 - U-03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
142 * U-04000000 - U-7FFFFFFF: 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
144 int cstrlen(const char *str)
146 uint8_t *p = (uint8_t *)str;
149 if ((*p & 0xC0) != 0xC0) {
154 if ((*p & 0xD0) == 0xC0) {
159 if ((*p & 0xF0) == 0xD0) {
164 if ((*p & 0xF8) == 0xF0) {
169 if ((*p & 0xFC) == 0xF8) {
174 if ((*p & 0xFE) == 0xFC) {
179 p++; /* Shouln't get here but must advance */
187 void *bmalloc(size_t size)
192 buf = sm_malloc(file, line, size);
198 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
204 void *b_malloc(const char *file, int line, size_t size)
209 buf = sm_malloc(file, line, size);
215 e_msg(file, line, M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
221 void bfree(void *buf)
224 sm_free(__FILE__, __LINE__, buf);
230 void *brealloc (void *buf, size_t size)
233 buf = sm_realloc(__FILE__, __LINE__, buf, size);
235 buf = realloc(buf, size);
239 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
245 void *bcalloc(size_t size1, size_t size2)
249 buf = calloc(size1, size2);
252 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.bstrerror());
257 /* Code now in src/lib/bsnprintf.c */
258 #ifndef USE_BSNPRINTF
264 int bsnprintf(char *str, int32_t size, const char *fmt, ...)
269 va_start(arg_ptr, fmt);
270 len = bvsnprintf(str, size, fmt, arg_ptr);
276 * Implement vsnprintf()
278 int bvsnprintf(char *str, int32_t size, const char *format, va_list ap)
280 #ifdef HAVE_VSNPRINTF
282 len = vsnprintf(str, size, format, ap);
290 buflen = size > BIG_BUF ? size : BIG_BUF;
291 buf = get_memory(buflen);
292 len = vsprintf(buf, format, ap);
294 Emsg0(M_ABORT, 0, _("Buffer overflow.\n"));
296 memcpy(str, buf, len);
297 str[len] = 0; /* len excludes the null */
302 #endif /* USE_BSNPRINTF */
304 #ifndef HAVE_LOCALTIME_R
306 struct tm *localtime_r(const time_t *timep, struct tm *tm)
308 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
312 ltm = localtime(timep);
314 memcpy(tm, ltm, sizeof(struct tm));
317 return ltm ? tm : NULL;
319 #endif /* HAVE_LOCALTIME_R */
321 #ifndef HAVE_READDIR_R
325 int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
327 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
333 ndir = readdir(dirp);
336 memcpy(entry, ndir, sizeof(struct dirent));
337 strcpy(entry->d_name, ndir->d_name);
347 #endif /* HAVE_READDIR_R */
350 int b_strerror(int errnum, char *buf, size_t bufsiz)
352 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
358 msg = strerror(errnum);
360 msg = _("Bad errno");
363 bstrncpy(buf, msg, bufsiz);
369 /* These routines are not normally turned on */
371 void b_memset(const char *file, int line, void *mem, int val, size_t num)
373 /* Testing for 2000 byte zero at beginning of Volume block */
374 if (num > 1900 && num < 3000) {
375 Pmsg3(000, _("Memset for %d bytes at %s:%d\n"), (int)num, file, line);
377 memset(mem, val, num);
381 #if !defined(HAVE_WIN32)
382 static int del_pid_file_ok = FALSE;
386 * Create a standard "Unix" pid file.
388 void create_pid_file(char *dir, const char *progname, int port)
390 #if !defined(HAVE_WIN32)
394 POOLMEM *fname = get_pool_memory(PM_FNAME);
397 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
398 if (stat(fname, &statp) == 0) {
399 /* File exists, see what we have */
401 if ((pidfd = open(fname, O_RDONLY|O_BINARY, 0)) < 0 ||
402 read(pidfd, &pidbuf, sizeof(pidbuf)) < 0 ||
403 sscanf(pidbuf, "%d", &oldpid) != 1) {
405 Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname,
408 /* Some OSes (IRIX) don't bother to clean out the old pid files after a crash, and
409 * since they use a deterministic algorithm for assigning PIDs, we can have
410 * pid conflicts with the old PID file after a reboot.
411 * The intent the following code is to check if the oldpid read from the pid
412 * file is the same as the currently executing process's pid,
413 * and if oldpid == getpid(), skip the attempt to
414 * kill(oldpid,0), since the attempt is guaranteed to succeed,
415 * but the success won't actually mean that there is an
416 * another Bacula process already running.
417 * For more details see bug #797.
419 if ((oldpid != (int)getpid()) && (kill(oldpid, 0) != -1 || errno != ESRCH)) {
420 Emsg3(M_ERROR_TERM, 0, _("%s is already running. pid=%d\nCheck file %s\n"),
421 progname, oldpid, fname);
423 /* He is not alive, so take over file ownership */
424 unlink(fname); /* remove stale pid file */
426 /* Create new pid file */
427 if ((pidfd = open(fname, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, 0640)) >= 0) {
428 len = sprintf(pidbuf, "%d\n", (int)getpid());
429 write(pidfd, pidbuf, len);
431 del_pid_file_ok = TRUE; /* we created it so we can delete it */
434 Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname,
437 free_pool_memory(fname);
443 * Delete the pid file if we created it
445 int delete_pid_file(char *dir, const char *progname, int port)
447 #if !defined(HAVE_WIN32)
448 POOLMEM *fname = get_pool_memory(PM_FNAME);
450 if (!del_pid_file_ok) {
451 free_pool_memory(fname);
454 del_pid_file_ok = FALSE;
455 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
457 free_pool_memory(fname);
465 uint64_t last_jobs_addr;
466 uint64_t reserved[20];
469 static struct s_state_hdr state_hdr = {
476 * Open and read the state file for the daemon
478 void read_state_file(char *dir, const char *progname, int port)
483 POOLMEM *fname = get_pool_memory(PM_FNAME);
484 struct s_state_hdr hdr;
485 int hdr_size = sizeof(hdr);
487 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
488 /* If file exists, see what we have */
489 // Dmsg1(10, "O_BINARY=%d\n", O_BINARY);
490 if ((sfd = open(fname, O_RDONLY|O_BINARY)) < 0) {
492 Dmsg3(010, "Could not open state file. sfd=%d size=%d: ERR=%s\n",
493 sfd, sizeof(hdr), be.bstrerror());
496 if ((stat=read(sfd, &hdr, hdr_size)) != hdr_size) {
498 Dmsg4(010, "Could not read state file. sfd=%d stat=%d size=%d: ERR=%s\n",
499 sfd, (int)stat, hdr_size, be.bstrerror());
502 if (hdr.version != state_hdr.version) {
503 Dmsg2(010, "Bad hdr version. Wanted %d got %d\n",
504 state_hdr.version, hdr.version);
508 if (strcmp(hdr.id, state_hdr.id) != 0) {
509 Dmsg0(000, "State file header id invalid.\n");
512 // Dmsg1(010, "Read header of %d bytes.\n", sizeof(hdr));
513 if (!read_last_jobs_list(sfd, hdr.last_jobs_addr)) {
524 free_pool_memory(fname);
528 * Write the state file
530 void write_state_file(char *dir, const char *progname, int port)
534 POOLMEM *fname = get_pool_memory(PM_FNAME);
536 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
537 /* Create new state file */
539 if ((sfd = open(fname, O_CREAT|O_WRONLY|O_BINARY, 0640)) < 0) {
541 Dmsg2(000, "Could not create state file. %s ERR=%s\n", fname, be.bstrerror());
542 Emsg2(M_ERROR, 0, _("Could not create state file. %s ERR=%s\n"), fname, be.bstrerror());
545 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
547 Dmsg1(000, "Write hdr error: ERR=%s\n", be.bstrerror());
550 // Dmsg1(010, "Wrote header of %d bytes\n", sizeof(state_hdr));
551 state_hdr.last_jobs_addr = sizeof(state_hdr);
552 state_hdr.reserved[0] = write_last_jobs_list(sfd, state_hdr.last_jobs_addr);
553 // Dmsg1(010, "write last job end = %d\n", (int)state_hdr.reserved[0]);
554 if (lseek(sfd, 0, SEEK_SET) < 0) {
556 Dmsg1(000, "lseek error: ERR=%s\n", be.bstrerror());
559 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
561 Pmsg1(000, _("Write final hdr error: ERR=%s\n"), be.bstrerror());
565 // Dmsg1(010, "rewrote header = %d\n", sizeof(state_hdr));
573 free_pool_memory(fname);
577 /* BSDI does not have this. This is a *poor* simulation */
580 strtoll(const char *ptr, char **endptr, int base)
582 return (long long int)strtod(ptr, endptr);
587 * Bacula's implementation of fgets(). The difference is that it handles
588 * being interrupted by a signal (e.g. a SIGCHLD).
591 char *bfgets(char *s, int size, FILE *fd)
596 for (int i=0; i < size-1; i++) {
600 } while (ch == EOF && ferror(fd) && (errno == EINTR || errno == EAGAIN));
610 if (ch == '\r') { /* Support for Mac/Windows file format */
612 if (ch != '\n') { /* Mac (\r only) */
613 (void)ungetc(ch, fd); /* Push next character back to fd */
626 * Make a "unique" filename. It is important that if
627 * called again with the same "what" that the result
628 * will be identical. This allows us to use the file
629 * without saving its name, and re-generate the name
630 * so that it can be deleted.
632 void make_unique_filename(POOLMEM **name, int Id, char *what)
634 Mmsg(name, "%s/%s.%s.%d.tmp", working_directory, my_name, what, Id);
637 char *escape_filename(const char *file_path)
639 if (file_path == NULL || strpbrk(file_path, "\"\\") == NULL) {
643 char *escaped_path = (char *)bmalloc(2 * (strlen(file_path) + 1));
644 char *cur_char = escaped_path;
647 if (*file_path == '\\' || *file_path == '"') {
651 *cur_char++ = *file_path++;